Import changeset

8 files changed, 2198 insertions, 0 deletions

diff --git a/bdb/cxx/cxx_app.cpp b/bdb/cxx/cxx_app.cpp
new file mode 100644
index 00000000000..1fcf04b5c43
--- /dev/null
+++ b/bdb/cxx/cxx_app.cpp
@@ -0,0 +1,671 @@
+/*-
+ * 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/bdb/cxx/cxx_except.cpp b/bdb/cxx/cxx_except.cpp
new file mode 100644
index 00000000000..a62e21a767d
--- /dev/null
+++ b/bdb/cxx/cxx_except.cpp
@@ -0,0 +1,132 @@
+/*-
+ * 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_except.cpp,v 11.7 2000/09/21 15:05:45 dda Exp $";
+#endif /* not lint */
+
+#include <string.h>
+
+#include "db_cxx.h"
+#include "cxx_int.h"
+
+// tmpString is used to create strings on the stack
+//
+class tmpString
+{
+public:
+	tmpString(const char *str1,
+		  const char *str2 = 0,
+		  const char *str3 = 0,
+		  const char *str4 = 0,
+		  const char *str5 = 0)
+	{
+		int len = strlen(str1);
+		if (str2)
+			len += strlen(str2);
+		if (str3)
+			len += strlen(str3);
+		if (str4)
+			len += strlen(str4);
+		if (str5)
+			len += strlen(str5);
+
+		s_ = new char[len+1];
+
+		strcpy(s_, str1);
+		if (str2)
+			strcat(s_, str2);
+		if (str3)
+			strcat(s_, str3);
+		if (str4)
+			strcat(s_, str4);
+		if (str5)
+			strcat(s_, str5);
+	}
+	~tmpString()                      { delete [] s_; }
+	operator const char *()           { return (s_); }
+
+private:
+	char *s_;
+};
+
+// Note: would not be needed if we can inherit from exception
+// It does not appear to be possible to inherit from exception
+// with the current Microsoft library (VC5.0).
+//
+static char *dupString(const char *s)
+{
+	char *r = new char[strlen(s)+1];
+	strcpy(r, s);
+	return (r);
+}
+
+////////////////////////////////////////////////////////////////////////
+//                                                                    //
+//                            DbException                             //
+//                                                                    //
+////////////////////////////////////////////////////////////////////////
+
+DbException::~DbException()
+{
+	if (what_)
+		delete [] what_;
+}
+
+DbException::DbException(int err)
+:	err_(err)
+{
+	what_ = dupString(db_strerror(err));
+}
+
+DbException::DbException(const char *description)
+:	err_(0)
+{
+	what_ = dupString(tmpString(description));
+}
+
+DbException::DbException(const char *prefix, int err)
+:	err_(err)
+{
+	what_ = dupString(tmpString(prefix, ": ", db_strerror(err)));
+}
+
+DbException::DbException(const char *prefix1, const char *prefix2, int err)
+:	err_(err)
+{
+	what_ = dupString(tmpString(prefix1, ": ", prefix2, ": ", db_strerror(err)));
+}
+
+DbException::DbException(const DbException &that)
+:	err_(that.err_)
+{
+	what_ = dupString(that.what_);
+}
+
+DbException &DbException::operator = (const DbException &that)
+{
+	if (this != &that) {
+		err_ = that.err_;
+		if (what_)
+			delete [] what_;
+		what_ = 0;           // in case new throws exception
+		what_ = dupString(that.what_);
+	}
+	return (*this);
+}
+
+int DbException::get_errno() const
+{
+	return (err_);
+}
+
+const char *DbException::what() const
+{
+	return (what_);
+}
diff --git a/bdb/cxx/cxx_lock.cpp b/bdb/cxx/cxx_lock.cpp
new file mode 100644
index 00000000000..e8ce2aa9d30
--- /dev/null
+++ b/bdb/cxx/cxx_lock.cpp
@@ -0,0 +1,125 @@
+/*-
+ * 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_lock.cpp,v 11.9 2000/09/21 15:05:45 dda Exp $";
+#endif /* not lint */
+
+#include <errno.h>
+#include <string.h>
+
+#include "db_cxx.h"
+#include "cxx_int.h"
+
+int DbEnv::lock_detect(u_int32_t flags, u_int32_t atype, int *aborted)
+{
+	DB_ENV *env = unwrap(this);
+	int err;
+
+	if ((err = ::lock_detect(env, flags, atype, aborted)) != 0) {
+		DB_ERROR("DbEnv::lock_detect", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::lock_get(u_int32_t locker, u_int32_t flags, const Dbt *obj,
+		    db_lockmode_t lock_mode, DbLock *lock)
+{
+	DB_ENV *env = unwrap(this);
+	int err;
+
+	if ((err = ::lock_get(env, locker, flags, obj,
+			      lock_mode, &lock->lock_)) != 0) {
+		DB_ERROR("DbEnv::lock_get", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::lock_id(u_int32_t *idp)
+{
+	DB_ENV *env = unwrap(this);
+	int err;
+
+	if ((err = ::lock_id(env, idp)) != 0) {
+		DB_ERROR("DbEnv::lock_id", err, error_policy());
+	}
+	return (err);
+}
+
+int DbEnv::lock_stat(DB_LOCK_STAT **statp,
+		     db_malloc_fcn_type db_malloc_fcn)
+{
+	DB_ENV *env = unwrap(this);
+	int err;
+
+	if ((err = ::lock_stat(env, statp, db_malloc_fcn)) != 0) {
+		DB_ERROR("DbEnv::lock_stat", err, error_policy());
+		return (err);
+	}
+	return (0);
+}
+
+int DbEnv::lock_vec(u_int32_t locker, u_int32_t flags,
+		    DB_LOCKREQ list[],
+		    int nlist, DB_LOCKREQ **elist_returned)
+{
+	DB_ENV *env = unwrap(this);
+	int err;
+
+	if ((err = ::lock_vec(env, locker, flags, list,
+			      nlist, elist_returned)) != 0) {
+		DB_ERROR("DbEnv::lock_vec", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+////////////////////////////////////////////////////////////////////////
+//                                                                    //
+//                            DbLock                                  //
+//                                                                    //
+////////////////////////////////////////////////////////////////////////
+
+DbLock::DbLock(DB_LOCK value)
+:	lock_(value)
+{
+}
+
+DbLock::DbLock()
+{
+	memset(&lock_, 0, sizeof(DB_LOCK));
+}
+
+DbLock::DbLock(const DbLock &that)
+:	lock_(that.lock_)
+{
+}
+
+DbLock &DbLock::operator = (const DbLock &that)
+{
+	lock_ = that.lock_;
+	return (*this);
+}
+
+int DbLock::put(DbEnv *env)
+{
+	DB_ENV *envp = unwrap(env);
+
+	if (!env) {
+		return (EINVAL);        // handle never assigned
+	}
+
+	int err;
+	if ((err = lock_put(envp, &lock_)) != 0) {
+		DB_ERROR("DbLock::put", err, env->error_policy());
+	}
+	return (err);
+}
diff --git a/bdb/cxx/cxx_log.cpp b/bdb/cxx/cxx_log.cpp
new file mode 100644
index 00000000000..336b9d337f0
--- /dev/null
+++ b/bdb/cxx/cxx_log.cpp
@@ -0,0 +1,125 @@
+/*-
+ * 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/bdb/cxx/cxx_mpool.cpp b/bdb/cxx/cxx_mpool.cpp
new file mode 100644
index 00000000000..22f4735e333
--- /dev/null
+++ b/bdb/cxx/cxx_mpool.cpp
@@ -0,0 +1,180 @@
+/*-
+ * 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_mpool.cpp,v 11.11 2000/09/21 15:05:45 dda Exp $";
+#endif /* not lint */
+
+#include <errno.h>
+
+#include "db_cxx.h"
+#include "cxx_int.h"
+
+////////////////////////////////////////////////////////////////////////
+//                                                                    //
+//                            DbMpoolFile                             //
+//                                                                    //
+////////////////////////////////////////////////////////////////////////
+
+DbMpoolFile::DbMpoolFile()
+:	imp_(0)
+{
+}
+
+DbMpoolFile::~DbMpoolFile()
+{
+}
+
+int DbMpoolFile::open(DbEnv *envp, const char *file,
+		      u_int32_t flags, int mode, size_t pagesize,
+		      DB_MPOOL_FINFO *finfop, DbMpoolFile **result)
+{
+	int err;
+
+	DB_MPOOLFILE *mpf;
+	DB_ENV *env = unwrap(envp);
+
+	if ((err = ::memp_fopen(env, file, flags, mode, pagesize,
+				finfop, &mpf)) != 0) {
+		DB_ERROR("DbMpoolFile::open", err, envp->error_policy());
+		return (err);
+	}
+	*result = new DbMpoolFile();
+	(*result)->imp_ = wrap(mpf);
+	return (0);
+}
+
+int DbMpoolFile::close()
+{
+	DB_MPOOLFILE *mpf = unwrap(this);
+	int err = 0;
+	if (!mpf) {
+		err = EINVAL;
+	}
+	else if ((err = ::memp_fclose(mpf)) != 0) {
+		DB_ERROR("DbMpoolFile::close", err, ON_ERROR_UNKNOWN);
+		return (err);
+	}
+	imp_ = 0;                   // extra safety
+
+	// This may seem weird, but is legal as long as we don't access
+	// any data before returning.
+	//
+	delete this;
+	return (0);
+}
+
+int DbMpoolFile::get(db_pgno_t *pgnoaddr, u_int32_t flags, void *pagep)
+{
+	DB_MPOOLFILE *mpf = unwrap(this);
+	int err = 0;
+	if (!mpf) {
+		err = EINVAL;
+	}
+	else if ((err = ::memp_fget(mpf, pgnoaddr, flags, pagep)) != 0) {
+		DB_ERROR("DbMpoolFile::get", err, ON_ERROR_UNKNOWN);
+	}
+	return (err);
+}
+
+int DbMpoolFile::put(void *pgaddr, u_int32_t flags)
+{
+	DB_MPOOLFILE *mpf = unwrap(this);
+	int err = 0;
+	if (!mpf) {
+		err = EINVAL;
+	}
+	else if ((err = ::memp_fput(mpf, pgaddr, flags)) != 0) {
+		DB_ERROR("DbMpoolFile::put", err, ON_ERROR_UNKNOWN);
+	}
+	return (err);
+}
+
+int DbMpoolFile::set(void *pgaddr, u_int32_t flags)
+{
+	DB_MPOOLFILE *mpf = unwrap(this);
+	int err = 0;
+	if (!mpf) {
+		err = EINVAL;
+	}
+	else if ((err = ::memp_fset(mpf, pgaddr, flags)) != 0) {
+		DB_ERROR("DbMpoolFile::set", err, ON_ERROR_UNKNOWN);
+	}
+	return (err);
+}
+
+int DbMpoolFile::sync()
+{
+	DB_MPOOLFILE *mpf = unwrap(this);
+	int err = 0;
+	if (!mpf) {
+		err = EINVAL;
+	}
+	else if ((err = ::memp_fsync(mpf)) != 0 && err != DB_INCOMPLETE) {
+		DB_ERROR("DbMpoolFile::sync", err, ON_ERROR_UNKNOWN);
+	}
+	return (err);
+}
+
+////////////////////////////////////////////////////////////////////////
+//                                                                    //
+//                            DbMpool                                 //
+//                                                                    //
+////////////////////////////////////////////////////////////////////////
+
+int DbEnv::memp_register(int ftype,
+			 pgin_fcn_type pgin_fcn,
+			 pgout_fcn_type pgout_fcn)
+{
+	DB_ENV *env = unwrap(this);
+	int err = 0;
+
+	if ((err = ::memp_register(env, ftype, pgin_fcn, pgout_fcn)) != 0) {
+		DB_ERROR("DbEnv::memp_register", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::memp_stat(DB_MPOOL_STAT **gsp, DB_MPOOL_FSTAT ***fsp,
+		     db_malloc_fcn_type db_malloc_fcn)
+{
+	DB_ENV *env = unwrap(this);
+	int err = 0;
+
+	if ((err = ::memp_stat(env, gsp, fsp, db_malloc_fcn)) != 0) {
+		DB_ERROR("DbEnv::memp_stat", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::memp_sync(DbLsn *sn)
+{
+	DB_ENV *env = unwrap(this);
+	int err = 0;
+
+	if ((err = ::memp_sync(env, sn)) != 0 && err != DB_INCOMPLETE) {
+		DB_ERROR("DbEnv::memp_sync", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::memp_trickle(int pct, int *nwrotep)
+{
+	DB_ENV *env = unwrap(this);
+	int err = 0;
+
+	if ((err = ::memp_trickle(env, pct, nwrotep)) != 0) {
+		DB_ERROR("DbEnv::memp_trickle", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
diff --git a/bdb/cxx/cxx_table.cpp b/bdb/cxx/cxx_table.cpp
new file mode 100644
index 00000000000..b7b335d26e9
--- /dev/null
+++ b/bdb/cxx/cxx_table.cpp
@@ -0,0 +1,808 @@
+/*-
+ * 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/bdb/cxx/cxx_txn.cpp b/bdb/cxx/cxx_txn.cpp
new file mode 100644
index 00000000000..0abae982644
--- /dev/null
+++ b/bdb/cxx/cxx_txn.cpp
@@ -0,0 +1,136 @@
+/*-
+ * 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_txn.cpp,v 11.13 2000/12/21 16:24:33 dda Exp $";
+#endif /* not lint */
+
+#include <errno.h>
+
+#include "db_cxx.h"
+#include "cxx_int.h"
+
+////////////////////////////////////////////////////////////////////////
+//                                                                    //
+//                            DbTxnMgr                                //
+//                                                                    //
+////////////////////////////////////////////////////////////////////////
+
+int DbEnv::txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+	DB_TXN *txn;
+
+	if ((err = ::txn_begin(env, unwrap(pid), &txn, flags)) != 0) {
+		DB_ERROR("DbEnv::txn_begin", err, error_policy());
+		return (err);
+	}
+	DbTxn *result = new DbTxn();
+	result->imp_ = wrap(txn);
+	*tid = result;
+	return (err);
+}
+
+int DbEnv::txn_checkpoint(u_int32_t kbyte, u_int32_t min, u_int32_t flags)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+	if ((err = ::txn_checkpoint(env, kbyte, min, flags)) != 0 &&
+	    err != DB_INCOMPLETE) {
+		DB_ERROR("DbEnv::txn_checkpoint", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::txn_stat(DB_TXN_STAT **statp, db_malloc_fcn_type db_malloc_fcn)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+	if ((err = ::txn_stat(env, statp, db_malloc_fcn)) != 0) {
+		DB_ERROR("DbEnv::txn_stat", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+////////////////////////////////////////////////////////////////////////
+//                                                                    //
+//                            DbTxn                                   //
+//                                                                    //
+////////////////////////////////////////////////////////////////////////
+
+DbTxn::DbTxn()
+:	imp_(0)
+{
+}
+
+DbTxn::~DbTxn()
+{
+}
+
+int DbTxn::abort()
+{
+	int err;
+	DB_TXN *txn;
+
+	txn = unwrap(this);
+	err = txn_abort(txn);
+
+	// It may seem weird to delete this, but is legal as long
+	// as we don't access any of its data before returning.
+	//
+	delete this;
+
+	if (err != 0)
+		DB_ERROR("DbTxn::abort", err, ON_ERROR_UNKNOWN);
+
+	return (err);
+}
+
+int DbTxn::commit(u_int32_t flags)
+{
+	int err;
+	DB_TXN *txn;
+
+	txn = unwrap(this);
+	err = txn_commit(txn, flags);
+
+	// It may seem weird to delete this, but is legal as long
+	// as we don't access any of its data before returning.
+	//
+	delete this;
+
+	if (err != 0)
+		DB_ERROR("DbTxn::commit", err, ON_ERROR_UNKNOWN);
+
+	return (err);
+}
+
+u_int32_t DbTxn::id()
+{
+	DB_TXN *txn;
+
+	txn = unwrap(this);
+	return (txn_id(txn));         // no error
+}
+
+int DbTxn::prepare()
+{
+	int err;
+	DB_TXN *txn;
+
+	txn = unwrap(this);
+	if ((err = txn_prepare(txn)) != 0) {
+		DB_ERROR("DbTxn::prepare", err, ON_ERROR_UNKNOWN);
+		return (err);
+	}
+	return (0);
+}
diff --git a/bdb/cxx/namemap.txt b/bdb/cxx/namemap.txt
new file mode 100644
index 00000000000..75207718577
--- /dev/null
+++ b/bdb/cxx/namemap.txt
@@ -0,0 +1,21 @@
+$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_