Update internal BDB to version 4.6.18.

15 files changed, 87 insertions, 1675 deletions

diff --git a/db/cxx/cxx_app.cpp b/db/cxx/cxx_app.cpp
deleted file mode 100644
index 1fcf04b5c..000000000
--- a/db/cxx/cxx_app.cpp
+++ /dev/null
@@ -1,671 +0,0 @@
-/*-
- * See the file LICENSE for redistribution information.
- *
- * Copyright (c) 1997, 1998, 1999, 2000
- *	Sleepycat Software.  All rights reserved.
- */
-
-#include "db_config.h"
-
-#ifndef lint
-static const char revid[] = "$Id: cxx_app.cpp,v 11.38 2000/12/21 20:30:18 dda Exp $";
-#endif /* not lint */
-
-#include <errno.h>
-#include <stdio.h>              // needed for set_error_stream
-#include <string.h>
-
-#include "db_cxx.h"
-#include "cxx_int.h"
-
-#include "db_int.h"
-#include "common_ext.h"
-
-// The reason for a static variable is that some structures
-// (like Dbts) have no connection to any Db or DbEnv, so when
-// errors occur in their methods, we must have some reasonable
-// way to determine whether to throw or return errors.
-//
-// This variable is taken from flags whenever a DbEnv is constructed.
-// Normally there is only one DbEnv per program, and even if not,
-// there is typically a single policy of throwing or returning.
-//
-static int last_known_error_policy = ON_ERROR_UNKNOWN;
-
-////////////////////////////////////////////////////////////////////////
-//                                                                    //
-//                            DbEnv                                   //
-//                                                                    //
-////////////////////////////////////////////////////////////////////////
-
-ostream *DbEnv::error_stream_ = 0;
-
-// _destroy_check is called when there is a user error in a
-// destructor, specifically when close has not been called for an
-// object (even if it was never opened).  If the DbEnv is being
-// destroyed we cannot always use DbEnv::error_stream_, so we'll
-// use cerr in that case.
-//
-void DbEnv::_destroy_check(const char *str, int isDbEnv)
-{
-	ostream *out;
-
-	out = error_stream_;
-	if (out == NULL || isDbEnv == 1)
-		out = &cerr;
-
-	(*out) << "DbEnv::_destroy_check: open " << str << " object destroyed\n";
-}
-
-// A truism for the DbEnv object is that there is a valid
-// DB_ENV handle from the constructor until close().
-// After the close, the DB_ENV handle is invalid and
-// no operations are permitted on the DbEnv (other than
-// destructor).  Leaving the DbEnv handle open and not
-// doing a close is generally considered an error.
-//
-// We used to allow DbEnv objects to be closed and reopened.
-// This implied always keeping a valid DB_ENV object, and
-// coordinating the open objects between Db/DbEnv turned
-// out to be overly complicated.  Now we do not allow this.
-
-DbEnv::DbEnv(u_int32_t flags)
-:	imp_(0)
-,	construct_error_(0)
-,	construct_flags_(flags)
-,	tx_recover_callback_(0)
-,	paniccall_callback_(0)
-{
-	int err;
-
-	COMPQUIET(err, 0);
-	if ((err = initialize(0)) != 0)
-		DB_ERROR("DbEnv::DbEnv", err, error_policy());
-}
-
-DbEnv::DbEnv(DB_ENV *env, u_int32_t flags)
-:	imp_(0)
-,	construct_error_(0)
-,	construct_flags_(flags)
-,	tx_recover_callback_(0)
-,	paniccall_callback_(0)
-{
-	int err;
-
-	COMPQUIET(err, 0);
-	if ((err = initialize(env)) != 0)
-		DB_ERROR("DbEnv::DbEnv", err, error_policy());
-}
-
-// Note: if the user has not closed, we call _destroy_check
-// to warn against this non-safe programming practice,
-// and call close anyway.
-//
-DbEnv::~DbEnv()
-{
-	DB_ENV *env = unwrap(this);
-
-	if (env != NULL) {
-		_destroy_check("DbEnv", 1);
-		(void)env->close(env, 0);
-
-		// extra safety
-		cleanup();
-	}
-}
-
-// called by Db destructor when the DbEnv is owned by DB.
-void DbEnv::cleanup()
-{
-	DB_ENV *env = unwrap(this);
-
-	if (env != NULL) {
-		env->cj_internal = 0;
-		imp_ = 0;
-	}
-}
-
-int DbEnv::close(u_int32_t flags)
-{
-	DB_ENV *env = unwrap(this);
-	int err, init_err;
-
-	COMPQUIET(init_err, 0);
-
-	// after a close (no matter if success or failure),
-	// the underlying DB_ENV object must not be accessed,
-	// so we clean up in advance.
-	//
-	cleanup();
-
-	// It's safe to throw an error after the close,
-	// since our error mechanism does not peer into
-	// the DB* structures.
-	//
-	if ((err = env->close(env, flags)) != 0) {
-		DB_ERROR("DbEnv::close", err, error_policy());
-	}
-	return (err);
-}
-
-void DbEnv::err(int error, const char *format, ...)
-{
-	va_list args;
-	DB_ENV *env = unwrap(this);
-
-	va_start(args, format);
-	__db_real_err(env, error, 1, 1, format, args);
-	va_end(args);
-}
-
-void DbEnv::errx(const char *format, ...)
-{
-	va_list args;
-	DB_ENV *env = unwrap(this);
-
-	va_start(args, format);
-	__db_real_err(env, 0, 0, 1, format, args);
-	va_end(args);
-}
-
-// used internally during constructor
-// to associate an existing DB_ENV with this DbEnv,
-// or create a new one.  If there is an error,
-// construct_error_ is set; this is examined during open.
-//
-int DbEnv::initialize(DB_ENV *env)
-{
-	int err;
-
-	last_known_error_policy = error_policy();
-
-	if (env == 0) {
-		// Create a new DB_ENV environment.
-		if ((err = ::db_env_create(&env,
-			construct_flags_ & ~DB_CXX_NO_EXCEPTIONS)) != 0) {
-			construct_error_ = err;
-			return (err);
-		}
-	}
-	imp_ = wrap(env);
-	env->cj_internal = this;    // for DB_ENV* to DbEnv* conversion
-	return (0);
-}
-
-// Return a tristate value corresponding to whether we should
-// throw exceptions on errors:
-//   ON_ERROR_RETURN
-//   ON_ERROR_THROW
-//   ON_ERROR_UNKNOWN
-//
-int DbEnv::error_policy()
-{
-	if ((construct_flags_ & DB_CXX_NO_EXCEPTIONS) != 0) {
-		return (ON_ERROR_RETURN);
-	}
-	else {
-		return (ON_ERROR_THROW);
-	}
-}
-
-// If an error occurred during the constructor, report it now.
-// Otherwise, call the underlying DB->open method.
-//
-int DbEnv::open(const char *db_home, u_int32_t flags, int mode)
-{
-	DB_ENV *env = unwrap(this);
-	int err;
-
-	if ((err = construct_error_) != 0)
-		DB_ERROR("Db::open", err, error_policy());
-	else if ((err = env->open(env, db_home, flags, mode)) != 0)
-		DB_ERROR("DbEnv::open", err, error_policy());
-
-	return (err);
-}
-
-int DbEnv::remove(const char *db_home, u_int32_t flags)
-{
-	DB_ENV *env;
-	int ret;
-
-	env = unwrap(this);
-
-	// after a remove (no matter if success or failure),
-	// the underlying DB_ENV object must not be accessed,
-	// so we clean up in advance.
-	//
-	cleanup();
-
-	if ((ret = env->remove(env, db_home, flags)) != 0)
-		DB_ERROR("DbEnv::remove", ret, error_policy());
-
-	return (ret);
-}
-
-// Report an error associated with the DbEnv.
-// error_policy is one of:
-//   ON_ERROR_THROW     throw an error
-//   ON_ERROR_RETURN    do nothing here, the caller will return an error
-//   ON_ERROR_UNKNOWN   defer the policy to policy saved in DbEnv::DbEnv
-//
-void DbEnv::runtime_error(const char *caller, int error, int error_policy)
-{
-	if (error_policy == ON_ERROR_UNKNOWN)
-		error_policy = last_known_error_policy;
-	if (error_policy == ON_ERROR_THROW) {
-		// Creating and throwing the object in two separate
-		// statements seems to be necessary for HP compilers.
-		DbException except(caller, error);
-		throw except;
-	}
-}
-
-// static method
-char *DbEnv::strerror(int error)
-{
-	return (db_strerror(error));
-}
-
-// This is a 'glue' function declared as extern "C" so it will
-// be compatible with picky compilers that do not allow mixing
-// of function pointers to 'C' functions with function pointers
-// to C++ functions.
-//
-extern "C"
-void _stream_error_function_c(const char *prefix, char *message)
-{
-	DbEnv::_stream_error_function(prefix, message);
-}
-
-void DbEnv::_stream_error_function(const char *prefix, char *message)
-{
-	// HP compilers need the extra casts, we don't know why.
-	if (error_stream_) {
-		if (prefix) {
-			(*error_stream_) << prefix << (const char *)": ";
-		}
-		if (message) {
-			(*error_stream_) << (const char *)message;
-		}
-		(*error_stream_) << (const char *)"\n";
-	}
-}
-
-// Note: This actually behaves a bit like a static function,
-// since DB_ENV.db_errcall has no information about which
-// db_env triggered the call.  A user that has multiple DB_ENVs
-// will simply not be able to have different streams for each one.
-//
-void DbEnv::set_error_stream(ostream *stream)
-{
-	DB_ENV *dbenv = unwrap(this);
-
-	error_stream_ = stream;
-	dbenv->set_errcall(dbenv, (stream == 0) ? 0 :
-			   _stream_error_function_c);
-}
-
-// static method
-char *DbEnv::version(int *major, int *minor, int *patch)
-{
-	return (db_version(major, minor, patch));
-}
-
-// This is a variant of the DB_WO_ACCESS macro to define a simple set_
-// method calling the underlying C method, but unlike a simple
-// set method, it may return an error or raise an exception.
-// Note this macro expects that input _argspec is an argument
-// list element (e.g. "char *arg") defined in terms of "arg".
-//
-#define	DB_DBENV_ACCESS(_name, _argspec)                       \
-							       \
-int DbEnv::set_##_name(_argspec)                               \
-{                                                              \
-	int ret;                                               \
-	DB_ENV *dbenv = unwrap(this);                          \
-							       \
-	if ((ret = (*(dbenv->set_##_name))(dbenv, arg)) != 0) {\
-		DB_ERROR("DbEnv::set_" # _name, ret, error_policy()); \
-	}                                                      \
-	return (ret);                                          \
-}
-
-#define	DB_DBENV_ACCESS_NORET(_name, _argspec)                 \
-							       \
-void DbEnv::set_##_name(_argspec)                              \
-{                                                              \
-	DB_ENV *dbenv = unwrap(this);                          \
-							       \
-	(*(dbenv->set_##_name))(dbenv, arg);                   \
-	return;                                                \
-}
-
-DB_DBENV_ACCESS_NORET(errfile, FILE *arg)
-DB_DBENV_ACCESS_NORET(errpfx, const char *arg)
-
-// We keep these alphabetical by field name,
-// for comparison with Java's list.
-//
-DB_DBENV_ACCESS(data_dir, const char *arg)
-DB_DBENV_ACCESS(lg_bsize, u_int32_t arg)
-DB_DBENV_ACCESS(lg_dir, const char *arg)
-DB_DBENV_ACCESS(lg_max, u_int32_t arg)
-DB_DBENV_ACCESS(lk_detect, u_int32_t arg)
-DB_DBENV_ACCESS(lk_max, u_int32_t arg)
-DB_DBENV_ACCESS(lk_max_lockers, u_int32_t arg)
-DB_DBENV_ACCESS(lk_max_locks, u_int32_t arg)
-DB_DBENV_ACCESS(lk_max_objects, u_int32_t arg)
-DB_DBENV_ACCESS(mp_mmapsize, size_t arg)
-DB_DBENV_ACCESS(mutexlocks, int arg)
-DB_DBENV_ACCESS(tmp_dir, const char *arg)
-DB_DBENV_ACCESS(tx_max, u_int32_t arg)
-
-// Here are the set methods that don't fit the above mold.
-//
-extern "C" {
-	typedef void (*db_errcall_fcn_type)
-		(const char *, char *);
-};
-
-void DbEnv::set_errcall(void (*arg)(const char *, char *))
-{
-	DB_ENV *dbenv = unwrap(this);
-
-	// XXX
-	// We are casting from a function ptr declared with C++
-	// linkage to one (same arg types) declared with C
-	// linkage.  It's hard to imagine a pair of C/C++
-	// compilers from the same vendor for which this
-	// won't work.  Unfortunately, we can't use a
-	// intercept function like the others since the
-	// function does not have a (DbEnv*) as one of
-	// the args.  If this causes trouble, we can pull
-	// the same trick we use in Java, namely stuffing
-	// a (DbEnv*) pointer into the prefix.  We're
-	// avoiding this for the moment because it obfuscates.
-	//
-	(*(dbenv->set_errcall))(dbenv, (db_errcall_fcn_type)arg);
-}
-
-int DbEnv::set_cachesize(u_int32_t gbytes, u_int32_t bytes, int ncache)
-{
-	int ret;
-	DB_ENV *dbenv = unwrap(this);
-
-	if ((ret =
-	    (*(dbenv->set_cachesize))(dbenv, gbytes, bytes, ncache)) != 0)
-		DB_ERROR("DbEnv::set_cachesize", ret, error_policy());
-
-	return (ret);
-}
-
-int DbEnv::set_flags(u_int32_t flags, int onoff)
-{
-	int ret;
-	DB_ENV *dbenv = unwrap(this);
-
-	if ((ret = (dbenv->set_flags)(dbenv, flags, onoff)) != 0)
-		DB_ERROR("DbEnv::set_flags", ret, error_policy());
-
-	return (ret);
-}
-
-int DbEnv::set_lk_conflicts(u_int8_t *lk_conflicts, int lk_max)
-{
-	int ret;
-	DB_ENV *dbenv = unwrap(this);
-
-	if ((ret = (*(dbenv->set_lk_conflicts))
-	     (dbenv, lk_conflicts, lk_max)) != 0)
-		DB_ERROR("DbEnv::set_lk_conflicts", ret, error_policy());
-
-	return (ret);
-}
-
-// static method
-int DbEnv::set_pageyield(int arg)
-{
-	int ret;
-
-	if ((ret = db_env_set_pageyield(arg)) != 0)
-		DB_ERROR("DbEnv::set_pageyield", ret, last_known_error_policy);
-
-	return (ret);
-}
-
-// static method
-int DbEnv::set_panicstate(int arg)
-{
-	int ret;
-
-	if ((ret = db_env_set_panicstate(arg)) != 0)
-		DB_ERROR("DbEnv::set_panicstate", ret, last_known_error_policy);
-
-	return (ret);
-}
-
-// static method
-int DbEnv::set_region_init(int arg)
-{
-	int ret;
-
-	if ((ret = db_env_set_region_init(arg)) != 0)
-		DB_ERROR("DbEnv::set_region_init", ret, last_known_error_policy);
-
-	return (ret);
-}
-
-int DbEnv::set_server(char *host, long tsec, long ssec, u_int32_t flags)
-{
-	int ret;
-	DB_ENV *dbenv = unwrap(this);
-
-	if ((ret = dbenv->set_server(dbenv, host, tsec, ssec, flags)) != 0)
-		DB_ERROR("DbEnv::set_server", ret, error_policy());
-
-	return (ret);
-}
-
-int DbEnv::set_shm_key(long shm_key)
-{
-	int ret;
-	DB_ENV *dbenv = unwrap(this);
-
-	if ((ret = dbenv->set_shm_key(dbenv, shm_key)) != 0)
-		DB_ERROR("DbEnv::set_shm_key", ret, error_policy());
-
-	return (ret);
-}
-
-// static method
-int DbEnv::set_tas_spins(u_int32_t arg)
-{
-	int ret;
-
-	if ((ret = db_env_set_tas_spins(arg)) != 0)
-		DB_ERROR("DbEnv::set_tas_spins", ret, last_known_error_policy);
-
-	return (ret);
-}
-
-int DbEnv::set_verbose(u_int32_t which, int onoff)
-{
-	int ret;
-	DB_ENV *dbenv = unwrap(this);
-
-	if ((ret = (*(dbenv->set_verbose))(dbenv, which, onoff)) != 0)
-		DB_ERROR("DbEnv::set_verbose", ret, error_policy());
-
-	return (ret);
-}
-
-// This is a 'glue' function declared as extern "C" so it will
-// be compatible with picky compilers that do not allow mixing
-// of function pointers to 'C' functions with function pointers
-// to C++ functions.
-//
-extern "C"
-int _tx_recover_intercept_c(DB_ENV *env, DBT *dbt,
-			    DB_LSN *lsn, db_recops op)
-{
-	return (DbEnv::_tx_recover_intercept(env, dbt, lsn, op));
-}
-
-int DbEnv::_tx_recover_intercept(DB_ENV *env, DBT *dbt,
-				DB_LSN *lsn, db_recops op)
-{
-	if (env == 0) {
-		DB_ERROR("DbEnv::tx_recover_callback", EINVAL, ON_ERROR_UNKNOWN);
-		return (EINVAL);
-	}
-	DbEnv *cxxenv = (DbEnv *)env->cj_internal;
-	if (cxxenv == 0) {
-		DB_ERROR("DbEnv::tx_recover_callback", EINVAL, ON_ERROR_UNKNOWN);
-		return (EINVAL);
-	}
-	if (cxxenv->tx_recover_callback_ == 0) {
-		DB_ERROR("DbEnv::tx_recover_callback", EINVAL, cxxenv->error_policy());
-		return (EINVAL);
-	}
-	Dbt *cxxdbt = (Dbt *)dbt;
-	DbLsn *cxxlsn = (DbLsn *)lsn;
-	return ((*cxxenv->tx_recover_callback_)(cxxenv, cxxdbt, cxxlsn, op));
-}
-
-int DbEnv::set_tx_recover
-    (int (*arg)(DbEnv *, Dbt *, DbLsn *, db_recops))
-{
-	int ret;
-	DB_ENV *dbenv = unwrap(this);
-
-	tx_recover_callback_ = arg;
-	if ((ret =
-	    (*(dbenv->set_tx_recover))(dbenv, _tx_recover_intercept_c)) != 0)
-		DB_ERROR("DbEnv::set_tx_recover", ret, error_policy());
-
-	return (ret);
-}
-
-int DbEnv::set_tx_timestamp(time_t *timestamp)
-{
-	int ret;
-	DB_ENV *dbenv = unwrap(this);
-
-	if ((ret = dbenv->set_tx_timestamp(dbenv, timestamp)) != 0)
-		DB_ERROR("DbEnv::set_tx_timestamp", ret, error_policy());
-
-	return (ret);
-}
-
-// This is a 'glue' function declared as extern "C" so it will
-// be compatible with picky compilers that do not allow mixing
-// of function pointers to 'C' functions with function pointers
-// to C++ functions.
-//
-extern "C"
-void _paniccall_intercept_c(DB_ENV *env, int errval)
-{
-	DbEnv::_paniccall_intercept(env, errval);
-}
-
-void DbEnv::_paniccall_intercept(DB_ENV *env, int errval)
-{
-	if (env == 0) {
-		DB_ERROR("DbEnv::paniccall_callback", EINVAL, ON_ERROR_UNKNOWN);
-	}
-	DbEnv *cxxenv = (DbEnv *)env->cj_internal;
-	if (cxxenv == 0) {
-		DB_ERROR("DbEnv::paniccall_callback", EINVAL, ON_ERROR_UNKNOWN);
-	}
-	if (cxxenv->paniccall_callback_ == 0) {
-		DB_ERROR("DbEnv::paniccall_callback", EINVAL, cxxenv->error_policy());
-	}
-	(*cxxenv->paniccall_callback_)(cxxenv, errval);
-}
-
-int DbEnv::set_paniccall(void (*arg)(DbEnv *, int))
-{
-	DB_ENV *dbenv = unwrap(this);
-
-	paniccall_callback_ = arg;
-
-	return ((*(dbenv->set_paniccall))(dbenv, _paniccall_intercept_c));
-}
-
-// This is a 'glue' function declared as extern "C" so it will
-// be compatible with picky compilers that do not allow mixing
-// of function pointers to 'C' functions with function pointers
-// to C++ functions.
-//
-extern "C"
-int _recovery_init_intercept_c(DB_ENV *env)
-{
-	return (DbEnv::_recovery_init_intercept(env));
-}
-
-int DbEnv::_recovery_init_intercept(DB_ENV *env)
-{
-	if (env == 0) {
-		DB_ERROR("DbEnv::recovery_init_callback", EINVAL,
-			 ON_ERROR_UNKNOWN);
-	}
-	DbEnv *cxxenv = (DbEnv *)env->cj_internal;
-	if (cxxenv == 0) {
-		DB_ERROR("DbEnv::recovery_init_callback", EINVAL,
-			 ON_ERROR_UNKNOWN);
-	}
-	if (cxxenv->recovery_init_callback_ == 0) {
-		DB_ERROR("DbEnv::recovery_init_callback", EINVAL,
-			 cxxenv->error_policy());
-	}
-	return ((*cxxenv->recovery_init_callback_)(cxxenv));
-}
-
-int DbEnv::set_recovery_init(int (*arg)(DbEnv *))
-{
-	DB_ENV *dbenv = unwrap(this);
-
-	recovery_init_callback_ = arg;
-
-	return ((*(dbenv->set_recovery_init))(dbenv, _recovery_init_intercept_c));
-}
-
-// This is a 'glue' function declared as extern "C" so it will
-// be compatible with picky compilers that do not allow mixing
-// of function pointers to 'C' functions with function pointers
-// to C++ functions.
-//
-extern "C"
-void _feedback_intercept_c(DB_ENV *env, int opcode, int pct)
-{
-	DbEnv::_feedback_intercept(env, opcode, pct);
-}
-
-void DbEnv::_feedback_intercept(DB_ENV *env, int opcode, int pct)
-{
-	if (env == 0) {
-		DB_ERROR("DbEnv::feedback_callback", EINVAL, ON_ERROR_UNKNOWN);
-		return;
-	}
-	DbEnv *cxxenv = (DbEnv *)env->cj_internal;
-	if (cxxenv == 0) {
-		DB_ERROR("DbEnv::feedback_callback", EINVAL, ON_ERROR_UNKNOWN);
-		return;
-	}
-	if (cxxenv->feedback_callback_ == 0) {
-		DB_ERROR("DbEnv::feedback_callback", EINVAL,
-			 cxxenv->error_policy());
-		return;
-	}
-	(*cxxenv->feedback_callback_)(cxxenv, opcode, pct);
-}
-
-int DbEnv::set_feedback(void (*arg)(DbEnv *, int, int))
-{
-	DB_ENV *dbenv = unwrap(this);
-
-	feedback_callback_ = arg;
-
-	return ((*(dbenv->set_feedback))(dbenv, _feedback_intercept_c));
-}
diff --git a/db/cxx/cxx_db.cpp b/db/cxx/cxx_db.cpp
index 0ecc2fe5e..2c95274ff 100644
--- a/db/cxx/cxx_db.cpp
+++ b/db/cxx/cxx_db.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_db.cpp,v 12.13 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_db.cpp,v 12.20 2007/06/28 13:02:50 mjc Exp $
  */
 
 #include "db_config.h"
@@ -97,6 +96,7 @@ Db::Db(DbEnv *env, u_int32_t flags)
 ,	bt_prefix_callback_(0)
 ,	dup_compare_callback_(0)
 ,	feedback_callback_(0)
+,	h_compare_callback_(0)
 ,	h_hash_callback_(0)
 {
 	if (env_ == 0)
@@ -239,6 +239,9 @@ void Db::errx(const char *format, ...)
 	DB_REAL_ERR(db->dbenv, 0, DB_ERROR_NOT_SET, 1, format);
 }
 
+DB_METHOD(exists, (DbTxn *txnid, Dbt *key, u_int32_t flags),
+    (db, unwrap(txnid), key, flags), DB_RETOK_EXISTS)
+
 DB_METHOD(fd, (int *fdp), (db, fdp), DB_RETOK_STD)
 
 int Db::get(DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags)
@@ -478,6 +481,14 @@ DB_CALLBACK_C_INTERCEPT(dup_compare,
 DB_SET_CALLBACK(set_dup_compare, dup_compare,
     (int (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg)
 
+DB_CALLBACK_C_INTERCEPT(h_compare,
+    int, (DB *cthis, const DBT *data1, const DBT *data2),
+    return,
+    (cxxthis, Dbt::get_const_Dbt(data1), Dbt::get_const_Dbt(data2)))
+
+DB_SET_CALLBACK(set_h_compare, h_compare,
+    (int (*arg)(Db *cxxthis, const Dbt *data1, const Dbt *data2)), arg)
+
 DB_CALLBACK_C_INTERCEPT(h_hash,
     u_int32_t, (DB *cthis, const void *data, u_int32_t len),
     return, (cxxthis, data, len))
@@ -552,6 +563,8 @@ DB_METHOD(get_flags, (u_int32_t *flagsp), (db, flagsp),
     DB_RETOK_STD)
 DB_METHOD(set_flags, (u_int32_t flags), (db, flags),
     DB_RETOK_STD)
+DB_METHOD(set_h_compare, (h_compare_fcn_type func),
+    (db, func), DB_RETOK_STD)
 DB_METHOD(get_h_ffactor, (u_int32_t *h_ffactorp),
     (db, h_ffactorp), DB_RETOK_STD)
 DB_METHOD(set_h_ffactor, (u_int32_t h_ffactor),
@@ -568,10 +581,15 @@ DB_METHOD(set_lorder, (int db_lorder), (db, db_lorder),
     DB_RETOK_STD)
 DB_METHOD_VOID(get_msgfile, (FILE **msgfilep), (db, msgfilep))
 DB_METHOD_VOID(set_msgfile, (FILE *msgfile), (db, msgfile))
+DB_METHOD_QUIET(get_multiple, (), (db))
 DB_METHOD(get_pagesize, (u_int32_t *db_pagesizep),
     (db, db_pagesizep), DB_RETOK_STD)
 DB_METHOD(set_pagesize, (u_int32_t db_pagesize),
     (db, db_pagesize), DB_RETOK_STD)
+DB_METHOD(get_priority, (DB_CACHE_PRIORITY *priorityp),
+    (db, priorityp), DB_RETOK_STD)
+DB_METHOD(set_priority, (DB_CACHE_PRIORITY priority),
+    (db, priority), DB_RETOK_STD)
 DB_METHOD(get_re_delim, (int *re_delimp),
     (db, re_delimp), DB_RETOK_STD)
 DB_METHOD(set_re_delim, (int re_delim),
diff --git a/db/cxx/cxx_dbc.cpp b/db/cxx/cxx_dbc.cpp
index 4ab337c54..6ef72d331 100644
--- a/db/cxx/cxx_dbc.cpp
+++ b/db/cxx/cxx_dbc.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_dbc.cpp,v 12.5 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_dbc.cpp,v 12.10 2007/06/26 16:58:17 bostic Exp $
  */
 
 #include "db_config.h"
@@ -33,7 +32,7 @@ int Dbc::_name _argspec							\
 	int ret;							\
 	DBC *dbc = this;						\
 									\
-	ret = dbc->c_##_name _arglist;					\
+	ret = dbc->_name _arglist;					\
 	if (!_retok(ret))						\
 		DB_ERROR(DbEnv::get_DbEnv(dbc->dbp->dbenv), \
 			"Dbc::" # _name, ret, ON_ERROR_UNKNOWN); \
@@ -58,7 +57,7 @@ int Dbc::dup(Dbc** cursorp, u_int32_t _flags)
 	DBC *dbc = this;
 	DBC *new_cursor = 0;
 
-	ret = dbc->c_dup(dbc, &new_cursor, _flags);
+	ret = dbc->dup(dbc, &new_cursor, _flags);
 
 	if (DB_RETOK_STD(ret))
 		// The following cast implies that Dbc can be no larger than DBC
@@ -75,7 +74,7 @@ int Dbc::get(Dbt* key, Dbt *data, u_int32_t _flags)
 	int ret;
 	DBC *dbc = this;
 
-	ret = dbc->c_get(dbc, key, data, _flags);
+	ret = dbc->get(dbc, key, data, _flags);
 
 	if (!DB_RETOK_DBCGET(ret)) {
 		if (ret == DB_BUFFER_SMALL && DB_OVERFLOWED_DBT(key))
@@ -97,7 +96,7 @@ int Dbc::pget(Dbt* key, Dbt *pkey, Dbt *data, u_int32_t _flags)
 	int ret;
 	DBC *dbc = this;
 
-	ret = dbc->c_pget(dbc, key, pkey, data, _flags);
+	ret = dbc->pget(dbc, key, pkey, data, _flags);
 
 	/* Logic is the same as for Dbc::get - reusing macro. */
 	if (!DB_RETOK_DBCGET(ret)) {
@@ -117,3 +116,6 @@ int Dbc::pget(Dbt* key, Dbt *pkey, Dbt *data, u_int32_t _flags)
 
 DBC_METHOD(put, (Dbt* key, Dbt *data, u_int32_t _flags),
     (dbc, key, data, _flags), DB_RETOK_DBCPUT)
+DBC_METHOD(get_priority, (DB_CACHE_PRIORITY *priorityp),
+    (dbc, priorityp), DB_RETOK_STD)
+DBC_METHOD(set_priority, (DB_CACHE_PRIORITY pri), (dbc, pri), DB_RETOK_STD)
diff --git a/db/cxx/cxx_dbt.cpp b/db/cxx/cxx_dbt.cpp
index cb203e18d..705dea332 100644
--- a/db/cxx/cxx_dbt.cpp
+++ b/db/cxx/cxx_dbt.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_dbt.cpp,v 12.4 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_dbt.cpp,v 12.6 2007/05/17 15:14:56 bostic Exp $
  */
 
 #include "db_config.h"
diff --git a/db/cxx/cxx_env.cpp b/db/cxx/cxx_env.cpp
index ef6dd5678..3db5647c8 100644
--- a/db/cxx/cxx_env.cpp
+++ b/db/cxx/cxx_env.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_env.cpp,v 12.32 2006/09/13 14:53:36 mjc Exp $
+ * $Id: cxx_env.cpp,v 12.40 2007/06/28 13:02:50 mjc Exp $
  */
 
 #include "db_config.h"
@@ -408,6 +407,7 @@ bool DbEnv::is_bigendian()
 	return unwrap(this)->is_bigendian() ? true : false;
 }
 
+DBENV_METHOD(get_thread_count, (u_int32_t *count), (dbenv, count))
 DBENV_METHOD(set_thread_count, (u_int32_t count), (dbenv, count))
 
 // used internally during constructor
@@ -741,9 +741,9 @@ DBENV_METHOD(get_lk_max_objects, (u_int32_t *max_objectsp),
 DBENV_METHOD(set_lk_max_objects, (u_int32_t max_objects), (dbenv, max_objects))
 DBENV_METHOD(get_mp_max_openfd, (int *maxopenfdp), (dbenv, maxopenfdp))
 DBENV_METHOD(set_mp_max_openfd, (int maxopenfd), (dbenv, maxopenfd))
-DBENV_METHOD(get_mp_max_write, (int *maxwritep, int *maxwrite_sleepp),
+DBENV_METHOD(get_mp_max_write, (int *maxwritep, db_timeout_t *maxwrite_sleepp),
     (dbenv, maxwritep, maxwrite_sleepp))
-DBENV_METHOD(set_mp_max_write, (int maxwrite, int maxwrite_sleep),
+DBENV_METHOD(set_mp_max_write, (int maxwrite, db_timeout_t maxwrite_sleep),
     (dbenv, maxwrite, maxwrite_sleep))
 DBENV_METHOD(get_mp_mmapsize, (size_t *mmapsizep), (dbenv, mmapsizep))
 DBENV_METHOD(set_mp_mmapsize, (size_t mmapsize), (dbenv, mmapsize))
@@ -772,6 +772,10 @@ DBENV_METHOD(get_cachesize,
 DBENV_METHOD(set_cachesize,
     (u_int32_t gbytes, u_int32_t bytes, int ncache),
     (dbenv, gbytes, bytes, ncache))
+DBENV_METHOD(get_cache_max, (u_int32_t *gbytesp, u_int32_t *bytesp),
+    (dbenv, gbytesp, bytesp))
+DBENV_METHOD(set_cache_max, (u_int32_t gbytes, u_int32_t bytes),
+    (dbenv, gbytes, bytes))
 
 void DbEnv::set_errcall(void (*arg)(const DbEnv *, const char *, const char *))
 {
@@ -1039,20 +1043,20 @@ int DbEnv::rep_set_transport(int myid, int (*arg)(DbEnv *,
 	return (ret);
 }
 
-DBENV_METHOD(rep_elect, (int nsites, int nvotes, int *eidp, u_int32_t flags),
-    (dbenv, nsites, nvotes, eidp, flags))
+DBENV_METHOD(rep_elect, (int nsites, int nvotes, u_int32_t flags),
+    (dbenv, nsites, nvotes, flags))
 DBENV_METHOD(rep_flush, (), (dbenv))
 DBENV_METHOD(rep_get_config, (u_int32_t which, int *onoffp),
     (dbenv, which, onoffp))
 DBENV_METHOD(set_rep_request, (u_int32_t min, u_int32_t max), (dbenv, min, max))
 
 int DbEnv::rep_process_message(Dbt *control,
-    Dbt *rec, int *idp, DbLsn *ret_lsnp)
+    Dbt *rec, int id, DbLsn *ret_lsnp)
 {
 	DB_ENV *dbenv = unwrap(this);
 	int ret;
 
-	ret = dbenv->rep_process_message(dbenv, control, rec, idp, ret_lsnp);
+	ret = dbenv->rep_process_message(dbenv, control, rec, id, ret_lsnp);
 	if (!DB_RETOK_REPPMSG(ret))
 		DB_ERROR(this, "DbEnv::rep_process_message", ret,
 		    error_policy());
@@ -1071,6 +1075,8 @@ DBENV_METHOD(rep_stat, (DB_REP_STAT **statp, u_int32_t flags),
 DBENV_METHOD(rep_stat_print, (u_int32_t flags), (dbenv, flags))
 DBENV_METHOD(rep_sync, (u_int32_t flags), (dbenv, flags))
 
+DBENV_METHOD(rep_set_lease, (u_int32_t clock_scale_factor, u_int32_t flags),
+    (dbenv, clock_scale_factor, flags))
 DBENV_METHOD(rep_get_limit, (u_int32_t *gbytesp, u_int32_t *bytesp),
     (dbenv, gbytesp, bytesp))
 DBENV_METHOD(rep_set_limit, (u_int32_t gbytes, u_int32_t bytes),
@@ -1098,6 +1104,9 @@ DBENV_METHOD(repmgr_site_list, (u_int *countp, DB_REPMGR_SITE **listp),
     (dbenv, countp, listp))
 DBENV_METHOD(repmgr_start, (int nthreads, u_int32_t flags),
     (dbenv, nthreads, flags))
+DBENV_METHOD(repmgr_stat, (DB_REPMGR_STAT **statp, u_int32_t flags),
+    (dbenv, statp, flags))
+DBENV_METHOD(repmgr_stat_print, (u_int32_t flags), (dbenv, flags))
 
 // End advanced replication API method implementations.
 
diff --git a/db/cxx/cxx_except.cpp b/db/cxx/cxx_except.cpp
index 3a58f6bec..27b642caa 100644
--- a/db/cxx/cxx_except.cpp
+++ b/db/cxx/cxx_except.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_except.cpp,v 12.10 2006/09/13 14:53:37 mjc Exp $
+ * $Id: cxx_except.cpp,v 12.12 2007/05/17 15:14:56 bostic Exp $
  */
 
 #include "db_config.h"
diff --git a/db/cxx/cxx_lock.cpp b/db/cxx/cxx_lock.cpp
index 8c5a537a2..7b77330be 100644
--- a/db/cxx/cxx_lock.cpp
+++ b/db/cxx/cxx_lock.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_lock.cpp,v 12.4 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_lock.cpp,v 12.6 2007/05/17 15:14:56 bostic Exp $
  */
 
 #include "db_config.h"
diff --git a/db/cxx/cxx_log.cpp b/db/cxx/cxx_log.cpp
deleted file mode 100644
index 336b9d337..000000000
--- a/db/cxx/cxx_log.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-/*-
- * See the file LICENSE for redistribution information.
- *
- * Copyright (c) 1997, 1998, 1999, 2000
- *	Sleepycat Software.  All rights reserved.
- */
-
-#include "db_config.h"
-
-#ifndef lint
-static const char revid[] = "$Id: cxx_log.cpp,v 11.9 2000/09/21 15:05:45 dda Exp $";
-#endif /* not lint */
-
-#include <errno.h>
-
-#include "db_cxx.h"
-#include "cxx_int.h"
-
-////////////////////////////////////////////////////////////////////////
-//                                                                    //
-//                            DbLog                                   //
-//                                                                    //
-////////////////////////////////////////////////////////////////////////
-
-int DbEnv::log_archive(char **list[], u_int32_t flags,
-		       db_malloc_fcn_type db_malloc_fcn)
-{
-	int err;
-	DB_ENV *env = unwrap(this);
-
-	if ((err = ::log_archive(env, list, flags, db_malloc_fcn)) != 0) {
-		DB_ERROR("DbEnv::log_archive", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int DbEnv::log_compare(const DbLsn *lsn0, const DbLsn *lsn1)
-{
-	return (::log_compare(lsn0, lsn1));
-}
-
-int DbEnv::log_file(DbLsn *lsn, char *namep, size_t len)
-{
-	int err;
-	DB_ENV *env = unwrap(this);
-
-	if ((err = ::log_file(env, lsn, namep, len)) != 0) {
-		DB_ERROR("DbEnv::log_file", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int DbEnv::log_flush(const DbLsn *lsn)
-{
-	int err;
-	DB_ENV *env = unwrap(this);
-
-	if ((err = ::log_flush(env, lsn)) != 0) {
-		DB_ERROR("DbEnv::log_flush", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int DbEnv::log_get(DbLsn *lsn, Dbt *data, u_int32_t flags)
-{
-	int err;
-	DB_ENV *env = unwrap(this);
-
-	if ((err = ::log_get(env, lsn, data, flags)) != 0) {
-		DB_ERROR("DbEnv::log_get", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int DbEnv::log_put(DbLsn *lsn, const Dbt *data, u_int32_t flags)
-{
-	int err = 0;
-	DB_ENV *env = unwrap(this);
-
-	if ((err = ::log_put(env, lsn, data, flags)) != 0) {
-		DB_ERROR("DbEnv::log_put", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int DbEnv::log_register(Db *dbp, const char *name)
-{
-	int err = 0;
-	DB_ENV *env = unwrap(this);
-
-	if ((err = ::log_register(env, unwrap(dbp), name)) != 0) {
-		DB_ERROR("DbEnv::log_register", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int DbEnv::log_stat(DB_LOG_STAT **spp, db_malloc_fcn_type db_malloc_fcn)
-{
-	int err = 0;
-	DB_ENV *env = unwrap(this);
-
-	if ((err = ::log_stat(env, spp, db_malloc_fcn)) != 0) {
-		DB_ERROR("DbEnv::log_stat", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int DbEnv::log_unregister(Db *dbp)
-{
-	int err;
-	DB_ENV *env = unwrap(this);
-
-	if ((err = ::log_unregister(env, unwrap(dbp))) != 0) {
-		DB_ERROR("DbEnv::log_unregister", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
diff --git a/db/cxx/cxx_logc.cpp b/db/cxx/cxx_logc.cpp
index 1e3c4ef70..819f5b0fb 100644
--- a/db/cxx/cxx_logc.cpp
+++ b/db/cxx/cxx_logc.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_logc.cpp,v 12.4 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_logc.cpp,v 12.8 2007/06/28 13:02:50 mjc Exp $
  */
 
 #include "db_config.h"
@@ -44,12 +43,12 @@ int DbLogc::close(u_int32_t _flags)
 }
 
 // The name _flags prevents a name clash with __db_log_cursor::flags
-int DbLogc::get(DbLsn *lsn, Dbt *data, u_int32_t _flags)
+int DbLogc::get(DbLsn *get_lsn, Dbt *data, u_int32_t _flags)
 {
 	DB_LOGC *logc = this;
 	int ret;
 
-	ret = logc->get(logc, lsn, data, _flags);
+	ret = logc->get(logc, get_lsn, data, _flags);
 
 	if (!DB_RETOK_LGGET(ret)) {
 		if (ret == DB_BUFFER_SMALL)
@@ -62,3 +61,18 @@ int DbLogc::get(DbLsn *lsn, Dbt *data, u_int32_t _flags)
 
 	return (ret);
 }
+
+// The name _flags prevents a name clash with __db_log_cursor::flags
+int DbLogc::version(u_int32_t *versionp, u_int32_t _flags)
+{
+	DB_LOGC *logc = this;
+	int ret;
+
+	ret = logc->version(logc, versionp, _flags);
+
+	if (!DB_RETOK_LGGET(ret))
+		DB_ERROR(DbEnv::get_DbEnv(logc->dbenv),
+			"DbLogc::version", ret, ON_ERROR_UNKNOWN);
+
+	return (ret);
+}
diff --git a/db/cxx/cxx_mpool.cpp b/db/cxx/cxx_mpool.cpp
index 1085f0390..db93114ac 100644
--- a/db/cxx/cxx_mpool.cpp
+++ b/db/cxx/cxx_mpool.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_mpool.cpp,v 12.5 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_mpool.cpp,v 12.10 2007/06/28 13:02:50 mjc Exp $
  */
 
 #include "db_config.h"
@@ -88,10 +87,9 @@ DB_MPOOLFILE_METHOD(get,
 DB_MPOOLFILE_METHOD(open,
     (const char *file, u_int32_t flags, int mode, size_t pagesize),
     (mpf, file, flags, mode, pagesize), DB_RETOK_STD)
-DB_MPOOLFILE_METHOD(put, (void *pgaddr, u_int32_t flags),
-    (mpf, pgaddr, flags), DB_RETOK_STD)
-DB_MPOOLFILE_METHOD(set, (void *pgaddr, u_int32_t flags),
-    (mpf, pgaddr, flags), DB_RETOK_STD)
+DB_MPOOLFILE_METHOD(put,
+    (void *pgaddr, DB_CACHE_PRIORITY priority, u_int32_t flags),
+    (mpf, pgaddr, priority, flags), DB_RETOK_STD)
 DB_MPOOLFILE_METHOD(get_clear_len, (u_int32_t *lenp),
     (mpf, lenp), DB_RETOK_STD)
 DB_MPOOLFILE_METHOD(set_clear_len, (u_int32_t len),
@@ -108,6 +106,8 @@ DB_MPOOLFILE_METHOD(get_ftype, (int *ftypep),
     (mpf, ftypep), DB_RETOK_STD)
 DB_MPOOLFILE_METHOD(set_ftype, (int ftype),
     (mpf, ftype), DB_RETOK_STD)
+DB_MPOOLFILE_METHOD(get_last_pgno, (db_pgno_t *pgnop),
+    (mpf, pgnop), DB_RETOK_STD)
 DB_MPOOLFILE_METHOD(get_lsn_offset, (int32_t *offsetp),
     (mpf, offsetp), DB_RETOK_STD)
 DB_MPOOLFILE_METHOD(set_lsn_offset, (int32_t offset),
diff --git a/db/cxx/cxx_multi.cpp b/db/cxx/cxx_multi.cpp
index a53f09b34..bf1c61e68 100644
--- a/db/cxx/cxx_multi.cpp
+++ b/db/cxx/cxx_multi.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_multi.cpp,v 12.7 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_multi.cpp,v 12.9 2007/05/17 15:14:56 bostic Exp $
  */
 
 #include "db_config.h"
diff --git a/db/cxx/cxx_seq.cpp b/db/cxx/cxx_seq.cpp
index d3a4bd0ad..33b2af37d 100644
--- a/db/cxx/cxx_seq.cpp
+++ b/db/cxx/cxx_seq.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_seq.cpp,v 12.6 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_seq.cpp,v 12.9 2007/05/17 17:23:26 bostic Exp $
  */
 
 #include "db_config.h"
@@ -97,7 +96,7 @@ Db *DbSequence::get_db()
 Dbt *DbSequence::get_key()
 {
 	DB_SEQUENCE *seq = unwrap(this);
-	memset(&key_, 0, sizeof (DBT));
+	memset(&key_, 0, sizeof(DBT));
 	(void)seq->get_key(seq, &key_);
 	return Dbt::get_Dbt(&key_);
 }
diff --git a/db/cxx/cxx_table.cpp b/db/cxx/cxx_table.cpp
deleted file mode 100644
index b7b335d26..000000000
--- a/db/cxx/cxx_table.cpp
+++ /dev/null
@@ -1,808 +0,0 @@
-/*-
- * See the file LICENSE for redistribution information.
- *
- * Copyright (c) 1997, 1998, 1999, 2000
- *	Sleepycat Software.  All rights reserved.
- */
-
-#include "db_config.h"
-
-#ifndef lint
-static const char revid[] = "$Id: cxx_table.cpp,v 11.35 2001/01/11 18:19:49 bostic Exp $";
-#endif /* not lint */
-
-#include <errno.h>
-#include <string.h>
-
-#include "db_cxx.h"
-#include "cxx_int.h"
-
-#include "db_int.h"
-#include "db_page.h"
-#include "db_ext.h"
-#include "common_ext.h"
-
-////////////////////////////////////////////////////////////////////////
-//                                                                    //
-//                            Db                                      //
-//                                                                    //
-////////////////////////////////////////////////////////////////////////
-
-// A truism for the DbEnv object is that there is a valid
-// DB_ENV handle from the constructor until close().
-// After the close, the DB handle is invalid and
-// no operations are permitted on the Db (other than
-// destructor).  Leaving the Db handle open and not
-// doing a close is generally considered an error.
-//
-// We used to allow Db objects to be closed and reopened.
-// This implied always keeping a valid DB object, and
-// coordinating the open objects between Db/DbEnv turned
-// out to be overly complicated.  Now we do not allow this.
-
-Db::Db(DbEnv *env, u_int32_t flags)
-:	imp_(0)
-,	env_(env)
-,	construct_error_(0)
-,	flags_(0)
-,	construct_flags_(flags)
-{
-	if (env_ == 0)
-		flags_ |= DB_CXX_PRIVATE_ENV;
-	initialize();
-}
-
-// Note: if the user has not closed, we call _destroy_check
-// to warn against this non-safe programming practice.
-// We can't close, because the environment may already
-// be closed/destroyed.
-//
-Db::~Db()
-{
-	DB *db;
-
-	db = unwrap(this);
-	if (db != NULL) {
-		DbEnv::_destroy_check("Db", 0);
-		cleanup();
-	}
-}
-
-// private method to initialize during constructor.
-// initialize must create a backing DB object,
-// and if that creates a new DB_ENV, it must be tied to a new DbEnv.
-// If there is an error, construct_error_ is set; this is examined
-// during open.
-//
-int Db::initialize()
-{
-	u_int32_t cxx_flags;
-	DB *db;
-	int err;
-	DB_ENV *cenv = unwrap(env_);
-
-	cxx_flags = construct_flags_ & DB_CXX_NO_EXCEPTIONS;
-
-	// Create a new underlying DB object.
-	// We rely on the fact that if a NULL DB_ENV* is given,
-	// one is allocated by DB.
-	//
-	if ((err = db_create(&db, cenv,
-			     construct_flags_ & ~cxx_flags)) != 0) {
-		construct_error_ = err;
-		return (err);
-	}
-
-	// Associate the DB with this object
-	imp_ = wrap(db);
-	db->cj_internal = this;
-
-	// Create a new DbEnv from a DB_ENV* if it was created locally.
-	// It is deleted in Db::close().
-	//
-	if ((flags_ & DB_CXX_PRIVATE_ENV) != 0)
-		env_ = new DbEnv(db->dbenv, cxx_flags);
-
-	return (0);
-}
-
-// private method to cleanup after destructor or during close.
-// If the environment was created by this Db object, we optionally
-// delete it, or return it so the caller can delete it after
-// last use.
-//
-void Db::cleanup()
-{
-	DB *db = unwrap(this);
-
-	if (db != NULL) {
-		// extra safety
-		db->cj_internal = 0;
-		imp_ = 0;
-
-		// we must dispose of the DbEnv object if
-		// we created it.  This will be the case
-		// if a NULL DbEnv was passed into the constructor.
-		// The underlying DB_ENV object will be inaccessible
-		// after the close, so we must clean it up now.
-		//
-		if ((flags_ & DB_CXX_PRIVATE_ENV) != 0) {
-			env_->cleanup();
-			delete env_;
-			env_ = 0;
-		}
-	}
-	construct_error_ = 0;
-}
-
-// Return a tristate value corresponding to whether we should
-// throw exceptions on errors:
-//   ON_ERROR_RETURN
-//   ON_ERROR_THROW
-//   ON_ERROR_UNKNOWN
-//
-int Db::error_policy()
-{
-	if (env_ != NULL)
-		return (env_->error_policy());
-	else {
-		// If the env_ is null, that means that the user
-		// did not attach an environment, so the correct error
-		// policy can be deduced from constructor flags
-		// for this Db.
-		//
-		if ((construct_flags_ & DB_CXX_NO_EXCEPTIONS) != 0) {
-			return (ON_ERROR_RETURN);
-		}
-		else {
-			return (ON_ERROR_THROW);
-		}
-	}
-}
-
-int Db::close(u_int32_t flags)
-{
-	DB *db = unwrap(this);
-	int err;
-
-	// after a DB->close (no matter if success or failure),
-	// the underlying DB object must not be accessed,
-	// so we clean up in advance.
-	//
-	cleanup();
-
-	// It's safe to throw an error after the close,
-	// since our error mechanism does not peer into
-	// the DB* structures.
-	//
-	if ((err = db->close(db, flags)) != 0 && err != DB_INCOMPLETE)
-		DB_ERROR("Db::close", err, error_policy());
-
-	return (err);
-}
-
-int Db::cursor(DbTxn *txnid, Dbc **cursorp, u_int32_t flags)
-{
-	DB *db = unwrap(this);
-	DBC *dbc = 0;
-	int err;
-
-	if ((err = db->cursor(db, unwrap(txnid), &dbc, flags)) != 0) {
-		DB_ERROR("Db::cursor", err, error_policy());
-		return (err);
-	}
-
-	// The following cast implies that Dbc can be no larger than DBC
-	*cursorp = (Dbc*)dbc;
-	return (0);
-}
-
-int Db::del(DbTxn *txnid, Dbt *key, u_int32_t flags)
-{
-	DB *db = unwrap(this);
-	int err;
-
-	if ((err = db->del(db, unwrap(txnid), key, flags)) != 0) {
-		// DB_NOTFOUND is a "normal" return, so should not be
-		// thrown as an error
-		//
-		if (err != DB_NOTFOUND) {
-			DB_ERROR("Db::del", err, error_policy());
-			return (err);
-		}
-	}
-	return (err);
-}
-
-void Db::err(int error, const char *format, ...)
-{
-	va_list args;
-	DB *db = unwrap(this);
-
-	va_start(args, format);
-	__db_real_err(db->dbenv, error, 1, 1, format, args);
-	va_end(args);
-}
-
-void Db::errx(const char *format, ...)
-{
-	va_list args;
-	DB *db = unwrap(this);
-
-	va_start(args, format);
-	__db_real_err(db->dbenv, 0, 0, 1, format, args);
-	va_end(args);
-}
-
-int Db::fd(int *fdp)
-{
-	DB *db = unwrap(this);
-	int err;
-
-	if ((err = db->fd(db, fdp)) != 0) {
-		DB_ERROR("Db::fd", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-// This is a 'glue' function declared as extern "C" so it will
-// be compatible with picky compilers that do not allow mixing
-// of function pointers to 'C' functions with function pointers
-// to C++ functions.
-//
-extern "C"
-void _db_feedback_intercept_c(DB *db, int opcode, int pct)
-{
-	Db::_feedback_intercept(db, opcode, pct);
-}
-
-//static
-void Db::_feedback_intercept(DB *db, int opcode, int pct)
-{
-	if (db == 0) {
-		DB_ERROR("Db::feedback_callback", EINVAL, ON_ERROR_UNKNOWN);
-		return;
-	}
-	Db *cxxdb = (Db *)db->cj_internal;
-	if (cxxdb == 0) {
-		DB_ERROR("Db::feedback_callback", EINVAL, ON_ERROR_UNKNOWN);
-		return;
-	}
-	if (cxxdb->feedback_callback_ == 0) {
-		DB_ERROR("Db::feedback_callback", EINVAL, cxxdb->error_policy());
-		return;
-	}
-	(*cxxdb->feedback_callback_)(cxxdb, opcode, pct);
-}
-
-int Db::set_feedback(void (*arg)(Db *, int, int))
-{
-	DB *db = unwrap(this);
-
-	feedback_callback_ = arg;
-
-	return ((*(db->set_feedback))(db, _db_feedback_intercept_c));
-}
-
-// This is a 'glue' function declared as extern "C" so it will
-// be compatible with picky compilers that do not allow mixing
-// of function pointers to 'C' functions with function pointers
-// to C++ functions.
-//
-extern "C"
-int _db_append_recno_intercept_c(DB *db, DBT *data, db_recno_t recno)
-{
-	return (Db::_append_recno_intercept(db, data, recno));
-}
-
-//static
-int Db::_append_recno_intercept(DB *db, DBT *data, db_recno_t recno)
-{
-	int err;
-
-	if (db == 0) {
-		DB_ERROR("Db::append_recno_callback", EINVAL, ON_ERROR_UNKNOWN);
-		return (EINVAL);
-	}
-	Db *cxxdb = (Db *)db->cj_internal;
-	if (cxxdb == 0) {
-		DB_ERROR("Db::append_recno_callback", EINVAL, ON_ERROR_UNKNOWN);
-		return (EINVAL);
-	}
-	if (cxxdb->append_recno_callback_ == 0) {
-		DB_ERROR("Db::append_recno_callback", EINVAL, cxxdb->error_policy());
-		return (EINVAL);
-	}
-
-	// making these copies is slow but portable.
-	// Another alternative is to cast the DBT* manufactured
-	// by the C layer to a Dbt*.  It 'should be' safe since
-	// Dbt is a thin shell over DBT, adding no extra data,
-	// but is nonportable, and could lead to errors if anything
-	// were added to the Dbt class.
-	//
-	Dbt cxxdbt;
-	memcpy((DBT *)&cxxdbt, data, sizeof(DBT));
-	err = (*cxxdb->append_recno_callback_)(cxxdb, &cxxdbt, recno);
-	memcpy(data, (DBT *)&cxxdbt, sizeof(DBT));
-	return (err);
-}
-
-int Db::set_append_recno(int (*arg)(Db *, Dbt *, db_recno_t))
-{
-	DB *db = unwrap(this);
-
-	append_recno_callback_ = arg;
-
-	return ((*(db->set_append_recno))(db, _db_append_recno_intercept_c));
-}
-
-int Db::get(DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags)
-{
-	DB *db = unwrap(this);
-	int err;
-
-	if ((err = db->get(db, unwrap(txnid), key, value, flags)) != 0) {
-		// DB_NOTFOUND and DB_KEYEMPTY are "normal" returns,
-		// so should not be thrown as an error
-		//
-		if (err != DB_NOTFOUND && err != DB_KEYEMPTY) {
-			DB_ERROR("Db::get", err, error_policy());
-			return (err);
-		}
-	}
-	return (err);
-}
-
-int Db::get_byteswapped() const
-{
-	DB *db = (DB *)unwrapConst(this);
-	return (db->get_byteswapped(db));
-}
-
-DBTYPE Db::get_type() const
-{
-	DB *db = (DB *)unwrapConst(this);
-	return ((DBTYPE)db->get_type(db));
-}
-
-int Db::join(Dbc **curslist, Dbc **cursorp, u_int32_t flags)
-{
-	// Dbc is a "compatible" subclass of DBC -
-	// that is, no virtual functions or even extra data members,
-	// so this cast, although technically non-portable,
-	// "should" always be okay.
-	//
-	DBC **list = (DBC **)(curslist);
-	DB *db = unwrap(this);
-	DBC *dbc = 0;
-	int err;
-
-	if ((err = db->join(db, list, &dbc, flags)) != 0) {
-		DB_ERROR("Db::join_cursor", err, error_policy());
-		return (err);
-	}
-	*cursorp = (Dbc*)dbc;
-	return (0);
-}
-
-int Db::key_range(DbTxn *txnid, Dbt *key,
-		  DB_KEY_RANGE *results, u_int32_t flags)
-{
-	DB *db = unwrap(this);
-	int err;
-
-	if ((err = db->key_range(db, unwrap(txnid), key,
-				 results, flags)) != 0) {
-		DB_ERROR("Db::key_range", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-// If an error occurred during the constructor, report it now.
-// Otherwise, call the underlying DB->open method.
-//
-int Db::open(const char *file, const char *database,
-	     DBTYPE type, u_int32_t flags, int mode)
-{
-	int err;
-	DB *db = unwrap(this);
-
-	if ((err = construct_error_) != 0)
-		DB_ERROR("Db::open", construct_error_, error_policy());
-	else if ((err = db->open(db, file, database, type, flags, mode)) != 0)
-		DB_ERROR("Db::open", err, error_policy());
-
-	return (err);
-}
-
-int Db::put(DbTxn *txnid, Dbt *key, Dbt *value, u_int32_t flags)
-{
-	int err;
-	DB *db = unwrap(this);
-
-	if ((err = db->put(db, unwrap(txnid), key, value, flags)) != 0) {
-
-		// DB_KEYEXIST is a "normal" return, so should not be
-		// thrown as an error
-		//
-		if (err != DB_KEYEXIST) {
-			DB_ERROR("Db::put", err, error_policy());
-			return (err);
-		}
-	}
-	return (err);
-}
-
-int Db::rename(const char *file, const char *database,
-	       const char *newname, u_int32_t flags)
-{
-	int err = 0;
-	DB *db = unwrap(this);
-
-	if (!db) {
-		DB_ERROR("Db::rename", EINVAL, error_policy());
-		return (EINVAL);
-	}
-
-	// after a DB->rename (no matter if success or failure),
-	// the underlying DB object must not be accessed,
-	// so we clean up in advance.
-	//
-	cleanup();
-
-	if ((err = db->rename(db, file, database, newname, flags)) != 0) {
-		DB_ERROR("Db::rename", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int Db::remove(const char *file, const char *database, u_int32_t flags)
-{
-	int err = 0;
-	DB *db = unwrap(this);
-
-	if (!db) {
-		DB_ERROR("Db::remove", EINVAL, error_policy());
-		return (EINVAL);
-	}
-
-	// after a DB->remove (no matter if success or failure),
-	// the underlying DB object must not be accessed,
-	// so we clean up in advance.
-	//
-	cleanup();
-
-	if ((err = db->remove(db, file, database, flags)) != 0)
-		DB_ERROR("Db::remove", err, error_policy());
-
-	return (err);
-}
-
-int Db::stat(void *sp, db_malloc_fcn_type db_malloc_fcn, u_int32_t flags)
-{
-	int err;
-	DB *db = unwrap(this);
-
-	if (!db) {
-		DB_ERROR("Db::stat", EINVAL, error_policy());
-		return (EINVAL);
-	}
-	if ((err = db->stat(db, sp, db_malloc_fcn, flags)) != 0) {
-		DB_ERROR("Db::stat", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-int Db::sync(u_int32_t flags)
-{
-	int err;
-	DB *db = unwrap(this);
-
-	if (!db) {
-		DB_ERROR("Db::sync", EINVAL, error_policy());
-		return (EINVAL);
-	}
-	if ((err = db->sync(db, flags)) != 0 && err != DB_INCOMPLETE) {
-		DB_ERROR("Db::sync", err, error_policy());
-		return (err);
-	}
-	return (err);
-}
-
-int Db::upgrade(const char *name, u_int32_t flags)
-{
-	int err;
-	DB *db = unwrap(this);
-
-	if (!db) {
-		DB_ERROR("Db::upgrade", EINVAL, error_policy());
-		return (EINVAL);
-	}
-	if ((err = db->upgrade(db, name, flags)) != 0) {
-		DB_ERROR("Db::upgrade", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-static int _verify_callback_cxx(void *handle, const void *str_arg)
-{
-	char *str;
-	ostream *out;
-
-	str = (char *)str_arg;
-	out = (ostream *)handle;
-
-	(*out) << str;
-	if (out->fail())
-		return (EIO);
-
-	return (0);
-}
-
-// This is a 'glue' function declared as extern "C" so it will
-// be compatible with picky compilers that do not allow mixing
-// of function pointers to 'C' functions with function pointers
-// to C++ functions.
-//
-extern "C"
-int _verify_callback_c(void *handle, const void *str_arg)
-{
-	return (_verify_callback_cxx(handle, str_arg));
-}
-
-int Db::verify(const char *name, const char *subdb,
-	       ostream *ostr, u_int32_t flags)
-{
-	int err;
-	DB *db = unwrap(this);
-
-	if (!db) {
-		DB_ERROR("Db::verify", EINVAL, error_policy());
-		return (EINVAL);
-	}
-	if ((err = __db_verify_internal(db, name, subdb, ostr,
-					_verify_callback_c, flags)) != 0) {
-		DB_ERROR("Db::verify", err, error_policy());
-		return (err);
-	}
-	return (0);
-}
-
-// This is a variant of the DB_WO_ACCESS macro to define a simple set_
-// method calling the underlying C method, but unlike a simple
-// set method, it may return an error or raise an exception.
-// Note this macro expects that input _argspec is an argument
-// list element (e.g. "char *arg") defined in terms of "arg".
-//
-#define	DB_DB_ACCESS(_name, _argspec)                          \
-\
-int Db::set_##_name(_argspec)                                  \
-{                                                              \
-	int ret;                                               \
-	DB *db = unwrap(this);                                 \
-							       \
-	if ((ret = (*(db->set_##_name))(db, arg)) != 0) {      \
-		DB_ERROR("Db::set_" # _name, ret, error_policy()); \
-	}                                                      \
-	return (ret);                                          \
-}
-
-#define	DB_DB_ACCESS_NORET(_name, _argspec)                    \
-							       \
-void Db::set_##_name(_argspec)                                 \
-{                                                              \
-	DB *db = unwrap(this);                                 \
-							       \
-	(*(db->set_##_name))(db, arg);                         \
-	return;                                                \
-}
-
-DB_DB_ACCESS(bt_compare, bt_compare_fcn_type arg)
-DB_DB_ACCESS(bt_maxkey, u_int32_t arg)
-DB_DB_ACCESS(bt_minkey, u_int32_t arg)
-DB_DB_ACCESS(bt_prefix, bt_prefix_fcn_type arg)
-DB_DB_ACCESS(dup_compare, dup_compare_fcn_type arg)
-DB_DB_ACCESS_NORET(errfile, FILE *arg)
-DB_DB_ACCESS_NORET(errpfx, const char *arg)
-DB_DB_ACCESS(flags, u_int32_t arg)
-DB_DB_ACCESS(h_ffactor, u_int32_t arg)
-DB_DB_ACCESS(h_hash, h_hash_fcn_type arg)
-DB_DB_ACCESS(h_nelem, u_int32_t arg)
-DB_DB_ACCESS(lorder, int arg)
-DB_DB_ACCESS(malloc, db_malloc_fcn_type arg)
-DB_DB_ACCESS(pagesize, u_int32_t arg)
-DB_DB_ACCESS(realloc, db_realloc_fcn_type arg)
-DB_DB_ACCESS(re_delim, int arg)
-DB_DB_ACCESS(re_len, u_int32_t arg)
-DB_DB_ACCESS(re_pad, int arg)
-DB_DB_ACCESS(re_source, char *arg)
-DB_DB_ACCESS(q_extentsize, u_int32_t arg)
-
-// Here are the set methods that don't fit the above mold.
-//
-
-void Db::set_errcall(void (*arg)(const char *, char *))
-{
-	env_->set_errcall(arg);
-}
-
-int Db::set_cachesize(u_int32_t gbytes, u_int32_t bytes, int ncache)
-{
-	int ret;
-	DB *db = unwrap(this);
-
-	if ((ret = (*(db->set_cachesize))(db, gbytes, bytes, ncache)) != 0) {
-		DB_ERROR("Db::set_cachesize", ret, error_policy());
-	}
-	return (ret);
-}
-
-int Db::set_paniccall(void (*callback)(DbEnv *, int))
-{
-	return (env_->set_paniccall(callback));
-}
-
-void Db::set_error_stream(ostream *error_stream)
-{
-	env_->set_error_stream(error_stream);
-}
-
-////////////////////////////////////////////////////////////////////////
-//                                                                    //
-//                            Dbc                                     //
-//                                                                    //
-////////////////////////////////////////////////////////////////////////
-
-// It's private, and should never be called, but VC4.0 needs it resolved
-//
-Dbc::~Dbc()
-{
-}
-
-int Dbc::close()
-{
-	DBC *cursor = this;
-	int err;
-
-	if ((err = cursor->c_close(cursor)) != 0) {
-		DB_ERROR("Db::close", err, ON_ERROR_UNKNOWN);
-		return (err);
-	}
-	return (0);
-}
-
-int Dbc::count(db_recno_t *countp, u_int32_t flags_arg)
-{
-	DBC *cursor = this;
-	int err;
-
-	if ((err = cursor->c_count(cursor, countp, flags_arg)) != 0) {
-		DB_ERROR("Db::count", err, ON_ERROR_UNKNOWN);
-		return (err);
-	}
-	return (0);
-}
-
-int Dbc::del(u_int32_t flags_arg)
-{
-	DBC *cursor = this;
-	int err;
-
-	if ((err = cursor->c_del(cursor, flags_arg)) != 0) {
-
-		// DB_KEYEMPTY is a "normal" return, so should not be
-		// thrown as an error
-		//
-		if (err != DB_KEYEMPTY) {
-			DB_ERROR("Db::del", err, ON_ERROR_UNKNOWN);
-			return (err);
-		}
-	}
-	return (err);
-}
-
-int Dbc::dup(Dbc** cursorp, u_int32_t flags_arg)
-{
-	DBC *cursor = this;
-	DBC *new_cursor = 0;
-	int err;
-
-	if ((err = cursor->c_dup(cursor, &new_cursor, flags_arg)) != 0) {
-		DB_ERROR("Db::dup", err, ON_ERROR_UNKNOWN);
-		return (err);
-	}
-
-	// The following cast implies that Dbc can be no larger than DBC
-	*cursorp = (Dbc*)new_cursor;
-	return (0);
-}
-
-int Dbc::get(Dbt* key, Dbt *data, u_int32_t flags_arg)
-{
-	DBC *cursor = this;
-	int err;
-
-	if ((err = cursor->c_get(cursor, key, data, flags_arg)) != 0) {
-
-		// DB_NOTFOUND and DB_KEYEMPTY are "normal" returns,
-		// so should not be thrown as an error
-		//
-		if (err != DB_NOTFOUND && err != DB_KEYEMPTY) {
-			DB_ERROR("Db::get", err, ON_ERROR_UNKNOWN);
-			return (err);
-		}
-	}
-	return (err);
-}
-
-int Dbc::put(Dbt* key, Dbt *data, u_int32_t flags_arg)
-{
-	DBC *cursor = this;
-	int err;
-
-	if ((err = cursor->c_put(cursor, key, data, flags_arg)) != 0) {
-
-		// DB_KEYEXIST is a "normal" return, so should not be
-		// thrown as an error
-		//
-		if (err != DB_KEYEXIST) {
-			DB_ERROR("Db::put", err, ON_ERROR_UNKNOWN);
-			return (err);
-		}
-	}
-	return (err);
-}
-
-////////////////////////////////////////////////////////////////////////
-//                                                                    //
-//                            Dbt                                 //
-//                                                                    //
-////////////////////////////////////////////////////////////////////////
-
-Dbt::Dbt()
-{
-	DBT *dbt = this;
-	memset(dbt, 0, sizeof(DBT));
-}
-
-Dbt::Dbt(void *data_arg, size_t size_arg)
-{
-	DBT *dbt = this;
-	memset(dbt, 0, sizeof(DBT));
-	set_data(data_arg);
-	set_size(size_arg);
-}
-
-Dbt::~Dbt()
-{
-}
-
-Dbt::Dbt(const Dbt &that)
-{
-	const DBT *from = &that;
-	DBT *to = this;
-	memcpy(to, from, sizeof(DBT));
-}
-
-Dbt &Dbt::operator = (const Dbt &that)
-{
-	if (this != &that) {
-		const DBT *from = &that;
-		DBT *to = this;
-		memcpy(to, from, sizeof(DBT));
-	}
-	return (*this);
-}
-
-DB_RW_ACCESS(Dbt, void *, data, data)
-DB_RW_ACCESS(Dbt, u_int32_t, size, size)
-DB_RW_ACCESS(Dbt, u_int32_t, ulen, ulen)
-DB_RW_ACCESS(Dbt, u_int32_t, dlen, dlen)
-DB_RW_ACCESS(Dbt, u_int32_t, doff, doff)
-DB_RW_ACCESS(Dbt, u_int32_t, flags, flags)
diff --git a/db/cxx/cxx_txn.cpp b/db/cxx/cxx_txn.cpp
index 6456e3461..cb0995d15 100644
--- a/db/cxx/cxx_txn.cpp
+++ b/db/cxx/cxx_txn.cpp
@@ -1,10 +1,9 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1997-2006
- *	Oracle Corporation.  All rights reserved.
+ * Copyright (c) 1997,2007 Oracle.  All rights reserved.
  *
- * $Id: cxx_txn.cpp,v 12.5 2006/08/24 14:45:13 bostic Exp $
+ * $Id: cxx_txn.cpp,v 12.7 2007/05/17 15:14:56 bostic Exp $
  */
 
 #include "db_config.h"
diff --git a/db/cxx/namemap.txt b/db/cxx/namemap.txt
deleted file mode 100644
index 752077185..000000000
--- a/db/cxx/namemap.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-$Id: namemap.txt,v 10.4 2000/02/19 20:57:54 bostic Exp $
-
-The bulk of DB provides for wrapper classes and appropriately named methods
-that call into DB.  For the most part, there is a straightforward mapping of
-names.  For the purposes of referencing documentation, this chart shows the
-underlying C structure name for each C++ class.  In some cases, using the
-given C prefix with a C++ method name gives the underlying C function name.
-For example, DbMpoolFile::close() is implemented by memp_fclose().
-
-C++                          C                       C prefix
-
-Db                          DB
-DbEnv                       DB_ENV
-Dbc                         DBC
-DbException                 none
-DbInfo                      DB_INFO
-DbLock                      DB_LOCK                  lock_
-DbLsn                       DB_LSN
-DbMpoolFile                 DB_MPOOL_FILE            memp_
-Dbt                         DBT
-DbTxn                       DB_TXN                   txn_