Initial revision

CVS patchset: 5110
CVS date: 2001/10/15 03:47:21

5 files changed, 2151 insertions, 0 deletions

diff --git a/db/cxx/cxx_db.cpp b/db/cxx/cxx_db.cpp
new file mode 100644
index 000000000..d573d48e4
--- /dev/null
+++ b/db/cxx/cxx_db.cpp
@@ -0,0 +1,822 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997-2001
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "Id: cxx_db.cpp,v 11.49 2001/07/28 20:01:18 dda 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_auto.h"
+#include "crdel_auto.h"
+#include "db_ext.h"
+#include "common_ext.h"
+
+// A truism for the Db object is that there is a valid
+// DB 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);
+}
+
+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) {
+			const char *name = "Db::get";
+			if (err == ENOMEM && DB_OVERFLOWED_DBT(value))
+				DB_ERROR_DBT(name, value, error_policy());
+			else
+				DB_ERROR(name, err, error_policy());
+			return (err);
+		}
+	}
+	return (err);
+}
+
+int Db::get_byteswapped(int *isswapped)
+{
+	DB *db = (DB *)unwrapConst(this);
+	return (db->get_byteswapped(db, isswapped));
+}
+
+int Db::get_type(DBTYPE *dbtype)
+{
+	DB *db = (DB *)unwrapConst(this);
+	return (db->get_type(db, dbtype));
+}
+
+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::pget(DbTxn *txnid, Dbt *key, Dbt *pkey, Dbt *value, u_int32_t flags)
+{
+	DB *db = unwrap(this);
+	int err;
+
+	if ((err = db->pget(db, unwrap(txnid), key, pkey,
+			    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) {
+			const char *name = "Db::pget";
+			if (err == ENOMEM && DB_OVERFLOWED_DBT(value))
+				DB_ERROR_DBT(name, value, error_policy());
+			else
+				DB_ERROR(name, err, error_policy());
+			return (err);
+		}
+	}
+	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::truncate(DbTxn *txnid, u_int32_t *countp, u_int32_t flags)
+{
+	int err = 0;
+	DB *db = unwrap(this);
+
+	if (!db) {
+		DB_ERROR("Db::truncate", EINVAL, error_policy());
+		return (EINVAL);
+	}
+	if ((err = db->truncate(db, unwrap(txnid), countp, flags)) != 0) {
+		DB_ERROR("Db::truncate", err, error_policy());
+		return (err);
+	}
+	return (0);
+}
+
+int Db::stat(void *sp, 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, 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);
+}
+////////////////////////////////////////////////////////////////////////
+//
+// callbacks
+//
+// *_intercept_c are 'glue' functions that must be declared
+// as extern "C" so to be typesafe.  Using a C++ method, even
+// a static class method with 'correct' arguments, will not pass
+// the test; some picky compilers do not allow mixing of function
+// pointers to 'C' functions with function pointers to C++ functions.
+//
+// One wart with this scheme is that the *_callback_ method pointer
+// must be declared public to be accessible by the C intercept.
+// It's possible to accomplish the goal without this, and with
+// another public transfer method, but it's just too much overhead.
+// These callbacks are supposed to be *fast*.
+//
+// The DBTs we receive in these callbacks from the C layer may be
+// manufactured there, but we want to treat them as a Dbts.
+// Technically speaking, these DBTs were not constructed as a Dbts,
+// but it should be safe to cast them as such given that Dbt is a
+// *very* thin extension of the DBT.  That is, Dbt has no additional
+// data elements, does not use virtual functions, virtual inheritance,
+// multiple inheritance, RTI, or any other language feature that
+// causes the structure to grow or be displaced.  Although this may
+// sound risky, a design goal of C++ is complete structure
+// compatibility with C, and has the philosophy 'if you don't use it,
+// you shouldn't incur the overhead'.  If the C/C++ compilers you're
+// using on a given machine do not have matching struct layouts, then
+// a lot more things will be broken than just this.
+//
+// The alternative, creating a Dbt here in the callback, and populating
+// it from the DBT, is just too slow and cumbersome to be very useful.
+
+/* associate callback */
+extern "C" int _db_associate_intercept_c(DB *secondary,
+					 const DBT *key,
+					 const DBT *data,
+					 DBT *retval)
+{
+	Db *cxxthis;
+
+	DB_ASSERT(secondary != NULL);
+	cxxthis = (Db *)secondary->cj_internal;
+	DB_ASSERT(cxxthis != NULL);
+	DB_ASSERT(cxxthis->associate_callback_ != 0);
+
+	return (*cxxthis->associate_callback_)(cxxthis,
+					       Dbt::get_const_Dbt(key),
+					       Dbt::get_const_Dbt(data),
+					       Dbt::get_Dbt(retval));
+}
+
+int Db::associate(Db *secondary, int (*callback)(Db *, const Dbt *,
+	const Dbt *, Dbt *), u_int32_t flags)
+{
+	DB *cthis = unwrap(this);
+
+	/* Since the secondary Db is used as the first argument
+	 * to the callback, we store the C++ callback on it
+	 * rather than on 'this'.
+	 */
+	secondary->associate_callback_ = callback;
+	return ((*(cthis->associate))
+		(cthis, unwrap(secondary), _db_associate_intercept_c, flags));
+}
+
+/* feedback callback */
+extern "C" void _db_feedback_intercept_c(DB *cthis, int opcode, int pct)
+{
+	Db *cxxthis;
+
+	DB_ASSERT(cthis != NULL);
+	cxxthis = (Db *)cthis->cj_internal;
+	DB_ASSERT(cxxthis != NULL);
+	DB_ASSERT(cxxthis->feedback_callback_ != 0);
+
+	(*cxxthis->feedback_callback_)(cxxthis, opcode, pct);
+	return;
+}
+
+int Db::set_feedback(void (*arg)(Db *cxxthis, int opcode, int pct))
+{
+	DB *cthis = unwrap(this);
+	feedback_callback_ = arg;
+	return ((*(cthis->set_feedback))
+		(cthis, _db_feedback_intercept_c));
+}
+
+/* append_recno callback */
+extern "C" int _db_append_recno_intercept_c(DB *cthis, DBT *data,
+					    db_recno_t recno)
+{
+	Db *cxxthis;
+
+	DB_ASSERT(cthis != NULL);
+	cxxthis = (Db *)cthis->cj_internal;
+	DB_ASSERT(cxxthis != NULL);
+	DB_ASSERT(cxxthis->append_recno_callback_ != 0);
+
+	return (*cxxthis->append_recno_callback_)(cxxthis,
+						  Dbt::get_Dbt(data),
+						  recno);
+}
+
+int Db::set_append_recno(int (*arg)(Db *cxxthis, Dbt *data, db_recno_t recno))
+{
+	DB *cthis = unwrap(this);
+	append_recno_callback_ = arg;
+	return ((*(cthis->set_append_recno))
+		(cthis, _db_append_recno_intercept_c));
+}
+
+/* bt_compare callback */
+extern "C" int _db_bt_compare_intercept_c(DB *cthis, const DBT *data1,
+					  const DBT *data2)
+{
+	Db *cxxthis;
+
+	DB_ASSERT(cthis != NULL);
+	cxxthis = (Db *)cthis->cj_internal;
+	DB_ASSERT(cxxthis != NULL);
+	DB_ASSERT(cxxthis->bt_compare_callback_ != 0);
+
+	return (*cxxthis->bt_compare_callback_)(cxxthis,
+						Dbt::get_const_Dbt(data1),
+						Dbt::get_const_Dbt(data2));
+}
+
+int Db::set_bt_compare(int (*arg)(Db *cxxthis, const Dbt *data1,
+				  const Dbt *data2))
+{
+	DB *cthis = unwrap(this);
+	bt_compare_callback_ = arg;
+	return ((*(cthis->set_bt_compare))
+		(cthis, _db_bt_compare_intercept_c));
+}
+
+/* bt_prefix callback */
+extern "C" size_t _db_bt_prefix_intercept_c(DB *cthis, const DBT *data1,
+					    const DBT *data2)
+{
+	Db *cxxthis;
+
+	DB_ASSERT(cthis != NULL);
+	cxxthis = (Db *)cthis->cj_internal;
+	DB_ASSERT(cxxthis != NULL);
+	DB_ASSERT(cxxthis->bt_prefix_callback_ != 0);
+
+	return (*cxxthis->bt_prefix_callback_)(cxxthis,
+					       Dbt::get_const_Dbt(data1),
+					       Dbt::get_const_Dbt(data2));
+}
+
+int Db::set_bt_prefix(size_t (*arg)(Db *cxxthis, const Dbt *data1,
+				    const Dbt *data2))
+{
+	DB *cthis = unwrap(this);
+	bt_prefix_callback_ = arg;
+	return ((*(cthis->set_bt_prefix))
+		(cthis, _db_bt_prefix_intercept_c));
+}
+
+/* dup_compare callback */
+extern "C" int _db_dup_compare_intercept_c(DB *cthis, const DBT *data1,
+					   const DBT *data2)
+{
+	Db *cxxthis;
+
+	DB_ASSERT(cthis != NULL);
+	cxxthis = (Db *)cthis->cj_internal;
+	DB_ASSERT(cxxthis != NULL);
+	DB_ASSERT(cxxthis->dup_compare_callback_ != 0);
+
+	return (*cxxthis->dup_compare_callback_)(cxxthis,
+						 Dbt::get_const_Dbt(data1),
+						 Dbt::get_const_Dbt(data2));
+}
+
+int Db::set_dup_compare(int (*arg)(Db *cxxthis, const Dbt *data1,
+				   const Dbt *data2))
+{
+	DB *cthis = unwrap(this);
+	dup_compare_callback_ = arg;
+	return ((*(cthis->set_dup_compare))
+		(cthis, _db_dup_compare_intercept_c));
+}
+
+/* h_hash callback */
+extern "C" u_int32_t _db_h_hash_intercept_c(DB *cthis, const void *data,
+					    u_int32_t len)
+{
+	Db *cxxthis;
+
+	DB_ASSERT(cthis != NULL);
+	cxxthis = (Db *)cthis->cj_internal;
+	DB_ASSERT(cxxthis != NULL);
+	DB_ASSERT(cxxthis->h_hash_callback_ != 0);
+
+	return (*cxxthis->h_hash_callback_)(cxxthis, data, len);
+}
+
+int Db::set_h_hash(u_int32_t (*arg)(Db *cxxthis, const void *data,
+				    u_int32_t len))
+{
+	DB *cthis = unwrap(this);
+	h_hash_callback_ = arg;
+	return ((*(cthis->set_h_hash))
+		(cthis, _db_h_hash_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 _verify_callback_c(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);
+}
+
+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(pagesize, u_int32_t 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 get/set methods that don't fit the above mold.
+//
+
+int Db::set_alloc(db_malloc_fcn_type malloc_fcn,
+		     db_realloc_fcn_type realloc_fcn,
+		     db_free_fcn_type free_fcn)
+{
+	DB *db;
+
+	db = unwrap(this);
+	return db->set_alloc(db, malloc_fcn, realloc_fcn, free_fcn);
+}
+
+void Db::set_errcall(void (*arg)(const char *, char *))
+{
+	env_->set_errcall(arg);
+}
+
+void *Db::get_app_private() const
+{
+	return unwrapConst(this)->app_private;
+}
+
+void Db::set_app_private(void *value)
+{
+	unwrap(this)->app_private = value;
+}
+
+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);
+}
diff --git a/db/cxx/cxx_dbc.cpp b/db/cxx/cxx_dbc.cpp
new file mode 100644
index 000000000..721bfa2fc
--- /dev/null
+++ b/db/cxx/cxx_dbc.cpp
@@ -0,0 +1,157 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997-2001
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "Id: cxx_dbc.cpp,v 11.50 2001/09/29 15:48:05 dda 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_auto.h"
+#include "crdel_auto.h"
+#include "db_ext.h"
+#include "common_ext.h"
+
+// 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("Dbc::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("Dbc::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("Dbc::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) {
+			const char *name = "Dbc::get";
+			if (err == ENOMEM && DB_OVERFLOWED_DBT(key))
+				DB_ERROR_DBT(name, key, ON_ERROR_UNKNOWN);
+			else if (err == ENOMEM && DB_OVERFLOWED_DBT(data))
+				DB_ERROR_DBT(name, data, ON_ERROR_UNKNOWN);
+			else
+				DB_ERROR(name, err, ON_ERROR_UNKNOWN);
+
+			return (err);
+		}
+	}
+	return (err);
+}
+
+int Dbc::pget(Dbt* key, Dbt *pkey, Dbt *data, u_int32_t flags_arg)
+{
+	DBC *cursor = this;
+	int err;
+
+	if ((err = cursor->c_pget(cursor, key, pkey, 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) {
+			const char *name = "Dbc::pget";
+			if (err == ENOMEM && DB_OVERFLOWED_DBT(key))
+				DB_ERROR_DBT(name, key, ON_ERROR_UNKNOWN);
+			else if (err == ENOMEM && DB_OVERFLOWED_DBT(data))
+				DB_ERROR_DBT(name, data, ON_ERROR_UNKNOWN);
+			else
+				DB_ERROR(name, 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("Dbc::put", err, ON_ERROR_UNKNOWN);
+			return (err);
+		}
+	}
+	return (err);
+}
diff --git a/db/cxx/cxx_dbt.cpp b/db/cxx/cxx_dbt.cpp
new file mode 100644
index 000000000..1c06f6f38
--- /dev/null
+++ b/db/cxx/cxx_dbt.cpp
@@ -0,0 +1,60 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997-2001
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "Id: cxx_dbt.cpp,v 11.49 2001/07/28 20:01:18 dda 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_auto.h"
+#include "crdel_auto.h"
+#include "db_ext.h"
+#include "common_ext.h"
+
+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);
+}
diff --git a/db/cxx/cxx_env.cpp b/db/cxx/cxx_env.cpp
new file mode 100644
index 000000000..7c7d3ab82
--- /dev/null
+++ b/db/cxx/cxx_env.cpp
@@ -0,0 +1,1045 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997-2001
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "Id: cxx_env.cpp,v 11.58 2001/10/04 21:13:59 bostic 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"
+
+// This datatype is needed for picky compilers.
+//
+extern "C" {
+	typedef void (*db_errcall_fcn_type)
+		(const char *, char *);
+};
+
+// 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;
+
+ostream *DbEnv::error_stream_ = 0;
+
+// These 'glue' function are declared as extern "C" so they 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);
+}
+
+extern "C"
+void _paniccall_intercept_c(DB_ENV *env, int errval)
+{
+	DbEnv::_paniccall_intercept(env, errval);
+}
+
+extern "C"
+int _recovery_init_intercept_c(DB_ENV *env)
+{
+	return (DbEnv::_recovery_init_intercept(env));
+}
+
+extern "C"
+void _stream_error_function_c(const char *prefix, char *message)
+{
+	DbEnv::_stream_error_function(prefix, message);
+}
+
+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));
+}
+
+extern "C"
+int _rep_send_intercept_c(DB_ENV *env, void *cookie, const DBT *cntrl,
+			  DBT *data, u_int32_t flags, int id)
+{
+	return (DbEnv::_rep_send_intercept(env,
+	    cookie, cntrl, data, flags, id));
+}
+
+// _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";
+}
+
+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);
+}
+
+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::_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::_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::_rep_send_intercept(DB_ENV *env, void *cookie, const DBT *cntrl,
+			       DBT *data, u_int32_t flags, int id)
+{
+
+	if (env == 0) {
+		DB_ERROR("DbEnv::rep_send_callback", EINVAL, ON_ERROR_UNKNOWN);
+		return (EINVAL);
+	}
+	DbEnv *cxxenv = (DbEnv *)env->cj_internal;
+	if (cxxenv == 0) {
+		DB_ERROR("DbEnv::rep_send_callback", EINVAL, ON_ERROR_UNKNOWN);
+		return (EINVAL);
+	}
+	const Dbt *cxxcntrl = (const Dbt *)cntrl;
+	Dbt *cxxdata = (Dbt *)data;
+	return ((*cxxenv->rep_send_callback_)(cxxenv,
+	    cookie, cxxcntrl, cxxdata, flags, id));
+}
+
+// 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)
+,	rep_send_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)
+,	rep_send_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;
+
+	// 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);
+}
+
+// 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);
+	}
+}
+
+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);
+}
+
+void *DbEnv::get_app_private() const
+{
+	return unwrapConst(this)->app_private;
+}
+
+// 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);
+}
+
+int DbEnv::lock_detect(u_int32_t flags, u_int32_t atype, int *aborted)
+{
+	DB_ENV *env = unwrap(this);
+	int err;
+
+	if ((err = env->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 = env->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 = env->lock_id(env, idp)) != 0) {
+		DB_ERROR("DbEnv::lock_id", err, error_policy());
+	}
+	return (err);
+}
+
+int DbEnv::lock_id_free(u_int32_t id)
+{
+	DB_ENV *env = unwrap(this);
+	int err;
+
+	if ((err = env->lock_id_free(env, id)) != 0) {
+		DB_ERROR("DbEnv::lock_id_free", err, error_policy());
+	}
+	return (err);
+}
+
+int DbEnv::lock_stat(DB_LOCK_STAT **statp, u_int32_t flags)
+{
+	DB_ENV *env = unwrap(this);
+	int err;
+
+	if ((err = env->lock_stat(env, statp, flags)) != 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 = env->lock_vec(env, locker, flags, list,
+			      nlist, elist_returned)) != 0) {
+		DB_ERROR("DbEnv::lock_vec", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::log_archive(char **list[], u_int32_t flags)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+
+	if ((err = env->log_archive(env, list, flags)) != 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_cursor(DbLogc **cursorp, u_int32_t flags)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+	DB_LOGC *dblogc = NULL;
+
+	if ((err = env->log_cursor(env, &dblogc, flags)) != 0) {
+		DB_ERROR("DbEnv::log_cursor", err, error_policy());
+		return (err);
+	}
+
+	// The following cast implies that DbLogc can be no larger than DB_LOGC
+	*cursorp = (DbLogc*)dblogc;
+	return (0);
+}
+
+int DbEnv::log_file(DbLsn *lsn, char *namep, size_t len)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+
+	if ((err = env->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 = env->log_flush(env, lsn)) != 0) {
+		DB_ERROR("DbEnv::log_flush", 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 = env->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 = env->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, u_int32_t flags)
+{
+	int err = 0;
+	DB_ENV *env = unwrap(this);
+
+	if ((err = env->log_stat(env, spp, flags)) != 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 = env->log_unregister(env, unwrap(dbp))) != 0) {
+		DB_ERROR("DbEnv::log_unregister", err, error_policy());
+		return (err);
+	}
+	return (0);
+}
+
+int DbEnv::memp_fcreate(DbMpoolFile **dbmfp, u_int32_t flags)
+{
+	DB_ENV *env;
+	int err;
+	DB_MPOOLFILE *mpf;
+
+	env = unwrap(this);
+	if (env == NULL) {
+		err = EINVAL;
+	}
+	else if ((err = env->memp_fcreate(env, &mpf, flags)) != 0) {
+		DB_ERROR("DbMpoolFile::f_create", err, ON_ERROR_UNKNOWN);
+	}
+	else {
+		*dbmfp = new DbMpoolFile();
+		(*dbmfp)->imp_ = wrap(mpf);
+	}
+	return (err);
+}
+
+int DbEnv::memp_register(int ftype,
+			 pgin_fcn_type pgin_fcn,
+			 pgout_fcn_type pgout_fcn)
+{
+	DB_ENV *env;
+	int err;
+
+	env = unwrap(this);
+	if ((err = env->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, u_int32_t flags)
+{
+	DB_ENV *env;
+	int err;
+
+	env = unwrap(this);
+	if ((err = env->memp_stat(env, gsp, fsp, flags)) != 0) {
+		DB_ERROR("DbEnv::memp_stat", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::memp_sync(DbLsn *sn)
+{
+	DB_ENV *env;
+	int err;
+
+	env = unwrap(this);
+	if ((err = env->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;
+	int err;
+
+	env = unwrap(this);
+	if ((err = env->memp_trickle(env, pct, nwrotep)) != 0) {
+		DB_ERROR("DbEnv::memp_trickle", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+// 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;
+	}
+}
+
+// Like DbEnv::runtime_error, but issue a DbMemoryException
+// based on the fact that this Dbt is not large enough.
+void DbEnv::runtime_error_dbt(const char *caller, Dbt *dbt, 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.
+		DbMemoryException except(caller, dbt);
+		throw except;
+	}
+}
+
+// static method
+char *DbEnv::strerror(int error)
+{
+	return (db_strerror(error));
+}
+
+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";
+	}
+}
+
+// set methods
+
+// 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(lg_regionmax, 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(tmp_dir, const char *arg)
+DB_DBENV_ACCESS(tx_max, u_int32_t arg)
+
+// Here are the get/set methods that don't fit the above mold.
+//
+
+int DbEnv::set_alloc(db_malloc_fcn_type malloc_fcn,
+		     db_realloc_fcn_type realloc_fcn,
+		     db_free_fcn_type free_fcn)
+{
+	DB_ENV *dbenv;
+
+	dbenv = unwrap(this);
+	return dbenv->set_alloc(dbenv, malloc_fcn, realloc_fcn, free_fcn);
+}
+
+void DbEnv::set_app_private(void *value)
+{
+	unwrap(this)->app_private = value;
+}
+
+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);
+}
+
+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);
+}
+
+// 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);
+}
+
+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));
+}
+
+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);
+}
+
+int DbEnv::set_paniccall(void (*arg)(DbEnv *, int))
+{
+	DB_ENV *dbenv = unwrap(this);
+
+	paniccall_callback_ = arg;
+
+	return ((*(dbenv->set_paniccall))(dbenv, _paniccall_intercept_c));
+}
+
+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));
+}
+
+int DbEnv::set_rpc_server(void *cl, char *host, long tsec, long ssec, u_int32_t flags)
+{
+	int ret;
+	DB_ENV *dbenv = unwrap(this);
+
+	if ((ret = dbenv->set_rpc_server(dbenv, cl, host, tsec, ssec, flags))
+	    != 0)
+		DB_ERROR("DbEnv::set_rpc_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);
+}
+
+int DbEnv::set_tas_spins(u_int32_t arg)
+{
+	int ret;
+	DB_ENV *dbenv = unwrap(this);
+
+	if ((ret = dbenv->set_tas_spins(dbenv, arg)) != 0)
+		DB_ERROR("DbEnv::set_tas_spins", ret, last_known_error_policy);
+
+	return (ret);
+}
+
+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);
+}
+
+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);
+}
+
+int DbEnv::txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+	DB_TXN *txn;
+
+	if ((err = env->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 = env->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_recover(DB_PREPLIST *preplist, long count,
+		       long *retp, u_int32_t flags)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+	if ((err = env->txn_recover(env, preplist, count, retp, flags)) != 0) {
+		DB_ERROR("DbEnv::txn_recover", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::txn_stat(DB_TXN_STAT **statp, u_int32_t flags)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+	if ((err = env->txn_stat(env, statp, flags)) != 0) {
+		DB_ERROR("DbEnv::txn_stat", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+int DbEnv::set_rep_transport(u_int32_t myid, void *cookie,
+    int (*f_send)(DbEnv *, void *, const Dbt *, Dbt *, u_int32_t, int))
+{
+	int ret;
+	DB_ENV *dbenv = unwrap(this);
+
+	rep_send_callback_ = f_send;
+	if ((ret = dbenv->set_rep_transport(dbenv,
+	    myid, cookie, _rep_send_intercept_c)) != 0)
+		DB_ERROR("DbEnv::set_rep_transport", ret, error_policy());
+
+	return (ret);
+}
+
+int DbEnv::rep_elect(int nsites,
+    int pri, u_int32_t wait, u_int32_t sleep, int *idp, int *selfp)
+{
+	int ret;
+	DB_ENV *dbenv = unwrap(this);
+	if ((ret = dbenv->rep_elect(dbenv,
+	    nsites, pri, wait, sleep, idp, selfp)) != 0)
+		DB_ERROR("DbEnv::rep_elect", ret, error_policy());
+
+	return (ret);
+}
+
+int DbEnv::rep_process_message(Dbt *control, Dbt *rec, int *idp)
+{
+	int ret;
+	DB_ENV *dbenv = unwrap(this);
+	if ((ret = dbenv->rep_process_message(dbenv, control, rec, idp)) != 0 &&
+	    ret != DB_REP_HOLDELECTION && ret != DB_REP_NEWSITE &&
+	    ret != DB_REP_NEWMASTER && ret != DB_REP_OUTDATED)
+		DB_ERROR("DbEnv::rep_process_message", ret, error_policy());
+
+	return (ret);
+}
+
+int DbEnv::rep_start(Dbt *cookie, u_int32_t flags)
+{
+	int ret;
+	DBT *cxxcookie = (DBT *)cookie;
+	DB_ENV *dbenv = unwrap(this);
+	if ((ret = dbenv->rep_start(dbenv, cxxcookie, flags)) != 0)
+		DB_ERROR("DbEnv::rep_start", ret, error_policy());
+
+	return (ret);
+}
+
+int DbEnv::set_timeout(db_timeout_t timeout, u_int32_t flags)
+{
+	int err;
+	DB_ENV *env = unwrap(this);
+	if ((err = env->set_timeout(env, timeout, flags)) != 0) {
+		DB_ERROR("DbEnv::set_timeout", err, error_policy());
+		return (err);
+	}
+	return (err);
+}
+
+// static method
+char *DbEnv::version(int *major, int *minor, int *patch)
+{
+	return (db_version(major, minor, patch));
+}
diff --git a/db/cxx/cxx_logc.cpp b/db/cxx/cxx_logc.cpp
new file mode 100644
index 000000000..f946b2523
--- /dev/null
+++ b/db/cxx/cxx_logc.cpp
@@ -0,0 +1,67 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997-2001
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "Id: cxx_logc.cpp,v 11.2 2001/10/02 01:33:37 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_auto.h"
+#include "crdel_auto.h"
+#include "db_ext.h"
+#include "common_ext.h"
+
+// It's private, and should never be called,
+// but some compilers need it resolved
+//
+DbLogc::~DbLogc()
+{
+}
+
+int DbLogc::close(u_int32_t flags)
+{
+	DB_LOGC *cursor = this;
+	int err;
+
+	if ((err = cursor->close(cursor, flags)) != 0) {
+		DB_ERROR("DbLogc::close", err, ON_ERROR_UNKNOWN);
+		return (err);
+	}
+	return (0);
+}
+
+int DbLogc::get(DbLsn *lsn, Dbt *data, u_int32_t flags)
+{
+	DB_LOGC *cursor = this;
+	int err;
+
+	if ((err = cursor->get(cursor, lsn, data, flags)) != 0) {
+
+		// DB_NOTFOUND is a "normal" returns,
+		// so should not be thrown as an error
+		//
+		if (err != DB_NOTFOUND) {
+			const char *name = "DbLogc::get";
+			if (err == ENOMEM && DB_OVERFLOWED_DBT(data))
+				DB_ERROR_DBT(name, data, ON_ERROR_UNKNOWN);
+			else
+				DB_ERROR(name, err, ON_ERROR_UNKNOWN);
+
+			return (err);
+		}
+	}
+	return (err);
+}