cvs removed it all. Not much use having it around anymore.

2002-11-20  Not Zed  <NotZed@Ximian.com>

        * libibex/*: cvs removed it all.  Not much use having it around
        anymore.

svn path=/trunk/; revision=18854

19 files changed, 0 insertions, 6733 deletions

diff --git a/libibex/.cvsignore b/libibex/.cvsignore
deleted file mode 100644
index b0d27ba734..0000000000
--- a/libibex/.cvsignore
+++ /dev/null
@@ -1,9 +0,0 @@
-.deps
-Makefile
-Makefile.in
-.libs
-.deps
-*.lo
-*.la
-testindex
-dumpindex
diff --git a/libibex/COPYING.LIB b/libibex/COPYING.LIB
deleted file mode 100644
index eb685a5ec9..0000000000
--- a/libibex/COPYING.LIB
+++ /dev/null
@@ -1,481 +0,0 @@
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
-                    675 Mass Ave, Cambridge, MA 02139, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the library GPL.  It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    c) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    d) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-     Appendix: How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free
-    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
diff --git a/libibex/ChangeLog b/libibex/ChangeLog
deleted file mode 100644
index 3c12acd3c3..0000000000
--- a/libibex/ChangeLog
+++ /dev/null
@@ -1,544 +0,0 @@
-2002-01-27  Ettore Perazzoli  <ettore@ximian.com>
-
-	* Makefile.am: Use LIBIBEX_{CFLAGS,LIBS}.
-
-2001-11-01    <NotZed@Ximian.com>
-
-	* ibex_block.c (ibex_open): Change to use pthread_mutex directly.
-	(ibex_close): Same.
-
-	* ibex_internal.h: Changed to use pthread mutexes.  Fixes #14218.
-
-2001-10-31    <NotZed@Ximian.com>
-
-	* ibex_internal.h (IBEX_TRYLOCK): Added a trylock, used by ibex_use.
-
-	* ibex_block.c (ibex_use): Do to a trylock on the ibex we're
-	checking to close, as it might be locked elsewhere in an obivously
-	simple deadlock.
-
-2001-10-30    <NotZed@Ximian.com>
-
-	* ibex_internal.h (IBEX_OPEN_THRESHOLD): Bump this to 15, 5 seems
-	a little small.  Its still settable using an environmental
-	variable though, hopefully with other fd optimisations this will
-	not be an excessive number.
-
-	* ibex_block.c (ibex_reset): If we can't open blocks, dont try to
-	deref it.
-	(ibex_move): Dont try to rename if we have no file to rename.
-	Change all callers to ibex_use to call it inside the lock.
-	Otherwise it could change while we're trying to use it ...
-	(ibex_use): Dont lock ib here, always assume we have it locked
-	already, and dont try to close it if we run across it in the list.
-
-2001-10-29    <NotZed@Ximian.com>
-
-	* ibex_block.c (ibex_move): Always rename file even if mv failed.
-
-2001-10-28    <NotZed@Ximian.com>
-
-	* ibex_block.c (ibex_move): New api entry to move an ibex file in
-	an atomic way.
-
-2001-10-12    <NotZed@Ximian.com>
-
-	* ibex_block.c (ibex_use): Added environmental variable
-	IBEX_OPEN_THRESHOLD which limits the maximum number of open ibex's
-	that can be active at any time.  The smallest this can be set to
-	is the default of 5.
-
-2001-09-20    <NotZed@Ximian.com>
-
-	* ibex_block.c: Turn off the o(x) debug set, & include alloca.h &
-	config.h.
-
-2001-09-17    <NotZed@Ximian.com>
-
-	* disktail.c (tail_space): Fix the tail space calculation, it
-	didn't always take into account the space used by a new tail node
-	(i think).
-	(tail_info): Add a failback assertion that end >= start.  Fix all
-	callers (needed to add blocks argument).
-
-2001-08-16  Not Zed  <NotZed@Ximian.com>
-
-	* dumpindex.c (main): Force open of internal data before using it.
-
-	* ibex_block.c (ibex_use): Use a next pointer so we keep the list
-	intact as we scan it.
-
-2001-08-15  Not Zed  <NotZed@Ximian.com>
-
-	* ibex_block.c (ibex_use): New function to limit use of fd's.
-	Mark an ibex file in use, re-open if necessary, and close off
-	another (lru) if necessary.
-	(ibex_unuse): Mark an ibex as not in use.
-	(ibex_open): Delay opening of the actual block file till later,
-	and add the ibex to a global list.
-	(ibex_save): Use/unuse around operations.
-	(close_backend): Zero out blocks when closed.
-	(ibex_close): Remove the ibex from the global list before closing
-	it down.
-	(ibex_index_buffer, ibex_find, ibex_unindex, ibex_find_name):
-	Use/unuse around ops.
-
-2001-08-10  Not Zed  <NotZed@Ximian.com>
-
-	* wordindexmem.c (sync_cache_entry): NOOP if writing to a failed
-	file.
-	(word_index_pre): NOOP if failed file.
-	(ibex_create_word_index_mem): Setup blocks value.
-
-	** Added internal exception handling to libibex, in the case of
-	errors with on-disk data, exceptions are returned.
-
-	* block.c (ibex_block_cache_open): Detect fatal errors below us
-	and clean up appropriately.
-	(ibex_block_cache_fail): New function to handle the failure, and
-	keep track of it.
-	(ibex_block_cache_sync): Dont do anything if we've failed on this
-	file.
-
-	* disktail.c (tail_compress): Add blocks param so we can assert
-	for exceptions.
-
-	* hash.c, block.c disktail.c: g_assert->ibex_block_cache_assert
-	where dealing with external data.
-
-	* hash.c (hash_info): Add index param so we can assert for exceptions.
-
-	* ibex_block.c (ibex_index_buffer): Setjmp before calling into
-	internal routines.
-	(ibex_save): "
-	(ibex_unindex): "
-	(ibex_find): "
-	(ibex_find_name): "
-	(ibex_contains_name): "
-	(ibex_reset): Function to reset the index file if we have an
-	error, call when we have an error.
-
-	* block.h (ibex_block_cache_assert): Create assertion/exception
-	macros, and include a setjmp buffer for returning it.
-
-2001-08-09  Not Zed  <NotZed@Ximian.com>
-
-	* Makefile.am (libibex_la_SOURCES): Remove wordindex.c,
-	wordindexmem is what's used.
-
-2001-06-01  Peter Williams  <peterw@ximian.com>
-
-	* Makefile.am (dumpindex_LDADD): Add GAL_LIBS here too.
-	(testindex_LDADD): And here.
-
-2001-04-25  Dan Winship  <danw@ximian.com>
-
-	* Makefile.am (libibex_la_LIBADD): Add GAL_LIBS for gunicode stuff
-	(until glib 2.0)
-	(INCLUDES): Use EXTRA_GNOME_CFLAGS
-	(dumpindex_LDADD, testindex_LDADD): fix
-	Remove references to mkindex and lookup.
-
-	* ibex_block.c (ibex_normalise_word, utf8_category): Convert to
-	gunicode interfaces
-
-	* ibex_db.c, lookup.c, mkindex.c: Unused, remove.
-
-2001-03-26  Kjartan Maraas  <kmaraas@gnome.org>
-
-	* disktail.c: Header shuffling. Move glibc headers before
-	gnome stuff.
-	* testindex.c: Same here.
-	* wordindexmem.c: Added <string.h> and <stdlib.h> to quench
-	warnings from newer gcc.
-	
-2000-12-24  Not Zed  <NotZed@HelixCode.com>
-
-	* Merge from camel-mt-branch.
-
-2000-12-18  Not Zed  <NotZed@HelixCode.com>
-
-	* dumpindex.c (main): Same here.
-
-	* testindex.c (main): Add a g_thread_init().  Sigh, glib's thread
-	stuff is snot.
-	(read_words): Setup another flat-out thread to test
-	multithreadedness at little bit.
-
-	* ibex_block.c (ibex_index_buffer): Add locking around internal
-	calls.
-	(ibex_open): Init the locking mutex.
-	(ibex_close): Free the locking mutex.
-	(ibex_unindex): 
-	(ibex_find): 
-	(ibex_find_name): 
-	(ibex_contains_name): Add locking around internal calls.
-
-	* ibex_internal.h (struct ibex): Add a lock.  Include config.h
-
-2000-12-13  Christopher James Lahey  <clahey@helixcode.com>
-
-	* disktail.c (tail_compress):
-	(tail_get): Added some casts to get rid of warnings.
-	(tail_dump): #if 0ed this out to get rid of a warning.
-	(ibex_diskarray_dump): Added a prototype.
-
-	* ibex_block.c (ibex_index_buffer): Assigned cat the value 0 to
-	start off with to avoid a warning.
-
-2000-12-12  Christopher James Lahey  <clahey@helixcode.com>
-
-	* wordindex.c (cache_sanity): Made cache_sanity only be included
-	if d(x) is defined as x.
-
-	* wordindexmem.c: Made node_sanity and cache_sanity only be
-	included if d(x) is defined as x or if MALLOC_CHECK is defined.
-	Made sync_value only be included if d(x) is defined as x.
-
-2000-11-28  Not Zed  <NotZed@HelixCode.com>
-
-	* index.h: Turn off index stats by default.
-
-	* ibex_block.c (ibex_save): And here.
-	(ibex_close): Debug out printfs.
-
-	* wordindexmem.c (ibex_create_word_index_mem): And here.
-	(num): Made buf static.
-
-	* block.c (ibex_block_cache_open): Debug out some printfs.
-	(ibex_block_read): And here.
-
-2000-11-17  Not Zed  <NotZed@HelixCode.com>
-
-	* wordindexmem.c (add_list): If we have the namecache active, and
-	there is no name there, we add it directly and dont look it up
-	first.
-
-	* testindex.c: Some performance testing & stat gathering stuff.
-
-2000-11-16  Not Zed  <NotZed@HelixCode.com>
-
-	* wordindexmem.c (ibex_create_word_index_mem): Initialise nameinit
-	& namecache.
-	(contains_name): On first call, load all names into memory.  We
-	usually do a whole lot of lookups in a row, and this saves a lot
-	of penalties on a big list, for not too much a memory hit.
-	(find_name): If we have the namelist in memory do a quick
-	short-circuit check to see if we have to do further processing.
-	(unindex_name): Cross check the namecache, if it is active.
-	Remove it there too/or exit (no work to do).
-	(word_flush): If we have the namecache active, destroy it now, as
-	it is not needed anymore (for now).
-
-2000-10-30  Kjartan Maraas  <kmaraas@gnome.org>
-
-	* hash.c: #include <stdlib.h> to remove warning.
-	* wordindex.c: #include <stdlib.h> and <string.h>.
-	
-2000-10-26  Not Zed  <NotZed@HelixCode.com>
-
-	* block.c (ibex_block_cache_open): Use IBEX_VERSION rather than
-	hardcoded version string.
-
-	* ibex_internal.h (IBEX_VERSION): Bumped version again.  This time
-	I did change the index format.
-	(IBEX_VERSION): moved into block.h
-
-	* hash.c (struct _hashroot): Add a linked list of keys to the table.
-	(struct _hashblock): Added a next pointer as a block number.
-	(hash_insert): Link new key blocks into the key block list.
-	(struct _HASHCursor): Renamed block to key and added a block item.
-	(hash_cursor_next): Changed to go through the linked list of all
-	hash items rather than through each hash chain separately.  >>
-	faster.
-	(ibex_hash_dump_rec): Remove a warning.
-
-2000-10-25    <jpr@helixcode.com>
-
-	* ibex_block.c: No longer include <db.h>
-
-2000-10-25  Not Zed  <NotZed@HelixCode.com>
-
-	* ibex_internal.h (IBEX_VERSION): Bumped to another version.  The
-	file format hasn't changed, but earlier bugs may create invalid
-	files.
-
-	* block.c (ibex_block_read): Use the root data directly.
-	(ibex_block_cache_open): As well.
-	(ibex_block_get): And here too.
-	(ibex_block_cache_sync): Sync the root block directly here.
-
-	* block.h: Pad root block out to 1024 bytes.
-	Added root block to struct _memcache.
-
-	* disktail.c (tail_get): Dirty the root block.
-	(tail_get): Fix for changes to root access.
-	(disk_remove): And here too.
-
-	* wordindexmem.c (sync_cache_entry): Handle the case of not having
-	any files in the list, which can happen now.
-	(word_index_pre): Make sure we set the wordid on the new cache
-	entry.
-
-	* ibex_block.c (ibex_save): Sigh.  Pass the right argument to
-	index_post.
-
-2000-10-24  JP Rosevear  <jpr@helixcode.com>
-
-	* .cvsignore: Shush
-
-2000-10-24  Not Zed  <NotZed@HelixCode.com>
-
-	* block.c (ibex_block_cache_open): Create a word_index_mem for
-	indexing the words, rather than a word_index.
-
-	* ibex_block.c (ibex_index_buffer): If we haven't called index_pre
-	yet, do it before indexing anything.
-	(ibex_save): If wehave called index_pre previously, call
-	index_post.
-	(ibex_close): And same for here.
-
-	* index.h: Added a cursor class, and cursor retrieval function for
-	iterating through an index's keys.
-
-	* wordindexmem.c (ibex_create_word_index_mem): New word class,
-	similar to wordindex, but meant to be faster for updates.
-	(word_index_pre): Implement.  We load all keys into memory.
-	(word_index_post): Implement.  We sync and free all keys.
-	(find): Remove lru code, its no longer a cache, but a lookup
-	table.
-	(add_index_cache): Remove lru code here too.
-	(find_name): And here.
-	(word_flush): Flush the hashtable direct.
-	(word_close): Call flush to flush, rather than doing it ourselves.
-	(add_index_cache): If we are in an index state, we can assume a
-	cache miss == a new word.
-	(word_index_post): Maintain whether or not we are in an index
-	state, and the depth of the state.
-	(word_index_pre): Likewise.  Dont reread the index if we have
-	already.
-	(cache_sanity): Fixed for struct changes.
-
-	* wordindex.h (IBEXWordClass): Added functions to prepare/cleanup
-	for lots of indexing.  i.e. can be used to optimise indexing speed
-	at the cost of extra memory usage during the indexing process.
-
-	* dumpindex.c: Dumps the contents of indexs.
-
-	* hash.c (ibex_hash_dump_rec): Also print the word count.
-	(hash_cursor_create): Create a new cursor for iterating through a
-	hashtable.
-	(hash_cursor_close): 'close' the cursor. It is upto the
-	application to close any cursors it creates.
-	(hash_cursor_next): Goto the next key id.
-	(hash_cursor_next_key): Goto the next key, reutrn the key.
-	(hash_get_cursor): Return a cursor object.
-
-	* wordindex.c (unindex_name): Cross-check the cache as well.
-	(word_index_post): 
-	(word_index_pre): Added (empty) callbacks for pre/post functions.
-
-2000-10-12  Not Zed  <NotZed@HelixCode.com>
-
-	* ibex_internal.h (struct ibex): Bumped ibex rev.
-
-	* block.c (ibex_block_cache_open): Bumped the ibex file revision
-	because of the hash table size change.
-
-	* index.h: Added some stat stuff.
-
-	* wordindex.c (struct _wordcache): Changed files[] to be a pointer
-	to an allocated block/or an individual item.
-	(find): Fix for changes to struct.
-	(find_name):  "
-	(sync_cache_entry): "
-	(add): "
-	(add_list): "
-	(add_index_cache): Free the cache file array if it was created.
-	(word_flush): And here.
-	(word_close): And here too.
-	(ibex_create_word_index): Double the size of the hashtables.
-	(word_flush): Make sure we reset the wordcount to 0 if we remove
-	the list items.  DOH.
-	(add_index_cache): Use a slightly more sohpisticated aging
-	algorithm to remove expired nodes.
-
-2000-10-10  Not Zed  <NotZed@HelixCode.com>
-
-	* hash.c (hash_find):
-	(hash_remove): 
-	(hash_insert):  Truncate key if it is too big to fit in a
-	single block to MAX_KEYLEN bytes.
-
-2000-09-28  Not Zed  <NotZed@HelixCode.com>
-
-	* block.c (ibex_block_free): Make sure we map the 'free' block to
-	a block number when unlinking a block (fixes a lot of assertion
-	failures).
-	(ibex_block_cache_open): Initialise sync flag on root block.  If
-	it is not set on open then the index could be in an invalid state,
-	and should be rescanned.
-	(ibex_block_cache_sync): Sync root block last, and set the sync
-	flag.
-	(ibex_block_cache_open): Mirror root block flags in block_cache
-	struct.
-	(ibex_block_cache_sync): Likewise.
-	(ibex_block_read): If we write a dirty block, then we clear the
-	sync flag if its still set; we are no longer synced.
-
-2000-09-19  Not Zed  <NotZed@HelixCode.com>
-
-	** Merged from IBEX_DISK branch to head.
-	
-	* file.c:
-	* find.c:
-	* words.c:
-	* index.c: Removed unused files.
-
-	* block.h: Changed block to use only 24 bits for next and 8 for
-	used, and fixed all relevant code.  Some cleanup.
-	
-	* disktail.c (tail_get): If we use an empty tail node, then make
-	sure we make it dirty.
-
-2000-09-15  Not Zed  <NotZed@HelixCode.com>
-
-	* wordindex.c (word_close): Free hashtable on exit too.
-
-	* disktail.c: Implemented tail-node storage for the end of long
-	lists, or for short lists.  Should save significant disk space
-	(5x?).
-	Implemented special case for 1-item lists, where the tailnode
-	pointer is used to store the index entry.
-
-2000-09-14  Not Zed  <NotZed@HelixCode.com>
-
-	* wordindex.c (add_index_key): Keys also handle tails.
-
-	* hash.c (hash_set_data_block): Added new parameter to keys - a
-	tail block (a full 32 bit block pointer).
-	(hash_get_data_block): And same here.
-
-2000-09-12  Not Zed  <NotZed@HelixCode.com>
-
-	* wordindex.c (word_close): Dont close namestore twice.
-
-2000-09-11  Not Zed  <NotZed@HelixCode.com>
-
-	** Redid almost everything, on-disk hash table to store an index
-	to index records, mroe on the way to modularisation (more to go),
-	now stores reverse indexes for deleting.
-
-2000-08-31  Not Zed  <NotZed@HelixCode.com>
-
-	* block.c (add_key_mem): Initialise a memory based array for newly
-	added index entries.
-	(add_record): Changed to cache updates in memory until we hit a
-	limit, and then flush them to disk.
-	(get_record): Merge in-memory records with disk records.
-	(remove_record): Remove from memory first, and if that fails, goto
-	disk.
-	(find_record): Check memory first, then disk if that fails.
-	(add_datum_list): oops, copy size * sizeof(blockid_t)
-	(add_indexed): Make sure we link in the head node when we create a
-	new one.
-
-2000-08-09  Christopher James Lahey  <clahey@helixcode.com>
-
-	* file.c, find.c: Fixed some warnings.
-
-2000-05-11  NotZed  <NotZed@HelixCode.com>
-
-	* index.c (ibex_unindex): Make sure we mark the ibex as dirty.
-
-2000-05-07  NotZed  <NotZed@HelixCode.com>
-
-	* file.c (ibex_save): New function, only write out the ibex if it
-	has changed.
-
-2000-05-07    <notzed@helixcode.com>
-
-	* file.c (ibex_open): Also close the fd after we're done.
-
-	* find.c (ibex_contains_name): New function to find out if a file
-	is indexed.
-
-2000-05-02  Matt Loper  <matt@helixcode.com>
-
-	* Makefile.am: set G_LOG_DOMAIN.
-
-2000-04-12  NotZed  <NotZed@HelixCode.com>
-
-	* find.c (ibex_dump_all): Debug function to dump the whole index
-	to stdout.
-
-	* words.c (get_ibex_file): Use g_strdup(), not strdup().
-
-2000-04-11  NotZed  <NotZed@HelixCode.com>
-
-	* file.c (write_word): Always write out all words we have (even if
-	its 0 ... the file expects it).  No longer check for removed files.	
-	(store_word): Check for removed files here, and only add to the
-	ordered tree if we have references left to this word.
-	(ibex_write): First insert into the tree, to determine the
-	wordcount to be saved in the output file, and then write that.
-	(ibex_open): Remove some debug.
-
-	* words.c (ibex_index_buffer): Always set 'unread', if it is a
-	valid pointer (dont rely on caller to initialise it).
-
-2000-03-26  NotZed  <NotZed@HelixCode.com>
-
-	* lookup.c (main): Fixed call to ibex_open.
-
-	* mkindex.c (main): Fixed call to ibex_open.
-
-	* file.c (ibex_open): Changed to accept flags and mode equivalent
-	to open(2).
-
-2000-02-25  Dan Winship  <danw@helixcode.com>
-
-	* *.c: add gtk-doc-style comments
-
-2000-02-21  Matt Loper  <matt@helixcode.com>
-
-	* .cvsignore: Added mkindex.
-
-2000-02-21  NotZed  <NotZed@HelixCode.com>
-
-	* Makefile.am: change noinst_LIBRARIES to noinst_LTLIBRARIES, and
-	supply -static to LDFLAGS.  Duh, and changed LDADD back to
-	libibex.la.
-
-2000-02-20  Matt Loper  <matt@helixcode.com>
-
-	* Makefile.am: changed mkindex_LDADD to libibex.a instead of
-	libibex.la.
-
-2000-02-19  Matt Loper  <matt@helixcode.com>
-
-	* .cvsignore: added lookup.
-
-2000-02-18  Miguel de Icaza  <miguel@nuclecu.unam.mx>
-
-	* Makefile.am (lookup_LDADD): For now. make a libibex.a library so
-	we can link it with the camel provider.  I hate libtool
-
-2000-02-16  Dan Winship  <danw@helixcode.com>
-
-	* Makefile.am: automakify
-
-2000-02-16  NotZed  <NotZed@HelixCode.com>
-
-	* find.[ch] (ibex_find_name): Finds if a word is indexed under a
-	given name.
-
-2000-02-14  NotZed  <notzed@zedzone.helixcode.com>
-
-	* Makefile: Hack together a build using libtool.  This should all
-	be auto*'d at some point I guess.
-
-2000-02-13  NotZed  <notzed@zedzone.helixcode.com>
-
-	* Added ChangeLog file.
-
diff --git a/libibex/Makefile.am b/libibex/Makefile.am
deleted file mode 100644
index 77fb172071..0000000000
--- a/libibex/Makefile.am
+++ /dev/null
@@ -1,33 +0,0 @@
-## Process this file with automake to produce Makefile.in
-
-noinst_LTLIBRARIES = libibex.la
-
-libibex_la_SOURCES = \
-	wordindexmem.c \
-	block.c ibex.h \
-	hash.c \
-	disktail.c \
-	ibex_block.c
-
-libibex_la_LDFLAGS = -static
-
-libibex_la_LIBADD = \
-	$(LIBIBEX_LIBS)
-
-noinst_HEADERS = \
-	ibex_internal.h \
-	block.h \
-	wordindex.h \
-	index.h
-
-INCLUDES = \
-	$(LIBIBEX_CFLAGS) \
-	-DG_LOG_DOMAIN=\"libibex\"
-
-noinst_PROGRAMS = dumpindex testindex
-
-dumpindex_SOURCES = dumpindex.c
-dumpindex_LDADD = libibex.la $(LIBIBEX_LIBS)
-
-testindex_SOURCES = testindex.c
-testindex_LDADD = libibex.la $(LIBIBEX_LIBS) -lm
diff --git a/libibex/TODO b/libibex/TODO
deleted file mode 100644
index a087c8d1f3..0000000000
--- a/libibex/TODO
+++ /dev/null
@@ -1,61 +0,0 @@
-Stability
----------
-* ibex_open should never crash, and should never return NULL without
-errno being set. Should check for errors when reading.
-
-
-Performance
------------
-* Profiling, keep thinking about data structures, etc.
-
-* Check memory usage
-
-* See if writing the "inverse image" of long ref streams helps
-compression without hurting performance now. (ie, if a word appears in
-more than half of the files, write out the list of files it _doesn't_
-appear in). (I tried this before, and it wasn't working well, but the
-file format and data structures have changed a lot.)
-
-* We could save a noticeable chunk of time if normalize_word computed
-the hash of the word and then we could pass that into
-g_hash_table_insert somehow.
-
-* Make a copy of the buffer to be indexed (or provide interface for
-caller to say ibex can munge the provided data) and then use that
-rather than constantly copying things. ?
-
-
-Functionality
--------------
-* ibex file locking
-
-* specify file mode in ibex_open
-
-* ibex_find* need to normalize the search words... should this be done
-by the caller or by ibex_find?
-
-* Needs to be some way to do a secondary search after getting results
-back from ibex_find* (ie, for "foo near bar"). This either has to be
-done by ibex, or requires us to export the normalize interface.
-
-* Does there need to be an ibex_find_any, or is that easy enough for the
-caller to do?
-
-* utf8_trans needs to cover at least two more code pages. This is
-tricky because it's not clear whether some of the letters there should
-be translated to ASCII or left as UTF8. This requires some
-investigation.
-
-* ibex_index_* need to ignore HTML tags.
-  NAME = [A-Za-z][A-Za-z0-9.-]*
-  </?{NAME}(\s*{NAME}(\s*=\s*({NAME}|"[^"]*"|'[^']*')))*>
-  <!(--([^-]*|-[^-])--\s*)*>
-
-  ugh. ok, simplifying, we get:
-  <[^!](([^"'>]*("[^"]*"|'[^']*'))*> or
-  <!(--([^-]*|-[^-])--\s*)*>
-
-  which is still not simple. sigh.
-
-* ibex_index_* need to recognize and ignore "non-text". Particularly
-BinHex and uuencoding.
diff --git a/libibex/block.c b/libibex/block.c
deleted file mode 100644
index 3d6f908c72..0000000000
--- a/libibex/block.c
+++ /dev/null
@@ -1,620 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
- *
- * Copyright (C) 2000 Ximian, Inc.
- *
- * Authors: Michael Zucchi <notzed@ximian.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/*
-  block file/cache/utility functions
-*/
-
-#include <stdio.h>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <errno.h>
-#include <string.h>
-#include <glib.h>
-
-#include "block.h"
-
-/*#define MALLOC_CHECK*/
-
-#ifdef MALLOC_CHECK
-#include <mcheck.h>
-#endif
-
-#define d(x)
-/*#define DEBUG*/
-
-int block_log;
-
-#ifdef IBEX_STATS
-static void
-init_stats(struct _memcache *index)
-{
-	index->stats = g_hash_table_new(g_direct_hash, g_direct_equal);
-}
-
-static void
-dump_1_stat(int id, struct _stat_info *info, struct _memcache *index)
-{
-	printf("%d %d %d %d %d\n", id, info->read, info->write, info->cache_hit, info->cache_miss);
-}
-
-static void
-dump_stats(struct _memcache *index)
-{
-	printf("Block reads writes hits misses\n");
-	g_hash_table_foreach(index->stats, dump_1_stat, index);
-}
-
-static void
-add_read(struct _memcache *index, int id)
-{
-	struct _stat_info *info;
-
-	info = g_hash_table_lookup(index->stats, (void *)id);
-	if (info == NULL) {
-		info = g_malloc0(sizeof(*info));
-		g_hash_table_insert(index->stats, (void *)id, info);
-	}
-	info->read++;
-}
-
-static void
-add_write(struct _memcache *index, int id)
-{
-	struct _stat_info *info;
-
-	info = g_hash_table_lookup(index->stats, (void *)id);
-	if (info == NULL) {
-		info = g_malloc0(sizeof(*info));
-		g_hash_table_insert(index->stats, (void *)id, info);
-	}
-	info->write++;
-}
-
-static void
-add_hit(struct _memcache *index, int id)
-{
-	struct _stat_info *info;
-
-	info = g_hash_table_lookup(index->stats, (void *)id);
-	if (info == NULL) {
-		info = g_malloc0(sizeof(*info));
-		g_hash_table_insert(index->stats, (void *)id, info);
-	}
-	info->cache_hit++;
-}
-
-static void
-add_miss(struct _memcache *index, int id)
-{
-	struct _stat_info *info;
-
-	info = g_hash_table_lookup(index->stats, (void *)id);
-	if (info == NULL) {
-		info = g_malloc0(sizeof(*info));
-		g_hash_table_insert(index->stats, (void *)id, info);
-	}
-	info->cache_miss++;
-}
-#endif /* IBEX_STATS */
-
-#ifdef MALLOC_CHECK
-static void
-checkmem(void *p)
-{
-	if (p) {
-		int status = mprobe(p);
-
-		switch (status) {
-		case MCHECK_HEAD:
-			printf("Memory underrun at %p\n", p);
-			abort();
-		case MCHECK_TAIL:
-			printf("Memory overrun at %p\n", p);
-			abort();
-		case MCHECK_FREE:
-			printf("Double free %p\n", p);
-			abort();
-		}
-	}
-}
-#endif
-
-/* simple list routines (for simplified memory management of cache/lists) */
-
-/**
- * ibex_list_new:
- * @v: 
- * 
- * Initialise a list header.  A list header must always be initialised
- * before use.
- **/
-void ibex_list_new(struct _list *v)
-{
-	v->head = (struct _listnode *)&v->tail;
-	v->tail = 0;
-	v->tailpred = (struct _listnode *)&v->head;
-}
-
-/**
- * ibex_list_addhead:
- * @l: List.
- * @n: Node to append.
- * 
- * Prepend a listnode to the head of the list @l.
- * 
- * Return value: Always @n.
- **/
-struct _listnode *ibex_list_addhead(struct _list *l, struct _listnode *n)
-{
-	n->next = l->head;
-	n->prev = (struct _listnode *)&l->head;
-	l->head->prev = n;
-	l->head = n;
-	return n;
-}
-
-/**
- * ibex_list_addtail:
- * @l: 
- * @n: 
- * 
- * Append a listnode to the end of the list @l.
- * 
- * Return value: Always the same as @n.
- **/
-struct _listnode *ibex_list_addtail(struct _list *l, struct _listnode *n)
-{
-	n->next = (struct _listnode *)&l->tail;
-	n->prev = l->tailpred;
-	l->tailpred->next = n;
-	l->tailpred = n;
-	return n;
-}
-
-/**
- * ibex_list_remove:
- * @n: The node to remove.
- * 
- * Remove a listnode from a list.
- * 
- * Return value: Always the same as @n.
- **/
-struct _listnode *ibex_list_remove(struct _listnode *n)
-{
-	n->next->prev = n->prev;
-	n->prev->next = n->next;
-	return n;
-}
-
-static struct _memblock *
-memblock_addr(struct _block *block)
-{
-	return (struct _memblock *)(((char *)block) - G_STRUCT_OFFSET(struct _memblock, data));
-}
-
-/* read/sync the rootblock into the block_cache structure */
-static int
-ibex_block_read_root(struct _memcache *block_cache)
-{
-	lseek(block_cache->fd, 0, SEEK_SET);
-	if (read(block_cache->fd, &block_cache->root, sizeof(block_cache->root)) != sizeof(block_cache->root)) {
-		
-		return -1;
-	}
-	return 0;
-}
-
-static int
-ibex_block_sync_root(struct _memcache *block_cache)
-{
-	lseek(block_cache->fd, 0, SEEK_SET);
-	if (write(block_cache->fd, &block_cache->root, sizeof(block_cache->root)) != sizeof(block_cache->root)) {
-		return -1;
-	}
-	return fsync(block_cache->fd);
-}
-
-
-/**
- * ibex_block_dirty:
- * @block: 
- * 
- * Dirty a block.  This will cause it to be written to disk on
- * a cache sync, or when the block is flushed from the cache.
- **/
-void
-ibex_block_dirty(struct _block *block)
-{
-	memblock_addr(block)->flags |= BLOCK_DIRTY;
-}
-
-static void
-sync_block(struct _memcache *block_cache, struct _memblock *memblock)
-{
-	if (block_log)
-		printf("writing block %d\n", memblock->block);
-
-	lseek(block_cache->fd, memblock->block, SEEK_SET);
-	if (write(block_cache->fd, &memblock->data, sizeof(memblock->data)) != -1) {
-		memblock->flags &= ~BLOCK_DIRTY;
-	}
-#ifdef IBEX_STATS
-	add_write(block_cache, memblock->block);
-#endif
-}
-
-/**
- * ibex_block_cache_sync:
- * @block_cache: 
- * 
- * Ensure the block cache is fully synced to disk.
- **/
-void
-ibex_block_cache_sync(struct _memcache *block_cache)
-{
-	struct _memblock *memblock;
-
-	if (block_cache->failed)
-		return;
-
-	memblock = (struct _memblock *)block_cache->nodes.head;
-	while (memblock->next) {
-#ifdef MALLOC_CHECK
-		checkmem(memblock);
-#endif
-		if (memblock->flags & BLOCK_DIRTY) {
-			sync_block(block_cache, memblock);
-		}
-		memblock = memblock->next;
-	}
-
-	block_cache->root.flags |= IBEX_ROOT_SYNCF;
-	if (ibex_block_sync_root(block_cache) != 0) {
-		block_cache->root.flags &= ~IBEX_ROOT_SYNCF;
-	}
-
-#ifdef IBEX_STATS
-	dump_stats(block_cache);
-#endif
-
-}
-
-#ifdef MALLOC_CHECK
-static void
-check_cache(struct _memcache *block_cache)
-{
-	struct _memblock *mw, *mn;
-
-	checkmem(block_cache);
-	checkmem(block_cache->index);
-
-	mw = (struct _memblock *)block_cache->nodes.head;
-	mn = mw->next;
-	while (mn) {
-		checkmem(mw);
-		mw = mn;
-		mn = mn->next;
-	}
-}
-#endif
-
-/**
- * ibex_block_cache_flush:
- * @block_cache: 
- * 
- * Ensure the block cache is fully synced to disk, and then flush
- * its contents from memory.
- **/
-void
-ibex_block_cache_flush(struct _memcache *block_cache)
-{
-	struct _memblock *mw, *mn;
-
-	ibex_block_cache_sync(block_cache);
-
-	mw = (struct _memblock *)block_cache->nodes.head;
-	mn = mw->next;
-	while (mn) {
-		g_hash_table_remove(block_cache->index, (void *)mw->block);
-		g_free(mw);
-		mw = mn;
-		mn = mn->next;
-	}
-	ibex_list_new(&block_cache->nodes);
-}
-
-/**
- * ibex_block_read:
- * @block_cache: 
- * @blockid: 
- * 
- * Read the data of a block by blockid.  The data contents is backed by
- * the block cache, and should be considered static.
- *
- * TODO; should this return a NULL block on error?
- *
- * Return value: The address of the block data (which may be cached).
- **/
-struct _block *
-ibex_block_read(struct _memcache *block_cache, blockid_t blockid)
-{
-	struct _memblock *memblock;
-
-#ifdef MALLOC_CHECK
-	check_cache(block_cache);
-#endif
-
-	/* nothing can read the root block directly */
-	ibex_block_cache_assert(block_cache, blockid != 0);
-	ibex_block_cache_assert(block_cache, blockid < block_cache->root.roof);
-
-	memblock = g_hash_table_lookup(block_cache->index, (void *)blockid);
-
-#ifdef MALLOC_CHECK
-	check_cache(block_cache);
-#endif
-
-	if (memblock) {
-		d(printf("foudn blockid in cache %d = %p\n", blockid, &memblock->data));
-
-		/* 'access' page */
-		ibex_list_remove((struct _listnode *)memblock);
-		ibex_list_addtail(&block_cache->nodes, (struct _listnode *)memblock);
-
-#ifdef MALLOC_CHECK
-		check_cache(block_cache);
-#endif
-
-#ifdef IBEX_STATS
-		add_hit(block_cache, memblock->block);
-#endif
-
-#ifdef MALLOC_CHECK
-		check_cache(block_cache);
-#endif
-
-		return &memblock->data;
-	}
-#ifdef IBEX_STATS
-	add_miss(block_cache, blockid);
-	add_read(block_cache, blockid);
-#endif
-	if (block_log)
-		printf("miss block %d\n", blockid);
-
-	d(printf("loading blockid from disk %d\n", blockid));
-	memblock = g_malloc(sizeof(*memblock));
-	memblock->block = blockid;
-	memblock->flags = 0;
-	lseek(block_cache->fd, blockid, SEEK_SET);
-	memset(&memblock->data, 0, sizeof(memblock->data));
-	read(block_cache->fd, &memblock->data, sizeof(memblock->data));
-
-	ibex_list_addtail(&block_cache->nodes, (struct _listnode *)memblock);
-	g_hash_table_insert(block_cache->index, (void *)blockid, memblock);
-	if (block_cache->count >= CACHE_SIZE) {
-		struct _memblock *old = (struct _memblock *)block_cache->nodes.head;
-		d(printf("discaring cache block %d\n", old->block));
-		g_hash_table_remove(block_cache->index, (void *)old->block);
-		ibex_list_remove((struct _listnode *)old);
-		if (old->flags & BLOCK_DIRTY) {
-			/* are we about to un-sync the file?  update root and sync it */
-			if (block_cache->root.flags & IBEX_ROOT_SYNCF) {
-				d(printf("Unsyncing root block\n"));
-
-				block_cache->root.flags &= ~IBEX_ROOT_SYNCF;
-				if (ibex_block_sync_root(block_cache) != 0) {
-					/* what do we do?  i dont know! */
-					g_warning("Could not sync root block of index: %s", strerror(errno));
-				}
-			}
-			sync_block(block_cache, old);
-		}
-		g_free(old);
-	} else {
-		block_cache->count++;
-	}
-
-	d(printf("  --- cached blocks : %d\n", block_cache->count));
-
-#ifdef MALLOC_CHECK
-	check_cache(block_cache);
-#endif
-	return &memblock->data;
-}
-
-void
-ibex_block_cache_fail(struct _memcache *block_cache, char *where, int line, char *why)
-{
-	block_cache->failed = TRUE;
-	block_cache->root.flags &= ~IBEX_ROOT_SYNCF;
-	/* and blow it away, we can do nothing better yet */
-	ftruncate(block_cache->fd, 0);
-
-	g_warning("%s(%d): Integrity assertion failed: '%s' on file '%s'", where, line, why, block_cache->name);
-
-	longjmp(block_cache->failenv, 1);
-}
-
-/**
- * ibex_block_cache_open:
- * @name: 
- * @flags: Flags as to open(2), should use O_RDWR and optionally O_CREAT.
- * @mode: Mose as to open(2)
- * 
- * Open a block file.
- * 
- * FIXME; this currently also initialises the word and name indexes
- * because their pointers are stored in the root block.  Should be
- * upto the caller to manage these pointers/data.
- *
- * Return value: NULL if the backing file could not be opened.
- **/
-struct _memcache *
-ibex_block_cache_open(const char *name, int flags, int mode)
-{
-	struct _memcache *block_cache = g_malloc0(sizeof(*block_cache));
-
-	d(printf("opening ibex file: %s", name));
-
-	/* setup cache */
-	ibex_list_new(&block_cache->nodes);
-	block_cache->count = 0;
-	block_cache->index = g_hash_table_new(g_direct_hash, g_direct_equal);
-	block_cache->fd = open(name, flags, mode);
-	block_cache->failed = FALSE;
-	block_cache->name = g_strdup(name);
-
-	if (block_cache->fd == -1) {
-		g_hash_table_destroy(block_cache->index);
-		g_free(block_cache);
-		return NULL;
-	}
-
-	if (ibex_block_cache_setjmp(block_cache) != 0) {
-		close(block_cache->fd);
-		g_hash_table_destroy(block_cache->index);
-		g_free(block_cache);
-		return NULL;		
-	}
-
-	ibex_block_read_root(block_cache);
-	if (block_cache->root.roof == 0
-	    || memcmp(block_cache->root.version, IBEX_VERSION, 4)
-	    || ((block_cache->root.flags & IBEX_ROOT_SYNCF) == 0)) {
-		d(printf("Initialising superblock\n"));
-		/* reset root data */
-		memcpy(block_cache->root.version, IBEX_VERSION, 4);
-		block_cache->root.roof = 1024;
-		block_cache->root.free = 0;
-		block_cache->root.words = 0;
-		block_cache->root.names = 0;
-		block_cache->root.tail = 0;	/* list of tail blocks */
-		block_cache->root.flags = 0;
-		ibex_block_sync_root(block_cache);
-		/* reset the file contents */
-		ftruncate(block_cache->fd, 1024);
-	} else {
-		d(printf("superblock already initialised:\n"
-			 " roof = %d\n free = %d\n words = %d\n names = %d\n tail = %d\n",
-			 block_cache->root.roof, block_cache->root.free,
-			 block_cache->root.words, block_cache->root.names, block_cache->root.tail));
-	}
-	/* FIXME: this should be moved higher up in the object tree */
-	{
-		struct _IBEXWord *ibex_create_word_index_mem(struct _memcache *bc, blockid_t *wordroot, blockid_t *nameroot);
-
-		block_cache->words = ibex_create_word_index_mem(block_cache, &block_cache->root.words,&block_cache->root.names);
-	}
-
-#ifdef IBEX_STATS
-	init_stats(block_cache);
-#endif
-
-	return block_cache;
-}
-
-/**
- * ibex_block_cache_close:
- * @block_cache: 
- * 
- * Close the block file, sync any remaining cached data
- * to disk, and free all resources.
- **/
-void
-ibex_block_cache_close(struct _memcache *block_cache)
-{
-	struct _memblock *mw, *mn;
-
-	ibex_block_cache_sync(block_cache);
-	close(block_cache->fd);
-	g_free(block_cache->name);
-
-	mw = (struct _memblock *)block_cache->nodes.head;
-	mn = mw->next;
-	while (mn) {
-		g_free(mw);
-		mw = mn;
-		mn = mw->next;
-	}
-
-	g_hash_table_destroy(block_cache->index);
-
-	g_free(block_cache);
-}
-
-/**
- * ibex_block_free:
- * @block_cache: 
- * @blockid: 
- * 
- * Return a block to the free pool.
- **/
-void
-ibex_block_free(struct _memcache *block_cache, blockid_t blockid)
-{
-	struct _block *block = ibex_block_read(block_cache, blockid);
-
-	block->next = block_number(block_cache->root.free);
-	block_cache->root.free = blockid;
-	ibex_block_dirty((struct _block *)block);
-}
-
-/**
- * ibex_block_get:
- * @block_cache: 
- * 
- * Allocate a new block, or access a previously freed block and return
- * its block id.  The block will have zeroed contents.
- * 
- * Return value: 0 if there are no blocks left (disk full/read only
- * file, etc).
- **/
-blockid_t
-ibex_block_get(struct _memcache *block_cache)
-{
-	struct _block *block;
-	blockid_t head;
-
-	if (block_cache->root.free) {
-		head = block_cache->root.free;
-		block = ibex_block_read(block_cache, head);
-		block_cache->root.free = block_location(block->next);
-	} else {
-		/* TODO: check the block will fit first */
-		/* TODO: no need to read this block, can allocate it manually (saves a syscall/read) */
-		head = block_cache->root.roof;
-		block_cache->root.roof += BLOCK_SIZE;
-		block = ibex_block_read(block_cache, head);
-	}
-
-	ibex_block_cache_assert(block_cache, head != 0);
-
-	d(printf("new block = %d\n", head));
-	block->next = 0;
-	block->used = 0;
-	ibex_block_dirty(block);
-	return head;
-}
diff --git a/libibex/block.h b/libibex/block.h
deleted file mode 100644
index 74221836e1..0000000000
--- a/libibex/block.h
+++ /dev/null
@@ -1,125 +0,0 @@
-
-/* public interfaces for block io routines */
-
-#ifndef _BLOCK_H
-#define _BLOCK_H
-
-/*#define IBEX_STATS*/		/* define to get/dump block access stats */
-
-#include <glib.h>
-#include <setjmp.h>
-
-/* version of file format */
-#define IBEX_VERSION "ibx6"
-
-typedef guint32 nameid_t;
-typedef guint32 blockid_t;
-
-#define BLOCK_BITS (8)
-#define BLOCK_SIZE (1<<BLOCK_BITS)
-#define CACHE_SIZE 256		/* blocks in disk cache */
-
-/* root block */
-struct _root {
-	char version[4];
-
-	blockid_t free;		/* list of free blocks */
-	blockid_t roof;		/* top of allocated space, everything below is in a free or used list */
-	blockid_t tail;		/* list of 'tail' blocks */
-
-	blockid_t words;	/* root of words index */
-	blockid_t names;	/* root of names index */
-
-	char flags;		/* state flags */
-
-	/* makes structure fill up to 1024 bytes */
-	char dummy[1024 - (sizeof(char)*5) - (sizeof(blockid_t)*5)];
-};
-
-#define IBEX_ROOT_SYNCF (1<<0)	/* file is synced */
-
-/* basic disk structure for (data) blocks */
-struct _block {
-	unsigned int next:32-BLOCK_BITS;	/* next block */
-	unsigned int used:BLOCK_BITS;		/* number of elements used */
-
-	nameid_t bl_data[(BLOCK_SIZE-4)/4];	/* references */
-};
-
-/* custom list structure, for a simple/efficient cache */
-struct _listnode {
-	struct _listnode *next;
-	struct _listnode *prev;
-};
-struct _list {
-	struct _listnode *head;
-	struct _listnode *tail;
-	struct _listnode *tailpred;
-};
-
-void ibex_list_new(struct _list *v);
-struct _listnode *ibex_list_addhead(struct _list *l, struct _listnode *n);
-struct _listnode *ibex_list_addtail(struct _list *l, struct _listnode *n);
-struct _listnode *ibex_list_remove(struct _listnode *n);
-
-/* in-memory structure for block cache */
-struct _memblock {
-	struct _memblock *next;
-	struct _memblock *prev;
-
-	blockid_t block;
-	int flags;
-
-	struct _block data;
-};
-#define BLOCK_DIRTY (1<<0)
-
-struct _memcache {
-	struct _list nodes;
-	int count;		/* nodes in cache */
-
-	GHashTable *index;	/* blockid->memblock mapping */
-
-	int fd;			/* file fd */
-	char *name;		/* file name */
-
-	jmp_buf failenv;	/* for exception failure */
-	int failed;		/* indicates the file failed */
-
-#ifdef IBEX_STATS
-	GHashTable *stats;
-#endif
-	struct _root root;	/* root block */
-
-	/* temporary here */
-	struct _IBEXWord *words; /* word index */
-};
-
-#ifdef IBEX_STATS
-struct _stat_info {
-	int read;
-	int write;
-	int cache_hit;
-	int cache_miss;
-};
-#endif /* IBEX_STATS */
-
-struct _memcache *ibex_block_cache_open(const char *name, int flags, int mode);
-void ibex_block_cache_close(struct _memcache *block_cache);
-void ibex_block_cache_sync(struct _memcache *block_cache);
-void ibex_block_cache_flush(struct _memcache *block_cache);
-
-#define ibex_block_cache_setjmp(bc) (((bc)==NULL)?1:setjmp((bc)->failenv))
-#define ibex_block_cache_assert(bc, cond) { if (!(cond)) { ibex_block_cache_fail(bc, __FILE__, __LINE__, # cond); } }
-
-void ibex_block_cache_fail(struct _memcache *block_cache, char *file, int line, char *why);
-
-blockid_t ibex_block_get(struct _memcache *block_cache);
-void ibex_block_free(struct _memcache *block_cache, blockid_t blockid);
-void ibex_block_dirty(struct _block *block);
-struct _block *ibex_block_read(struct _memcache *block_cache, blockid_t blockid);
-
-#define block_number(x) ((x)>>BLOCK_BITS)
-#define block_location(x) ((x)<<BLOCK_BITS)
-
-#endif /* ! _BLOCK_H */
diff --git a/libibex/diskarray.c b/libibex/diskarray.c
deleted file mode 100644
index 6eeec9e695..0000000000
--- a/libibex/diskarray.c
+++ /dev/null
@@ -1,254 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
- *
- * Copyright (C) 2000 Ximian, Inc.
- *
- * Authors: Michael Zucchi <notzed@ximian.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/* a disk based array storage class */
-
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <glib.h>
-
-#include "block.h"
-#include "index.h"
-
-#define d(x)
-/*#define DEBUG*/
-
-static struct _IBEXStore *disk_create(struct _memcache *bc);
-static int disk_sync(struct _IBEXStore *store);
-static int disk_close(struct _IBEXStore *store);
-
-static blockid_t disk_add(struct _IBEXStore *store, blockid_t head, nameid_t data);
-static blockid_t disk_add_list(struct _IBEXStore *store, blockid_t head, GArray *data);
-static blockid_t disk_remove(struct _IBEXStore *store, blockid_t head, nameid_t data);
-static void disk_free(struct _IBEXStore *store, blockid_t head);
-
-static gboolean disk_find(struct _IBEXStore *store, blockid_t head, nameid_t data);
-static GArray *disk_get(struct _IBEXStore *store, blockid_t head);
-
-struct _IBEXStoreClass ibex_diskarray_class = {
-	disk_create, disk_sync, disk_close,
-	disk_add, disk_add_list,
-	disk_remove, disk_free,
-	disk_find, disk_get
-};
-
-static struct _IBEXStore *disk_create(struct _memcache *bc)
-{
-	struct _IBEXStore *store;
-
-	store = g_malloc0(sizeof(*store));
-	store->klass = &ibex_diskarray_class;
-	store->blocks = bc;
-
-	return store;
-}
-
-static int disk_sync(struct _IBEXStore *store)
-{
-	/* no cache, nop */
-	return 0;
-}
-
-static int disk_close(struct _IBEXStore *store)
-{
-	g_free(store);
-	return 0;
-}
-
-static blockid_t
-disk_add(struct _IBEXStore *store, blockid_t head, nameid_t data)
-{
-	struct _block *block;
-	struct _block *newblock;
-	blockid_t new;
-
-	if (head == 0) {
-		head = ibex_block_get(store->blocks);
-	}
-	block = ibex_block_read(store->blocks, head);
-
-	d(printf("adding record %d to block %d (next = %d)\n", data, head, block->next));
-
-	if (block->used < sizeof(block->bl_data)/sizeof(block->bl_data[0])) {
-		d(printf("adding record into block %d  %d\n", head, data));
-		block->bl_data[block->used] = data;
-		block->used++;
-		ibex_block_dirty(block);
-		return head;
-	} else {
-		new = ibex_block_get(store->blocks);
-		newblock = ibex_block_read(store->blocks, new);
-		newblock->next = head;
-		newblock->bl_data[0] = data;
-		newblock->used = 1;
-		d(printf("adding record into new %d  %d, next =%d\n", new, data, newblock->next));
-		ibex_block_dirty(newblock);
-		return new;
-	}
-}
-
-static blockid_t
-disk_add_list(struct _IBEXStore *store, blockid_t head, GArray *data)
-{
-	struct _block *block;
-	struct _block *newblock;
-	blockid_t new;
-	int copied = 0;
-	int left, space, tocopy;
-
-	if (head == 0) {
-		head = ibex_block_get(store->blocks);
-	}
-	block = ibex_block_read(store->blocks, head);
-
-	while (copied < data->len) {
-		left = data->len - copied;
-		space = sizeof(block->bl_data)/sizeof(block->bl_data[0]) - block->used;
-		if (space) {
-			tocopy = MIN(left, space);
-			memcpy(block->bl_data+block->used, &g_array_index(data, blockid_t, copied), tocopy*sizeof(blockid_t));
-			block->used += tocopy;
-			ibex_block_dirty(block);
-		} else {
-			new = ibex_block_get(store->blocks);
-			newblock = ibex_block_read(store->blocks, new);
-			newblock->next = head;
-			tocopy = MIN(left, sizeof(block->bl_data)/sizeof(block->bl_data[0]));
-			memcpy(newblock->bl_data, &g_array_index(data, blockid_t, copied), tocopy*sizeof(blockid_t));
-			newblock->used = tocopy;
-			block = newblock;
-			head = new;
-			ibex_block_dirty(newblock);
-		}
-		copied += tocopy;
-	}
-	return head;
-}
-
-static blockid_t
-disk_remove(struct _IBEXStore *store, blockid_t head, nameid_t data)
-{
-	blockid_t node = head;
-
-	d(printf("removing %d from %d\n", data, head));
-	while (node) {
-		struct _block *block = ibex_block_read(store->blocks, node);
-		int i;
-
-		for (i=0;i<block->used;i++) {
-			if (block->bl_data[i] == data) {
-				struct _block *start = ibex_block_read(store->blocks, head);
-
-				start->used--;
-				block->bl_data[i] = start->bl_data[start->used];
-				if (start->used == 0) {
-					struct _root *root = (struct _root *)ibex_block_read(store->blocks, 0);
-					blockid_t new;
-
-					d(printf("dropping block %d, new head = %d\n", head, start->next));
-					new = start->next;
-					start->next = root->free;
-					root->free = head;
-					head = new;
-					ibex_block_dirty((struct _block *)root);
-				}
-				ibex_block_dirty(block);
-				ibex_block_dirty(start);
-				return head;
-			}
-		}
-		node = block->next;
-	}
-	return head;
-}
-
-static void disk_free(struct _IBEXStore *store, blockid_t head)
-{
-	blockid_t next;
-	struct _block *block;
-
-	while (head) {
-		block = ibex_block_read(store->blocks, head);
-		next = block->next;
-		ibex_block_free(store->blocks, head);
-		head = next;
-	}
-}
-
-static gboolean
-disk_find(struct _IBEXStore *store, blockid_t head, nameid_t data)
-{
-	blockid_t node = head;
-
-	d(printf("finding %d from %d\n", data, head));
-	while (node) {
-		struct _block *block = ibex_block_read(store->blocks, node);
-		int i;
-
-		for (i=0;i<block->used;i++) {
-			if (block->bl_data[i] == data) {
-				return TRUE;
-			}
-		}
-		node = block->next;
-	}
-	return FALSE;
-}
-
-static GArray *
-disk_get(struct _IBEXStore *store, blockid_t head)
-{
-	GArray *result = g_array_new(0, 0, sizeof(nameid_t));
-
-	while (head) {
-		struct _block *block = ibex_block_read(store->blocks, head);
-
-		d(printf("getting data from block %d\n", head));
-
-		g_array_append_vals(result, block->bl_data, block->used);
-		head = block->next;
-		d(printf("next = %d\n", head));
-	}
-	return result;
-}
-
-void
-ibex_diskarray_dump(struct _memcache *blocks, blockid_t head)
-{
-	blockid_t node = head;
-
-	printf("dumping list %d\n", node);
-	while (node) {
-		struct _block *block = ibex_block_read(blocks, node);
-		int i;
-
-		printf(" block %d used %d\n ", node, block->used);
-		for (i=0;i<block->used;i++) {
-			printf(" %d", block->bl_data[i]);
-		}
-		printf("\n");
-		node = block->next;
-	}
-}
diff --git a/libibex/disktail.c b/libibex/disktail.c
deleted file mode 100644
index 7d3abd10d8..0000000000
--- a/libibex/disktail.c
+++ /dev/null
@@ -1,819 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
- *
- * Copyright (C) 2000 Ximian, Inc.
- *
- * Authors: Michael Zucchi <notzed@ximian.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/* a disk based array storage class that stores the tails of data lists
-   in common blocks */
-
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <stdio.h>
-
-#include <glib.h>
-
-#include "block.h"
-#include "index.h"
-
-#define d(x)
-/*#define DEBUG*/
-
-/* marker to define which root keys indicate a single length key */
-#define BLOCK_ONE (1<<BLOCK_BITS)
-
-/* tail blocks only contain tail data ... */
-/* and we pack it in, similar to the key data, only more compact */
-struct _tailblock {
-	unsigned int next:32-BLOCK_BITS; /* only needs to point to block numbers */
-	unsigned int used:BLOCK_BITS; /* how many entries are used */
-	union {
-		unsigned char offset[BLOCK_SIZE-4]; /* works upto blocksize of 1024 bytes */
-		nameid_t data[(BLOCK_SIZE-4)/4];
-	} tailblock_u;
-};
-#define tb_offset tailblock_u.offset
-#define tb_data tailblock_u.data
-
-/* map a tail index to a block index */
-#define TAIL_INDEX(b) ((b) & (BLOCK_SIZE-1))
-/* map a tail index to a block number */
-#define TAIL_BLOCK(b) ((b) & ~(BLOCK_SIZE-1))
-/* map a block + index to a tailid */
-#define TAIL_KEY(b, i) (((b) & ~(BLOCK_SIZE-1)) | ((i) & (BLOCK_SIZE-1)))
-
-#define TAIL_THRESHOLD ((BLOCK_SIZE-8)/6)
-
-static struct _IBEXStore *disk_create(struct _memcache *bc);
-static int disk_sync(struct _IBEXStore *store);
-static int disk_close(struct _IBEXStore *store);
-
-static blockid_t disk_add(struct _IBEXStore *store, blockid_t *head, blockid_t *tail, nameid_t data);
-static blockid_t disk_add_list(struct _IBEXStore *store, blockid_t *head, blockid_t *tail, GArray *data);
-static blockid_t disk_remove(struct _IBEXStore *store, blockid_t *head, blockid_t *tail, nameid_t data);
-static void disk_free(struct _IBEXStore *store, blockid_t head, blockid_t tail);
-
-static gboolean disk_find(struct _IBEXStore *store, blockid_t head, blockid_t tail, nameid_t data);
-static GArray *disk_get(struct _IBEXStore *store, blockid_t head, blockid_t tail);
-
-struct _IBEXStoreClass ibex_diskarray_class = {
-	disk_create, disk_sync, disk_close,
-	disk_add, disk_add_list,
-	disk_remove, disk_free,
-	disk_find, disk_get
-};
-
-
-static int
-tail_info(struct _memcache *blocks, struct _tailblock *bucket, nameid_t tailid, blockid_t **startptr)
-{
-	blockid_t *start, *end;
-	int index;
-
-	/* get start/end of area to zap */
-	index = TAIL_INDEX(tailid);
-	start = &bucket->tb_data[bucket->tb_offset[index]];
-	if (index == 0) {
-		end = &bucket->tb_data[sizeof(bucket->tb_data)/sizeof(bucket->tb_data[0])];
-	} else {
-		end = &bucket->tb_data[bucket->tb_offset[index-1]];
-	}
-	if (startptr)
-		*startptr = start;
-
-	ibex_block_cache_assert(blocks, end >= start);
-
-	return end-start;
-}
-
-/* compresses (or expand) the bucket entry, to the new size */
-static void
-tail_compress(struct _memcache *blocks, struct _tailblock *bucket, int index, int newsize)
-{
-	int i;
-	blockid_t *start, *end, *newstart;
-
-	/* get start/end of area to zap */
-	start = &bucket->tb_data[bucket->tb_offset[index]];
-	if (index == 0) {
-		end = &bucket->tb_data[sizeof(bucket->tb_data)/sizeof(bucket->tb_data[0])];
-	} else {
-		end = &bucket->tb_data[bucket->tb_offset[index-1]];
-	}
-
-	if (end-start == newsize)
-		return;
-
-	/*
-	     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXyyyyy
-	     0                           20   25
-
-	     newsize = 0
-	     end = 25
-	     newstart = 0
-	     start = 20
-
-	     newstart+(end-start)-newsize = 5
-	     i = start-newstart
-
-	     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXyyyyy
-	     0                           20   25
-
-	     newsize = 2
-	     end = 25
-	     newstart = 0
-	     start = 20
-
-	     newstart+(end-start)-newsize = 3
-	     i = start-newstart + MIN(end-start, newsize)) = 22
-
-	     XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-	     5 	                         25
-	     newsize = 5
-	     end = 25
-	     start = 25
-	     newstart = 5
-
-	     newstart+(end-start)-newsize = 0
-	     i = start-newstart = 20
-
-	     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXyy
-	     3 	                         23 25
-	     newsize = 5
-	     end = 25
-	     start = 23
-	     newstart = 3
-
-	     newstart+(end-start)-newsize = 0
-	     i = start-newstart + MIN(end-start, newsize) = 22
-
-	*/
-
-
-	/* fixup data */
-	newstart = &bucket->tb_data[bucket->tb_offset[bucket->used-1]];
-
-	ibex_block_cache_assert(blocks, newstart+(end-start)-newsize <= &bucket->tb_data[sizeof(bucket->tb_data)/sizeof(bucket->tb_data[0])]);
-	ibex_block_cache_assert(blocks, newstart + (start-newstart) + MIN(end-start, newsize) <= &bucket->tb_data[sizeof(bucket->tb_data)/sizeof(bucket->tb_data[0])]);
-	ibex_block_cache_assert(blocks, newstart+(end-start)-newsize >= (blockid_t *) &bucket->tb_offset[bucket->used]);
-	ibex_block_cache_assert(blocks, newstart + (start-newstart) + MIN(end-start, newsize) >= (blockid_t *) &bucket->tb_offset[bucket->used]);
-
-	memmove(newstart+(end-start)-newsize, newstart, ((start-newstart)+MIN(end-start, newsize)) * sizeof(blockid_t));
-
-	/* fixup key pointers */
-	for (i=index;i<bucket->used;i++) {
-		bucket->tb_offset[i] += (end-start)-newsize;
-	}
-	ibex_block_dirty((struct _block *)bucket);
-}
-
-/*
-  returns the number of blockid's free
-*/
-static int
-tail_space(struct _tailblock *tail)
-{
-	if (tail->used == 0)
-		return sizeof(tail->tb_data)/sizeof(tail->tb_data[0])-1;
-
-	return  &tail->tb_data[tail->tb_offset[tail->used-1]]
-		- (blockid_t *)&tail->tb_offset[tail->used] - 1;
-}
-
-#if 0
-static void
-tail_dump(struct _memcache *blocks, blockid_t tailid)
-{
-	int i;
-	struct _tailblock *tail = (struct _tailblock *)ibex_block_read(blocks, TAIL_BLOCK(tailid));
-
-	printf("Block %d, used %d\n", tailid, tail->used);
-	for (i=0;i<sizeof(struct _tailblock)/sizeof(unsigned int);i++) {
-		printf(" %08x", ((unsigned int *)tail)[i]);
-	}
-	printf("\n");
-}
-#endif
-
-static blockid_t
-tail_get(struct _memcache *blocks, int size)
-{
-	blockid_t tailid;
-	struct _tailblock *tail;
-	int freeindex;
-	blockid_t *end;
-	int i, count = 0;
-
-	d(printf("looking for a tail node with %d items in it\n", size));
-
-	/* look for a node with enough space, if we dont find it fairly
-	   quickly, just quit.  needs a better free algorithm i think ... */
-	tailid = blocks->root.tail;
-	while (tailid && count<5) {
-		int space;
-
-		d(printf(" checking tail node %d\n", tailid));
-
-		tail = (struct _tailblock *)ibex_block_read(blocks, tailid);
-
-		if (tail->used == 0) {
-			/* assume its big enough ... */
-			tail->used = 1;
-			tail->tb_offset[0] = sizeof(tail->tb_data)/sizeof(tail->tb_data[0]) - size;
-			d(printf("allocated %d (%d), used %d\n", tailid, tailid, tail->used));
-			ibex_block_dirty((struct _block *)tail);
-
-			ibex_block_cache_assert(blocks, &tail->tb_offset[tail->used-1]
-						< (unsigned char *) &tail->tb_data[tail->tb_offset[tail->used-1]]);
-
-			return tailid;
-		}
-
-		ibex_block_cache_assert(blocks, &tail->tb_offset[tail->used-1]
-					< (unsigned char *) &tail->tb_data[tail->tb_offset[tail->used-1]]);
-
-		/* see if we have a free slot first */
-		freeindex = -1;
-		end = &tail->tb_data[sizeof(tail->tb_data)/sizeof(tail->tb_data[0])];
-		for (i=0;i<tail->used;i++) {
-			if (end == &tail->tb_data[tail->tb_offset[i]]) {
-				freeindex = i;
-				break;
-			}
-			end = &tail->tb_data[tail->tb_offset[i]];
-		}
-
-		/* determine how much space we have available - incl any extra header we might need */
-		space =  ((char *)&tail->tb_data[tail->tb_offset[tail->used-1]])
-			- ((char *)&tail->tb_offset[tail->used])
-			/* FIXMEL work out why this is out a little bit */
-			- 8;
-		if (freeindex == -1)
-			space -= sizeof(tail->tb_offset[0]);
-
-		/* if we have enough, set it up, creating a new entry if necessary */
-		/* for some really odd reason the compiler promotes this expression to unsigned, hence
-		   the requirement for the space>0 check ... */
-		if (space>0 && space > size*sizeof(blockid_t)) {
-			d(printf("space = %d, size = %d size*sizeof() = %d truth = %d\n", space, size, size*sizeof(blockid_t), space>size*sizeof(blockid_t)));
-			if (freeindex == -1) {
-				freeindex = tail->used;
-				tail->tb_offset[tail->used] = tail->tb_offset[tail->used-1];
-				tail->used++;
-			}
-			tail_compress(blocks, tail, freeindex, size);
-			ibex_block_dirty((struct _block *)tail);
-			d(printf("allocated %d (%d), used %d\n", tailid, TAIL_KEY(tailid, freeindex), tail->used));
-			return TAIL_KEY(tailid, freeindex);
-		}
-		count++;
-		tailid = block_location(tail->next);
-	}
-
-	d(printf("allocating new data node for tail data\n"));
-	tailid = ibex_block_get(blocks);
-	tail = (struct _tailblock *)ibex_block_read(blocks, tailid);
-	tail->next = block_number(blocks->root.tail);
-	blocks->root.tail = tailid;
-	tail->used = 1;
-	tail->tb_offset[0] = sizeof(tail->tb_data)/sizeof(tail->tb_data[0]) - size;
-	ibex_block_dirty((struct _block *)tail);
-	d(printf("allocated %d (%d), used %d\n", tailid, TAIL_KEY(tailid, 0), tail->used));
-
-	g_assert(&tail->tb_offset[tail->used-1]
-		 < (unsigned char *) &tail->tb_data[tail->tb_offset[tail->used-1]]);
-
-	return TAIL_KEY(tailid, 0);
-}
-
-static void
-tail_free(struct _memcache *blocks, blockid_t tailid)
-{
-	struct _tailblock *tail;
-
-	d(printf("freeing tail id %d\n", tailid));
-
-	if (tailid == 0)
-		return;
-
-	tail = (struct _tailblock *)ibex_block_read(blocks, TAIL_BLOCK(tailid));
-	d(printf("  tail %d used %d\n", tailid, tail->used));
-	ibex_block_cache_assert(blocks, tail->used);
-	if (TAIL_INDEX(tailid)  == tail->used - 1) {
-		tail->used --;
-	} else {
-		tail_compress(blocks, tail, TAIL_INDEX(tailid), 0);
-	}
-	ibex_block_dirty((struct _block *)tail);
-}
-
-static struct _IBEXStore *disk_create(struct _memcache *bc)
-{
-	struct _IBEXStore *store;
-
-	store = g_malloc0(sizeof(*store));
-	store->klass = &ibex_diskarray_class;
-	store->blocks = bc;
-
-	return store;
-}
-
-static int disk_sync(struct _IBEXStore *store)
-{
-	/* no cache, nop */
-	return 0;
-}
-
-static int disk_close(struct _IBEXStore *store)
-{
-	g_free(store);
-	return 0;
-}
-
-static blockid_t
-disk_add(struct _IBEXStore *store, blockid_t *headptr, blockid_t *tailptr, nameid_t data)
-{
-	struct _block *block;
-	struct _block *newblock;
-	blockid_t new, head = *headptr /*, tail = *tailptr*/;
-
-	g_error("Inbimplemented");
-
-	if (head == 0) {
-		head = ibex_block_get(store->blocks);
-	}
-	block = ibex_block_read(store->blocks, head);
-
-	d(printf("adding record %d to block %d (next = %d)\n", data, head, block->next));
-
-	if (block->used < sizeof(block->bl_data)/sizeof(block->bl_data[0])) {
-		(printf("adding record into block %d  %d\n", head, data));
-		block->bl_data[block->used] = data;
-		block->used++;
-		ibex_block_dirty(block);
-		return head;
-	} else {
-		new = ibex_block_get(store->blocks);
-		newblock = ibex_block_read(store->blocks, new);
-		newblock->next = block_number(head);
-		newblock->bl_data[0] = data;
-		newblock->used = 1;
-		d(printf("adding record into new %d  %d, next =%d\n", new, data, newblock->next));
-		ibex_block_dirty(newblock);
-		return new;
-	}
-}
-
-static blockid_t
-disk_add_blocks_internal(struct _IBEXStore *store, blockid_t *headptr, blockid_t *tailptr, GArray *data)
-{
-	blockid_t head = *headptr, tail = *tailptr, new;
-	int tocopy;
-	struct _tailblock *tailblock;
-	struct _block *block, *newblock;
-	int space, copied = 0, left;
-
-	/* assumes this funciton is in control of any tail creation */ 
-	ibex_block_cache_assert(store->blocks, tail == 0);
-
-	d(printf("Adding %d items to block list\n", data->len));
-
-	if (head == 0) {
-		head = ibex_block_get(store->blocks);
-		d(printf("allocating new head %d\n", head));
-	}
-	block = ibex_block_read(store->blocks, head);
-
-	/* ensure the first block is full before proceeding */
-	space = sizeof(block->bl_data)/sizeof(block->bl_data[0]) - block->used;
-	if (space) {
-		tocopy = MIN(data->len, space);
-		memcpy(block->bl_data+block->used, &g_array_index(data, blockid_t, copied), tocopy*sizeof(blockid_t));
-		block->used += tocopy;
-		ibex_block_dirty(block);
-		copied = tocopy;
-		d(printf("copied %d items to left over last node\n", tocopy));
-	}
-
-	while (copied < data->len) {
-		left = data->len - copied;
-		/* do we drop the rest in a tail? */
-		if (left < TAIL_THRESHOLD) {
-			d(printf("Storing remaining %d items in tail\n", left));
-			tocopy = left;
-			new = tail_get(store->blocks, tocopy);
-			tailblock = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(new));
-			memcpy(&tailblock->tb_data[tailblock->tb_offset[TAIL_INDEX(new)]],
-			       &g_array_index(data, blockid_t, copied), tocopy*sizeof(blockid_t));
-			*tailptr = new;
-		} else {
-			new = ibex_block_get(store->blocks);
-			newblock = (struct _block *)ibex_block_read(store->blocks, new);
-			newblock->next = block_number(head);
-			tocopy = MIN(left, sizeof(block->bl_data)/sizeof(block->bl_data[0]));
-			d(printf("storing %d items in own block\n", tocopy));
-			memcpy(newblock->bl_data, &g_array_index(data, blockid_t, copied), tocopy*sizeof(blockid_t));
-			newblock->used = tocopy;
-			block = newblock;
-			head = new;
-			ibex_block_dirty(newblock);
-		}
-		copied += tocopy;
-	}
-
-	*headptr = head;
-	return head;
-}
-/*
-  case 1:
-    no head, no tail, adding a lot of data
-      add blocks until the last, which goes in a tail node
-  case 2:
-    no head, no tail, adding a little data
-      just add a tail node
-  case 3:
-    no head, tail, total exceeds a block
-      merge as much as possible into new full blocks, then the remainder in the tail
-  case 4:
-    no head, tail, room in existing tail for data
-      add new data to tail node
-  case 5:
-    no head, tail, no room in existing tail for data
-      add a new tail node, copy data across, free old tail node
-*/
-
-static blockid_t
-disk_add_list(struct _IBEXStore *store, blockid_t *headptr, blockid_t *tailptr, GArray *data)
-{
-	blockid_t new, head = *headptr, tail = *tailptr, *start;
-	struct _tailblock *tailblock, *tailnew;
-	int len;
-	GArray *tmpdata = NULL;
-
-	d(printf("adding %d items head=%d tail=%d\n", data->len, head, tail));
-	if (data->len == 0)
-		return head;
-
-	/* store length=1 data in the tail pointer */
-	if (head == 0 && tail == 0 && data->len == 1) {
-		*headptr = BLOCK_ONE;
-		*tailptr = g_array_index(data, blockid_t, 0);
-		return BLOCK_ONE;
-	}
-	/* if we got length=1 data to append to, upgrade it to a real block list */
-	if (head == BLOCK_ONE) {
-		tmpdata = g_array_new(0, 0, sizeof(blockid_t));
-		g_array_append_vals(tmpdata, data->data, data->len);
-		g_array_append_val(tmpdata, tail);
-		head = *headptr = 0;
-		tail = *tailptr = 0;
-	}
-
-	/* if we have no head, then check the tail */
-	if (head == 0) {
-		if (tail == 0) {
-			if (data->len >= TAIL_THRESHOLD) {
-				/* add normally */
-				head = disk_add_blocks_internal(store, headptr, tailptr, data);
-			} else {
-				/* else add to a tail block */
-				new = tail_get(store->blocks, data->len);
-				d(printf("adding %d items to a tail block %d\n", data->len, new));
-				tailnew = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(new));
-				memcpy(&tailnew->tb_data[tailnew->tb_offset[TAIL_INDEX(new)]],
-				       data->data, data->len*sizeof(blockid_t));
-				*tailptr = new;
-				ibex_block_dirty((struct _block *)tailnew);
-			}
-		} else {
-			tailblock = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(tail));
-			len = tail_info(store->blocks, tailblock, tail, &start);
-			/* case 3 */
-			if (len + data->len >= TAIL_THRESHOLD) {
-				/* this is suboptimal, but should work - merge the tail data with
-				   our new data, and write it out */
-				if (tmpdata == NULL) {
-					tmpdata = g_array_new(0, 0, sizeof(blockid_t));
-					g_array_append_vals(tmpdata, data->data, data->len);
-				}
-				g_array_append_vals(tmpdata, start, len);
-				*tailptr = 0;
-				tail_free(store->blocks, tail);
-				head = disk_add_blocks_internal(store, headptr, tailptr, tmpdata);
-			} else if (tail_space(tailblock) >= data->len) {
-				/* can we just expand this in our node, or do we need a new one? */
-				tail_compress(store->blocks, tailblock, TAIL_INDEX(tail), data->len + len);
-				memcpy(&tailblock->tb_data[tailblock->tb_offset[TAIL_INDEX(tail)] + len],
-				       data->data, data->len * sizeof(blockid_t));
-				ibex_block_dirty((struct _block *)tailblock);
-			} else {
-				/* we need to allocate a new tail node */
-				new = tail_get(store->blocks, data->len + len);
-				/* and copy the data across */
-				tailnew = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(new));
-				memcpy(&tailnew->tb_data[tailnew->tb_offset[TAIL_INDEX(new)]],
-				       start, len*sizeof(blockid_t));
-				memcpy(&tailnew->tb_data[tailnew->tb_offset[TAIL_INDEX(new)]+len],
-				       data->data, data->len*sizeof(blockid_t));
-				tail_free(store->blocks, tail);
-				ibex_block_dirty((struct _block *)tailnew);
-				*tailptr = new;
-			}
-		}
-	} else {
-		if (tail) {
-			/* read/merge the tail with the new data, rewrite out.
-			   suboptimal, but it should be 'ok' ? */
-			tailblock = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(tail));
-			len = tail_info(store->blocks, tailblock, tail, &start);
-			tmpdata = g_array_new(0, 0, sizeof(blockid_t));
-			g_array_append_vals(tmpdata, start, len);
-			g_array_append_vals(tmpdata, data->data, data->len);
-			*tailptr = 0;
-			tail_free(store->blocks, tail);
-			head = disk_add_blocks_internal(store, headptr, tailptr, tmpdata);
-		} else {
-			head = disk_add_blocks_internal(store, headptr, tailptr, data);
-		}
-	}
-	if (tmpdata)
-		g_array_free(tmpdata, TRUE);
-
-	return head;
-}
-
-static blockid_t
-disk_remove(struct _IBEXStore *store, blockid_t *headptr, blockid_t *tailptr, nameid_t data)
-{
-	blockid_t head = *headptr, node = *headptr, tail = *tailptr;
-	int i;
-
-	/* special case for 1-item nodes */
-	if (head == BLOCK_ONE) {
-		if (tail == data) {
-			*tailptr = 0;
-			*headptr = 0;
-			head = 0;
-		}
-		return head;
-	}
-
-	d(printf("removing %d from %d\n", data, head));
-	while (node) {
-		struct _block *block = ibex_block_read(store->blocks, node);
-
-		for (i=0;i<block->used;i++) {
-			if (block->bl_data[i] == data) {
-				struct _block *start = ibex_block_read(store->blocks, head);
-
-				d(printf("removing data from block %d\n ", head));
-
-				start->used--;
-				block->bl_data[i] = start->bl_data[start->used];
-				if (start->used == 0) {
-					blockid_t new;
-
-					d(printf("dropping block %d, new head = %d\n", head, start->next));
-					new = block_location(start->next);
-					start->next = block_number(store->blocks->root.free);
-					store->blocks->root.free = head;
-					head = new;
-				}
-				ibex_block_dirty(block);
-				ibex_block_dirty(start);
-				*headptr = head;
-				return head;
-			}
-		}
-		node = block_location(block->next);
-	}
-
-	if (tail) {
-		struct _tailblock *tailblock = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(tail));
-		int len;
-		blockid_t *start;
-
-		len = tail_info(store->blocks, tailblock, tail, &start);
-		for (i=0;i<len;i++) {
-			if (start[i] == data) {
-				for (;i<len-1;i++)
-					start[i] = start[i+1];
-				if (len == 1)
-					*tailptr = 0;
-				if (len == 1 && (tailblock->used-1) == TAIL_INDEX(tail)) {
-					d(printf("dropping/unlinking tailblock %d (%d) used = %d\n",
-						 TAIL_BLOCK(tail), tail, tailblock->used));
-					tailblock->used--;
-					/* drop/unlink block? */
-					ibex_block_dirty((struct _block *)tailblock);
-					*tailptr = 0;
-				} else {
-					tail_compress(store->blocks, tailblock, TAIL_INDEX(tail), len-1);
-					ibex_block_dirty((struct _block *)tailblock);
-				}
-			}
-		}
-		
-	}
-
-	return head;
-}
-
-static void disk_free(struct _IBEXStore *store, blockid_t head, blockid_t tail)
-{
-	blockid_t next;
-	struct _block *block;
-
-	if (head == BLOCK_ONE)
-		return;
-
-	while (head) {
-		d(printf("freeing block %d\n", head));
-		block = ibex_block_read(store->blocks, head);
-		next = block_location(block->next);
-		ibex_block_free(store->blocks, head);
-		head = next;
-	}
-	if (tail) {
-		struct _tailblock *tailblock = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(tail));
-		d(printf("freeing tail block %d (%d)\n", TAIL_BLOCK(tail), tail));
-		tail_compress(store->blocks, tailblock, TAIL_INDEX(tail), 0);
-		ibex_block_dirty((struct _block *)tailblock);
-	}
-}
-
-static gboolean
-disk_find(struct _IBEXStore *store, blockid_t head, blockid_t tail, nameid_t data)
-{
-	blockid_t node = head;
-	int i;
-
-	d(printf("finding %d from %d\n", data, head));
-
-	if (head == BLOCK_ONE)
-		return data == tail;
-
-	/* first check full blocks */
-	while (node) {
-		struct _block *block = ibex_block_read(store->blocks, node);
-
-		for (i=0;i<block->used;i++) {
-			if (block->bl_data[i] == data) {
-				return TRUE;
-			}
-		}
-		node = block_location(block->next);
-	}
-
-	/* then check tail */
-	if (tail) {
-		struct _tailblock *tailblock = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(tail));
-		int len;
-		blockid_t *start;
-
-		len = tail_info(store->blocks, tailblock, tail, &start);
-		for (i=0;i<len;i++) {
-			if (start[i] == data)
-				return TRUE;
-		}
-	}
-
-	return FALSE;
-}
-
-static GArray *
-disk_get(struct _IBEXStore *store, blockid_t head, blockid_t tail)
-{
-	GArray *result = g_array_new(0, 0, sizeof(nameid_t));
-
-	if (head == BLOCK_ONE) {
-		g_array_append_val(result, tail);
-		return result;
-	}
-
-	while (head) {
-		struct _block *block = ibex_block_read(store->blocks, head);
-
-		d(printf("getting data from block %d\n", head));
-
-		g_array_append_vals(result, block->bl_data, block->used);
-		head = block_location(block->next);
-		d(printf("next = %d\n", head));
-	}
-
-	/* chuck on any tail data as well */
-	if (tail) {
-		struct _tailblock *tailblock;
-		int len;
-		blockid_t *start;
-		
-		tailblock = (struct _tailblock *)ibex_block_read(store->blocks, TAIL_BLOCK(tail));
-		len = tail_info(store->blocks, tailblock, tail, &start);
-		g_array_append_vals(result, start, len);
-	}
-	return result;
-}
-
-void ibex_diskarray_dump(struct _memcache *blocks, blockid_t head, blockid_t tail);
-
-void
-ibex_diskarray_dump(struct _memcache *blocks, blockid_t head, blockid_t tail)
-{
-	blockid_t node = head;
-
-	printf("dumping list %d tail %d\n", node, tail);
-	if (head == BLOCK_ONE) {
-		printf(" 1 length index: %d\n", tail);
-		return;
-	}
-       
-	while (node) {
-		struct _block *block = ibex_block_read(blocks, node);
-		int i;
-
-		printf(" block %d used %d\n ", node, block->used);
-		for (i=0;i<block->used;i++) {
-			printf(" %d", block->bl_data[i]);
-		}
-		printf("\n");
-		node = block_location(block->next);
-	}
-
-	printf("tail: ");
-	if (tail) {
-		struct _tailblock *tailblock;
-		int len;
-		blockid_t *start;
-		int i;
-
-		tailblock = (struct _tailblock *)ibex_block_read(blocks, TAIL_BLOCK(tail));
-		len = tail_info(blocks, tailblock, tail, &start);
-		for (i=0;i<len;i++)
-			printf(" %d", start[i]);
-	}
-	printf("\n");
-}
-
-#if 0
-int main(int argc, char **argv)
-{
-	struct _memcache *bc;
-	struct _IBEXStore *disk;
-	int i;
-	blockid_t data[100];
-	GArray adata;
-	blockid_t head=0, tail=0;
-
-	for (i=0;i<100;i++) {
-		data[i] = i;
-	}
-
-	bc = ibex_block_cache_open("index.db", O_CREAT|O_RDWR, 0600);
-	disk = ibex_diskarray_class.create(bc);
-
-	head = 0;
-	tail = 0;
-	adata.data = data;
-	adata.len = 70;
-	for (i=0;i<100;i++) {
-		printf("Loop %d\n", i);
-		ibex_diskarray_class.add_list(disk, &head, &tail, &adata);
-		ibex_diskarray_dump(bc, head, tail);
-	}
-	
-#if 0
-	for (i=1;i<100;i++) {
-		printf("inserting %d items\n", i);
-		adata.data = data;
-		adata.len = i;
-		head=0;
-		tail=0;
-		ibex_diskarray_class.add_list(disk, &head, &tail, &adata);
-		ibex_diskarray_dump(bc, head, tail);
-	}
-#endif
-	ibex_diskarray_class.close(disk);
-	ibex_block_cache_close(bc);
-	return 0;
-}
-
-#endif
diff --git a/libibex/dumpindex.c b/libibex/dumpindex.c
deleted file mode 100644
index 5f8cacd603..0000000000
--- a/libibex/dumpindex.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-  Dump the hash tables from an ibex file.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "ibex_internal.h"
-
-extern void ibex_hash_dump(struct _IBEXIndex *index);
-
-static void
-index_iterate(struct _IBEXIndex *index)
-{
-	struct _IBEXCursor *idc;
-	int len;
-	char *key;
-	int total = 0, totallen = 0;
-
-	idc = index->klass->get_cursor(index);
-	key = idc->klass->next_key(idc, &len);
-	while (len) {
-		total++;
-		totallen += len;
-		printf("%s\n", key);
-		g_free(key);
-		key = idc->klass->next_key(idc, &len);
-	}
-	g_free(key);
-
-	idc->klass->close(idc);
-
-	printf("Iterate Totals: %d items, total bytes %d\n", total, totallen);
-}
-
-int main(int argc, char **argv)
-{
-	ibex *ib;
-
-#ifdef ENABLE_THREADS
-	g_thread_init(0);
-#endif
-
-	if (argc != 2) {
-		printf("Usage: %s ibexfile\n", argv[0]);
-		return 1;
-	}
-	ib = ibex_open(argv[1], O_RDONLY, 0);
-	if (ib == NULL) {
-		perror("Opening ibex file\n");
-		return 1;
-	}
-
-	/* force real-open of the ibex internals */
-	ibex_contains_name(ib, "dummy");
-
-	ibex_hash_dump(ib->words->wordindex);
-	ibex_hash_dump(ib->words->nameindex);
-
-	index_iterate(ib->words->wordindex);
-	index_iterate(ib->words->nameindex);
-
-	ibex_close(ib);
-
-	return 0;
-}
diff --git a/libibex/hash.c b/libibex/hash.c
deleted file mode 100644
index 93cc22e72e..0000000000
--- a/libibex/hash.c
+++ /dev/null
@@ -1,856 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
- *
- * Copyright (C) 2000 Ximian, Inc.
- *
- * Authors: Michael Zucchi <notzed@ximian.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/* hash based index mechanism */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-
-#include "block.h"
-#include "index.h"
-
-#define d(x)
-
-#define HASH_SIZE (1024)
-#define KEY_THRESHOLD (sizeof(struct _hashkey) + 4) /* minimum number of free bytes we worry about
-						      maintaining free blocks for */
-#define ARRAY_LEN(a) (sizeof(a)/sizeof(a[0]))
-
-typedef guint32 hashid_t;
-
-struct _HASHCursor {
-	struct _IBEXCursor cursor;
-
-	hashid_t key;
-	hashid_t block;
-	unsigned int index;
-	unsigned int size;
-};
-
-static struct _IBEXIndex *hash_create(struct _memcache *bc, int size);
-static struct _IBEXIndex *hash_open(struct _memcache *bc, blockid_t root);
-static int hash_sync(struct _IBEXIndex *index);
-static int hash_close(struct _IBEXIndex *index);
-
-static hashid_t hash_find(struct _IBEXIndex *index, const char *key, int keylen);
-static void hash_remove(struct _IBEXIndex *index, const char *key, int keylen);
-static hashid_t hash_insert(struct _IBEXIndex *index, const char *key, int keylen);
-static char *hash_get_key(struct _IBEXIndex *index, hashid_t hashbucket, int *len);
-static void hash_set_data_block(struct _IBEXIndex *index, hashid_t keyid, blockid_t blockid, blockid_t tail);
-static blockid_t hash_get_data_block(struct _IBEXIndex *index, hashid_t keyid, blockid_t *tail);
-static struct _IBEXCursor *hash_get_cursor(struct _IBEXIndex *index);
-
-static struct _IBEXCursor *hash_cursor_create(struct _IBEXIndex *);
-static void hash_cursor_close(struct _IBEXCursor *);
-static guint32 hash_cursor_next(struct _IBEXCursor *);
-static char *hash_cursor_next_key(struct _IBEXCursor *, int *keylenptr);
-
-struct _IBEXIndexClass ibex_hash_class = {
-	hash_create, hash_open,
-	hash_sync, hash_close,
-	hash_find,
-	hash_remove,
-	hash_insert,
-	hash_get_key,
-	hash_set_data_block,
-	hash_get_data_block,
-	hash_get_cursor,
-};
-
-struct _IBEXCursorClass ibex_hash_cursor_class = {
-	hash_cursor_close,
-	hash_cursor_next,
-	hash_cursor_next_key
-};
-
-/* the reason we have the tail here is that otherwise we need to
-   have a 32 bit blockid for the root node; which would make this
-   structure the same size anyway, with about 24 wasted bits */
-struct _hashkey {
-	blockid_t next;		/* next in hash chain */
-	blockid_t tail;
-	unsigned int root:32-BLOCK_BITS;
-	unsigned int keyoffset:BLOCK_BITS;
-};
-
-struct _hashblock {
-	unsigned int next:32-BLOCK_BITS;	/* next block, linked list of all key blocks: block number */
-	unsigned int used:BLOCK_BITS;		/* number of elements used */
-	union {
-		struct _hashkey keys[(BLOCK_SIZE-4)/sizeof(struct _hashkey)];
-		char keydata[BLOCK_SIZE-4];
-	} hashblock_u;
-};
-#define hb_keys hashblock_u.keys
-#define hb_keydata hashblock_u.keydata
-
-/* size of block overhead + 2 key block overhead */
-#define MAX_KEYLEN (BLOCK_SIZE - 4 - 12 - 12)
-
-/* root block for a hash index */
-struct _hashroot {
-	hashid_t free;		/* free list */
-	guint32 size;		/* how big the hash table is */
-	hashid_t keys;		/* linked list of blocks */
-	hashid_t table[(BLOCK_SIZE-8)/sizeof(hashid_t)]; /* pointers to blocks of pointers */
-};
-
-struct _hashtableblock {
-	hashid_t buckets[BLOCK_SIZE/sizeof(hashid_t)];
-};
-
-/* map a hash index to a block index */
-#define HASH_INDEX(b) ((b) & (BLOCK_SIZE-1))
-/* map a hash index to a block number */
-#define HASH_BLOCK(b) ((b) & ~(BLOCK_SIZE-1))
-/* map a block + index to a hash key */
-#define HASH_KEY(b, i) (((b) & ~(BLOCK_SIZE-1)) | ((i) & (BLOCK_SIZE-1)))
-
-/* taken from tdb/gdbm */
-static unsigned int hash_key(const unsigned char *key, int keylen)
-{
-	char *newkey;
-	newkey = alloca(keylen+1);
-	memcpy(newkey, key, keylen);
-	newkey[keylen]=0;
-	return g_str_hash(newkey);
-#if 0
-	unsigned int value;	/* Used to compute the hash value.  */
-	unsigned int  i;	/* Used to cycle through random values. */
-
-	/* Set the initial value from the key size. */
-	value = 0x238F13AF * keylen;
-	for (i=0; i < keylen; i++) {
-		value = (value + (key[i] << (i*5 % 24)));
-	}
-
-	value = (1103515243 * value + 12345);  
-
-	return value;
-#endif
-}
-
-/* create a new hash table, return a pointer to its root block */
-static struct _IBEXIndex *
-hash_create(struct _memcache *bc, int size)
-{
-	blockid_t root, block;
-	struct _hashroot *hashroot;
-	int i;
-	struct _hashtableblock *table;
-	struct _IBEXIndex *index;
-
-	g_assert(size<=10240);
-
-	d(printf("initialising hash table, size = %d\n", size));
-
-	index = g_malloc0(sizeof(*index));
-	index->blocks = bc;
-	index->klass = &ibex_hash_class;
-	root = ibex_block_get(bc);
-	index->root = root;
-	d(printf(" root = %d\n", root));
-	hashroot = (struct _hashroot *)ibex_block_read(bc, root);
-	hashroot->free = 0;
-	hashroot->size = size;
-	ibex_block_dirty((struct _block *)hashroot);
-	for (i=0;i<size/(BLOCK_SIZE/sizeof(blockid_t));i++) {
-		d(printf("initialising hash table index block %d\n", i));
-		block = hashroot->table[i] = ibex_block_get(bc);
-		table = (struct _hashtableblock *)ibex_block_read(bc, block);
-		memset(table, 0, sizeof(table));
-		ibex_block_dirty((struct _block *)table);
-	}
-
-	return index;
-}
-
-static struct _IBEXIndex *
-hash_open(struct _memcache *bc, blockid_t root)
-{
-	struct _IBEXIndex *index;
-
-	/* FIXME: check a 'magic', and the root for validity */
-
-	index = g_malloc0(sizeof(*index));
-	index->blocks = bc;
-	index->root = root;
-	index->klass = &ibex_hash_class;
-
-	return index;
-}
-
-
-static int hash_sync(struct _IBEXIndex *index)
-{
-	/* nop, index always synced on disk (at least, to blocks) */
-	return 0;
-}
-
-static int hash_close(struct _IBEXIndex *index)
-{
-#ifdef INDEX_STAT
-	printf("Performed %d lookups, average %f depth\n", index->lookups, (double)index->lookup_total/index->lookups);
-#endif
-	g_free(index);
-	return 0;
-}
-
-/* get an iterator class */
-static struct _IBEXCursor *hash_get_cursor(struct _IBEXIndex *index)
-{
-	return hash_cursor_create(index);
-}
-
-/* convert a hashbucket id into a name */
-static char *
-hash_get_key(struct _IBEXIndex *index, hashid_t hashbucket, int *len)
-{
-	struct _hashblock *bucket;
-	int ind;
-	char *ret, *start, *end;
-
-	if (hashbucket == 0) {
-		if (len)
-			*len = 0;
-		return g_strdup("");
-	}
-
-	bucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(hashbucket));
-	ind = HASH_INDEX(hashbucket);
-
-	ibex_block_cache_assert(index->blocks, ind < bucket->used);
-
-	start = &bucket->hb_keydata[bucket->hb_keys[ind].keyoffset];
-	if (ind == 0) {
-		end = &bucket->hb_keydata[sizeof(bucket->hb_keydata)/sizeof(bucket->hb_keydata[0])];
-	} else {
-		end = &bucket->hb_keydata[bucket->hb_keys[ind-1].keyoffset];
-	}
-	
-	ret = g_malloc(end-start+1);
-	memcpy(ret, start, end-start);
-	ret[end-start]=0;
-	if (len)
-		*len = end-start;
-	return ret;
-}
-
-/* sigh, this is fnugly code ... */
-static hashid_t
-hash_find(struct _IBEXIndex *index, const char *key, int keylen)
-{
-	struct _hashroot *hashroot;
-	guint32 hash;
-	int hashentry;
-	blockid_t hashtable;
-	hashid_t hashbucket;
-	struct _hashtableblock *table;
-
-	g_assert(index != 0);
-	g_assert(index->root != 0);
-
-	d(printf("finding hash %.*s\n", keylen, key));
-
-	/* truncate the key to the maximum size */
-	if (keylen > MAX_KEYLEN)
-		keylen = MAX_KEYLEN;
-
-	hashroot = (struct _hashroot *)ibex_block_read(index->blocks, index->root);
-
-	/* find the table containing this entry */
-	hash = hash_key(key, keylen) % hashroot->size;
-	hashtable = hashroot->table[hash / (BLOCK_SIZE/sizeof(blockid_t))];
-	ibex_block_cache_assert(index->blocks, hashtable != 0);
-	table = (struct _hashtableblock *)ibex_block_read(index->blocks, hashtable);
-	hashentry = hash % (BLOCK_SIZE/sizeof(blockid_t));
-	/* and its bucket */
-	hashbucket = table->buckets[hashentry];
-
-#ifdef INDEX_STAT
-	index->lookups++;
-#endif
-	/* go down the bucket chain, reading each entry till we are done ... */
-	while (hashbucket != 0) {
-		struct _hashblock *bucket;
-		char *start, *end;
-		int ind;
-
-#ifdef INDEX_STAT
-		index->lookup_total++;
-#endif
-
-		d(printf(" checking bucket %d\n", hashbucket));
-
-		/* get the real bucket id from the hashbucket id */
-		bucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(hashbucket));
-		/* and get the key number within the block */
-		ind = HASH_INDEX(hashbucket);
-
-		ibex_block_cache_assert(index->blocks, ind < bucket->used);
-
-		start = &bucket->hb_keydata[bucket->hb_keys[ind].keyoffset];
-		if (ind == 0) {
-			end = &bucket->hb_keydata[sizeof(bucket->hb_keydata)/sizeof(bucket->hb_keydata[0])];
-		} else {
-			end = &bucket->hb_keydata[bucket->hb_keys[ind-1].keyoffset];
-		}
-		if ( (end-start) == keylen
-		     && memcmp(start, key, keylen) == 0) {
-			return hashbucket;
-		}
-		hashbucket = bucket->hb_keys[ind].next;
-	}
-	return 0;
-}
-
-static int
-hash_info(struct _IBEXIndex *idex, struct _hashblock *bucket, int index)
-{
-	char *start, *end;
-
-	ibex_block_cache_assert(idex->blocks, index < bucket->used);
-
-	start = &bucket->hb_keydata[bucket->hb_keys[index].keyoffset];
-	if (index == 0) {
-		end = &bucket->hb_keydata[sizeof(bucket->hb_keydata)/sizeof(bucket->hb_keydata[0])];
-	} else {
-		end = &bucket->hb_keydata[bucket->hb_keys[index-1].keyoffset];
-	}
-
-	return end-start;
-}
-
-
-/* TODO: get rid of hash_compress/remove and just have one a-la the disktail code */
-
-/* compresses the bucket 'bucket', removing data
-   at index 'index' */
-static void
-hash_compress(struct _hashblock *bucket, int index)
-{
-	int i;
-	char *start, *end, *newstart;
-
-	/* get start/end of area to zap */
-	start = &bucket->hb_keydata[bucket->hb_keys[index].keyoffset];
-	if (index == 0) {
-		end = &bucket->hb_keydata[sizeof(bucket->hb_keydata)/sizeof(bucket->hb_keydata[0])];
-	} else {
-		end = &bucket->hb_keydata[bucket->hb_keys[index-1].keyoffset];
-	}
-
-	if (start == end)
-		return;
-
-	/* fixup data */
-	newstart = &bucket->hb_keydata[bucket->hb_keys[bucket->used-1].keyoffset];
-	memmove(newstart+(end-start), newstart, start-newstart);
-
-	/* fixup key pointers */
-	for (i=index;i<bucket->used;i++) {
-		bucket->hb_keys[i].keyoffset += (end-start);
-	}
-	ibex_block_dirty((struct _block *)bucket);
-}
-
-/* make room 'len' for the key 'index' */
-/* assumes key 'index' is already empty (0 length) */
-static void
-hash_expand(struct _hashblock *bucket, int index, int len)
-{
-	int i;
-	char *end, *newstart;
-
-	/* get start/end of area to zap */
-	if (index == 0) {
-		end = &bucket->hb_keydata[sizeof(bucket->hb_keydata)/sizeof(bucket->hb_keydata[0])];
-	} else {
-		end = &bucket->hb_keydata[bucket->hb_keys[index-1].keyoffset];
-	}
-
-	/* fixup data */
-	newstart = &bucket->hb_keydata[bucket->hb_keys[bucket->used-1].keyoffset];
-	memmove(newstart-len, newstart, end-newstart);
-
-	/* fixup key pointers */
-	for (i=index;i<bucket->used;i++) {
-		bucket->hb_keys[i].keyoffset -= len;
-	}
-	ibex_block_dirty((struct _block *)bucket);
-}
-
-static void
-hash_remove(struct _IBEXIndex *index, const char *key, int keylen)
-{
-	struct _hashroot *hashroot;
-	guint32 hash;
-	int hashentry;
-	blockid_t hashtable;
-	hashid_t hashbucket, hashprev;
-	struct _hashtableblock *table;
-
-	g_assert(index != 0);
-	g_assert(index->root != 0);
-
-	d(printf("removing hash %.*s\n", keylen, key));
-
-	/* truncate the key to the maximum size */
-	if (keylen > MAX_KEYLEN)
-		keylen = MAX_KEYLEN;
-
-	hashroot = (struct _hashroot *)ibex_block_read(index->blocks, index->root);
-
-	/* find the table containing this entry */
-	hash = hash_key(key, keylen) % hashroot->size;
-	hashtable = hashroot->table[hash / (BLOCK_SIZE/sizeof(blockid_t))];
-	table = (struct _hashtableblock *)ibex_block_read(index->blocks, hashtable);
-	hashentry = hash % (BLOCK_SIZE/sizeof(blockid_t));
-	/* and its bucket */
-	hashbucket = table->buckets[hashentry];
-
-	/* go down the bucket chain, reading each entry till we are done ... */
-	hashprev = 0;
-	while (hashbucket != 0) {
-		struct _hashblock *bucket;
-		char *start, *end;
-		int ind;
-
-		d(printf(" checking bucket %d\n", hashbucket));
-
-		/* get the real bucket id from the hashbucket id */
-		bucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(hashbucket));
-		/* and get the key number within the block */
-		ind = HASH_INDEX(hashbucket);
-
-		ibex_block_cache_assert(index->blocks, ind < bucket->used);
-
-		start = &bucket->hb_keydata[bucket->hb_keys[ind].keyoffset];
-		if (ind == 0) {
-			end = &bucket->hb_keydata[sizeof(bucket->hb_keydata)/sizeof(bucket->hb_keydata[0])];
-		} else {
-			end = &bucket->hb_keydata[bucket->hb_keys[ind-1].keyoffset];
-		}
-		if ( (end-start) == keylen
-		     && memcmp(start, key, keylen) == 0) {
-			struct _hashblock *prevbucket;
-
-			if (hashprev == 0) {
-				/* unlink from hash chain */
-				table->buckets[hashentry] = bucket->hb_keys[HASH_INDEX(hashbucket)].next;
-				/* link into free list */
-				bucket->hb_keys[HASH_INDEX(hashbucket)].next = hashroot->free;
-				hashroot->free = hashbucket;
-				/* compress away data */
-				hash_compress(bucket, HASH_INDEX(hashbucket));
-				ibex_block_dirty((struct _block *)bucket);
-				ibex_block_dirty((struct _block *)table);
-				ibex_block_dirty((struct _block *)hashroot);
-			} else {
-				prevbucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(hashprev));
-				prevbucket->hb_keys[HASH_INDEX(hashprev)].next = bucket->hb_keys[ind].next;
-				/* link into free list */
-				bucket->hb_keys[ind].next = hashroot->free;
-				hashroot->free = hashbucket;
-				/* compress entry */
-				hash_compress(bucket, ind);
-				ibex_block_dirty((struct _block *)bucket);
-				ibex_block_dirty((struct _block *)prevbucket);
-				ibex_block_dirty((struct _block *)hashroot);
-			}
-			return;
-		}
-		hashprev = hashbucket;
-		hashbucket = bucket->hb_keys[ind].next;
-	}
-}
-
-/* set where the datablock is located */
-static void
-hash_set_data_block(struct _IBEXIndex *index, hashid_t keyid, blockid_t blockid, blockid_t tail)
-{
-	struct _hashblock *bucket;
-
-	d(printf("setting data block hash %d to %d tail %d\n", keyid, blockid, tail));
-
-	/* map to a block number */
-	ibex_block_cache_assert(index->blocks, (blockid & (BLOCK_SIZE-1)) == 0);
-	blockid >>= BLOCK_BITS;
-
-	bucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(keyid));
-	if (bucket->hb_keys[HASH_INDEX(keyid)].root != blockid
-	    || bucket->hb_keys[HASH_INDEX(keyid)].tail != tail) {
-		bucket->hb_keys[HASH_INDEX(keyid)].tail = tail;
-		bucket->hb_keys[HASH_INDEX(keyid)].root = blockid;
-		ibex_block_dirty((struct _block *)bucket);
-	}
-}
-
-static blockid_t
-hash_get_data_block(struct _IBEXIndex *index, hashid_t keyid, blockid_t *tail)
-{
-	struct _hashblock *bucket;
-
-	d(printf("getting data block hash %d\n", keyid));
-
-	if (keyid == 0) {
-		if (tail)
-			*tail = 0;
-		return 0;
-	}
-
-	bucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(keyid));
-	if (tail)
-		*tail = bucket->hb_keys[HASH_INDEX(keyid)].tail;
-	return bucket->hb_keys[HASH_INDEX(keyid)].root << BLOCK_BITS;
-}
-
-static hashid_t
-hash_insert(struct _IBEXIndex *index, const char *key, int keylen)
-{
-	struct _hashroot *hashroot;
-	guint32 hash;
-	int hashentry;
-	blockid_t hashtable;
-	hashid_t hashbucket, keybucket, keyprev, keyfree;
-	struct _hashtableblock *table;
-	struct _hashblock *bucket;
-	int count;
-
-	g_assert(index != 0);
-	g_assert(index->root != 0);
-
-	/* truncate the key to the maximum size */
-	if (keylen > MAX_KEYLEN)
-		keylen = MAX_KEYLEN;
-
-	d(printf("inserting hash %.*s\n", keylen, key));
-
-	hashroot = (struct _hashroot *)ibex_block_read(index->blocks, index->root);
-
-	/* find the table containing this entry */
-	hash = hash_key(key, keylen) % hashroot->size;
-	hashtable = hashroot->table[hash / (BLOCK_SIZE/sizeof(blockid_t))];
-	table = (struct _hashtableblock *)ibex_block_read(index->blocks, hashtable);
-	hashentry = hash % (BLOCK_SIZE/sizeof(blockid_t));
-	/* and its bucket */
-	hashbucket = table->buckets[hashentry];
-
-	/* now look for a free slot, first try the free list */
-	/* but dont try too hard if our key is just too long ... so just scan upto
-	   4 blocks, but if we dont find a space, tough ... */
-	keybucket = hashroot->free;
-	keyprev = 0;
-	count = 0;
-	while (keybucket && count<4) {
-		int space;
-		
-		d(printf(" checking free %d\n", keybucket));
-
-		/* read the bucket containing this free key */
-		bucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(keybucket));
-
-		/* check if there is enough space for the key */
-		space =  &bucket->hb_keydata[bucket->hb_keys[bucket->used-1].keyoffset]
-			- (char *)&bucket->hb_keys[bucket->used];
-		if (space >= keylen) {
-			hash_expand(bucket, HASH_INDEX(keybucket), keylen);
-			memcpy(&bucket->hb_keydata[bucket->hb_keys[HASH_INDEX(keybucket)].keyoffset], key, keylen);
-
-			/* check if there is free space still in this node, and there are no other empty blocks */
-			keyfree = bucket->hb_keys[HASH_INDEX(keybucket)].next;
-			if ((space-keylen) >= KEY_THRESHOLD) {
-				int i;
-				int head = ARRAY_LEN(bucket->hb_keydata);
-				int found = FALSE;
-
-				for (i=0;i<bucket->used;i++) {
-					if (bucket->hb_keys[i].keyoffset == head) {
-						/* already have a free slot in this block, leave it */
-						found = TRUE;
-						break;
-					}
-					head = bucket->hb_keys[i].keyoffset;
-				}
-				if (!found) {
-					/* we should link in a new free slot for this node */
-					bucket->hb_keys[bucket->used].next = bucket->hb_keys[HASH_INDEX(keybucket)].next;
-					bucket->hb_keys[bucket->used].keyoffset = bucket->hb_keys[bucket->used-1].keyoffset;
-					keyfree = HASH_KEY(HASH_BLOCK(keybucket), bucket->used);
-					bucket->used++;
-				}
-			}
-			/* link 'keyfree' back to the parent ... */
-			if (keyprev == 0) {
-				hashroot->free = keyfree;
-				ibex_block_dirty((struct _block *)hashroot);
-			} else {
-				struct _hashblock *prevbucket;
-				prevbucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(keyprev));
-				prevbucket->hb_keys[HASH_INDEX(keyprev)].next = keyfree;
-				ibex_block_dirty((struct _block *)prevbucket);
-			}
-
-			/* link into the hash chain */
-			bucket->hb_keys[HASH_INDEX(keybucket)].next = hashbucket;
-			bucket->hb_keys[HASH_INDEX(keybucket)].root = 0;
-			bucket->hb_keys[HASH_INDEX(keybucket)].tail = 0;
-			table->buckets[hashentry] = keybucket;
-			ibex_block_dirty((struct _block *)table);
-			ibex_block_dirty((struct _block *)bucket);
-
-			d(printf(" new key id %d\n", keybucket));
-			d(printf(" new free id %d\n", hashroot->free));
-
-			return keybucket;
-		}
-
-		count++;
-		keyprev = keybucket;
-		keybucket = bucket->hb_keys[HASH_INDEX(keybucket)].next;
-	}
-
-	/* else create a new block ... */
-	keybucket = ibex_block_get(index->blocks);
-	bucket = (struct _hashblock *)ibex_block_read(index->blocks, keybucket);
-
-	d(printf("creating new key bucket %d\n", keybucket));
-
-	memset(bucket, 0, sizeof(*bucket));
-
-	bucket->used = 2;
-	/* first block, is the new key */
-	bucket->hb_keys[0].keyoffset = ARRAY_LEN(bucket->hb_keydata) - keylen;
-	memcpy(&bucket->hb_keydata[bucket->hb_keys[0].keyoffset], key, keylen);
-	bucket->hb_keys[0].next = hashbucket;
-	bucket->hb_keys[0].root = 0;
-	bucket->hb_keys[0].tail = 0;
-
-	table->buckets[hashentry] = HASH_KEY(keybucket, 0);
-
-	/* next block is a free block, link into free list */
-	bucket->hb_keys[1].keyoffset = bucket->hb_keys[0].keyoffset;
-	bucket->hb_keys[1].next = hashroot->free;
-	hashroot->free = HASH_KEY(keybucket, 1);
-
-	/* link new block into keys list */
-	bucket->next = block_number(hashroot->keys);
-	hashroot->keys = keybucket;
-
-	ibex_block_dirty((struct _block *)hashroot);
-	ibex_block_dirty((struct _block *)table);
-	ibex_block_dirty((struct _block *)bucket);
-
-	d(printf(" new key id %d\n", HASH_KEY(keybucket, 0)));
-	d(printf(" new free id %d\n", hashroot->free));
-
-	return HASH_KEY(keybucket, 0);
-}
-
-/* hash cursor functions */
-static struct _IBEXCursor *
-hash_cursor_create(struct _IBEXIndex *idx)
-{
-	struct _HASHCursor *idc;
-	struct _hashroot *hashroot;
-
-	idc = g_malloc(sizeof(*idc));
-	idc->cursor.klass = &ibex_hash_cursor_class;
-	idc->cursor.index = idx;
-	idc->key = 0;
-	idc->index = 0;
-
-	hashroot = (struct _hashroot *)ibex_block_read(idx->blocks, idx->root);
-	idc->size = hashroot->size;
-	idc->block = hashroot->keys;
-	
-	return &idc->cursor;
-}
-
-static void
-hash_cursor_close(struct _IBEXCursor *idc)
-{
-	g_free(idc);
-}
-
-static guint32
-hash_cursor_next(struct _IBEXCursor *idc)
-{
-	struct _HASHCursor *hc = (struct _HASHCursor *)idc;
-	struct _hashblock *bucket;
-
-	while (hc->block != 0) {
-		bucket = (struct _hashblock *)ibex_block_read(idc->index->blocks, hc->block);
-		while (hc->index < bucket->used) {
-			if (hash_info(idc->index, bucket, hc->index) > 0) {
-				hc->key = HASH_KEY(hc->block, hc->index);
-				hc->index++;
-				if (hc->index == bucket->used) {
-					hc->index = 0;
-					hc->block = block_location(bucket->next);
-				}
-				return hc->key;
-			}
-			hc->index++;
-		}
-		hc->index = 0;
-		hc->block = block_location(bucket->next);
-	}
-
-	return hc->block;
-}
-
-static char *
-hash_cursor_next_key(struct _IBEXCursor *idc, int *keylenptr)
-{
-	/* TODO: this could be made slightly mroe efficient going to the structs direct.
-	   but i'm lazy today */
-	return idc->index->klass->get_key(idc->index, idc->klass->next(idc), keylenptr);
-}
-
-/* debug */
-void ibex_hash_dump(struct _IBEXIndex *index);
-static void ibex_hash_dump_rec(struct _IBEXIndex *index, int *words, int *wordslen);
-
-void ibex_hash_dump(struct _IBEXIndex *index)
-{
-	int words = 0, wordslen=0;
-
-	ibex_hash_dump_rec(index, &words, &wordslen);
-
-	printf("Total words = %d, bytes = %d, ave length = %f\n", words, wordslen, (double)wordslen/(double)words);
-}
-
-
-static void
-ibex_hash_dump_rec(struct _IBEXIndex *index, int *words, int *wordslen)
-{
-	int i;
-	struct _hashtableblock *table;
-	struct _hashblock *bucket;
-	struct _hashroot *hashroot;
-	blockid_t hashtable;
-	hashid_t hashbucket;
-	extern void ibex_diskarray_dump(struct _memcache *blocks, blockid_t head, blockid_t tail);
-
-
-	printf("Walking hash tree:\n");
-	hashroot = (struct _hashroot *)ibex_block_read(index->blocks, index->root);
-	for (i=0;i<hashroot->size;i++) {
-		printf("Hash table chain: %d\n", i);
-		hashtable = hashroot->table[i / (BLOCK_SIZE/sizeof(blockid_t))];
-		table = (struct _hashtableblock *)ibex_block_read(index->blocks, hashtable);
-		hashbucket = table->buckets[i % (BLOCK_SIZE/sizeof(blockid_t))];
-		while (hashbucket) {
-			int len;
-
-			*words = *words + 1;
-
-			bucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(hashbucket));
-			printf(" bucket %d: [used %d]", hashbucket, bucket->used);
-			if (HASH_INDEX(hashbucket) == 0) {
-				len = ARRAY_LEN(bucket->hb_keydata) -
-					bucket->hb_keys[HASH_INDEX(hashbucket)].keyoffset;
-			} else {
-				len = bucket->hb_keys[HASH_INDEX(hashbucket)-1].keyoffset -
-					bucket->hb_keys[HASH_INDEX(hashbucket)].keyoffset;
-			}
-			printf("'%.*s' = %d next=%d\n", len, &bucket->hb_keydata[bucket->hb_keys[HASH_INDEX(hashbucket)].keyoffset],
-			       bucket->hb_keys[HASH_INDEX(hashbucket)].root,
-			       bucket->hb_keys[HASH_INDEX(hashbucket)].next);
-
-			*wordslen = *wordslen + len;
-
-			ibex_diskarray_dump(index->blocks,
-					    bucket->hb_keys[HASH_INDEX(hashbucket)].root << BLOCK_BITS,
-					    bucket->hb_keys[HASH_INDEX(hashbucket)].tail);
-
-			hashbucket = bucket->hb_keys[HASH_INDEX(hashbucket)].next;
-		}
-		/* make sure its still in the cache */
-		hashroot = (struct _hashroot *)ibex_block_read(index->blocks, index->root);
-	}
-
-	hashbucket = hashroot->free;
-	printf("Dumping free lists ..\n");
-	while (hashbucket) {
-		printf(" %d", hashbucket);
-		bucket = (struct _hashblock *)ibex_block_read(index->blocks, HASH_BLOCK(hashbucket));
-		hashbucket = bucket->hb_keys[HASH_INDEX(hashbucket)].next;
-	}
-	printf("\n");
-}
-
-#if 0
-int main(int argc, char **argv)
-{
-	struct _memcache *bc;
-	struct _IBEXIndex *hash;
-	int i;
-
-	bc = ibex_block_cache_open("index.db", O_CREAT|O_RDWR, 0600);
-	hash = ibex_hash_class.create(bc, 1024);
-	for (i=0;i<10000;i++) {
-		char key[16];
-		sprintf(key, "key %d", i);
-		ibex_hash_class.insert(hash, key, strlen(key));
-	}
-
-	for (i=500;i<1000;i++) {
-		char key[16];
-		sprintf(key, "key %d", i);
-		ibex_hash_class.remove(hash, key, strlen(key));
-	}
-
-	for (i=500;i<1000;i++) {
-		char key[16];
-		sprintf(key, "key %d", i);
-		ibex_hash_class.insert(hash, key, strlen(key));
-	}
-
-
-	ibex_hash_dump(hash);
-
-	for (i=0;i<2000;i++) {
-		char key[16], *lookup;
-		hashid_t keyid;
-		blockid_t root, tail;
-
-		sprintf(key, "key %d", i);
-		keyid = ibex_hash_class.find(hash, key, strlen(key));
-		lookup = ibex_hash_class.get_key(hash, keyid, 0);
-		root = ibex_hash_class.get_data(hash, keyid, &tail);
-		printf("key %s = %d = '%s' root:%d tail:%d \n", key, keyid, lookup, root, tail);
-		g_free(lookup);
-	}
-
-	ibex_hash_class.close(hash);
-	ibex_block_cache_close(bc);
-	return 0;
-}
-
-#endif
diff --git a/libibex/ibex.h b/libibex/ibex.h
deleted file mode 100644
index aafa6e734c..0000000000
--- a/libibex/ibex.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*
- * Copyright (C) 2000 Ximian, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#ifndef IBEX_H
-#define IBEX_H
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <glib.h>
-
-struct ibex;
-typedef struct ibex ibex;
-
-/* All functions that can fail set errno and return NULL or -1 on
- * failure.
- */
-
-/* Open the named ibex index file. If CREATE is true, create the file
- * if it doesn't already exist.
- */
-ibex *ibex_open (char *file, int flags, int mode);
-
-/* Write the ibex to disk. */
-int ibex_write (ibex *ib);
-
-/* only save if ibex has changed. */
-int ibex_save (ibex *ib);
-
-/* rename an ibex file to a new location */
-int ibex_move (ibex *ib, const char *newname);
-
-/* Write the ibex to disk if it has changed, and free all memory
- * associated with it.
- */
-int ibex_close (ibex *ib);
-
-
-
-/* Index the named file. (If the FILENAME is already in the index,
- * remove the old copy.
- */
-int ibex_index_file (ibex *ib, char *filename);
-
-/* Index LEN bytes off FD, using NAME as the filename in the index.
- * (If NAME already exists in the index, this adds more data to it.)
- */
-int ibex_index_fd (ibex *ib, char *name, int fd, size_t len);
-
-/* Like ibex_index_fd, but with a buffer rather than a file descriptor.
- * The buffer does not need to be '\0'-terminated. If UNREAD is not
- * NULL, then the indexer won't assume that the buffer ends on a word
- * boundary, and will return (in UNREAD) the number of bytes from the
- * end of the buffer that it didn't use, if any.
- */
-int ibex_index_buffer (ibex *ib, char *name, char *buffer,
-		       size_t len, size_t *unread);
-
-/* Remove entries for a given file from the index. (Most of the removal
- * isn't actually done until the file is written out to disk, so this
- * is very fast.)
- */
-void ibex_unindex (ibex *ib, char *name);
-
-/* Rename a file in the index. (This is also fast.) */
-void ibex_rename (ibex *ib, char *oldfilename, char *newfilename);
-
-
-
-/* Find a word in the index. Returns an array of strings: the caller
- * should free the array, but should not free or modify the strings.
- */
-GPtrArray *ibex_find (ibex *ib, char *word);
-
-/* Find if a word is contained in a specific name reference.
- */
-gboolean ibex_find_name (ibex *ib, char *name, char *word);
-
-/* has a file been indexed?
- */
-gboolean ibex_contains_name(ibex *ib, char *name);
-
-/* Return all the files containing all of the words in the given
- * array. Returned data is like with ibex_find.
- */
-GPtrArray *ibex_find_all (ibex *ib, GPtrArray *words);
-
-/* Debug function, dumps the whole index tree, showing removed files as well */
-void ibex_dump_all (ibex *ib);
-
-#endif /* ! IBEX_H */
-
diff --git a/libibex/ibex_block.c b/libibex/ibex_block.c
deleted file mode 100644
index 054a8791cf..0000000000
--- a/libibex/ibex_block.c
+++ /dev/null
@@ -1,649 +0,0 @@
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <glib.h>
-
-#include <stdio.h>
-#include <gal/unicode/gunicode.h>
-#include <ctype.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-
-#include "ibex_internal.h"
-
-#define d(x)
-#define o(x) 
-
-static void ibex_reset(ibex *ib);
-static int close_backend(ibex *ib);
-
-static struct _list ibex_list = { (struct _listnode *)&ibex_list.tail, 0, (struct _listnode *)&ibex_list.head };
-static int ibex_open_init = 0;
-static int ibex_open_threshold = IBEX_OPEN_THRESHOLD;
-
-#ifdef ENABLE_THREADS
-#include <pthread.h>
-static pthread_mutex_t ibex_list_lock = PTHREAD_MUTEX_INITIALIZER;
-static int ibex_opened;		/* count of actually opened ibexe's */
-#define IBEX_LIST_LOCK(ib) (pthread_mutex_lock(&ibex_list_lock))
-#define IBEX_LIST_UNLOCK(ib) (pthread_mutex_unlock(&ibex_list_lock))
-#else
-#define IBEX_LIST_LOCK(ib) 
-#define IBEX_LIST_UNLOCK(ib) 
-#endif
-
-/* check we are open properly */
-
-/* TODO: return errors? */
-static void ibex_use(ibex *ib)
-{
-	ibex *wb, *wn;
-
-	/* always lock list then ibex */
-	IBEX_LIST_LOCK(ib);
-
-	if (ib->blocks == NULL) {
-		o(printf("Delayed opening ibex '%s', total = %d\n", ib->name, ibex_opened+1));
-
-		ib->blocks = ibex_block_cache_open(ib->name, ib->flags, ib->mode);
-		if (ib->blocks) {
-			/* FIXME: the blockcache or the wordindex needs to manage the other one */
-			ib->words = ib->blocks->words;		
-		} else {
-			ib->words = NULL;
-			g_warning("ibex_use:open(): Error occured?: %s\n", strerror(errno));
-		}
-		if (ib->blocks != NULL)
-			ibex_opened++;
-	}
-
-	ib->usecount++;
-
-	/* this makes an 'lru' cache of used files */
-	ibex_list_remove((struct _listnode *)ib);
-	ibex_list_addtail(&ibex_list, (struct _listnode *)ib);
-
-	/* check env variable override for open threshold */
-	if (!ibex_open_init) {
-		char *limit;
-
-		ibex_open_init = TRUE;
-		limit = getenv("IBEX_OPEN_THRESHOLD");
-		if (limit) {
-			ibex_open_threshold = atoi(limit);
-			if (ibex_open_threshold < IBEX_OPEN_THRESHOLD)
-				ibex_open_threshold = IBEX_OPEN_THRESHOLD;
-		}
-	}
-
-	/* check for other ibex's we can close now to not over-use fd's.
-	   we can't do this first for locking issues */
-	wb = (ibex *)ibex_list.head;
-	wn = wb->next;
-	while (wn && ibex_opened > ibex_open_threshold) {
-		if (wb != ib && IBEX_TRYLOCK(wb) == 0) {
-			if (wb->usecount == 0 && wb->blocks != NULL) {
-				o(printf("Forcing close of obex '%s', total = %d\n", wb->name, ibex_opened-1));
-				close_backend(wb);
-				ibex_opened--;
-			}
-			IBEX_UNLOCK(wb);
-		}
-		wb = wn;
-		wn = wn->next;
-	}
-
-	IBEX_LIST_UNLOCK(ib);
-}
-
-static void ibex_unuse(ibex *ib)
-{
-	ib->usecount--;
-}
-
-static signed char utf8_trans[] = {
-	'A', 'A', 'A', 'A', 'A', 'A', -1, 'C', 'E', 'E', 'E', 'E', 'I', 'I',
-	'I', 'I', -2, 'N', 'O', 'O', 'O', 'O', 'O', '*', 'O', 'U', 'U', 'U',
-	'U', 'Y', -3, -4, 'a', 'a', 'a', 'a', 'a', 'a', -5, 'c', 'e', 'e',
-	'e', 'e', 'i', 'i', 'i', 'i', -6, 'n', 'o', 'o', 'o', 'o', 'o', '/',
-	'o', 'u', 'u', 'u', 'u', 'y', -7, 'y', 'A', 'a', 'A', 'a', 'A', 'a',
-	'C', 'c', 'C', 'c', 'C', 'c', 'C', 'c', 'D', 'd', 'D', 'd', 'E', 'e',
-	'E', 'e', 'E', 'e', 'E', 'e', 'E', 'e', 'G', 'g', 'G', 'g', 'G', 'g',
-	'G', 'g', 'H', 'h', 'H', 'h', 'I', 'i', 'I', 'i', 'I', 'i', 'I', 'i',
-	'I', 'i', -8, -9, 'J', 'j', 'K', 'k', 'k', 'L', 'l', 'L', 'l', 'L',
-	'l', 'L', 'l', 'L', 'l', 'N', 'n', 'N', 'n', 'N', 'n', 'n', -10, -11,
-	'O', 'o', 'O', 'o', 'O', 'o', -12, -13, 'R', 'r', 'R', 'r', 'R', 'r',
-	'S', 'r', 'S', 's', 'S', 's', 'S', 's', 'T', 't', 'T', 't', 'T', 't',
-	'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u', 'W', 'w',
-	'Y', 'y', 'Y', 'Z', 'z', 'Z', 'z', 'Z', 'z', 's'
-};
-
-static char *utf8_long_trans[] = {
-	"AE", "TH", "TH", "ss", "ae", "th", "th", "IJ", "ij",
-	"NG", "ng", "OE", "oe"
-};
-
-/* This is a bit weird. It takes pointers to the start and end (actually
- * just past the end) of a UTF-8-encoded word, and a buffer at least 1
- * byte longer than the length of the word. It copies the word into the
- * buffer in all lowercase without accents, and splits up ligatures.
- * (Since any ligature would be a multi-byte character in UTF-8, splitting
- * them into two US-ASCII characters won't overrun the buffer.)
- *
- * It is not safe to call this routine with bad UTF-8.
- */
-static void
-ibex_normalise_word(char *start, char *end, char *buf)
-{
-	unsigned char *s, *d;
-	gunichar uc;
-
-	s = (unsigned char *)start;
-	d = (unsigned char *)buf;
-	while (s < (unsigned char *)end) {
-		if (*s < 0x80) {
-			/* US-ASCII character: copy unless it's
-			 * an apostrophe.
-			 */
-			if (*s != '\'')
-				*d++ = tolower (*s);
-			s++;
-		} else {
-			char *next = g_utf8_next_char (s);
-			uc = g_utf8_get_char (s);
-			if (uc >= 0xc0 && uc < 0xc0 + sizeof (utf8_trans)) {
-				signed char ch = utf8_trans[uc - 0xc0];
-				if (ch > 0)
-					*d++ = tolower (ch);
-				else {
-					*d++ = tolower (utf8_long_trans[-ch - 1][0]);
-					*d++ = tolower (utf8_long_trans[-ch - 1][1]);
-				}
-				s = next;
-			} else {
-				while (s < (unsigned char *)next)
-					*d++ = *s++;
-			}
-		}
-	}
-	*d = '\0';
-}
-
-enum { IBEX_ALPHA, IBEX_NONALPHA, IBEX_INVALID, IBEX_INCOMPLETE };
-
-static int
-utf8_category (char *p, char **np, char *end)
-{
-	if (isascii ((unsigned char)*p)) {
-		*np = p + 1;
-		if (isalpha ((unsigned char)*p) || *p == '\'')
-			return IBEX_ALPHA;
-		return IBEX_NONALPHA;
-	} else {
-		gunichar uc;
-
-		*np = g_utf8_find_next_char (p, end);
-		if (!*np)
-			return IBEX_INCOMPLETE;
-		uc = g_utf8_get_char (p);
-		if (uc == (gunichar) -1)
-			return IBEX_INVALID;
-		else if (g_unichar_isalpha (uc))
-			return IBEX_ALPHA;
-		else
-			return IBEX_NONALPHA;
-	}
-}
-
-/**
- * ibex_index_buffer: the lowest-level ibex indexing interface
- * @ib: an ibex
- * @name: the name of the file being indexed
- * @buffer: a buffer containing data from the file
- * @len: the length of @buffer
- * @unread: an output argument containing the number of unread bytes
- *
- * This routine indexes up to @len bytes from @buffer into @ib.
- * If @unread is NULL, the indexer assumes that the buffer ends on a
- * word boundary, and will index all the way to the end of the
- * buffer. If @unread is not NULL, and the buffer ends with an
- * alphabetic character, the indexer will assume that the buffer has
- * been cut off in the middle of a word, and return the number of
- * un-indexed bytes at the end of the buffer in *@unread. The caller
- * should then read in more data through whatever means it has
- * and pass in the unread bytes from the original buffer, followed
- * by the new data, on its next call.
- *
- * Return value: 0 on success, -1 on failure.
- **/
-int
-ibex_index_buffer (ibex *ib, char *name, char *buffer, size_t len, size_t *unread)
-{
-	char *p, *q, *nq, *end;
-	char *word;
-	int wordsiz, cat = 0;
-	GHashTable *words = g_hash_table_new(g_str_hash, g_str_equal);
-	GPtrArray *wordlist = g_ptr_array_new();
-	int i, ret=-1;
-
-	if (unread)
-		*unread = 0;
-
-	end = buffer + len;
-	wordsiz = 20;
-	word = g_malloc (wordsiz);
-
-	p = buffer;
-	while (p < end) {
-		while (p < end) {
-			cat = utf8_category (p, &q, end);
-			if (cat != IBEX_NONALPHA)
-				break;
-			p = q;
-		}
-		if (p == end) {
-			goto done;
-		} else if (cat == IBEX_INVALID) {
-			goto error;
-		} else if (cat == IBEX_INCOMPLETE)
-			q = end;
-
-		while (q < end) {
-			cat = utf8_category (q, &nq, end);
-			if (cat != IBEX_ALPHA)
-				break;
-			q = nq;
-		}
-		if (cat == IBEX_INVALID ||
-		    (cat == IBEX_INCOMPLETE && !unread)) {
-			goto error;
-		} else if (cat == IBEX_INCOMPLETE || (q == end && unread)) {
-			*unread = end - p;
-			goto done;
-		}
-
-		if (wordsiz < q - p + 1) {
-			wordsiz = q - p + 1;
-			word = g_realloc (word, wordsiz);
-		}
-		ibex_normalise_word (p, q, word);
-		if (word[0]) {
-			if (g_hash_table_lookup(words, word) == 0) {
-				char *newword = g_strdup(word);
-				g_ptr_array_add(wordlist, newword);
-				g_hash_table_insert(words, newword, name);
-			}
-		}
-		p = q;
-	}
-done:
-	/* this weird word=NULL shit is to get rid of compiler warnings about clobbering with longjmp */
-	g_free(word);
-	word = NULL;
-
-	IBEX_LOCK(ib);
-
-	ibex_use(ib);
-
-	if (ibex_block_cache_setjmp(ib->blocks) != 0) {
-		printf("Error in indexing\n");
-		ret = -1;
-		ibex_reset(ib);
-		word = NULL;	/* here too */
-	} else {
-		word = NULL;	/* ... and here */
-		d(printf("name %s count %d size %d\n", name, wordlist->len, len));
-		if (!ib->predone) {
-			ib->words->klass->index_pre(ib->words);
-			ib->predone = TRUE;
-		}
-		ib->words->klass->add_list(ib->words, name, wordlist);
-		ret = 0;
-	}
-
-	ibex_unuse(ib);
-
-	IBEX_UNLOCK(ib);
-
-error:
-	for (i=0;i<wordlist->len;i++)
-		g_free(wordlist->pdata[i]);
-	g_ptr_array_free(wordlist, TRUE);
-	g_hash_table_destroy(words);
-	g_free(word);
-	return ret;
-}
-
-
-/**
- * ibex_open:
- * @file: 
- * @flags: 
- * @mode: 
- * 
- * Open a new ibex file.  file, flags, and mode as for open(2)
- * 
- * Return value: A new ibex, or NULL on failure.
- **/
-ibex *ibex_open (char *file, int flags, int mode)
-{
-	ibex *ib;
-
-	ib = g_malloc0(sizeof(*ib));
-	ib->blocks = NULL;
-	ib->usecount = 0;
-#if 0
-	ib->blocks = ibex_block_cache_open(file, flags, mode);
-	if (ib->blocks == 0) {
-		g_warning("create: Error occured?: %s\n", strerror(errno));
-		g_free(ib);
-		return NULL;
-	}
-	/* FIXME: the blockcache or the wordindex needs to manage the other one */
-	ib->words = ib->blocks->words;
-#endif
-	ib->name = g_strdup(file);
-	ib->flags = flags;
-	ib->mode = mode;
-
-#ifdef ENABLE_THREADS
-	pthread_mutex_init(&ib->lock, NULL);
-#endif
-
-	IBEX_LIST_LOCK(ib);
-	ibex_list_addtail(&ibex_list, (struct _listnode *)ib);
-	IBEX_LIST_UNLOCK(ib);
-
-	return ib;
-}
-
-/**
- * ibex_save:
- * @ib: 
- * 
- * Save (sync) an ibex file to disk.
- * 
- * Return value: -1 on failure.
- **/
-int ibex_save (ibex *ib)
-{
-	int ret;
-
-	d(printf("syncing database\n"));
-
-	IBEX_LOCK(ib);
-
-	ibex_use(ib);
-
-	if (ibex_block_cache_setjmp(ib->blocks) != 0) {
-		ibex_reset(ib);
-		printf("Error saving\n");
-		ret = -1;
-	} else {
-		if (ib->predone) {
-			ib->words->klass->index_post(ib->words);
-			ib->predone = FALSE;
-		}
-		ib->words->klass->sync(ib->words);
-		/* FIXME: some return */
-		ibex_block_cache_sync(ib->blocks);
-		ret = 0;
-	}
-
-	ibex_unuse(ib);
-
-	IBEX_UNLOCK(ib);
-
-	return ret;
-}
-
-static int
-close_backend(ibex *ib)
-{
-	int ret;
-
-	if (ib->blocks == 0)
-		return 0;
-
-	if (ibex_block_cache_setjmp(ib->blocks) != 0) {
-		printf("Error closing!\n");
-		ret = -1;
-	} else {
-		if (ib->predone) {
-			ib->words->klass->index_post(ib->words);
-			ib->predone = FALSE;
-		}
-
-		ib->words->klass->close(ib->words);
-		/* FIXME: return */
-		ibex_block_cache_close(ib->blocks);
-		ib->blocks = NULL;
-		ret = 0;
-	}
-
-	return ret;
-}
-
-/* close/reopen the ibex file, assumes we have lock */
-static void
-ibex_reset(ibex *ib)
-{
-	g_warning("resetting ibex file");
-
-	close_backend(ib);
-
-	ib->blocks = ibex_block_cache_open(ib->name, ib->flags, ib->mode);
-	if (ib->blocks == 0) {
-		g_warning("ibex_reset create: Error occured?: %s\n", strerror(errno));
-	} else {
-		/* FIXME: the blockcache or the wordindex needs to manage the other one */
-		ib->words = ib->blocks->words;
-	}
-}
-
-/**
- * ibex_close:
- * @ib: 
- * 
- * Close (and save) an ibex file, restoring all resources used.
- * 
- * Return value: -1 on error.  In either case, ibex is no longer
- * defined afterwards.
- **/
-int ibex_close (ibex *ib)
-{
-	int ret;
-
-	d(printf("closing database\n"));
-
-	g_assert(ib->usecount == 0);
-
-	IBEX_LIST_LOCK(ib);
-	ibex_list_remove((struct _listnode *)ib);
-	IBEX_LIST_UNLOCK(ib);
-
-	if (ib->blocks != NULL)
-		ret = close_backend(ib);
-	else
-		ret = 0;
-
-	g_free(ib->name);
-
-#ifdef ENABLE_THREADS
-	pthread_mutex_destroy(&ib->lock);
-#endif
-
-	g_free(ib);
-
-	return ret;
-}
-
-/* rename/move the ibex file */
-int ibex_move(ibex *ib, const char *newname)
-{
-	int ret = 0, error = 0;
-	struct stat st;
-
-	IBEX_LOCK(ib);
-
-	if (ib->blocks)
-		close_backend(ib);
-
-	if (stat(ib->name, &st) == -1 && errno == ENOENT) {
-		error = 0;
-	} else if (rename(ib->name, newname) == -1) {
-		g_warning("could not rename ibex file '%s' to '%s': '%s'", ib->name, newname, strerror(errno));
-		ret = -1;
-		error = errno;
-	}
-
-	g_free(ib->name);
-	ib->name = g_strdup(newname);
-
-	IBEX_UNLOCK(ib);
-
-	if (ret == -1)
-		errno = error;
-
-	return ret;
-}
-
-
-/**
- * ibex_unindex:
- * @ib: 
- * @name: 
- * 
- * Remove a name from the index.
- **/
-void ibex_unindex (ibex *ib, char *name)
-{
-	d(printf("trying to unindex '%s'\n", name));
-
-	IBEX_LOCK(ib);
-
-	ibex_use(ib);
-
-	if (ibex_block_cache_setjmp(ib->blocks) != 0) {
-		printf("Error unindexing!\n");
-		ibex_reset(ib);
-	} else {
-		ib->words->klass->unindex_name(ib->words, name);
-	}
-
-	ibex_unuse(ib);
-
-	IBEX_UNLOCK(ib);
-}
-
-/**
- * ibex_find:
- * @ib: 
- * @word: 
- * 
- * Find all names containing @word.
- * 
- * Return value: 
- **/
-GPtrArray *ibex_find (ibex *ib, char *word)
-{
-	char *normal;
-	int len;
-	GPtrArray *ret;
-
-	len = strlen(word);
-	normal = alloca(len+1);
-	ibex_normalise_word(word, word+len, normal);
-
-	IBEX_LOCK(ib);
-	ibex_use(ib);
-
-	if (ibex_block_cache_setjmp(ib->blocks) != 0) {
-		ibex_reset(ib);
-		ret = NULL;
-	} else {
-		ret = ib->words->klass->find(ib->words, normal);
-	}
-
-	ibex_unuse(ib);
-	IBEX_UNLOCK(ib);
-
-	return ret;
-}
-
-/**
- * ibex_find_name:
- * @ib: 
- * @name: 
- * @word: 
- * 
- * Return #TRUE if the specific @word is contained in @name.
- * 
- * Return value: 
- **/
-gboolean ibex_find_name (ibex *ib, char *name, char *word)
-{
-	char *normal;
-	int len;
-	gboolean ret;
-
-	len = strlen(word);
-	normal = alloca(len+1);
-	ibex_normalise_word(word, word+len, normal);
-
-	IBEX_LOCK(ib);
-	ibex_use(ib);
-
-	if (ibex_block_cache_setjmp(ib->blocks) != 0) {
-		ibex_reset(ib);
-		ret = FALSE;
-	} else {
-		ret = ib->words->klass->find_name(ib->words, name, normal);
-	}
-
-	ibex_unuse(ib);
-	IBEX_UNLOCK(ib);
-
-	return ret;
-}
-
-/**
- * ibex_contains_name:
- * @ib: 
- * @name: 
- * 
- * Returns true if the name @name is somewhere in the database.
- * 
- * Return value: 
- **/
-gboolean ibex_contains_name(ibex *ib, char *name)
-{
-	gboolean ret;
-
-	IBEX_LOCK(ib);
-	ibex_use(ib);
-
-	if (ibex_block_cache_setjmp(ib->blocks) != 0) {
-		ibex_reset(ib);
-		ret = FALSE;
-	} else {
-		ret = ib->words->klass->contains_name(ib->words, name);
-	}
-
-	ibex_unuse(ib);
-	IBEX_UNLOCK(ib);
-
-	return ret;
-}
-
diff --git a/libibex/ibex_internal.h b/libibex/ibex_internal.h
deleted file mode 100644
index aaba414d37..0000000000
--- a/libibex/ibex_internal.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*
- * Copyright (C) 2000 Ximian, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#include "config.h"
-
-#include <e-util/e-msgport.h>
-#include <glib.h>
-
-#include "ibex.h"
-#include "block.h"
-#include "wordindex.h"
-
-#ifdef ENABLE_THREADS
-#include <pthread.h>
-#endif
-
-struct ibex {
-	struct ibex *next;	/* for list of open ibex's */
-	struct ibex *prev;
-
-	int usecount;
-
-	char *name;
-	int flags;
-	int mode;
-	struct _memcache *blocks;
-	struct _IBEXWord *words;
-	int predone;
-
-#ifdef ENABLE_THREADS
-	pthread_mutex_t lock;
-#endif
-	
-};
-
-#define IBEX_OPEN_THRESHOLD (15)
-
-#ifdef ENABLE_THREADS
-/*#define IBEX_LOCK(ib) (printf(__FILE__ "%d: %s: locking ibex\n", __LINE__, __FUNCTION__), g_mutex_lock(ib->lock))
-  #define IBEX_UNLOCK(ib) (printf(__FILE__ "%d: %s: unlocking ibex\n", __LINE__, __FUNCTION__), g_mutex_unlock(ib->lock))*/
-#define IBEX_LOCK(ib) (pthread_mutex_lock(&ib->lock))
-#define IBEX_UNLOCK(ib) (pthread_mutex_unlock(&ib->lock))
-#define IBEX_TRYLOCK(ib) (pthread_mutex_trylock(&ib->lock))
-#else
-#define IBEX_LOCK(ib) 
-#define IBEX_UNLOCK(ib) 
-#define IBEX_TRYLOCK(ib) (0)
-#endif
-
diff --git a/libibex/index.h b/libibex/index.h
deleted file mode 100644
index 432c82cff8..0000000000
--- a/libibex/index.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
- *
- * Copyright (C) 2000 Ximian, Inc.
- *
- * Authors: Michael Zucchi <notzed@ximian.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#ifndef _INDEX_H
-#define _INDEX_H
-
-/* an indexing 'class' maps a key to 1 piece of info */
-
-/*#define INDEX_STAT*/
-
-struct _IBEXCursor {
-	struct _IBEXCursorClass *klass;
-	struct _IBEXIndex *index;
-};
-
-struct _IBEXCursorClass {
-	void (*close)(struct _IBEXCursor *);
-
-	guint32 (*next)(struct _IBEXCursor *);
-	char *(*next_key)(struct _IBEXCursor *, int *keylenptr);
-};
-
-struct _IBEXIndex {
-	struct _IBEXIndexClass *klass;
-	struct _memcache *blocks;
-	blockid_t root;		/* root block of ondisk index data */
-#ifdef INDEX_STAT
-	int lookups;		/* how many lookups */
-	int lookup_total;	/* how many blocks loaded for all lookups (hash chain depth) */
-#endif
-};
-
-struct _IBEXIndexClass {
-
-	struct _IBEXIndex *(*create)(struct _memcache *bc, int size);
-	struct _IBEXIndex *(*open)(struct _memcache *bc, blockid_t root);
-
-	int (*sync)(struct _IBEXIndex *);
-	int (*close)(struct _IBEXIndex *);
-
-	/* lookup a key in the index, returns the keyid of this item, or 0 if not found */
-	guint32 (*find)(struct _IBEXIndex *, const char *key, int keylen);
-
-	/* remove a key from the index */
-	void (*remove)(struct _IBEXIndex *, const char *key, int keylen);
-
-	/* insert a new key into the index, the keyid is returned */
-	guint32 (*insert)(struct _IBEXIndex *, const char *key, int keylen);
-
-	/* get the key contents/key length from the keyid */
-	char *(*get_key)(struct _IBEXIndex *, guint32 keyid, int *keylenptr);
-
-	/* set the key contents based on the keyid */
-	void (*set_data)(struct _IBEXIndex *, guint32 keyid, blockid_t datablock, blockid_t tail);
-
-	/* get the key contents based on the keyid */
-	blockid_t (*get_data)(struct _IBEXIndex *, guint32 keyid, blockid_t *tail);
-
-	/* get a cursor for iterating over all contents */
-	struct _IBEXCursor *(*get_cursor)(struct _IBEXIndex *);
-};
-
-/* a storage class, stores lists of lists of id's */
-
-struct _IBEXStore {
-	struct _IBEXStoreClass *klass;
-	struct _memcache *blocks;
-};
-
-struct _IBEXStoreClass {
-	struct _IBEXStore *(*create)(struct _memcache *bc);
-	int (*sync)(struct _IBEXStore *store);
-	int (*close)(struct _IBEXStore *store);
-
-	blockid_t (*add)(struct _IBEXStore *store, blockid_t *head, blockid_t *tail, nameid_t data);
-	blockid_t (*add_list)(struct _IBEXStore *store, blockid_t *head, blockid_t *tail, GArray *data);
-	blockid_t (*remove)(struct _IBEXStore *store, blockid_t *head, blockid_t *tail, nameid_t data);
-	void (*free)(struct _IBEXStore *store, blockid_t head, blockid_t tail);
-
-	gboolean (*find)(struct _IBEXStore *store, blockid_t head, blockid_t tail, nameid_t data);
-	GArray *(*get)(struct _IBEXStore *store, blockid_t head, blockid_t tail);
-};
-
-#endif
diff --git a/libibex/testindex.c b/libibex/testindex.c
deleted file mode 100644
index 064ff1b7ac..0000000000
--- a/libibex/testindex.c
+++ /dev/null
@@ -1,320 +0,0 @@
-/* Test code for libibex */
-
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-#include <glib.h>
-#include "ibex_internal.h"
-
-#ifdef ENABLE_THREADS
-#include <pthread.h>
-#endif
-
-#define TIMEIT
-/*#define DO_MCHECK*/
-
-#ifdef TIMEIT
-#include <sys/time.h>
-#include <unistd.h>
-#endif
-
-#ifdef DO_MCHECK
-#include <mcheck.h>
-#endif
-
-void word_index_mem_dump_info(struct _IBEXWord *idx);
-
-/*
-  The following is a routine to generate a Gaussian distribution
-  of pseudo random numbers, to make the results a little more
-  meaningful
-*/
-
-/* boxmuller.c           Implements the Polar form of the Box-Muller
-                         Transformation
-
-                      (c) Copyright 1994, Everett F. Carter Jr.
-                          Permission is granted by the author to use
-                          this software for any application provided this
-                          copyright notice is preserved.
-
-*/
-
-#include <stdlib.h>
-#include <math.h>
-
-#define ranf() ((float)rand()/(float)RAND_MAX)
-
-static float box_muller(float m, float s)      /* normal random variate generator */
-{                                       /* mean m, standard deviation s */
-        float x1, x2, w, y1;
-        static float y2;
-        static int use_last = 0;
-
-        if (use_last)                   /* use value from previous call */
-        {
-                y1 = y2;
-                use_last = 0;
-        }
-        else
-        {
-                do {
-                        x1 = 2.0 * ranf() - 1.0;
-                        x2 = 2.0 * ranf() - 1.0;
-                        w = x1 * x1 + x2 * x2;
-                } while ( w >= 1.0 );
-
-                w = sqrt( (-2.0 * log( w ) ) / w );
-                y1 = x1 * w;
-                y2 = x2 * w;
-                use_last = 1;
-        }
-
-        return( m + y1 * s );
-}
-
-/* gets a word from words, using m and s as distribution values */
-static char *getword(GPtrArray *words, float m, float s)
-{
-	int index;
-
-	do {
-		index = (int)box_muller(m, s);
-	} while (index<0 || index>=words->len);
-
-	return words->pdata[index];
-}
-
-#ifdef ENABLE_THREADS
-int do_read_words;
-
-static void *
-read_words(void *in)
-{
-	ibex *ib = in;
-	GPtrArray *a;
-	int lastlen = 0;
-	int i;
-
-	while (do_read_words) {
-		a = ibex_find(ib, "joneses");
-		if (a->len != lastlen) {
-			printf("Found %d joneses!\n", a->len);
-			lastlen = a->len;
-		}
-		for (i=0;i<a->len;i++)
-			g_free(a->pdata[i]);
-		g_ptr_array_free(a, TRUE);
-	}
-}
-#endif
-
-
-
-#ifdef DO_MCHECK
-static int blowup(int status)
-{
-	switch(status) {
-	case 1:
-		printf("Double free failure\n");
-		break;
-	case 2:
-		printf("Memory clobbered before block\n");
-		break;
-	case 3:
-		printf("Memory clobbered after block\n");
-		break;
-	}
-	abort();
-	return status;
-}
-#endif
-
-int main(int argc, char **argv)
-{
-	int i, j;
-	GPtrArray *words;
-	char line[256];
-	int len;
-	FILE *file;
-	float m, s;
-	ibex *ib;
-	GString *buffer;
-	int files;
-	char *dict;
-	int synccount;
-#ifdef TIMEIT
-	struct timeval start, end;
-	unsigned long diff;
-#endif
-#ifdef ENABLE_THREADS
-	pthread_t id;
-#endif
-
-#ifdef DO_MCHECK
-	mcheck(blowup);
-#endif
-	words = g_ptr_array_new();
-	buffer = g_string_new("");
-
-#ifdef ENABLE_THREADS
-	g_thread_init(0);
-#undef ENABLE_THREADS
-#endif
-
-#ifdef TIMEIT
-	gettimeofday(&start, NULL);
-#endif
-
-	srand(0xABADF00D);
-
-	synccount = 1000;
-	files = 8000;
-	dict = "/usr/dict/words";
-
-	/* read words into an array */
-	file = fopen(dict, "r");
-	if (file == NULL) {
-		fprintf(stderr, "Cannot open word file: %s: %s\n", dict, strerror(errno));
-		return 1;
-	}
-	while (fgets(line, sizeof(line), file) != NULL) {
-		len = strlen(line);
-		if (len>0 && line[len-1]=='\n') {
-			line[len-1]=0;
-		}
-		g_ptr_array_add(words, g_strdup(line));
-	}
-	fclose(file);
-	
-	fprintf(stderr, "Read %d words\n", words->len);
-
-	/* *shrug* arbitrary values really */
-	m = words->len/2;
-	/* well, the average vocabulary of a mailbox is about 10K words */
-	s = 1000.0;
-
-	printf("mean is %f, s is %f\n", m, s);
-
-	/* open ibex file */
-	ib = ibex_open("test.ibex", O_RDWR|O_CREAT, 0600);
-	if (ib == NULL) {
-		perror("Creating ibex file\n");
-		return 1;
-	}
-
-#ifdef ENABLE_THREADS
-	do_read_words = 1;
-	pthread_create(&id, 0, read_words, ib);
-#endif
-	printf("Adding %d files\n", files);
-
-	
-	/* simulate adding new words to a bunch of files */
-	for (j=0;j<200000;j++) {
-		/* always new name */
-		char *name;
-		/* something like 60 words in a typical message, say */
-		int count = (int)box_muller(60.0, 20.0);
-		int word = (int)box_muller(m, 4000);
-		GPtrArray *a;
-		static int lastlen = 0;
-
-		/* random name */
-		name = words->pdata[word % words->len];
-
-		if (j%1000 == 0 && j>0) {
-			IBEX_LOCK(ib);
-			word_index_mem_dump_info(ib->words);
-			IBEX_UNLOCK(ib);
-		}
-
-		/* lookup word just to test lookup */
-		a = ibex_find(ib, name);
-		if (a) {
-			for (i=0;i<a->len;i++)
-				g_free(a->pdata[i]);
-			g_ptr_array_free(a, TRUE);
-		}
-
-		/* half the time, remove items from the index */
-		if (rand() < RAND_MAX/2) {
-			ibex_unindex(ib, name);
-		} else {
-			/* cache the name info */
-			ibex_contains_name(ib, name);
-
-			/*printf("Adding %d words to '%s'\n", count, name);*/
-
-			g_string_truncate(buffer, 0);
-
-			/* build up the word buffer */
-			for (i=0;i<count;i++) {
-				if (i>0)
-					g_string_append_c(buffer, ' ');
-				g_string_append(buffer, getword(words, m, 2000));
-			}
-
-			/* and index it */
-			ibex_index_buffer(ib, name, buffer->str, buffer->len, NULL);
-		}
-
-
-		a = ibex_find(ib, "joneses");
-		if (a) {
-			if (a->len != lastlen) {
-				printf("Found %d joneses!\n", a->len);
-				lastlen = a->len;
-			}
-			for (i=0;i<a->len;i++)
-				g_free(a->pdata[i]);
-			g_ptr_array_free(a, TRUE);
-		}
-
-		if (j%synccount == 0) {
-			printf("Reloading index\n");
-			IBEX_LOCK(ib);
-			word_index_mem_dump_info(ib->words);
-			IBEX_UNLOCK(ib);
-#ifdef ENABLE_THREADS
-			do_read_words = 0;
-			pthread_join(id, 0);
-#endif
-			ibex_save(ib);
-			ibex_close(ib);
-
-			ib = ibex_open("test.ibex", O_RDWR|O_CREAT, 0600);
-			ibex_contains_name(ib, name);
-			IBEX_LOCK(ib);
-			word_index_mem_dump_info(ib->words);
-			IBEX_UNLOCK(ib);
-#ifdef ENABLE_THREADS
-			do_read_words = 1;
-			pthread_create(&id, 0, read_words, ib);
-#endif
-		}
-
-	}
-
-
-	IBEX_LOCK(ib);
-	word_index_mem_dump_info(ib->words);
-	IBEX_UNLOCK(ib);
-
-#ifdef ENABLE_THREADS
-	do_read_words = 0;
-	pthread_join(id, 0);
-#endif
-
-	ibex_close(ib);
-
-#ifdef TIMEIT
-	gettimeofday(&end, NULL);
-	diff = end.tv_sec * 1000 + end.tv_usec/1000;
-	diff -= start.tv_sec * 1000 + start.tv_usec/1000;
-	printf("Total time taken %ld.%03ld seconds\n", diff / 1000, diff % 1000);
-#endif
-
-	return 0;
-}
-
diff --git a/libibex/wordindex.c b/libibex/wordindex.c
deleted file mode 100644
index 6ddbcb599a..0000000000
--- a/libibex/wordindex.c
+++ /dev/null
@@ -1,645 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
- *
- * Copyright (C) 2000 Ximian, Inc.
- *
- * Authors: Michael Zucchi <notzed@ximian.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/* code to manage a word index */
-/* includes a cache for word index writes,
-   but not for name index writes (currently), or any reads.
-
-Note the word cache is only needed during indexing of lots
-of words, and could then be discarded (:flush()).
-
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <glib.h>
-
-#include "block.h"
-#include "index.h"
-#include "wordindex.h"
-
-#define d(x)
-
-/*#define WORDCACHE_SIZE (256)*/
-#define WORDCACHE_SIZE (4096)
-
-extern struct _IBEXStoreClass ibex_diskarray_class;
-extern struct _IBEXIndexClass ibex_hash_class;
-
-/* need 2 types of hash key?
-   one that just stores the wordid / wordblock
-   and one that stores the filecount/files?
-*/
-
-
-#define CACHE_FILE_COUNT (62)
-
-struct _wordcache {
-	struct _wordcache *next;
-	struct _wordcache *prev;
-	nameid_t wordid;	/* disk wordid */
-	blockid_t wordblock;	/* head of disk list */
-	blockid_t wordtail;	/* and the tail data */
-	short filecount;	/* how many valid items in files[] */
-	short filealloc;	/* how much allocated space in files[] */
-	union {
-		nameid_t *files;	/* memory cache of files */
-		nameid_t file0;	/* if filecount == 1 && filealloc == 0, store directly */
-	} file;
-	char word[1];		/* actual word follows */
-};
-
-static void unindex_name(struct _IBEXWord *, const char *name); 	/* unindex all entries for name */
-static gboolean contains_name(struct _IBEXWord *, const char *name);	/* index contains data for name */
-static GPtrArray *find(struct _IBEXWord *, const char *word);		/* returns all matches for word */
-static gboolean find_name(struct _IBEXWord *, const char *name, const char *word);	/* find if name contains word */
-static void add(struct _IBEXWord *, const char *name, const char *word);	/* adds a single word to name (slow) */
-static void add_list(struct _IBEXWord *, const char *name, GPtrArray *words);/* adds a bunch of words to a given name */
-static int word_sync(struct _IBEXWord *idx);
-static int word_flush(struct _IBEXWord *idx);
-static int word_close(struct _IBEXWord *idx);
-static void word_index_pre(struct _IBEXWord *idx);
-static void word_index_post(struct _IBEXWord *idx);
-
-struct _IBEXWordClass ibex_word_index_class = {
-	word_sync, word_flush, word_close,
-	word_index_pre, word_index_post,
-	unindex_name, contains_name,
-	find, find_name,
-	add, add_list
-};
-
-/* this interface isn't the best, but it'll do for now */
-struct _IBEXWord *
-ibex_create_word_index(struct _memcache *bc, blockid_t *wordroot, blockid_t *nameroot)
-{
-	struct _IBEXWord *idx;
-
-	idx = g_malloc0(sizeof(*idx));
-	idx->wordcache = g_hash_table_new(g_str_hash, g_str_equal);
-	ibex_list_new(&idx->wordnodes);
-	idx->wordcount = 0;
-	idx->klass = &ibex_word_index_class;
-
-	/* we use the same block array storage for both indexes at the moment */
-	idx->wordstore = ibex_diskarray_class.create(bc);
-	idx->namestore = idx->wordstore;
-
-	/* but not the same indexes! */
-	if (*wordroot) {
-		printf("opening wordindex root = %d\n", *wordroot);
-		idx->wordindex = ibex_hash_class.open(bc, *wordroot);
-	} else {
-		idx->wordindex = ibex_hash_class.create(bc, 2048);
-		*wordroot = idx->wordindex->root;
-		printf("creating wordindex root = %d\n", *wordroot);
-	}
-	if (*nameroot) {
-		printf("opening nameindex root = %d\n", *nameroot);
-		idx->nameindex = ibex_hash_class.open(bc, *nameroot);
-	} else {
-		idx->nameindex = ibex_hash_class.create(bc, 2048);
-		*nameroot = idx->nameindex->root;
-		printf("creating nameindex root = %d\n", *nameroot);
-	}
-	return idx;
-}
-
-#if d(!)0
-static void
-cache_sanity(struct _wordcache *head)
-{
-	while (head->next) {
-		g_assert(head->filecount <= head->filealloc);
-		g_assert(strlen(head->word) != 0);
-		head = head->next;
-	}
-}
-#endif
-
-static void word_index_pre(struct _IBEXWord *idx)
-{
-}
-
-static void word_index_post(struct _IBEXWord *idx)
-{
-}
-
-/* unindex all entries for name */
-static void unindex_name(struct _IBEXWord *idx, const char *name)
-{
-	GArray *words;
-	int i;
-	nameid_t nameid, wordid;
-	blockid_t nameblock, wordblock, newblock, nametail, wordtail, newtail;
-	char *word;
-	struct _wordcache *cache;
-
-	d(printf("unindexing %s\n", name));
-
-	/* lookup the hash key */
-	nameid = idx->nameindex->klass->find(idx->nameindex, name, strlen(name));
-	/* get the block for this key */
-	nameblock = idx->nameindex->klass->get_data(idx->nameindex, nameid, &nametail);
-	/* and the data for this block */
-	words = idx->namestore->klass->get(idx->namestore, nameblock, nametail);
-	/* walk it ... */
-	for (i=0;i<words->len;i++) {
-		/* get the word */
-		wordid = g_array_index(words, nameid_t, i);
-		d(printf(" word %d\n", wordid));
-		/* get the data block */
-		wordblock = idx->wordindex->klass->get_data(idx->wordindex, wordid, &wordtail);
-		/* clear this name from it */
-		newblock = wordblock;
-		newtail = wordtail;
-		idx->wordstore->klass->remove(idx->wordstore, &newblock, &newtail, nameid);
-		if (newblock != wordblock || newtail != wordtail)
-			idx->wordindex->klass->set_data(idx->wordindex, wordid, newblock, newtail);
-
-		/* now check the cache as well */
-		word = idx->nameindex->klass->get_key(idx->wordindex, wordid, NULL);
-		if (word) {
-			cache = g_hash_table_lookup(idx->wordcache, word);
-			if (cache) {
-				/* its there, update our head/tail pointers */
-				cache->wordblock = newblock;
-				cache->wordtail = newtail;
-
-				/* now check that we have a data entry in it */
-				if (cache->filealloc == 0 && cache->filecount == 1) {
-					if (cache->file.file0 == nameid) {
-						cache->filecount = 0;
-					}
-				} else {
-					int j;
-
-					for (j=0;j<cache->filecount;j++) {
-						if (cache->file.files[j] == nameid) {
-							cache->file.files[j] = cache->file.files[cache->filecount-1];
-							cache->filecount--;
-							break;
-						}
-					}
-				}
-			}
-			g_free(word);
-		}
-	}
-	g_array_free(words, TRUE);
-
-	/* and remove name data and itself */
-	idx->namestore->klass->free(idx->namestore, nameblock, nametail);
-	idx->nameindex->klass->remove(idx->nameindex, name, strlen(name));
-}
-
-/* index contains (any) data for name */
-static gboolean contains_name(struct _IBEXWord *idx, const char *name)
-{
-	return idx->nameindex->klass->find(idx->nameindex, name, strlen(name)) != 0;
-}
-
-/* returns all matches for word */
-static GPtrArray *find(struct _IBEXWord *idx, const char *word)
-{
-	nameid_t wordid, nameid;
-	GPtrArray *res;
-	GArray *names;
-	int i;
-	char *new;
-	struct _wordcache *cache;
-	blockid_t wordblock, wordtail;
-
-	res = g_ptr_array_new();
-
-	cache = g_hash_table_lookup(idx->wordcache, word);
-	if (cache) {
-		/* freshen cache entry if we touch it */
-		ibex_list_remove((struct _listnode *)cache);
-		ibex_list_addtail(&idx->wordnodes, (struct _listnode *)cache);
-		wordid = cache->wordid;
-		wordblock = cache->wordblock;
-		wordtail = cache->wordtail;
-	} else {
-		/* lookup the hash key */
-		wordid = idx->wordindex->klass->find(idx->wordindex, word, strlen(word));
-		/* get the block for this key */
-		wordblock = idx->wordindex->klass->get_data(idx->wordindex, wordid, &wordtail);
-	}
-	/* and the data for this block */
-	names = idx->wordstore->klass->get(idx->wordstore, wordblock, wordtail);
-	/* .. including any memory-only data */
-	if (cache) {
-		if (cache->filealloc == 0 && cache->filecount == 1)
-			g_array_append_val(names, cache->file.file0);
-		else
-			g_array_append_vals(names, cache->file.files, cache->filecount);
-	}
-
-	/* walk it ... converting id's back to strings */
-	g_ptr_array_set_size(res, names->len);
-	for (i=0;i<names->len;i++) {
-		nameid = g_array_index(names, nameid_t, i);
-		new = idx->nameindex->klass->get_key(idx->nameindex, nameid, NULL);
-		res->pdata[i] = new;
-	}
-	g_array_free(names, TRUE);
-	return res;
-}
-
-/* find if name contains word */
-static gboolean find_name(struct _IBEXWord *idx, const char *name, const char *word)
-{
-	nameid_t wordid, nameid;
-	blockid_t nameblock, nametail;
-	struct _wordcache *cache;
-	int i;
-
-	/* lookup the hash key for the name */
-	nameid = idx->nameindex->klass->find(idx->nameindex, name, strlen(name));
-	/* get the block for this name */
-	nameblock = idx->nameindex->klass->get_data(idx->nameindex, nameid, &nametail);
-
-	/* check if there is an in-memory cache for this word, check its file there first */
-	cache = g_hash_table_lookup(idx->wordcache, word);
-	if (cache) {
-		/* freshen cache entry if we touch it */
-		ibex_list_remove((struct _listnode *)cache);
-		ibex_list_addtail(&idx->wordnodes, (struct _listnode *)cache);
-		if (cache->filecount == 1 && cache->filealloc == 0) {
-			if (cache->file.file0 == nameid)
-				return TRUE;
-		} else {
-			for (i=0;i<cache->filecount;i++) {
-				if (cache->file.files[i] == nameid)
-					return TRUE;
-			}
-		}
-		/* not there?  well we can use the wordid anyway */
-		wordid = cache->wordid;
-	} else {
-		/* lookup the hash key for word */
-		wordid = idx->wordindex->klass->find(idx->wordindex, word, strlen(word));
-	}
-
-	/* see if wordid is in nameblock */
-	return idx->namestore->klass->find(idx->namestore, nameblock, nametail, wordid);
-}
-
-/* cache helper functions */
-/* flush a cache entry to disk, and empty it out */
-static void
-sync_cache_entry(struct _IBEXWord *idx, struct _wordcache *cache)
-{
-	GArray array; /* just use this as a header */
-	blockid_t oldblock, oldtail;
-	
-	d(printf("syncing cache entry '%s' used %d\n", cache->word, cache->filecount));
-	if (cache->filecount == 1 && cache->filealloc == 0)
-		array.data = (char *)&cache->file.file0;
-	else
-		array.data = (char *)cache->file.files;
-	array.len = cache->filecount;
-	oldblock = cache->wordblock;
-	oldtail = cache->wordtail;
-	idx->wordstore->klass->add_list(idx->wordstore, &cache->wordblock, &cache->wordtail, &array);
-	if (oldblock != cache->wordblock || oldtail != cache->wordtail) {
-		idx->wordindex->klass->set_data(idx->wordindex, cache->wordid, cache->wordblock, cache->wordtail);
-	}
-	cache->filecount = 0;
-}
-
-/* create a new key in an index, returning its id and head block */
-static void
-add_index_key(struct _IBEXIndex *wordindex, const char *word, nameid_t *wordid, blockid_t *wordblock, blockid_t *wordtail)
-{
-	/* initialise cache entry - id of word entry and head block */
-	*wordid = wordindex->klass->find(wordindex, word, strlen(word));
-	if (*wordid == 0) {
-		*wordid = wordindex->klass->insert(wordindex, word, strlen(word));
-		*wordblock = 0;
-		*wordtail = 0;
-	} else {
-		*wordblock = wordindex->klass->get_data(wordindex, *wordid, wordtail);
-	}
-}
-
-/* create a new key in a cached index (only word cache so far), flushing old keys
-   if too much space is being used */
-static struct _wordcache *
-add_index_cache(struct _IBEXWord *idx, const char *word)
-{
-	struct _wordcache *cache;
-
-	d(printf("adding %s to cache\n", word));
-
-	cache = g_hash_table_lookup(idx->wordcache, word);
-	if (cache == 0) {
-		/* see if we have to flush off the last entry */
-		if (idx->wordcount >= WORDCACHE_SIZE) {
-			struct _wordcache *mincache;
-			int min, count=0;
-			/* remove last entry, and flush it */
-			cache = (struct _wordcache *)idx->wordnodes.tailpred;
-			mincache = cache;
-			min = mincache->filecount;
-
-			d(printf("flushing word from cache %s\n", cache->word));
-			/* instead of just using the last entry, we try and find an entry with
-			   with only 1 item (failing that, the smallest in the range we look at) */
-			/* this could probably benefit greatly from a more sophisticated aging algorithm */
-			while (cache->next && count < 100) {
-				if (cache->filecount == 1) {
-					mincache = cache;
-					break;
-				}
-				if (cache->filecount > 0 && cache->filecount < min) {
-					mincache = cache;
-					min = cache->filecount;
-				}
-				cache = cache->next;
-				count++;
-			}
-			ibex_list_remove((struct _listnode *)mincache);
-			g_hash_table_remove(idx->wordcache, mincache->word);
-			sync_cache_entry(idx, mincache);
-			if (mincache->filealloc)
-				g_free(mincache->file.files);
-			g_free(mincache);
-			idx->wordcount--;
-		}
-		cache = g_malloc0(sizeof(*cache)+strlen(word));
-		/* initialise cache entry - id of word entry and head block */
-		add_index_key(idx->wordindex, word, &cache->wordid, &cache->wordblock, &cache->wordtail);
-		/* other fields */
-		strcpy(cache->word, word);
-		cache->filecount = 0;
-		g_hash_table_insert(idx->wordcache, cache->word, cache);
-		ibex_list_addhead(&idx->wordnodes, (struct _listnode *)cache);
-		idx->wordcount++;
-	} else {
-		/* move cache bucket ot the head of the cache list */
-		ibex_list_remove((struct _listnode *)cache);
-		ibex_list_addhead(&idx->wordnodes, (struct _listnode *)cache);
-	}
-	return cache;
-}
-
-/* adds a single word to name (slow) */
-static void add(struct _IBEXWord *idx, const char *name, const char *word)
-{
-	nameid_t nameid;
-	blockid_t nameblock, newblock, nametail, newtail;
-	struct _wordcache *cache;
-
-	g_error("Dont use wordindex::add()");
-	abort();
-
-	cache = add_index_cache(idx, word);
-
-	/* get the nameid and block start for this name */
-	add_index_key(idx->nameindex, name, &nameid, &nameblock, &nametail);
-
-	/* check for repeats of the last name - dont add anything */
-	if (cache->filecount == 1 && cache->filealloc == 0) {
-		if (cache->file.file0 == nameid)
-			return;
-	} else {
-		if (cache->file.files[cache->filecount] == nameid)
-			return;
-	}
-
-	/* see if we are setting the first, drop it in the union */
-	if (cache->filecount == 0 && cache->filealloc == 0) {
-		cache->file.file0 = nameid;
-	} else if (cache->filecount == 1 && cache->filealloc == 0) {
-		nameid_t saveid;
-		/* we need to allocate space for words */
-		saveid = cache->file.file0;
-		cache->file.files = g_malloc(sizeof(cache->file.files[0]) * CACHE_FILE_COUNT);
-		/* this could possibly grow as needed, but i wont for now */
-		cache->filealloc = CACHE_FILE_COUNT;
-		cache->file.files[0] = saveid;
-		cache->file.files[1] = nameid;
-	} else {
-		cache->file.files[cache->filecount] = nameid;
-	}
-
-	cache->filecount++;
-
-	/* if we are full, force a flush now */
-	if (cache->filealloc && cache->filecount >= cache->filealloc) {
-		sync_cache_entry(idx, cache);
-	}
-
-	newtail = nametail;
-	newblock = nameblock;
-	idx->namestore->klass->add(idx->namestore, &newblock, &newtail, cache->wordid);
-	if (newblock != nameblock || newtail != nametail) {
-		idx->nameindex->klass->set_data(idx->nameindex, nameid, newblock, newtail);
-	}
-}
-
-/* adds a bunch of words to a given name */
-static void add_list(struct _IBEXWord *idx, const char *name, GPtrArray *words)
-{
-	int i;
-	GArray *data = g_array_new(0, 0, sizeof(nameid_t));
-	blockid_t nameblock, newblock, nametail, newtail;
-	nameid_t nameid;
-	struct _wordcache *cache;
-
-	d(printf("Adding words to name %s\n", name));
-
-	d(cache_sanity((struct _wordcache *)idx->wordnodes.head));
-
-	/* get the nameid and block start for this name */
-	add_index_key(idx->nameindex, name, &nameid, &nameblock, &nametail);
-
-	d(cache_sanity((struct _wordcache *)idx->wordnodes.head));
-
-	for (i=0;i<words->len;i++) {
-		char *word = words->pdata[i];
-
-		cache = add_index_cache(idx, word);
-
-		/*d(cache_sanity((struct _wordcache *)idx->wordnodes.head));*/
-
-		/* check for duplicates; doesn't catch duplicates over an overflow boundary.  Watch me care. */
-		if (cache->filecount == 0
-		    /* the 1 item case */
-		    || (cache->filecount == 1 && cache->filealloc == 0 && cache->file.file0 != nameid)
-		    /* the normal case */
-		    || (cache->filealloc > 0 && cache->file.files[cache->filecount-1] != nameid)) {
-
-			/* see if we are setting the first, drop it in the union */
-			if (cache->filecount == 0 && cache->filealloc == 0) {
-				cache->file.file0 = nameid;
-			} else if (cache->filecount == 1 && cache->filealloc == 0) {
-				nameid_t saveid;
-				/* we need to allocate space for words */
-				saveid = cache->file.file0;
-				cache->file.files = g_malloc(sizeof(cache->file.files[0]) * CACHE_FILE_COUNT);
-				/* this could possibly grow as needed, but i wont for now */
-				cache->filealloc = CACHE_FILE_COUNT;
-				cache->file.files[0] = saveid;
-				cache->file.files[1] = nameid;
-			} else {
-				cache->file.files[cache->filecount] = nameid;
-			}
-
-			cache->filecount++;
-
-			/* if we are full, force a flush now */
-			if (cache->filealloc && cache->filecount >= cache->filealloc) {
-				sync_cache_entry(idx, cache);
-			}
-
-			/*d(cache_sanity((struct _wordcache *)idx->wordnodes.head));*/
-
-			/* and append this wordid for this name in memory */
-			g_array_append_val(data, cache->wordid);
-		}
-
-		/*d(cache_sanity((struct _wordcache *)idx->wordnodes.head));*/
-	}
-
-	d(cache_sanity((struct _wordcache *)idx->wordnodes.head));
-
-	/* and append these word id's in one go */
-	newblock = nameblock;
-	newtail = nametail;
-	idx->namestore->klass->add_list(idx->namestore, &newblock, &newtail, data);
-	if (newblock != nameblock || newtail != nametail) {
-		idx->nameindex->klass->set_data(idx->nameindex, nameid, newblock, newtail);
-	}
-
-	d(cache_sanity((struct _wordcache *)idx->wordnodes.head));
-
-	g_array_free(data, TRUE);
-}
-
-/* sync any in-memory data to disk */
-static int
-word_sync(struct _IBEXWord *idx)
-{
-	/* we just flush also, save memory */
-	word_flush(idx);
-
-#if 0
-	struct _wordcache *cache = (struct _wordcache *)idx->wordnodes.head;
-
-	while (cache->next) {
-		sync_cache_entry(idx, cache);
-		cache = cache->next;
-	}
-
-	/*ibex_hash_dump(idx->wordindex);*/
-	/*ibex_hash_dump(idx->nameindex);*/
-#endif
-	return 0;
-}
-
-/* sync and flush any in-memory data to disk and free it */
-static int
-word_flush(struct _IBEXWord *idx)
-{
-	struct _wordcache *cache = (struct _wordcache *)idx->wordnodes.head, *next;
-	extern int block_log;
-	int count= 0;
-	int used=0, wasted=0;
-
-	block_log = 0;
-
-	next = cache->next;
-	while (next) {
-		count++;
-		used += sizeof(struct _wordcache) + (cache->filealloc * sizeof(nameid_t));
-		if (cache->filealloc)
-			wasted += (cache->filealloc-cache->filecount)*sizeof(nameid_t);
-		else
-			wasted += (1-cache->filecount) * sizeof(nameid_t);
-
-		/*printf("syncing word %s\n", cache->word);*/
-		sync_cache_entry(idx, cache);
-		g_hash_table_remove(idx->wordcache, cache->word);
-		if (cache->filealloc)
-			g_free(cache->file.files);
-		g_free(cache);
-		cache = next;
-		next = cache->next;
-	}
-
-	printf("sync cache entries = %d\n used memory = %d\n wasted memory = %d\n", count, used, wasted);
-
-	block_log = 0;
-	ibex_list_new(&idx->wordnodes);
-	idx->wordcount = 0;
-	return 0;
-}
-
-static int word_close(struct _IBEXWord *idx)
-{
-	struct _wordcache *cache = (struct _wordcache *)idx->wordnodes.head, *next;
-	extern int block_log;
-	int count= 0;
-	int used=0, wasted=0;
-
-	block_log = 0;
-
-	next = cache->next;
-	while (next) {
-		count++;
-		used += sizeof(struct _wordcache) + (cache->filealloc * sizeof(nameid_t));
-		if (cache->filealloc)
-			wasted += (cache->filealloc-cache->filecount)*sizeof(nameid_t);
-		else
-			wasted += (1-cache->filecount) * sizeof(nameid_t);
-
-		/*printf("closing word %s\n", cache->word);*/
-		sync_cache_entry(idx, cache);
-		if (cache->filealloc)
-			g_free(cache->file.files);
-		g_free(cache);
-		cache = next;
-		next = cache->next;
-	}
-	block_log = 0;
-
-	printf("cache entries = %d\n used memory = %d\n wasted memory = %d\n", count, used, wasted);
-
-	idx->namestore->klass->close(idx->namestore);
-	idx->nameindex->klass->close(idx->nameindex);
-	/*same as namestore:
-	  idx->wordstore->klass->close(idx->wordstore);*/
-	idx->wordindex->klass->close(idx->wordindex);
-	g_hash_table_destroy(idx->wordcache);
-	g_free(idx);
-
-	return 0;
-}
diff --git a/libibex/wordindex.h b/libibex/wordindex.h
deleted file mode 100644
index a3c44c6ca7..0000000000
--- a/libibex/wordindex.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
- *
- * Copyright (C) 2000 Ximian, Inc.
- *
- * Authors: Michael Zucchi <notzed@ximian.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#ifndef _WORDINDEX_H
-#define _WORDINDEX_H
-
-#include <glib.h>
-
-#include "block.h"
-#include "index.h"
-
-struct _IBEXWord;
-
-/* not used yet */
-typedef void (*IBEXNormaliseFunc)(char *source, int len, char *dest);
-
-struct _IBEXWordClass {
-	int (*sync)(struct _IBEXWord *);
-	int (*flush)(struct _IBEXWord *);
-	int (*close)(struct _IBEXWord *);
-
-	void (*index_pre)(struct _IBEXWord *); /* get ready for doing a lot of indexing.  may be a nop */
-	void (*index_post)(struct _IBEXWord *);
-
-	void (*unindex_name)(struct _IBEXWord *, const char *name);		/* unindex all entries for name */
-	gboolean (*contains_name)(struct _IBEXWord *, const char *name);	/* index contains data for name */
-	GPtrArray *(*find)(struct _IBEXWord *, const char *word);		/* returns all matches for word */
-	gboolean (*find_name)(struct _IBEXWord *, const char *name, const char *word);	/* find if name contains word */
-	void (*add)(struct _IBEXWord *, const char *name, const char *word);	/* adds a single word to name */
-	void (*add_list)(struct _IBEXWord *, const char *name, GPtrArray *words);/* adds a bunch of words to a given name */
-};
-
-struct _IBEXWord {
-	struct _IBEXWordClass *klass;
-	struct _IBEXStore *wordstore;
-	struct _IBEXIndex *wordindex;
-	struct _IBEXStore *namestore;
-	struct _IBEXIndex *nameindex;
-
-	struct _memcache *blocks;
-
-	/* word caching info (should probably be modularised) */
-	GHashTable *wordcache;	/* word->struct _wordcache mapping */
-	struct _list wordnodes;	/* LRU list of wordcache structures */
-	int wordcount;		/* how much space used in cache */
-	int precount;
-	GHashTable *namecache;	/* a list of names (only), cached for quick reference */
-	int nameinit;
-};
-
-
-/*struct _IBEXWord *ibex_create_word_index(struct _memcache *bc, blockid_t *wordroot, blockid_t *nameroot);*/
-
-/* alternate implemenation */
-struct _IBEXWord *ibex_create_word_index_mem(struct _memcache *bc, blockid_t *wordroot, blockid_t *nameroot);
-
-#endif /* !_WORDINDEX_H */
diff --git a/libibex/wordindexmem.c b/libibex/wordindexmem.c
deleted file mode 100644
index d3c7a5c316..0000000000
--- a/libibex/wordindexmem.c
+++ /dev/null
@@ -1,901 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
- *
- * Copyright (C) 2000 Ximian, Inc.
- *
- * Authors: Michael Zucchi <notzed@ximian.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/* this is the same as wordindex.c, but it doesn't have an LRU cache
-   for word names.  it has a lookup tab le that is only loaded if
-   index-pre is called, otherwise it always hits disk */
-
-/* code to manage a word index */
-/* includes a cache for word index writes,
-   but not for name index writes (currently), or any reads.
-
-Note the word cache is only needed during indexing of lots
-of words, and could then be discarded (:flush()).
-
-*/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <glib.h>
-
-#include "block.h"
-#include "index.h"
-#include "wordindex.h"
-
-/*#define MALLOC_CHECK*/
-
-#ifdef MALLOC_CHECK
-#include <mcheck.h>
-#endif
-
-#define d(x)
-
-/*#define WORDCACHE_SIZE (256)*/
-#define WORDCACHE_SIZE (4096)
-
-extern struct _IBEXStoreClass ibex_diskarray_class;
-extern struct _IBEXIndexClass ibex_hash_class;
-
-/* need 2 types of hash key?
-   one that just stores the wordid / wordblock
-   and one that stores the filecount/files?
-*/
-
-
-#define CACHE_FILE_COUNT (62)
-
-struct _wordcache {
-	nameid_t wordid;	/* disk wordid */
-	blockid_t wordblock;	/* head of disk list */
-	blockid_t wordtail;	/* and the tail data */
-	short filecount;	/* how many valid items in files[] */
-	short filealloc;	/* how much allocated space in files[] */
-	union {
-		nameid_t *files;	/* memory cache of files */
-		nameid_t file0;	/* if filecount == 1 && filealloc == 0, store directly */
-	} file;
-	char word[1];		/* actual word follows */
-};
-
-static void unindex_name(struct _IBEXWord *, const char *name); 	/* unindex all entries for name */
-static gboolean contains_name(struct _IBEXWord *, const char *name);	/* index contains data for name */
-static GPtrArray *find(struct _IBEXWord *, const char *word);		/* returns all matches for word */
-static gboolean find_name(struct _IBEXWord *, const char *name, const char *word);	/* find if name contains word */
-static void add(struct _IBEXWord *, const char *name, const char *word);	/* adds a single word to name (slow) */
-static void add_list(struct _IBEXWord *, const char *name, GPtrArray *words);/* adds a bunch of words to a given name */
-static int word_sync(struct _IBEXWord *idx);
-static int word_flush(struct _IBEXWord *idx);
-static int word_close(struct _IBEXWord *idx);
-static void word_index_pre(struct _IBEXWord *idx);
-static void word_index_post(struct _IBEXWord *idx);
-
-static void sync_cache_entry(struct _IBEXWord *idx, struct _wordcache *cache);
-
-struct _IBEXWordClass ibex_word_index_mem_class = {
-	word_sync, word_flush, word_close,
-	word_index_pre, word_index_post,
-	unindex_name, contains_name,
-	find, find_name,
-	add, add_list
-};
-
-#ifdef MALLOC_CHECK
-static void
-checkmem(void *p)
-{
-	if (p) {
-		int status = mprobe(p);
-
-		switch (status) {
-		case MCHECK_HEAD:
-			printf("Memory underrun at %p\n", p);
-			abort();
-		case MCHECK_TAIL:
-			printf("Memory overrun at %p\n", p);
-			abort();
-		case MCHECK_FREE:
-			printf("Double free %p\n", p);
-			abort();
-		}
-	}
-}
-#endif
-
-/* this interface isn't the best, but it'll do for now */
-struct _IBEXWord *
-ibex_create_word_index_mem(struct _memcache *bc, blockid_t *wordroot, blockid_t *nameroot)
-{
-	struct _IBEXWord *idx;
-
-	idx = g_malloc0(sizeof(*idx));
-	idx->blocks = bc;
-	idx->wordcache = g_hash_table_new(g_str_hash, g_str_equal);
-	ibex_list_new(&idx->wordnodes);
-	idx->wordcount = 0;
-	idx->precount = 0;
-	idx->namecache = g_hash_table_new(g_str_hash, g_str_equal);
-	idx->nameinit = 0;
-	idx->klass = &ibex_word_index_mem_class;
-
-	/* we use the same block array storage for both indexes at the moment */
-	idx->wordstore = ibex_diskarray_class.create(bc);
-	idx->namestore = idx->wordstore;
-
-	/* but not the same indexes! */
-	if (*wordroot) {
-		d(printf("opening wordindex root = %d\n", *wordroot));
-		idx->wordindex = ibex_hash_class.open(bc, *wordroot);
-	} else {
-		idx->wordindex = ibex_hash_class.create(bc, 2048);
-		*wordroot = idx->wordindex->root;
-		d(printf("creating wordindex root = %d\n", *wordroot));
-	}
-	if (*nameroot) {
-		d(printf("opening nameindex root = %d\n", *nameroot));
-		idx->nameindex = ibex_hash_class.open(bc, *nameroot);
-	} else {
-		idx->nameindex = ibex_hash_class.create(bc, 2048);
-		*nameroot = idx->nameindex->root;
-		d(printf("creating nameindex root = %d\n", *nameroot));
-	}
-	return idx;
-}
-
-#if (d(!)0) || defined(MALLOC_CHECK)
-static void
-node_sanity(char *key, struct _wordcache *node, void *data)
-{
-	g_assert(node->filecount <= node->filealloc || (node->filecount == 1 && node->filealloc == 0));
-	g_assert(strlen(node->word) != 0);
-#ifdef MALLOC_CHECK
-	checkmem(node);
-	if (node->filealloc)
-		checkmem(node->file.files);
-#endif
-}
-
-static void
-cache_sanity(struct _IBEXWord *idx)
-{
-#ifdef MALLOC_CHECK
-	checkmem(idx);
-#endif
-	g_hash_table_foreach(idx->wordcache, (GHFunc)node_sanity, idx);
-}
-#endif
-
-static void word_index_pre(struct _IBEXWord *idx)
-{
-	struct _IBEXCursor *idc;
-	struct _wordcache *cache;
-	nameid_t wordid;
-	char *key;
-	int len;
-
-	idx->precount ++;
-	if (idx->precount > 1)
-		return;
-
-	/* NOOP if failed */
-	if (idx->blocks->failed) {
-		g_warning("word_index_pre() on failed data file");
-		return;
-	}
-
-	/* want to load all words into the cache lookup table */
-	d(printf("pre-loading all word info into memory\n"));
-	idc = idx->wordindex->klass->get_cursor(idx->wordindex);
-	while ( (wordid = idc->klass->next(idc)) ) {
-		key = idc->index->klass->get_key(idc->index, wordid, &len);
-		/*d(printf("Adding word %s\n", key));*/
-		cache = g_malloc0(sizeof(*cache) + strlen(key));
-		strcpy(cache->word, key);
-		g_free(key);
-		cache->wordid = wordid;
-		cache->wordblock = idc->index->klass->get_data(idc->index, wordid, &cache->wordtail);
-		cache->filecount = 0;
-		cache->filealloc = 0;
-		g_hash_table_insert(idx->wordcache, cache->word, cache);
-		idx->wordcount++;
-	}
-
-#ifdef MALLOC_CHECK
-	cache_sanity(idx);
-#endif
-
-	idc->klass->close(idc);
-
-	d(printf("done\n"));
-}
-
-static gboolean
-sync_free_value(void *key, void *value, void *data)
-{
-	struct _wordcache *cache = (struct _wordcache *)value;
-	struct _IBEXWord *idx = (struct _IBEXWord *)data;
-
-	sync_cache_entry(idx, cache);
-	if (cache->filealloc)
-		g_free(cache->file.files);
-	g_free(cache);
-
-	return TRUE;
-}
-
-#if d(!)0
-static void
-sync_value(void *key, void *value, void *data)
-{
-	struct _wordcache *cache = (struct _wordcache *)value;
-	struct _IBEXWord *idx = (struct _IBEXWord *)data;
-
-	sync_cache_entry(idx, cache);
-}
-#endif
-
-static void word_index_post(struct _IBEXWord *idx)
-{
-	idx->precount--;
-	if (idx->precount > 0)
-		return;
-	idx->precount = 0;
-
-#ifdef MALLOC_CHECK
-	cache_sanity(idx);
-#endif
-
-	g_hash_table_foreach_remove(idx->wordcache, sync_free_value, idx);
-	idx->wordcount = 0;
-}
-
-/* unindex all entries for name */
-static void unindex_name(struct _IBEXWord *idx, const char *name)
-{
-	GArray *words;
-	int i;
-	nameid_t nameid, wordid;
-	blockid_t nameblock, wordblock, newblock, nametail, wordtail, newtail;
-	char *word;
-	struct _wordcache *cache;
-
-	d(printf("unindexing %s\n", name));
-
-	/* if we have a namecache, check that to see if we need to remove that item, or there is no work here */
-	if (idx->nameinit) {
-		char *oldkey;
-		gboolean oldval;
-
-		if (g_hash_table_lookup_extended(idx->namecache, name, (void *)&oldkey, (void *)&oldval)) {
-			g_hash_table_remove(idx->namecache, oldkey);
-			g_free(oldkey);
-		} else {
-			return;
-		}
-	}
-
-	/* lookup the hash key */
-	nameid = idx->nameindex->klass->find(idx->nameindex, name, strlen(name));
-	/* get the block for this key */
-	nameblock = idx->nameindex->klass->get_data(idx->nameindex, nameid, &nametail);
-	/* and the data for this block */
-	words = idx->namestore->klass->get(idx->namestore, nameblock, nametail);
-	/* walk it ... */
-	for (i=0;i<words->len;i++) {
-		/* get the word */
-		wordid = g_array_index(words, nameid_t, i);
-		d(printf(" word %d\n", wordid));
-		/* get the data block */
-		wordblock = idx->wordindex->klass->get_data(idx->wordindex, wordid, &wordtail);
-		/* clear this name from it */
-		newblock = wordblock;
-		newtail = wordtail;
-		idx->wordstore->klass->remove(idx->wordstore, &newblock, &newtail, nameid);
-		if (newblock != wordblock || newtail != wordtail)
-			idx->wordindex->klass->set_data(idx->wordindex, wordid, newblock, newtail);
-
-		/* now check the cache as well */
-		word = idx->nameindex->klass->get_key(idx->wordindex, wordid, NULL);
-		if (word) {
-			cache = g_hash_table_lookup(idx->wordcache, word);
-			if (cache) {
-				/* its there, update our head/tail pointers */
-				cache->wordblock = newblock;
-				cache->wordtail = newtail;
-
-				/* now check that we have a data entry in it */
-				if (cache->filealloc == 0 && cache->filecount == 1) {
-					if (cache->file.file0 == nameid) {
-						cache->filecount = 0;
-					}
-				} else {
-					int j;
-
-					for (j=0;j<cache->filecount;j++) {
-						if (cache->file.files[j] == nameid) {
-							cache->file.files[j] = cache->file.files[cache->filecount-1];
-							cache->filecount--;
-							break;
-						}
-					}
-				}
-			}
-			g_free(word);
-		}
-	}
-	g_array_free(words, TRUE);
-
-	/* and remove name data and itself */
-	idx->namestore->klass->free(idx->namestore, nameblock, nametail);
-	idx->nameindex->klass->remove(idx->nameindex, name, strlen(name));
-}
-
-/* index contains (any) data for name */
-static gboolean contains_name(struct _IBEXWord *idx, const char *name)
-{
-	struct _IBEXCursor *idc;
-	nameid_t wordid;
-	char *key;
-	int len;
-
-	/* load all the names into memory, since we're *usually* about to do a lot of these */
-
-	/* Note that because of the (poor) hash algorithm, this is >> faster than
-	   looking up every key in turn.  Basically because all keys are stored packed
-	   in the same list, not in buckets of keys for the same hash (among other reasons) */
-
-	if (!idx->nameinit) {
-		d(printf("pre-loading all name info into memory\n"));
-		idc = idx->nameindex->klass->get_cursor(idx->nameindex);
-		while ( (wordid = idc->klass->next(idc)) ) {
-			key = idc->index->klass->get_key(idc->index, wordid, &len);
-			g_hash_table_insert(idx->namecache, key, (void *)TRUE);
-		}
-		idc->klass->close(idc);
-		idx->nameinit = TRUE;
-	}
-
-	return (gboolean)g_hash_table_lookup(idx->namecache, name);
-	/*return idx->nameindex->klass->find(idx->nameindex, name, strlen(name)) != 0;*/
-}
-
-/* returns all matches for word */
-static GPtrArray *find(struct _IBEXWord *idx, const char *word)
-{
-	nameid_t wordid, nameid;
-	GPtrArray *res;
-	GArray *names;
-	int i;
-	char *new;
-	struct _wordcache *cache;
-	blockid_t wordblock, wordtail;
-
-	res = g_ptr_array_new();
-
-	cache = g_hash_table_lookup(idx->wordcache, word);
-	if (cache) {
-#if 0
-		/* freshen cache entry if we touch it */
-		ibex_list_remove((struct _listnode *)cache);
-		ibex_list_addtail(&idx->wordnodes, (struct _listnode *)cache);
-#endif
-		wordid = cache->wordid;
-		wordblock = cache->wordblock;
-		wordtail = cache->wordtail;
-	} else {
-		/* lookup the hash key */
-		wordid = idx->wordindex->klass->find(idx->wordindex, word, strlen(word));
-		/* get the block for this key */
-		wordblock = idx->wordindex->klass->get_data(idx->wordindex, wordid, &wordtail);
-	}
-	/* and the data for this block */
-	names = idx->wordstore->klass->get(idx->wordstore, wordblock, wordtail);
-	/* .. including any memory-only data */
-	if (cache) {
-		if (cache->filealloc == 0 && cache->filecount == 1)
-			g_array_append_val(names, cache->file.file0);
-		else
-			g_array_append_vals(names, cache->file.files, cache->filecount);
-	}
-
-	/* walk it ... converting id's back to strings */
-	g_ptr_array_set_size(res, names->len);
-	for (i=0;i<names->len;i++) {
-		nameid = g_array_index(names, nameid_t, i);
-		new = idx->nameindex->klass->get_key(idx->nameindex, nameid, NULL);
-		res->pdata[i] = new;
-	}
-	g_array_free(names, TRUE);
-	return res;
-}
-
-/* find if name contains word */
-static gboolean find_name(struct _IBEXWord *idx, const char *name, const char *word)
-{
-	nameid_t wordid, nameid;
-	blockid_t nameblock, nametail;
-	struct _wordcache *cache;
-	int i;
-
-	/* if we have the namelist in memory, quick-check that */
-	if (idx->nameinit && g_hash_table_lookup(idx->namecache, name) == NULL)
-		return FALSE;
-
-	/* lookup the hash key for the name */
-	nameid = idx->nameindex->klass->find(idx->nameindex, name, strlen(name));
-	/* get the block for this name */
-	nameblock = idx->nameindex->klass->get_data(idx->nameindex, nameid, &nametail);
-
-	/* check if there is an in-memory cache for this word, check its file there first */
-	cache = g_hash_table_lookup(idx->wordcache, word);
-	if (cache) {
-#if 0
-		/* freshen cache entry if we touch it */
-		ibex_list_remove((struct _listnode *)cache);
-		ibex_list_addtail(&idx->wordnodes, (struct _listnode *)cache);
-#endif
-		if (cache->filecount == 1 && cache->filealloc == 0) {
-			if (cache->file.file0 == nameid)
-				return TRUE;
-		} else {
-			for (i=0;i<cache->filecount;i++) {
-				if (cache->file.files[i] == nameid)
-					return TRUE;
-			}
-		}
-		/* not there?  well we can use the wordid anyway */
-		wordid = cache->wordid;
-	} else {
-		/* lookup the hash key for word */
-		wordid = idx->wordindex->klass->find(idx->wordindex, word, strlen(word));
-	}
-
-	/* see if wordid is in nameblock */
-	return idx->namestore->klass->find(idx->namestore, nameblock, nametail, wordid);
-}
-
-/* cache helper functions */
-/* flush a cache entry to disk, and empty it out */
-static void
-sync_cache_entry(struct _IBEXWord *idx, struct _wordcache *cache)
-{
-	GArray array; /* just use this as a header */
-	blockid_t oldblock, oldtail;
-
-	/* NOOP if failed */
-	if (idx->blocks->failed)
-		return;
-	
-	if (cache->filecount == 0)
-		return;
-
-	d(printf("syncing cache entry '%s' used %d\n", cache->word, cache->filecount));
-	if (cache->filecount == 1 && cache->filealloc == 0)
-		array.data = (char *)&cache->file.file0;
-	else
-		array.data = (char *)cache->file.files;
-	array.len = cache->filecount;
-	oldblock = cache->wordblock;
-	oldtail = cache->wordtail;
-	idx->wordstore->klass->add_list(idx->wordstore, &cache->wordblock, &cache->wordtail, &array);
-	if (oldblock != cache->wordblock || oldtail != cache->wordtail) {
-		idx->wordindex->klass->set_data(idx->wordindex, cache->wordid, cache->wordblock, cache->wordtail);
-	}
-	cache->filecount = 0;
-}
-
-/* create a new key in an index, returning its id and head block */
-static void
-add_index_key(struct _IBEXIndex *wordindex, const char *word, nameid_t *wordid, blockid_t *wordblock, blockid_t *wordtail)
-{
-	/* initialise cache entry - id of word entry and head block */
-	*wordid = wordindex->klass->find(wordindex, word, strlen(word));
-
-	if (*wordid == 0) {
-		*wordid = wordindex->klass->insert(wordindex, word, strlen(word));
-		*wordblock = 0;
-		*wordtail = 0;
-	} else {
-		*wordblock = wordindex->klass->get_data(wordindex, *wordid, wordtail);
-	}
-}
-
-/* create a new key in a cached index (only word cache so far), flushing old keys
-   if too much space is being used */
-static struct _wordcache *
-add_index_cache(struct _IBEXWord *idx, const char *word)
-{
-	struct _wordcache *cache;
-
-	cache = g_hash_table_lookup(idx->wordcache, word);
-	if (cache == 0) {
-		/*d(printf("adding %s to cache\n", word));*/
-
-#if 0
-		/* see if we have to flush off the last entry */
-		if (idx->wordcount >= WORDCACHE_SIZE) {
-			struct _wordcache *mincache;
-			int min, count=0;
-			/* remove last entry, and flush it */
-			cache = (struct _wordcache *)idx->wordnodes.tailpred;
-			mincache = cache;
-			min = mincache->filecount;
-
-			d(printf("flushing word from cache %s\n", cache->word));
-			/* instead of just using the last entry, we try and find an entry with
-			   with only 1 item (failing that, the smallest in the range we look at) */
-			/* this could probably benefit greatly from a more sophisticated aging algorithm */
-			while (cache->next && count < 100) {
-				if (cache->filecount == 1) {
-					mincache = cache;
-					break;
-				}
-				if (cache->filecount > 0 && cache->filecount < min) {
-					mincache = cache;
-					min = cache->filecount;
-				}
-				cache = cache->next;
-				count++;
-			}
-			ibex_list_remove((struct _listnode *)mincache);
-			g_hash_table_remove(idx->wordcache, mincache->word);
-			sync_cache_entry(idx, mincache);
-			if (mincache->filealloc)
-				g_free(mincache->file.files);
-			g_free(mincache);
-			idx->wordcount--;
-		}
-#endif
-		cache = g_malloc0(sizeof(*cache)+strlen(word));
-		/* if we're in an index state, we can assume we dont have it if we dont have it in memory */
-		if (idx->precount == 0) {
-			/* initialise cache entry - id of word entry and head block */
-			add_index_key(idx->wordindex, word, &cache->wordid, &cache->wordblock, &cache->wordtail);
-		} else {
-			cache->wordid = idx->wordindex->klass->insert(idx->wordindex, word, strlen(word));
-		}
-		/* other fields */
-		strcpy(cache->word, word);
-		cache->filecount = 0;
-		g_hash_table_insert(idx->wordcache, cache->word, cache);
-#if 0
-		ibex_list_addhead(&idx->wordnodes, (struct _listnode *)cache);
-#endif
-		idx->wordcount++;
-	} else {
-		/*d(printf("already have %s in cache\n", word));*/
-#if 0
-		/* move cache bucket ot the head of the cache list */
-		ibex_list_remove((struct _listnode *)cache);
-		ibex_list_addhead(&idx->wordnodes, (struct _listnode *)cache);
-#endif
-	}
-	return cache;
-}
-
-/* adds a single word to name (slow) */
-static void add(struct _IBEXWord *idx, const char *name, const char *word)
-{
-	nameid_t nameid;
-	blockid_t nameblock, newblock, nametail, newtail;
-	struct _wordcache *cache;
-
-	g_error("Dont use wordindex::add()");
-	abort();
-
-	cache = add_index_cache(idx, word);
-
-	/* get the nameid and block start for this name */
-	add_index_key(idx->nameindex, name, &nameid, &nameblock, &nametail);
-
-	/* check for repeats of the last name - dont add anything */
-	if (cache->filecount == 1 && cache->filealloc == 0) {
-		if (cache->file.file0 == nameid)
-			return;
-	} else {
-		if (cache->file.files[cache->filecount] == nameid)
-			return;
-	}
-
-	/* see if we are setting the first, drop it in the union */
-	if (cache->filecount == 0 && cache->filealloc == 0) {
-		cache->file.file0 = nameid;
-	} else if (cache->filecount == 1 && cache->filealloc == 0) {
-		nameid_t saveid;
-		/* we need to allocate space for words */
-		saveid = cache->file.file0;
-		cache->file.files = g_malloc(sizeof(cache->file.files[0]) * CACHE_FILE_COUNT);
-		/* this could possibly grow as needed, but i wont for now */
-		cache->filealloc = CACHE_FILE_COUNT;
-		cache->file.files[0] = saveid;
-		cache->file.files[1] = nameid;
-	} else {
-		cache->file.files[cache->filecount] = nameid;
-	}
-
-	cache->filecount++;
-
-	/* if we are full, force a flush now */
-	if (cache->filealloc && cache->filecount >= cache->filealloc) {
-		sync_cache_entry(idx, cache);
-	}
-
-	newtail = nametail;
-	newblock = nameblock;
-	idx->namestore->klass->add(idx->namestore, &newblock, &newtail, cache->wordid);
-	if (newblock != nameblock || newtail != nametail) {
-		idx->nameindex->klass->set_data(idx->nameindex, nameid, newblock, newtail);
-	}
-}
-
-/* adds a bunch of words to a given name */
-static void add_list(struct _IBEXWord *idx, const char *name, GPtrArray *words)
-{
-	int i;
-	GArray *data = g_array_new(0, 0, sizeof(nameid_t));
-	blockid_t nameblock, newblock, nametail, newtail;
-	nameid_t nameid;
-	struct _wordcache *cache;
-
-	d(printf("Adding words to name %s\n", name));
-
-	d(cache_sanity(idx));
-
-	/* make sure we keep the namecache in sync, if it is active */
-	if (idx->nameinit && g_hash_table_lookup(idx->namecache, name) == NULL) {
-		g_hash_table_insert(idx->namecache, g_strdup(name), (void *)TRUE);
-		/* we know we dont have it in the disk hash either, so we insert anew (saves a lookup) */
-		nameid = idx->nameindex->klass->insert(idx->nameindex, name, strlen(name));
-		nameblock = 0;
-		nametail = 0;
-	} else {
-		/* get the nameid and block start for this name */
-		add_index_key(idx->nameindex, name, &nameid, &nameblock, &nametail);
-	}
-
-	d(cache_sanity(idx));
-
-	for (i=0;i<words->len;i++) {
-		char *word = words->pdata[i];
-
-		cache = add_index_cache(idx, word);
-
-		/*d(cache_sanity(idx));*/
-
-		/* check for duplicates; doesn't catch duplicates over an overflow boundary.  Watch me care. */
-		if (cache->filecount == 0
-		    /* the 1 item case */
-		    || (cache->filecount == 1 && cache->filealloc == 0 && cache->file.file0 != nameid)
-		    /* the normal case */
-		    || (cache->filealloc > 0 && cache->file.files[cache->filecount-1] != nameid)) {
-
-			/* see if we are setting the first, drop it in the union */
-			if (cache->filecount == 0 && cache->filealloc == 0) {
-				cache->file.file0 = nameid;
-			} else if (cache->filecount == 1 && cache->filealloc == 0) {
-				nameid_t saveid;
-				/* we need to allocate space for words */
-				saveid = cache->file.file0;
-				cache->file.files = g_malloc(sizeof(cache->file.files[0]) * CACHE_FILE_COUNT);
-				/* this could possibly grow as needed, but i wont for now */
-				cache->filealloc = CACHE_FILE_COUNT;
-				cache->file.files[0] = saveid;
-				cache->file.files[1] = nameid;
-			} else {
-				cache->file.files[cache->filecount] = nameid;
-			}
-
-			cache->filecount++;
-
-			/* if we are full, force a flush now */
-			if (cache->filealloc && cache->filecount >= cache->filealloc) {
-				sync_cache_entry(idx, cache);
-			}
-
-			/*d(cache_sanity(idx));*/
-
-			/* and append this wordid for this name in memory */
-			g_array_append_val(data, cache->wordid);
-		}
-
-		/*d(cache_sanity(idx));*/
-	}
-
-	d(cache_sanity(idx));
-
-	/* and append these word id's in one go */
-	newblock = nameblock;
-	newtail = nametail;
-	idx->namestore->klass->add_list(idx->namestore, &newblock, &newtail, data);
-	if (newblock != nameblock || newtail != nametail) {
-		idx->nameindex->klass->set_data(idx->nameindex, nameid, newblock, newtail);
-	}
-
-	d(cache_sanity(idx));
-
-	g_array_free(data, TRUE);
-}
-
-/* sync any in-memory data to disk */
-static int
-word_sync(struct _IBEXWord *idx)
-{
-	/* we just flush also, save memory */
-	word_flush(idx);
-
-#if 0
-	struct _wordcache *cache = (struct _wordcache *)idx->wordnodes.head;
-
-	while (cache->next) {
-		sync_cache_entry(idx, cache);
-		cache = cache->next;
-	}
-
-	/*ibex_hash_dump(idx->wordindex);*/
-	/*ibex_hash_dump(idx->nameindex);*/
-#endif
-	return 0;
-}
-
-static gboolean
-free_key(void *key, void *value, void *data)
-{
-	g_free(key);
-
-	return TRUE;
-}
-
-/* sync and flush any in-memory data to disk and free it */
-static int
-word_flush(struct _IBEXWord *idx)
-{
-	d(cache_sanity(idx));
-
-	g_hash_table_foreach_remove(idx->wordcache, sync_free_value, idx);
-	idx->wordcount = 0;
-	if (idx->nameinit) {
-		g_hash_table_foreach_remove(idx->namecache, free_key, NULL);
-		idx->nameinit = FALSE;
-	}
-	return 0;
-}
-
-static int word_close(struct _IBEXWord *idx)
-{
-	idx->klass->flush(idx);
-
-	idx->namestore->klass->close(idx->namestore);
-	idx->nameindex->klass->close(idx->nameindex);
-	/*same as namestore:
-	  idx->wordstore->klass->close(idx->wordstore);*/
-	idx->wordindex->klass->close(idx->wordindex);
-	g_hash_table_destroy(idx->wordcache);
-	g_hash_table_destroy(idx->namecache);
-	g_free(idx);
-
-	return 0;
-}
-
-/* debugging/tuning function */
-
-struct _stats {
-	int memcache;		/* total memory used by cache entries */
-	int memfile;		/* total mem ysed by file data */
-	int memfileused;	/* actual memory used by file data */
-	int memword;		/* total mem used by words */
-	int file1;		/* total file entries with only 1 entry */
-	int total;
-};
-
-static void
-get_info(void *key, void *value, void *data)
-{
-	struct _wordcache *cache = (struct _wordcache *)value;
-	struct _stats *stats = (struct _stats *)data;
-
-	/* round up to probable alignment, + malloc overheads */
-	stats->memcache += ((sizeof(struct _wordcache) + strlen(cache->word) + 4 + 3) & ~3);
-	if (cache->filealloc > 0) {
-		/* size of file array data */
-		stats->memcache += sizeof(nameid_t) * cache->filealloc + 4;
-		/* actual used memory */
-		stats->memfile += sizeof(nameid_t) * cache->filealloc;
-		stats->memfileused += sizeof(nameid_t) * cache->filecount;
-	}
-	if (cache->filecount == 1 && cache->filealloc == 0)
-		stats->file1++;
-
-	stats->memword += strlen(cache->word);
-	stats->total++;
-}
-
-static char *
-num(int num)
-{
-	int n;
-	static char buf[256];
-	char *p = buf;
-	char type = 0;
-
-	n = num;
-	if (n>1000000) {
-		p+= sprintf(p, "%d ", n/1000000);
-		n -= (n/1000000)*1000000;
-		type = 'M';
-	}
-	if (n>1000) {
-		if (num>1000000)
-			p+= sprintf(p, "%03d ", n/1000);
-		else
-			p+= sprintf(p, "%d ", n/1000);
-		n -= (n/1000)*1000;
-		if (type == 0)
-			type = 'K';
-	}
-	if (num > 1000)
-		p += sprintf(p, "%03d", n);
-	else
-		p += sprintf(p, "%d", n);
-
-	n = num;
-	switch (type) {
-	case 'M':
-		p += sprintf(p, ", %d.%02dM", n/1024/1024, n*100/1024/1024);
-		break;
-	case 'K':
-		p += sprintf(p, ", %d.%02dK", n/1024, n*100/1024);
-		break;
-	case 0:
-		break;
-	}
-
-	return buf;
-}
-
-void word_index_mem_dump_info(struct _IBEXWord *idx);
-
-void word_index_mem_dump_info(struct _IBEXWord *idx)
-{
-	struct _stats stats = { 0 };
-	int useful;
-
-	g_hash_table_foreach(idx->wordcache, get_info, &stats);
-
-	useful = stats.total * sizeof(struct _wordcache) + stats.memword + stats.memfile;
-
-	printf("Word Index Stats:\n");
-	printf("Total word count: %d\n", stats.total);
-	printf("Total memory used: %s\n", num(stats.memcache));
-	printf("Total useful memory: %s\n", num(useful));
-	printf("Total malloc/alignment overhead: %s\n", num(stats.memcache - useful));
-	printf("Total buffer overhead: %s\n", num(stats.memfile - stats.memfileused));
-	printf("Space taken by words: %s\n", num(stats.memword + stats.total));
-	printf("Number of 1-word entries: %s\n", num(stats.file1));
-	if (stats.memcache > 0)
-		printf("%% unused space: %d %%\n", (stats.memfile - stats.memfileused) * 100 / stats.memcache);
-}
-