Initial revision

CVS patchset: 5213
CVS date: 2001/12/06 00:07:07

31 files changed, 8107 insertions, 0 deletions

diff --git a/db/build_win32/db_cxx.h b/db/build_win32/db_cxx.h
new file mode 100644
index 000000000..df7e1ddfd
--- /dev/null
+++ b/db/build_win32/db_cxx.h
@@ -0,0 +1,727 @@
+/* DO NOT EDIT: automatically built by dist/s_win32. */
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997-2001
+ *	Sleepycat Software.  All rights reserved.
+ *
+ * Id: db_cxx.in,v 11.87 2001/11/09 21:31:35 bostic Exp 
+ */
+
+#ifndef _DB_CXX_H_
+#define	_DB_CXX_H_
+//
+// C++ assumptions:
+//
+// To ensure portability to many platforms, both new and old, we make
+// few assumptions about the C++ compiler and library.  For example,
+// we do not expect STL, templates or namespaces to be available.  The
+// "newest" C++ feature used is exceptions, which are used liberally
+// to transmit error information.  Even the use of exceptions can be
+// disabled at runtime, to do so, use the DB_CXX_NO_EXCEPTIONS flags
+// with the DbEnv or Db constructor.
+//
+// C++ naming conventions:
+//
+//  - All top level class names start with Db.
+//  - All class members start with lower case letter.
+//  - All private data members are suffixed with underscore.
+//  - Use underscores to divide names into multiple words.
+//  - Simple data accessors are named with get_ or set_ prefix.
+//  - All method names are taken from names of functions in the C
+//    layer of db (usually by dropping a prefix like "db_").
+//    These methods have the same argument types and order,
+//    other than dropping the explicit arg that acts as "this".
+//
+// As a rule, each DbFoo object has exactly one underlying DB_FOO struct
+// (defined in db.h) associated with it.  In some cases, we inherit directly
+// from the DB_FOO structure to make this relationship explicit.  Often,
+// the underlying C layer allocates and deallocates these structures, so
+// there is no easy way to add any data to the DbFoo class.  When you see
+// a comment about whether data is permitted to be added, this is what
+// is going on.  Of course, if we need to add data to such C++ classes
+// in the future, we will arrange to have an indirect pointer to the
+// DB_FOO struct (as some of the classes already have).
+//
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Forward declarations
+//
+
+#include <stdarg.h>
+
+#define	HAVE_CXX_STDHEADERS 1
+#ifdef HAVE_CXX_STDHEADERS
+#include <iostream>
+#define	OSTREAMCLASS	std::ostream
+#else
+#include <iostream.h>
+#define	OSTREAMCLASS	ostream
+#endif
+
+#include "db.h"
+#include "cxx_common.h"
+#include "cxx_except.h"
+
+class Db;                                        // forward
+class Dbc;                                       // forward
+class DbEnv;                                     // forward
+class DbInfo;                                    // forward
+class DbLock;                                    // forward
+class DbLogc;                                    // forward
+class DbLsn;                                     // forward
+class DbMpoolFile;                               // forward
+class Dbt;                                       // forward
+class DbTxn;                                     // forward
+
+// These classes are not defined here and should be invisible
+// to the user, but some compilers require forward references.
+// There is one for each use of the DEFINE_DB_CLASS macro.
+
+class DbImp;
+class DbEnvImp;
+class DbMpoolFileImp;
+class DbTxnImp;
+
+// DEFINE_DB_CLASS defines an imp_ data member and imp() accessor.
+// The underlying type is a pointer to an opaque *Imp class, that
+// gets converted to the correct implementation class by the implementation.
+//
+// Since these defines use "private/public" labels, and leave the access
+// being "private", we always use these by convention before any data
+// members in the private section of a class.  Keeping them in the
+// private section also emphasizes that they are off limits to user code.
+//
+#define	DEFINE_DB_CLASS(name) \
+	public: class name##Imp* imp() { return (imp_); } \
+	public: const class name##Imp* constimp() const { return (imp_); } \
+	private: class name##Imp* imp_
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Turn off inappropriate compiler warnings
+//
+
+#ifdef _MSC_VER
+
+// These are level 4 warnings that are explicitly disabled.
+// With Visual C++, by default you do not see above level 3 unless
+// you use /W4.  But we like to compile with the highest level
+// warnings to catch other errors.
+//
+// 4201: nameless struct/union
+//       triggered by standard include file <winnt.h>
+//
+// 4514: unreferenced inline function has been removed
+//       certain include files in MSVC define methods that are not called
+//
+#pragma warning(disable: 4201 4514)
+
+#endif
+
+// Some interfaces can be customized by allowing users to define
+// callback functions.  For performance and logistical reasons, some
+// callback functions must be declared in extern "C" blocks.  For others,
+// we allow you to declare the callbacks in C++ or C (or an extern "C"
+// block) as you wish.  See the set methods for the callbacks for
+// the choices.
+//
+extern "C" {
+	typedef void * (*db_malloc_fcn_type)
+		(size_t);
+	typedef void * (*db_realloc_fcn_type)
+		(void *, size_t);
+	typedef void (*db_free_fcn_type)
+		(void *);
+	typedef int (*bt_compare_fcn_type)          /*C++ version available*/
+		(DB *, const DBT *, const DBT *);
+	typedef size_t (*bt_prefix_fcn_type)        /*C++ version available*/
+		(DB *, const DBT *, const DBT *);
+	typedef int (*dup_compare_fcn_type)         /*C++ version available*/
+		(DB *, const DBT *, const DBT *);
+	typedef u_int32_t (*h_hash_fcn_type)        /*C++ version available*/
+		(DB *, const void *, u_int32_t);
+	typedef int (*pgin_fcn_type)
+		(DB_ENV *dbenv, db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
+	typedef int (*pgout_fcn_type)
+		(DB_ENV *dbenv, db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Lock classes
+//
+
+class _exported DbLock
+{
+	friend class DbEnv;
+
+public:
+	DbLock();
+
+	int put(DbEnv *env);
+
+	DbLock(const DbLock &);
+	DbLock &operator = (const DbLock &);
+
+protected:
+	// We can add data to this class if needed
+	// since its contained class is not allocated by db.
+	// (see comment at top)
+
+	DbLock(DB_LOCK);
+	DB_LOCK lock_;
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Log classes
+//
+
+class _exported DbLsn : protected DB_LSN
+{
+	friend class DbEnv;          // friendship needed to cast to base class
+	friend class DbLogc;         // friendship needed to cast to base class
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Memory pool classes
+//
+
+class _exported DbMpoolFile
+{
+	friend class DbEnv;
+
+public:
+	int close(u_int32_t flags);
+	int get(db_pgno_t *pgnoaddr, u_int32_t flags, void *pagep);
+	void last_pgno(db_pgno_t *pgnoaddr);
+	int open(const char *file, u_int32_t flags, int mode, size_t pagesize);
+	int put(void *pgaddr, u_int32_t flags);
+	void refcnt(db_pgno_t *pgnoaddr);
+	int set(void *pgaddr, u_int32_t flags);
+	int set_clear_len(u_int32_t len);
+	int set_fileid(u_int8_t *fileid);
+	int set_ftype(int ftype);
+	int set_lsn_offset(int32_t offset);
+	int set_pgcookie(DBT *dbt);
+	void set_unlink(int);
+	int sync();
+
+private:
+	// We can add data to this class if needed
+	// since it is implemented via a pointer.
+	// (see comment at top)
+
+	// Note: use DbEnv::memp_fcreate() to get pointers to a DbMpoolFile,
+	// and call DbMpoolFile::close() rather than delete to release them.
+	//
+	DbMpoolFile();
+
+	// Shut g++ up.
+protected:
+	~DbMpoolFile();
+
+private:
+	// no copying
+	DbMpoolFile(const DbMpoolFile &);
+	void operator = (const DbMpoolFile &);
+
+	DEFINE_DB_CLASS(DbMpoolFile);
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Transaction classes
+//
+
+class _exported DbTxn
+{
+	friend class DbEnv;
+
+public:
+	int abort();
+	int commit(u_int32_t flags);
+	u_int32_t id();
+	int prepare(u_int8_t *gid);
+	int set_timeout(db_timeout_t timeout, u_int32_t flags);
+
+private:
+	// We can add data to this class if needed
+	// since it is implemented via a pointer.
+	// (see comment at top)
+
+	// Note: use DbEnv::txn_begin() to get pointers to a DbTxn,
+	// and call DbTxn::abort() or DbTxn::commit rather than
+	// delete to release them.
+	//
+	DbTxn();
+	~DbTxn();
+
+	// no copying
+	DbTxn(const DbTxn &);
+	void operator = (const DbTxn &);
+
+	DEFINE_DB_CLASS(DbTxn);
+};
+
+//
+// Berkeley DB environment class.  Provides functions for opening databases.
+// User of this library can use this class as a starting point for
+// developing a DB application - derive their application class from
+// this one, add application control logic.
+//
+// Note that if you use the default constructor, you must explicitly
+// call appinit() before any other db activity (e.g. opening files)
+//
+class _exported DbEnv
+{
+	friend class Db;
+	friend class DbLock;
+	friend class DbMpoolFile;
+
+public:
+
+	~DbEnv();
+
+	// After using this constructor, you can set any needed
+	// parameters for the environment using the set_* methods.
+	// Then call open() to finish initializing the environment
+	// and attaching it to underlying files.
+	//
+	DbEnv(u_int32_t flags);
+
+	// These methods match those in the C interface.
+	//
+	int close(u_int32_t);
+	void err(int, const char *, ...);
+	void errx(const char *, ...);
+	void *get_app_private() const;
+	int open(const char *, u_int32_t, int);
+	int remove(const char *, u_int32_t);
+	int set_alloc(db_malloc_fcn_type, db_realloc_fcn_type,
+		      db_free_fcn_type);
+	void set_app_private(void *);
+	int set_cachesize(u_int32_t, u_int32_t, int);
+	int set_data_dir(const char *);
+	void set_errcall(void (*)(const char *, char *));
+	void set_errfile(FILE *);
+	void set_errpfx(const char *);
+	int set_flags(u_int32_t, int);
+	int set_feedback(void (*)(DbEnv *, int, int));
+	int set_recovery_init(int (*)(DbEnv *));
+	int set_lg_bsize(u_int32_t);
+	int set_lg_dir(const char *);
+	int set_lg_max(u_int32_t);
+	int set_lg_regionmax(u_int32_t);
+	int set_lk_conflicts(u_int8_t *, int);
+	int set_lk_detect(u_int32_t);
+	int set_lk_max(u_int32_t);
+	int set_lk_max_lockers(u_int32_t);
+	int set_lk_max_locks(u_int32_t);
+	int set_lk_max_objects(u_int32_t);
+	int set_mp_mmapsize(size_t);
+	int set_paniccall(void (*)(DbEnv *, int));
+	int set_rpc_server(void *, char *, long, long, u_int32_t);
+	int set_shm_key(long);
+	int set_timeout(db_timeout_t timeout, u_int32_t flags);
+	int set_tmp_dir(const char *);
+	int set_tas_spins(u_int32_t);
+	int set_tx_max(u_int32_t);
+	int set_tx_recover(int (*)(DbEnv *, Dbt *, DbLsn *, db_recops));
+	int set_tx_timestamp(time_t *);
+	int set_verbose(u_int32_t which, int onoff);
+
+	// Version information.  A static method so it can be obtained anytime.
+	//
+	static char *version(int *major, int *minor, int *patch);
+
+	// Convert DB errors to strings
+	static char *strerror(int);
+
+	// If an error is detected and the error call function
+	// or stream is set, a message is dispatched or printed.
+	// If a prefix is set, each message is prefixed.
+	//
+	// You can use set_errcall() or set_errfile() above to control
+	// error functionality.  Alternatively, you can call
+	// set_error_stream() to force all errors to a C++ stream.
+	// It is unwise to mix these approaches.
+	//
+	void set_error_stream(OSTREAMCLASS *);
+
+	// used internally
+	static void runtime_error(const char *caller, int err,
+				  int error_policy);
+	static void runtime_error_dbt(const char *caller, Dbt *dbt,
+				  int error_policy);
+
+	// Lock functions
+	//
+	int lock_detect(u_int32_t flags, u_int32_t atype, int *aborted);
+	int lock_get(u_int32_t locker, u_int32_t flags, const Dbt *obj,
+		     db_lockmode_t lock_mode, DbLock *lock);
+	int lock_id(u_int32_t *idp);
+	int lock_id_free(u_int32_t id);
+	int lock_stat(DB_LOCK_STAT **statp, u_int32_t flags);
+	int lock_vec(u_int32_t locker, u_int32_t flags, DB_LOCKREQ list[],
+		     int nlist, DB_LOCKREQ **elistp);
+
+	// Log functions
+	//
+	int log_archive(char **list[], u_int32_t flags);
+	static int log_compare(const DbLsn *lsn0, const DbLsn *lsn1);
+	int log_cursor(DbLogc **cursorp, u_int32_t flags);
+	int log_file(DbLsn *lsn, char *namep, size_t len);
+	int log_flush(const DbLsn *lsn);
+	int log_put(DbLsn *lsn, const Dbt *data, u_int32_t flags);
+
+	int log_register(Db *dbp, const char *name);
+	int log_stat(DB_LOG_STAT **spp, u_int32_t flags);
+	int log_unregister(Db *dbp);
+
+	// Mpool functions
+	//
+	int memp_fcreate(DbMpoolFile **dbmfp, u_int32_t flags);
+	int memp_register(int ftype,
+			  pgin_fcn_type pgin_fcn,
+			  pgout_fcn_type pgout_fcn);
+	int memp_stat(DB_MPOOL_STAT
+		      **gsp, DB_MPOOL_FSTAT ***fsp, u_int32_t flags);
+	int memp_sync(DbLsn *lsn);
+	int memp_trickle(int pct, int *nwrotep);
+
+	// Transaction functions
+	//
+	int txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags);
+	int txn_checkpoint(u_int32_t kbyte, u_int32_t min, u_int32_t flags);
+	int txn_recover(DB_PREPLIST *preplist, long count,
+			long *retp, u_int32_t flags);
+	int txn_stat(DB_TXN_STAT **statp, u_int32_t flags);
+
+	// Replication functions
+	//
+	int rep_elect(int, int, u_int32_t, int *);
+	int rep_process_message(Dbt *, Dbt *, int *);
+	int rep_start(Dbt *, u_int32_t);
+	int set_rep_transport(u_int32_t,
+	    int (*)(DbEnv *, const Dbt *, const Dbt *, int, u_int32_t));
+
+	// Conversion functions
+	//
+	DB_ENV *get_DB_ENV()
+	{
+		return (DB_ENV *)imp();
+	}
+
+	const DB_ENV *get_const_DB_ENV() const
+	{
+		return (const DB_ENV *)constimp();
+	}
+
+	static DbEnv* get_DbEnv(DB_ENV *dbenv)
+	{
+		return (DbEnv *)dbenv->cj_internal;
+	}
+
+	static const DbEnv* get_const_DbEnv(const DB_ENV *dbenv)
+	{
+		return (const DbEnv *)dbenv->cj_internal;
+	}
+
+	// These are public only because they need to be called
+	// via C functions.  They should never be called by users
+	// of this class.
+	//
+	static void _stream_error_function(const char *, char *);
+	static int _tx_recover_intercept(DB_ENV *env, DBT *dbt, DB_LSN *lsn,
+					db_recops op);
+	static void _paniccall_intercept(DB_ENV *env, int errval);
+	static int _recovery_init_intercept(DB_ENV *env);
+	static void _feedback_intercept(DB_ENV *env, int opcode, int pct);
+	static int _rep_send_intercept(DB_ENV *env,
+				       const DBT *cntrl, const DBT *data,
+				       int id, u_int32_t flags);
+	static void _destroy_check(const char *str, int isDbEnv);
+
+private:
+	void cleanup();
+	int initialize(DB_ENV *env);
+	int error_policy();
+
+	// Used internally
+	DbEnv(DB_ENV *, u_int32_t flags);
+
+	// no copying
+	DbEnv(const DbEnv &);
+	void operator = (const DbEnv &);
+
+	DEFINE_DB_CLASS(DbEnv);
+
+	// instance data
+	int construct_error_;
+	u_int32_t construct_flags_;
+	int (*tx_recover_callback_)(DbEnv *, Dbt *, DbLsn *, db_recops);
+	int (*recovery_init_callback_)(DbEnv *);
+	void (*paniccall_callback_)(DbEnv *, int);
+	void (*feedback_callback_)(DbEnv *, int, int);
+	int (*pgin_callback_)(DbEnv *dbenv, db_pgno_t pgno,
+			      void *pgaddr, Dbt *pgcookie);
+	int (*pgout_callback_)(DbEnv *dbenv, db_pgno_t pgno,
+			       void *pgaddr, Dbt *pgcookie);
+	int (*rep_send_callback_)(DbEnv *,
+	    const Dbt *, const Dbt *, int, u_int32_t);
+
+	// class data
+	static OSTREAMCLASS *error_stream_;
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Table access classes
+//
+
+//
+// Represents a database table = a set of keys with associated values.
+//
+class _exported Db
+{
+	friend class DbEnv;
+
+public:
+	Db(DbEnv*, u_int32_t);      // create a Db object, then call open()
+	~Db();                      // does *not* call close.
+
+	// These methods exactly match those in the C interface.
+	//
+	int associate(Db *secondary, int (*callback)(Db *, const Dbt *,
+		const Dbt *, Dbt *), u_int32_t flags);
+	int close(u_int32_t flags);
+	int cursor(DbTxn *txnid, Dbc **cursorp, u_int32_t flags);
+	int del(DbTxn *txnid, Dbt *key, u_int32_t flags);
+	void err(int, const char *, ...);
+	void errx(const char *, ...);
+	int fd(int *fdp);
+	int get(DbTxn *txnid, Dbt *key, Dbt *data, u_int32_t flags);
+	void *get_app_private() const;
+	int get_byteswapped(int *);
+	int get_type(DBTYPE *);
+	int join(Dbc **curslist, Dbc **dbcp, u_int32_t flags);
+	int key_range(DbTxn *, Dbt *, DB_KEY_RANGE *, u_int32_t);
+	int open(const char *, const char *subname, DBTYPE, u_int32_t, int);
+	int pget(DbTxn *txnid, Dbt *key, Dbt *pkey, Dbt *data,
+		 u_int32_t flags);
+	int put(DbTxn *, Dbt *, Dbt *, u_int32_t);
+	int remove(const char *, const char *, u_int32_t);
+	int rename(const char *, const char *, const char *, u_int32_t);
+	int set_alloc(db_malloc_fcn_type, db_realloc_fcn_type,
+		      db_free_fcn_type);
+	void set_app_private(void *);
+	int set_append_recno(int (*)(Db *, Dbt *, db_recno_t));
+	int set_bt_compare(bt_compare_fcn_type); /*deprecated*/
+	int set_bt_compare(int (*)(Db *, const Dbt *, const Dbt *));
+	int set_bt_maxkey(u_int32_t);
+	int set_bt_minkey(u_int32_t);
+	int set_bt_prefix(bt_prefix_fcn_type); /*deprecated*/
+	int set_bt_prefix(size_t (*)(Db *, const Dbt *, const Dbt *));
+	int set_cachesize(u_int32_t, u_int32_t, int);
+	int set_dup_compare(dup_compare_fcn_type); /*deprecated*/
+	int set_dup_compare(int (*)(Db *, const Dbt *, const Dbt *));
+	void set_errcall(void (*)(const char *, char *));
+	void set_errfile(FILE *);
+	void set_errpfx(const char *);
+	int set_feedback(void (*)(Db *, int, int));
+	int set_flags(u_int32_t);
+	int set_h_ffactor(u_int32_t);
+	int set_h_hash(h_hash_fcn_type); /*deprecated*/
+	int set_h_hash(u_int32_t (*)(Db *, const void *, u_int32_t));
+	int set_h_nelem(u_int32_t);
+	int set_lorder(int);
+	int set_pagesize(u_int32_t);
+	int set_paniccall(void (*)(DbEnv *, int));
+	int set_re_delim(int);
+	int set_re_len(u_int32_t);
+	int set_re_pad(int);
+	int set_re_source(char *);
+	int set_q_extentsize(u_int32_t);
+	int stat(void *sp, u_int32_t flags);
+	int sync(u_int32_t flags);
+	int truncate(DbTxn *, u_int32_t *, u_int32_t);
+	int upgrade(const char *name, u_int32_t flags);
+	int verify(const char *, const char *, OSTREAMCLASS *, u_int32_t);
+
+	// These additional methods are not in the C interface, and
+	// are only available for C++.
+	//
+	void set_error_stream(OSTREAMCLASS *);
+
+	DB *get_DB()
+	{
+		return (DB *)imp();
+	}
+
+	const DB *get_const_DB() const
+	{
+		return (const DB *)constimp();
+	}
+
+	static Db* get_Db(DB *db)
+	{
+		return (Db *)db->cj_internal;
+	}
+
+	static const Db* get_const_Db(const DB *db)
+	{
+		return (const Db *)db->cj_internal;
+	}
+
+	// These are public only because they need to be called
+	// via C callback functions.  They should never be used by
+	// external users of this class.
+	//
+	void (*feedback_callback_)(Db *, int, int);
+	int (*append_recno_callback_)(Db *, Dbt *, db_recno_t);
+	int (*bt_compare_callback_)(Db *, const Dbt *, const Dbt *);
+	size_t (*bt_prefix_callback_)(Db *, const Dbt *, const Dbt *);
+	int (*dup_compare_callback_)(Db *, const Dbt *, const Dbt *);
+	u_int32_t (*h_hash_callback_)(Db *, const void *, u_int32_t);
+	int (*associate_callback_)(Db *, const Dbt *, const Dbt *, Dbt *);
+private:
+
+	// no copying
+	Db(const Db &);
+	Db &operator = (const Db &);
+
+	DEFINE_DB_CLASS(Db);
+
+	void cleanup();
+	int initialize();
+	int error_policy();
+
+	// instance data
+	DbEnv *env_;
+	int construct_error_;
+	u_int32_t flags_;
+	u_int32_t construct_flags_;
+};
+
+//
+// A chunk of data, maybe a key or value.
+//
+class _exported Dbt : private DBT
+{
+	friend class Dbc;
+	friend class Db;
+	friend class DbEnv;
+	friend class DbLogc;
+
+public:
+
+	// key/data
+	void *get_data() const                 { return data; }
+	void set_data(void *value)             { data = value; }
+
+	// key/data length
+	u_int32_t get_size() const             { return size; }
+	void set_size(u_int32_t value)         { size = value; }
+
+	// RO: length of user buffer.
+	u_int32_t get_ulen() const             { return ulen; }
+	void set_ulen(u_int32_t value)         { ulen = value; }
+
+	// RO: get/put record length.
+	u_int32_t get_dlen() const             { return dlen; }
+	void set_dlen(u_int32_t value)         { dlen = value; }
+
+	// RO: get/put record offset.
+	u_int32_t get_doff() const             { return doff; }
+	void set_doff(u_int32_t value)         { doff = value; }
+
+	// flags
+	u_int32_t get_flags() const            { return flags; }
+	void set_flags(u_int32_t value)        { flags = value; }
+
+	// Conversion functions
+	DBT *get_DBT()                         { return (DBT *)this; }
+	const DBT *get_const_DBT() const       { return (const DBT *)this; }
+
+	static Dbt* get_Dbt(DBT *dbt)          { return (Dbt *)dbt; }
+	static const Dbt* get_const_Dbt(const DBT *dbt)
+					       { return (const Dbt *)dbt; }
+
+	Dbt(void *data, size_t size);
+	Dbt();
+	~Dbt();
+	Dbt(const Dbt &);
+	Dbt &operator = (const Dbt &);
+
+private:
+	// Note: no extra data appears in this class (other than
+	// inherited from DBT) since we need DBT and Dbt objects
+	// to have interchangable pointers.
+	//
+	// When subclassing this class, remember that callback
+	// methods like bt_compare, bt_prefix, dup_compare may
+	// internally manufacture DBT objects (which later are
+	// cast to Dbt), so such callbacks might receive objects
+	// not of your subclassed type.
+};
+
+class _exported Dbc : protected DBC
+{
+	friend class Db;
+
+public:
+	int close();
+	int count(db_recno_t *countp, u_int32_t flags);
+	int del(u_int32_t flags);
+	int dup(Dbc** cursorp, u_int32_t flags);
+	int get(Dbt* key, Dbt *data, u_int32_t flags);
+	int pget(Dbt* key, Dbt* pkey, Dbt *data, u_int32_t flags);
+	int put(Dbt* key, Dbt *data, u_int32_t flags);
+
+private:
+	// No data is permitted in this class (see comment at top)
+
+	// Note: use Db::cursor() to get pointers to a Dbc,
+	// and call Dbc::close() rather than delete to release them.
+	//
+	Dbc();
+	~Dbc();
+
+	// no copying
+	Dbc(const Dbc &);
+	Dbc &operator = (const Dbc &);
+};
+
+class _exported DbLogc : protected DB_LOGC
+{
+	friend class DbEnv;
+
+public:
+	int close(u_int32_t _flags);
+	int get(DbLsn *lsn, Dbt *data, u_int32_t _flags);
+
+private:
+	// No data is permitted in this class (see comment at top)
+
+	// Note: use Db::cursor() to get pointers to a Dbc,
+	// and call Dbc::close() rather than delete to release them.
+	//
+	DbLogc();
+	~DbLogc();
+
+	// no copying
+	DbLogc(const Dbc &);
+	DbLogc &operator = (const Dbc &);
+};
+#endif /* !_DB_CXX_H_ */
diff --git a/db/build_win32/db_perf.dsp b/db/build_win32/db_perf.dsp
new file mode 100644
index 000000000..ae3ef78d9
--- /dev/null
+++ b/db/build_win32/db_perf.dsp
@@ -0,0 +1,212 @@
+# Microsoft Developer Studio Project File - Name="db_perf" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=db_perf - Win32 Debug Static
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "db_perf.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "db_perf.mak" CFG="db_perf - Win32 Debug Static"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "db_perf - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "db_perf - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE "db_perf - Win32 Release Static" (based on "Win32 (x86) Console Application")
+!MESSAGE "db_perf - Win32 Debug Static" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "db_perf - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /I "../include" /I "../include_auto" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 Release/libdb40.lib /nologo /subsystem:console /machine:I386 /nodefaultlib:"libcmt"
+
+!ELSEIF  "$(CFG)" == "db_perf - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /GX /Z7 /Od /I "." /I "../include" /I "../include_auto" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 Debug/libdb40d.lib /nologo /subsystem:console /pdb:none /debug /machine:I386 /nodefaultlib:"libcmtd" /fixed:no
+
+!ELSEIF  "$(CFG)" == "db_perf - Win32 Release Static"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release_static"
+# PROP Intermediate_Dir "Release_static"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "." /I "../include" /I "../include_auto" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /I "." /I "../include" /I "../include_auto" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 Release_static/libdb40.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 Release_static/libdb40s.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "db_perf - Win32 Debug Static"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug_static"
+# PROP Intermediate_Dir "Debug_static"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W3 /GX /Z7 /Od /I "." /I "../include" /I "../include_auto" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MTd /W3 /GX /Z7 /Od /I "." /I "../include" /I "../include_auto" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 Debug_static/libdb40d.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /pdb:none /debug /machine:I386 /fixed:no
+# ADD LINK32 Debug_static/libdb40sd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /pdb:none /debug /machine:I386 /fixed:no
+
+!ENDIF 
+
+# Begin Target
+
+# Name "db_perf - Win32 Release"
+# Name "db_perf - Win32 Debug"
+# Name "db_perf - Win32 Release Static"
+# Name "db_perf - Win32 Debug Static"
+# Begin Source File
+
+SOURCE=..\test_perf\db_perf.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\clib\getopt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_cache_check.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_checkpoint.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_config.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_dbs.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_debug.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_file.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_key.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_log.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_misc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_op.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_parse.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_spawn.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_thread.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_trickle.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_txn.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\test_perf\perf_util.c
+# End Source File
+# End Target
+# End Project
diff --git a/db/dist/aclocal/cxx.ac b/db/dist/aclocal/cxx.ac
new file mode 100644
index 000000000..d19171c33
--- /dev/null
+++ b/db/dist/aclocal/cxx.ac
@@ -0,0 +1,17 @@
+# C++ checks to determine what style of headers to use and
+# whether to use "using" clauses.
+
+AC_DEFUN(AC_CXX_HAVE_STDHEADERS, [
+AC_SUBST(cxx_have_stdheaders)
+AC_CACHE_CHECK([whether C++ supports the ISO C++ standard includes],
+db_cv_cxx_have_stdheaders,
+[AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ AC_TRY_COMPILE([#include <iostream>
+],[return 0;],
+ db_cv_cxx_have_stdheaders=yes, db_cv_cxx_have_stdheaders=no)
+ AC_LANG_RESTORE
+])
+if test "$db_cv_cxx_have_stdheaders" = yes; then
+	cxx_have_stdheaders="#define	HAVE_CXX_STDHEADERS 1"
+fi])
diff --git a/db/docs/api_c/rep_elect.html b/db/docs/api_c/rep_elect.html
new file mode 100644
index 000000000..609eae899
--- /dev/null
+++ b/db/docs/api_c/rep_elect.html
@@ -0,0 +1,82 @@
+<!--Id: rep_elect.so,v 1.4 2001/10/26 13:57:00 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DB_ENV-&gt;rep_elect</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DB_ENV-&gt;rep_elect</h1>
+</td>
+<td align=right>
+<a href="../api_c/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+#include &lt;db.h&gt;
+<p>
+int
+DB_ENV-&gt;rep_elect(DB_ENV *env, int nsites,
+    int priority, u_int32_t timeout, int *envid);
+</pre></h3>
+<h1>Description</h1>
+<p>The DB_ENV-&gt;rep_elect function holds an election for the master of a replication
+group, returning the new master's ID in the <b>envid</b> parameter.
+<p>The <b>nsites</b> parameter indicates the number of environments that
+the application believes are in the replication group.  This number is
+used by Berkeley DB to avoid having two masters active simultaneously, even
+in the case of a network partition.  During an election, a new master
+cannot be elected unless more than half of <b>nsites</b> agree on
+the new master.  Thus, in the face of a network partition, the side of
+the partition with more than half the environments will elect a new
+master and continue, while the environments communicating with fewer
+than half the other environments will fail to find a new master.
+<p>The <b>priority</b> parameter is the priority of this environment.  It
+must be a positive integer, or 0 if this environment is not permitted
+to become a master (see <a href="../ref/rep/pri.html">Replication
+environment priorities</a> for more information).
+<a name="3"><!--meow--></a>
+<p>The <b>timeout</b> parameter specifies a timeout period for an
+election.  If the election has not completed after <b>timeout</b>
+microseconds, the thread will return DB_REP_UNAVAIL.
+<p>The DB_ENV-&gt;rep_elect function either returns successfully, with the new
+master's environment ID in the memory pointed to by the <b>envid</b>
+parameter, or it will return DB_REP_UNAVAIL if the participating
+group members were unable to elect a new master for any reason.  In the
+event of a successful return, the new master's ID may be the ID of the
+previous master, or the ID of the current environment.  The application
+is responsible for adjusting its usage of the other environments in the
+replication group, including directing all database updates to the newly
+selected master, in accordance with the results of this election.
+<p>The thread of control that calls the DB_ENV-&gt;rep_elect function must not be the
+thread of control that processes incoming messages; processing the
+incoming messages is necessary to successfully complete an election.
+<p>The DB_ENV-&gt;rep_elect function returns a non-zero error value on failure and 0 on success.
+<h1>Errors</h1>
+<p>The DB_ENV-&gt;rep_elect function may fail and return a non-zero error for the following conditions:
+<p><dl compact>
+<p><dt>DB_REP_UNAVAIL<dd>The replication group was unable to elect a master.
+</dl>
+<p>The DB_ENV-&gt;rep_elect function may fail and return a non-zero error for errors specified for other Berkeley DB and C library or system functions.
+If a catastrophic error has occurred, the DB_ENV-&gt;rep_elect function may fail and return
+<a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a>, in which case all subsequent Berkeley DB calls will fail
+in the same way.
+<h1>See Also</h1>
+<a href="../api_c/rep_start.html">DB_ENV-&gt;rep_start</a>,
+<a href="../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a>,
+<a href="../api_c/rep_message.html">DB_ENV-&gt;rep_process_message</a>,
+and
+<a href="../api_c/rep_transport.html">DB_ENV-&gt;set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_c/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_c/rep_message.html b/db/docs/api_c/rep_message.html
new file mode 100644
index 000000000..ef61b5e49
--- /dev/null
+++ b/db/docs/api_c/rep_message.html
@@ -0,0 +1,82 @@
+<!--Id: rep_message.so,v 1.4 2001/10/25 20:15:23 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DB_ENV-&gt;rep_process_message</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DB_ENV-&gt;rep_process_message</h1>
+</td>
+<td align=right>
+<a href="../api_c/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+#include &lt;db.h&gt;
+<p>
+int
+DB_ENV-&gt;rep_process_message(DB_ENV *env,
+    DBT *control, DBT *rec, int *envid)
+</pre></h3>
+<h1>Description</h1>
+<p>The DB_ENV-&gt;rep_process_message function processes an incoming replication
+message sent by a member of the replication group to the local database
+environment.
+<p>The <b>rec</b> and <b>control</b> parameters should reference a copy
+of the parameters specified by Berkeley DB for the <b>rec</b> and
+<b>control</b> parameters on the sending environment.
+<p>The <b>envid</b> parameter should contain the local identifier that
+corresponds to the environment that sent the message to be processed
+(see <a href="../ref/rep/id.html">Replication environment IDs</a> for more
+information).
+<p>For implementation reasons, all incoming replication messages must be
+processed using the same <a href="../api_c/env_create.html">DB_ENV</a> handle.  It is not required that
+a single thread of control process all messages, only that all threads
+of control processing messages use the same handle.
+<p>The DB_ENV-&gt;rep_process_message function may return one of several special conditions:
+<p><dl compact>
+<p><dt><a name="DB_REP_DUPMASTER">DB_REP_DUPMASTER</a><dd>The replication group has more than one master; the application should
+reconfigure itself as a client by calling the <a href="../api_c/rep_start.html">DB_ENV-&gt;rep_start</a> function, and
+then call for an election by calling <a href="../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a>.
+<p><dt><a name="DB_REP_HOLDELECTION">DB_REP_HOLDELECTION</a><dd>An election is needed, the application should call for an election by
+calling <a href="../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a>.
+<p><dt><a name="DB_REP_NEWMASTER">DB_REP_NEWMASTER</a><dd>A new master has been elected.  The memory location referenced by the
+<b>envid</b> parameter contains the environment ID of the new master.
+If the recipient of this error return has been made master, it is the
+application's responsibility to begin acting as the master environment.
+<p><dt><a name="DB_REP_NEWSITE">DB_REP_NEWSITE</a><dd>The system received contact information from a new environment.  The
+<b>rec</b> parameter contains the opaque data specified in the
+<b>cdata</b> parameter to the <a href="../api_c/rep_start.html">DB_ENV-&gt;rep_start</a>.  The application
+should take whatever action is needed to establish a communication
+channel with this new environment.
+<p><dt><a name="DB_REP_OUTDATED">DB_REP_OUTDATED</a><dd>The current environment's logs are too far out of date with respect to
+the master to be automatically synchronized.  The application should
+copy over a hot backup of the environment, run recovery, and restart
+the client.
+</dl>
+<p>Otherwise, the DB_ENV-&gt;rep_process_message function returns a non-zero error value on failure and 0 on success.
+<h1>Errors</h1>
+<p>The DB_ENV-&gt;rep_process_message function may fail and return a non-zero error for errors specified for other Berkeley DB and C library or system functions.
+If a catastrophic error has occurred, the DB_ENV-&gt;rep_process_message function may fail and return
+<a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a>, in which case all subsequent Berkeley DB calls will fail
+in the same way.
+<h1>See Also</h1>
+<a href="../api_c/rep_start.html">DB_ENV-&gt;rep_start</a>,
+<a href="../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a>,
+<a href="../api_c/rep_message.html">DB_ENV-&gt;rep_process_message</a>,
+and
+<a href="../api_c/rep_transport.html">DB_ENV-&gt;set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_c/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_c/rep_start.html b/db/docs/api_c/rep_start.html
new file mode 100644
index 000000000..b4b7be4c5
--- /dev/null
+++ b/db/docs/api_c/rep_start.html
@@ -0,0 +1,74 @@
+<!--Id: rep_start.so,v 1.2 2001/10/25 14:08:43 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DB_ENV-&gt;rep_start</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DB_ENV-&gt;rep_start</h1>
+</td>
+<td align=right>
+<a href="../api_c/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+#include &lt;db.h&gt;
+<p>
+int
+DB_ENV-&gt;rep_start(DB_ENV *env, DBT *cdata, u_int32_t flags);
+</pre></h3>
+<h1>Description</h1>
+<p>The DB_ENV-&gt;rep_start function configures the database environment as a client
+or master in a group of replicated database environments.  Replication
+master environments are the only database environments where replicated
+databases may be modified.  Replication client environments are
+read-only as long as they are clients.  Replication client environments
+may be upgraded to be replication master environments in the case that
+the current master fails or there is no master present.
+<p>The enclosing database environment must already have been opened by
+calling the <a href="../api_c/env_open.html">DB_ENV-&gt;open</a> function and must already have been configured
+to send replication messages by calling the <a href="../api_c/rep_transport.html">DB_ENV-&gt;set_rep_transport</a> function.
+<p>The <b>cdata</b> parameter is an opaque data item that is sent over
+the communication infrastructure when the client or master comes online
+(see <a href="../ref/rep/newsite.html">Connecting to a new site</a> for
+more information).  If no such information is useful, <b>cdata</b>
+should be NULL.
+<p>The <b>flags</b> value must be set to one of the following values:
+<p><dl compact>
+<p><dt><a name="DB_REP_CLIENT">DB_REP_CLIENT</a><dd>Configure the environment as a replication client.
+<p><dt><a name="DB_REP_LOGSONLY">DB_REP_LOGSONLY</a><dd>Configure the environment as a log files-only client.
+<p><dt><a name="DB_REP_MASTER">DB_REP_MASTER</a><dd>Configure the environment as a replication master.
+</dl>
+<p>The DB_ENV-&gt;rep_start function returns a non-zero error value on failure and 0 on success.
+<h1>Errors</h1>
+<p>The DB_ENV-&gt;rep_start function may fail and return a non-zero error for the following conditions:
+<p><dl compact>
+<p><dt>EINVAL<dd>An invalid flag value or parameter was specified.
+<p>The environment was not already configured to communicate with a
+replication group by a call to <a href="../api_c/rep_transport.html">DB_ENV-&gt;set_rep_transport</a>.
+<p>The environment was not already opened.
+</dl>
+<p>The DB_ENV-&gt;rep_start function may fail and return a non-zero error for errors specified for other Berkeley DB and C library or system functions.
+If a catastrophic error has occurred, the DB_ENV-&gt;rep_start function may fail and return
+<a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a>, in which case all subsequent Berkeley DB calls will fail
+in the same way.
+<h1>See Also</h1>
+<a href="../api_c/rep_start.html">DB_ENV-&gt;rep_start</a>,
+<a href="../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a>,
+<a href="../api_c/rep_message.html">DB_ENV-&gt;rep_process_message</a>,
+and
+<a href="../api_c/rep_transport.html">DB_ENV-&gt;set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_c/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_c/rep_transport.html b/db/docs/api_c/rep_transport.html
new file mode 100644
index 000000000..ac3d59f18
--- /dev/null
+++ b/db/docs/api_c/rep_transport.html
@@ -0,0 +1,92 @@
+<!--Id: rep_transport.so,v 1.4 2001/10/26 23:51:06 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DB_ENV-&gt;set_rep_transport</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DB_ENV-&gt;set_rep_transport</h1>
+</td>
+<td align=right>
+<a href="../api_c/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+#include &lt;db.h&gt;
+<p>
+int
+DB_ENV-&gt;set_rep_transport(DB_ENV *env, int envid,
+    int (*send)(DB_ENV *dbenv,
+    const DBT *control, const DBT *rec, int envid, u_int32_t flags));
+</pre></h3>
+<h1>Description</h1>
+<p>The DB_ENV-&gt;set_rep_transport function initializes the communication infrastructure
+for a database environment participating in a replicated application.
+<p>The <b>envid</b> parameter is the local environment's ID.  It must be
+a positive integer and uniquely identify this Berkeley DB database environment
+(see <a href="../ref/rep/id.html">Replication environment IDs</a> for more
+information).
+<p>The <b>send</b> parameter is a callback interface used to transmit data
+using the replication application's communication infrastructure.  The
+parameters to <b>send</b> are as follows:
+<p><dl compact>
+<p><dt>dbenv<dd>The enclosing database environment.
+<p><dt>control<dd>The control parameter is the first of the two data elements to be
+transmitted by the <b>send</b> interface.
+<p><dt>rec<dd>The rec parameter is the second of the two data elements to be
+transmitted by the <b>send</b> interface.
+<p><dt>envid<dd>The <b>envid</b> parameter is a positive integer identifier that
+specifies the replication environment to which the message should be
+sent (see <a href="../ref/rep/id.html">Replication environment IDs</a> for
+more information).
+<p><a name="3"><!--meow--></a>
+The special identifier DB_EID_BROADCAST indicates that a message
+should be broadcast to every environment in the replication group.  The
+application may use a true broadcast protocol, or may send the message
+in sequence to each machine with which it is in communication.
+<p><dt>flag<dd>
+<p>The <b>flags</b> value must be set to 0 or by bitwise inclusively <b>OR</b>'ing together one or
+more of the following values:
+<p><dl compact>
+<p><dt><a name="DB_REP_PERMANENT">DB_REP_PERMANENT</a><dd>The record being sent is critical for maintaining database integrity
+(for example, the message includes a transaction commit).  The
+application should take appropriate action to enforce the reliability
+guarantees it has chosen, such as waiting for acknowledgement from one
+or more clients.
+</dl>
+</dl>
+<p>The <b>send</b> interface must return 0 on success and non-zero on
+failure.  If the <b>send</b> interface fails, the message being sent
+is necessary to maintain database integrity, and the local log is not
+configured for synchronous flushing, the local log will be flushed;
+otherwise, any error from the <b>send</b> interface will be ignored.
+<p>It may sometimes be useful to pass application-specific data to the
+<b>send</b> interface; see <a href="../ref/env/faq.html">Environment
+FAQ</a> for a discussion on how to do this.
+<p>The <b>flags</b> parameter is currently unused, and must be set to 0.
+<p>The DB_ENV-&gt;set_rep_transport function returns a non-zero error value on failure and 0 on success.
+<h1>Errors</h1>
+<p>The DB_ENV-&gt;set_rep_transport function may fail and return a non-zero error for errors specified for other Berkeley DB and C library or system functions.
+If a catastrophic error has occurred, the DB_ENV-&gt;set_rep_transport function may fail and return
+<a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a>, in which case all subsequent Berkeley DB calls will fail
+in the same way.
+<h1>See Also</h1>
+<a href="../api_c/rep_start.html">DB_ENV-&gt;rep_start</a>,
+<a href="../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a>,
+<a href="../api_c/rep_message.html">DB_ENV-&gt;rep_process_message</a>,
+and
+<a href="../api_c/rep_transport.html">DB_ENV-&gt;set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_c/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_cxx/rep_elect.html b/db/docs/api_cxx/rep_elect.html
new file mode 100644
index 000000000..7aac497e7
--- /dev/null
+++ b/db/docs/api_cxx/rep_elect.html
@@ -0,0 +1,84 @@
+<!--Id: rep_elect.so,v 1.4 2001/10/26 13:57:00 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DbEnv::rep_elect</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DbEnv::rep_elect</h1>
+</td>
+<td align=right>
+<a href="../api_cxx/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+#include &lt;db_cxx.h&gt;
+<p>
+int
+DbEnv::rep_elect(int nsites,
+    int priority, u_int32_t timeout, int *envid);
+</pre></h3>
+<h1>Description</h1>
+<p>The DbEnv::rep_elect method holds an election for the master of a replication
+group, returning the new master's ID in the <b>envid</b> parameter.
+<p>The <b>nsites</b> parameter indicates the number of environments that
+the application believes are in the replication group.  This number is
+used by Berkeley DB to avoid having two masters active simultaneously, even
+in the case of a network partition.  During an election, a new master
+cannot be elected unless more than half of <b>nsites</b> agree on
+the new master.  Thus, in the face of a network partition, the side of
+the partition with more than half the environments will elect a new
+master and continue, while the environments communicating with fewer
+than half the other environments will fail to find a new master.
+<p>The <b>priority</b> parameter is the priority of this environment.  It
+must be a positive integer, or 0 if this environment is not permitted
+to become a master (see <a href="../ref/rep/pri.html">Replication
+environment priorities</a> for more information).
+<a name="3"><!--meow--></a>
+<p>The <b>timeout</b> parameter specifies a timeout period for an
+election.  If the election has not completed after <b>timeout</b>
+microseconds, the thread will return DB_REP_UNAVAIL.
+<p>The DbEnv::rep_elect method either returns successfully, with the new
+master's environment ID in the memory pointed to by the <b>envid</b>
+parameter, or it will return DB_REP_UNAVAIL if the participating
+group members were unable to elect a new master for any reason.  In the
+event of a successful return, the new master's ID may be the ID of the
+previous master, or the ID of the current environment.  The application
+is responsible for adjusting its usage of the other environments in the
+replication group, including directing all database updates to the newly
+selected master, in accordance with the results of this election.
+<p>The thread of control that calls the DbEnv::rep_elect method must not be the
+thread of control that processes incoming messages; processing the
+incoming messages is necessary to successfully complete an election.
+<p>The DbEnv::rep_elect method either returns a non-zero error value or throws an exception that
+encapsulates a non-zero error value on failure, and returns 0 on success.
+<h1>Errors</h1>
+<p>The DbEnv::rep_elect method may fail and throw an exception or return a non-zero error for the following conditions:
+<p><dl compact>
+<p><dt>DB_REP_UNAVAIL<dd>The replication group was unable to elect a master.
+</dl>
+<p>The DbEnv::rep_elect method may fail and throw an exception or return a non-zero error for errors specified for other Berkeley DB and C library or system methods.
+If a catastrophic error has occurred, the DbEnv::rep_elect method may fail and either
+return <a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a> or throw an exception encapsulating
+<a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a>, in which case all subsequent Berkeley DB calls will fail
+in the same way.
+<h1>See Also</h1>
+<a href="../api_cxx/rep_start.html">DbEnv::rep_start</a>,
+<a href="../api_cxx/rep_elect.html">DbEnv::rep_elect</a>,
+<a href="../api_cxx/rep_message.html">DbEnv::rep_process_message</a>,
+and
+<a href="../api_cxx/rep_transport.html">DbEnv::set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_cxx/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_cxx/rep_message.html b/db/docs/api_cxx/rep_message.html
new file mode 100644
index 000000000..4004c3f0e
--- /dev/null
+++ b/db/docs/api_cxx/rep_message.html
@@ -0,0 +1,83 @@
+<!--Id: rep_message.so,v 1.4 2001/10/25 20:15:23 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DbEnv::rep_process_message</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DbEnv::rep_process_message</h1>
+</td>
+<td align=right>
+<a href="../api_cxx/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+#include &lt;db_cxx.h&gt;
+<p>
+int
+DbEnv::rep_process_message(Dbt *control, Dbt *rec, int *envid)
+</pre></h3>
+<h1>Description</h1>
+<p>The DbEnv::rep_process_message method processes an incoming replication
+message sent by a member of the replication group to the local database
+environment.
+<p>The <b>rec</b> and <b>control</b> parameters should reference a copy
+of the parameters specified by Berkeley DB for the <b>rec</b> and
+<b>control</b> parameters on the sending environment.
+<p>The <b>envid</b> parameter should contain the local identifier that
+corresponds to the environment that sent the message to be processed
+(see <a href="../ref/rep/id.html">Replication environment IDs</a> for more
+information).
+<p>For implementation reasons, all incoming replication messages must be
+processed using the same <a href="../api_cxx/dbenv_class.html">DbEnv</a> handle.  It is not required that
+a single thread of control process all messages, only that all threads
+of control processing messages use the same handle.
+<p>The DbEnv::rep_process_message method may return one of several special conditions:
+<p><dl compact>
+<p><dt><a name="DB_REP_DUPMASTER">DB_REP_DUPMASTER</a><dd>The replication group has more than one master; the application should
+reconfigure itself as a client by calling the <a href="../api_cxx/rep_start.html">DbEnv::rep_start</a> method, and
+then call for an election by calling <a href="../api_cxx/rep_elect.html">DbEnv::rep_elect</a>.
+<p><dt><a name="DB_REP_HOLDELECTION">DB_REP_HOLDELECTION</a><dd>An election is needed, the application should call for an election by
+calling <a href="../api_cxx/rep_elect.html">DbEnv::rep_elect</a>.
+<p><dt><a name="DB_REP_NEWMASTER">DB_REP_NEWMASTER</a><dd>A new master has been elected.  The memory location referenced by the
+<b>envid</b> parameter contains the environment ID of the new master.
+If the recipient of this error return has been made master, it is the
+application's responsibility to begin acting as the master environment.
+<p><dt><a name="DB_REP_NEWSITE">DB_REP_NEWSITE</a><dd>The system received contact information from a new environment.  The
+<b>rec</b> parameter contains the opaque data specified in the
+<b>cdata</b> parameter to the <a href="../api_cxx/rep_start.html">DbEnv::rep_start</a>.  The application
+should take whatever action is needed to establish a communication
+channel with this new environment.
+<p><dt><a name="DB_REP_OUTDATED">DB_REP_OUTDATED</a><dd>The current environment's logs are too far out of date with respect to
+the master to be automatically synchronized.  The application should
+copy over a hot backup of the environment, run recovery, and restart
+the client.
+</dl>
+<p>Otherwise, the DbEnv::rep_process_message method either returns a non-zero error value or throws an exception that
+encapsulates a non-zero error value on failure, and returns 0 on success.
+<h1>Errors</h1>
+<p>The DbEnv::rep_process_message method may fail and throw an exception or return a non-zero error for errors specified for other Berkeley DB and C library or system methods.
+If a catastrophic error has occurred, the DbEnv::rep_process_message method may fail and either
+return <a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a> or throw an exception encapsulating
+<a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a>, in which case all subsequent Berkeley DB calls will fail
+in the same way.
+<h1>See Also</h1>
+<a href="../api_cxx/rep_start.html">DbEnv::rep_start</a>,
+<a href="../api_cxx/rep_elect.html">DbEnv::rep_elect</a>,
+<a href="../api_cxx/rep_message.html">DbEnv::rep_process_message</a>,
+and
+<a href="../api_cxx/rep_transport.html">DbEnv::set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_cxx/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_cxx/rep_start.html b/db/docs/api_cxx/rep_start.html
new file mode 100644
index 000000000..3be75a427
--- /dev/null
+++ b/db/docs/api_cxx/rep_start.html
@@ -0,0 +1,76 @@
+<!--Id: rep_start.so,v 1.2 2001/10/25 14:08:43 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DbEnv::rep_start</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DbEnv::rep_start</h1>
+</td>
+<td align=right>
+<a href="../api_cxx/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+#include &lt;db_cxx.h&gt;
+<p>
+int
+DbEnv::rep_start(Dbt *cdata, u_int32_t flags);
+</pre></h3>
+<h1>Description</h1>
+<p>The DbEnv::rep_start method configures the database environment as a client
+or master in a group of replicated database environments.  Replication
+master environments are the only database environments where replicated
+databases may be modified.  Replication client environments are
+read-only as long as they are clients.  Replication client environments
+may be upgraded to be replication master environments in the case that
+the current master fails or there is no master present.
+<p>The enclosing database environment must already have been opened by
+calling the <a href="../api_cxx/env_open.html">DbEnv::open</a> method and must already have been configured
+to send replication messages by calling the <a href="../api_cxx/rep_transport.html">DbEnv::set_rep_transport</a> method.
+<p>The <b>cdata</b> parameter is an opaque data item that is sent over
+the communication infrastructure when the client or master comes online
+(see <a href="../ref/rep/newsite.html">Connecting to a new site</a> for
+more information).  If no such information is useful, <b>cdata</b>
+should be NULL.
+<p>The <b>flags</b> value must be set to one of the following values:
+<p><dl compact>
+<p><dt><a name="DB_REP_CLIENT">DB_REP_CLIENT</a><dd>Configure the environment as a replication client.
+<p><dt><a name="DB_REP_LOGSONLY">DB_REP_LOGSONLY</a><dd>Configure the environment as a log files-only client.
+<p><dt><a name="DB_REP_MASTER">DB_REP_MASTER</a><dd>Configure the environment as a replication master.
+</dl>
+<p>The DbEnv::rep_start method either returns a non-zero error value or throws an exception that
+encapsulates a non-zero error value on failure, and returns 0 on success.
+<h1>Errors</h1>
+<p>The DbEnv::rep_start method may fail and throw an exception or return a non-zero error for the following conditions:
+<p><dl compact>
+<p><dt>EINVAL<dd>An invalid flag value or parameter was specified.
+<p>The environment was not already configured to communicate with a
+replication group by a call to <a href="../api_cxx/rep_transport.html">DbEnv::set_rep_transport</a>.
+<p>The environment was not already opened.
+</dl>
+<p>The DbEnv::rep_start method may fail and throw an exception or return a non-zero error for errors specified for other Berkeley DB and C library or system methods.
+If a catastrophic error has occurred, the DbEnv::rep_start method may fail and either
+return <a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a> or throw an exception encapsulating
+<a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a>, in which case all subsequent Berkeley DB calls will fail
+in the same way.
+<h1>See Also</h1>
+<a href="../api_cxx/rep_start.html">DbEnv::rep_start</a>,
+<a href="../api_cxx/rep_elect.html">DbEnv::rep_elect</a>,
+<a href="../api_cxx/rep_message.html">DbEnv::rep_process_message</a>,
+and
+<a href="../api_cxx/rep_transport.html">DbEnv::set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_cxx/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_cxx/rep_transport.html b/db/docs/api_cxx/rep_transport.html
new file mode 100644
index 000000000..6998e11cd
--- /dev/null
+++ b/db/docs/api_cxx/rep_transport.html
@@ -0,0 +1,94 @@
+<!--Id: rep_transport.so,v 1.4 2001/10/26 23:51:06 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DbEnv::set_rep_transport</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DbEnv::set_rep_transport</h1>
+</td>
+<td align=right>
+<a href="../api_cxx/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+#include &lt;db_cxx.h&gt;
+<p>
+int
+DbEnv::set_rep_transport(int envid,
+    int (*send)(DB_ENV *dbenv,
+    const Dbt *control, const Dbt *rec, int envid, u_int32_t flags));
+</pre></h3>
+<h1>Description</h1>
+<p>The DbEnv::set_rep_transport method initializes the communication infrastructure
+for a database environment participating in a replicated application.
+<p>The <b>envid</b> parameter is the local environment's ID.  It must be
+a positive integer and uniquely identify this Berkeley DB database environment
+(see <a href="../ref/rep/id.html">Replication environment IDs</a> for more
+information).
+<p>The <b>send</b> parameter is a callback interface used to transmit data
+using the replication application's communication infrastructure.  The
+parameters to <b>send</b> are as follows:
+<p><dl compact>
+<p><dt>dbenv<dd>The enclosing database environment.
+<p><dt>control<dd>The control parameter is the first of the two data elements to be
+transmitted by the <b>send</b> interface.
+<p><dt>rec<dd>The rec parameter is the second of the two data elements to be
+transmitted by the <b>send</b> interface.
+<p><dt>envid<dd>The <b>envid</b> parameter is a positive integer identifier that
+specifies the replication environment to which the message should be
+sent (see <a href="../ref/rep/id.html">Replication environment IDs</a> for
+more information).
+<p><a name="3"><!--meow--></a>
+The special identifier DB_EID_BROADCAST indicates that a message
+should be broadcast to every environment in the replication group.  The
+application may use a true broadcast protocol, or may send the message
+in sequence to each machine with which it is in communication.
+<p><dt>flag<dd>
+<p>The <b>flags</b> value must be set to 0 or by bitwise inclusively <b>OR</b>'ing together one or
+more of the following values:
+<p><dl compact>
+<p><dt><a name="DB_REP_PERMANENT">DB_REP_PERMANENT</a><dd>The record being sent is critical for maintaining database integrity
+(for example, the message includes a transaction commit).  The
+application should take appropriate action to enforce the reliability
+guarantees it has chosen, such as waiting for acknowledgement from one
+or more clients.
+</dl>
+</dl>
+<p>The <b>send</b> interface must return 0 on success and non-zero on
+failure.  If the <b>send</b> interface fails, the message being sent
+is necessary to maintain database integrity, and the local log is not
+configured for synchronous flushing, the local log will be flushed;
+otherwise, any error from the <b>send</b> interface will be ignored.
+<p>It may sometimes be useful to pass application-specific data to the
+<b>send</b> interface; see <a href="../ref/env/faq.html">Environment
+FAQ</a> for a discussion on how to do this.
+<p>The <b>flags</b> parameter is currently unused, and must be set to 0.
+<p>The DbEnv::set_rep_transport method either returns a non-zero error value or throws an exception that
+encapsulates a non-zero error value on failure, and returns 0 on success.
+<h1>Errors</h1>
+<p>The DbEnv::set_rep_transport method may fail and throw an exception or return a non-zero error for errors specified for other Berkeley DB and C library or system methods.
+If a catastrophic error has occurred, the DbEnv::set_rep_transport method may fail and either
+return <a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a> or throw an exception encapsulating
+<a href="../ref/program/errorret.html#DB_RUNRECOVERY">DB_RUNRECOVERY</a>, in which case all subsequent Berkeley DB calls will fail
+in the same way.
+<h1>See Also</h1>
+<a href="../api_cxx/rep_start.html">DbEnv::rep_start</a>,
+<a href="../api_cxx/rep_elect.html">DbEnv::rep_elect</a>,
+<a href="../api_cxx/rep_message.html">DbEnv::rep_process_message</a>,
+and
+<a href="../api_cxx/rep_transport.html">DbEnv::set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_cxx/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_java/rep_elect.html b/db/docs/api_java/rep_elect.html
new file mode 100644
index 000000000..6d68a98fd
--- /dev/null
+++ b/db/docs/api_java/rep_elect.html
@@ -0,0 +1,83 @@
+<!--Id: rep_elect.so,v 1.4 2001/10/26 13:57:00 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DbEnv.rep_elect</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DbEnv.rep_elect</h1>
+</td>
+<td align=right>
+<a href="../api_java/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+import com.sleepycat.db.*;
+<p>
+public int rep_elect(int nsites,
+  int priority, int timeout, int *envid);
+    throws DbException;
+</pre></h3>
+<h1>Description</h1>
+<p>The DbEnv.rep_elect method holds an election for the master of a replication
+group, returning the new master's ID in the <b>envid</b> parameter.
+<p>The <b>nsites</b> parameter indicates the number of environments that
+the application believes are in the replication group.  This number is
+used by Berkeley DB to avoid having two masters active simultaneously, even
+in the case of a network partition.  During an election, a new master
+cannot be elected unless more than half of <b>nsites</b> agree on
+the new master.  Thus, in the face of a network partition, the side of
+the partition with more than half the environments will elect a new
+master and continue, while the environments communicating with fewer
+than half the other environments will fail to find a new master.
+<p>The <b>priority</b> parameter is the priority of this environment.  It
+must be a positive integer, or 0 if this environment is not permitted
+to become a master (see <a href="../ref/rep/pri.html">Replication
+environment priorities</a> for more information).
+<a name="3"><!--meow--></a>
+<p>The <b>timeout</b> parameter specifies a timeout period for an
+election.  If the election has not completed after <b>timeout</b>
+microseconds, the thread will return Db.DB_REP_UNAVAIL.
+<p>The DbEnv.rep_elect method either returns successfully, with the new
+master's environment ID in the memory pointed to by the <b>envid</b>
+parameter, or it will return Db.DB_REP_UNAVAIL if the participating
+group members were unable to elect a new master for any reason.  In the
+event of a successful return, the new master's ID may be the ID of the
+previous master, or the ID of the current environment.  The application
+is responsible for adjusting its usage of the other environments in the
+replication group, including directing all database updates to the newly
+selected master, in accordance with the results of this election.
+<p>The thread of control that calls the DbEnv.rep_elect method must not be the
+thread of control that processes incoming messages; processing the
+incoming messages is necessary to successfully complete an election.
+<p>The DbEnv.rep_elect method throws an exception that encapsulates a non-zero error value on
+failure.
+<h1>Errors</h1>
+<p>The DbEnv.rep_elect method may fail and throw an exception encapsulating a non-zero error for the following conditions:
+<p><dl compact>
+<p><dt>DB_REP_UNAVAIL<dd>The replication group was unable to elect a master.
+</dl>
+<p>The DbEnv.rep_elect method may fail and throw an exception for errors specified for other Berkeley DB and C library or system methods.
+If a catastrophic error has occurred, the DbEnv.rep_elect method may fail and throw
+a <a href="../api_java/runrec_class.html">DbRunRecoveryException</a>, in which case all subsequent Berkeley DB calls
+will fail in the same way.
+<h1>See Also</h1>
+<a href="../api_java/rep_start.html">DbEnv.rep_start</a>,
+<a href="../api_java/rep_elect.html">DbEnv.rep_elect</a>,
+<a href="../api_java/rep_message.html">DbEnv.rep_process_message</a>,
+and
+<a href="../api_java/rep_transport.html">DbEnv.set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_java/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_java/rep_message.html b/db/docs/api_java/rep_message.html
new file mode 100644
index 000000000..8c553b309
--- /dev/null
+++ b/db/docs/api_java/rep_message.html
@@ -0,0 +1,82 @@
+<!--Id: rep_message.so,v 1.4 2001/10/25 20:15:23 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DbEnv.rep_process_message</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DbEnv.rep_process_message</h1>
+</td>
+<td align=right>
+<a href="../api_java/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+import com.sleepycat.db.*;
+<p>
+public void rep_process_message(Dbt *control, Dbt *rec, int *envid)
+    throws DbException;
+</pre></h3>
+<h1>Description</h1>
+<p>The DbEnv.rep_process_message method processes an incoming replication
+message sent by a member of the replication group to the local database
+environment.
+<p>The <b>rec</b> and <b>control</b> parameters should reference a copy
+of the parameters specified by Berkeley DB for the <b>rec</b> and
+<b>control</b> parameters on the sending environment.
+<p>The <b>envid</b> parameter should contain the local identifier that
+corresponds to the environment that sent the message to be processed
+(see <a href="../ref/rep/id.html">Replication environment IDs</a> for more
+information).
+<p>For implementation reasons, all incoming replication messages must be
+processed using the same <a href="../api_java/dbenv_class.html">DbEnv</a> handle.  It is not required that
+a single thread of control process all messages, only that all threads
+of control processing messages use the same handle.
+<p>The DbEnv.rep_process_message method may return one of several special conditions:
+<p><dl compact>
+<p><dt><a name="Db.DB_REP_DUPMASTER">Db.DB_REP_DUPMASTER</a><dd>The replication group has more than one master; the application should
+reconfigure itself as a client by calling the <a href="../api_java/rep_start.html">DbEnv.rep_start</a> method, and
+then call for an election by calling <a href="../api_java/rep_elect.html">DbEnv.rep_elect</a>.
+<p><dt><a name="Db.DB_REP_HOLDELECTION">Db.DB_REP_HOLDELECTION</a><dd>An election is needed, the application should call for an election by
+calling <a href="../api_java/rep_elect.html">DbEnv.rep_elect</a>.
+<p><dt><a name="Db.DB_REP_NEWMASTER">Db.DB_REP_NEWMASTER</a><dd>A new master has been elected.  The memory location referenced by the
+<b>envid</b> parameter contains the environment ID of the new master.
+If the recipient of this error return has been made master, it is the
+application's responsibility to begin acting as the master environment.
+<p><dt><a name="Db.DB_REP_NEWSITE">Db.DB_REP_NEWSITE</a><dd>The system received contact information from a new environment.  The
+<b>rec</b> parameter contains the opaque data specified in the
+<b>cdata</b> parameter to the <a href="../api_java/rep_start.html">DbEnv.rep_start</a>.  The application
+should take whatever action is needed to establish a communication
+channel with this new environment.
+<p><dt><a name="Db.DB_REP_OUTDATED">Db.DB_REP_OUTDATED</a><dd>The current environment's logs are too far out of date with respect to
+the master to be automatically synchronized.  The application should
+copy over a hot backup of the environment, run recovery, and restart
+the client.
+</dl>
+<p>Otherwise, the DbEnv.rep_process_message method throws an exception that encapsulates a non-zero error value on
+failure.
+<h1>Errors</h1>
+<p>The DbEnv.rep_process_message method may fail and throw an exception for errors specified for other Berkeley DB and C library or system methods.
+If a catastrophic error has occurred, the DbEnv.rep_process_message method may fail and throw
+a <a href="../api_java/runrec_class.html">DbRunRecoveryException</a>, in which case all subsequent Berkeley DB calls
+will fail in the same way.
+<h1>See Also</h1>
+<a href="../api_java/rep_start.html">DbEnv.rep_start</a>,
+<a href="../api_java/rep_elect.html">DbEnv.rep_elect</a>,
+<a href="../api_java/rep_message.html">DbEnv.rep_process_message</a>,
+and
+<a href="../api_java/rep_transport.html">DbEnv.set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_java/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_java/rep_start.html b/db/docs/api_java/rep_start.html
new file mode 100644
index 000000000..a3c0f3750
--- /dev/null
+++ b/db/docs/api_java/rep_start.html
@@ -0,0 +1,75 @@
+<!--Id: rep_start.so,v 1.2 2001/10/25 14:08:43 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DbEnv.rep_start</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DbEnv.rep_start</h1>
+</td>
+<td align=right>
+<a href="../api_java/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+import com.sleepycat.db.*;
+<p>
+public void rep_start(Dbt cdata, int flags)
+    throws DbException;
+</pre></h3>
+<h1>Description</h1>
+<p>The DbEnv.rep_start method configures the database environment as a client
+or master in a group of replicated database environments.  Replication
+master environments are the only database environments where replicated
+databases may be modified.  Replication client environments are
+read-only as long as they are clients.  Replication client environments
+may be upgraded to be replication master environments in the case that
+the current master fails or there is no master present.
+<p>The enclosing database environment must already have been opened by
+calling the <a href="../api_java/env_open.html">DbEnv.open</a> method and must already have been configured
+to send replication messages by calling the <a href="../api_java/rep_transport.html">DbEnv.set_rep_transport</a> method.
+<p>The <b>cdata</b> parameter is an opaque data item that is sent over
+the communication infrastructure when the client or master comes online
+(see <a href="../ref/rep/newsite.html">Connecting to a new site</a> for
+more information).  If no such information is useful, <b>cdata</b>
+should be null.
+<p>The <b>flags</b> value must be set to one of the following values:
+<p><dl compact>
+<p><dt><a name="Db.DB_REP_CLIENT">Db.DB_REP_CLIENT</a><dd>Configure the environment as a replication client.
+<p><dt><a name="Db.DB_REP_LOGSONLY">Db.DB_REP_LOGSONLY</a><dd>Configure the environment as a log files-only client.
+<p><dt><a name="Db.DB_REP_MASTER">Db.DB_REP_MASTER</a><dd>Configure the environment as a replication master.
+</dl>
+<p>The DbEnv.rep_start method throws an exception that encapsulates a non-zero error value on
+failure.
+<h1>Errors</h1>
+<p>The DbEnv.rep_start method may fail and throw an exception encapsulating a non-zero error for the following conditions:
+<p><dl compact>
+<p><dt>EINVAL<dd>An invalid flag value or parameter was specified.
+<p>The environment was not already configured to communicate with a
+replication group by a call to <a href="../api_java/rep_transport.html">DbEnv.set_rep_transport</a>.
+<p>The environment was not already opened.
+</dl>
+<p>The DbEnv.rep_start method may fail and throw an exception for errors specified for other Berkeley DB and C library or system methods.
+If a catastrophic error has occurred, the DbEnv.rep_start method may fail and throw
+a <a href="../api_java/runrec_class.html">DbRunRecoveryException</a>, in which case all subsequent Berkeley DB calls
+will fail in the same way.
+<h1>See Also</h1>
+<a href="../api_java/rep_start.html">DbEnv.rep_start</a>,
+<a href="../api_java/rep_elect.html">DbEnv.rep_elect</a>,
+<a href="../api_java/rep_message.html">DbEnv.rep_process_message</a>,
+and
+<a href="../api_java/rep_transport.html">DbEnv.set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_java/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/api_java/rep_transport.html b/db/docs/api_java/rep_transport.html
new file mode 100644
index 000000000..f27039c86
--- /dev/null
+++ b/db/docs/api_java/rep_transport.html
@@ -0,0 +1,100 @@
+<!--Id: rep_transport.so,v 1.4 2001/10/26 23:51:06 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB: DbEnv.set_rep_transport</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<a name="2"><!--meow--></a>
+<table width="100%"><tr valign=top>
+<td>
+<h1>DbEnv.set_rep_transport</h1>
+</td>
+<td align=right>
+<a href="../api_java/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<hr size=1 noshade>
+<tt>
+<h3><pre>
+import com.sleepycat.db.*;
+<p>
+public interface DbEnvSend
+{
+    public abstract int db_send(DB_ENV *dbenv,
+      const Dbt *control, const Dbt *rec, int envid, int flags);
+}
+public class DbEnv
+{
+    public int set_rep_transport(DbEnvSend db_send)
+	throws DbException;
+    ...
+}
+</pre></h3>
+<h1>Description</h1>
+<p>The DbEnv.set_rep_transport method initializes the communication infrastructure
+for a database environment participating in a replicated application.
+<p>The <b>envid</b> parameter is the local environment's ID.  It must be
+a positive integer and uniquely identify this Berkeley DB database environment
+(see <a href="../ref/rep/id.html">Replication environment IDs</a> for more
+information).
+<p>The <b>send</b> parameter is a callback interface used to transmit data
+using the replication application's communication infrastructure.  The
+parameters to <b>send</b> are as follows:
+<p><dl compact>
+<p><dt>dbenv<dd>The enclosing database environment.
+<p><dt>control<dd>The control parameter is the first of the two data elements to be
+transmitted by the <b>send</b> interface.
+<p><dt>rec<dd>The rec parameter is the second of the two data elements to be
+transmitted by the <b>send</b> interface.
+<p><dt>envid<dd>The <b>envid</b> parameter is a positive integer identifier that
+specifies the replication environment to which the message should be
+sent (see <a href="../ref/rep/id.html">Replication environment IDs</a> for
+more information).
+<p><a name="3"><!--meow--></a>
+The special identifier Db.DB_EID_BROADCAST indicates that a message
+should be broadcast to every environment in the replication group.  The
+application may use a true broadcast protocol, or may send the message
+in sequence to each machine with which it is in communication.
+<p><dt>flag<dd>
+<p>The <b>flags</b> value must be set to 0 or by bitwise inclusively <b>OR</b>'ing together one or
+more of the following values:
+<p><dl compact>
+<p><dt><a name="Db.DB_REP_PERMANENT">Db.DB_REP_PERMANENT</a><dd>The record being sent is critical for maintaining database integrity
+(for example, the message includes a transaction commit).  The
+application should take appropriate action to enforce the reliability
+guarantees it has chosen, such as waiting for acknowledgement from one
+or more clients.
+</dl>
+</dl>
+<p>The <b>send</b> interface must return 0 on success and non-zero on
+failure.  If the <b>send</b> interface fails, the message being sent
+is necessary to maintain database integrity, and the local log is not
+configured for synchronous flushing, the local log will be flushed;
+otherwise, any error from the <b>send</b> interface will be ignored.
+<p>It may sometimes be useful to pass application-specific data to the
+<b>send</b> interface; see <a href="../ref/env/faq.html">Environment
+FAQ</a> for a discussion on how to do this.
+<p>The <b>flags</b> parameter is currently unused, and must be set to 0.
+<p>The DbEnv.set_rep_transport method throws an exception that encapsulates a non-zero error value on
+failure.
+<h1>Errors</h1>
+<p>The DbEnv.set_rep_transport method may fail and throw an exception for errors specified for other Berkeley DB and C library or system methods.
+If a catastrophic error has occurred, the DbEnv.set_rep_transport method may fail and throw
+a <a href="../api_java/runrec_class.html">DbRunRecoveryException</a>, in which case all subsequent Berkeley DB calls
+will fail in the same way.
+<h1>See Also</h1>
+<a href="../api_java/rep_start.html">DbEnv.rep_start</a>,
+<a href="../api_java/rep_elect.html">DbEnv.rep_elect</a>,
+<a href="../api_java/rep_message.html">DbEnv.rep_process_message</a>,
+and
+<a href="../api_java/rep_transport.html">DbEnv.set_rep_transport</a>.
+</tt>
+<table width="100%"><tr><td><br></td><td align=right>
+<a href="../api_java/c_index.html"><img src="../images/api.gif" alt="API"></a><a href="../reftoc.html"><img src="../images/ref.gif" alt="Ref"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/ref/rep/ex.html b/db/docs/ref/rep/ex.html
new file mode 100644
index 000000000..d0e38e0f5
--- /dev/null
+++ b/db/docs/ref/rep/ex.html
@@ -0,0 +1,64 @@
+<!--Id: ex.so,v 1.3 2001/11/18 15:17:22 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB Reference Guide: Ex_repquote: a replication example</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<table width="100%"><tr valign=top>
+<td><h3><dl><dt>Berkeley DB Reference Guide:<dd>Berkeley DB Replication</dl></h3></td>
+<td align=right><a href="../../ref/rep/faq.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/rep/ex_comm.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p>
+<h1 align=center>Ex_repquote: a replication example</h1>
+<p>Ex_repquote, found in the <b>examples_c/ex_repquote</b> subdirectory
+of the Berkeley DB distribution, is a simple but complete demonstration of a
+replicated application.  The application is a mock stock ticker.  The
+master accepts a stock symbol and an integer value as input, stores this
+information into a replicated database; the clients display the contents
+of the database every few seconds.
+<p>The ex_repquote application's communication infrastructure is based on
+TCP/IP sockets, and uses POSIX 1003.1 style networking/socket support.
+As a result, it is not as portable as the Berkeley DB library itself.  The
+Makefile created by the standard UNIX configuration will build the
+ex_repquote application on most platforms.  Enter "make ex_repquote" to
+attempt to build it.
+<p>The synopsis for ex_repquote is as follows:
+<pre>ex_repquote [<b>-MC</b>] [<b>-h home</b>] [<b>-m host:port</b>] [<b>-o host:port</b>] [<b>-n sites</b>] [<b>-p priority</b>]</pre>
+<p>The options to ex_repquote are as follows:
+<p><dl compact>
+<p><dt><b>-M</b><dd>Configure this process as a master.
+<p><dt><b>-C</b><dd>Configure this process as a client.
+<p><dt><b>-h</b><dd>Specify a home directory for the database environment; by
+default, the current working directory is used.
+<p><dt><b>-m</b><dd>Listen on port "port" of host "host" for incoming connections.
+<p><dt><b>-o</b><dd>Attempt to connect to another member of the replication group which is
+listening on host "host" at port "port".  Members of a replication group
+should be able to find all other members of a replication group so long
+as they are in contact with at least one other member of the replication
+group.
+<p><dt><b>-n</b><dd>Specify the total number of sites in the replication group.
+<p><dt><b>-p</b><dd>Set the election priority.  See <a href="../../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a> for more
+information.
+</dl>
+<p>A typical ex_repquote session begins with a command such as the
+following, to start a master:
+<p><blockquote><pre>ex_repquote -M -p 100 -n 4 -h DIR1 -m localhost:5000</pre></blockquote>
+<p>and several clients:
+<p><blockquote><pre>ex_repquote -C -p 50 -n 4 -h DIR2 -m localhost:5001 -o localhost:5000
+ex_repquote -C -p 10 -n 4 -h DIR3 -m localhost:5002 -o localhost:5000
+ex_repquote -C -p  0 -n 4 -h DIR4 -m localhost:5003 -o localhost:5000</pre></blockquote>
+<p>In this example, the client with home directory DIR4 can never become
+a master (its priority is 0).  Both of the other clients can become
+masters, but the one with home directory DIR2 is preferred.  Priorities
+are assigned by the application and should reflect the desirability of
+having particular clients take over as master in the case that the
+master fails.
+<table width="100%"><tr><td><br></td><td align=right><a href="../../ref/rep/faq.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/rep/ex_comm.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/ref/rep/ex_comm.html b/db/docs/ref/rep/ex_comm.html
new file mode 100644
index 000000000..2e41aeb72
--- /dev/null
+++ b/db/docs/ref/rep/ex_comm.html
@@ -0,0 +1,176 @@
+<!--Id: ex_comm.so,v 1.5 2001/11/18 15:32:21 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB Reference Guide: Ex_repquote: a TCP/IP based communication infrastructure</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<table width="100%"><tr valign=top>
+<td><h3><dl><dt>Berkeley DB Reference Guide:<dd>Berkeley DB Replication</dl></h3></td>
+<td align=right><a href="../../ref/rep/ex.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/rep/ex_rq.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p>
+<h1 align=center>Ex_repquote: a TCP/IP based communication infrastructure</h1>
+<p>All Berkeley DB replication applications must implement a communication
+infrastructure.  The communication infrastructure consists of three
+parts: a way to map environment IDs to particular sites, the functions
+to get and receive messages, and the application architecture that
+supports the particular communication infrastructure used (for example,
+individual threads per communicating site, a shared message handler for
+all sites, a hybrid solution).  The communication infrastructure is
+implemented in the file <b>ex_repquote/ex_rq_net.c</b>, and each part
+of that infrastructure is described as follows.
+<p>Ex_repquote maintains a table of environment ID to TCP/IP port mappings.
+This table is stored in the app_private field of the <a href="../../api_c/env_create.html">DB_ENV</a>
+object so it can be accessed by any function that has the database
+environment handle.  The table is represented by a machtab_t structure
+which contains a reference to a linked list of member_t's, both of which
+are defined in <b>ex_repquote/ex_rq_net.c</b>.  Each member_t contains
+the host and port identification, the environment ID, and a file
+descriptor.  The table is maintained by the following interfaces:
+<p><blockquote><pre>int machtab_add(machtab_t *machtab, int fd, u_int32_t hostaddr, int port, int *eidp);
+int machtab_init(machtab_t **machtabp, int priority, int nsites);
+int machtab_getinfo(machtab_t *machtab, int eid, u_int32_t *hostp, int *portp);
+void machtab_parm(machtab_t *machtab, int *nump, int *priorityp, u_int32_t *timeoutp);
+int machtab_rem(machtab_t *machtab, int eid, int lock);
+</pre></blockquote>
+<p>These interfaces are particular to this application and communication
+infrastructure, but provide an indication of the sort of functionality
+that is needed to maintain the application-specific state for a
+TCP/IP-based infrastructure.  The goal of the table and its interfaces
+is threefold: First, it must guarantee that given an environment ID,
+the send function can send a message to the appropriate place.  Second,
+when given the special environment ID <a href="../../api_c/rep_transport.html#DB_EID_BROADCAST">DB_EID_BROADCAST</a>, the send
+function can send messages to all the machines in the group.  Third,
+upon receipt of an incoming message, the receive function can correctly
+identify the sender and pass the appropriate environment ID to the
+<a href="../../api_c/rep_message.html">DB_ENV-&gt;rep_process_message</a> method.
+<p>Mapping a particular environment ID to a specific port is accomplished
+by looping through the linked list until the desired environment ID is
+found.  Broadcast communication is implemented by looping through the
+linked list and sending to each member found.  Since each port
+communicates with only a single other environment, receipt of a message
+on a particular port precisely identifies the sender.
+<p>The example provided is merely one way to satisfy these requirements,
+and there are alternative implementations as well.  For instance,
+instead of associating separate socket connections with each remote
+environment, an application might instead label each message with a
+sender identifier; instead of looping through a table and sending a
+copy of a message to each member of the replication group, the
+application could send a single message using a broadcast protocol.
+<p>In ex_repquote's case, the send function (slightly simplified) is as
+follows:
+<pre><p><blockquote>int
+quote_send(dbenv, control, rec, eid, flags)
+	DB_ENV *dbenv;
+	const DBT *control, *rec;
+	int eid;
+	u_int32_t flags;
+{
+	int fd, n, ret;
+	machtab_t *machtab;
+	member_t *m;
+<p>
+	machtab = (machtab_t *)dbenv-&gt;app_private;
+<p>
+	/* 
+	 * If this is a broadcast, call a separate function to
+	 * iterate through the table of environment (a/k/a
+	 * machine) IDs and call quote_send_one on each.
+	 * (This function is not reproduced here, but can be
+	 * seen in ex_rq_net.c.)
+	 */
+	if (eid == DB_EID_BROADCAST) {
+		n = quote_send_broadcast(machtab, rec, control, flags);
+		if (n &lt; 0)
+			return (DB_REP_UNAVAIL);
+		return (0);
+	}
+<p>
+	/* Find the fild descriptor, fd, associated with this EID. */
+	fd = 0;
+	if ((ret = pthread_mutex_lock(&machtab-&gt;mtmutex)) != 0)
+		return (0);
+	for (m = LIST_FIRST(&machtab-&gt;machlist); m != NULL;
+	    m = LIST_NEXT(m, links)) {
+		if (m-&gt;eid == eid) {
+			fd = m-&gt;fd;
+			break;
+		}
+	}
+	if (pthread_mutex_unlock(&machtab-&gt;mtmutex) != 0)
+		return (-1);
+<p>
+	if (fd == 0)
+		return (DB_REP_UNAVAIL);
+<p>
+	/* We have a file descriptor;  write the data over it. */
+	ret = quote_send_one(rec, control, fd, flags);
+<p>
+	return (ret);
+}
+<p>
+static int
+quote_send_broadcast(machtab, rec, control, flags)
+	machtab_t *machtab;
+	const DBT *rec, *control;
+	u_int32_t flags;
+{
+	int ret, sent;
+	member_t *m, *next;
+	if ((ret = pthread_mutex_lock(&machtab-&gt;mtmutex)) != 0)
+		return (0);
+	sent = 0;
+	for (m = LIST_FIRST(&machtab-&gt;machlist); m != NULL; m = next) {
+		next = LIST_NEXT(m, links);
+		if ((ret = quote_send_one(rec, control, m-&gt;fd, flags)) != 0) {
+			(void)machtab_rem(machtab, m-&gt;eid, 0);
+		} else
+			sent++;
+	}
+	if (pthread_mutex_unlock(&machtab-&gt;mtmutex) != 0)
+		return (-1);
+	return (sent);
+}</blockquote></pre>
+<p>The quote_send_one function has been omitted as it simply writes the
+data requested over the file descriptor that it is passed.  It contains
+nothing specific to Berkeley DB or this communication infrastructure.  The
+complete code can be found in <b>ex_repquote/ex_rq_net.c</b>.
+<p>The quote_send function is passed as the callback to <a href="../../api_c/rep_transport.html">DB_ENV-&gt;set_rep_transport</a>;
+Berkeley DB automatically sends messages as needed for replication.  The
+receive function is a mirror to the quote_send_one function.  It is not
+a callback function (the application is responsible for collecting
+messages and calling <a href="../../api_c/rep_message.html">DB_ENV-&gt;rep_process_message</a> on them as is convenient).  In
+the sample application, all messages transmitted are Berkeley DB messages that
+get handled by <a href="../../api_c/rep_message.html">DB_ENV-&gt;rep_process_message</a>, however, this is not always going
+to be the case.  The application may want to pass its own messages
+across the same channels, distinguish between its own messages and those
+of Berkeley DB, and then pass only the Berkeley DB ones to <a href="../../api_c/rep_message.html">DB_ENV-&gt;rep_process_message</a>.
+<p>The final component of the communication infrastructure is the process
+model used to communicate with all the sites in the replication group.
+Each site creates a thread of control that listens on its designated
+socket (as specified by the <b>-m</b> command line argument) and
+then creates a new channel for each site that contacts it.  In addition,
+each site explicitly connects to the sites specified in the
+<b>-o</b> command line argument.  This is a fairly standard TCP/IP
+process architecture and is implemented by the following functions (all
+in <b>ex_repquote/ex_rq_net.c</b>).
+<p><blockquote><pre>int get_connected_socket(machtab_t *machtab, char *progname, char *remotehost,
+int port, int *is_open, int *eidp): Connect to the specified host/port, add the
+site to the machtab, and return a file descriptor for communication with this
+site.
+<p>
+int listen_socket_init(char *progname, int port): Initialize a socket for
+listening on a particular part.
+<p>
+int listen_socket_accept(machtab_t *machtab, char *progname, int socket,
+int *eidp): Accept a connection on a socket and add it to the machtab.
+int listen_socket_connect</pre></blockquote>
+<table width="100%"><tr><td><br></td><td align=right><a href="../../ref/rep/ex.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/rep/ex_rq.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/ref/rep/ex_rq.html b/db/docs/ref/rep/ex_rq.html
new file mode 100644
index 000000000..84d0e83ba
--- /dev/null
+++ b/db/docs/ref/rep/ex_rq.html
@@ -0,0 +1,235 @@
+<!--Id: ex_rq.so,v 1.3 2001/11/18 15:17:23 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB Reference Guide: Ex_repquote: putting it all together</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<table width="100%"><tr valign=top>
+<td><h3><dl><dt>Berkeley DB Reference Guide:<dd>Berkeley DB Replication</dl></h3></td>
+<td align=right><a href="../../ref/rep/ex_comm.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/xa/intro.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p>
+<h1 align=center>Ex_repquote: putting it all together</h1>
+<p>A replicated application must initialize a replicated environment, set
+up its communication infrastructure, and then make sure that incoming
+messages are received and processed.
+<p>To initialize replication, ex_repquote creates a Berkeley DB environment and
+calls <a href="../../api_c/rep_transport.html">DB_ENV-&gt;set_rep_transport</a> to establish a send function.  The following
+code fragment (from the env_init function, found in
+<b>ex_repquote/ex_rq_main.c</b>) demonstrates this.  Prior to calling
+this function, the application has called machtab_init to initialize
+its environment ID to port mapping structure and passed this structure
+into env_init.
+<pre><p><blockquote>if ((ret = db_env_create(&dbenv, 0)) != 0) {
+	fprintf(stderr, "%s: env create failed: %s\n",
+	    progname, db_strerror(ret));
+	return (ret);
+}
+dbenv-&gt;set_errfile(dbenv, stderr);
+dbenv-&gt;set_errpfx(dbenv, prefix);
+(void)dbenv-&gt;set_cachesize(dbenv, 0, CACHESIZE, 0);
+<p>
+dbenv-&gt;app_private = machtab;
+(void)dbenv-&gt;set_rep_transport(dbenv, SELF_EID, quote_send);
+<p>
+flags = DB_CREATE | DB_THREAD |
+    DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN;
+<p>
+ret = dbenv-&gt;open(dbenv, home, flags, 0);</blockquote></pre>
+<p>ex_repquote opens a listening socket for incoming connections and opens
+an outgoing connection to every machine that it knows about (that is,
+all the sites listed in the <b>-o</b> command line argument).
+Applications can structure the details of this in different ways, but
+ex_repquote creates a user-level thread to listen on its socket, plus
+a thread to loop and handle messages on each socket, in addition to the
+threads needed to manage the user interface, update the database on the
+master, and read from the database on the client (in other words, in
+addition to the normal functionality of any database application).
+<p>Once the initial threads have all been started and the communications
+infrastructure is initialized, the application signals that it is ready
+for replication and joins a replication group by calling
+<a href="../../api_c/rep_start.html">DB_ENV-&gt;rep_start</a>:
+<pre><p><blockquote>if (whoami == MASTER) {	
+	if ((ret = dbenv-&gt;rep_start(dbenv, NULL, DB_REP_MASTER)) != 0) {
+		/* Complain and exit on error. */
+	}
+	/* Go run the master application code. */
+} else {
+	memset(&local, 0, sizeof(local));
+	local.data = myaddr;
+	local.size = strlen(myaddr) + 1;
+	if ((ret =
+	    dbenv-&gt;rep_start(dbenv, &local, DB_REP_CLIENT)) != 0) {
+		/* Complain and exit on error. */
+	}
+	/* Sleep to give ourselves a minute to find a master. */
+	sleep(5);
+	/* Go run the client application code. */
+}</blockquote></pre>
+<p>Note the use of the optional second argument to <a href="../../api_c/rep_start.html">DB_ENV-&gt;rep_start</a> in
+the client initialization code.  The argument "myaddr" is a piece of
+data, opaque to Berkeley DB, that will be broadcast to each member of a
+replication group; it allows new clients to join a replication group,
+without knowing the location of all its members;  the new client will
+be contacted by the members it does not know about, who will receive
+the new client's contact information that was specified in "myaddr."
+See <a href="../../ref/rep/newsite.html">Connecting to a new site</a> for more
+information.
+<p>The final piece of a replicated application is the code that loops,
+receives, and processes messages from a given remote environment.
+ex_repquote runs one of these loops in a parallel thread for each socket
+connection; other applications may want to queue messages somehow and
+process them asynchronously, or select() on a number of sockets and
+either look up the correct environment ID for each or encapsulate the
+ID in the communications protocol.  The details may thus vary from
+application to application, but in ex_repquote the message-handling loop
+is as follows (code fragment from the hm_loop function, found in
+<b>ex_repquote/ex_rq_util.c</b>):
+<pre><p><blockquote>DB_ENV *dbenv;
+DBT rec, control;	/* Structures encapsulating a received message. */
+elect_args *ea;		/* Parameters to the elect thread. */
+machtab_t *tab;		/* The environment ID to fd mapping table. */
+pthread_t elect_thr;	/* Election thread spawned. */
+site_t self;		/* My host and port identification. */
+int eid;		/* Environment from whom I am receiving messages. */
+int fd;			/* FD on which I am receiving messages. */
+int master_eid;		/* Global indicating the current master eid. */
+int n;			/* Number of sites; obtained from machtab_parm. */
+int newm;		/* New master EID. */
+int open;		/* Boolean indicating if connection already exists. */
+int pri;		/* My priority. */
+int r, ret;		/* Return values. */
+int timeout;		/* My election timeout value. */
+int tmpid;		/* Used to call dbenv-&gt;rep_process_message. */
+char *c;		/* Temp used in parsing host:port names. */
+char *myaddr;		/* My host/port address. */
+char *progname;		/* Program name for error messages. */
+void *status;		/* Pthread return status. */
+for (ret = 0; ret == 0;) {
+	if ((ret = get_next_message(fd, &rec, &control)) != 0) {
+		/*
+		 * There was some sort of network error;  close this
+		 * connection and remove it from the table of
+		 * environment IDs.
+		 */
+		close(fd);
+		if ((ret = machtab_rem(tab, eid, 1)) != 0)
+			break;
+<p>
+		/*
+		 * If I'm the master, I just lost a client and this
+		 * thread is done.
+		 */
+		if (master_eid == SELF_EID)
+			break;
+<p>
+		/*
+		 * If I was talking with the master and the master
+		 * went away, I need to call an election; else I'm
+		 * done.
+		 */
+		if (master_eid != eid)
+			break;
+<p>
+		master_eid = DB_EID_INVALID;
+		/* 
+		 * In ex_repquote, the environment ID table stores 
+		 * election parameters.
+		 */
+		machtab_parm(tab, &n, &pri, &timeout);
+		if ((ret = dbenv-&gt;rep_elect(dbenv,
+		    n, pri, timeout, &newm)) != 0)
+			continue;
+<p>
+		/*
+		 * If I won the election, become the master.
+		 * Otherwise, just exit.
+		 */
+		if (newm == SELF_EID && (ret =
+		    dbenv-&gt;rep_start(dbenv, NULL, DB_REP_MASTER)) == 0)
+			ret = domaster(dbenv, progname);
+		break;
+	}
+<p>
+	/* If we get here, we have a message to process. */
+<p>
+	tmpid = eid;
+	switch(r = dbenv-&gt;rep_process_message(dbenv,
+	    &control, &rec, &tmpid)) {
+	case DB_REP_NEWSITE:
+		/*
+		 * Check if we got sent connect information and if we
+		 * did, if this is me or if we already have a
+		 * connection to this new site.  If we don't,
+		 * establish a new one.
+		 */
+<p>
+		/* No connect info. */
+		if (rec.size == 0)
+			break;
+<p>
+		/* It's me, do nothing. */
+		if (strncmp(myaddr, rec.data, rec.size) == 0)
+			break;
+<p>
+		self.host = (char *)rec.data;
+		self.host = strtok(self.host, ":");
+		if ((c = strtok(NULL, ":")) == NULL) {
+			dbenv-&gt;errx(dbenv, "Bad host specification");
+			goto err;
+		}
+		self.port = atoi(c);
+<p>
+		/*
+		 * We try to connect to the new site.  If we can't,
+		 * we treat it as an error since we know that the site
+		 * should be up if we got a message from it (even
+		 * indirectly).
+		 */
+		if ((ret = connect_site(dbenv,
+		    tab, progname, &self, &open, &eid)) != 0)
+			goto err;
+		break;
+	case DB_REP_HOLDELECTION:
+		if (master_eid == SELF_EID)
+			break;
+		/* Make sure that previous election has finished. */
+		if (ea != NULL) {
+			(void)pthread_join(elect_thr, &status);
+			ea = NULL;
+		}
+		if ((ea = calloc(sizeof(elect_args), 1)) == NULL) {
+			ret = errno;
+			goto err;
+		}
+		ea-&gt;dbenv = dbenv;
+		ea-&gt;machtab = tab;
+		ret = pthread_create(&elect_thr,
+		    NULL, elect_thread, (void *)ea);
+		break;
+	case DB_REP_NEWMASTER:
+		/* Check if it's us. */
+		master_eid = tmpid;
+		if (tmpid == SELF_EID) {
+			if ((ret = dbenv-&gt;rep_start(dbenv,
+			    NULL, DB_REP_MASTER)) != 0)
+				goto err;
+			ret = domaster(dbenv, progname);
+		}
+		break;
+	case 0:
+		break;
+	default:
+		dbenv-&gt;err(dbenv, r, "DBENV-&gt;rep_process_message");
+		break;
+	}
+}</blockquote></pre>
+<table width="100%"><tr><td><br></td><td align=right><a href="../../ref/rep/ex_comm.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/xa/intro.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/ref/rep/partition.html b/db/docs/ref/rep/partition.html
new file mode 100644
index 000000000..1b9cc8e41
--- /dev/null
+++ b/db/docs/ref/rep/partition.html
@@ -0,0 +1,89 @@
+<!--Id: partition.so,v 1.1 2001/10/25 20:05:34 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB Reference Guide: Network partitions</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<table width="100%"><tr valign=top>
+<td><h3><dl><dt>Berkeley DB Reference Guide:<dd>Berkeley DB Replication</dl></h3></td>
+<td align=right><a href="../../ref/rep/trans.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/rep/faq.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p>
+<h1 align=center>Network partitions</h1>
+<p>The Berkeley DB replication implementation can be affected by network
+partitioning problems.
+<p>For example, consider a replication group with N members.  The network
+partitions with the master on one side and more than N/2 of the sites
+on the other side.  The sites on the side with the master will continue
+forward, and the master will continue to accept write queries for the
+databases.  Unfortunately, the sites on the other side of the partition,
+realizing they no longer have a master, will hold an election.  The
+election will succeed as there are more than N/2 of the total sites
+participating, and there will then be two masters for the replication
+group.  Since both masters are potentially accepting write queries, the
+databases could diverge in incompatible ways.
+<p>If multiple masters are ever found to exist in a replication group, a
+master detecting the problem will return <a href="../../api_c/rep_message.html#DB_REP_DUPMASTER">DB_REP_DUPMASTER</a>.  If
+the application sees this return, it should reconfigure itself as a
+client (by calling <a href="../../api_c/rep_start.html">DB_ENV-&gt;rep_start</a>), and then call for an election
+(by calling <a href="../../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a>).  The site that wins the election may be
+one of the two previous masters, or it may be another site entirely.
+Regardless, the winning system will bring all of the other systems into
+conformance.
+<p>As another example, consider a replication group with a master
+environment and two clients A and B, where client A may upgrade to
+master status and client B cannot.  Then, assume client A is partitioned
+from the other two database environments, and it becomes out-of-date
+with respect to the master.  Then, assume the master crashes and does
+not come back on-line.  Subsequently, the network partition is restored,
+and clients A and B hold an election.  As client B cannot win the
+election, client A will win by default, and in order to get back into
+sync with client B, possibly committed transactions on client B will be
+unrolled until the two sites can once again move forward together.
+<p>In both of these examples, there is a phase where a newly elected master
+brings the members of a replication group into conformance with itself
+so that it can start sending new information to them.  This can result
+in the loss of information as previously committed transactions are
+unrolled.
+<p>In architectures where network partitions are an issue, applications
+may want to implement a heart-beat protocol to minimize the consequences
+of a bad network partition.  As long as a master is able to contact at
+least half of the sites in the replication group, it is impossible for
+there to be two masters.  If the master can no longer contact a
+sufficient number of systems, it should reconfigure itself as a client,
+and hold an election.
+<p>There is another tool applications can use to minimize the damage in
+the case of a network partition.  By specifying a <b>nsites</b>
+argument to <a href="../../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a> that is larger than the actual number of
+database environments in the replication group, applications can keep
+systems from declaring themselves the master unless they can talk to at
+a large percentage of the sites in the system.  For example, if there
+are 20 database environments in the replication group, and an argument
+of 30 is specified to the <a href="../../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a> function, then a system will have
+to be able to talk to at least 16 of the sites to declare itself the
+master.
+<p>Specifying a <b>nsites</b> argument to <a href="../../api_c/rep_elect.html">DB_ENV-&gt;rep_elect</a> that is
+smaller than the actual number of database environments in the
+replication group has its uses as well.  For example, consider a
+replication group with 2 environments.  If they are partitioned from
+each other, neither of the sites could ever get enough votes to become
+the master.  A reasonable alternative would be to specify a
+<b>nsites</b> argument of 2 to one of the systems and a <b>nsites</b>
+argument of 1 to the other.  That way, one of the systems could win
+elections even when partitioned, while the other one could not.  This
+would allow at one of the systems to continue accepting write queries
+after the partition.
+<p>These scenarios stress the importance of good network infrastructure in
+Berkeley DB replicated environments.  When replicating database environments
+over sufficiently lossy networking, the best solution may well be to
+pick a single master, and only hold elections when human intervention
+has determined the selected master is unable to recover at all.
+<table width="100%"><tr><td><br></td><td align=right><a href="../../ref/rep/trans.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/rep/faq.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/ref/upgrade.4.0/asr.html b/db/docs/ref/upgrade.4.0/asr.html
new file mode 100644
index 000000000..36d6efa09
--- /dev/null
+++ b/db/docs/ref/upgrade.4.0/asr.html
@@ -0,0 +1,39 @@
+<!--Id: asr.so,v 1.2 2001/11/14 02:27:11 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB Reference Guide: Release 4.0: application-specific recovery</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<table width="100%"><tr valign=top>
+<td><h3><dl><dt>Berkeley DB Reference Guide:<dd>Upgrading Berkeley DB Applications</dl></h3></td>
+<td align=right><a href="../../ref/upgrade.4.0/cxx.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/upgrade.4.0/disk.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p>
+<h1 align=center>Release 4.0: application-specific recovery</h1>
+<p>If you have created your own logging and recovery routines, you may need
+to upgrade them to the Berkeley DB 4.0 release.
+<p>First, you should regenerate your logging, print, read and the other
+automatically generated routines, using the dist/gen_rec.awk tool
+included in the Berkeley DB distribution.
+<p>Next, compare the template file code generated by the gen_rec.awk tool
+against the code generated by the last release in which you built a
+template file.  Any changes in the templates should be incorporated into
+the recovery routines you have written.
+<p>Third, if your recovery functions refer to <a href="../../api_c/env_set_tx_recover.html#DB_TXN_FORWARD_ROLL">DB_TXN_FORWARD_ROLL</a>
+(that is, your code checks for that particular operation code), you
+should replace it with DB_REDO(op) which compares the operation code to
+both <a href="../../api_c/env_set_tx_recover.html#DB_TXN_FORWARD_ROLL">DB_TXN_FORWARD_ROLL</a> and <a href="../../api_c/env_set_tx_recover.html#DB_TXN_APPLY">DB_TXN_APPLY</a>.
+(<a href="../../api_c/env_set_tx_recover.html#DB_TXN_APPLY">DB_TXN_APPLY</a> is a potential value for the operation code as of
+the 4.0 release.)
+<p>Finally, if you have created your own logging and recovery routines, we
+recommend that you contact Sleepycat support and ask us to review those
+routines for you.
+<table width="100%"><tr><td><br></td><td align=right><a href="../../ref/upgrade.4.0/cxx.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/upgrade.4.0/disk.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/docs/ref/upgrade.4.0/cxx.html b/db/docs/ref/upgrade.4.0/cxx.html
new file mode 100644
index 000000000..410b0cf06
--- /dev/null
+++ b/db/docs/ref/upgrade.4.0/cxx.html
@@ -0,0 +1,48 @@
+<!--Id: cxx.so,v 1.2 2001/11/16 16:49:43 bostic Exp -->
+<!--Copyright 1997-2001 by Sleepycat Software, Inc.-->
+<!--All rights reserved.-->
+<html>
+<head>
+<title>Berkeley DB Reference Guide: Release 4.0: C++ ostream objects</title>
+<meta name="description" content="Berkeley DB: An embedded database programmatic toolkit.">
+<meta name="keywords" content="embedded,database,programmatic,toolkit,b+tree,btree,hash,hashing,transaction,transactions,locking,logging,access method,access methods,java,C,C++">
+</head>
+<body bgcolor=white>
+<table width="100%"><tr valign=top>
+<td><h3><dl><dt>Berkeley DB Reference Guide:<dd>Upgrading Berkeley DB Applications</dl></h3></td>
+<td align=right><a href="../../ref/upgrade.4.0/java.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/upgrade.4.0/asr.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p>
+<h1 align=center>Release 4.0: C++ ostream objects</h1>
+<p>In the 4.0 release, the Berkeley DB C++ API has been changed to use the ISO
+standard C++ API in preference to the older, less portable interfaces,
+where available.  This means the Berkeley DB methods that used to take an
+ostream object as a parameter now expect a std::ostream.  Specifically,
+the following methods have changed:
+<p><blockquote><pre>DbEnv::set_error_stream
+Db::set_error_stream
+Db::verify</pre></blockquote>
+<p>On many platforms, the old and the new C++ styles are interchangeable;
+on some platforms (notably Win32), they are incompatible. If your code
+uses these methods and you have trouble with the 4.0 release, you should
+update code that looks like this:
+<p><blockquote><pre>#include &lt;iostream.h&gt;
+#include &lt;db_cxx.h&gt;
+<p>
+void foo(Db db) {
+	db.set_error_stream(&cerr);
+}</pre></blockquote>
+<p>to look like this:
+<p><blockquote><pre>#include &lt;iostream&gt;
+#include &lt;db_cxx.h&gt;
+<p>
+using std::cerr;
+<p>
+void foo(Db db) {
+	db.set_error_stream(&cerr);
+}</pre></blockquote>
+<table width="100%"><tr><td><br></td><td align=right><a href="../../ref/upgrade.4.0/java.html"><img src="../../images/prev.gif" alt="Prev"></a><a href="../../reftoc.html"><img src="../../images/ref.gif" alt="Ref"></a><a href="../../ref/upgrade.4.0/asr.html"><img src="../../images/next.gif" alt="Next"></a>
+</td></tr></table>
+<p><font size=1><a href="http://www.sleepycat.com">Copyright Sleepycat Software</a></font>
+</body>
+</html>
diff --git a/db/include/db_cxx.in b/db/include/db_cxx.in
new file mode 100644
index 000000000..95c0bc03c
--- /dev/null
+++ b/db/include/db_cxx.in
@@ -0,0 +1,726 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997-2001
+ *	Sleepycat Software.  All rights reserved.
+ *
+ * Id: db_cxx.in,v 11.87 2001/11/09 21:31:35 bostic Exp 
+ */
+
+#ifndef _DB_CXX_H_
+#define	_DB_CXX_H_
+//
+// C++ assumptions:
+//
+// To ensure portability to many platforms, both new and old, we make
+// few assumptions about the C++ compiler and library.  For example,
+// we do not expect STL, templates or namespaces to be available.  The
+// "newest" C++ feature used is exceptions, which are used liberally
+// to transmit error information.  Even the use of exceptions can be
+// disabled at runtime, to do so, use the DB_CXX_NO_EXCEPTIONS flags
+// with the DbEnv or Db constructor.
+//
+// C++ naming conventions:
+//
+//  - All top level class names start with Db.
+//  - All class members start with lower case letter.
+//  - All private data members are suffixed with underscore.
+//  - Use underscores to divide names into multiple words.
+//  - Simple data accessors are named with get_ or set_ prefix.
+//  - All method names are taken from names of functions in the C
+//    layer of db (usually by dropping a prefix like "db_").
+//    These methods have the same argument types and order,
+//    other than dropping the explicit arg that acts as "this".
+//
+// As a rule, each DbFoo object has exactly one underlying DB_FOO struct
+// (defined in db.h) associated with it.  In some cases, we inherit directly
+// from the DB_FOO structure to make this relationship explicit.  Often,
+// the underlying C layer allocates and deallocates these structures, so
+// there is no easy way to add any data to the DbFoo class.  When you see
+// a comment about whether data is permitted to be added, this is what
+// is going on.  Of course, if we need to add data to such C++ classes
+// in the future, we will arrange to have an indirect pointer to the
+// DB_FOO struct (as some of the classes already have).
+//
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Forward declarations
+//
+
+#include <stdarg.h>
+
+@cxx_have_stdheaders@
+#ifdef HAVE_CXX_STDHEADERS
+#include <iostream>
+#define	OSTREAMCLASS	std::ostream
+#else
+#include <iostream.h>
+#define	OSTREAMCLASS	ostream
+#endif
+
+#include "db.h"
+#include "cxx_common.h"
+#include "cxx_except.h"
+
+class Db;                                        // forward
+class Dbc;                                       // forward
+class DbEnv;                                     // forward
+class DbInfo;                                    // forward
+class DbLock;                                    // forward
+class DbLogc;                                    // forward
+class DbLsn;                                     // forward
+class DbMpoolFile;                               // forward
+class Dbt;                                       // forward
+class DbTxn;                                     // forward
+
+// These classes are not defined here and should be invisible
+// to the user, but some compilers require forward references.
+// There is one for each use of the DEFINE_DB_CLASS macro.
+
+class DbImp;
+class DbEnvImp;
+class DbMpoolFileImp;
+class DbTxnImp;
+
+// DEFINE_DB_CLASS defines an imp_ data member and imp() accessor.
+// The underlying type is a pointer to an opaque *Imp class, that
+// gets converted to the correct implementation class by the implementation.
+//
+// Since these defines use "private/public" labels, and leave the access
+// being "private", we always use these by convention before any data
+// members in the private section of a class.  Keeping them in the
+// private section also emphasizes that they are off limits to user code.
+//
+#define	DEFINE_DB_CLASS(name) \
+	public: class name##Imp* imp() { return (imp_); } \
+	public: const class name##Imp* constimp() const { return (imp_); } \
+	private: class name##Imp* imp_
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Turn off inappropriate compiler warnings
+//
+
+#ifdef _MSC_VER
+
+// These are level 4 warnings that are explicitly disabled.
+// With Visual C++, by default you do not see above level 3 unless
+// you use /W4.  But we like to compile with the highest level
+// warnings to catch other errors.
+//
+// 4201: nameless struct/union
+//       triggered by standard include file <winnt.h>
+//
+// 4514: unreferenced inline function has been removed
+//       certain include files in MSVC define methods that are not called
+//
+#pragma warning(disable: 4201 4514)
+
+#endif
+
+// Some interfaces can be customized by allowing users to define
+// callback functions.  For performance and logistical reasons, some
+// callback functions must be declared in extern "C" blocks.  For others,
+// we allow you to declare the callbacks in C++ or C (or an extern "C"
+// block) as you wish.  See the set methods for the callbacks for
+// the choices.
+//
+extern "C" {
+	typedef void * (*db_malloc_fcn_type)
+		(size_t);
+	typedef void * (*db_realloc_fcn_type)
+		(void *, size_t);
+	typedef void (*db_free_fcn_type)
+		(void *);
+	typedef int (*bt_compare_fcn_type)          /*C++ version available*/
+		(DB *, const DBT *, const DBT *);
+	typedef size_t (*bt_prefix_fcn_type)        /*C++ version available*/
+		(DB *, const DBT *, const DBT *);
+	typedef int (*dup_compare_fcn_type)         /*C++ version available*/
+		(DB *, const DBT *, const DBT *);
+	typedef u_int32_t (*h_hash_fcn_type)        /*C++ version available*/
+		(DB *, const void *, u_int32_t);
+	typedef int (*pgin_fcn_type)
+		(DB_ENV *dbenv, db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
+	typedef int (*pgout_fcn_type)
+		(DB_ENV *dbenv, db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Lock classes
+//
+
+class _exported DbLock
+{
+	friend class DbEnv;
+
+public:
+	DbLock();
+
+	int put(DbEnv *env);
+
+	DbLock(const DbLock &);
+	DbLock &operator = (const DbLock &);
+
+protected:
+	// We can add data to this class if needed
+	// since its contained class is not allocated by db.
+	// (see comment at top)
+
+	DbLock(DB_LOCK);
+	DB_LOCK lock_;
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Log classes
+//
+
+class _exported DbLsn : protected DB_LSN
+{
+	friend class DbEnv;          // friendship needed to cast to base class
+	friend class DbLogc;         // friendship needed to cast to base class
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Memory pool classes
+//
+
+class _exported DbMpoolFile
+{
+	friend class DbEnv;
+
+public:
+	int close(u_int32_t flags);
+	int get(db_pgno_t *pgnoaddr, u_int32_t flags, void *pagep);
+	void last_pgno(db_pgno_t *pgnoaddr);
+	int open(const char *file, u_int32_t flags, int mode, size_t pagesize);
+	int put(void *pgaddr, u_int32_t flags);
+	void refcnt(db_pgno_t *pgnoaddr);
+	int set(void *pgaddr, u_int32_t flags);
+	int set_clear_len(u_int32_t len);
+	int set_fileid(u_int8_t *fileid);
+	int set_ftype(int ftype);
+	int set_lsn_offset(int32_t offset);
+	int set_pgcookie(DBT *dbt);
+	void set_unlink(int);
+	int sync();
+
+private:
+	// We can add data to this class if needed
+	// since it is implemented via a pointer.
+	// (see comment at top)
+
+	// Note: use DbEnv::memp_fcreate() to get pointers to a DbMpoolFile,
+	// and call DbMpoolFile::close() rather than delete to release them.
+	//
+	DbMpoolFile();
+
+	// Shut g++ up.
+protected:
+	~DbMpoolFile();
+
+private:
+	// no copying
+	DbMpoolFile(const DbMpoolFile &);
+	void operator = (const DbMpoolFile &);
+
+	DEFINE_DB_CLASS(DbMpoolFile);
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Transaction classes
+//
+
+class _exported DbTxn
+{
+	friend class DbEnv;
+
+public:
+	int abort();
+	int commit(u_int32_t flags);
+	u_int32_t id();
+	int prepare(u_int8_t *gid);
+	int set_timeout(db_timeout_t timeout, u_int32_t flags);
+
+private:
+	// We can add data to this class if needed
+	// since it is implemented via a pointer.
+	// (see comment at top)
+
+	// Note: use DbEnv::txn_begin() to get pointers to a DbTxn,
+	// and call DbTxn::abort() or DbTxn::commit rather than
+	// delete to release them.
+	//
+	DbTxn();
+	~DbTxn();
+
+	// no copying
+	DbTxn(const DbTxn &);
+	void operator = (const DbTxn &);
+
+	DEFINE_DB_CLASS(DbTxn);
+};
+
+//
+// Berkeley DB environment class.  Provides functions for opening databases.
+// User of this library can use this class as a starting point for
+// developing a DB application - derive their application class from
+// this one, add application control logic.
+//
+// Note that if you use the default constructor, you must explicitly
+// call appinit() before any other db activity (e.g. opening files)
+//
+class _exported DbEnv
+{
+	friend class Db;
+	friend class DbLock;
+	friend class DbMpoolFile;
+
+public:
+
+	~DbEnv();
+
+	// After using this constructor, you can set any needed
+	// parameters for the environment using the set_* methods.
+	// Then call open() to finish initializing the environment
+	// and attaching it to underlying files.
+	//
+	DbEnv(u_int32_t flags);
+
+	// These methods match those in the C interface.
+	//
+	int close(u_int32_t);
+	void err(int, const char *, ...);
+	void errx(const char *, ...);
+	void *get_app_private() const;
+	int open(const char *, u_int32_t, int);
+	int remove(const char *, u_int32_t);
+	int set_alloc(db_malloc_fcn_type, db_realloc_fcn_type,
+		      db_free_fcn_type);
+	void set_app_private(void *);
+	int set_cachesize(u_int32_t, u_int32_t, int);
+	int set_data_dir(const char *);
+	void set_errcall(void (*)(const char *, char *));
+	void set_errfile(FILE *);
+	void set_errpfx(const char *);
+	int set_flags(u_int32_t, int);
+	int set_feedback(void (*)(DbEnv *, int, int));
+	int set_recovery_init(int (*)(DbEnv *));
+	int set_lg_bsize(u_int32_t);
+	int set_lg_dir(const char *);
+	int set_lg_max(u_int32_t);
+	int set_lg_regionmax(u_int32_t);
+	int set_lk_conflicts(u_int8_t *, int);
+	int set_lk_detect(u_int32_t);
+	int set_lk_max(u_int32_t);
+	int set_lk_max_lockers(u_int32_t);
+	int set_lk_max_locks(u_int32_t);
+	int set_lk_max_objects(u_int32_t);
+	int set_mp_mmapsize(size_t);
+	int set_paniccall(void (*)(DbEnv *, int));
+	int set_rpc_server(void *, char *, long, long, u_int32_t);
+	int set_shm_key(long);
+	int set_timeout(db_timeout_t timeout, u_int32_t flags);
+	int set_tmp_dir(const char *);
+	int set_tas_spins(u_int32_t);
+	int set_tx_max(u_int32_t);
+	int set_tx_recover(int (*)(DbEnv *, Dbt *, DbLsn *, db_recops));
+	int set_tx_timestamp(time_t *);
+	int set_verbose(u_int32_t which, int onoff);
+
+	// Version information.  A static method so it can be obtained anytime.
+	//
+	static char *version(int *major, int *minor, int *patch);
+
+	// Convert DB errors to strings
+	static char *strerror(int);
+
+	// If an error is detected and the error call function
+	// or stream is set, a message is dispatched or printed.
+	// If a prefix is set, each message is prefixed.
+	//
+	// You can use set_errcall() or set_errfile() above to control
+	// error functionality.  Alternatively, you can call
+	// set_error_stream() to force all errors to a C++ stream.
+	// It is unwise to mix these approaches.
+	//
+	void set_error_stream(OSTREAMCLASS *);
+
+	// used internally
+	static void runtime_error(const char *caller, int err,
+				  int error_policy);
+	static void runtime_error_dbt(const char *caller, Dbt *dbt,
+				  int error_policy);
+
+	// Lock functions
+	//
+	int lock_detect(u_int32_t flags, u_int32_t atype, int *aborted);
+	int lock_get(u_int32_t locker, u_int32_t flags, const Dbt *obj,
+		     db_lockmode_t lock_mode, DbLock *lock);
+	int lock_id(u_int32_t *idp);
+	int lock_id_free(u_int32_t id);
+	int lock_stat(DB_LOCK_STAT **statp, u_int32_t flags);
+	int lock_vec(u_int32_t locker, u_int32_t flags, DB_LOCKREQ list[],
+		     int nlist, DB_LOCKREQ **elistp);
+
+	// Log functions
+	//
+	int log_archive(char **list[], u_int32_t flags);
+	static int log_compare(const DbLsn *lsn0, const DbLsn *lsn1);
+	int log_cursor(DbLogc **cursorp, u_int32_t flags);
+	int log_file(DbLsn *lsn, char *namep, size_t len);
+	int log_flush(const DbLsn *lsn);
+	int log_put(DbLsn *lsn, const Dbt *data, u_int32_t flags);
+
+	int log_register(Db *dbp, const char *name);
+	int log_stat(DB_LOG_STAT **spp, u_int32_t flags);
+	int log_unregister(Db *dbp);
+
+	// Mpool functions
+	//
+	int memp_fcreate(DbMpoolFile **dbmfp, u_int32_t flags);
+	int memp_register(int ftype,
+			  pgin_fcn_type pgin_fcn,
+			  pgout_fcn_type pgout_fcn);
+	int memp_stat(DB_MPOOL_STAT
+		      **gsp, DB_MPOOL_FSTAT ***fsp, u_int32_t flags);
+	int memp_sync(DbLsn *lsn);
+	int memp_trickle(int pct, int *nwrotep);
+
+	// Transaction functions
+	//
+	int txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags);
+	int txn_checkpoint(u_int32_t kbyte, u_int32_t min, u_int32_t flags);
+	int txn_recover(DB_PREPLIST *preplist, long count,
+			long *retp, u_int32_t flags);
+	int txn_stat(DB_TXN_STAT **statp, u_int32_t flags);
+
+	// Replication functions
+	//
+	int rep_elect(int, int, u_int32_t, int *);
+	int rep_process_message(Dbt *, Dbt *, int *);
+	int rep_start(Dbt *, u_int32_t);
+	int set_rep_transport(u_int32_t,
+	    int (*)(DbEnv *, const Dbt *, const Dbt *, int, u_int32_t));
+
+	// Conversion functions
+	//
+	DB_ENV *get_DB_ENV()
+	{
+		return (DB_ENV *)imp();
+	}
+
+	const DB_ENV *get_const_DB_ENV() const
+	{
+		return (const DB_ENV *)constimp();
+	}
+
+	static DbEnv* get_DbEnv(DB_ENV *dbenv)
+	{
+		return (DbEnv *)dbenv->cj_internal;
+	}
+
+	static const DbEnv* get_const_DbEnv(const DB_ENV *dbenv)
+	{
+		return (const DbEnv *)dbenv->cj_internal;
+	}
+
+	// These are public only because they need to be called
+	// via C functions.  They should never be called by users
+	// of this class.
+	//
+	static void _stream_error_function(const char *, char *);
+	static int _tx_recover_intercept(DB_ENV *env, DBT *dbt, DB_LSN *lsn,
+					db_recops op);
+	static void _paniccall_intercept(DB_ENV *env, int errval);
+	static int _recovery_init_intercept(DB_ENV *env);
+	static void _feedback_intercept(DB_ENV *env, int opcode, int pct);
+	static int _rep_send_intercept(DB_ENV *env,
+				       const DBT *cntrl, const DBT *data,
+				       int id, u_int32_t flags);
+	static void _destroy_check(const char *str, int isDbEnv);
+
+private:
+	void cleanup();
+	int initialize(DB_ENV *env);
+	int error_policy();
+
+	// Used internally
+	DbEnv(DB_ENV *, u_int32_t flags);
+
+	// no copying
+	DbEnv(const DbEnv &);
+	void operator = (const DbEnv &);
+
+	DEFINE_DB_CLASS(DbEnv);
+
+	// instance data
+	int construct_error_;
+	u_int32_t construct_flags_;
+	int (*tx_recover_callback_)(DbEnv *, Dbt *, DbLsn *, db_recops);
+	int (*recovery_init_callback_)(DbEnv *);
+	void (*paniccall_callback_)(DbEnv *, int);
+	void (*feedback_callback_)(DbEnv *, int, int);
+	int (*pgin_callback_)(DbEnv *dbenv, db_pgno_t pgno,
+			      void *pgaddr, Dbt *pgcookie);
+	int (*pgout_callback_)(DbEnv *dbenv, db_pgno_t pgno,
+			       void *pgaddr, Dbt *pgcookie);
+	int (*rep_send_callback_)(DbEnv *,
+	    const Dbt *, const Dbt *, int, u_int32_t);
+
+	// class data
+	static OSTREAMCLASS *error_stream_;
+};
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+//
+// Table access classes
+//
+
+//
+// Represents a database table = a set of keys with associated values.
+//
+class _exported Db
+{
+	friend class DbEnv;
+
+public:
+	Db(DbEnv*, u_int32_t);      // create a Db object, then call open()
+	~Db();                      // does *not* call close.
+
+	// These methods exactly match those in the C interface.
+	//
+	int associate(Db *secondary, int (*callback)(Db *, const Dbt *,
+		const Dbt *, Dbt *), u_int32_t flags);
+	int close(u_int32_t flags);
+	int cursor(DbTxn *txnid, Dbc **cursorp, u_int32_t flags);
+	int del(DbTxn *txnid, Dbt *key, u_int32_t flags);
+	void err(int, const char *, ...);
+	void errx(const char *, ...);
+	int fd(int *fdp);
+	int get(DbTxn *txnid, Dbt *key, Dbt *data, u_int32_t flags);
+	void *get_app_private() const;
+	int get_byteswapped(int *);
+	int get_type(DBTYPE *);
+	int join(Dbc **curslist, Dbc **dbcp, u_int32_t flags);
+	int key_range(DbTxn *, Dbt *, DB_KEY_RANGE *, u_int32_t);
+	int open(const char *, const char *subname, DBTYPE, u_int32_t, int);
+	int pget(DbTxn *txnid, Dbt *key, Dbt *pkey, Dbt *data,
+		 u_int32_t flags);
+	int put(DbTxn *, Dbt *, Dbt *, u_int32_t);
+	int remove(const char *, const char *, u_int32_t);
+	int rename(const char *, const char *, const char *, u_int32_t);
+	int set_alloc(db_malloc_fcn_type, db_realloc_fcn_type,
+		      db_free_fcn_type);
+	void set_app_private(void *);
+	int set_append_recno(int (*)(Db *, Dbt *, db_recno_t));
+	int set_bt_compare(bt_compare_fcn_type); /*deprecated*/
+	int set_bt_compare(int (*)(Db *, const Dbt *, const Dbt *));
+	int set_bt_maxkey(u_int32_t);
+	int set_bt_minkey(u_int32_t);
+	int set_bt_prefix(bt_prefix_fcn_type); /*deprecated*/
+	int set_bt_prefix(size_t (*)(Db *, const Dbt *, const Dbt *));
+	int set_cachesize(u_int32_t, u_int32_t, int);
+	int set_dup_compare(dup_compare_fcn_type); /*deprecated*/
+	int set_dup_compare(int (*)(Db *, const Dbt *, const Dbt *));
+	void set_errcall(void (*)(const char *, char *));
+	void set_errfile(FILE *);
+	void set_errpfx(const char *);
+	int set_feedback(void (*)(Db *, int, int));
+	int set_flags(u_int32_t);
+	int set_h_ffactor(u_int32_t);
+	int set_h_hash(h_hash_fcn_type); /*deprecated*/
+	int set_h_hash(u_int32_t (*)(Db *, const void *, u_int32_t));
+	int set_h_nelem(u_int32_t);
+	int set_lorder(int);
+	int set_pagesize(u_int32_t);
+	int set_paniccall(void (*)(DbEnv *, int));
+	int set_re_delim(int);
+	int set_re_len(u_int32_t);
+	int set_re_pad(int);
+	int set_re_source(char *);
+	int set_q_extentsize(u_int32_t);
+	int stat(void *sp, u_int32_t flags);
+	int sync(u_int32_t flags);
+	int truncate(DbTxn *, u_int32_t *, u_int32_t);
+	int upgrade(const char *name, u_int32_t flags);
+	int verify(const char *, const char *, OSTREAMCLASS *, u_int32_t);
+
+	// These additional methods are not in the C interface, and
+	// are only available for C++.
+	//
+	void set_error_stream(OSTREAMCLASS *);
+
+	DB *get_DB()
+	{
+		return (DB *)imp();
+	}
+
+	const DB *get_const_DB() const
+	{
+		return (const DB *)constimp();
+	}
+
+	static Db* get_Db(DB *db)
+	{
+		return (Db *)db->cj_internal;
+	}
+
+	static const Db* get_const_Db(const DB *db)
+	{
+		return (const Db *)db->cj_internal;
+	}
+
+	// These are public only because they need to be called
+	// via C callback functions.  They should never be used by
+	// external users of this class.
+	//
+	void (*feedback_callback_)(Db *, int, int);
+	int (*append_recno_callback_)(Db *, Dbt *, db_recno_t);
+	int (*bt_compare_callback_)(Db *, const Dbt *, const Dbt *);
+	size_t (*bt_prefix_callback_)(Db *, const Dbt *, const Dbt *);
+	int (*dup_compare_callback_)(Db *, const Dbt *, const Dbt *);
+	u_int32_t (*h_hash_callback_)(Db *, const void *, u_int32_t);
+	int (*associate_callback_)(Db *, const Dbt *, const Dbt *, Dbt *);
+private:
+
+	// no copying
+	Db(const Db &);
+	Db &operator = (const Db &);
+
+	DEFINE_DB_CLASS(Db);
+
+	void cleanup();
+	int initialize();
+	int error_policy();
+
+	// instance data
+	DbEnv *env_;
+	int construct_error_;
+	u_int32_t flags_;
+	u_int32_t construct_flags_;
+};
+
+//
+// A chunk of data, maybe a key or value.
+//
+class _exported Dbt : private DBT
+{
+	friend class Dbc;
+	friend class Db;
+	friend class DbEnv;
+	friend class DbLogc;
+
+public:
+
+	// key/data
+	void *get_data() const                 { return data; }
+	void set_data(void *value)             { data = value; }
+
+	// key/data length
+	u_int32_t get_size() const             { return size; }
+	void set_size(u_int32_t value)         { size = value; }
+
+	// RO: length of user buffer.
+	u_int32_t get_ulen() const             { return ulen; }
+	void set_ulen(u_int32_t value)         { ulen = value; }
+
+	// RO: get/put record length.
+	u_int32_t get_dlen() const             { return dlen; }
+	void set_dlen(u_int32_t value)         { dlen = value; }
+
+	// RO: get/put record offset.
+	u_int32_t get_doff() const             { return doff; }
+	void set_doff(u_int32_t value)         { doff = value; }
+
+	// flags
+	u_int32_t get_flags() const            { return flags; }
+	void set_flags(u_int32_t value)        { flags = value; }
+
+	// Conversion functions
+	DBT *get_DBT()                         { return (DBT *)this; }
+	const DBT *get_const_DBT() const       { return (const DBT *)this; }
+
+	static Dbt* get_Dbt(DBT *dbt)          { return (Dbt *)dbt; }
+	static const Dbt* get_const_Dbt(const DBT *dbt)
+					       { return (const Dbt *)dbt; }
+
+	Dbt(void *data, size_t size);
+	Dbt();
+	~Dbt();
+	Dbt(const Dbt &);
+	Dbt &operator = (const Dbt &);
+
+private:
+	// Note: no extra data appears in this class (other than
+	// inherited from DBT) since we need DBT and Dbt objects
+	// to have interchangable pointers.
+	//
+	// When subclassing this class, remember that callback
+	// methods like bt_compare, bt_prefix, dup_compare may
+	// internally manufacture DBT objects (which later are
+	// cast to Dbt), so such callbacks might receive objects
+	// not of your subclassed type.
+};
+
+class _exported Dbc : protected DBC
+{
+	friend class Db;
+
+public:
+	int close();
+	int count(db_recno_t *countp, u_int32_t flags);
+	int del(u_int32_t flags);
+	int dup(Dbc** cursorp, u_int32_t flags);
+	int get(Dbt* key, Dbt *data, u_int32_t flags);
+	int pget(Dbt* key, Dbt* pkey, Dbt *data, u_int32_t flags);
+	int put(Dbt* key, Dbt *data, u_int32_t flags);
+
+private:
+	// No data is permitted in this class (see comment at top)
+
+	// Note: use Db::cursor() to get pointers to a Dbc,
+	// and call Dbc::close() rather than delete to release them.
+	//
+	Dbc();
+	~Dbc();
+
+	// no copying
+	Dbc(const Dbc &);
+	Dbc &operator = (const Dbc &);
+};
+
+class _exported DbLogc : protected DB_LOGC
+{
+	friend class DbEnv;
+
+public:
+	int close(u_int32_t _flags);
+	int get(DbLsn *lsn, Dbt *data, u_int32_t _flags);
+
+private:
+	// No data is permitted in this class (see comment at top)
+
+	// Note: use Db::cursor() to get pointers to a Dbc,
+	// and call Dbc::close() rather than delete to release them.
+	//
+	DbLogc();
+	~DbLogc();
+
+	// no copying
+	DbLogc(const Dbc &);
+	DbLogc &operator = (const Dbc &);
+};
+#endif /* !_DB_CXX_H_ */
diff --git a/db/perl/BerkeleyDB/constants.h b/db/perl/BerkeleyDB/constants.h
new file mode 100644
index 000000000..83db0fec6
--- /dev/null
+++ b/db/perl/BerkeleyDB/constants.h
@@ -0,0 +1,3555 @@
+#define PERL_constant_NOTFOUND	1
+#define PERL_constant_NOTDEF	2
+#define PERL_constant_ISIV	3
+#define PERL_constant_ISNO	4
+#define PERL_constant_ISNV	5
+#define PERL_constant_ISPV	6
+#define PERL_constant_ISPVN	7
+#define PERL_constant_ISSV	8
+#define PERL_constant_ISUNDEF	9
+#define PERL_constant_ISUV	10
+#define PERL_constant_ISYES	11
+
+#ifndef NVTYPE
+typedef double NV; /* 5.6 and later define NVTYPE, and typedef NV to it.  */
+#endif
+#ifndef aTHX_
+#define aTHX_ /* 5.6 or later define this for threading support.  */
+#endif
+#ifndef pTHX_
+#define pTHX_ /* 5.6 or later define this for threading support.  */
+#endif
+
+static int
+constant_6 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_DUP DB_PAD DB_RMW DB_SET */
+  /* Offset 3 gives the best switch position.  */
+  switch (name[3]) {
+  case 'D':
+    if (memEQ(name, "DB_DUP", 6)) {
+    /*                  ^        */
+#ifdef DB_DUP
+      *iv_return = DB_DUP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "DB_PAD", 6)) {
+    /*                  ^        */
+#ifdef DB_PAD
+      *iv_return = DB_PAD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "DB_RMW", 6)) {
+    /*                  ^        */
+#ifdef DB_RMW
+      *iv_return = DB_RMW;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_SET", 6)) {
+    /*                  ^        */
+#ifdef DB_SET
+      *iv_return = DB_SET;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_7 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_EXCL DB_HASH DB_LAST DB_NEXT DB_PREV */
+  /* Offset 3 gives the best switch position.  */
+  switch (name[3]) {
+  case 'E':
+    if (memEQ(name, "DB_EXCL", 7)) {
+    /*                  ^         */
+#ifdef DB_EXCL
+      *iv_return = DB_EXCL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'H':
+    if (memEQ(name, "DB_HASH", 7)) {
+    /*                  ^         */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_HASH;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_LAST", 7)) {
+    /*                  ^         */
+#ifdef DB_LAST
+      *iv_return = DB_LAST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_NEXT", 7)) {
+    /*                  ^         */
+#ifdef DB_NEXT
+      *iv_return = DB_NEXT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "DB_PREV", 7)) {
+    /*                  ^         */
+#ifdef DB_PREV
+      *iv_return = DB_PREV;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_8 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_AFTER DB_BTREE DB_FIRST DB_FLUSH DB_FORCE DB_QUEUE DB_RECNO */
+  /* Offset 4 gives the best switch position.  */
+  switch (name[4]) {
+  case 'E':
+    if (memEQ(name, "DB_RECNO", 8)) {
+    /*                   ^         */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_RECNO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'F':
+    if (memEQ(name, "DB_AFTER", 8)) {
+    /*                   ^         */
+#ifdef DB_AFTER
+      *iv_return = DB_AFTER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_FIRST", 8)) {
+    /*                   ^         */
+#ifdef DB_FIRST
+      *iv_return = DB_FIRST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_FLUSH", 8)) {
+    /*                   ^         */
+#ifdef DB_FLUSH
+      *iv_return = DB_FLUSH;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_FORCE", 8)) {
+    /*                   ^         */
+#ifdef DB_FORCE
+      *iv_return = DB_FORCE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_BTREE", 8)) {
+    /*                   ^         */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_BTREE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'U':
+    if (memEQ(name, "DB_QUEUE", 8)) {
+    /*                   ^         */
+#if (DB_VERSION_MAJOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 55)
+      *iv_return = DB_QUEUE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_9 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_APPEND DB_BEFORE DB_CLIENT DB_COMMIT DB_CREATE DB_CURLSN DB_EXTENT
+     DB_GETREC DB_NOMMAP DB_NOSYNC DB_RDONLY DB_RECNUM DB_THREAD DB_VERIFY */
+  /* Offset 5 gives the best switch position.  */
+  switch (name[5]) {
+  case 'C':
+    if (memEQ(name, "DB_RECNUM", 9)) {
+    /*                    ^         */
+#ifdef DB_RECNUM
+      *iv_return = DB_RECNUM;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_CREATE", 9)) {
+    /*                    ^         */
+#ifdef DB_CREATE
+      *iv_return = DB_CREATE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'F':
+    if (memEQ(name, "DB_BEFORE", 9)) {
+    /*                    ^         */
+#ifdef DB_BEFORE
+      *iv_return = DB_BEFORE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_CLIENT", 9)) {
+    /*                    ^         */
+#ifdef DB_CLIENT
+      *iv_return = DB_CLIENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "DB_COMMIT", 9)) {
+    /*                    ^         */
+#ifdef DB_COMMIT
+      *iv_return = DB_COMMIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_NOMMAP", 9)) {
+    /*                    ^         */
+#ifdef DB_NOMMAP
+      *iv_return = DB_NOMMAP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_RDONLY", 9)) {
+    /*                    ^         */
+#ifdef DB_RDONLY
+      *iv_return = DB_RDONLY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "DB_APPEND", 9)) {
+    /*                    ^         */
+#ifdef DB_APPEND
+      *iv_return = DB_APPEND;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "DB_CURLSN", 9)) {
+    /*                    ^         */
+#ifdef DB_CURLSN
+      *iv_return = DB_CURLSN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_THREAD", 9)) {
+    /*                    ^         */
+#ifdef DB_THREAD
+      *iv_return = DB_THREAD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_VERIFY", 9)) {
+    /*                    ^         */
+#ifdef DB_VERIFY
+      *iv_return = DB_VERIFY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_NOSYNC", 9)) {
+    /*                    ^         */
+#ifdef DB_NOSYNC
+      *iv_return = DB_NOSYNC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_EXTENT", 9)) {
+    /*                    ^         */
+#ifdef DB_EXTENT
+      *iv_return = DB_EXTENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_GETREC", 9)) {
+    /*                    ^         */
+#ifdef DB_GETREC
+      *iv_return = DB_GETREC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_10 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_CONSUME DB_CURRENT DB_DELETED DB_DUPSORT DB_ENV_CDB DB_ENV_TXN
+     DB_JOINENV DB_KEYLAST DB_NOPANIC DB_OK_HASH DB_PRIVATE DB_PR_PAGE
+     DB_RECOVER DB_SALVAGE DB_TIMEOUT DB_TXN_CKP DB_UNKNOWN DB_UPGRADE */
+  /* Offset 8 gives the best switch position.  */
+  switch (name[8]) {
+  case 'D':
+    if (memEQ(name, "DB_ENV_CDB", 10)) {
+    /*                       ^        */
+#ifdef DB_ENV_CDB
+      *iv_return = DB_ENV_CDB;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_UPGRADE", 10)) {
+    /*                       ^        */
+#ifdef DB_UPGRADE
+      *iv_return = DB_UPGRADE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_DELETED", 10)) {
+    /*                       ^        */
+#ifdef DB_DELETED
+      *iv_return = DB_DELETED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_RECOVER", 10)) {
+    /*                       ^        */
+#ifdef DB_RECOVER
+      *iv_return = DB_RECOVER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_PR_PAGE", 10)) {
+    /*                       ^        */
+#ifdef DB_PR_PAGE
+      *iv_return = DB_PR_PAGE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_SALVAGE", 10)) {
+    /*                       ^        */
+#ifdef DB_SALVAGE
+      *iv_return = DB_SALVAGE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_NOPANIC", 10)) {
+    /*                       ^        */
+#ifdef DB_NOPANIC
+      *iv_return = DB_NOPANIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'K':
+    if (memEQ(name, "DB_TXN_CKP", 10)) {
+    /*                       ^        */
+#ifdef DB_TXN_CKP
+      *iv_return = DB_TXN_CKP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "DB_CONSUME", 10)) {
+    /*                       ^        */
+#ifdef DB_CONSUME
+      *iv_return = DB_CONSUME;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_CURRENT", 10)) {
+    /*                       ^        */
+#ifdef DB_CURRENT
+      *iv_return = DB_CURRENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_JOINENV", 10)) {
+    /*                       ^        */
+#ifdef DB_JOINENV
+      *iv_return = DB_JOINENV;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "DB_DUPSORT", 10)) {
+    /*                       ^        */
+#ifdef DB_DUPSORT
+      *iv_return = DB_DUPSORT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_KEYLAST", 10)) {
+    /*                       ^        */
+#ifdef DB_KEYLAST
+      *iv_return = DB_KEYLAST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_OK_HASH", 10)) {
+    /*                       ^        */
+#ifdef DB_OK_HASH
+      *iv_return = DB_OK_HASH;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_PRIVATE", 10)) {
+    /*                       ^        */
+#ifdef DB_PRIVATE
+      *iv_return = DB_PRIVATE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'U':
+    if (memEQ(name, "DB_TIMEOUT", 10)) {
+    /*                       ^        */
+#ifdef DB_TIMEOUT
+      *iv_return = DB_TIMEOUT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'W':
+    if (memEQ(name, "DB_UNKNOWN", 10)) {
+    /*                       ^        */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_UNKNOWN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'X':
+    if (memEQ(name, "DB_ENV_TXN", 10)) {
+    /*                       ^        */
+#ifdef DB_ENV_TXN
+      *iv_return = DB_ENV_TXN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_11 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_APP_INIT DB_ARCH_ABS DB_ARCH_LOG DB_FIXEDLEN DB_GET_BOTH DB_INIT_CDB
+     DB_INIT_LOG DB_INIT_TXN DB_KEYEMPTY DB_KEYEXIST DB_KEYFIRST DB_LOCKDOWN
+     DB_LOCK_GET DB_LOCK_PUT DB_LOGMAGIC DB_LOG_DISK DB_MULTIPLE DB_NEXT_DUP
+     DB_NOSERVER DB_NOTFOUND DB_OK_BTREE DB_OK_QUEUE DB_OK_RECNO DB_POSITION
+     DB_QAMMAGIC DB_RENUMBER DB_SNAPSHOT DB_TRUNCATE DB_TXNMAGIC DB_TXN_REDO
+     DB_TXN_SYNC DB_TXN_UNDO DB_YIELDCPU */
+  /* Offset 8 gives the best switch position.  */
+  switch (name[8]) {
+  case 'A':
+    if (memEQ(name, "DB_ARCH_ABS", 11)) {
+    /*                       ^         */
+#ifdef DB_ARCH_ABS
+      *iv_return = DB_ARCH_ABS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TRUNCATE", 11)) {
+    /*                       ^         */
+#ifdef DB_TRUNCATE
+      *iv_return = DB_TRUNCATE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'B':
+    if (memEQ(name, "DB_RENUMBER", 11)) {
+    /*                       ^         */
+#ifdef DB_RENUMBER
+      *iv_return = DB_RENUMBER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'C':
+    if (memEQ(name, "DB_INIT_CDB", 11)) {
+    /*                       ^         */
+#ifdef DB_INIT_CDB
+      *iv_return = DB_INIT_CDB;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_OK_RECNO", 11)) {
+    /*                       ^         */
+#ifdef DB_OK_RECNO
+      *iv_return = DB_OK_RECNO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_YIELDCPU", 11)) {
+    /*                       ^         */
+#ifdef DB_YIELDCPU
+      *iv_return = DB_YIELDCPU;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'D':
+    if (memEQ(name, "DB_NEXT_DUP", 11)) {
+    /*                       ^         */
+#ifdef DB_NEXT_DUP
+      *iv_return = DB_NEXT_DUP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_OK_QUEUE", 11)) {
+    /*                       ^         */
+#ifdef DB_OK_QUEUE
+      *iv_return = DB_OK_QUEUE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_REDO", 11)) {
+    /*                       ^         */
+#ifdef DB_TXN_REDO
+      *iv_return = DB_TXN_REDO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_LOCK_GET", 11)) {
+    /*                       ^         */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_LOCK_GET;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOGMAGIC", 11)) {
+    /*                       ^         */
+#ifdef DB_LOGMAGIC
+      *iv_return = DB_LOGMAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_QAMMAGIC", 11)) {
+    /*                       ^         */
+#ifdef DB_QAMMAGIC
+      *iv_return = DB_QAMMAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXNMAGIC", 11)) {
+    /*                       ^         */
+#ifdef DB_TXNMAGIC
+      *iv_return = DB_TXNMAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'H':
+    if (memEQ(name, "DB_SNAPSHOT", 11)) {
+    /*                       ^         */
+#ifdef DB_SNAPSHOT
+      *iv_return = DB_SNAPSHOT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_KEYEXIST", 11)) {
+    /*                       ^         */
+#ifdef DB_KEYEXIST
+      *iv_return = DB_KEYEXIST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOG_DISK", 11)) {
+    /*                       ^         */
+#ifdef DB_LOG_DISK
+      *iv_return = DB_LOG_DISK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_POSITION", 11)) {
+    /*                       ^         */
+#ifdef DB_POSITION
+      *iv_return = DB_POSITION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_ARCH_LOG", 11)) {
+    /*                       ^         */
+#ifdef DB_ARCH_LOG
+      *iv_return = DB_ARCH_LOG;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_FIXEDLEN", 11)) {
+    /*                       ^         */
+#ifdef DB_FIXEDLEN
+      *iv_return = DB_FIXEDLEN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_INIT_LOG", 11)) {
+    /*                       ^         */
+#ifdef DB_INIT_LOG
+      *iv_return = DB_INIT_LOG;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_APP_INIT", 11)) {
+    /*                       ^         */
+#ifdef DB_APP_INIT
+      *iv_return = DB_APP_INIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_UNDO", 11)) {
+    /*                       ^         */
+#ifdef DB_TXN_UNDO
+      *iv_return = DB_TXN_UNDO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_GET_BOTH", 11)) {
+    /*                       ^         */
+#ifdef DB_GET_BOTH
+      *iv_return = DB_GET_BOTH;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCKDOWN", 11)) {
+    /*                       ^         */
+#ifdef DB_LOCKDOWN
+      *iv_return = DB_LOCKDOWN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "DB_KEYEMPTY", 11)) {
+    /*                       ^         */
+#ifdef DB_KEYEMPTY
+      *iv_return = DB_KEYEMPTY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_PUT", 11)) {
+    /*                       ^         */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_LOCK_PUT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_MULTIPLE", 11)) {
+    /*                       ^         */
+#ifdef DB_MULTIPLE
+      *iv_return = DB_MULTIPLE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "DB_KEYFIRST", 11)) {
+    /*                       ^         */
+#ifdef DB_KEYFIRST
+      *iv_return = DB_KEYFIRST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_OK_BTREE", 11)) {
+    /*                       ^         */
+#ifdef DB_OK_BTREE
+      *iv_return = DB_OK_BTREE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_INIT_TXN", 11)) {
+    /*                       ^         */
+#ifdef DB_INIT_TXN
+      *iv_return = DB_INIT_TXN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'U':
+    if (memEQ(name, "DB_NOTFOUND", 11)) {
+    /*                       ^         */
+#ifdef DB_NOTFOUND
+      *iv_return = DB_NOTFOUND;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'V':
+    if (memEQ(name, "DB_NOSERVER", 11)) {
+    /*                       ^         */
+#ifdef DB_NOSERVER
+      *iv_return = DB_NOSERVER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'Y':
+    if (memEQ(name, "DB_TXN_SYNC", 11)) {
+    /*                       ^         */
+#ifdef DB_TXN_SYNC
+      *iv_return = DB_TXN_SYNC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_12 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_ARCH_DATA DB_CDB_ALLDB DB_CL_WRITER DB_DELIMITER DB_DUPCURSOR
+     DB_FAST_STAT DB_GET_BOTHC DB_GET_RECNO DB_HASHMAGIC DB_INIT_LOCK
+     DB_JOIN_ITEM DB_LOCKMAGIC DB_LOCK_DUMP DB_LOCK_RW_N DB_LOGOLDVER
+     DB_MAX_PAGES DB_MPOOL_NEW DB_NEEDSPLIT DB_NODUPDATA DB_NOLOCKING
+     DB_NORECURSE DB_PAGEYIELD DB_PAGE_LOCK DB_POSITIONI DB_QAMOLDVER
+     DB_SET_RANGE DB_SET_RECNO DB_SWAPBYTES DB_TEMPORARY DB_TXN_ABORT
+     DB_TXN_APPLY DB_WRITELOCK DB_XA_CREATE */
+  /* Offset 3 gives the best switch position.  */
+  switch (name[3]) {
+  case 'A':
+    if (memEQ(name, "DB_ARCH_DATA", 12)) {
+    /*                  ^               */
+#ifdef DB_ARCH_DATA
+      *iv_return = DB_ARCH_DATA;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'C':
+    if (memEQ(name, "DB_CDB_ALLDB", 12)) {
+    /*                  ^               */
+#ifdef DB_CDB_ALLDB
+      *iv_return = DB_CDB_ALLDB;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_CL_WRITER", 12)) {
+    /*                  ^               */
+#ifdef DB_CL_WRITER
+      *iv_return = DB_CL_WRITER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'D':
+    if (memEQ(name, "DB_DELIMITER", 12)) {
+    /*                  ^               */
+#ifdef DB_DELIMITER
+      *iv_return = DB_DELIMITER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_DUPCURSOR", 12)) {
+    /*                  ^               */
+#ifdef DB_DUPCURSOR
+      *iv_return = DB_DUPCURSOR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'F':
+    if (memEQ(name, "DB_FAST_STAT", 12)) {
+    /*                  ^               */
+#ifdef DB_FAST_STAT
+      *iv_return = DB_FAST_STAT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_GET_BOTHC", 12)) {
+    /*                  ^               */
+#ifdef DB_GET_BOTHC
+      *iv_return = DB_GET_BOTHC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_GET_RECNO", 12)) {
+    /*                  ^               */
+#ifdef DB_GET_RECNO
+      *iv_return = DB_GET_RECNO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'H':
+    if (memEQ(name, "DB_HASHMAGIC", 12)) {
+    /*                  ^               */
+#ifdef DB_HASHMAGIC
+      *iv_return = DB_HASHMAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_INIT_LOCK", 12)) {
+    /*                  ^               */
+#ifdef DB_INIT_LOCK
+      *iv_return = DB_INIT_LOCK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'J':
+    if (memEQ(name, "DB_JOIN_ITEM", 12)) {
+    /*                  ^               */
+#ifdef DB_JOIN_ITEM
+      *iv_return = DB_JOIN_ITEM;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_LOCKMAGIC", 12)) {
+    /*                  ^               */
+#ifdef DB_LOCKMAGIC
+      *iv_return = DB_LOCKMAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_DUMP", 12)) {
+    /*                  ^               */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_LOCK_DUMP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_RW_N", 12)) {
+    /*                  ^               */
+#ifdef DB_LOCK_RW_N
+      *iv_return = DB_LOCK_RW_N;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOGOLDVER", 12)) {
+    /*                  ^               */
+#ifdef DB_LOGOLDVER
+      *iv_return = DB_LOGOLDVER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "DB_MAX_PAGES", 12)) {
+    /*                  ^               */
+#ifdef DB_MAX_PAGES
+      *iv_return = DB_MAX_PAGES;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_MPOOL_NEW", 12)) {
+    /*                  ^               */
+#ifdef DB_MPOOL_NEW
+      *iv_return = DB_MPOOL_NEW;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_NEEDSPLIT", 12)) {
+    /*                  ^               */
+#ifdef DB_NEEDSPLIT
+      *iv_return = DB_NEEDSPLIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_NODUPDATA", 12)) {
+    /*                  ^               */
+#ifdef DB_NODUPDATA
+      *iv_return = DB_NODUPDATA;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_NOLOCKING", 12)) {
+    /*                  ^               */
+#ifdef DB_NOLOCKING
+      *iv_return = DB_NOLOCKING;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_NORECURSE", 12)) {
+    /*                  ^               */
+#ifdef DB_NORECURSE
+      *iv_return = DB_NORECURSE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "DB_PAGEYIELD", 12)) {
+    /*                  ^               */
+#ifdef DB_PAGEYIELD
+      *iv_return = DB_PAGEYIELD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_PAGE_LOCK", 12)) {
+    /*                  ^               */
+#ifdef DB_PAGE_LOCK
+      *iv_return = DB_PAGE_LOCK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_POSITIONI", 12)) {
+    /*                  ^               */
+#ifdef DB_POSITIONI
+      *iv_return = DB_POSITIONI;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'Q':
+    if (memEQ(name, "DB_QAMOLDVER", 12)) {
+    /*                  ^               */
+#ifdef DB_QAMOLDVER
+      *iv_return = DB_QAMOLDVER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_SET_RANGE", 12)) {
+    /*                  ^               */
+#ifdef DB_SET_RANGE
+      *iv_return = DB_SET_RANGE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_SET_RECNO", 12)) {
+    /*                  ^               */
+#ifdef DB_SET_RECNO
+      *iv_return = DB_SET_RECNO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_SWAPBYTES", 12)) {
+    /*                  ^               */
+#ifdef DB_SWAPBYTES
+      *iv_return = DB_SWAPBYTES;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_TEMPORARY", 12)) {
+    /*                  ^               */
+#ifdef DB_TEMPORARY
+      *iv_return = DB_TEMPORARY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_ABORT", 12)) {
+    /*                  ^               */
+#if (DB_VERSION_MAJOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 1) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1 && \
+     DB_VERSION_PATCH >= 12)
+      *iv_return = DB_TXN_ABORT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_APPLY", 12)) {
+    /*                  ^               */
+#if (DB_VERSION_MAJOR > 4) || \
+    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 7)
+      *iv_return = DB_TXN_APPLY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'W':
+    if (memEQ(name, "DB_WRITELOCK", 12)) {
+    /*                  ^               */
+#ifdef DB_WRITELOCK
+      *iv_return = DB_WRITELOCK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'X':
+    if (memEQ(name, "DB_XA_CREATE", 12)) {
+    /*                  ^               */
+#ifdef DB_XA_CREATE
+      *iv_return = DB_XA_CREATE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_13 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_AGGRESSIVE DB_BTREEMAGIC DB_CHECKPOINT DB_DIRTY_READ DB_DONOTINDEX
+     DB_ENV_CREATE DB_ENV_NOMMAP DB_ENV_THREAD DB_HASHOLDVER DB_INCOMPLETE
+     DB_INIT_MPOOL DB_LOCK_NORUN DB_LOCK_RIW_N DB_LOGVERSION DB_LOG_LOCKED
+     DB_MPOOL_LAST DB_MUTEXDEBUG DB_MUTEXLOCKS DB_NEXT_NODUP DB_NOORDERCHK
+     DB_PREV_NODUP DB_PR_HEADERS DB_QAMVERSION DB_RDWRMASTER DB_REGISTERED
+     DB_REP_CLIENT DB_REP_MASTER DB_SEQUENTIAL DB_STAT_CLEAR DB_SYSTEM_MEM
+     DB_TXNVERSION DB_TXN_NOSYNC DB_TXN_NOWAIT DB_VERIFY_BAD */
+  /* Offset 5 gives the best switch position.  */
+  switch (name[5]) {
+  case 'A':
+    if (memEQ(name, "DB_STAT_CLEAR", 13)) {
+    /*                    ^              */
+#ifdef DB_STAT_CLEAR
+      *iv_return = DB_STAT_CLEAR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'C':
+    if (memEQ(name, "DB_INCOMPLETE", 13)) {
+    /*                    ^              */
+#ifdef DB_INCOMPLETE
+      *iv_return = DB_INCOMPLETE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_NORUN", 13)) {
+    /*                    ^              */
+#ifdef DB_LOCK_NORUN
+      *iv_return = DB_LOCK_NORUN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_RIW_N", 13)) {
+    /*                    ^              */
+#ifdef DB_LOCK_RIW_N
+      *iv_return = DB_LOCK_RIW_N;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_CHECKPOINT", 13)) {
+    /*                    ^              */
+#ifdef DB_CHECKPOINT
+      *iv_return = DB_CHECKPOINT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_PREV_NODUP", 13)) {
+    /*                    ^              */
+#ifdef DB_PREV_NODUP
+      *iv_return = DB_PREV_NODUP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_AGGRESSIVE", 13)) {
+    /*                    ^              */
+#ifdef DB_AGGRESSIVE
+      *iv_return = DB_AGGRESSIVE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOGVERSION", 13)) {
+    /*                    ^              */
+#ifdef DB_LOGVERSION
+      *iv_return = DB_LOGVERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOG_LOCKED", 13)) {
+    /*                    ^              */
+#ifdef DB_LOG_LOCKED
+      *iv_return = DB_LOG_LOCKED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REGISTERED", 13)) {
+    /*                    ^              */
+#ifdef DB_REGISTERED
+      *iv_return = DB_REGISTERED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_INIT_MPOOL", 13)) {
+    /*                    ^              */
+#ifdef DB_INIT_MPOOL
+      *iv_return = DB_INIT_MPOOL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "DB_QAMVERSION", 13)) {
+    /*                    ^              */
+#ifdef DB_QAMVERSION
+      *iv_return = DB_QAMVERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_DONOTINDEX", 13)) {
+    /*                    ^              */
+#ifdef DB_DONOTINDEX
+      *iv_return = DB_DONOTINDEX;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXNVERSION", 13)) {
+    /*                    ^              */
+#ifdef DB_TXNVERSION
+      *iv_return = DB_TXNVERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_NOSYNC", 13)) {
+    /*                    ^              */
+#ifdef DB_TXN_NOSYNC
+      *iv_return = DB_TXN_NOSYNC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_NOWAIT", 13)) {
+    /*                    ^              */
+#ifdef DB_TXN_NOWAIT
+      *iv_return = DB_TXN_NOWAIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_MPOOL_LAST", 13)) {
+    /*                    ^              */
+#ifdef DB_MPOOL_LAST
+      *iv_return = DB_MPOOL_LAST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_NOORDERCHK", 13)) {
+    /*                    ^              */
+#ifdef DB_NOORDERCHK
+      *iv_return = DB_NOORDERCHK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "DB_REP_CLIENT", 13)) {
+    /*                    ^              */
+#ifdef DB_REP_CLIENT
+      *iv_return = DB_REP_CLIENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REP_MASTER", 13)) {
+    /*                    ^              */
+#ifdef DB_REP_MASTER
+      *iv_return = DB_REP_MASTER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'Q':
+    if (memEQ(name, "DB_SEQUENTIAL", 13)) {
+    /*                    ^              */
+#ifdef DB_SEQUENTIAL
+      *iv_return = DB_SEQUENTIAL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "DB_BTREEMAGIC", 13)) {
+    /*                    ^              */
+#ifdef DB_BTREEMAGIC
+      *iv_return = DB_BTREEMAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_DIRTY_READ", 13)) {
+    /*                    ^              */
+#ifdef DB_DIRTY_READ
+      *iv_return = DB_DIRTY_READ;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_VERIFY_BAD", 13)) {
+    /*                    ^              */
+#ifdef DB_VERIFY_BAD
+      *iv_return = DB_VERIFY_BAD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_HASHOLDVER", 13)) {
+    /*                    ^              */
+#ifdef DB_HASHOLDVER
+      *iv_return = DB_HASHOLDVER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_SYSTEM_MEM", 13)) {
+    /*                    ^              */
+#ifdef DB_SYSTEM_MEM
+      *iv_return = DB_SYSTEM_MEM;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_MUTEXDEBUG", 13)) {
+    /*                    ^              */
+#ifdef DB_MUTEXDEBUG
+      *iv_return = DB_MUTEXDEBUG;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_MUTEXLOCKS", 13)) {
+    /*                    ^              */
+#ifdef DB_MUTEXLOCKS
+      *iv_return = DB_MUTEXLOCKS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'V':
+    if (memEQ(name, "DB_ENV_CREATE", 13)) {
+    /*                    ^              */
+#ifdef DB_ENV_CREATE
+      *iv_return = DB_ENV_CREATE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_ENV_NOMMAP", 13)) {
+    /*                    ^              */
+#ifdef DB_ENV_NOMMAP
+      *iv_return = DB_ENV_NOMMAP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_ENV_THREAD", 13)) {
+    /*                    ^              */
+#ifdef DB_ENV_THREAD
+      *iv_return = DB_ENV_THREAD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'W':
+    if (memEQ(name, "DB_RDWRMASTER", 13)) {
+    /*                    ^              */
+#ifdef DB_RDWRMASTER
+      *iv_return = DB_RDWRMASTER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'X':
+    if (memEQ(name, "DB_NEXT_NODUP", 13)) {
+    /*                    ^              */
+#ifdef DB_NEXT_NODUP
+      *iv_return = DB_NEXT_NODUP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case '_':
+    if (memEQ(name, "DB_PR_HEADERS", 13)) {
+    /*                    ^              */
+#ifdef DB_PR_HEADERS
+      *iv_return = DB_PR_HEADERS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_14 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_BTREEOLDVER DB_ENV_APPINIT DB_ENV_DBLOCAL DB_ENV_LOCKING DB_ENV_LOGGING
+     DB_ENV_NOPANIC DB_ENV_PRIVATE DB_FILE_ID_LEN DB_HASHVERSION DB_INVALID_EID
+     DB_JOIN_NOSORT DB_LOCKVERSION DB_LOCK_EXPIRE DB_LOCK_NOWAIT DB_LOCK_OLDEST
+     DB_LOCK_RANDOM DB_LOCK_RECORD DB_LOCK_SWITCH DB_MAX_RECORDS DB_MPOOL_CLEAN
+     DB_MPOOL_DIRTY DB_NOOVERWRITE DB_NOSERVER_ID DB_ODDFILESIZE DB_OLD_VERSION
+     DB_OPEN_CALLED DB_RECORDCOUNT DB_RECORD_LOCK DB_REGION_ANON DB_REGION_INIT
+     DB_REGION_NAME DB_REP_NEWSITE DB_REP_UNAVAIL DB_REVSPLITOFF DB_RUNRECOVERY
+     DB_SET_TXN_NOW DB_USE_ENVIRON DB_WRITECURSOR DB_XIDDATASIZE */
+  /* Offset 9 gives the best switch position.  */
+  switch (name[9]) {
+  case 'A':
+    if (memEQ(name, "DB_LOCK_RANDOM", 14)) {
+    /*                        ^           */
+#ifdef DB_LOCK_RANDOM
+      *iv_return = DB_LOCK_RANDOM;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_OPEN_CALLED", 14)) {
+    /*                        ^           */
+#ifdef DB_OPEN_CALLED
+      *iv_return = DB_OPEN_CALLED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REP_UNAVAIL", 14)) {
+    /*                        ^           */
+#ifdef DB_REP_UNAVAIL
+      *iv_return = DB_REP_UNAVAIL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_XIDDATASIZE", 14)) {
+    /*                        ^           */
+#ifdef DB_XIDDATASIZE
+      *iv_return = DB_XIDDATASIZE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'C':
+    if (memEQ(name, "DB_ENV_LOCKING", 14)) {
+    /*                        ^           */
+#ifdef DB_ENV_LOCKING
+      *iv_return = DB_ENV_LOCKING;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_MAX_RECORDS", 14)) {
+    /*                        ^           */
+#ifdef DB_MAX_RECORDS
+      *iv_return = DB_MAX_RECORDS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_MPOOL_CLEAN", 14)) {
+    /*                        ^           */
+#ifdef DB_MPOOL_CLEAN
+      *iv_return = DB_MPOOL_CLEAN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_RECORDCOUNT", 14)) {
+    /*                        ^           */
+#ifdef DB_RECORDCOUNT
+      *iv_return = DB_RECORDCOUNT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'D':
+    if (memEQ(name, "DB_FILE_ID_LEN", 14)) {
+    /*                        ^           */
+#ifdef DB_FILE_ID_LEN
+      *iv_return = DB_FILE_ID_LEN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_INVALID_EID", 14)) {
+    /*                        ^           */
+#ifdef DB_INVALID_EID
+      *iv_return = DB_INVALID_EID;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_MPOOL_DIRTY", 14)) {
+    /*                        ^           */
+#ifdef DB_MPOOL_DIRTY
+      *iv_return = DB_MPOOL_DIRTY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_LOCK_RECORD", 14)) {
+    /*                        ^           */
+#ifdef DB_LOCK_RECORD
+      *iv_return = DB_LOCK_RECORD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_NOSERVER_ID", 14)) {
+    /*                        ^           */
+#ifdef DB_NOSERVER_ID
+      *iv_return = DB_NOSERVER_ID;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_ODDFILESIZE", 14)) {
+    /*                        ^           */
+#ifdef DB_ODDFILESIZE
+      *iv_return = DB_ODDFILESIZE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_ENV_LOGGING", 14)) {
+    /*                        ^           */
+#ifdef DB_ENV_LOGGING
+      *iv_return = DB_ENV_LOGGING;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_ENV_PRIVATE", 14)) {
+    /*                        ^           */
+#ifdef DB_ENV_PRIVATE
+      *iv_return = DB_ENV_PRIVATE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REVSPLITOFF", 14)) {
+    /*                        ^           */
+#ifdef DB_REVSPLITOFF
+      *iv_return = DB_REVSPLITOFF;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_BTREEOLDVER", 14)) {
+    /*                        ^           */
+#ifdef DB_BTREEOLDVER
+      *iv_return = DB_BTREEOLDVER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_ENV_DBLOCAL", 14)) {
+    /*                        ^           */
+#ifdef DB_ENV_DBLOCAL
+      *iv_return = DB_ENV_DBLOCAL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_OLDEST", 14)) {
+    /*                        ^           */
+#ifdef DB_LOCK_OLDEST
+      *iv_return = DB_LOCK_OLDEST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_SET_TXN_NOW", 14)) {
+    /*                        ^           */
+#ifdef DB_SET_TXN_NOW
+      *iv_return = DB_SET_TXN_NOW;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_JOIN_NOSORT", 14)) {
+    /*                        ^           */
+#ifdef DB_JOIN_NOSORT
+      *iv_return = DB_JOIN_NOSORT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_NOWAIT", 14)) {
+    /*                        ^           */
+#ifdef DB_LOCK_NOWAIT
+      *iv_return = DB_LOCK_NOWAIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_RUNRECOVERY", 14)) {
+    /*                        ^           */
+#ifdef DB_RUNRECOVERY
+      *iv_return = DB_RUNRECOVERY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "DB_ENV_APPINIT", 14)) {
+    /*                        ^           */
+#ifdef DB_ENV_APPINIT
+      *iv_return = DB_ENV_APPINIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_ENV_NOPANIC", 14)) {
+    /*                        ^           */
+#ifdef DB_ENV_NOPANIC
+      *iv_return = DB_ENV_NOPANIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "DB_HASHVERSION", 14)) {
+    /*                        ^           */
+#ifdef DB_HASHVERSION
+      *iv_return = DB_HASHVERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCKVERSION", 14)) {
+    /*                        ^           */
+#ifdef DB_LOCKVERSION
+      *iv_return = DB_LOCKVERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_OLD_VERSION", 14)) {
+    /*                        ^           */
+#ifdef DB_OLD_VERSION
+      *iv_return = DB_OLD_VERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'U':
+    if (memEQ(name, "DB_WRITECURSOR", 14)) {
+    /*                        ^           */
+#ifdef DB_WRITECURSOR
+      *iv_return = DB_WRITECURSOR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'V':
+    if (memEQ(name, "DB_USE_ENVIRON", 14)) {
+    /*                        ^           */
+#ifdef DB_USE_ENVIRON
+      *iv_return = DB_USE_ENVIRON;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'W':
+    if (memEQ(name, "DB_LOCK_SWITCH", 14)) {
+    /*                        ^           */
+#ifdef DB_LOCK_SWITCH
+      *iv_return = DB_LOCK_SWITCH;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_NOOVERWRITE", 14)) {
+    /*                        ^           */
+#ifdef DB_NOOVERWRITE
+      *iv_return = DB_NOOVERWRITE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REP_NEWSITE", 14)) {
+    /*                        ^           */
+#ifdef DB_REP_NEWSITE
+      *iv_return = DB_REP_NEWSITE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'X':
+    if (memEQ(name, "DB_LOCK_EXPIRE", 14)) {
+    /*                        ^           */
+#ifdef DB_LOCK_EXPIRE
+      *iv_return = DB_LOCK_EXPIRE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case '_':
+    if (memEQ(name, "DB_RECORD_LOCK", 14)) {
+    /*                        ^           */
+#ifdef DB_RECORD_LOCK
+      *iv_return = DB_RECORD_LOCK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REGION_ANON", 14)) {
+    /*                        ^           */
+#ifdef DB_REGION_ANON
+      *iv_return = DB_REGION_ANON;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REGION_INIT", 14)) {
+    /*                        ^           */
+#ifdef DB_REGION_INIT
+      *iv_return = DB_REGION_INIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REGION_NAME", 14)) {
+    /*                        ^           */
+#ifdef DB_REGION_NAME
+      *iv_return = DB_REGION_NAME;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_15 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_APPLY_LOGREG DB_BTREEVERSION DB_CONSUME_WAIT DB_ENV_LOCKDOWN
+     DB_ENV_PANIC_OK DB_ENV_YIELDCPU DB_LOCK_DEFAULT DB_LOCK_INHERIT
+     DB_LOCK_NOTHELD DB_LOCK_PUT_ALL DB_LOCK_PUT_OBJ DB_LOCK_TIMEOUT
+     DB_LOCK_UPGRADE DB_MPOOL_CREATE DB_MPOOL_EXTENT DB_MULTIPLE_KEY
+     DB_OPFLAGS_MASK DB_ORDERCHKONLY DB_REGION_MAGIC DB_REP_LOGSONLY
+     DB_REP_OUTDATED DB_SURPRISE_KID DB_TEST_POSTLOG DB_TEST_PREOPEN
+     DB_TXN_LOCK_2PL DB_TXN_LOG_MASK DB_TXN_LOG_REDO DB_TXN_LOG_UNDO
+     DB_VERIFY_FATAL */
+  /* Offset 10 gives the best switch position.  */
+  switch (name[10]) {
+  case 'D':
+    if (memEQ(name, "DB_REP_OUTDATED", 15)) {
+    /*                         ^           */
+#ifdef DB_REP_OUTDATED
+      *iv_return = DB_REP_OUTDATED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_MULTIPLE_KEY", 15)) {
+    /*                         ^           */
+#ifdef DB_MULTIPLE_KEY
+      *iv_return = DB_MULTIPLE_KEY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_SURPRISE_KID", 15)) {
+    /*                         ^           */
+#ifdef DB_SURPRISE_KID
+      *iv_return = DB_SURPRISE_KID;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TEST_PREOPEN", 15)) {
+    /*                         ^           */
+#ifdef DB_TEST_PREOPEN
+      *iv_return = DB_TEST_PREOPEN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'F':
+    if (memEQ(name, "DB_LOCK_DEFAULT", 15)) {
+    /*                         ^           */
+#ifdef DB_LOCK_DEFAULT
+      *iv_return = DB_LOCK_DEFAULT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_VERIFY_FATAL", 15)) {
+    /*                         ^           */
+#ifdef DB_VERIFY_FATAL
+      *iv_return = DB_VERIFY_FATAL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_LOCK_UPGRADE", 15)) {
+    /*                         ^           */
+#ifdef DB_LOCK_UPGRADE
+      *iv_return = DB_LOCK_UPGRADE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'H':
+    if (memEQ(name, "DB_LOCK_INHERIT", 15)) {
+    /*                         ^           */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 7) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 7 && \
+     DB_VERSION_PATCH >= 1)
+      *iv_return = DB_LOCK_INHERIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_ENV_PANIC_OK", 15)) {
+    /*                         ^           */
+#ifdef DB_ENV_PANIC_OK
+      *iv_return = DB_ENV_PANIC_OK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'K':
+    if (memEQ(name, "DB_ENV_LOCKDOWN", 15)) {
+    /*                         ^           */
+#ifdef DB_ENV_LOCKDOWN
+      *iv_return = DB_ENV_LOCKDOWN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_ORDERCHKONLY", 15)) {
+    /*                         ^           */
+#ifdef DB_ORDERCHKONLY
+      *iv_return = DB_ORDERCHKONLY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_LOCK_2PL", 15)) {
+    /*                         ^           */
+#ifdef DB_TXN_LOCK_2PL
+      *iv_return = DB_TXN_LOCK_2PL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_ENV_YIELDCPU", 15)) {
+    /*                         ^           */
+#ifdef DB_ENV_YIELDCPU
+      *iv_return = DB_ENV_YIELDCPU;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "DB_LOCK_TIMEOUT", 15)) {
+    /*                         ^           */
+#if (DB_VERSION_MAJOR > 4) || \
+    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 7)
+      *iv_return = DB_LOCK_TIMEOUT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REGION_MAGIC", 15)) {
+    /*                         ^           */
+#ifdef DB_REGION_MAGIC
+      *iv_return = DB_REGION_MAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_APPLY_LOGREG", 15)) {
+    /*                         ^           */
+#ifdef DB_APPLY_LOGREG
+      *iv_return = DB_APPLY_LOGREG;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "DB_BTREEVERSION", 15)) {
+    /*                         ^           */
+#ifdef DB_BTREEVERSION
+      *iv_return = DB_BTREEVERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_MPOOL_CREATE", 15)) {
+    /*                         ^           */
+#ifdef DB_MPOOL_CREATE
+      *iv_return = DB_MPOOL_CREATE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_REP_LOGSONLY", 15)) {
+    /*                         ^           */
+#ifdef DB_REP_LOGSONLY
+      *iv_return = DB_REP_LOGSONLY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TEST_POSTLOG", 15)) {
+    /*                         ^           */
+#ifdef DB_TEST_POSTLOG
+      *iv_return = DB_TEST_POSTLOG;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_LOCK_NOTHELD", 15)) {
+    /*                         ^           */
+#ifdef DB_LOCK_NOTHELD
+      *iv_return = DB_LOCK_NOTHELD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_PUT_ALL", 15)) {
+    /*                         ^           */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_LOCK_PUT_ALL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_PUT_OBJ", 15)) {
+    /*                         ^           */
+#if (DB_VERSION_MAJOR > 2) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 0)
+      *iv_return = DB_LOCK_PUT_OBJ;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'X':
+    if (memEQ(name, "DB_MPOOL_EXTENT", 15)) {
+    /*                         ^           */
+#ifdef DB_MPOOL_EXTENT
+      *iv_return = DB_MPOOL_EXTENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case '_':
+    if (memEQ(name, "DB_CONSUME_WAIT", 15)) {
+    /*                         ^           */
+#ifdef DB_CONSUME_WAIT
+      *iv_return = DB_CONSUME_WAIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_OPFLAGS_MASK", 15)) {
+    /*                         ^           */
+#ifdef DB_OPFLAGS_MASK
+      *iv_return = DB_OPFLAGS_MASK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_LOG_MASK", 15)) {
+    /*                         ^           */
+#ifdef DB_TXN_LOG_MASK
+      *iv_return = DB_TXN_LOG_MASK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_LOG_REDO", 15)) {
+    /*                         ^           */
+#ifdef DB_TXN_LOG_REDO
+      *iv_return = DB_TXN_LOG_REDO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_LOG_UNDO", 15)) {
+    /*                         ^           */
+#ifdef DB_TXN_LOG_UNDO
+      *iv_return = DB_TXN_LOG_UNDO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_16 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_BROADCAST_EID DB_CACHED_COUNTS DB_ENV_CDB_ALLDB DB_ENV_NOLOCKING
+     DB_ENV_RPCCLIENT DB_FCNTL_LOCKING DB_JAVA_CALLBACK DB_LOCK_CONFLICT
+     DB_LOCK_DEADLOCK DB_LOCK_MAXLOCKS DB_LOCK_MINLOCKS DB_LOCK_MINWRITE
+     DB_LOCK_PUT_READ DB_LOCK_YOUNGEST DB_LOGC_BUF_SIZE DB_MPOOL_DISCARD
+     DB_MPOOL_PRIVATE DB_NOSERVER_HOME DB_PAGE_NOTFOUND DB_RECOVER_FATAL
+     DB_REP_DUPMASTER DB_REP_NEWMASTER DB_REP_PERMANENT DB_SECONDARY_BAD
+     DB_TEST_POSTOPEN DB_TEST_POSTSYNC DB_TXN_LOCK_MASK DB_TXN_OPENFILES
+     DB_VERB_CHKPOINT DB_VERB_DEADLOCK DB_VERB_RECOVERY DB_VERB_WAITSFOR
+     DB_VERSION_MAJOR DB_VERSION_MINOR DB_VERSION_PATCH DB_VRFY_FLAGMASK */
+  /* Offset 11 gives the best switch position.  */
+  switch (name[11]) {
+  case 'A':
+    if (memEQ(name, "DB_ENV_CDB_ALLDB", 16)) {
+    /*                          ^           */
+#ifdef DB_ENV_CDB_ALLDB
+      *iv_return = DB_ENV_CDB_ALLDB;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REP_DUPMASTER", 16)) {
+    /*                          ^           */
+#ifdef DB_REP_DUPMASTER
+      *iv_return = DB_REP_DUPMASTER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REP_NEWMASTER", 16)) {
+    /*                          ^           */
+#ifdef DB_REP_NEWMASTER
+      *iv_return = DB_REP_NEWMASTER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_REP_PERMANENT", 16)) {
+    /*                          ^           */
+#ifdef DB_REP_PERMANENT
+      *iv_return = DB_REP_PERMANENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'C':
+    if (memEQ(name, "DB_ENV_NOLOCKING", 16)) {
+    /*                          ^           */
+#ifdef DB_ENV_NOLOCKING
+      *iv_return = DB_ENV_NOLOCKING;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_FCNTL_LOCKING", 16)) {
+    /*                          ^           */
+#ifdef DB_FCNTL_LOCKING
+      *iv_return = DB_FCNTL_LOCKING;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'D':
+    if (memEQ(name, "DB_LOCK_DEADLOCK", 16)) {
+    /*                          ^           */
+#ifdef DB_LOCK_DEADLOCK
+      *iv_return = DB_LOCK_DEADLOCK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_VERB_DEADLOCK", 16)) {
+    /*                          ^           */
+#ifdef DB_VERB_DEADLOCK
+      *iv_return = DB_VERB_DEADLOCK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'F':
+    if (memEQ(name, "DB_LOCK_CONFLICT", 16)) {
+    /*                          ^           */
+#ifdef DB_LOCK_CONFLICT
+      *iv_return = DB_LOCK_CONFLICT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_PAGE_NOTFOUND", 16)) {
+    /*                          ^           */
+#ifdef DB_PAGE_NOTFOUND
+      *iv_return = DB_PAGE_NOTFOUND;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_RECOVER_FATAL", 16)) {
+    /*                          ^           */
+#ifdef DB_RECOVER_FATAL
+      *iv_return = DB_RECOVER_FATAL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_OPENFILES", 16)) {
+    /*                          ^           */
+#if (DB_VERSION_MAJOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 1) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1 && \
+     DB_VERSION_PATCH >= 12)
+      *iv_return = DB_TXN_OPENFILES;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_VRFY_FLAGMASK", 16)) {
+    /*                          ^           */
+#ifdef DB_VRFY_FLAGMASK
+      *iv_return = DB_VRFY_FLAGMASK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_MPOOL_PRIVATE", 16)) {
+    /*                          ^           */
+#ifdef DB_MPOOL_PRIVATE
+      *iv_return = DB_MPOOL_PRIVATE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_ENV_RPCCLIENT", 16)) {
+    /*                          ^           */
+#ifdef DB_ENV_RPCCLIENT
+      *iv_return = DB_ENV_RPCCLIENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_JAVA_CALLBACK", 16)) {
+    /*                          ^           */
+#ifdef DB_JAVA_CALLBACK
+      *iv_return = DB_JAVA_CALLBACK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_MAXLOCKS", 16)) {
+    /*                          ^           */
+#ifdef DB_LOCK_MAXLOCKS
+      *iv_return = DB_LOCK_MAXLOCKS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_MINLOCKS", 16)) {
+    /*                          ^           */
+#ifdef DB_LOCK_MINLOCKS
+      *iv_return = DB_LOCK_MINLOCKS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "DB_VERSION_MAJOR", 16)) {
+    /*                          ^           */
+#ifdef DB_VERSION_MAJOR
+      *iv_return = DB_VERSION_MAJOR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_VERSION_MINOR", 16)) {
+    /*                          ^           */
+#ifdef DB_VERSION_MINOR
+      *iv_return = DB_VERSION_MINOR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_LOCK_YOUNGEST", 16)) {
+    /*                          ^           */
+#ifdef DB_LOCK_YOUNGEST
+      *iv_return = DB_LOCK_YOUNGEST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_CACHED_COUNTS", 16)) {
+    /*                          ^           */
+#ifdef DB_CACHED_COUNTS
+      *iv_return = DB_CACHED_COUNTS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_VERB_RECOVERY", 16)) {
+    /*                          ^           */
+#ifdef DB_VERB_RECOVERY
+      *iv_return = DB_VERB_RECOVERY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "DB_VERB_CHKPOINT", 16)) {
+    /*                          ^           */
+#ifdef DB_VERB_CHKPOINT
+      *iv_return = DB_VERB_CHKPOINT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_VERSION_PATCH", 16)) {
+    /*                          ^           */
+#ifdef DB_VERSION_PATCH
+      *iv_return = DB_VERSION_PATCH;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_MPOOL_DISCARD", 16)) {
+    /*                          ^           */
+#ifdef DB_MPOOL_DISCARD
+      *iv_return = DB_MPOOL_DISCARD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_BROADCAST_EID", 16)) {
+    /*                          ^           */
+#ifdef DB_BROADCAST_EID
+      *iv_return = DB_BROADCAST_EID;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TEST_POSTOPEN", 16)) {
+    /*                          ^           */
+#ifdef DB_TEST_POSTOPEN
+      *iv_return = DB_TEST_POSTOPEN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TEST_POSTSYNC", 16)) {
+    /*                          ^           */
+#ifdef DB_TEST_POSTSYNC
+      *iv_return = DB_TEST_POSTSYNC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_VERB_WAITSFOR", 16)) {
+    /*                          ^           */
+#ifdef DB_VERB_WAITSFOR
+      *iv_return = DB_VERB_WAITSFOR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'W':
+    if (memEQ(name, "DB_LOCK_MINWRITE", 16)) {
+    /*                          ^           */
+#ifdef DB_LOCK_MINWRITE
+      *iv_return = DB_LOCK_MINWRITE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'Y':
+    if (memEQ(name, "DB_SECONDARY_BAD", 16)) {
+    /*                          ^           */
+#ifdef DB_SECONDARY_BAD
+      *iv_return = DB_SECONDARY_BAD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case '_':
+    if (memEQ(name, "DB_LOCK_PUT_READ", 16)) {
+    /*                          ^           */
+#if (DB_VERSION_MAJOR > 4) || \
+    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 7)
+      *iv_return = DB_LOCK_PUT_READ;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOGC_BUF_SIZE", 16)) {
+    /*                          ^           */
+#ifdef DB_LOGC_BUF_SIZE
+      *iv_return = DB_LOGC_BUF_SIZE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_NOSERVER_HOME", 16)) {
+    /*                          ^           */
+#ifdef DB_NOSERVER_HOME
+      *iv_return = DB_NOSERVER_HOME;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_LOCK_MASK", 16)) {
+    /*                          ^           */
+#ifdef DB_TXN_LOCK_MASK
+      *iv_return = DB_TXN_LOCK_MASK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_17 (pTHX_ const char *name, IV *iv_return, const char **pv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_ENV_REP_CLIENT DB_ENV_REP_MASTER DB_ENV_STANDALONE DB_ENV_SYSTEM_MEM
+     DB_ENV_TXN_NOSYNC DB_ENV_USER_ALLOC DB_GET_BOTH_RANGE DB_LOG_SILENT_ERR
+     DB_RPC_SERVERPROG DB_RPC_SERVERVERS DB_TEST_PRERENAME DB_TXN_POPENFILES
+     DB_VERSION_STRING */
+  /* Offset 14 gives the best switch position.  */
+  switch (name[14]) {
+  case 'A':
+    if (memEQ(name, "DB_TEST_PRERENAME", 17)) {
+    /*                             ^         */
+#ifdef DB_TEST_PRERENAME
+      *iv_return = DB_TEST_PRERENAME;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_ENV_REP_CLIENT", 17)) {
+    /*                             ^         */
+#ifdef DB_ENV_REP_CLIENT
+      *iv_return = DB_ENV_REP_CLIENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOG_SILENT_ERR", 17)) {
+    /*                             ^         */
+#ifdef DB_LOG_SILENT_ERR
+      *iv_return = DB_LOG_SILENT_ERR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_RPC_SERVERVERS", 17)) {
+    /*                             ^         */
+#ifdef DB_RPC_SERVERVERS
+      *iv_return = DB_RPC_SERVERVERS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_VERSION_STRING", 17)) {
+    /*                             ^         */
+#ifdef DB_VERSION_STRING
+      *pv_return = DB_VERSION_STRING;
+      return PERL_constant_ISPV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_ENV_USER_ALLOC", 17)) {
+    /*                             ^         */
+#ifdef DB_ENV_USER_ALLOC
+      *iv_return = DB_ENV_USER_ALLOC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_POPENFILES", 17)) {
+    /*                             ^         */
+#if (DB_VERSION_MAJOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 3 && \
+     DB_VERSION_PATCH >= 4)
+      *iv_return = DB_TXN_POPENFILES;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "DB_ENV_SYSTEM_MEM", 17)) {
+    /*                             ^         */
+#ifdef DB_ENV_SYSTEM_MEM
+      *iv_return = DB_ENV_SYSTEM_MEM;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_GET_BOTH_RANGE", 17)) {
+    /*                             ^         */
+#ifdef DB_GET_BOTH_RANGE
+      *iv_return = DB_GET_BOTH_RANGE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_ENV_STANDALONE", 17)) {
+    /*                             ^         */
+#ifdef DB_ENV_STANDALONE
+      *iv_return = DB_ENV_STANDALONE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "DB_RPC_SERVERPROG", 17)) {
+    /*                             ^         */
+#ifdef DB_RPC_SERVERPROG
+      *iv_return = DB_RPC_SERVERPROG;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_ENV_REP_MASTER", 17)) {
+    /*                             ^         */
+#ifdef DB_ENV_REP_MASTER
+      *iv_return = DB_ENV_REP_MASTER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'Y':
+    if (memEQ(name, "DB_ENV_TXN_NOSYNC", 17)) {
+    /*                             ^         */
+#ifdef DB_ENV_TXN_NOSYNC
+      *iv_return = DB_ENV_TXN_NOSYNC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_18 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_ALREADY_ABORTED DB_ENV_OPEN_CALLED DB_ENV_REGION_INIT
+     DB_LOCK_NOTGRANTED DB_MPOOL_NEW_GROUP DB_PR_RECOVERYTEST
+     DB_SET_TXN_TIMEOUT DB_TEST_POSTRENAME DB_TEST_PREDESTROY
+     DB_TEST_PREEXTOPEN */
+  /* Offset 13 gives the best switch position.  */
+  switch (name[13]) {
+  case 'A':
+    if (memEQ(name, "DB_ENV_OPEN_CALLED", 18)) {
+    /*                            ^           */
+#ifdef DB_ENV_OPEN_CALLED
+      *iv_return = DB_ENV_OPEN_CALLED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_NOTGRANTED", 18)) {
+    /*                            ^           */
+#ifdef DB_LOCK_NOTGRANTED
+      *iv_return = DB_LOCK_NOTGRANTED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_TEST_POSTRENAME", 18)) {
+    /*                            ^           */
+#ifdef DB_TEST_POSTRENAME
+      *iv_return = DB_TEST_POSTRENAME;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_MPOOL_NEW_GROUP", 18)) {
+    /*                            ^           */
+#ifdef DB_MPOOL_NEW_GROUP
+      *iv_return = DB_MPOOL_NEW_GROUP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "DB_SET_TXN_TIMEOUT", 18)) {
+    /*                            ^           */
+#ifdef DB_SET_TXN_TIMEOUT
+      *iv_return = DB_SET_TXN_TIMEOUT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_ALREADY_ABORTED", 18)) {
+    /*                            ^           */
+#ifdef DB_ALREADY_ABORTED
+      *iv_return = DB_ALREADY_ABORTED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_TEST_PREDESTROY", 18)) {
+    /*                            ^           */
+#ifdef DB_TEST_PREDESTROY
+      *iv_return = DB_TEST_PREDESTROY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_TEST_PREEXTOPEN", 18)) {
+    /*                            ^           */
+#ifdef DB_TEST_PREEXTOPEN
+      *iv_return = DB_TEST_PREEXTOPEN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'Y':
+    if (memEQ(name, "DB_PR_RECOVERYTEST", 18)) {
+    /*                            ^           */
+#ifdef DB_PR_RECOVERYTEST
+      *iv_return = DB_PR_RECOVERYTEST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case '_':
+    if (memEQ(name, "DB_ENV_REGION_INIT", 18)) {
+    /*                            ^           */
+#ifdef DB_ENV_REGION_INIT
+      *iv_return = DB_ENV_REGION_INIT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_19 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_ENV_REP_LOGSONLY DB_LOCK_FREE_LOCKER DB_LOCK_GET_TIMEOUT
+     DB_LOCK_SET_TIMEOUT DB_REP_HOLDELECTION DB_SET_LOCK_TIMEOUT
+     DB_TEST_POSTDESTROY DB_TEST_POSTEXTOPEN DB_TEST_POSTLOGMETA
+     DB_TXN_FORWARD_ROLL DB_TXN_LOG_UNDOREDO DB_UNRESOLVED_CHILD
+     DB_UPDATE_SECONDARY DB_USE_ENVIRON_ROOT */
+  /* Offset 13 gives the best switch position.  */
+  switch (name[13]) {
+  case 'D':
+    if (memEQ(name, "DB_TXN_FORWARD_ROLL", 19)) {
+    /*                            ^            */
+#if (DB_VERSION_MAJOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 1) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1 && \
+     DB_VERSION_PATCH >= 12)
+      *iv_return = DB_TXN_FORWARD_ROLL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_LOG_UNDOREDO", 19)) {
+    /*                            ^            */
+#ifdef DB_TXN_LOG_UNDOREDO
+      *iv_return = DB_TXN_LOG_UNDOREDO;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_REP_HOLDELECTION", 19)) {
+    /*                            ^            */
+#ifdef DB_REP_HOLDELECTION
+      *iv_return = DB_REP_HOLDELECTION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TEST_POSTDESTROY", 19)) {
+    /*                            ^            */
+#ifdef DB_TEST_POSTDESTROY
+      *iv_return = DB_TEST_POSTDESTROY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'G':
+    if (memEQ(name, "DB_ENV_REP_LOGSONLY", 19)) {
+    /*                            ^            */
+#ifdef DB_ENV_REP_LOGSONLY
+      *iv_return = DB_ENV_REP_LOGSONLY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'I':
+    if (memEQ(name, "DB_LOCK_GET_TIMEOUT", 19)) {
+    /*                            ^            */
+#if (DB_VERSION_MAJOR > 4) || \
+    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) || \
+    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0 && \
+     DB_VERSION_PATCH >= 7)
+      *iv_return = DB_LOCK_GET_TIMEOUT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_LOCK_SET_TIMEOUT", 19)) {
+    /*                            ^            */
+#ifdef DB_LOCK_SET_TIMEOUT
+      *iv_return = DB_LOCK_SET_TIMEOUT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_SET_LOCK_TIMEOUT", 19)) {
+    /*                            ^            */
+#ifdef DB_SET_LOCK_TIMEOUT
+      *iv_return = DB_SET_LOCK_TIMEOUT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_LOCK_FREE_LOCKER", 19)) {
+    /*                            ^            */
+#ifdef DB_LOCK_FREE_LOCKER
+      *iv_return = DB_LOCK_FREE_LOCKER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_USE_ENVIRON_ROOT", 19)) {
+    /*                            ^            */
+#ifdef DB_USE_ENVIRON_ROOT
+      *iv_return = DB_USE_ENVIRON_ROOT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "DB_TEST_POSTLOGMETA", 19)) {
+    /*                            ^            */
+#ifdef DB_TEST_POSTLOGMETA
+      *iv_return = DB_TEST_POSTLOGMETA;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_UPDATE_SECONDARY", 19)) {
+    /*                            ^            */
+#ifdef DB_UPDATE_SECONDARY
+      *iv_return = DB_UPDATE_SECONDARY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'X':
+    if (memEQ(name, "DB_TEST_POSTEXTOPEN", 19)) {
+    /*                            ^            */
+#ifdef DB_TEST_POSTEXTOPEN
+      *iv_return = DB_TEST_POSTEXTOPEN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case '_':
+    if (memEQ(name, "DB_UNRESOLVED_CHILD", 19)) {
+    /*                            ^            */
+#ifdef DB_UNRESOLVED_CHILD
+      *iv_return = DB_UNRESOLVED_CHILD;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_20 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_CXX_NO_EXCEPTIONS DB_LOGFILEID_INVALID DB_PANIC_ENVIRONMENT
+     DB_TEST_PREEXTDELETE DB_TEST_PREEXTUNLINK DB_TXN_BACKWARD_ROLL
+     DB_TXN_LOCK_OPTIMIST */
+  /* Offset 19 gives the best switch position.  */
+  switch (name[19]) {
+  case 'D':
+    if (memEQ(name, "DB_LOGFILEID_INVALID", 20)) {
+    /*                                  ^       */
+#ifdef DB_LOGFILEID_INVALID
+      *iv_return = DB_LOGFILEID_INVALID;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'E':
+    if (memEQ(name, "DB_TEST_PREEXTDELETE", 20)) {
+    /*                                  ^       */
+#ifdef DB_TEST_PREEXTDELETE
+      *iv_return = DB_TEST_PREEXTDELETE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'K':
+    if (memEQ(name, "DB_TEST_PREEXTUNLINK", 20)) {
+    /*                                  ^       */
+#ifdef DB_TEST_PREEXTUNLINK
+      *iv_return = DB_TEST_PREEXTUNLINK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_TXN_BACKWARD_ROLL", 20)) {
+    /*                                  ^       */
+#if (DB_VERSION_MAJOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 1) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1 && \
+     DB_VERSION_PATCH >= 12)
+      *iv_return = DB_TXN_BACKWARD_ROLL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "DB_CXX_NO_EXCEPTIONS", 20)) {
+    /*                                  ^       */
+#ifdef DB_CXX_NO_EXCEPTIONS
+      *iv_return = DB_CXX_NO_EXCEPTIONS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "DB_PANIC_ENVIRONMENT", 20)) {
+    /*                                  ^       */
+#ifdef DB_PANIC_ENVIRONMENT
+      *iv_return = DB_PANIC_ENVIRONMENT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    if (memEQ(name, "DB_TXN_LOCK_OPTIMIST", 20)) {
+    /*                                  ^       */
+#ifdef DB_TXN_LOCK_OPTIMIST
+      *iv_return = DB_TXN_LOCK_OPTIMIST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_21 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_LOCK_UPGRADE_WRITE DB_TEST_POSTEXTDELETE DB_TEST_POSTEXTUNLINK */
+  /* Offset 16 gives the best switch position.  */
+  switch (name[16]) {
+  case 'E':
+    if (memEQ(name, "DB_TEST_POSTEXTDELETE", 21)) {
+    /*                               ^           */
+#ifdef DB_TEST_POSTEXTDELETE
+      *iv_return = DB_TEST_POSTEXTDELETE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "DB_TEST_POSTEXTUNLINK", 21)) {
+    /*                               ^           */
+#ifdef DB_TEST_POSTEXTUNLINK
+      *iv_return = DB_TEST_POSTEXTUNLINK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'W':
+    if (memEQ(name, "DB_LOCK_UPGRADE_WRITE", 21)) {
+    /*                               ^           */
+#if (DB_VERSION_MAJOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 3) || \
+    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 3 && \
+     DB_VERSION_PATCH >= 4)
+      *iv_return = DB_LOCK_UPGRADE_WRITE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant (pTHX_ const char *name, STRLEN len, IV *iv_return, const char **pv_return) {
+  /* Initially switch on the length of the name.  */
+  /* When generated this function returned values for the list of names given
+     in this section of perl code.  Rather than manually editing these functions
+     to add or remove constants, which would result in this comment and section
+     of code becoming inaccurate, we recommend that you edit this section of
+     code, and use it to regenerate a new set of constant functions which you
+     then use to replace the originals.
+
+     Regenerate these constant functions by feeding this entire source file to
+     perl -x
+
+#!bleedperl -w
+use ExtUtils::Constant qw (constant_types C_constant XS_constant);
+
+my $types = {map {($_, 1)} qw(IV PV)};
+my @names = (qw(DB_AFTER DB_AGGRESSIVE DB_ALREADY_ABORTED DB_APPEND
+	       DB_APPLY_LOGREG DB_APP_INIT DB_ARCH_ABS DB_ARCH_DATA DB_ARCH_LOG
+	       DB_BEFORE DB_BROADCAST_EID DB_BTREEMAGIC DB_BTREEOLDVER
+	       DB_BTREEVERSION DB_CACHED_COUNTS DB_CDB_ALLDB DB_CHECKPOINT
+	       DB_CLIENT DB_CL_WRITER DB_COMMIT DB_CONSUME DB_CONSUME_WAIT
+	       DB_CREATE DB_CURLSN DB_CURRENT DB_CXX_NO_EXCEPTIONS DB_DELETED
+	       DB_DELIMITER DB_DIRTY_READ DB_DONOTINDEX DB_DUP DB_DUPCURSOR
+	       DB_DUPSORT DB_ENV_APPINIT DB_ENV_CDB DB_ENV_CDB_ALLDB
+	       DB_ENV_CREATE DB_ENV_DBLOCAL DB_ENV_LOCKDOWN DB_ENV_LOCKING
+	       DB_ENV_LOGGING DB_ENV_NOLOCKING DB_ENV_NOMMAP DB_ENV_NOPANIC
+	       DB_ENV_OPEN_CALLED DB_ENV_PANIC_OK DB_ENV_PRIVATE
+	       DB_ENV_REGION_INIT DB_ENV_REP_CLIENT DB_ENV_REP_LOGSONLY
+	       DB_ENV_REP_MASTER DB_ENV_RPCCLIENT DB_ENV_RPCCLIENT_GIVEN
+	       DB_ENV_STANDALONE DB_ENV_SYSTEM_MEM DB_ENV_THREAD DB_ENV_TXN
+	       DB_ENV_TXN_NOSYNC DB_ENV_USER_ALLOC DB_ENV_YIELDCPU DB_EXCL
+	       DB_EXTENT DB_FAST_STAT DB_FCNTL_LOCKING DB_FILE_ID_LEN DB_FIRST
+	       DB_FIXEDLEN DB_FLUSH DB_FORCE DB_GETREC DB_GET_BOTH DB_GET_BOTHC
+	       DB_GET_BOTH_RANGE DB_GET_RECNO DB_HASHMAGIC DB_HASHOLDVER
+	       DB_HASHVERSION DB_INCOMPLETE DB_INIT_CDB DB_INIT_LOCK
+	       DB_INIT_LOG DB_INIT_MPOOL DB_INIT_TXN DB_INVALID_EID
+	       DB_JAVA_CALLBACK DB_JOINENV DB_JOIN_ITEM DB_JOIN_NOSORT
+	       DB_KEYEMPTY DB_KEYEXIST DB_KEYFIRST DB_KEYLAST DB_LAST
+	       DB_LOCKDOWN DB_LOCKMAGIC DB_LOCKVERSION DB_LOCK_CONFLICT
+	       DB_LOCK_DEADLOCK DB_LOCK_DEFAULT DB_LOCK_EXPIRE
+	       DB_LOCK_FREE_LOCKER DB_LOCK_MAXLOCKS DB_LOCK_MINLOCKS
+	       DB_LOCK_MINWRITE DB_LOCK_NORUN DB_LOCK_NOTGRANTED
+	       DB_LOCK_NOTHELD DB_LOCK_NOWAIT DB_LOCK_OLDEST DB_LOCK_RANDOM
+	       DB_LOCK_RECORD DB_LOCK_RIW_N DB_LOCK_RW_N DB_LOCK_SET_TIMEOUT
+	       DB_LOCK_SWITCH DB_LOCK_UPGRADE DB_LOCK_YOUNGEST DB_LOGC_BUF_SIZE
+	       DB_LOGFILEID_INVALID DB_LOGMAGIC DB_LOGOLDVER DB_LOGVERSION
+	       DB_LOG_DISK DB_LOG_LOCKED DB_LOG_SILENT_ERR DB_MAX_PAGES
+	       DB_MAX_RECORDS DB_MPOOL_CLEAN DB_MPOOL_CREATE DB_MPOOL_DIRTY
+	       DB_MPOOL_DISCARD DB_MPOOL_EXTENT DB_MPOOL_LAST DB_MPOOL_NEW
+	       DB_MPOOL_NEW_GROUP DB_MPOOL_PRIVATE DB_MULTIPLE DB_MULTIPLE_KEY
+	       DB_MUTEXDEBUG DB_MUTEXLOCKS DB_NEEDSPLIT DB_NEXT DB_NEXT_DUP
+	       DB_NEXT_NODUP DB_NODUPDATA DB_NOLOCKING DB_NOMMAP DB_NOORDERCHK
+	       DB_NOOVERWRITE DB_NOPANIC DB_NORECURSE DB_NOSERVER
+	       DB_NOSERVER_HOME DB_NOSERVER_ID DB_NOSYNC DB_NOTFOUND
+	       DB_ODDFILESIZE DB_OK_BTREE DB_OK_HASH DB_OK_QUEUE DB_OK_RECNO
+	       DB_OLD_VERSION DB_OPEN_CALLED DB_OPFLAGS_MASK DB_ORDERCHKONLY
+	       DB_PAD DB_PAGEYIELD DB_PAGE_LOCK DB_PAGE_NOTFOUND
+	       DB_PANIC_ENVIRONMENT DB_POSITION DB_POSITIONI DB_PREV
+	       DB_PREV_NODUP DB_PRIVATE DB_PR_HEADERS DB_PR_PAGE
+	       DB_PR_RECOVERYTEST DB_QAMMAGIC DB_QAMOLDVER DB_QAMVERSION
+	       DB_RDONLY DB_RDWRMASTER DB_RECNUM DB_RECORDCOUNT DB_RECORD_LOCK
+	       DB_RECOVER DB_RECOVER_FATAL DB_REGION_ANON DB_REGION_INIT
+	       DB_REGION_MAGIC DB_REGION_NAME DB_REGISTERED DB_RENUMBER
+	       DB_REP_CLIENT DB_REP_DUPMASTER DB_REP_HOLDELECTION
+	       DB_REP_LOGSONLY DB_REP_MASTER DB_REP_NEWMASTER DB_REP_NEWSITE
+	       DB_REP_OUTDATED DB_REP_PERMANENT DB_REP_UNAVAIL DB_REVSPLITOFF
+	       DB_RMW DB_RPC_SERVERPROG DB_RPC_SERVERVERS DB_RUNRECOVERY
+	       DB_SALVAGE DB_SECONDARY_BAD DB_SEQUENTIAL DB_SET
+	       DB_SET_LOCK_TIMEOUT DB_SET_RANGE DB_SET_RECNO DB_SET_TXN_NOW
+	       DB_SET_TXN_TIMEOUT DB_SNAPSHOT DB_STAT_CLEAR DB_SURPRISE_KID
+	       DB_SWAPBYTES DB_SYSTEM_MEM DB_TEMPORARY DB_TEST_POSTDESTROY
+	       DB_TEST_POSTEXTDELETE DB_TEST_POSTEXTOPEN DB_TEST_POSTEXTUNLINK
+	       DB_TEST_POSTLOG DB_TEST_POSTLOGMETA DB_TEST_POSTOPEN
+	       DB_TEST_POSTRENAME DB_TEST_POSTSYNC DB_TEST_PREDESTROY
+	       DB_TEST_PREEXTDELETE DB_TEST_PREEXTOPEN DB_TEST_PREEXTUNLINK
+	       DB_TEST_PREOPEN DB_TEST_PRERENAME DB_THREAD DB_TIMEOUT
+	       DB_TRUNCATE DB_TXNMAGIC DB_TXNVERSION DB_TXN_CKP DB_TXN_LOCK_2PL
+	       DB_TXN_LOCK_MASK DB_TXN_LOCK_OPTIMIST DB_TXN_LOCK_OPTIMISTIC
+	       DB_TXN_LOG_MASK DB_TXN_LOG_REDO DB_TXN_LOG_UNDO
+	       DB_TXN_LOG_UNDOREDO DB_TXN_NOSYNC DB_TXN_NOWAIT DB_TXN_REDO
+	       DB_TXN_SYNC DB_TXN_UNDO DB_UNRESOLVED_CHILD DB_UPDATE_SECONDARY
+	       DB_UPGRADE DB_USE_ENVIRON DB_USE_ENVIRON_ROOT DB_VERB_CHKPOINT
+	       DB_VERB_DEADLOCK DB_VERB_RECOVERY DB_VERB_WAITSFOR DB_VERIFY
+	       DB_VERIFY_BAD DB_VERIFY_FATAL DB_VERSION_MAJOR DB_VERSION_MINOR
+	       DB_VERSION_PATCH DB_VRFY_FLAGMASK DB_WRITECURSOR DB_WRITELOCK
+	       DB_XA_CREATE DB_XIDDATASIZE DB_YIELDCPU),
+            {name=>"DB_BTREE", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_HASH", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_LOCK_DUMP", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_LOCK_GET", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_LOCK_GET_TIMEOUT", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 4) || \\\n    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 7)\n", "#endif\n"]},
+            {name=>"DB_LOCK_INHERIT", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 7) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 7 && \\\n     DB_VERSION_PATCH >= 1)\n", "#endif\n"]},
+            {name=>"DB_LOCK_PUT", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_LOCK_PUT_ALL", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_LOCK_PUT_OBJ", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_LOCK_PUT_READ", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 4) || \\\n    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 7)\n", "#endif\n"]},
+            {name=>"DB_LOCK_TIMEOUT", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 4) || \\\n    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 7)\n", "#endif\n"]},
+            {name=>"DB_LOCK_UPGRADE_WRITE", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 3 && \\\n     DB_VERSION_PATCH >= 4)\n", "#endif\n"]},
+            {name=>"DB_QUEUE", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 55)\n", "#endif\n"]},
+            {name=>"DB_RECNO", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_TXN_ABORT", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 1) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1 && \\\n     DB_VERSION_PATCH >= 12)\n", "#endif\n"]},
+            {name=>"DB_TXN_APPLY", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 4) || \\\n    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 7)\n", "#endif\n"]},
+            {name=>"DB_TXN_BACKWARD_ROLL", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 1) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1 && \\\n     DB_VERSION_PATCH >= 12)\n", "#endif\n"]},
+            {name=>"DB_TXN_FORWARD_ROLL", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 1) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1 && \\\n     DB_VERSION_PATCH >= 12)\n", "#endif\n"]},
+            {name=>"DB_TXN_OPENFILES", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 1) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1 && \\\n     DB_VERSION_PATCH >= 12)\n", "#endif\n"]},
+            {name=>"DB_TXN_POPENFILES", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR > 3) || \\\n    (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 3 && \\\n     DB_VERSION_PATCH >= 4)\n", "#endif\n"]},
+            {name=>"DB_UNKNOWN", type=>"IV", macro=>["#if (DB_VERSION_MAJOR > 2) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 0) || \\\n    (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && \\\n     DB_VERSION_PATCH >= 0)\n", "#endif\n"]},
+            {name=>"DB_VERSION_STRING", type=>"PV"});
+
+print constant_types(); # macro defs
+foreach (C_constant ("BerkeleyDB", 'constant', 'IV', $types, undef, 3, @names) ) {
+    print $_, "\n"; # C constant subs
+}
+print "#### XS Section:\n";
+print XS_constant ("BerkeleyDB", $types);
+__END__
+   */
+
+  switch (len) {
+  case 6:
+    return constant_6 (aTHX_ name, iv_return);
+    break;
+  case 7:
+    return constant_7 (aTHX_ name, iv_return);
+    break;
+  case 8:
+    return constant_8 (aTHX_ name, iv_return);
+    break;
+  case 9:
+    return constant_9 (aTHX_ name, iv_return);
+    break;
+  case 10:
+    return constant_10 (aTHX_ name, iv_return);
+    break;
+  case 11:
+    return constant_11 (aTHX_ name, iv_return);
+    break;
+  case 12:
+    return constant_12 (aTHX_ name, iv_return);
+    break;
+  case 13:
+    return constant_13 (aTHX_ name, iv_return);
+    break;
+  case 14:
+    return constant_14 (aTHX_ name, iv_return);
+    break;
+  case 15:
+    return constant_15 (aTHX_ name, iv_return);
+    break;
+  case 16:
+    return constant_16 (aTHX_ name, iv_return);
+    break;
+  case 17:
+    return constant_17 (aTHX_ name, iv_return, pv_return);
+    break;
+  case 18:
+    return constant_18 (aTHX_ name, iv_return);
+    break;
+  case 19:
+    return constant_19 (aTHX_ name, iv_return);
+    break;
+  case 20:
+    return constant_20 (aTHX_ name, iv_return);
+    break;
+  case 21:
+    return constant_21 (aTHX_ name, iv_return);
+    break;
+  case 22:
+    /* Names all of length 22.  */
+    /* DB_ENV_RPCCLIENT_GIVEN DB_TXN_LOCK_OPTIMISTIC */
+    /* Offset 8 gives the best switch position.  */
+    switch (name[8]) {
+    case 'O':
+      if (memEQ(name, "DB_TXN_LOCK_OPTIMISTIC", 22)) {
+      /*                       ^                    */
+#ifdef DB_TXN_LOCK_OPTIMISTIC
+        *iv_return = DB_TXN_LOCK_OPTIMISTIC;
+        return PERL_constant_ISIV;
+#else
+        return PERL_constant_NOTDEF;
+#endif
+      }
+      break;
+    case 'P':
+      if (memEQ(name, "DB_ENV_RPCCLIENT_GIVEN", 22)) {
+      /*                       ^                    */
+#ifdef DB_ENV_RPCCLIENT_GIVEN
+        *iv_return = DB_ENV_RPCCLIENT_GIVEN;
+        return PERL_constant_ISIV;
+#else
+        return PERL_constant_NOTDEF;
+#endif
+      }
+      break;
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
diff --git a/db/perl/BerkeleyDB/constants.xs b/db/perl/BerkeleyDB/constants.xs
new file mode 100644
index 000000000..1b2c8b2c3
--- /dev/null
+++ b/db/perl/BerkeleyDB/constants.xs
@@ -0,0 +1,87 @@
+void
+constant(sv)
+    PREINIT:
+#ifdef dXSTARG
+	dXSTARG; /* Faster if we have it.  */
+#else
+	dTARGET;
+#endif
+	STRLEN		len;
+        int		type;
+	IV		iv;
+	/* NV		nv;	Uncomment this if you need to return NVs */
+	const char	*pv;
+    INPUT:
+	SV *		sv;
+        const char *	s = SvPV(sv, len);
+    PPCODE:
+        /* Change this to constant(aTHX_ s, len, &iv, &nv);
+           if you need to return both NVs and IVs */
+	type = constant(aTHX_ s, len, &iv, &pv);
+      /* Return 1 or 2 items. First is error message, or undef if no error.
+           Second, if present, is found value */
+        switch (type) {
+        case PERL_constant_NOTFOUND:
+          sv = sv_2mortal(newSVpvf("%s is not a valid BerkeleyDB macro", s));
+          PUSHs(sv);
+          break;
+        case PERL_constant_NOTDEF:
+          sv = sv_2mortal(newSVpvf(
+	    "Your vendor has not defined BerkeleyDB macro %s, used", s));
+          PUSHs(sv);
+          break;
+        case PERL_constant_ISIV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHi(iv);
+          break;
+	/* Uncomment this if you need to return NOs
+        case PERL_constant_ISNO:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHs(&PL_sv_no);
+          break; */
+	/* Uncomment this if you need to return NVs
+        case PERL_constant_ISNV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHn(nv);
+          break; */
+        case PERL_constant_ISPV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHp(pv, strlen(pv));
+          break;
+	/* Uncomment this if you need to return PVNs
+        case PERL_constant_ISPVN:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHp(pv, iv);
+          break; */
+	/* Uncomment this if you need to return SVs
+        case PERL_constant_ISSV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHs(sv);
+          break; */
+	/* Uncomment this if you need to return UNDEFs
+        case PERL_constant_ISUNDEF:
+          break; */
+	/* Uncomment this if you need to return UVs
+        case PERL_constant_ISUV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHu((UV)iv);
+          break; */
+	/* Uncomment this if you need to return YESs
+        case PERL_constant_ISYES:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHs(&PL_sv_yes);
+          break; */
+        default:
+          sv = sv_2mortal(newSVpvf(
+	    "Unexpected return type %d while processing BerkeleyDB macro %s, used",
+               type, s));
+          PUSHs(sv);
+        }
diff --git a/db/perl/DB_File/fallback.h b/db/perl/DB_File/fallback.h
new file mode 100644
index 000000000..0213308a0
--- /dev/null
+++ b/db/perl/DB_File/fallback.h
@@ -0,0 +1,455 @@
+#define PERL_constant_NOTFOUND	1
+#define PERL_constant_NOTDEF	2
+#define PERL_constant_ISIV	3
+#define PERL_constant_ISNO	4
+#define PERL_constant_ISNV	5
+#define PERL_constant_ISPV	6
+#define PERL_constant_ISPVN	7
+#define PERL_constant_ISSV	8
+#define PERL_constant_ISUNDEF	9
+#define PERL_constant_ISUV	10
+#define PERL_constant_ISYES	11
+
+#ifndef NVTYPE
+typedef double NV; /* 5.6 and later define NVTYPE, and typedef NV to it.  */
+#endif
+#ifndef aTHX_
+#define aTHX_ /* 5.6 or later define this for threading support.  */
+#endif
+#ifndef pTHX_
+#define pTHX_ /* 5.6 or later define this for threading support.  */
+#endif
+
+static int
+constant_6 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_TXN R_LAST R_NEXT R_PREV */
+  /* Offset 2 gives the best switch position.  */
+  switch (name[2]) {
+  case 'L':
+    if (memEQ(name, "R_LAST", 6)) {
+    /*                 ^         */
+#ifdef R_LAST
+      *iv_return = R_LAST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "R_NEXT", 6)) {
+    /*                 ^         */
+#ifdef R_NEXT
+      *iv_return = R_NEXT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "R_PREV", 6)) {
+    /*                 ^         */
+#ifdef R_PREV
+      *iv_return = R_PREV;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case '_':
+    if (memEQ(name, "DB_TXN", 6)) {
+    /*                 ^         */
+#ifdef DB_TXN
+      *iv_return = DB_TXN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_7 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_LOCK R_FIRST R_NOKEY */
+  /* Offset 3 gives the best switch position.  */
+  switch (name[3]) {
+  case 'I':
+    if (memEQ(name, "R_FIRST", 7)) {
+    /*                  ^         */
+#ifdef R_FIRST
+      *iv_return = R_FIRST;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "DB_LOCK", 7)) {
+    /*                  ^         */
+#ifdef DB_LOCK
+      *iv_return = DB_LOCK;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "R_NOKEY", 7)) {
+    /*                  ^         */
+#ifdef R_NOKEY
+      *iv_return = R_NOKEY;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_8 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     DB_SHMEM R_CURSOR R_IAFTER */
+  /* Offset 5 gives the best switch position.  */
+  switch (name[5]) {
+  case 'M':
+    if (memEQ(name, "DB_SHMEM", 8)) {
+    /*                    ^        */
+#ifdef DB_SHMEM
+      *iv_return = DB_SHMEM;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "R_CURSOR", 8)) {
+    /*                    ^        */
+#ifdef R_CURSOR
+      *iv_return = R_CURSOR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'T':
+    if (memEQ(name, "R_IAFTER", 8)) {
+    /*                    ^        */
+#ifdef R_IAFTER
+      *iv_return = R_IAFTER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_9 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     HASHMAGIC RET_ERROR R_IBEFORE */
+  /* Offset 7 gives the best switch position.  */
+  switch (name[7]) {
+  case 'I':
+    if (memEQ(name, "HASHMAGIC", 9)) {
+    /*                      ^       */
+#ifdef HASHMAGIC
+      *iv_return = HASHMAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'O':
+    if (memEQ(name, "RET_ERROR", 9)) {
+    /*                      ^       */
+#ifdef RET_ERROR
+      *iv_return = RET_ERROR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "R_IBEFORE", 9)) {
+    /*                      ^       */
+#ifdef R_IBEFORE
+      *iv_return = R_IBEFORE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_10 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     BTREEMAGIC R_FIXEDLEN R_SNAPSHOT __R_UNUSED */
+  /* Offset 5 gives the best switch position.  */
+  switch (name[5]) {
+  case 'E':
+    if (memEQ(name, "R_FIXEDLEN", 10)) {
+    /*                    ^           */
+#ifdef R_FIXEDLEN
+      *iv_return = R_FIXEDLEN;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'M':
+    if (memEQ(name, "BTREEMAGIC", 10)) {
+    /*                    ^           */
+#ifdef BTREEMAGIC
+      *iv_return = BTREEMAGIC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "__R_UNUSED", 10)) {
+    /*                    ^           */
+#ifdef __R_UNUSED
+      *iv_return = __R_UNUSED;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'P':
+    if (memEQ(name, "R_SNAPSHOT", 10)) {
+    /*                    ^           */
+#ifdef R_SNAPSHOT
+      *iv_return = R_SNAPSHOT;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant_11 (pTHX_ const char *name, IV *iv_return) {
+  /* When generated this function returned values for the list of names given
+     here.  However, subsequent manual editing may have added or removed some.
+     HASHVERSION RET_SPECIAL RET_SUCCESS R_RECNOSYNC R_SETCURSOR */
+  /* Offset 10 gives the best switch position.  */
+  switch (name[10]) {
+  case 'C':
+    if (memEQ(name, "R_RECNOSYNC", 11)) {
+    /*                         ^       */
+#ifdef R_RECNOSYNC
+      *iv_return = R_RECNOSYNC;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'L':
+    if (memEQ(name, "RET_SPECIAL", 11)) {
+    /*                         ^       */
+#ifdef RET_SPECIAL
+      *iv_return = RET_SPECIAL;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'N':
+    if (memEQ(name, "HASHVERSION", 11)) {
+    /*                         ^       */
+#ifdef HASHVERSION
+      *iv_return = HASHVERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'R':
+    if (memEQ(name, "R_SETCURSOR", 11)) {
+    /*                         ^       */
+#ifdef R_SETCURSOR
+      *iv_return = R_SETCURSOR;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 'S':
+    if (memEQ(name, "RET_SUCCESS", 11)) {
+    /*                         ^       */
+#ifdef RET_SUCCESS
+      *iv_return = RET_SUCCESS;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
+static int
+constant (pTHX_ const char *name, STRLEN len, IV *iv_return) {
+  /* Initially switch on the length of the name.  */
+  /* When generated this function returned values for the list of names given
+     in this section of perl code.  Rather than manually editing these functions
+     to add or remove constants, which would result in this comment and section
+     of code becoming inaccurate, we recommend that you edit this section of
+     code, and use it to regenerate a new set of constant functions which you
+     then use to replace the originals.
+
+     Regenerate these constant functions by feeding this entire source file to
+     perl -x
+
+#!bleedperl -w
+use ExtUtils::Constant qw (constant_types C_constant XS_constant);
+
+my $types = {map {($_, 1)} qw(IV)};
+my @names = (qw(BTREEMAGIC BTREEVERSION DB_LOCK DB_SHMEM DB_TXN HASHMAGIC
+	       HASHVERSION MAX_PAGE_NUMBER MAX_PAGE_OFFSET MAX_REC_NUMBER
+	       RET_ERROR RET_SPECIAL RET_SUCCESS R_CURSOR R_DUP R_FIRST
+	       R_FIXEDLEN R_IAFTER R_IBEFORE R_LAST R_NEXT R_NOKEY
+	       R_NOOVERWRITE R_PREV R_RECNOSYNC R_SETCURSOR R_SNAPSHOT
+	       __R_UNUSED));
+
+print constant_types(); # macro defs
+foreach (C_constant ("DB_File", 'constant', 'IV', $types, undef, 3, @names) ) {
+    print $_, "\n"; # C constant subs
+}
+print "#### XS Section:\n";
+print XS_constant ("DB_File", $types);
+__END__
+   */
+
+  switch (len) {
+  case 5:
+    if (memEQ(name, "R_DUP", 5)) {
+#ifdef R_DUP
+      *iv_return = R_DUP;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 6:
+    return constant_6 (aTHX_ name, iv_return);
+    break;
+  case 7:
+    return constant_7 (aTHX_ name, iv_return);
+    break;
+  case 8:
+    return constant_8 (aTHX_ name, iv_return);
+    break;
+  case 9:
+    return constant_9 (aTHX_ name, iv_return);
+    break;
+  case 10:
+    return constant_10 (aTHX_ name, iv_return);
+    break;
+  case 11:
+    return constant_11 (aTHX_ name, iv_return);
+    break;
+  case 12:
+    if (memEQ(name, "BTREEVERSION", 12)) {
+#ifdef BTREEVERSION
+      *iv_return = BTREEVERSION;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 13:
+    if (memEQ(name, "R_NOOVERWRITE", 13)) {
+#ifdef R_NOOVERWRITE
+      *iv_return = R_NOOVERWRITE;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 14:
+    if (memEQ(name, "MAX_REC_NUMBER", 14)) {
+#ifdef MAX_REC_NUMBER
+      *iv_return = MAX_REC_NUMBER;
+      return PERL_constant_ISIV;
+#else
+      return PERL_constant_NOTDEF;
+#endif
+    }
+    break;
+  case 15:
+    /* Names all of length 15.  */
+    /* MAX_PAGE_NUMBER MAX_PAGE_OFFSET */
+    /* Offset 9 gives the best switch position.  */
+    switch (name[9]) {
+    case 'N':
+      if (memEQ(name, "MAX_PAGE_NUMBER", 15)) {
+      /*                        ^            */
+#ifdef MAX_PAGE_NUMBER
+        *iv_return = MAX_PAGE_NUMBER;
+        return PERL_constant_ISIV;
+#else
+        return PERL_constant_NOTDEF;
+#endif
+      }
+      break;
+    case 'O':
+      if (memEQ(name, "MAX_PAGE_OFFSET", 15)) {
+      /*                        ^            */
+#ifdef MAX_PAGE_OFFSET
+        *iv_return = MAX_PAGE_OFFSET;
+        return PERL_constant_ISIV;
+#else
+        return PERL_constant_NOTDEF;
+#endif
+      }
+      break;
+    }
+    break;
+  }
+  return PERL_constant_NOTFOUND;
+}
+
diff --git a/db/perl/DB_File/fallback.xs b/db/perl/DB_File/fallback.xs
new file mode 100644
index 000000000..8650cdf76
--- /dev/null
+++ b/db/perl/DB_File/fallback.xs
@@ -0,0 +1,88 @@
+void
+constant(sv)
+    PREINIT:
+#ifdef dXSTARG
+	dXSTARG; /* Faster if we have it.  */
+#else
+	dTARGET;
+#endif
+	STRLEN		len;
+        int		type;
+	IV		iv;
+	/* NV		nv;	Uncomment this if you need to return NVs */
+	/* const char	*pv;	Uncomment this if you need to return PVs */
+    INPUT:
+	SV *		sv;
+        const char *	s = SvPV(sv, len);
+    PPCODE:
+        /* Change this to constant(aTHX_ s, len, &iv, &nv);
+           if you need to return both NVs and IVs */
+	type = constant(aTHX_ s, len, &iv);
+      /* Return 1 or 2 items. First is error message, or undef if no error.
+           Second, if present, is found value */
+        switch (type) {
+        case PERL_constant_NOTFOUND:
+          sv = sv_2mortal(newSVpvf("%s is not a valid DB_File macro", s));
+          PUSHs(sv);
+          break;
+        case PERL_constant_NOTDEF:
+          sv = sv_2mortal(newSVpvf(
+	    "Your vendor has not defined DB_File macro %s, used", s));
+          PUSHs(sv);
+          break;
+        case PERL_constant_ISIV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHi(iv);
+          break;
+	/* Uncomment this if you need to return NOs
+        case PERL_constant_ISNO:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHs(&PL_sv_no);
+          break; */
+	/* Uncomment this if you need to return NVs
+        case PERL_constant_ISNV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHn(nv);
+          break; */
+	/* Uncomment this if you need to return PVs
+        case PERL_constant_ISPV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHp(pv, strlen(pv));
+          break; */
+	/* Uncomment this if you need to return PVNs
+        case PERL_constant_ISPVN:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHp(pv, iv);
+          break; */
+	/* Uncomment this if you need to return SVs
+        case PERL_constant_ISSV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHs(sv);
+          break; */
+	/* Uncomment this if you need to return UNDEFs
+        case PERL_constant_ISUNDEF:
+          break; */
+	/* Uncomment this if you need to return UVs
+        case PERL_constant_ISUV:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHu((UV)iv);
+          break; */
+	/* Uncomment this if you need to return YESs
+        case PERL_constant_ISYES:
+          EXTEND(SP, 1);
+          PUSHs(&PL_sv_undef);
+          PUSHs(&PL_sv_yes);
+          break; */
+        default:
+          sv = sv_2mortal(newSVpvf(
+	    "Unexpected return type %d while processing DB_File macro %s, used",
+               type, s));
+          PUSHs(sv);
+        }
diff --git a/db/perl/DB_File/ppport.h b/db/perl/DB_File/ppport.h
new file mode 100644
index 000000000..b4fbc7bff
--- /dev/null
+++ b/db/perl/DB_File/ppport.h
@@ -0,0 +1,282 @@
+/* This file is Based on output from 
+ * Perl/Pollution/Portability Version 2.0000 */
+
+#ifndef _P_P_PORTABILITY_H_
+#define _P_P_PORTABILITY_H_
+
+#ifndef PERL_REVISION
+#   ifndef __PATCHLEVEL_H_INCLUDED__
+#       include "patchlevel.h"
+#   endif
+#   ifndef PERL_REVISION
+#	define PERL_REVISION	(5)
+        /* Replace: 1 */
+#       define PERL_VERSION	PATCHLEVEL
+#       define PERL_SUBVERSION	SUBVERSION
+        /* Replace PERL_PATCHLEVEL with PERL_VERSION */
+        /* Replace: 0 */
+#   endif
+#endif
+
+#define PERL_BCDVERSION ((PERL_REVISION * 0x1000000L) + (PERL_VERSION * 0x1000L) + PERL_SUBVERSION)
+
+#ifndef ERRSV
+#	define ERRSV perl_get_sv("@",FALSE)
+#endif
+
+#if (PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5))
+/* Replace: 1 */
+#	define PL_Sv		Sv
+#	define PL_compiling	compiling
+#	define PL_copline	copline
+#	define PL_curcop	curcop
+#	define PL_curstash	curstash
+#	define PL_defgv		defgv
+#	define PL_dirty		dirty
+#	define PL_hints		hints
+#	define PL_na		na
+#	define PL_perldb	perldb
+#	define PL_rsfp_filters	rsfp_filters
+#	define PL_rsfp		rsfp
+#	define PL_stdingv	stdingv
+#	define PL_sv_no		sv_no
+#	define PL_sv_undef	sv_undef
+#	define PL_sv_yes	sv_yes
+/* Replace: 0 */
+#endif
+
+#ifndef pTHX
+#    define pTHX
+#    define pTHX_
+#    define aTHX
+#    define aTHX_
+#endif         
+
+#ifndef PTR2IV
+#    define PTR2IV(d)   (IV)(d)
+#endif
+ 
+#ifndef INT2PTR
+#    define INT2PTR(any,d)      (any)(d)
+#endif
+
+#ifndef dTHR
+#  ifdef WIN32
+#	define dTHR extern int Perl___notused
+#  else
+#	define dTHR extern int errno
+#  endif
+#endif
+
+#ifndef boolSV
+#	define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
+#endif
+
+#ifndef gv_stashpvn
+#	define gv_stashpvn(str,len,flags) gv_stashpv(str,flags)
+#endif
+
+#ifndef newSVpvn
+#	define newSVpvn(data,len) ((len) ? newSVpv ((data), (len)) : newSVpv ("", 0))
+#endif
+
+#ifndef newRV_inc
+/* Replace: 1 */
+#	define newRV_inc(sv) newRV(sv)
+/* Replace: 0 */
+#endif
+
+/* DEFSV appears first in 5.004_56 */
+#ifndef DEFSV
+#  define DEFSV	GvSV(PL_defgv)
+#endif
+
+#ifndef SAVE_DEFSV
+#    define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv))
+#endif
+
+#ifndef newRV_noinc
+#  ifdef __GNUC__
+#    define newRV_noinc(sv)               \
+      ({                                  \
+          SV *nsv = (SV*)newRV(sv);       \
+          SvREFCNT_dec(sv);               \
+          nsv;                            \
+      })
+#  else
+#    if defined(CRIPPLED_CC) || defined(USE_THREADS)
+static SV * newRV_noinc (SV * sv)
+{
+          SV *nsv = (SV*)newRV(sv);       
+          SvREFCNT_dec(sv);               
+          return nsv;                     
+}
+#    else
+#      define newRV_noinc(sv)    \
+        ((PL_Sv=(SV*)newRV(sv), SvREFCNT_dec(sv), (SV*)PL_Sv)
+#    endif
+#  endif
+#endif
+
+/* Provide: newCONSTSUB */
+
+/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
+#if (PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION < 63))
+
+#if defined(NEED_newCONSTSUB)
+static
+#else
+extern void newCONSTSUB _((HV * stash, char * name, SV *sv));
+#endif
+
+#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
+void
+newCONSTSUB(stash,name,sv)
+HV *stash;
+char *name;
+SV *sv;
+{
+	U32 oldhints = PL_hints;
+	HV *old_cop_stash = PL_curcop->cop_stash;
+	HV *old_curstash = PL_curstash;
+	line_t oldline = PL_curcop->cop_line;
+	PL_curcop->cop_line = PL_copline;
+
+	PL_hints &= ~HINT_BLOCK_SCOPE;
+	if (stash)
+		PL_curstash = PL_curcop->cop_stash = stash;
+
+	newSUB(
+
+#if (PERL_VERSION < 3) || ((PERL_VERSION == 3) && (PERL_SUBVERSION < 22))
+     /* before 5.003_22 */
+		start_subparse(),
+#else
+#  if (PERL_VERSION == 3) && (PERL_SUBVERSION == 22)
+     /* 5.003_22 */
+     		start_subparse(0),
+#  else
+     /* 5.003_23  onwards */
+     		start_subparse(FALSE, 0),
+#  endif
+#endif
+
+		newSVOP(OP_CONST, 0, newSVpv(name,0)),
+		newSVOP(OP_CONST, 0, &PL_sv_no),   /* SvPV(&PL_sv_no) == "" -- GMB */
+		newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
+	);
+
+	PL_hints = oldhints;
+	PL_curcop->cop_stash = old_cop_stash;
+	PL_curstash = old_curstash;
+	PL_curcop->cop_line = oldline;
+}
+#endif
+
+#endif /* newCONSTSUB */
+
+
+#ifndef START_MY_CXT
+
+/*
+ * Boilerplate macros for initializing and accessing interpreter-local
+ * data from C.  All statics in extensions should be reworked to use
+ * this, if you want to make the extension thread-safe.  See ext/re/re.xs
+ * for an example of the use of these macros.
+ *
+ * Code that uses these macros is responsible for the following:
+ * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
+ * 2. Declare a typedef named my_cxt_t that is a structure that contains
+ *    all the data that needs to be interpreter-local.
+ * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
+ * 4. Use the MY_CXT_INIT macro such that it is called exactly once
+ *    (typically put in the BOOT: section).
+ * 5. Use the members of the my_cxt_t structure everywhere as
+ *    MY_CXT.member.
+ * 6. Use the dMY_CXT macro (a declaration) in all the functions that
+ *    access MY_CXT.
+ */
+
+#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
+    defined(PERL_CAPI)    || defined(PERL_IMPLICIT_CONTEXT)
+
+/* This must appear in all extensions that define a my_cxt_t structure,
+ * right after the definition (i.e. at file scope).  The non-threads
+ * case below uses it to declare the data as static. */
+#define START_MY_CXT
+
+#if PERL_REVISION == 5 && \
+    (PERL_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION < 68 ))
+/* Fetches the SV that keeps the per-interpreter data. */
+#define dMY_CXT_SV \
+	SV *my_cxt_sv = perl_get_sv(MY_CXT_KEY, FALSE)
+#else /* >= perl5.004_68 */
+#define dMY_CXT_SV \
+	SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY,		\
+				  sizeof(MY_CXT_KEY)-1, TRUE)
+#endif /* < perl5.004_68 */
+
+/* This declaration should be used within all functions that use the
+ * interpreter-local data. */
+#define dMY_CXT	\
+	dMY_CXT_SV;							\
+	my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
+
+/* Creates and zeroes the per-interpreter data.
+ * (We allocate my_cxtp in a Perl SV so that it will be released when
+ * the interpreter goes away.) */
+#define MY_CXT_INIT \
+	dMY_CXT_SV;							\
+	/* newSV() allocates one more than needed */			\
+	my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
+	Zero(my_cxtp, 1, my_cxt_t);					\
+	sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
+
+/* This macro must be used to access members of the my_cxt_t structure.
+ * e.g. MYCXT.some_data */
+#define MY_CXT		(*my_cxtp)
+
+/* Judicious use of these macros can reduce the number of times dMY_CXT
+ * is used.  Use is similar to pTHX, aTHX etc. */
+#define pMY_CXT		my_cxt_t *my_cxtp
+#define pMY_CXT_	pMY_CXT,
+#define _pMY_CXT	,pMY_CXT
+#define aMY_CXT		my_cxtp
+#define aMY_CXT_	aMY_CXT,
+#define _aMY_CXT	,aMY_CXT
+
+#else /* single interpreter */
+
+#ifndef NOOP
+#  define NOOP (void)0
+#endif
+
+#ifdef HASATTRIBUTE
+#  define PERL_UNUSED_DECL __attribute__((unused))
+#else
+#  define PERL_UNUSED_DECL
+#endif    
+
+#ifndef dNOOP
+#  define dNOOP extern int Perl___notused PERL_UNUSED_DECL
+#endif
+
+#define START_MY_CXT	static my_cxt_t my_cxt;
+#define dMY_CXT_SV	dNOOP
+#define dMY_CXT		dNOOP
+#define MY_CXT_INIT	NOOP
+#define MY_CXT		my_cxt
+
+#define pMY_CXT		void
+#define pMY_CXT_
+#define _pMY_CXT
+#define aMY_CXT
+#define aMY_CXT_
+#define _aMY_CXT
+
+#endif 
+
+#endif /* START_MY_CXT */
+
+
+#endif /* _P_P_PORTABILITY_H_ */
diff --git a/db/test/lock005.tcl b/db/test/lock005.tcl
new file mode 100644
index 000000000..3f54745d3
--- /dev/null
+++ b/db/test/lock005.tcl
@@ -0,0 +1,47 @@
+# See the file LICENSE for redistribution information.
+#
+# Copyright (c) 1996-2001
+#	Sleepycat Software.  All rights reserved.
+#
+# Id: lock005.tcl,v 1.1 2001/11/16 20:13:04 sandstro Exp 
+#
+# TEST	lock005
+# TEST	Check that page locks are being released properly.
+
+proc lock005 { } {
+	source ./include.tcl
+
+	puts "Lock005: Page lock release test"
+
+	# Clean up after previous runs
+	env_cleanup $testdir
+
+	# Open/create the lock region
+	set e [berkdb env -create -lock -home $testdir -txn -log]
+	error_check_good env_open [is_valid_env $e] TRUE
+
+	# Open/create the database
+	set db [berkdb open -create -env $e -len 10 -queue q.db]
+	error_check_good dbopen [is_valid_db $db] TRUE
+
+	# Start the first transaction
+	set txn1 [$e txn -nowait]
+	error_check_good txn_begin [is_valid_txn $txn1 $e] TRUE
+	set ret [$db put -txn $txn1 -append record1]
+	error_check_good dbput_txn1 $ret 1
+
+	# Start a second transaction while first is still running
+	set txn2 [$e txn -nowait]
+	error_check_good txn_begin [is_valid_txn $txn2 $e] TRUE	
+	set ret [catch {$db put -txn $txn2 -append record2} res] 
+	error_check_good dbput_txn2 $ret 0
+      error_check_good dbput_txn2recno $res 2	
+
+	# Clean up
+	error_check_good txn1commit [$txn1 commit] 0
+	error_check_good txn2commit [$txn2 commit] 0
+	error_check_good db_close [$db close] 0
+	error_check_good env_close [$e close] 0
+
+}
+
diff --git a/db/test/recd016.tcl b/db/test/recd016.tcl
new file mode 100644
index 000000000..0513d1d18
--- /dev/null
+++ b/db/test/recd016.tcl
@@ -0,0 +1,177 @@
+# See the file LICENSE for redistribution information.
+#
+# Copyright (c) 1999-2001
+#	Sleepycat Software.  All rights reserved.
+#
+# Id: recd016.tcl,v 11.1 2001/11/07 18:45:02 sue Exp 
+#
+# TEST	recd016
+# TEST	This is a recovery test for testing running recovery while
+# TEST	recovery is already running.  While bad things may or may not
+# TEST	happen, if recovery is then run properly, things should be correct.
+proc recd016 { method args } {
+	source ./include.tcl
+
+	set args [convert_args $method $args]
+	set omethod [convert_method $method]
+
+	puts "Recd016: $method ($args) simultaneous recovery test"
+
+	# Create the database and environment.
+	set testfile recd016.db
+
+	#
+	# For this test we create our database ahead of time so that we
+	# don't need to send methods and args to the script.
+	#
+	cleanup $testdir NULL
+
+	#
+	# Use a smaller log to make more files and slow down recovery.
+	#
+	set gflags ""
+	set pflags ""
+	set log_max [expr 256 * 1024]
+	set nentries 10000
+	set nrec 6
+	set t1 $testdir/t1
+	set t2 $testdir/t2
+	set t3 $testdir/t3
+	set t4 $testdir/t4
+	set t5 $testdir/t5
+
+	puts "\tRecd016.a: Create environment and database"
+	set env_cmd "berkdb env -create -log_max $log_max -txn -home $testdir"
+	set env [eval $env_cmd]
+	error_check_good dbenv [is_valid_env $env] TRUE
+	set db [eval {berkdb_open -create} $omethod -env $env $args $testfile]
+	error_check_good dbopen [is_valid_db $db] TRUE
+	set did [open $dict]
+	set abid [open $t4 w]
+
+	if { [is_record_based $method] == 1 } {
+		set checkfunc recd016_recno.check
+		append gflags " -recno"
+	} else {
+		set checkfunc recd016.check
+	}
+	puts "\tRecd016.b: put/get loop"
+	# Here is the loop where we put and get each key/data pair
+	set count 0
+	while { [gets $did str] != -1 && $count < $nentries } {
+		if { [is_record_based $method] == 1 } {
+			global kvals
+
+			set key [expr $count + 1]
+			if { 0xffffffff > 0 && $key > 0xffffffff } {
+				set key [expr $key - 0x100000000]
+			}
+			if { $key == 0 || $key - 0xffffffff == 1 } {
+				incr key
+				incr count
+			}
+			set kvals($key) [pad_data $method $str]
+		} else {
+			set key $str
+			set str [reverse $str]
+		}
+		#
+		# Start a transaction.  Alternately abort and commit them.
+		# This will create a bigger log for recovery to collide.
+		#
+		set txn [$env txn]
+		set ret [eval \
+		    {$db put} -txn $txn $pflags {$key [chop_data $method $str]}]
+		error_check_good put $ret 0
+
+		if {[expr $count % 2] == 0} {
+			set ret [$txn commit]
+			error_check_good txn_commit $ret 0
+			set ret [eval {$db get} $gflags {$key}]
+			error_check_good commit_get \
+			    $ret [list [list $key [pad_data $method $str]]]
+		} else {
+			set ret [$txn abort]
+			error_check_good txn_abort $ret 0
+			set ret [eval {$db get} $gflags {$key}]
+			error_check_good abort_get [llength $ret] 0
+			puts $abid $key
+		}
+		incr count
+	}
+	close $did
+	close $abid
+	error_check_good dbclose [$db close] 0
+	error_check_good envclose [$env close] 0
+
+	set pidlist {}
+	puts "\tRecd016.c: Start up $nrec recovery processes at once"
+	for {set i 0} {$i < $nrec} {incr i} {
+		set p [exec $util_path/db_recover -h $testdir -c &]
+		lappend pidlist $p
+	}
+	watch_procs 5
+	#
+	# Now that they are all done run recovery correctly
+	puts "\tRecd016.d: Run recovery process"
+	set stat [catch {exec $util_path/db_recover -h $testdir -c} result]
+	if { $stat == 1 } {
+		error "FAIL: Recovery error: $result."
+	}
+
+	puts "\tRecd016.e: Open, dump and check database"
+	# Now compare the keys to see if they match the dictionary (or ints)
+	if { [is_record_based $method] == 1 } {
+		set oid [open $t2 w]
+		for {set i 1} {$i <= $nentries} {incr i} {
+			set j $i
+			if { 0xffffffff > 0 && $j > 0xffffffff } {
+				set j [expr $j - 0x100000000]
+			}
+			if { $j == 0 } {
+				incr i
+				incr j
+			}
+			puts $oid $j
+		}
+		close $oid
+	} else {
+		set q q
+		filehead $nentries $dict $t2
+	}
+	filesort $t2 $t3
+	file rename -force $t3 $t2
+	filesort $t4 $t3
+	file rename -force $t3 $t4
+	fileextract $t2 $t4 $t3
+	file rename -force $t3 $t5
+
+	set env [eval $env_cmd]
+	error_check_good dbenv [is_valid_env $env] TRUE
+
+	set txn ""
+	open_and_dump_file $testfile $env $txn $t1 $checkfunc \
+	    dump_file_direction "-first" "-next"
+	filesort $t1 $t3
+	error_check_good envclose [$env close] 0
+
+	error_check_good Recd016:diff($t5,$t3) \
+	    [filecmp $t5 $t3] 0
+
+	set stat [catch {exec $util_path/db_printlog -h $testdir \
+	    > $testdir/LOG } ret]
+	error_check_good db_printlog $stat 0
+	fileremove $testdir/LOG
+}
+
+# Check function for recd016; keys and data are identical
+proc recd016.check { key data } {
+	error_check_good "key/data mismatch" $data [reverse $key]
+}
+
+proc recd016_recno.check { key data } {
+	global kvals
+
+	error_check_good key"$key"_exists [info exists kvals($key)] 1
+	error_check_good "key/data mismatch, key $key" $data $kvals($key)
+}
diff --git a/db/test/scr018/chk.comma b/db/test/scr018/chk.comma
new file mode 100644
index 000000000..d15e3cf4d
--- /dev/null
+++ b/db/test/scr018/chk.comma
@@ -0,0 +1,30 @@
+#!/bin/sh -
+#
+# Id: chk.comma,v 1.1 2001/11/03 18:43:49 bostic Exp 
+#
+# Look for trailing commas in declarations.  Some compilers can't handle:
+#	enum {
+#		foo,
+#		bar,
+#	};
+
+[ -f ../libdb.a ] || (cd .. && make libdb.a) || {
+	echo 'FAIL: unable to find or build libdb.a'
+	exit 1
+}
+
+if cc -g -Wall -I.. t.c ../libdb.a -o t; then
+	:
+else
+	echo "FAIL: unable to compile test program t.c"
+	exit 1
+fi
+
+if ./t ../../*/*.[ch] ../../*/*.in; then
+	:
+else
+	echo "FAIL: test program failed"
+	exit 1
+fi
+
+exit 0
diff --git a/db/test/scr018/t.c b/db/test/scr018/t.c
new file mode 100644
index 000000000..4056a6059
--- /dev/null
+++ b/db/test/scr018/t.c
@@ -0,0 +1,46 @@
+#include <sys/types.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <strings.h>
+
+int
+chk(f)
+	char *f;
+{
+	int ch, l, r;
+
+	if (freopen(f, "r", stdin) == NULL) {
+		fprintf(stderr, "%s: %s\n", f, strerror(errno));
+		exit (1);
+	}
+	for (l = 1, r = 0; (ch = getchar()) != EOF;) {
+		if (ch != ',')
+			goto next;
+		do { ch = getchar(); } while (isblank(ch));
+		if (ch != '\n')
+			goto next;
+		++l;
+		do { ch = getchar(); } while (isblank(ch));
+		if (ch != '}')
+			goto next;
+		r = 1;
+		printf("%s: line %d\n", f, l);
+
+next:		if (ch == '\n')
+			++l;
+	}
+	return (r);
+}
+
+int
+main(int argc, char *argv[])
+{
+	int r;
+
+	for (r = 0; *++argv != NULL;)
+		if (chk(*argv))
+			r = 1;
+	return (r);
+}