Imported Upstream version 4.8.30.NCupstream/4.8.30.NC

2 files changed, 7910 insertions, 0 deletions

diff --git a/libdb_csharp/db.i b/libdb_csharp/db.i
new file mode 100644
index 00000000..d4af6c36
--- /dev/null
+++ b/libdb_csharp/db.i
@@ -0,0 +1,1976 @@
+%module libdb_csharp
+%{
+#include "db_config.h"
+#include "db_int.h"
+#include "dbinc/txn.h"
+#include "db.h"
+%}
+
+typedef unsigned int u_int;
+typedef unsigned long u_int32_t;
+typedef u_int32_t size_t;
+typedef unsigned long db_pgno_t;
+typedef unsigned long db_recno_t;
+typedef u_int32_t db_mutex_t;
+typedef u_int32_t db_threadid_t;
+typedef unsigned long db_timeout_t;
+typedef int pid_t;
+typedef	uintptr_t	roff_t;
+typedef u_int32_t uintptr_t;
+typedef int int32_t;
+typedef int64_t db_seq_t;
+typedef long long int int64_t;
+typedef u_int32_t DB_CACHE_PRIORITY;
+
+%csmethodmodifiers "internal";
+%typemap(csclassmodifiers) SWIGTYPE "internal class"
+%pragma(csharp) moduleclassmodifiers="internal class"
+%typemap(csclassmodifiers) DBTYPE "internal enum"
+%typemap(csclassmodifiers) db_lockmode_t "internal enum"
+%typemap(csclassmodifiers) db_lockop_t "internal enum"
+%typemap(csclassmodifiers) db_recops "internal enum"
+
+typedef enum {
+	DB_BTREE=1,
+	DB_HASH=2,
+	DB_RECNO=3,
+	DB_QUEUE=4,
+	DB_UNKNOWN=5			/* Figure it out on open. */
+} DBTYPE;
+
+typedef enum {
+	DB_LOCK_NG=0,			/* Not granted. */
+	DB_LOCK_READ=1,			/* Shared/read. */
+	DB_LOCK_WRITE=2,		/* Exclusive/write. */	
+	DB_LOCK_WAIT=3,			/* Wait for event */
+	DB_LOCK_IWRITE=4,		/* Intent exclusive/write. */
+	DB_LOCK_IREAD=5,		/* Intent to share/read. */
+	DB_LOCK_IWR=6,			/* Intent to read and write. */
+	DB_LOCK_READ_UNCOMMITTED=7,	/* Degree 1 isolation. */
+	DB_LOCK_WWRITE=8		/* Was Written. */
+} db_lockmode_t;
+
+typedef enum {
+	DB_LOCK_DUMP=0,			/* Display held locks. */
+	DB_LOCK_GET=1,			/* Get the lock. */
+	DB_LOCK_GET_TIMEOUT=2,		/* Get lock with a timeout. */
+	DB_LOCK_INHERIT=3,		/* Pass locks to parent. */
+	DB_LOCK_PUT=4,			/* Release the lock. */
+	DB_LOCK_PUT_ALL=5,		/* Release locker's locks. */
+	DB_LOCK_PUT_OBJ=6,		/* Release locker's locks on obj. */
+	DB_LOCK_PUT_READ=7,		/* Release locker's read locks. */
+	DB_LOCK_TIMEOUT=8,		/* Force a txn to timeout. */
+	DB_LOCK_TRADE=9,		/* Trade locker ids on a lock. */
+	DB_LOCK_UPGRADE_WRITE=10	/* Upgrade writes for dirty reads. */
+} db_lockop_t;
+
+typedef enum {
+	DB_TXN_ABORT=0,			/* Public. */
+	DB_TXN_APPLY=1,			/* Public. */
+	DB_TXN_BACKWARD_ROLL=3,		/* Public. */
+	DB_TXN_FORWARD_ROLL=4,		/* Public. */
+	DB_TXN_OPENFILES=5,		/* Internal. */
+	DB_TXN_POPENFILES=6,		/* Internal. */
+	DB_TXN_PRINT=7			/* Public. */
+} db_recops;
+
+struct __db;			typedef struct __db DB;
+struct __db_compact;	typedef struct __db_compact DB_COMPACT;
+struct __db_lock_u;		typedef struct __db_lock_u DB_LOCK;
+struct __db_lsn;		typedef struct __db_lsn DB_LSN;
+struct __db_preplist;	typedef struct __db_preplist DB_PREPLIST;
+struct __db_repmgrsite; typedef struct __db_repmgrsite DB_REPMGR_SITE;
+struct __db_sequence;	typedef struct __db_sequence DB_SEQUENCE;
+struct __dbc;			typedef struct __dbc DBC;
+struct __dbenv;			typedef struct __dbenv DB_ENV;
+struct __dbt;			typedef struct __dbt DBT;
+struct __dbtxn;			typedef struct __dbtxn DB_TXN;
+struct __key_range;		typedef struct __key_range DB_KEY_RANGE;
+
+%typemap(cstype) char ** "ref string"
+%typemap(imtype) char ** "ref string"
+%typemap(csin) char ** "ref $csinput"
+%typemap(cstype) char *** "ref string[]"
+%typemap(imtype) char *** "ref string[]"
+%typemap(csin) char *** "ref $csinput"
+%typemap(cstype) int * "ref int"
+%typemap(imtype) int * "ref int"
+%typemap(csin) int * "ref $csinput"
+%typemap(cstype) u_int32_t * "ref uint"
+%typemap(imtype) u_int32_t * "ref uint"
+%typemap(csin) u_int32_t * "ref $csinput"
+%typemap(cstype) u_int * "ref uint"
+%typemap(imtype) u_int * "ref uint"
+%typemap(csin) u_int * "ref $csinput"
+%typemap(cstype) db_pgno_t * "ref uint"
+%typemap(imtype) db_pgno_t * "ref uint"
+%typemap(csin) db_pgno_t * "ref $csinput"
+%typemap(cstype) time_t * "ref long"
+%typemap(imtype) time_t * "ref long"
+%typemap(csin) time_t * "ref $csinput"
+%typemap(cstype) db_timeout_t * "ref uint"
+%typemap(imtype) db_timeout_t * "ref uint"
+%typemap(csin) db_timeout_t * "ref $csinput"
+%typemap(cstype) db_seq_t "Int64"
+%typemap(imtype) db_seq_t "Int64"
+%typemap(csin) db_seq_t "$csinput"
+%typemap(cstype) db_seq_t * "ref Int64"
+%typemap(imtype) db_seq_t * "ref Int64"
+%typemap(csin) db_seq_t * "ref $csinput"
+%typemap(cstype) u_int8_t [DB_GID_SIZE] "byte[]"
+%typemap(imtype) u_int8_t [DB_GID_SIZE] "byte[]"
+%typemap(csin) u_int8_t [DB_GID_SIZE] "$csinput"
+%typemap(cstype) u_int8_t * "byte[,]"
+%typemap(imtype) u_int8_t * "byte[,]"
+%typemap(csin) u_int8_t * "$csinput"
+
+%typemap(cstype) DBT * "DatabaseEntry"
+%typemap(csin, post="      GC.KeepAlive($csinput);") DBT * "$csclassname.getCPtr(DatabaseEntry.getDBT($csinput))"
+
+%typemap(csfinalize) DB, DB_ENV, DB_SEQUENCE ""
+%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") DB, DB_ENV, DB_SEQUENCE %{ {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+} %}
+
+%typemap(csout) int close(u_int32_t flags) {
+		int ret = $imcall;
+		if (ret == 0)
+			/* Close is a db handle destructor.  Reflect that in the wrapper class. */
+			swigCPtr = new HandleRef(null, IntPtr.Zero);
+		else
+			DatabaseException.ThrowException(ret);
+		return ret;
+} 
+
+%typemap(csout) int get_transactional{
+		return $imcall;
+}
+
+%typemap(csout) int get_multiple{
+		return $imcall;
+}
+
+%typemap(csout) char **log_archive {
+	IntPtr cPtr = $imcall;
+	List<string> ret = new List<string>();
+	if (cPtr == IntPtr.Zero)
+		return ret;
+
+	IntPtr[] strs = new IntPtr[cntp];
+	Marshal.Copy(cPtr, strs, 0, cntp);
+
+	for (int i =0; i < cntp; i++)
+		ret.Add(Marshal.PtrToStringAnsi(strs[i]));
+	libdb_csharp.__os_ufree(this, cPtr);
+	return ret;
+}
+
+%typemap(csout) char **get_data_dirs {
+	IntPtr cPtr = $imcall;
+	List<string> ret = new List<string>();
+	if (cPtr == IntPtr.Zero)
+		return ret;
+
+	IntPtr[] strs = new IntPtr[cntp];
+	Marshal.Copy(cPtr, strs, 0, cntp);
+
+	for (int i =0; i < cntp; i++)
+		ret.Add(Marshal.PtrToStringAnsi(strs[i]));
+
+	return ret;
+}
+		
+%typemap(csout) int log_compare{
+		return $imcall;
+}
+%typemap(csout) int log_file{
+		return $imcall;
+}
+
+%typemap(csout) int open {
+	int ret;
+	ret = $imcall;
+	if (ret != 0)
+		close(0);
+	DatabaseException.ThrowException(ret);
+	return ret;
+}
+
+%typemap(csout) int remove {
+	int ret;
+	ret = $imcall;
+	/* 
+	 * remove is a handle destructor, regardless of whether the remove
+	 * succeeds.  Reflect that in the wrapper class. 
+	 */
+	swigCPtr = new HandleRef(null, IntPtr.Zero);
+	DatabaseException.ThrowException(ret);
+	return ret;
+}
+
+%typemap(csout) int rename {
+	int ret;
+	ret = $imcall;
+	/* 
+	 * rename is a handle destructor, regardless of whether the rename
+	 * succeeds.  Reflect that in the wrapper class. 
+	 */
+	swigCPtr = new HandleRef(null, IntPtr.Zero);
+	DatabaseException.ThrowException(ret);
+	return ret;
+}
+
+%typemap(csout) DB_REPMGR_SITE *repmgr_site_list(u_int *countp, u_int *sizep, int *err) {
+	IntPtr cPtr = $imcall;
+	if (cPtr == IntPtr.Zero)
+		return new RepMgrSite[] { null };
+	/*
+	 * This is a big kludgy, but we need to free the memory that
+	 * repmgr_site_list mallocs.  The RepMgrSite constructors will copy all
+	 * the data out of that malloc'd area and we can free it right away.
+	 * This is easier than trying to construct a SWIG generated object that
+	 * will copy everything in it's constructor, because SWIG generated
+	 * classes come with a lot of baggage.
+	 */	
+	RepMgrSite[] ret = new RepMgrSite[countp];
+	for (int i = 0; i < countp; i++) {
+		/*
+		 * We're copying data out of an array of countp DB_REPMGR_SITE
+		 * structures, whose size varies between 32- and 64-bit
+		 * platforms.  
+		 */
+		IntPtr val = new IntPtr((IntPtr.Size == 4 ? cPtr.ToInt32() : cPtr.ToInt64()) + i * sizep);
+		ret[i] = new RepMgrSite(new DB_REPMGR_SITE(val, false));
+	}
+	libdb_csharp.__os_ufree(this, cPtr);
+	return ret;
+}
+
+
+%typemap(csout) void *stat {
+	return $imcall;
+}
+%typemap(csout) void *lock_stat(u_int32_t flags, int *err) {
+	return $imcall;
+}
+%typemap(csout) void *log_stat(u_int32_t flags, int *err) {
+	return $imcall;
+}
+%typemap(csout) void *memp_stat(u_int32_t flags, int *err) {
+	return $imcall;
+}
+%typemap(csout) void *mutex_stat(u_int32_t flags, int *err) {
+	return $imcall;
+}
+%typemap(csout) void *repmgr_stat(u_int32_t flags, int *err) {
+	return $imcall;
+}
+%typemap(csout) void *rep_stat(u_int32_t flags, int *err) {
+	return $imcall;
+}
+%typemap(csout) void *txn_stat(u_int32_t flags, uint *size, int *err) {
+	return $imcall;
+}
+
+%typemap(csout) int verify(const char *file, const char *database, FILE *handle, int (*callback)(void *handle, const void *str), u_int32_t flags) {
+		int ret;
+		ret = $imcall;
+		/* Verify is a db handle destructor.  Reflect that in the wrapper class. */
+		swigCMemOwn = false;
+		swigCPtr = new HandleRef(null, IntPtr.Zero);
+		DatabaseException.ThrowException(ret);
+		return ret;
+}
+
+%typemap(csout) int {
+		int ret;
+		ret = $imcall;
+		DatabaseException.ThrowException(ret);
+		return ret;
+}
+
+typedef struct __db_compact {
+	u_int32_t	compact_fillpercent;	/* Desired fillfactor: 1-100 */
+	db_timeout_t	compact_timeout;	/* Lock timeout. */
+	u_int32_t	compact_pages;		/* Max pages to process. */
+	/* Output Stats. */
+	u_int32_t	compact_pages_free;	/* Number of pages freed. */
+	u_int32_t	compact_pages_examine;	/* Number of pages examine. */
+	u_int32_t	compact_levels;		/* Number of levels removed. */
+	u_int32_t	compact_deadlock;	/* Number of deadlocks. */
+	db_pgno_t	compact_pages_truncated; /* Pages truncated to OS. */
+	/* Internal. */
+	db_pgno_t	compact_truncate;	/* Page number for truncation */
+} DB_COMPACT;
+
+typedef struct __db_lsn {
+	u_int32_t file;
+	u_int32_t offset;
+} DB_LSN;
+
+%typemap(cscode) DB %{
+	internal DBC cursor(DB_TXN txn, uint flags) {
+		int err = 0;
+		DBC ret = cursor(txn, flags, ref err);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+	
+	internal DBC join(IntPtr[] curslist, uint flags) {
+		int err = 0;
+		DBC ret = join(curslist, flags, ref err);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+
+	internal BTreeStatStruct stat_bt(DB_TXN txn, uint flags) {
+		int err = 0;
+		IntPtr ptr = stat(txn, flags, ref err);
+		DatabaseException.ThrowException(err);
+		BTreeStatStruct ret = (BTreeStatStruct)Marshal.PtrToStructure(ptr, typeof(BTreeStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+	internal HashStatStruct stat_hash(DB_TXN txn, uint flags) {
+		int err = 0;
+		IntPtr ptr = stat(txn, flags, ref err);
+		DatabaseException.ThrowException(err);
+		HashStatStruct ret = (HashStatStruct)Marshal.PtrToStructure(ptr, typeof(HashStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+	internal QueueStatStruct stat_qam(DB_TXN txn, uint flags) {
+		int err = 0;
+		IntPtr ptr = stat(txn, flags, ref err);
+		DatabaseException.ThrowException(err);
+		QueueStatStruct ret = (QueueStatStruct)Marshal.PtrToStructure(ptr, typeof(QueueStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+%}
+typedef struct __db
+{
+	%typemap(cstype) void *api_internal "BaseDatabase"
+	%typemap(imtype) void *api_internal "BaseDatabase"
+	%typemap(csin) void *api_internal "value"
+	%typemap(csvarout) void *api_internal %{
+		get { return $imcall; }
+	%}
+	void *api_internal;
+	
+%extend {
+	%typemap(cstype) int (*dbt_usercopy)(DBT*, u_int32_t, void *, u_int32_t, u_int32_t) "DBTCopyDelegate"
+	%typemap(imtype) int (*dbt_usercopy)(DBT*, u_int32_t, void *, u_int32_t, u_int32_t) "DBTCopyDelegate"
+	%typemap(csin) int (*dbt_usercopy)(DBT*, u_int32_t, void *, u_int32_t, u_int32_t) "dbt_usercopy"
+	int set_usercopy(int (*dbt_usercopy)(DBT *, u_int32_t, void *, u_int32_t, u_int32_t)) {
+		self->env->dbt_usercopy = dbt_usercopy;
+		return 0;
+	}
+	
+	DB(DB_ENV *env, u_int32_t flags) {
+		DB *self = NULL;
+		errno = db_create(&self, env, flags);
+		return self;
+	}
+
+	~DB() { }
+
+	%typemap(cstype) int (*)(DB*, const DBT*, const DBT*, DBT*) "BDB_AssociateDelegate"
+	%typemap(imtype) int (*)(DB*, const DBT*, const DBT*, DBT*) "BDB_AssociateDelegate"
+	%typemap(csin) int (*callback)(DB *secondary, const DBT *key, const DBT *data, DBT *result) "callback"
+	int associate(DB_TXN *txn, DB *sec, int (*callback)(DB *secondary, const DBT *key, const DBT *data, DBT *result), u_int32_t flags) {
+		return self->associate(self, txn, sec, callback, flags);
+	}
+		
+	%typemap(cstype) int (*)(DB*, const DBT*, DBT*, const DBT*, int *) "BDB_AssociateForeignDelegate"
+	%typemap(imtype) int (*)(DB*, const DBT*, DBT*, const DBT*, int *) "BDB_AssociateForeignDelegate"
+	%typemap(csin) int (*callback)(DB *foreign, const DBT *key, DBT *data, const DBT *result, int *changed) "callback"
+	int associate_foreign(DB *dbp, int (*callback)(DB *secondary, const DBT *key, DBT *data, const DBT *foreign, int *changed), u_int32_t flags) {
+		return self->associate_foreign(self, dbp, callback, flags);
+	}
+		
+	int close(u_int32_t flags) {
+		return self->close(self, flags);
+	}
+	
+	int compact(DB_TXN *txn, DBT *start, DBT *stop, DB_COMPACT *cdata, u_int32_t flags, DBT *end) {
+		return self->compact(self, txn, start, stop, cdata, flags, end);
+	}
+	
+	%csmethodmodifiers cursor "private"
+	DBC *cursor(DB_TXN *txn, u_int32_t flags, int *err) {
+		DBC *cursor = NULL;
+		
+		*err = self->cursor(self, txn, &cursor, flags);
+		return cursor;
+	}
+	
+	int del(DB_TXN *txn, DBT *key, u_int32_t flags) {
+		return self->del(self, txn, key, flags);
+	}
+	
+	DB_ENV *env() {
+		return self->dbenv;
+	}
+
+	int exists(DB_TXN *txn, DBT *key, u_int32_t flags) {
+		return self->exists(self, txn, key, flags);
+	}
+		
+	int get(DB_TXN *txn, DBT *key, DBT *data, u_int32_t flags) {
+		return self->get(self, txn, key, data, flags);
+	}
+	
+	int get_byteswapped(int *isswapped) {
+		return self->get_byteswapped(self, isswapped);
+	}
+	
+	int get_dbname(const char **filenamep, const char **dbnamep) {
+		return self->get_dbname(self, filenamep, dbnamep);
+	}
+	
+	int get_multiple() {
+		return self->get_multiple(self);
+	}
+
+	int get_open_flags(u_int32_t *flags) {
+		return self->get_open_flags(self, flags);
+	}
+	
+	int get_transactional() {
+		return self->get_transactional(self);
+	}
+	
+	%typemap(cstype) DBTYPE * "ref DBTYPE"
+	%typemap(imtype) DBTYPE * "ref DBTYPE"
+	%typemap(csin) DBTYPE * "ref $csinput"
+	int get_type(DBTYPE *type) {
+		return self->get_type(self, type);
+	}
+	
+	%csmethodmodifiers join "private"
+	%typemap(cstype) DBC ** "IntPtr[]"
+	%typemap(imtype) DBC ** "IntPtr[]"
+	%typemap(csin) DBC ** "$csinput"
+	DBC *join(DBC **curslist, u_int32_t flags, int *err) {
+		DBC *dbc = NULL;
+		
+		*err = self->join(self, curslist, &dbc, flags);
+		return dbc;
+	}
+	
+	int key_range(DB_TXN *txn, DBT *key, DB_KEY_RANGE *range, u_int32_t flags) {
+		return self->key_range(self, txn, key, range, flags);
+	}
+		
+	int open(DB_TXN *txn, const char *file, const char *database, DBTYPE type, u_int32_t flags, int mode) {
+		return self->open(self, txn, file, database, type, flags, mode);
+	}
+	
+	int pget(DB_TXN *txn, DBT *key, DBT *pkey, DBT *data, u_int32_t flags) {
+		return self->pget(self, txn, key, pkey, data, flags);
+	}
+
+	int put(DB_TXN *txn, DBT *key, DBT *data, u_int32_t flags) {
+		return self->put(self, txn, key, data, flags);
+	}
+	
+	int remove(const char *file, const char *database, u_int32_t flags) {
+		return self->remove(self, file, database, flags);
+	}
+	
+	int rename(const char *file, const char *database, const char *newname, u_int32_t flags) {
+		return self->rename(self, file, database, newname, flags);
+	}
+	
+	%typemap(cstype) int (*)(DB*, DBT*, db_recno_t) "BDB_AppendRecnoDelegate"
+	%typemap(imtype) int (*)(DB*, DBT*, db_recno_t) "BDB_AppendRecnoDelegate"
+	%typemap(csin) int (*callback)(DB *dbp, DBT*, db_recno_t) "callback"
+	int set_append_recno(int (*callback)(DB *dbp, DBT*, db_recno_t)) {
+		return self->set_append_recno(self, callback);
+	}
+	
+	%typemap(cstype) int (*)(DB*, const DBT*, const DBT*) "BDB_CompareDelegate"
+	%typemap(imtype) int (*)(DB*, const DBT*, const DBT*) "BDB_CompareDelegate"
+	%typemap(csin) int (*callback)(DB *dbp, const DBT *dbt1, const DBT *dbt2) "callback"
+	int set_bt_compare(int (*callback)(DB *dbp, const DBT *dbt1, const DBT *dbt2)) {
+		return self->set_bt_compare(self, callback);
+	}
+	
+	%typemap(cstype) int (*)(DB *dbp, const DBT *prevKey, const DBT *prevData, const DBT *key, const DBT *data, DBT *dest) "BDB_CompressDelegate"
+	%typemap(imtype) int (*)(DB *dbp, const DBT *prevKey, const DBT *prevData, const DBT *key, const DBT *data, DBT *dest) "BDB_CompressDelegate"
+	%typemap(csin) int (*compress)(DB *dbp, const DBT *prevKey, const DBT *prevData, const DBT *key, const DBT *data, DBT *dest) "compress"
+	%typemap(cstype) int (*)(DB *dbp, const DBT *prevKey, const DBT *prevData, DBT *compressed, DBT *destKey, DBT *destData) "BDB_DecompressDelegate"
+	%typemap(imtype) int (*)(DB *dbp, const DBT *prevKey, const DBT *prevData, DBT *compressed, DBT *destKey, DBT *destData) "BDB_DecompressDelegate"
+	%typemap(csin) int (*decompress)(DB *dbp, const DBT *prevKey, const DBT *prevData, DBT *compressed, DBT *destKey, DBT *destData) "decompress"
+	int set_bt_compress(int (*compress)(DB *dbp, const DBT *prevKey, const DBT *prevData, const DBT *key, const DBT *data, DBT *dest), int (*decompress)(DB *dbp, const DBT *prevKey, const DBT *prevData, DBT *compressed, DBT *destKey, DBT *destData)) {
+		return self->set_bt_compress(self, compress, decompress);
+	}
+
+	int get_bt_minkey(u_int32_t *bt_minkey) {
+		return self->get_bt_minkey(self, bt_minkey);
+	}
+	int set_bt_minkey(u_int32_t bt_minkey) {
+		return self->set_bt_minkey(self, bt_minkey);
+	}
+	
+	int set_bt_prefix(int (*callback)(DB *dbp, const DBT *dbt1, const DBT *dbt2)) {
+		return self->set_bt_prefix(self, callback);
+	}
+	
+	int get_cachesize(u_int32_t *gbytes, u_int32_t *bytes, int *ncache) {
+		return self->get_cachesize(self, gbytes, bytes, ncache);
+	}
+	int set_cachesize(u_int32_t gbytes, u_int32_t bytes, int ncache) {
+		return self->set_cachesize(self, gbytes, bytes, ncache);
+	}
+	
+	int set_dup_compare(int (*callback)(DB *dbp, const DBT *dbt1, const DBT *dbt2)) {
+		return self->set_dup_compare(self, callback);
+	}
+	
+	int get_encrypt_flags(u_int32_t *flags) {
+		return self->get_encrypt_flags(self, flags);
+	}
+	int set_encrypt(const char *pwd, u_int32_t flags) {
+		return self->set_encrypt(self, pwd, flags);
+	}
+	
+	%typemap(cstype) void (*)(const DB_ENV *, const char *, const char *) "BDB_ErrcallDelegate"
+	%typemap(imtype) void (*)(const DB_ENV *, const char *, const char *) "BDB_ErrcallDelegate"
+	%typemap(csin) void (*db_errcall_fcn)(const DB_ENV *dbenv, const char *errpfx, const char *errmsg) "db_errcall_fcn"
+	void set_errcall(void (*db_errcall_fcn)(const DB_ENV *dbenv, const char *errpfx, const char *errmsg)) {
+		self->set_errcall(self, db_errcall_fcn);
+	}
+	
+	%typemap(cstype) int (*)(DB*, int, int) "BDB_DbFeedbackDelegate"
+	%typemap(imtype) int (*)(DB*, int, int) "BDB_DbFeedbackDelegate"
+	%typemap(csin) int (*callback)(DB *dbp, int opcode, int percent) "callback"
+	int set_feedback(int (*callback)(DB *dbp, int opcode, int percent)) {
+		return self->set_feedback(self, callback);
+	}
+	
+	int get_flags(u_int32_t *flags) {
+		return self->get_flags(self, flags);
+	}
+	int set_flags(u_int32_t flags) {
+		return self->set_flags(self, flags);
+	}
+	
+	int set_h_compare(int (*callback)(DB *dbp, const DBT *dbt1, const DBT *dbt2)) {
+		return self->set_h_compare(self, callback);
+	}
+	
+	int get_h_ffactor(u_int32_t *ffactor) {
+		return self->get_h_ffactor(self, ffactor);
+	}
+	int set_h_ffactor(u_int32_t ffactor) {
+		return self->set_h_ffactor(self, ffactor);
+	}
+	
+	%typemap(cstype) u_int32_t (*)(DB*, const void*, u_int32_t) "BDB_HashDelegate"
+	%typemap(imtype) u_int32_t (*)(DB*, const void*, u_int32_t) "BDB_HashDelegate"
+	%typemap(csin) u_int32_t (*callback)(DB *dbp, const void *bytes, u_int32_t length) "callback"
+	int set_h_hash(u_int32_t (*callback)(DB *dbp, const void *bytes, u_int32_t length)) {
+		return self->set_h_hash(self, callback);
+	}
+	
+	int get_h_nelem(u_int32_t *nelem) {
+		return self->get_h_nelem(self, nelem);
+	}
+	int set_h_nelem(u_int32_t nelem) {
+		return self->set_h_nelem(self, nelem);
+	}
+	
+	int get_lorder(int *lorder) {
+		return self->get_lorder(self, lorder);
+	}
+	int set_lorder(int lorder) {
+		return self->set_lorder(self, lorder);
+	}
+	
+	int get_pagesize(u_int32_t *pgsz) {
+		return self->get_pagesize(self, pgsz);
+	}
+	int set_pagesize(u_int32_t pgsz) {
+		return self->set_pagesize(self, pgsz);
+	}
+	
+	int get_priority(DB_CACHE_PRIORITY *flags) {
+		return self->get_priority(self, flags);
+	}
+	int set_priority(DB_CACHE_PRIORITY flags) {
+		return self->set_priority(self, flags);
+	}
+	
+	int get_q_extentsize(u_int32_t *extentsz) {
+		return self->get_q_extentsize(self, extentsz);
+	}
+	int set_q_extentsize(u_int32_t extentsz) {
+		return self->set_q_extentsize(self, extentsz);
+	}
+	
+	int get_re_delim(int *delim) {
+		return self->get_re_delim(self, delim);
+	}
+	int set_re_delim(int delim) {
+		return self->set_re_delim(self, delim);
+	}
+	
+	int get_re_len(u_int32_t *len) {
+		return self->get_re_len(self, len);
+	}
+	int set_re_len(u_int32_t len) {
+		return self->set_re_len(self, len);
+	}
+	
+	int get_re_pad(int *pad) {
+		return self->get_re_pad(self, pad);
+	}
+	int set_re_pad(int pad) {
+		return self->set_re_pad(self, pad);
+	}
+	
+	int get_re_source(const char **source) {
+		return self->get_re_source(self, source);
+	}
+	int set_re_source(char *source) {
+		return self->set_re_source(self, source);
+	}
+	
+	%csmethodmodifiers stat "private"
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	void *stat(DB_TXN *txnid, u_int32_t flags, int *err) {
+		void *ret = NULL;
+
+		*err = self->stat(self, txnid, &ret, flags);
+		return ret;
+	}
+
+	int stat_print(u_int32_t flags) {
+		return self->stat_print(self, flags);
+	}
+
+	int sync(u_int32_t flags) {
+		return self->sync(self, flags);
+	}
+	
+	int truncate(DB_TXN *txn, u_int32_t *countp, u_int32_t flags) {
+		return self->truncate(self, txn, countp, flags);
+	}
+	
+	int upgrade(const char *file, u_int32_t flags) {
+		return self->upgrade(self, file, flags);
+	}
+	
+	%typemap(cstype) FILE * "System.IO.TextWriter"
+	%typemap(imtype) FILE * "System.IO.TextWriter"
+	%typemap(csin) FILE * "$csinput"
+	%typemap(cstype) int (*)(void*, const void*) "BDB_FileWriteDelegate"
+	%typemap(imtype) int (*)(void*, const void*) "BDB_FileWriteDelegate"
+	%typemap(csin) int (*callback)(void *handle, const void *str) "callback"
+	int verify(const char *file, const char *database, FILE *handle, int (*callback)(void *handle, const void *str), u_int32_t flags) {
+		/*
+		 * We can't easily #include "dbinc/db_ext.h" because of name
+		 * clashes, so we declare this explicitly.
+		 */
+		extern int __db_verify_internal __P((DB *, const char *, const
+		    char *, void *, int (*)(void *, const void *), u_int32_t));
+		return __db_verify_internal(self, file, database, (void *)handle, callback, flags);
+	}
+}
+} DB;
+
+%typemap(cscode) DBC %{
+	internal DBC dup(uint flags) {
+		int err = 0;
+		DBC ret = dup(flags, ref err);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+%}
+typedef struct __dbc
+{
+%extend {
+	int close() {
+		return self->close(self);
+	}
+	
+	%typemap(cstype) db_recno_t * "ref uint"
+	%typemap(imtype) db_recno_t * "ref uint"
+	%typemap(csin) db_recno_t * "ref $csinput"
+	
+	int cmp(DBC *other_dbc, int *result, u_int32_t flags) {
+		return self->cmp(self, other_dbc, result, flags);
+	}
+
+	int count(db_recno_t *cnt, u_int32_t flags) {
+		return self->count(self, cnt, flags);
+	}
+
+	int del(u_int32_t flags) {
+		return self->del(self, flags);
+	}
+	
+	%csmethodmodifiers dup "private"
+	DBC *dup(u_int32_t flags, int *err) {
+		DBC *cursor = NULL;
+		
+		*err = self->dup(self, &cursor, flags);
+		return cursor;
+	}
+	
+	int get(DBT *key, DBT *data, u_int32_t flags) {
+		return self->get(self, key, data, flags);
+	}
+	
+	int pget(DBT *key, DBT *pkey, DBT *data, u_int32_t flags) {
+		return self->pget(self, key, pkey, data, flags);
+	}
+	
+	int put(DBT *key, DBT *data, u_int32_t flags) {
+		return self->put(self, key, data, flags);
+	}
+	
+	int set_priority(u_int32_t priority) {
+		return self->set_priority(self, priority);
+	}
+		
+}
+} DBC;
+
+%typemap(cscode) DBT %{
+	internal IntPtr dataPtr {
+		get {
+			return $imclassname.DBT_data_get(swigCPtr);
+		}
+	}
+%}
+typedef struct __dbt
+{
+	u_int32_t dlen;
+	u_int32_t doff;
+	u_int32_t flags;
+	u_int32_t size;
+	u_int32_t ulen;
+	
+%typemap(cstype) void * "byte[]"
+%typemap(imtype) void * "IntPtr"
+%typemap(csvarin) void *data %{
+	set {
+		IntPtr _data = Marshal.AllocHGlobal(value.Length);
+        Marshal.Copy(value, 0, _data, value.Length);
+        $imclassname.DBT_data_set(swigCPtr, _data);
+        size = (uint)value.Length;
+	}
+%}
+%typemap(csvarout) void *data %{
+	get {
+		IntPtr datap = $imcall;
+		int sz = (int)size;
+		byte[] ret = new byte[sz];
+		Marshal.Copy(datap, ret, 0, sz);
+		return ret;
+	}
+%}
+	void *data;
+	
+	%typemap(cstype) void *app_data "DatabaseEntry"
+	%typemap(imtype) void *app_data "DatabaseEntry"
+	%typemap(csin) void *app_data "value"
+	%typemap(csvarout) void *app_data %{
+		get { return $imcall; }
+	%}
+	void *app_data;
+	
+%extend {
+	%typemap(csconstruct) DBT %{: this($imcall, true) { 
+		flags = DbConstants.DB_DBT_USERCOPY;
+	} %}
+	
+	DBT() {
+		DBT *self = NULL;
+		self = malloc(sizeof(DBT));
+		memset(self, 0, sizeof(DBT));
+		return self;
+	}
+}
+} DBT;
+
+typedef struct __db_repmgrsite
+{
+	int eid;
+	char host[];
+	u_int port;
+	u_int32_t status;
+} DB_REPMGR_SITE;
+
+typedef struct __dbtxn
+{
+%extend {
+	int abort() {
+		return self->abort(self);
+	}
+	
+	int commit(u_int32_t flags) {
+		return self->commit(self, flags);
+	}
+	
+	int discard(u_int32_t flags) {
+		return self->discard(self, flags);
+	}
+	
+	u_int32_t id() {
+		return self->id(self);
+	}
+	
+	int prepare(u_int8_t globalID[DB_GID_SIZE]) {
+		return self->prepare(self, globalID);
+	}
+	
+	int get_name(const char **name) {
+		return self->get_name(self, name);
+	}
+	int set_name(const char *name) {
+		return self->set_name(self, name);
+	}
+
+	int set_timeout(db_timeout_t timeout, u_int32_t flags) {
+		return self->set_timeout(self, timeout, flags);
+	}
+}
+} DB_TXN;
+
+%typemap(cscode) DB_ENV %{
+	internal DB_TXN cdsgroup_begin() {
+		int err = 0;
+		DB_TXN ret = cdsgroup_begin(ref err);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+	internal List<string> get_data_dirs() {
+		int err = 0;
+		int cnt = 0;
+		List<string> ret = get_data_dirs(ref err, ref cnt);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+	internal DB_LOCK lock_get(uint locker, uint flags, DBT arg2, db_lockmode_t mode) {
+		int err = 0;
+		DB_LOCK ret = lock_get(locker, flags, arg2, mode, ref err);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+	internal LockStatStruct lock_stat(uint flags) {
+		int err = 0;
+		IntPtr ptr = lock_stat(flags, ref err);
+		DatabaseException.ThrowException(err);
+		LockStatStruct ret = (LockStatStruct)Marshal.PtrToStructure(ptr, typeof(LockStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+	internal List<string> log_archive(uint flags) {
+		int err = 0;
+		int cnt = 0;
+		List<string> ret = log_archive(flags, ref err, ref cnt);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+	internal string log_file(DB_LSN dblsn) {
+		int err = 0;
+		int len = 100;
+		IntPtr namep;
+		while (true) {
+			namep = Marshal.AllocHGlobal(len);
+			err = log_file(dblsn, namep, (uint)len);
+			if (err != DbConstants.DB_BUFFER_SMALL)
+				break;
+			Marshal.FreeHGlobal(namep);
+			len *= 2;
+		}
+		DatabaseException.ThrowException(err);
+		string ret = Marshal.PtrToStringAnsi(namep);
+		Marshal.FreeHGlobal(namep);
+		return ret;
+	}
+	internal LogStatStruct log_stat(uint flags) {
+		int err = 0;
+		IntPtr ptr = log_stat(flags, ref err);
+		DatabaseException.ThrowException(err);
+		LogStatStruct ret = (LogStatStruct)Marshal.PtrToStructure(ptr, typeof(LogStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+	internal MempStatStruct memp_stat(uint flags) {
+		int err = 0;
+	        int cnt = 0;
+        	IntPtr mpf = new IntPtr();
+	        IntPtr ptr = memp_stat(ref mpf, flags, ref err, ref cnt);
+		DatabaseException.ThrowException(err);
+        	IntPtr[] files = new IntPtr[cnt];
+		if (cnt > 0)
+	        	Marshal.Copy(mpf, files, 0, cnt);
+
+	        MempStatStruct ret = new MempStatStruct();
+		ret.st = (MPoolStatStruct)Marshal.PtrToStructure(ptr, typeof(MPoolStatStruct));
+        	ret.files = new MPoolFileStatStruct[cnt];
+	        for (int i = 0; i < cnt; i++)
+        	    ret.files[i] = (MPoolFileStatStruct)Marshal.PtrToStructure(files[i], typeof(MPoolFileStatStruct));
+
+		libdb_csharp.__os_ufree(null, ptr);
+		libdb_csharp.__os_ufree(null, mpf);
+		return ret;
+	}
+	internal MutexStatStruct mutex_stat(uint flags) {
+		int err = 0;
+		IntPtr ptr = mutex_stat(flags, ref err);
+		DatabaseException.ThrowException(err);
+		MutexStatStruct ret = (MutexStatStruct)Marshal.PtrToStructure(ptr, typeof(MutexStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+	internal RepMgrSite[] repmgr_site_list() {
+		uint count = 0;
+		int err = 0;
+		uint size = 0;
+		RepMgrSite[] ret = repmgr_site_list(ref count, ref size, ref err);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+	internal RepMgrStatStruct repmgr_stat(uint flags) {
+		int err = 0;
+		IntPtr ptr = repmgr_stat(flags, ref err);
+		DatabaseException.ThrowException(err);
+		RepMgrStatStruct ret = (RepMgrStatStruct)Marshal.PtrToStructure(ptr, typeof(RepMgrStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+	internal ReplicationStatStruct rep_stat(uint flags) {
+		int err = 0;
+		IntPtr ptr = rep_stat(flags, ref err);
+		DatabaseException.ThrowException(err);
+		ReplicationStatStruct ret = (ReplicationStatStruct)Marshal.PtrToStructure(ptr, typeof(ReplicationStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+	internal DB_TXN txn_begin(DB_TXN parent, uint flags) {
+		int err = 0;
+		DB_TXN ret = txn_begin(parent, flags, ref err);
+		DatabaseException.ThrowException(err);
+		return ret;
+	}
+	internal PreparedTransaction[] txn_recover(uint count, uint flags) {
+		int err = 0;
+		IntPtr prepp = Marshal.AllocHGlobal((int)(count * (IntPtr.Size + DbConstants.DB_GID_SIZE)));
+		uint sz = 0;
+		err = txn_recover(prepp, count, ref sz, flags);
+		DatabaseException.ThrowException(err);
+		PreparedTransaction[] ret = new PreparedTransaction[sz];
+		for (int i = 0; i < sz; i++) {
+			IntPtr cPtr = new IntPtr((IntPtr.Size == 4 ? prepp.ToInt32() : prepp.ToInt64()) + i * (IntPtr.Size + DbConstants.DB_GID_SIZE));
+			DB_PREPLIST prep = new DB_PREPLIST(cPtr, false);
+			ret[i] = new PreparedTransaction(prep);
+		}
+		Marshal.FreeHGlobal(prepp);
+		return ret;
+	}
+	internal TxnStatStruct txn_stat(uint flags) {
+		int err = 0;
+		uint size = 0;
+		int offset = Marshal.SizeOf(typeof(DB_TXN_ACTIVE));
+		IntPtr ptr = txn_stat(flags, ref size, ref err);
+		DatabaseException.ThrowException(err);
+	        TxnStatStruct ret = new TxnStatStruct();
+		ret.st = (TransactionStatStruct)Marshal.PtrToStructure(ptr, typeof(TransactionStatStruct));
+        	ret.st_txnarray = new DB_TXN_ACTIVE[ret.st.st_nactive];
+	        ret.st_txngids = new byte[ret.st.st_nactive][];
+        	ret.st_txnnames = new string[ret.st.st_nactive];
+
+	        for (int i = 0; i < ret.st.st_nactive; i++) {
+        	    IntPtr activep = new IntPtr((IntPtr.Size == 4 ? ret.st.st_txnarray.ToInt32() : ret.st.st_txnarray.ToInt64()) + i * size);
+	            ret.st_txnarray[i] = (DB_TXN_ACTIVE)Marshal.PtrToStructure(activep, typeof(DB_TXN_ACTIVE));
+        	    ret.st_txngids[i] = new byte[DbConstants.DB_GID_SIZE];
+	            IntPtr gidp = new IntPtr((IntPtr.Size == 4 ? activep.ToInt32() : activep.ToInt64()) + offset);
+        	    Marshal.Copy(gidp, ret.st_txngids[i], 0, (int)DbConstants.DB_GID_SIZE);
+	            IntPtr namep = new IntPtr((IntPtr.Size == 4 ? gidp.ToInt32() : gidp.ToInt64()) + DbConstants.DB_GID_SIZE);
+        	    ret.st_txnnames[i] = Marshal.PtrToStringAnsi(namep);
+	        }
+        	libdb_csharp.__os_ufree(null, ptr);
+        
+		return ret;
+	}
+	
+%}
+%typemap(csimports) DB_ENV "using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;"		
+typedef struct __dbenv
+{
+
+%typemap(cstype) void *api2_internal "DatabaseEnvironment"
+%typemap(imtype) void *api2_internal "DatabaseEnvironment"
+%typemap(csin) void *api2_internal "value"
+%typemap(csvarout) void *api2_internal %{
+		get { return $imcall; }
+%}
+	void *api2_internal;
+	
+%extend {
+	%typemap(cstype) int (*dbt_usercopy)(DBT*, u_int32_t, void *, u_int32_t, u_int32_t) "DBTCopyDelegate"
+	%typemap(imtype) int (*dbt_usercopy)(DBT*, u_int32_t, void *, u_int32_t, u_int32_t) "DBTCopyDelegate"
+	%typemap(csin) int (*dbt_usercopy)(DBT*, u_int32_t, void *, u_int32_t, u_int32_t) "dbt_usercopy"
+	int set_usercopy(int (*dbt_usercopy)(DBT *, u_int32_t, void *, u_int32_t, u_int32_t)) {
+		self->env->dbt_usercopy = dbt_usercopy;
+		return 0;
+	}
+	
+	DB_ENV(u_int32_t flags) {
+		DB_ENV *self = NULL;
+		errno = db_env_create(&self, flags);
+		return self;
+	}
+	
+	~DB_ENV() { }
+
+	%csmethodmodifiers cdsgroup_begin "private"
+	DB_TXN *cdsgroup_begin(int *err) {
+		DB_TXN *group;
+		
+		*err = self->cdsgroup_begin(self, &group);
+		return group;
+	}
+	 
+	int close(u_int32_t flags) {
+		return self->close(self, flags);
+	}
+	
+	int dbremove(DB_TXN *txn, const char *file, const char *database, u_int32_t flags) {
+		return self->dbremove(self, txn, file, database, flags);
+	}
+	
+	int dbrename(DB_TXN *txn, const char *file, const char *database, const char *newname, u_int32_t flags) {
+		return self->dbrename(self, txn, file, database, newname, flags);
+	}
+	
+	int failchk(u_int32_t flags) {
+		return self->failchk(self, flags);
+	}
+	
+	int fileid_reset(const char *file, u_int32_t flags) {
+		return self->fileid_reset(self, file, flags);
+	}
+	
+	int get_home(const char **file) {
+		return self->get_home(self, file);
+	}
+	
+	int lock_detect(u_int32_t flags, u_int32_t atype, u_int32_t *rejected) {
+		return self->lock_detect(self, flags, atype, rejected);
+	}
+	
+	%csmethodmodifiers lock_get "private"
+	DB_LOCK lock_get(u_int32_t locker, u_int32_t flags, DBT *object, const db_lockmode_t mode, int *err) {
+		DB_LOCK lock;
+		
+		*err = self->lock_get(self, locker, flags, object, mode, &lock);
+		return lock;
+	}
+	
+	int lock_id(u_int32_t *id) {
+		return self->lock_id(self, id);
+	}
+		
+	int lock_id_free(u_int32_t id) {
+		return self->lock_id_free(self, id);
+	}
+	
+	int lock_put(DB_LOCK *lck) {
+		return self->lock_put(self, lck);
+	}
+
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	%csmethodmodifiers lock_stat "private"		
+	void *lock_stat(u_int32_t flags, int *err) {
+		DB_LOCK_STAT *ret;
+		*err = self->lock_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+
+	int lock_stat_print(u_int32_t flags) {
+		return self->lock_stat_print(self, flags);
+	}
+
+
+	%typemap(cstype) DB_LOCKREQ ** "IntPtr[]"
+	%typemap(imtype) DB_LOCKREQ ** "IntPtr[]"
+	%typemap(csin) DB_LOCKREQ ** "$csinput"
+	int lock_vec(u_int32_t locker, u_int32_t flags, DB_LOCKREQ **list, int nlist, DB_LOCKREQ *elistp){
+		int i, ret;
+		DB_LOCKREQ *vec;
+		
+		ret = __os_malloc(self->env, sizeof(DB_LOCKREQ) * nlist, &vec);
+		if (ret != 0)
+			return ENOMEM;
+		for (i = 0; i < nlist; i++)
+			vec[i] = *list[i];
+			
+		if (elistp == NULL)
+			ret = self->lock_vec(self, locker, flags, vec, nlist, NULL);
+		else
+			ret = self->lock_vec(self, locker, flags, vec, nlist, &elistp);
+			
+		for (i = 0; i < nlist; i++)
+			*list[i] = vec[i];
+		
+		__os_free(self->env , vec);
+		
+		return ret;
+	}
+
+	%typemap(cstype) char ** "List<string>"
+	%typemap(imtype) char ** "IntPtr"
+	%typemap(csin) char ** "$csinput"
+	char **log_archive(u_int32_t flags, int *err, int *cntp) {
+		char **list = NULL;
+		int cnt = 0;
+		*err = self->log_archive(self, &list, flags);
+
+		if (list != NULL)
+			while (list[cnt] != NULL) {
+				cnt++;
+			}
+		*cntp = cnt;
+		return list;
+	}
+	%typemap(cstype) char ** "ref string"
+	%typemap(imtype) char ** "ref string"
+	%typemap(csin) char ** "ref $csinput"
+
+	%typemap(cstype) char *namep "IntPtr"
+	%typemap(imtype) char *namep "IntPtr"
+	%csmethodmodifiers log_file "private"
+	int log_file(const DB_LSN *lsn, char *namep, size_t len) {
+		int ret = self->log_file(self, lsn, namep, len);
+		if (ret == EINVAL)
+			return DB_BUFFER_SMALL;
+		return ret;
+	}
+	
+	int log_flush(const DB_LSN *lsn) {
+		return self->log_flush(self, lsn);
+	}
+	
+	int log_put(DB_LSN *lsn, DBT *data, u_int32_t flags) {
+		return self->log_put(self, lsn, data, flags);
+	}
+	
+	int log_get_config(u_int32_t which, int *onoff) {
+		return self->log_get_config(self, which, onoff);
+	}
+	int log_set_config(u_int32_t which, int onoff) {
+		return self->log_set_config(self, which, onoff);
+	}
+	
+	int log_printf(DB_TXN *txn, const char *str) {
+		return self->log_printf(self, txn, "%s", str);
+	}
+	
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	%csmethodmodifiers log_stat "private"		
+	void *log_stat(u_int32_t flags, int *err) {
+		DB_LOG_STAT *ret;
+		*err = self->log_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+
+	int log_stat_print(u_int32_t flags) {
+		return self->log_stat_print(self, flags);
+	}
+
+
+	int lsn_reset(const char *file, u_int32_t flags) {
+		return self->lsn_reset(self, file, flags);
+	}
+	
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	%typemap(cstype, out="ref IntPtr") void *** "ref IntPtr"
+	%typemap(csin) void *** "ref $csinput"
+	%typemap(imtype, out="ref IntPtr") void *** "ref IntPtr"
+	%csmethodmodifiers memp_stat "private"		
+	void *memp_stat(void ***fstatp, u_int32_t flags, int *err, int *cntp) {
+		DB_MPOOL_STAT *ret;
+		DB_MPOOL_FSTAT **fptr;
+		int cnt;
+
+		*err = self->memp_stat(self, &ret, &fptr, flags);
+		cnt = 0;
+		if (fptr != NULL)
+			while (fptr[cnt] != NULL) {
+				cnt++;
+			}
+
+		*cntp = cnt;
+		*fstatp = (void **)fptr;
+		return (void *)ret;
+	}
+
+	int memp_stat_print(u_int32_t flags) {
+		return self->memp_stat_print(self, flags);
+	}
+
+	int memp_sync(DB_LSN *lsn) {
+		return self->memp_sync(self, lsn);
+	}
+	
+	int memp_trickle(int percent, int *nwrotep) {
+		return self->memp_trickle(self, percent, nwrotep);
+	}
+	
+	int mutex_alloc(u_int32_t flags, db_mutex_t *mutexp) {
+		return self->mutex_alloc(self, flags, mutexp);
+	}
+	
+	int mutex_free(db_mutex_t mutex) {
+		return self->mutex_free(self, mutex);
+	}
+	
+	int mutex_lock(db_mutex_t mutex) {
+		return self->mutex_lock(self, mutex);
+	}
+	
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	%csmethodmodifiers mutex_stat "private"		
+	void *mutex_stat(u_int32_t flags, int *err) {
+		DB_MUTEX_STAT *ret;
+		*err = self->mutex_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+
+	int mutex_stat_print(u_int32_t flags) {
+		return self->mutex_stat_print(self, flags);
+	}
+
+	int mutex_unlock(db_mutex_t mutex) {
+		return self->mutex_unlock(self, mutex);
+	}
+	
+	int mutex_get_align(u_int32_t *align) {
+		return self->mutex_get_align(self, align);
+	}
+	int mutex_set_align(u_int32_t align) {
+		return self->mutex_set_align(self, align);
+	}
+	
+	int mutex_get_increment(u_int32_t *increment) {
+		return self->mutex_get_increment(self, increment);
+	}
+	int mutex_set_increment(u_int32_t increment) {
+		return self->mutex_set_increment(self, increment);
+	}
+	
+	int mutex_get_max(u_int32_t *max) {
+		return self->mutex_get_max(self, max);
+	}
+	int mutex_set_max(u_int32_t max) {
+		return self->mutex_set_max(self, max);
+	}
+	
+	int mutex_get_tas_spins(u_int32_t *tas_spins) {
+		return self->mutex_get_tas_spins(self, tas_spins);
+	}
+	int mutex_set_tas_spins(u_int32_t tas_spins) {
+		return self->mutex_set_tas_spins(self, tas_spins);
+	}
+	
+	int open(const char *home, u_int32_t flags, int mode) {
+		return self->open(self, home, flags, mode);
+	}
+
+	int get_open_flags(u_int32_t *flags) {
+		return self->get_open_flags(self, flags);
+	}
+	
+	int remove(char *db_home, u_int32_t flags) {
+		return self->remove(self, db_home, flags);
+	}
+	
+	int repmgr_add_remote_site(const char *host, u_int port, int *eidp, u_int32_t flags) {
+		return self->repmgr_add_remote_site(self, host, port, eidp, flags);
+	}
+
+	int repmgr_set_ack_policy(int ack_policy) {
+		return self->repmgr_set_ack_policy(self, ack_policy);
+	}
+	int repmgr_get_ack_policy(int *ack_policy) {
+		return self->repmgr_get_ack_policy(self, ack_policy);
+	}
+
+	int repmgr_set_local_site(const char *host, u_int port, u_int32_t flags) {
+		return self->repmgr_set_local_site(self, host, port, flags);
+	}
+
+	%typemap(cstype) DB_REPMGR_SITE * "RepMgrSite[]"
+	%typemap(imtype) DB_REPMGR_SITE * "IntPtr"
+	%csmethodmodifiers repmgr_site_list "private"
+	DB_REPMGR_SITE *repmgr_site_list(u_int *countp, u_int32_t *sizep, int *err) {
+		DB_REPMGR_SITE *listp = NULL;
+	
+		*err = self->repmgr_site_list(self, countp, &listp);
+		*sizep = sizeof(DB_REPMGR_SITE);
+		return listp;
+	}
+
+	int repmgr_start(int nthreads, u_int32_t flags) {
+		return self->repmgr_start(self, nthreads, flags);
+	}
+
+	%csmethodmodifiers repmgr_stat "private"		
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	void *repmgr_stat(u_int32_t flags, int *err) {
+		DB_REPMGR_STAT *ret;
+		*err = self->repmgr_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+
+	int repmgr_stat_print(u_int32_t flags) {
+		return self->repmgr_stat_print(self, flags);
+	}
+
+	int rep_elect(u_int32_t nsites, u_int32_t nvotes, u_int32_t flags) {
+		return self->rep_elect(self, nsites, nvotes, flags);
+	}
+
+	int rep_process_message(DBT *control, DBT *rec, int envid, DB_LSN *ret_lsnp) {
+		return self->rep_process_message(self, control, rec, envid, ret_lsnp);
+	}
+
+	int rep_start(DBT *cdata, u_int32_t flags) {
+		return self->rep_start(self, cdata, flags);
+	}
+
+	%csmethodmodifiers rep_stat "private"		
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	void *rep_stat(u_int32_t flags, int *err) {
+		DB_REP_STAT *ret;
+		*err = self->rep_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+
+	int rep_stat_print(u_int32_t flags) {
+		return self->rep_stat_print(self, flags);
+	}
+
+	int rep_sync(u_int32_t flags) {
+		return self->rep_sync(self, flags);
+	}
+
+	int rep_set_config(u_int32_t which, int onoff) {
+		return self->rep_set_config(self, which, onoff);
+	}
+	int rep_get_config(u_int32_t which, int *onoffp) {
+		return self->rep_get_config(self, which, onoffp);
+	}
+
+	int rep_set_clockskew(u_int32_t fast_clock, u_int32_t slow_clock) {
+		return self->rep_set_clockskew(self, fast_clock, slow_clock);
+	}
+	int rep_get_clockskew(u_int32_t *fast_clockp, u_int32_t *slow_clockp) {
+		return self->rep_get_clockskew(self, fast_clockp, slow_clockp);
+	}
+
+	int rep_set_limit(u_int32_t gbytes, u_int32_t bytes) {
+		return self->rep_set_limit(self, gbytes, bytes);
+	}
+	int rep_get_limit(u_int32_t *gbytesp, u_int32_t *bytesp) {
+		return self->rep_get_limit(self, gbytesp, bytesp);
+	}
+
+	int rep_set_nsites(u_int32_t nsites) {
+		return self->rep_set_nsites(self, nsites);
+	}
+	int rep_get_nsites(u_int32_t *nsitesp) {
+		return self->rep_get_nsites(self, nsitesp);
+	}
+
+	int rep_set_priority(u_int32_t priority) {
+		return self->rep_set_priority(self, priority);
+	}
+	int rep_get_priority(u_int32_t *priorityp) {
+		return self->rep_get_priority(self, priorityp);
+	}
+
+	int rep_set_request(u_int32_t min, u_int32_t max) {
+		return self->rep_set_request(self, min, max);
+	}
+	int rep_get_request(u_int32_t *minp, u_int32_t *maxp) {
+		return self->rep_get_request(self, minp, maxp);
+	}
+
+	int rep_set_timeout(int which, u_int32_t timeout) {
+		return self->rep_set_timeout(self, which, timeout);
+	}
+	int rep_get_timeout(int which, u_int32_t *timeoutp) {
+		return self->rep_get_timeout(self, which, timeoutp);
+	}
+
+	%typemap(cstype) int (*)(DB_ENV*, const DBT*, const DBT*, const DB_LSN *, int envid, u_int32_t) "BDB_RepTransportDelegate"
+	%typemap(imtype) int (*)(DB_ENV*, const DBT*, const DBT*, const DB_LSN *, int envid, u_int32_t) "BDB_RepTransportDelegate"
+	%typemap(csin) int (*send)(DB_ENV *, const DBT*, const DBT*, const DB_LSN*, int, u_int32_t) "send"
+	int rep_set_transport(int envid, int (*send)(DB_ENV *dbenv, const DBT *control, const DBT *rec, const DB_LSN *lsnp, int envid, u_int32_t flags)) {
+		return self->rep_set_transport(self, envid, send);
+	}
+	
+	int get_cachesize(u_int32_t *gbytes, u_int32_t *bytes, int *ncache) {
+		return self->get_cachesize(self, gbytes, bytes, ncache);
+	}
+	int set_cachesize(u_int32_t gbytes, u_int32_t bytes, int ncache) {
+		return self->set_cachesize(self, gbytes, bytes, ncache);
+	}
+	
+	int get_cache_max(u_int32_t *gbytes, u_int32_t *bytes) {
+		return self->get_cache_max(self, gbytes, bytes);
+	}
+	int set_cache_max(u_int32_t gbytes, u_int32_t bytes) {
+		return self->set_cache_max(self, gbytes, bytes);
+	}
+	
+	%typemap(cstype) char ** "List<string>"
+	%typemap(imtype) char ** "IntPtr"
+	%typemap(csin) char ** "$csinput"
+	%csmethodmodifiers get_data_dirs "private"
+	char **get_data_dirs(int *err, int *cntp) {
+		char **list = NULL;
+		int cnt = 0;
+		*err = self->get_data_dirs(self, &list);
+
+		if (list != NULL)
+			while (list[cnt] != NULL) {
+				cnt++;
+			}
+		*cntp = cnt;
+		return list;
+	}
+	
+	int add_data_dir(const char *dir) {
+		return self->add_data_dir(self, dir);
+	}
+	
+	int set_create_dir(const char *dir) {
+		return self->set_create_dir(self, dir);
+	}
+
+	int get_encrypt_flags(u_int32_t *flags) {
+		return self->get_encrypt_flags(self, flags);
+	}
+	int set_encrypt(const char *passwd, u_int32_t flags) {
+		return self->set_encrypt(self, passwd, flags);
+	}
+	
+	%typemap(cstype) void (*)(const DB_ENV *, const char *, const char *) "BDB_ErrcallDelegate"
+	%typemap(imtype) void (*)(const DB_ENV *, const char *, const char *) "BDB_ErrcallDelegate"
+	%typemap(csin) void (*db_errcall_fcn)(const DB_ENV *dbenv, const char *errpfx, const char *errmsg) "db_errcall_fcn"
+	void set_errcall(void (*db_errcall_fcn)(const DB_ENV *dbenv, const char *errpfx, const char *errmsg)) {
+		self->set_errcall(self, db_errcall_fcn);
+	}
+
+	%typemap(cstype) void (*)(DB_ENV*, u_int32_t, void*) "BDB_EventNotifyDelegate"
+	%typemap(imtype) void (*)(DB_ENV*, u_int32_t, void*) "BDB_EventNotifyDelegate"
+	%typemap(csin) void (*callback)(DB_ENV *dbenv, u_int32_t, void*) "callback"
+	int set_event_notify(void (*callback)(DB_ENV *env, u_int32_t event, void *event_info)) {
+		return self->set_event_notify(self, callback);
+	}
+	
+	%typemap(cstype) void (*)(DB_ENV*, int, int) "BDB_EnvFeedbackDelegate"
+	%typemap(imtype) void (*)(DB_ENV*, int, int) "BDB_EnvFeedbackDelegate"
+	%typemap(csin) void (*callback)(DB_ENV *dbenv, int opcode, int percent) "callback"
+	int set_feedback(void (*callback)(DB_ENV *dbenv, int opcode, int percent)) {
+		return self->set_feedback(self, callback);
+	}
+	
+	int get_flags(u_int32_t *flags) {
+		return self->get_flags(self, flags);
+	}
+	int set_flags(u_int32_t flags, int onoff) {
+		return self->set_flags(self, flags, onoff);
+	}
+	
+	%typemap(cstype) char ** "ref string"
+	%typemap(imtype) char ** "ref string"
+	%typemap(csin) char ** "ref $csinput"
+	%csmethodmodifiers get_data_dirs "private"
+	int get_intermediate_dir_mode(const char **mode) {
+		return self->get_intermediate_dir_mode(self, mode);
+	}
+	int set_intermediate_dir_mode(const char *mode) {
+		return self->set_intermediate_dir_mode(self, mode);
+	}
+	
+	%typemap(cstype) int (*)(DB_ENV*, pid_t, db_threadid_t, u_int32_t) "BDB_IsAliveDelegate"
+	%typemap(imtype) int (*)(DB_ENV*, pid_t, db_threadid_t, u_int32_t) "BDB_IsAliveDelegate"
+	%typemap(csin) int (*callback)(DB_ENV *dbenv, pid_t, db_threadid_t, u_int32_t) "callback"
+	int set_isalive(int (*callback)(DB_ENV *dbenv, pid_t pid, db_threadid_t tid, u_int32_t flags)) {
+		return self->set_isalive(self, callback);
+	}
+	
+	int get_lg_bsize(u_int32_t *bsize){
+		return self->get_lg_bsize(self, bsize);
+	}
+	int set_lg_bsize(u_int32_t bsize){
+		return self->set_lg_bsize(self, bsize);
+	}
+	int get_lg_dir(const char **dir){
+		return self->get_lg_dir(self, dir);
+	}
+	int set_lg_dir(const char *dir){
+		return self->set_lg_dir(self, dir);
+	}
+	int get_lg_filemode(int *mode){
+		return self->get_lg_filemode(self, mode);
+	}
+	int set_lg_filemode(int mode){
+		return self->set_lg_filemode(self, mode);
+	}
+	int get_lg_max(u_int32_t *max){
+		return self->get_lg_max(self, max);
+	}
+	int set_lg_max(u_int32_t max){
+		return self->set_lg_max(self, max);
+	}
+	int get_lg_regionmax(u_int32_t *max){
+		return self->get_lg_regionmax(self, max);
+	}
+	int set_lg_regionmax(u_int32_t max){
+		return self->set_lg_regionmax(self, max);
+	}
+	
+	int get_lk_conflicts_nmodes(int *nmodes) {
+		return self->get_lk_conflicts(self, NULL, nmodes);
+	}
+	
+	int get_lk_conflicts(u_int8_t *conflicts) {
+		int i, nmodes, ret;
+		u_int8_t *mtrx = NULL;
+		
+		ret = self->get_lk_conflicts(self, &mtrx, &nmodes);
+		for (i = 0; i < nmodes * nmodes; i++)
+			conflicts[i] = mtrx[i];
+		
+		return ret;
+	}
+	int set_lk_conflicts(u_int8_t *conflicts, int nmodes) {
+		return self->set_lk_conflicts(self, conflicts, nmodes);
+	}
+	
+	int get_lk_detect(u_int32_t *mode) {
+		return self->get_lk_detect(self, mode);
+	}
+	int set_lk_detect(u_int32_t mode) {
+		return self->set_lk_detect(self, mode);
+	}
+	
+	int get_lk_max_locks(u_int32_t *max) {
+		return self->get_lk_max_locks(self, max);
+	}
+	int set_lk_max_locks(u_int32_t max) {
+		return self->set_lk_max_locks(self, max);
+	}
+	
+	int get_lk_max_lockers(u_int32_t *max) {
+		return self->get_lk_max_lockers(self, max);
+	}
+	int set_lk_max_lockers(u_int32_t max) {
+		return self->set_lk_max_lockers(self, max);
+	}
+	
+	int get_lk_max_objects(u_int32_t *max) {
+		return self->get_lk_max_objects(self, max);
+	}
+	int set_lk_max_objects(u_int32_t max) {
+		return self->set_lk_max_objects(self, max);
+	}
+	
+	int get_lk_partitions(u_int32_t *max) {
+		return self->get_lk_partitions(self, max);
+	}
+	int set_lk_partitions(u_int32_t max) {
+		return self->set_lk_partitions(self, max);
+	}
+	
+	int get_mp_max_openfd(int *maxopenfd) {
+		return self->get_mp_max_openfd(self, maxopenfd);
+	}
+	int set_mp_max_openfd(int maxopenfd) {
+		return self->set_mp_max_openfd(self, maxopenfd);
+	}
+	
+	int get_mp_max_write(int *maxwrite, db_timeout_t *maxwrite_sleep) {
+		return self->get_mp_max_write(self, maxwrite, maxwrite_sleep);
+	}
+	int set_mp_max_write(int maxwrite, db_timeout_t maxwrite_sleep) {
+		return self->set_mp_max_write(self, maxwrite, maxwrite_sleep);
+	}
+	
+	int get_mp_mmapsize(size_t *mp_mmapsize) {
+		return self->get_mp_mmapsize(self, mp_mmapsize);
+	}
+	int set_mp_mmapsize(size_t mp_mmapsize) {
+		return self->set_mp_mmapsize(self, mp_mmapsize);
+	}
+	
+	int get_thread_count(u_int32_t *count) {
+		return self->get_thread_count(self, count);
+	}
+	int set_thread_count(u_int32_t count) {
+		return self->set_thread_count(self, count);
+	}
+	
+	%typemap(cstype) void (*)(DB_ENV*, pid_t*, db_threadid_t*) "BDB_ThreadIDDelegate"
+	%typemap(imtype) void (*)(DB_ENV*, pid_t*, db_threadid_t*) "BDB_ThreadIDDelegate"
+	%typemap(csin) void (*callback)(DB_ENV *dbenv, pid_t*, db_threadid_t*) "callback"
+	int set_thread_id(void (*callback)(DB_ENV *dbenv, pid_t *pid, db_threadid_t *tid)) {
+		return self->set_thread_id(self, callback);
+	}
+	
+	%typemap(cstype) char* (*)(DB_ENV*, pid_t, db_threadid_t, char *) "BDB_ThreadNameDelegate"
+	%typemap(imtype) char* (*)(DB_ENV*, pid_t, db_threadid_t, char *) "BDB_ThreadNameDelegate"
+	%typemap(csin) char *(*callback)(DB_ENV *dbenv, pid_t, db_threadid_t, char *) "callback"
+	int set_thread_id_string(char *(*callback)(DB_ENV *dbenv, pid_t pid, db_threadid_t tid, char *buf)) {
+		return self->set_thread_id_string(self, callback);
+	}
+
+	int get_timeout(db_timeout_t *timeout, u_int32_t flags) {
+		return self->get_timeout(self, timeout, flags);
+	}
+	int set_timeout(db_timeout_t timeout, u_int32_t flags) {
+		return self->set_timeout(self, timeout, flags);
+	}
+	
+	int get_tmp_dir(const char **dir) {
+		return self->get_tmp_dir(self, dir);
+	}
+	int set_tmp_dir(const char *dir) {
+		return self->set_tmp_dir(self, dir);
+	}
+	
+	int get_tx_max(u_int32_t *max) {
+		return self->get_tx_max(self, max);
+	}
+	int set_tx_max(u_int32_t max) {
+		return self->set_tx_max(self, max);
+	}
+	
+	int get_tx_timestamp(time_t *timestamp) {
+		return self->get_tx_timestamp(self, timestamp);
+	}
+	int set_tx_timestamp(time_t *timestamp) {
+		return self->set_tx_timestamp(self, timestamp);
+	}
+	
+	int get_verbose(u_int32_t *msgs) {
+		int onoff, ret;
+		
+		*msgs = 0;
+		if ((ret = self->get_verbose(self, DB_VERB_DEADLOCK, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_DEADLOCK;
+		if ((ret = self->get_verbose(self, DB_VERB_FILEOPS, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_FILEOPS;
+		if ((ret = self->get_verbose(self, DB_VERB_FILEOPS_ALL, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_FILEOPS_ALL;
+		if ((ret = self->get_verbose(self, DB_VERB_RECOVERY, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_RECOVERY;
+		if ((ret = self->get_verbose(self, DB_VERB_REGISTER, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REGISTER;
+		if ((ret = self->get_verbose(self, DB_VERB_REPLICATION, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REPLICATION;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_ELECT, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_ELECT;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_LEASE, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_LEASE;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_MISC, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_MISC;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_MSGS, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_MSGS;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_SYNC, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_SYNC;
+		if ((ret = self->get_verbose(self, DB_VERB_REPMGR_CONNFAIL, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REPMGR_CONNFAIL;
+		if ((ret = self->get_verbose(self, DB_VERB_REPMGR_MISC, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REPMGR_MISC;
+		if ((ret = self->get_verbose(self, DB_VERB_WAITSFOR, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_WAITSFOR;
+		
+		return 0;
+	}
+	int set_verbose(u_int32_t which, int onoff) {
+		int ret;
+
+		if ((which & DB_VERB_DEADLOCK) && 
+			(ret = self->set_verbose(self, DB_VERB_DEADLOCK, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_FILEOPS) && 
+			(ret = self->set_verbose(self, DB_VERB_FILEOPS, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_FILEOPS_ALL) && 
+			(ret = self->set_verbose(self, DB_VERB_FILEOPS_ALL, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_RECOVERY) && 
+			(ret = self->set_verbose(self, DB_VERB_RECOVERY, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REGISTER) && 
+			(ret = self->set_verbose(self, DB_VERB_REGISTER, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REPLICATION) && 
+			(ret = self->set_verbose(self, DB_VERB_REPLICATION, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_ELECT) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_ELECT, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_LEASE) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_LEASE, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_MISC) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_MISC, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_MSGS) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_MSGS, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_SYNC) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_SYNC, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REPMGR_CONNFAIL) && 
+			(ret = self->set_verbose(self, DB_VERB_REPMGR_CONNFAIL, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REPMGR_MISC) &&
+			(ret = self->set_verbose(self, DB_VERB_REPMGR_MISC, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_WAITSFOR) &&
+			(ret = self->set_verbose(self, DB_VERB_WAITSFOR, onoff)) != 0)
+			return ret;
+		return 0;
+	}
+	
+	int stat_print(u_int32_t flags) {
+		return self->stat_print(self, flags);
+	}
+
+	%csmethodmodifiers txn_begin "private"
+	DB_TXN *txn_begin(DB_TXN *parent, u_int32_t flags, int *err) {
+		DB_TXN *txnid = NULL;
+		
+		*err = self->txn_begin(self, parent, &txnid, flags);
+		return txnid;
+	}
+	
+	int txn_checkpoint(u_int32_t kbyte, u_int32_t min, u_int32_t flags) {
+		return self->txn_checkpoint(self, kbyte, min, flags);
+	}
+	
+	%csmethodmodifiers txn_recover "private"
+	%typemap(cstype) DB_PREPLIST [] "IntPtr"
+	%typemap(imtype) DB_PREPLIST [] "IntPtr"
+	%typemap(csin) DB_PREPLIST [] "$csinput"
+	int txn_recover(DB_PREPLIST preplist[], u_int32_t count, u_int32_t *retp, u_int32_t flags) {
+		return self->txn_recover(self, preplist, count, retp, flags);
+	}
+
+	%csmethodmodifiers txn_stat "private"		
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	void *txn_stat(u_int32_t flags, u_int32_t *size, int *err) {
+		DB_TXN_STAT *ret;
+		*err = self->txn_stat(self, &ret, flags);
+		*size = sizeof(DB_TXN_ACTIVE);
+		return (void *)ret;
+	}
+
+	int txn_stat_print(u_int32_t flags) {
+		return self->txn_stat_print(self, flags);
+	}
+
+}
+} DB_ENV;
+
+typedef struct __key_range {
+	double less;
+	double equal;
+	double greater;
+} DB_KEY_RANGE;
+
+typedef struct __db_lock_u {
+	roff_t		off;		/* Offset of the lock in the region */
+	u_int32_t	ndx;		/* Index of the object referenced by
+					 * this lock; used for locking. */
+	u_int32_t	gen;		/* Generation number of this lock. */
+	db_lockmode_t	mode;		/* mode of this lock. */
+} DB_LOCK;
+
+typedef struct __db_lockreq {
+	db_lockop_t	 op;		/* Operation. */
+	db_lockmode_t	 mode;		/* Requested mode. */
+	db_timeout_t	 timeout;	/* Time to expire lock. */
+	DBT		*obj;		/* Object being locked. */
+	%rename(lck) lock;
+	DB_LOCK		 lock;		/* Lock returned. */
+} DB_LOCKREQ;
+
+char *db_strerror(int errno);
+int log_compare(DB_LSN *lsn0, DB_LSN *lsn1);
+%typemap(cstype) void *ptr "IntPtr"
+%typemap(imtype) void *ptr "IntPtr"
+%typemap(csin) void *ptr "$csinput"
+%rename(__os_ufree) wrap_ufree;
+%inline %{
+void wrap_ufree(DB_ENV *dbenv, void *ptr) {
+	if (dbenv == NULL)
+		__os_ufree(NULL, ptr);
+	else
+		__os_ufree(dbenv->env, ptr);
+}
+%}
+
+typedef struct __db_preplist {
+	%typemap(csvarout) u_int8_t gid[DB_GID_SIZE] %{
+        get {
+          byte[] ret = new byte[DbConstants.DB_GID_SIZE];
+	  IntPtr cPtr = new IntPtr(swigCPtr.Handle.ToInt32() + IntPtr.Size);
+	  Marshal.Copy(cPtr, ret, 0, ret.Length);
+	  return ret;
+        }
+	%}
+
+	DB_TXN	*txn;
+	u_int8_t gid[DB_GID_SIZE];
+} DB_PREPLIST;
+
+%typemap(cscode) DB_SEQUENCE %{
+	internal SequenceStatStruct stat(uint flags) {
+		int err = 0;
+		IntPtr ptr = stat(flags, ref err);
+		DatabaseException.ThrowException(err);
+		SequenceStatStruct ret = (SequenceStatStruct)Marshal.PtrToStructure(ptr, typeof(SequenceStatStruct));
+		libdb_csharp.__os_ufree(null, ptr);
+		return ret;
+	}
+%}
+typedef struct __db_sequence {
+%extend {
+	DB_SEQUENCE(DB *dbp, u_int32_t flags) {
+		DB_SEQUENCE *seq = NULL;
+		int ret;
+		
+		ret = db_sequence_create(&seq, dbp, flags);
+		if (ret == 0)
+			return seq;
+		else
+			return NULL;
+	}
+	
+	~DB_SEQUENCE() { }
+
+	int close(u_int32_t flags) {
+		return self->close(self, flags);
+	}
+	
+	int get(DB_TXN *txn, int32_t delta, db_seq_t *retp, u_int32_t flags) {
+		return self->get(self, txn, delta, retp, flags);
+	}
+	
+	DB *get_db() {
+		DB *dbp = NULL;
+		int err = 0;
+		err = self->get_db(self, &dbp);
+		return dbp;
+	}
+	
+	int get_key(DBT *key) {
+		return self->get_key(self, key);
+	}
+	
+	int initial_value(db_seq_t value) {
+		return self->initial_value(self, value);
+	}
+	
+	int open(DB_TXN *txn, DBT *key, u_int32_t flags) {
+		return self->open(self, txn, key, flags);
+	}
+	
+	int remove(DB_TXN *txn, u_int32_t flags) {
+		return self->remove(self, txn, flags);
+	}
+	
+	int get_cachesize(int32_t *size) {
+		return self->get_cachesize(self, size);
+	}
+	int set_cachesize(int32_t size) {
+		return self->set_cachesize(self, size);
+	}
+	
+	int get_flags(u_int32_t *flags) {
+		return self->get_flags(self, flags);
+	}
+	int set_flags(u_int32_t flags) {
+		return self->set_flags(self, flags);
+	}
+	
+	int get_range(db_seq_t *min, db_seq_t *max) {
+		return self->get_range(self, min, max);
+	}
+	int set_range(db_seq_t min, db_seq_t max) {
+		return self->set_range(self, min, max);
+	}
+
+	%csmethodmodifiers stat "private"		
+	%typemap(cstype, out="IntPtr") void * "IntPtr"
+	void *stat(u_int32_t flags, int *err) {
+		DB_SEQUENCE_STAT *ret = NULL;
+
+		*err = self->stat(self, &ret, flags);
+		return (void *)ret;
+	}
+
+	int stat_print(u_int32_t flags) {
+		return self->stat_print(self, flags);
+	}
+}
+} DB_SEQUENCE;
+
+%pragma(csharp) imclasscode=%{
+#if DEBUG
+	private const string libname = "libdb_csharp" + DbConstants.DB_VERSION_MAJOR_STR + DbConstants.DB_VERSION_MINOR_STR + "d";
+#else
+	private const string libname = "libdb_csharp" + DbConstants.DB_VERSION_MAJOR_STR + DbConstants.DB_VERSION_MINOR_STR;
+#endif
+%}
diff --git a/libdb_csharp/db_csharp_wrap.c b/libdb_csharp/db_csharp_wrap.c
new file mode 100644
index 00000000..d78cdca6
--- /dev/null
+++ b/libdb_csharp/db_csharp_wrap.c
@@ -0,0 +1,5934 @@
+#include "db_config.h"
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.38
+ * 
+ * This file is not intended to be easily readable and contains a number of 
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG 
+ * interface file instead. 
+ * ----------------------------------------------------------------------------- */
+
+#define SWIGCSHARP
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__)) 
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__)) 
+# else
+#   define SWIGUNUSED 
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif 
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#  ifndef GCC_HASCLASSVISIBILITY
+#    define GCC_HASCLASSVISIBILITY
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif 
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# undef _CRT_SECURE_NO_DEPRECATE
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+
+/* Callback for returning strings to C# without leaking memory */
+typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
+static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
+
+
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_libdb_csharp(SWIG_CSharpStringHelperCallback callback) {
+  SWIG_csharp_string_callback = callback;
+}
+
+
+/* Contract support */
+
+#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
+
+
+#include "db_int.h"
+#include "dbinc/txn.h"
+#include "db.h"
+
+SWIGINTERN int DB_set_usercopy(DB *self,int (*dbt_usercopy)(DBT *,u_int32_t,void *,u_int32_t,u_int32_t)){
+		self->env->dbt_usercopy = dbt_usercopy;
+		return 0;
+	}
+SWIGINTERN DB *new_DB(DB_ENV *env,u_int32_t flags){
+		DB *self = NULL;
+		errno = db_create(&self, env, flags);
+		return self;
+	}
+SWIGINTERN void delete_DB(DB *self){ }
+SWIGINTERN int DB_associate(DB *self,DB_TXN *txn,DB *sec,int (*callback)(DB *,DBT const *,DBT const *,DBT *),u_int32_t flags){
+		return self->associate(self, txn, sec, callback, flags);
+	}
+SWIGINTERN int DB_associate_foreign(DB *self,DB *dbp,int (*callback)(DB *,DBT const *,DBT *,DBT const *,int *),u_int32_t flags){
+		return self->associate_foreign(self, dbp, callback, flags);
+	}
+SWIGINTERN int DB_close(DB *self,u_int32_t flags){
+		return self->close(self, flags);
+	}
+SWIGINTERN int DB_compact(DB *self,DB_TXN *txn,DBT *start,DBT *stop,DB_COMPACT *cdata,u_int32_t flags,DBT *end){
+		return self->compact(self, txn, start, stop, cdata, flags, end);
+	}
+SWIGINTERN DBC *DB_cursor(DB *self,DB_TXN *txn,u_int32_t flags,int *err){
+		DBC *cursor = NULL;
+		
+		*err = self->cursor(self, txn, &cursor, flags);
+		return cursor;
+	}
+SWIGINTERN int DB_del(DB *self,DB_TXN *txn,DBT *key,u_int32_t flags){
+		return self->del(self, txn, key, flags);
+	}
+SWIGINTERN DB_ENV *DB_env(DB *self){
+		return self->dbenv;
+	}
+SWIGINTERN int DB_exists(DB *self,DB_TXN *txn,DBT *key,u_int32_t flags){
+		return self->exists(self, txn, key, flags);
+	}
+SWIGINTERN int DB_get(DB *self,DB_TXN *txn,DBT *key,DBT *data,u_int32_t flags){
+		return self->get(self, txn, key, data, flags);
+	}
+SWIGINTERN int DB_get_byteswapped(DB *self,int *isswapped){
+		return self->get_byteswapped(self, isswapped);
+	}
+SWIGINTERN int DB_get_dbname(DB *self,char const **filenamep,char const **dbnamep){
+		return self->get_dbname(self, filenamep, dbnamep);
+	}
+SWIGINTERN int DB_get_multiple(DB *self){
+		return self->get_multiple(self);
+	}
+SWIGINTERN int DB_get_open_flags(DB *self,u_int32_t *flags){
+		return self->get_open_flags(self, flags);
+	}
+SWIGINTERN int DB_get_transactional(DB *self){
+		return self->get_transactional(self);
+	}
+SWIGINTERN int DB_get_type(DB *self,DBTYPE *type){
+		return self->get_type(self, type);
+	}
+SWIGINTERN DBC *DB_join(DB *self,DBC **curslist,u_int32_t flags,int *err){
+		DBC *dbc = NULL;
+		
+		*err = self->join(self, curslist, &dbc, flags);
+		return dbc;
+	}
+SWIGINTERN int DB_key_range(DB *self,DB_TXN *txn,DBT *key,DB_KEY_RANGE *range,u_int32_t flags){
+		return self->key_range(self, txn, key, range, flags);
+	}
+SWIGINTERN int DB_open(DB *self,DB_TXN *txn,char const *file,char const *database,DBTYPE type,u_int32_t flags,int mode){
+		return self->open(self, txn, file, database, type, flags, mode);
+	}
+SWIGINTERN int DB_pget(DB *self,DB_TXN *txn,DBT *key,DBT *pkey,DBT *data,u_int32_t flags){
+		return self->pget(self, txn, key, pkey, data, flags);
+	}
+SWIGINTERN int DB_put(DB *self,DB_TXN *txn,DBT *key,DBT *data,u_int32_t flags){
+		return self->put(self, txn, key, data, flags);
+	}
+SWIGINTERN int DB_remove(DB *self,char const *file,char const *database,u_int32_t flags){
+		return self->remove(self, file, database, flags);
+	}
+SWIGINTERN int DB_rename(DB *self,char const *file,char const *database,char const *newname,u_int32_t flags){
+		return self->rename(self, file, database, newname, flags);
+	}
+SWIGINTERN int DB_set_append_recno(DB *self,int (*callback)(DB *,DBT *,db_recno_t)){
+		return self->set_append_recno(self, callback);
+	}
+SWIGINTERN int DB_set_bt_compare(DB *self,int (*callback)(DB *,DBT const *,DBT const *)){
+		return self->set_bt_compare(self, callback);
+	}
+SWIGINTERN int DB_set_bt_compress(DB *self,int (*compress)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *),int (*decompress)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *)){
+		return self->set_bt_compress(self, compress, decompress);
+	}
+SWIGINTERN int DB_get_bt_minkey(DB *self,u_int32_t *bt_minkey){
+		return self->get_bt_minkey(self, bt_minkey);
+	}
+SWIGINTERN int DB_set_bt_minkey(DB *self,u_int32_t bt_minkey){
+		return self->set_bt_minkey(self, bt_minkey);
+	}
+SWIGINTERN int DB_set_bt_prefix(DB *self,int (*callback)(DB *,DBT const *,DBT const *)){
+		return self->set_bt_prefix(self, callback);
+	}
+SWIGINTERN int DB_get_cachesize(DB *self,u_int32_t *gbytes,u_int32_t *bytes,int *ncache){
+		return self->get_cachesize(self, gbytes, bytes, ncache);
+	}
+SWIGINTERN int DB_set_cachesize(DB *self,u_int32_t gbytes,u_int32_t bytes,int ncache){
+		return self->set_cachesize(self, gbytes, bytes, ncache);
+	}
+SWIGINTERN int DB_set_dup_compare(DB *self,int (*callback)(DB *,DBT const *,DBT const *)){
+		return self->set_dup_compare(self, callback);
+	}
+SWIGINTERN int DB_get_encrypt_flags(DB *self,u_int32_t *flags){
+		return self->get_encrypt_flags(self, flags);
+	}
+SWIGINTERN int DB_set_encrypt(DB *self,char const *pwd,u_int32_t flags){
+		return self->set_encrypt(self, pwd, flags);
+	}
+SWIGINTERN void DB_set_errcall(DB *self,void (*db_errcall_fcn)(DB_ENV const *,char const *,char const *)){
+		self->set_errcall(self, db_errcall_fcn);
+	}
+SWIGINTERN int DB_set_feedback(DB *self,int (*callback)(DB *,int,int)){
+		return self->set_feedback(self, callback);
+	}
+SWIGINTERN int DB_get_flags(DB *self,u_int32_t *flags){
+		return self->get_flags(self, flags);
+	}
+SWIGINTERN int DB_set_flags(DB *self,u_int32_t flags){
+		return self->set_flags(self, flags);
+	}
+SWIGINTERN int DB_set_h_compare(DB *self,int (*callback)(DB *,DBT const *,DBT const *)){
+		return self->set_h_compare(self, callback);
+	}
+SWIGINTERN int DB_get_h_ffactor(DB *self,u_int32_t *ffactor){
+		return self->get_h_ffactor(self, ffactor);
+	}
+SWIGINTERN int DB_set_h_ffactor(DB *self,u_int32_t ffactor){
+		return self->set_h_ffactor(self, ffactor);
+	}
+SWIGINTERN int DB_set_h_hash(DB *self,u_int32_t (*callback)(DB *,void const *,u_int32_t)){
+		return self->set_h_hash(self, callback);
+	}
+SWIGINTERN int DB_get_h_nelem(DB *self,u_int32_t *nelem){
+		return self->get_h_nelem(self, nelem);
+	}
+SWIGINTERN int DB_set_h_nelem(DB *self,u_int32_t nelem){
+		return self->set_h_nelem(self, nelem);
+	}
+SWIGINTERN int DB_get_lorder(DB *self,int *lorder){
+		return self->get_lorder(self, lorder);
+	}
+SWIGINTERN int DB_set_lorder(DB *self,int lorder){
+		return self->set_lorder(self, lorder);
+	}
+SWIGINTERN int DB_get_pagesize(DB *self,u_int32_t *pgsz){
+		return self->get_pagesize(self, pgsz);
+	}
+SWIGINTERN int DB_set_pagesize(DB *self,u_int32_t pgsz){
+		return self->set_pagesize(self, pgsz);
+	}
+SWIGINTERN int DB_get_priority(DB *self,DB_CACHE_PRIORITY *flags){
+		return self->get_priority(self, flags);
+	}
+SWIGINTERN int DB_set_priority(DB *self,DB_CACHE_PRIORITY flags){
+		return self->set_priority(self, flags);
+	}
+SWIGINTERN int DB_get_q_extentsize(DB *self,u_int32_t *extentsz){
+		return self->get_q_extentsize(self, extentsz);
+	}
+SWIGINTERN int DB_set_q_extentsize(DB *self,u_int32_t extentsz){
+		return self->set_q_extentsize(self, extentsz);
+	}
+SWIGINTERN int DB_get_re_delim(DB *self,int *delim){
+		return self->get_re_delim(self, delim);
+	}
+SWIGINTERN int DB_set_re_delim(DB *self,int delim){
+		return self->set_re_delim(self, delim);
+	}
+SWIGINTERN int DB_get_re_len(DB *self,u_int32_t *len){
+		return self->get_re_len(self, len);
+	}
+SWIGINTERN int DB_set_re_len(DB *self,u_int32_t len){
+		return self->set_re_len(self, len);
+	}
+SWIGINTERN int DB_get_re_pad(DB *self,int *pad){
+		return self->get_re_pad(self, pad);
+	}
+SWIGINTERN int DB_set_re_pad(DB *self,int pad){
+		return self->set_re_pad(self, pad);
+	}
+SWIGINTERN int DB_get_re_source(DB *self,char const **source){
+		return self->get_re_source(self, source);
+	}
+SWIGINTERN int DB_set_re_source(DB *self,char *source){
+		return self->set_re_source(self, source);
+	}
+SWIGINTERN void *DB_stat(DB *self,DB_TXN *txnid,u_int32_t flags,int *err){
+		void *ret = NULL;
+
+		*err = self->stat(self, txnid, &ret, flags);
+		return ret;
+	}
+SWIGINTERN int DB_stat_print(DB *self,u_int32_t flags){
+		return self->stat_print(self, flags);
+	}
+SWIGINTERN int DB_sync(DB *self,u_int32_t flags){
+		return self->sync(self, flags);
+	}
+SWIGINTERN int DB_truncate(DB *self,DB_TXN *txn,u_int32_t *countp,u_int32_t flags){
+		return self->truncate(self, txn, countp, flags);
+	}
+SWIGINTERN int DB_upgrade(DB *self,char const *file,u_int32_t flags){
+		return self->upgrade(self, file, flags);
+	}
+SWIGINTERN int DB_verify(DB *self,char const *file,char const *database,FILE *handle,int (*callback)(void *,void const *),u_int32_t flags){
+		/*
+		 * We can't easily #include "dbinc/db_ext.h" because of name
+		 * clashes, so we declare this explicitly.
+		 */
+		extern int __db_verify_internal __P((DB *, const char *, const
+		    char *, void *, int (*)(void *, const void *), u_int32_t));
+		return __db_verify_internal(self, file, database, (void *)handle, callback, flags);
+	}
+SWIGINTERN int DBC_close(DBC *self){
+		return self->close(self);
+	}
+SWIGINTERN int DBC_cmp(DBC *self,DBC *other_dbc,int *result,u_int32_t flags){
+		return self->cmp(self, other_dbc, result, flags);
+	}
+SWIGINTERN int DBC_count(DBC *self,db_recno_t *cnt,u_int32_t flags){
+		return self->count(self, cnt, flags);
+	}
+SWIGINTERN int DBC_del(DBC *self,u_int32_t flags){
+		return self->del(self, flags);
+	}
+SWIGINTERN DBC *DBC_dup(DBC *self,u_int32_t flags,int *err){
+		DBC *cursor = NULL;
+		
+		*err = self->dup(self, &cursor, flags);
+		return cursor;
+	}
+SWIGINTERN int DBC_get(DBC *self,DBT *key,DBT *data,u_int32_t flags){
+		return self->get(self, key, data, flags);
+	}
+SWIGINTERN int DBC_pget(DBC *self,DBT *key,DBT *pkey,DBT *data,u_int32_t flags){
+		return self->pget(self, key, pkey, data, flags);
+	}
+SWIGINTERN int DBC_put(DBC *self,DBT *key,DBT *data,u_int32_t flags){
+		return self->put(self, key, data, flags);
+	}
+SWIGINTERN int DBC_set_priority(DBC *self,u_int32_t priority){
+		return self->set_priority(self, priority);
+	}
+SWIGINTERN DBT *new_DBT(){
+		DBT *self = NULL;
+		self = malloc(sizeof(DBT));
+		memset(self, 0, sizeof(DBT));
+		return self;
+	}
+SWIGINTERN int DB_TXN_abort(DB_TXN *self){
+		return self->abort(self);
+	}
+SWIGINTERN int DB_TXN_commit(DB_TXN *self,u_int32_t flags){
+		return self->commit(self, flags);
+	}
+SWIGINTERN int DB_TXN_discard(DB_TXN *self,u_int32_t flags){
+		return self->discard(self, flags);
+	}
+SWIGINTERN u_int32_t DB_TXN_id(DB_TXN *self){
+		return self->id(self);
+	}
+SWIGINTERN int DB_TXN_prepare(DB_TXN *self,u_int8_t globalID[DB_GID_SIZE]){
+		return self->prepare(self, globalID);
+	}
+SWIGINTERN int DB_TXN_get_name(DB_TXN *self,char const **name){
+		return self->get_name(self, name);
+	}
+SWIGINTERN int DB_TXN_set_name(DB_TXN *self,char const *name){
+		return self->set_name(self, name);
+	}
+SWIGINTERN int DB_TXN_set_timeout(DB_TXN *self,db_timeout_t timeout,u_int32_t flags){
+		return self->set_timeout(self, timeout, flags);
+	}
+SWIGINTERN int DB_ENV_set_usercopy(DB_ENV *self,int (*dbt_usercopy)(DBT *,u_int32_t,void *,u_int32_t,u_int32_t)){
+		self->env->dbt_usercopy = dbt_usercopy;
+		return 0;
+	}
+SWIGINTERN DB_ENV *new_DB_ENV(u_int32_t flags){
+		DB_ENV *self = NULL;
+		errno = db_env_create(&self, flags);
+		return self;
+	}
+SWIGINTERN void delete_DB_ENV(DB_ENV *self){ }
+SWIGINTERN DB_TXN *DB_ENV_cdsgroup_begin(DB_ENV *self,int *err){
+		DB_TXN *group;
+		
+		*err = self->cdsgroup_begin(self, &group);
+		return group;
+	}
+SWIGINTERN int DB_ENV_close(DB_ENV *self,u_int32_t flags){
+		return self->close(self, flags);
+	}
+SWIGINTERN int DB_ENV_dbremove(DB_ENV *self,DB_TXN *txn,char const *file,char const *database,u_int32_t flags){
+		return self->dbremove(self, txn, file, database, flags);
+	}
+SWIGINTERN int DB_ENV_dbrename(DB_ENV *self,DB_TXN *txn,char const *file,char const *database,char const *newname,u_int32_t flags){
+		return self->dbrename(self, txn, file, database, newname, flags);
+	}
+SWIGINTERN int DB_ENV_failchk(DB_ENV *self,u_int32_t flags){
+		return self->failchk(self, flags);
+	}
+SWIGINTERN int DB_ENV_fileid_reset(DB_ENV *self,char const *file,u_int32_t flags){
+		return self->fileid_reset(self, file, flags);
+	}
+SWIGINTERN int DB_ENV_get_home(DB_ENV *self,char const **file){
+		return self->get_home(self, file);
+	}
+SWIGINTERN int DB_ENV_lock_detect(DB_ENV *self,u_int32_t flags,u_int32_t atype,u_int32_t *rejected){
+		return self->lock_detect(self, flags, atype, rejected);
+	}
+SWIGINTERN DB_LOCK DB_ENV_lock_get(DB_ENV *self,u_int32_t locker,u_int32_t flags,DBT *object,db_lockmode_t const mode,int *err){
+		DB_LOCK lock;
+		
+		*err = self->lock_get(self, locker, flags, object, mode, &lock);
+		return lock;
+	}
+SWIGINTERN int DB_ENV_lock_id(DB_ENV *self,u_int32_t *id){
+		return self->lock_id(self, id);
+	}
+SWIGINTERN int DB_ENV_lock_id_free(DB_ENV *self,u_int32_t id){
+		return self->lock_id_free(self, id);
+	}
+SWIGINTERN int DB_ENV_lock_put(DB_ENV *self,DB_LOCK *lck){
+		return self->lock_put(self, lck);
+	}
+SWIGINTERN void *DB_ENV_lock_stat(DB_ENV *self,u_int32_t flags,int *err){
+		DB_LOCK_STAT *ret;
+		*err = self->lock_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+SWIGINTERN int DB_ENV_lock_stat_print(DB_ENV *self,u_int32_t flags){
+		return self->lock_stat_print(self, flags);
+	}
+SWIGINTERN int DB_ENV_lock_vec(DB_ENV *self,u_int32_t locker,u_int32_t flags,DB_LOCKREQ **list,int nlist,DB_LOCKREQ *elistp){
+		int i, ret;
+		DB_LOCKREQ *vec;
+		
+		ret = __os_malloc(self->env, sizeof(DB_LOCKREQ) * nlist, &vec);
+		if (ret != 0)
+			return ENOMEM;
+		for (i = 0; i < nlist; i++)
+			vec[i] = *list[i];
+			
+		if (elistp == NULL)
+			ret = self->lock_vec(self, locker, flags, vec, nlist, NULL);
+		else
+			ret = self->lock_vec(self, locker, flags, vec, nlist, &elistp);
+			
+		for (i = 0; i < nlist; i++)
+			*list[i] = vec[i];
+		
+		__os_free(self->env , vec);
+		
+		return ret;
+	}
+SWIGINTERN char **DB_ENV_log_archive(DB_ENV *self,u_int32_t flags,int *err,int *cntp){
+		char **list = NULL;
+		int cnt = 0;
+		*err = self->log_archive(self, &list, flags);
+
+		if (list != NULL)
+			while (list[cnt] != NULL) {
+				cnt++;
+			}
+		*cntp = cnt;
+		return list;
+	}
+SWIGINTERN int DB_ENV_log_file(DB_ENV *self,DB_LSN const *lsn,char *namep,size_t len){
+		int ret = self->log_file(self, lsn, namep, len);
+		if (ret == EINVAL)
+			return DB_BUFFER_SMALL;
+		return ret;
+	}
+SWIGINTERN int DB_ENV_log_flush(DB_ENV *self,DB_LSN const *lsn){
+		return self->log_flush(self, lsn);
+	}
+SWIGINTERN int DB_ENV_log_put(DB_ENV *self,DB_LSN *lsn,DBT *data,u_int32_t flags){
+		return self->log_put(self, lsn, data, flags);
+	}
+SWIGINTERN int DB_ENV_log_get_config(DB_ENV *self,u_int32_t which,int *onoff){
+		return self->log_get_config(self, which, onoff);
+	}
+SWIGINTERN int DB_ENV_log_set_config(DB_ENV *self,u_int32_t which,int onoff){
+		return self->log_set_config(self, which, onoff);
+	}
+SWIGINTERN int DB_ENV_log_printf(DB_ENV *self,DB_TXN *txn,char const *str){
+		return self->log_printf(self, txn, "%s", str);
+	}
+SWIGINTERN void *DB_ENV_log_stat(DB_ENV *self,u_int32_t flags,int *err){
+		DB_LOG_STAT *ret;
+		*err = self->log_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+SWIGINTERN int DB_ENV_log_stat_print(DB_ENV *self,u_int32_t flags){
+		return self->log_stat_print(self, flags);
+	}
+SWIGINTERN int DB_ENV_lsn_reset(DB_ENV *self,char const *file,u_int32_t flags){
+		return self->lsn_reset(self, file, flags);
+	}
+SWIGINTERN void *DB_ENV_memp_stat(DB_ENV *self,void ***fstatp,u_int32_t flags,int *err,int *cntp){
+		DB_MPOOL_STAT *ret;
+		DB_MPOOL_FSTAT **fptr;
+		int cnt;
+
+		*err = self->memp_stat(self, &ret, &fptr, flags);
+		cnt = 0;
+		if (fptr != NULL)
+			while (fptr[cnt] != NULL) {
+				cnt++;
+			}
+
+		*cntp = cnt;
+		*fstatp = (void **)fptr;
+		return (void *)ret;
+	}
+SWIGINTERN int DB_ENV_memp_stat_print(DB_ENV *self,u_int32_t flags){
+		return self->memp_stat_print(self, flags);
+	}
+SWIGINTERN int DB_ENV_memp_sync(DB_ENV *self,DB_LSN *lsn){
+		return self->memp_sync(self, lsn);
+	}
+SWIGINTERN int DB_ENV_memp_trickle(DB_ENV *self,int percent,int *nwrotep){
+		return self->memp_trickle(self, percent, nwrotep);
+	}
+SWIGINTERN int DB_ENV_mutex_alloc(DB_ENV *self,u_int32_t flags,db_mutex_t *mutexp){
+		return self->mutex_alloc(self, flags, mutexp);
+	}
+SWIGINTERN int DB_ENV_mutex_free(DB_ENV *self,db_mutex_t mutex){
+		return self->mutex_free(self, mutex);
+	}
+SWIGINTERN int DB_ENV_mutex_lock(DB_ENV *self,db_mutex_t mutex){
+		return self->mutex_lock(self, mutex);
+	}
+SWIGINTERN void *DB_ENV_mutex_stat(DB_ENV *self,u_int32_t flags,int *err){
+		DB_MUTEX_STAT *ret;
+		*err = self->mutex_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+SWIGINTERN int DB_ENV_mutex_stat_print(DB_ENV *self,u_int32_t flags){
+		return self->mutex_stat_print(self, flags);
+	}
+SWIGINTERN int DB_ENV_mutex_unlock(DB_ENV *self,db_mutex_t mutex){
+		return self->mutex_unlock(self, mutex);
+	}
+SWIGINTERN int DB_ENV_mutex_get_align(DB_ENV *self,u_int32_t *align){
+		return self->mutex_get_align(self, align);
+	}
+SWIGINTERN int DB_ENV_mutex_set_align(DB_ENV *self,u_int32_t align){
+		return self->mutex_set_align(self, align);
+	}
+SWIGINTERN int DB_ENV_mutex_get_increment(DB_ENV *self,u_int32_t *increment){
+		return self->mutex_get_increment(self, increment);
+	}
+SWIGINTERN int DB_ENV_mutex_set_increment(DB_ENV *self,u_int32_t increment){
+		return self->mutex_set_increment(self, increment);
+	}
+SWIGINTERN int DB_ENV_mutex_get_max(DB_ENV *self,u_int32_t *max){
+		return self->mutex_get_max(self, max);
+	}
+SWIGINTERN int DB_ENV_mutex_set_max(DB_ENV *self,u_int32_t max){
+		return self->mutex_set_max(self, max);
+	}
+SWIGINTERN int DB_ENV_mutex_get_tas_spins(DB_ENV *self,u_int32_t *tas_spins){
+		return self->mutex_get_tas_spins(self, tas_spins);
+	}
+SWIGINTERN int DB_ENV_mutex_set_tas_spins(DB_ENV *self,u_int32_t tas_spins){
+		return self->mutex_set_tas_spins(self, tas_spins);
+	}
+SWIGINTERN int DB_ENV_open(DB_ENV *self,char const *home,u_int32_t flags,int mode){
+		return self->open(self, home, flags, mode);
+	}
+SWIGINTERN int DB_ENV_get_open_flags(DB_ENV *self,u_int32_t *flags){
+		return self->get_open_flags(self, flags);
+	}
+SWIGINTERN int DB_ENV_remove(DB_ENV *self,char *db_home,u_int32_t flags){
+		return self->remove(self, db_home, flags);
+	}
+SWIGINTERN int DB_ENV_repmgr_add_remote_site(DB_ENV *self,char const *host,u_int port,int *eidp,u_int32_t flags){
+		return self->repmgr_add_remote_site(self, host, port, eidp, flags);
+	}
+SWIGINTERN int DB_ENV_repmgr_set_ack_policy(DB_ENV *self,int ack_policy){
+		return self->repmgr_set_ack_policy(self, ack_policy);
+	}
+SWIGINTERN int DB_ENV_repmgr_get_ack_policy(DB_ENV *self,int *ack_policy){
+		return self->repmgr_get_ack_policy(self, ack_policy);
+	}
+SWIGINTERN int DB_ENV_repmgr_set_local_site(DB_ENV *self,char const *host,u_int port,u_int32_t flags){
+		return self->repmgr_set_local_site(self, host, port, flags);
+	}
+SWIGINTERN DB_REPMGR_SITE *DB_ENV_repmgr_site_list(DB_ENV *self,u_int *countp,u_int32_t *sizep,int *err){
+		DB_REPMGR_SITE *listp = NULL;
+	
+		*err = self->repmgr_site_list(self, countp, &listp);
+		*sizep = sizeof(DB_REPMGR_SITE);
+		return listp;
+	}
+SWIGINTERN int DB_ENV_repmgr_start(DB_ENV *self,int nthreads,u_int32_t flags){
+		return self->repmgr_start(self, nthreads, flags);
+	}
+SWIGINTERN void *DB_ENV_repmgr_stat(DB_ENV *self,u_int32_t flags,int *err){
+		DB_REPMGR_STAT *ret;
+		*err = self->repmgr_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+SWIGINTERN int DB_ENV_repmgr_stat_print(DB_ENV *self,u_int32_t flags){
+		return self->repmgr_stat_print(self, flags);
+	}
+SWIGINTERN int DB_ENV_rep_elect(DB_ENV *self,u_int32_t nsites,u_int32_t nvotes,u_int32_t flags){
+		return self->rep_elect(self, nsites, nvotes, flags);
+	}
+SWIGINTERN int DB_ENV_rep_process_message(DB_ENV *self,DBT *control,DBT *rec,int envid,DB_LSN *ret_lsnp){
+		return self->rep_process_message(self, control, rec, envid, ret_lsnp);
+	}
+SWIGINTERN int DB_ENV_rep_start(DB_ENV *self,DBT *cdata,u_int32_t flags){
+		return self->rep_start(self, cdata, flags);
+	}
+SWIGINTERN void *DB_ENV_rep_stat(DB_ENV *self,u_int32_t flags,int *err){
+		DB_REP_STAT *ret;
+		*err = self->rep_stat(self, &ret, flags);
+		return (void *)ret;
+	}
+SWIGINTERN int DB_ENV_rep_stat_print(DB_ENV *self,u_int32_t flags){
+		return self->rep_stat_print(self, flags);
+	}
+SWIGINTERN int DB_ENV_rep_sync(DB_ENV *self,u_int32_t flags){
+		return self->rep_sync(self, flags);
+	}
+SWIGINTERN int DB_ENV_rep_set_config(DB_ENV *self,u_int32_t which,int onoff){
+		return self->rep_set_config(self, which, onoff);
+	}
+SWIGINTERN int DB_ENV_rep_get_config(DB_ENV *self,u_int32_t which,int *onoffp){
+		return self->rep_get_config(self, which, onoffp);
+	}
+SWIGINTERN int DB_ENV_rep_set_clockskew(DB_ENV *self,u_int32_t fast_clock,u_int32_t slow_clock){
+		return self->rep_set_clockskew(self, fast_clock, slow_clock);
+	}
+SWIGINTERN int DB_ENV_rep_get_clockskew(DB_ENV *self,u_int32_t *fast_clockp,u_int32_t *slow_clockp){
+		return self->rep_get_clockskew(self, fast_clockp, slow_clockp);
+	}
+SWIGINTERN int DB_ENV_rep_set_limit(DB_ENV *self,u_int32_t gbytes,u_int32_t bytes){
+		return self->rep_set_limit(self, gbytes, bytes);
+	}
+SWIGINTERN int DB_ENV_rep_get_limit(DB_ENV *self,u_int32_t *gbytesp,u_int32_t *bytesp){
+		return self->rep_get_limit(self, gbytesp, bytesp);
+	}
+SWIGINTERN int DB_ENV_rep_set_nsites(DB_ENV *self,u_int32_t nsites){
+		return self->rep_set_nsites(self, nsites);
+	}
+SWIGINTERN int DB_ENV_rep_get_nsites(DB_ENV *self,u_int32_t *nsitesp){
+		return self->rep_get_nsites(self, nsitesp);
+	}
+SWIGINTERN int DB_ENV_rep_set_priority(DB_ENV *self,u_int32_t priority){
+		return self->rep_set_priority(self, priority);
+	}
+SWIGINTERN int DB_ENV_rep_get_priority(DB_ENV *self,u_int32_t *priorityp){
+		return self->rep_get_priority(self, priorityp);
+	}
+SWIGINTERN int DB_ENV_rep_set_request(DB_ENV *self,u_int32_t min,u_int32_t max){
+		return self->rep_set_request(self, min, max);
+	}
+SWIGINTERN int DB_ENV_rep_get_request(DB_ENV *self,u_int32_t *minp,u_int32_t *maxp){
+		return self->rep_get_request(self, minp, maxp);
+	}
+SWIGINTERN int DB_ENV_rep_set_timeout(DB_ENV *self,int which,u_int32_t timeout){
+		return self->rep_set_timeout(self, which, timeout);
+	}
+SWIGINTERN int DB_ENV_rep_get_timeout(DB_ENV *self,int which,u_int32_t *timeoutp){
+		return self->rep_get_timeout(self, which, timeoutp);
+	}
+SWIGINTERN int DB_ENV_rep_set_transport(DB_ENV *self,int envid,int (*send)(DB_ENV *,DBT const *,DBT const *,DB_LSN const *,int,u_int32_t)){
+		return self->rep_set_transport(self, envid, send);
+	}
+SWIGINTERN int DB_ENV_get_cachesize(DB_ENV *self,u_int32_t *gbytes,u_int32_t *bytes,int *ncache){
+		return self->get_cachesize(self, gbytes, bytes, ncache);
+	}
+SWIGINTERN int DB_ENV_set_cachesize(DB_ENV *self,u_int32_t gbytes,u_int32_t bytes,int ncache){
+		return self->set_cachesize(self, gbytes, bytes, ncache);
+	}
+SWIGINTERN int DB_ENV_get_cache_max(DB_ENV *self,u_int32_t *gbytes,u_int32_t *bytes){
+		return self->get_cache_max(self, gbytes, bytes);
+	}
+SWIGINTERN int DB_ENV_set_cache_max(DB_ENV *self,u_int32_t gbytes,u_int32_t bytes){
+		return self->set_cache_max(self, gbytes, bytes);
+	}
+SWIGINTERN char **DB_ENV_get_data_dirs(DB_ENV *self,int *err,int *cntp){
+		char **list = NULL;
+		int cnt = 0;
+		*err = self->get_data_dirs(self, &list);
+
+		if (list != NULL)
+			while (list[cnt] != NULL) {
+				cnt++;
+			}
+		*cntp = cnt;
+		return list;
+	}
+SWIGINTERN int DB_ENV_add_data_dir(DB_ENV *self,char const *dir){
+		return self->add_data_dir(self, dir);
+	}
+SWIGINTERN int DB_ENV_set_create_dir(DB_ENV *self,char const *dir){
+		return self->set_create_dir(self, dir);
+	}
+SWIGINTERN int DB_ENV_get_encrypt_flags(DB_ENV *self,u_int32_t *flags){
+		return self->get_encrypt_flags(self, flags);
+	}
+SWIGINTERN int DB_ENV_set_encrypt(DB_ENV *self,char const *passwd,u_int32_t flags){
+		return self->set_encrypt(self, passwd, flags);
+	}
+SWIGINTERN void DB_ENV_set_errcall(DB_ENV *self,void (*db_errcall_fcn)(DB_ENV const *,char const *,char const *)){
+		self->set_errcall(self, db_errcall_fcn);
+	}
+SWIGINTERN int DB_ENV_set_event_notify(DB_ENV *self,void (*callback)(DB_ENV *,u_int32_t,void *)){
+		return self->set_event_notify(self, callback);
+	}
+SWIGINTERN int DB_ENV_set_feedback(DB_ENV *self,void (*callback)(DB_ENV *,int,int)){
+		return self->set_feedback(self, callback);
+	}
+SWIGINTERN int DB_ENV_get_flags(DB_ENV *self,u_int32_t *flags){
+		return self->get_flags(self, flags);
+	}
+SWIGINTERN int DB_ENV_set_flags(DB_ENV *self,u_int32_t flags,int onoff){
+		return self->set_flags(self, flags, onoff);
+	}
+SWIGINTERN int DB_ENV_get_intermediate_dir_mode(DB_ENV *self,char const **mode){
+		return self->get_intermediate_dir_mode(self, mode);
+	}
+SWIGINTERN int DB_ENV_set_intermediate_dir_mode(DB_ENV *self,char const *mode){
+		return self->set_intermediate_dir_mode(self, mode);
+	}
+SWIGINTERN int DB_ENV_set_isalive(DB_ENV *self,int (*callback)(DB_ENV *,pid_t,db_threadid_t,u_int32_t)){
+		return self->set_isalive(self, callback);
+	}
+SWIGINTERN int DB_ENV_get_lg_bsize(DB_ENV *self,u_int32_t *bsize){
+		return self->get_lg_bsize(self, bsize);
+	}
+SWIGINTERN int DB_ENV_set_lg_bsize(DB_ENV *self,u_int32_t bsize){
+		return self->set_lg_bsize(self, bsize);
+	}
+SWIGINTERN int DB_ENV_get_lg_dir(DB_ENV *self,char const **dir){
+		return self->get_lg_dir(self, dir);
+	}
+SWIGINTERN int DB_ENV_set_lg_dir(DB_ENV *self,char const *dir){
+		return self->set_lg_dir(self, dir);
+	}
+SWIGINTERN int DB_ENV_get_lg_filemode(DB_ENV *self,int *mode){
+		return self->get_lg_filemode(self, mode);
+	}
+SWIGINTERN int DB_ENV_set_lg_filemode(DB_ENV *self,int mode){
+		return self->set_lg_filemode(self, mode);
+	}
+SWIGINTERN int DB_ENV_get_lg_max(DB_ENV *self,u_int32_t *max){
+		return self->get_lg_max(self, max);
+	}
+SWIGINTERN int DB_ENV_set_lg_max(DB_ENV *self,u_int32_t max){
+		return self->set_lg_max(self, max);
+	}
+SWIGINTERN int DB_ENV_get_lg_regionmax(DB_ENV *self,u_int32_t *max){
+		return self->get_lg_regionmax(self, max);
+	}
+SWIGINTERN int DB_ENV_set_lg_regionmax(DB_ENV *self,u_int32_t max){
+		return self->set_lg_regionmax(self, max);
+	}
+SWIGINTERN int DB_ENV_get_lk_conflicts_nmodes(DB_ENV *self,int *nmodes){
+		return self->get_lk_conflicts(self, NULL, nmodes);
+	}
+SWIGINTERN int DB_ENV_get_lk_conflicts(DB_ENV *self,u_int8_t *conflicts){
+		int i, nmodes, ret;
+		u_int8_t *mtrx = NULL;
+		
+		ret = self->get_lk_conflicts(self, &mtrx, &nmodes);
+		for (i = 0; i < nmodes * nmodes; i++)
+			conflicts[i] = mtrx[i];
+		
+		return ret;
+	}
+SWIGINTERN int DB_ENV_set_lk_conflicts(DB_ENV *self,u_int8_t *conflicts,int nmodes){
+		return self->set_lk_conflicts(self, conflicts, nmodes);
+	}
+SWIGINTERN int DB_ENV_get_lk_detect(DB_ENV *self,u_int32_t *mode){
+		return self->get_lk_detect(self, mode);
+	}
+SWIGINTERN int DB_ENV_set_lk_detect(DB_ENV *self,u_int32_t mode){
+		return self->set_lk_detect(self, mode);
+	}
+SWIGINTERN int DB_ENV_get_lk_max_locks(DB_ENV *self,u_int32_t *max){
+		return self->get_lk_max_locks(self, max);
+	}
+SWIGINTERN int DB_ENV_set_lk_max_locks(DB_ENV *self,u_int32_t max){
+		return self->set_lk_max_locks(self, max);
+	}
+SWIGINTERN int DB_ENV_get_lk_max_lockers(DB_ENV *self,u_int32_t *max){
+		return self->get_lk_max_lockers(self, max);
+	}
+SWIGINTERN int DB_ENV_set_lk_max_lockers(DB_ENV *self,u_int32_t max){
+		return self->set_lk_max_lockers(self, max);
+	}
+SWIGINTERN int DB_ENV_get_lk_max_objects(DB_ENV *self,u_int32_t *max){
+		return self->get_lk_max_objects(self, max);
+	}
+SWIGINTERN int DB_ENV_set_lk_max_objects(DB_ENV *self,u_int32_t max){
+		return self->set_lk_max_objects(self, max);
+	}
+SWIGINTERN int DB_ENV_get_lk_partitions(DB_ENV *self,u_int32_t *max){
+		return self->get_lk_partitions(self, max);
+	}
+SWIGINTERN int DB_ENV_set_lk_partitions(DB_ENV *self,u_int32_t max){
+		return self->set_lk_partitions(self, max);
+	}
+SWIGINTERN int DB_ENV_get_mp_max_openfd(DB_ENV *self,int *maxopenfd){
+		return self->get_mp_max_openfd(self, maxopenfd);
+	}
+SWIGINTERN int DB_ENV_set_mp_max_openfd(DB_ENV *self,int maxopenfd){
+		return self->set_mp_max_openfd(self, maxopenfd);
+	}
+SWIGINTERN int DB_ENV_get_mp_max_write(DB_ENV *self,int *maxwrite,db_timeout_t *maxwrite_sleep){
+		return self->get_mp_max_write(self, maxwrite, maxwrite_sleep);
+	}
+SWIGINTERN int DB_ENV_set_mp_max_write(DB_ENV *self,int maxwrite,db_timeout_t maxwrite_sleep){
+		return self->set_mp_max_write(self, maxwrite, maxwrite_sleep);
+	}
+SWIGINTERN int DB_ENV_get_mp_mmapsize(DB_ENV *self,size_t *mp_mmapsize){
+		return self->get_mp_mmapsize(self, mp_mmapsize);
+	}
+SWIGINTERN int DB_ENV_set_mp_mmapsize(DB_ENV *self,size_t mp_mmapsize){
+		return self->set_mp_mmapsize(self, mp_mmapsize);
+	}
+SWIGINTERN int DB_ENV_get_thread_count(DB_ENV *self,u_int32_t *count){
+		return self->get_thread_count(self, count);
+	}
+SWIGINTERN int DB_ENV_set_thread_count(DB_ENV *self,u_int32_t count){
+		return self->set_thread_count(self, count);
+	}
+SWIGINTERN int DB_ENV_set_thread_id(DB_ENV *self,void (*callback)(DB_ENV *,pid_t *,db_threadid_t *)){
+		return self->set_thread_id(self, callback);
+	}
+SWIGINTERN int DB_ENV_set_thread_id_string(DB_ENV *self,char *(*callback)(DB_ENV *,pid_t,db_threadid_t,char *)){
+		return self->set_thread_id_string(self, callback);
+	}
+SWIGINTERN int DB_ENV_get_timeout(DB_ENV *self,db_timeout_t *timeout,u_int32_t flags){
+		return self->get_timeout(self, timeout, flags);
+	}
+SWIGINTERN int DB_ENV_set_timeout(DB_ENV *self,db_timeout_t timeout,u_int32_t flags){
+		return self->set_timeout(self, timeout, flags);
+	}
+SWIGINTERN int DB_ENV_get_tmp_dir(DB_ENV *self,char const **dir){
+		return self->get_tmp_dir(self, dir);
+	}
+SWIGINTERN int DB_ENV_set_tmp_dir(DB_ENV *self,char const *dir){
+		return self->set_tmp_dir(self, dir);
+	}
+SWIGINTERN int DB_ENV_get_tx_max(DB_ENV *self,u_int32_t *max){
+		return self->get_tx_max(self, max);
+	}
+SWIGINTERN int DB_ENV_set_tx_max(DB_ENV *self,u_int32_t max){
+		return self->set_tx_max(self, max);
+	}
+SWIGINTERN int DB_ENV_get_tx_timestamp(DB_ENV *self,time_t *timestamp){
+		return self->get_tx_timestamp(self, timestamp);
+	}
+SWIGINTERN int DB_ENV_set_tx_timestamp(DB_ENV *self,time_t *timestamp){
+		return self->set_tx_timestamp(self, timestamp);
+	}
+SWIGINTERN int DB_ENV_get_verbose(DB_ENV *self,u_int32_t *msgs){
+		int onoff, ret;
+		
+		*msgs = 0;
+		if ((ret = self->get_verbose(self, DB_VERB_DEADLOCK, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_DEADLOCK;
+		if ((ret = self->get_verbose(self, DB_VERB_FILEOPS, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_FILEOPS;
+		if ((ret = self->get_verbose(self, DB_VERB_FILEOPS_ALL, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_FILEOPS_ALL;
+		if ((ret = self->get_verbose(self, DB_VERB_RECOVERY, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_RECOVERY;
+		if ((ret = self->get_verbose(self, DB_VERB_REGISTER, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REGISTER;
+		if ((ret = self->get_verbose(self, DB_VERB_REPLICATION, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REPLICATION;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_ELECT, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_ELECT;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_LEASE, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_LEASE;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_MISC, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_MISC;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_MSGS, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_MSGS;
+		if ((ret = self->get_verbose(self, DB_VERB_REP_SYNC, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REP_SYNC;
+		if ((ret = self->get_verbose(self, DB_VERB_REPMGR_CONNFAIL, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REPMGR_CONNFAIL;
+		if ((ret = self->get_verbose(self, DB_VERB_REPMGR_MISC, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_REPMGR_MISC;
+		if ((ret = self->get_verbose(self, DB_VERB_WAITSFOR, &onoff)) != 0)
+			return ret;
+		if (onoff)
+			*msgs |= DB_VERB_WAITSFOR;
+		
+		return 0;
+	}
+SWIGINTERN int DB_ENV_set_verbose(DB_ENV *self,u_int32_t which,int onoff){
+		int ret;
+
+		if ((which & DB_VERB_DEADLOCK) && 
+			(ret = self->set_verbose(self, DB_VERB_DEADLOCK, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_FILEOPS) && 
+			(ret = self->set_verbose(self, DB_VERB_FILEOPS, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_FILEOPS_ALL) && 
+			(ret = self->set_verbose(self, DB_VERB_FILEOPS_ALL, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_RECOVERY) && 
+			(ret = self->set_verbose(self, DB_VERB_RECOVERY, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REGISTER) && 
+			(ret = self->set_verbose(self, DB_VERB_REGISTER, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REPLICATION) && 
+			(ret = self->set_verbose(self, DB_VERB_REPLICATION, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_ELECT) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_ELECT, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_LEASE) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_LEASE, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_MISC) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_MISC, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_MSGS) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_MSGS, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REP_SYNC) && 
+			(ret = self->set_verbose(self, DB_VERB_REP_SYNC, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REPMGR_CONNFAIL) && 
+			(ret = self->set_verbose(self, DB_VERB_REPMGR_CONNFAIL, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_REPMGR_MISC) &&
+			(ret = self->set_verbose(self, DB_VERB_REPMGR_MISC, onoff)) != 0)
+			return ret;
+		if ((which & DB_VERB_WAITSFOR) &&
+			(ret = self->set_verbose(self, DB_VERB_WAITSFOR, onoff)) != 0)
+			return ret;
+		return 0;
+	}
+SWIGINTERN int DB_ENV_stat_print(DB_ENV *self,u_int32_t flags){
+		return self->stat_print(self, flags);
+	}
+SWIGINTERN DB_TXN *DB_ENV_txn_begin(DB_ENV *self,DB_TXN *parent,u_int32_t flags,int *err){
+		DB_TXN *txnid = NULL;
+		
+		*err = self->txn_begin(self, parent, &txnid, flags);
+		return txnid;
+	}
+SWIGINTERN int DB_ENV_txn_checkpoint(DB_ENV *self,u_int32_t kbyte,u_int32_t min,u_int32_t flags){
+		return self->txn_checkpoint(self, kbyte, min, flags);
+	}
+SWIGINTERN int DB_ENV_txn_recover(DB_ENV *self,DB_PREPLIST preplist[],u_int32_t count,u_int32_t *retp,u_int32_t flags){
+		return self->txn_recover(self, preplist, count, retp, flags);
+	}
+SWIGINTERN void *DB_ENV_txn_stat(DB_ENV *self,u_int32_t flags,u_int32_t *size,int *err){
+		DB_TXN_STAT *ret;
+		*err = self->txn_stat(self, &ret, flags);
+		*size = sizeof(DB_TXN_ACTIVE);
+		return (void *)ret;
+	}
+SWIGINTERN int DB_ENV_txn_stat_print(DB_ENV *self,u_int32_t flags){
+		return self->txn_stat_print(self, flags);
+	}
+
+void wrap_ufree(DB_ENV *dbenv, void *ptr) {
+	if (dbenv == NULL)
+		__os_ufree(NULL, ptr);
+	else
+		__os_ufree(dbenv->env, ptr);
+}
+
+SWIGINTERN DB_SEQUENCE *new_DB_SEQUENCE(DB *dbp,u_int32_t flags){
+		DB_SEQUENCE *seq = NULL;
+		int ret;
+		
+		ret = db_sequence_create(&seq, dbp, flags);
+		if (ret == 0)
+			return seq;
+		else
+			return NULL;
+	}
+SWIGINTERN void delete_DB_SEQUENCE(DB_SEQUENCE *self){ }
+SWIGINTERN int DB_SEQUENCE_close(DB_SEQUENCE *self,u_int32_t flags){
+		return self->close(self, flags);
+	}
+SWIGINTERN int DB_SEQUENCE_get(DB_SEQUENCE *self,DB_TXN *txn,int32_t delta,db_seq_t *retp,u_int32_t flags){
+		return self->get(self, txn, delta, retp, flags);
+	}
+SWIGINTERN DB *DB_SEQUENCE_get_db(DB_SEQUENCE *self){
+		DB *dbp = NULL;
+		int err = 0;
+		err = self->get_db(self, &dbp);
+		return dbp;
+	}
+SWIGINTERN int DB_SEQUENCE_get_key(DB_SEQUENCE *self,DBT *key){
+		return self->get_key(self, key);
+	}
+SWIGINTERN int DB_SEQUENCE_initial_value(DB_SEQUENCE *self,db_seq_t value){
+		return self->initial_value(self, value);
+	}
+SWIGINTERN int DB_SEQUENCE_open(DB_SEQUENCE *self,DB_TXN *txn,DBT *key,u_int32_t flags){
+		return self->open(self, txn, key, flags);
+	}
+SWIGINTERN int DB_SEQUENCE_remove(DB_SEQUENCE *self,DB_TXN *txn,u_int32_t flags){
+		return self->remove(self, txn, flags);
+	}
+SWIGINTERN int DB_SEQUENCE_get_cachesize(DB_SEQUENCE *self,int32_t *size){
+		return self->get_cachesize(self, size);
+	}
+SWIGINTERN int DB_SEQUENCE_set_cachesize(DB_SEQUENCE *self,int32_t size){
+		return self->set_cachesize(self, size);
+	}
+SWIGINTERN int DB_SEQUENCE_get_flags(DB_SEQUENCE *self,u_int32_t *flags){
+		return self->get_flags(self, flags);
+	}
+SWIGINTERN int DB_SEQUENCE_set_flags(DB_SEQUENCE *self,u_int32_t flags){
+		return self->set_flags(self, flags);
+	}
+SWIGINTERN int DB_SEQUENCE_get_range(DB_SEQUENCE *self,db_seq_t *min,db_seq_t *max){
+		return self->get_range(self, min, max);
+	}
+SWIGINTERN int DB_SEQUENCE_set_range(DB_SEQUENCE *self,db_seq_t min,db_seq_t max){
+		return self->set_range(self, min, max);
+	}
+SWIGINTERN void *DB_SEQUENCE_stat(DB_SEQUENCE *self,u_int32_t flags,int *err){
+		DB_SEQUENCE_STAT *ret = NULL;
+
+		*err = self->stat(self, &ret, flags);
+		return (void *)ret;
+	}
+SWIGINTERN int DB_SEQUENCE_stat_print(DB_SEQUENCE *self,u_int32_t flags){
+		return self->stat_print(self, flags);
+	}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_fillpercent_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->compact_fillpercent = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_fillpercent_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (u_int32_t) ((arg1)->compact_fillpercent);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_timeout_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  db_timeout_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (db_timeout_t)jarg2; 
+  if (arg1) (arg1)->compact_timeout = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_timeout_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  db_timeout_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (db_timeout_t) ((arg1)->compact_timeout);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_pages_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->compact_pages = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_pages_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (u_int32_t) ((arg1)->compact_pages);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_pages_free_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->compact_pages_free = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_pages_free_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (u_int32_t) ((arg1)->compact_pages_free);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_pages_examine_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->compact_pages_examine = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_pages_examine_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (u_int32_t) ((arg1)->compact_pages_examine);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_levels_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->compact_levels = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_levels_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (u_int32_t) ((arg1)->compact_levels);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_deadlock_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->compact_deadlock = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_deadlock_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (u_int32_t) ((arg1)->compact_deadlock);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_pages_truncated_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  db_pgno_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (db_pgno_t)jarg2; 
+  if (arg1) (arg1)->compact_pages_truncated = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_pages_truncated_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  db_pgno_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (db_pgno_t) ((arg1)->compact_pages_truncated);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_COMPACT_compact_truncate_set(void * jarg1, unsigned long jarg2) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  db_pgno_t arg2 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  arg2 = (db_pgno_t)jarg2; 
+  if (arg1) (arg1)->compact_truncate = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_COMPACT_compact_truncate_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  db_pgno_t result;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  result = (db_pgno_t) ((arg1)->compact_truncate);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_COMPACT() {
+  void * jresult ;
+  DB_COMPACT *result = 0 ;
+  
+  result = (DB_COMPACT *)calloc(1, sizeof(DB_COMPACT));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_COMPACT(void * jarg1) {
+  DB_COMPACT *arg1 = (DB_COMPACT *) 0 ;
+  
+  arg1 = (DB_COMPACT *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LSN_file_set(void * jarg1, unsigned long jarg2) {
+  DB_LSN *arg1 = (DB_LSN *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_LSN *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->file = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_LSN_file_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_LSN *arg1 = (DB_LSN *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_LSN *)jarg1; 
+  result = (u_int32_t) ((arg1)->file);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LSN_offset_set(void * jarg1, unsigned long jarg2) {
+  DB_LSN *arg1 = (DB_LSN *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_LSN *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->offset = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_LSN_offset_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_LSN *arg1 = (DB_LSN *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_LSN *)jarg1; 
+  result = (u_int32_t) ((arg1)->offset);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_LSN() {
+  void * jresult ;
+  DB_LSN *result = 0 ;
+  
+  result = (DB_LSN *)calloc(1, sizeof(DB_LSN));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_LSN(void * jarg1) {
+  DB_LSN *arg1 = (DB_LSN *) 0 ;
+  
+  arg1 = (DB_LSN *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_api_internal_set(void * jarg1, void * jarg2) {
+  DB *arg1 = (DB *) 0 ;
+  void *arg2 = (void *) 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (void *)jarg2; 
+  if (arg1) (arg1)->api_internal = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_api_internal_get(void * jarg1) {
+  void * jresult ;
+  DB *arg1 = (DB *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  result = (void *) ((arg1)->api_internal);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_usercopy(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int (*arg2)(DBT *,u_int32_t,void *,u_int32_t,u_int32_t) = (int (*)(DBT *,u_int32_t,void *,u_int32_t,u_int32_t)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int (*)(DBT *,u_int32_t,void *,u_int32_t,u_int32_t))jarg2; 
+  result = (int)DB_set_usercopy(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB(void * jarg1, unsigned long jarg2) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  DB *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (DB *)new_DB(arg1,arg2);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB(void * jarg1) {
+  DB *arg1 = (DB *) 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  delete_DB(arg1);
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_associate(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DB *arg3 = (DB *) 0 ;
+  int (*arg4)(DB *,DBT const *,DBT const *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT *)) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DB *)jarg3; 
+  arg4 = (int (*)(DB *,DBT const *,DBT const *,DBT *))jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_associate(arg1,arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_associate_foreign(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB *arg2 = (DB *) 0 ;
+  int (*arg3)(DB *,DBT const *,DBT *,DBT const *,int *) = (int (*)(DB *,DBT const *,DBT *,DBT const *,int *)) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB *)jarg2; 
+  arg3 = (int (*)(DB *,DBT const *,DBT *,DBT const *,int *))jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_associate_foreign(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_close(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_close(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_compact(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6, void * jarg7) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  DBT *arg4 = (DBT *) 0 ;
+  DB_COMPACT *arg5 = (DB_COMPACT *) 0 ;
+  u_int32_t arg6 ;
+  DBT *arg7 = (DBT *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (DBT *)jarg4; 
+  arg5 = (DB_COMPACT *)jarg5; 
+  arg6 = (u_int32_t)jarg6; 
+  arg7 = (DBT *)jarg7; 
+  result = (int)DB_compact(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_cursor(void * jarg1, void * jarg2, unsigned long jarg3, void * jarg4) {
+  void * jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  u_int32_t arg3 ;
+  int *arg4 = (int *) 0 ;
+  DBC *result = 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (DBC *)DB_cursor(arg1,arg2,arg3,arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_del(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_del(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_env(void * jarg1) {
+  void * jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_ENV *result = 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  result = (DB_ENV *)DB_env(arg1);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_exists(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_exists(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  DBT *arg4 = (DBT *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (DBT *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_get(arg1,arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_byteswapped(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (int)DB_get_byteswapped(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_dbname(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  char **arg2 = (char **) 0 ;
+  char **arg3 = (char **) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (char **)jarg2; 
+  arg3 = (char **)jarg3; 
+  result = (int)DB_get_dbname(arg1,(char const **)arg2,(char const **)arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_multiple(void * jarg1) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  result = (int)DB_get_multiple(arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_open_flags(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_open_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_transactional(void * jarg1) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  result = (int)DB_get_transactional(arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_type(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DBTYPE *arg2 = (DBTYPE *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DBTYPE *)jarg2; 
+  result = (int)DB_get_type(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_join(void * jarg1, void * jarg2, unsigned long jarg3, void * jarg4) {
+  void * jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DBC **arg2 = (DBC **) 0 ;
+  u_int32_t arg3 ;
+  int *arg4 = (int *) 0 ;
+  DBC *result = 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DBC **)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (DBC *)DB_join(arg1,arg2,arg3,arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_key_range(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  DB_KEY_RANGE *arg4 = (DB_KEY_RANGE *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (DB_KEY_RANGE *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_key_range(arg1,arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_open(void * jarg1, void * jarg2, char * jarg3, char * jarg4, int jarg5, unsigned long jarg6, int jarg7) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  DBTYPE arg5 ;
+  u_int32_t arg6 ;
+  int arg7 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  arg5 = (DBTYPE)jarg5; 
+  arg6 = (u_int32_t)jarg6; 
+  arg7 = (int)jarg7; 
+  result = (int)DB_open(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_pget(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  DBT *arg4 = (DBT *) 0 ;
+  DBT *arg5 = (DBT *) 0 ;
+  u_int32_t arg6 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (DBT *)jarg4; 
+  arg5 = (DBT *)jarg5; 
+  arg6 = (u_int32_t)jarg6; 
+  result = (int)DB_pget(arg1,arg2,arg3,arg4,arg5,arg6);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_put(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  DBT *arg4 = (DBT *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (DBT *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_put(arg1,arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_remove(void * jarg1, char * jarg2, char * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_remove(arg1,(char const *)arg2,(char const *)arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_rename(void * jarg1, char * jarg2, char * jarg3, char * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_rename(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_append_recno(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int (*arg2)(DB *,DBT *,db_recno_t) = (int (*)(DB *,DBT *,db_recno_t)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int (*)(DB *,DBT *,db_recno_t))jarg2; 
+  result = (int)DB_set_append_recno(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_bt_compare(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int (*)(DB *,DBT const *,DBT const *))jarg2; 
+  result = (int)DB_set_bt_compare(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_bt_compress(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int (*arg2)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *)) 0 ;
+  int (*arg3)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int (*)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *))jarg2; 
+  arg3 = (int (*)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *))jarg3; 
+  result = (int)DB_set_bt_compress(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_bt_minkey(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_bt_minkey(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_bt_minkey(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_set_bt_minkey(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_bt_prefix(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int (*)(DB *,DBT const *,DBT const *))jarg2; 
+  result = (int)DB_set_bt_prefix(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_cachesize(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int *arg4 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (int)DB_get_cachesize(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_cachesize(void * jarg1, unsigned long jarg2, unsigned long jarg3, int jarg4) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  int arg4 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (int)jarg4; 
+  result = (int)DB_set_cachesize(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_dup_compare(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int (*)(DB *,DBT const *,DBT const *))jarg2; 
+  result = (int)DB_set_dup_compare(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_encrypt_flags(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_encrypt_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_encrypt(void * jarg1, char * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_set_encrypt(arg1,(char const *)arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_set_errcall(void * jarg1, void * jarg2) {
+  DB *arg1 = (DB *) 0 ;
+  void (*arg2)(DB_ENV const *,char const *,char const *) = (void (*)(DB_ENV const *,char const *,char const *)) 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (void (*)(DB_ENV const *,char const *,char const *))jarg2; 
+  DB_set_errcall(arg1,arg2);
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_feedback(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int (*arg2)(DB *,int,int) = (int (*)(DB *,int,int)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int (*)(DB *,int,int))jarg2; 
+  result = (int)DB_set_feedback(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_flags(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_flags(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_set_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_h_compare(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int (*)(DB *,DBT const *,DBT const *))jarg2; 
+  result = (int)DB_set_h_compare(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_h_ffactor(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_h_ffactor(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_h_ffactor(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_set_h_ffactor(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_h_hash(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t (*arg2)(DB *,void const *,u_int32_t) = (u_int32_t (*)(DB *,void const *,u_int32_t)) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t (*)(DB *,void const *,u_int32_t))jarg2; 
+  result = (int)DB_set_h_hash(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_h_nelem(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_h_nelem(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_h_nelem(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_set_h_nelem(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_lorder(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (int)DB_get_lorder(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_lorder(void * jarg1, int jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int)jarg2; 
+  result = (int)DB_set_lorder(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_pagesize(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_pagesize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_pagesize(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_set_pagesize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_priority(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_CACHE_PRIORITY *arg2 = (DB_CACHE_PRIORITY *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_CACHE_PRIORITY *)jarg2; 
+  result = (int)DB_get_priority(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_priority(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_CACHE_PRIORITY arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_CACHE_PRIORITY)jarg2; 
+  result = (int)DB_set_priority(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_q_extentsize(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_q_extentsize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_q_extentsize(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_set_q_extentsize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_re_delim(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (int)DB_get_re_delim(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_re_delim(void * jarg1, int jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int)jarg2; 
+  result = (int)DB_set_re_delim(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_re_len(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_get_re_len(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_re_len(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_set_re_len(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_re_pad(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (int)DB_get_re_pad(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_re_pad(void * jarg1, int jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  int arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (int)jarg2; 
+  result = (int)DB_set_re_pad(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_get_re_source(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  char **arg2 = (char **) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (char **)jarg2; 
+  result = (int)DB_get_re_source(arg1,(char const **)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_set_re_source(void * jarg1, char * jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (int)DB_set_re_source(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_stat(void * jarg1, void * jarg2, unsigned long jarg3, void * jarg4) {
+  void * jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  u_int32_t arg3 ;
+  int *arg4 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (void *)DB_stat(arg1,arg2,arg3,arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_sync(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_sync(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_truncate(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_truncate(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_upgrade(void * jarg1, char * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_upgrade(arg1,(char const *)arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_verify(void * jarg1, char * jarg2, char * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
+  int jresult ;
+  DB *arg1 = (DB *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  FILE *arg4 = (FILE *) 0 ;
+  int (*arg5)(void *,void const *) = (int (*)(void *,void const *)) 0 ;
+  u_int32_t arg6 ;
+  int result;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (FILE *)jarg4; 
+  arg5 = (int (*)(void *,void const *))jarg5; 
+  arg6 = (u_int32_t)jarg6; 
+  result = (int)DB_verify(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DBC_close(void * jarg1) {
+  int jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  int result;
+  
+  arg1 = (DBC *)jarg1; 
+  result = (int)DBC_close(arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DBC_cmp(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  DBC *arg2 = (DBC *) 0 ;
+  int *arg3 = (int *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DBC *)jarg1; 
+  arg2 = (DBC *)jarg2; 
+  arg3 = (int *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DBC_cmp(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DBC_count(void * jarg1, void * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  db_recno_t *arg2 = (db_recno_t *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DBC *)jarg1; 
+  arg2 = (db_recno_t *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DBC_count(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DBC_del(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DBC *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DBC_del(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DBC_dup(void * jarg1, unsigned long jarg2, void * jarg3) {
+  void * jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  DBC *result = 0 ;
+  
+  arg1 = (DBC *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (DBC *)DBC_dup(arg1,arg2,arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DBC_get(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  DBT *arg2 = (DBT *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DBC *)jarg1; 
+  arg2 = (DBT *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DBC_get(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DBC_pget(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  DBT *arg2 = (DBT *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  DBT *arg4 = (DBT *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DBC *)jarg1; 
+  arg2 = (DBT *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (DBT *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DBC_pget(arg1,arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DBC_put(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  DBT *arg2 = (DBT *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DBC *)jarg1; 
+  arg2 = (DBT *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DBC_put(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DBC_set_priority(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DBC *arg1 = (DBC *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DBC *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DBC_set_priority(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DBC() {
+  void * jresult ;
+  DBC *result = 0 ;
+  
+  result = (DBC *)calloc(1, sizeof(DBC));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DBC(void * jarg1) {
+  DBC *arg1 = (DBC *) 0 ;
+  
+  arg1 = (DBC *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DBT_dlen_set(void * jarg1, unsigned long jarg2) {
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DBT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->dlen = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DBT_dlen_get(void * jarg1) {
+  unsigned long jresult ;
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DBT *)jarg1; 
+  result = (u_int32_t) ((arg1)->dlen);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DBT_doff_set(void * jarg1, unsigned long jarg2) {
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DBT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->doff = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DBT_doff_get(void * jarg1) {
+  unsigned long jresult ;
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DBT *)jarg1; 
+  result = (u_int32_t) ((arg1)->doff);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DBT_flags_set(void * jarg1, unsigned long jarg2) {
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DBT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->flags = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DBT_flags_get(void * jarg1) {
+  unsigned long jresult ;
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DBT *)jarg1; 
+  result = (u_int32_t) ((arg1)->flags);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DBT_size_set(void * jarg1, unsigned long jarg2) {
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DBT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->size = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DBT_size_get(void * jarg1) {
+  unsigned long jresult ;
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DBT *)jarg1; 
+  result = (u_int32_t) ((arg1)->size);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DBT_ulen_set(void * jarg1, unsigned long jarg2) {
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DBT *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->ulen = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DBT_ulen_get(void * jarg1) {
+  unsigned long jresult ;
+  DBT *arg1 = (DBT *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DBT *)jarg1; 
+  result = (u_int32_t) ((arg1)->ulen);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DBT_data_set(void * jarg1, void * jarg2) {
+  DBT *arg1 = (DBT *) 0 ;
+  void *arg2 = (void *) 0 ;
+  
+  arg1 = (DBT *)jarg1; 
+  arg2 = (void *)jarg2; 
+  if (arg1) (arg1)->data = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DBT_data_get(void * jarg1) {
+  void * jresult ;
+  DBT *arg1 = (DBT *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DBT *)jarg1; 
+  result = (void *) ((arg1)->data);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DBT_app_data_set(void * jarg1, void * jarg2) {
+  DBT *arg1 = (DBT *) 0 ;
+  void *arg2 = (void *) 0 ;
+  
+  arg1 = (DBT *)jarg1; 
+  arg2 = (void *)jarg2; 
+  if (arg1) (arg1)->app_data = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DBT_app_data_get(void * jarg1) {
+  void * jresult ;
+  DBT *arg1 = (DBT *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DBT *)jarg1; 
+  result = (void *) ((arg1)->app_data);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DBT() {
+  void * jresult ;
+  DBT *result = 0 ;
+  
+  result = (DBT *)new_DBT();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DBT(void * jarg1) {
+  DBT *arg1 = (DBT *) 0 ;
+  
+  arg1 = (DBT *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_REPMGR_SITE_eid_set(void * jarg1, int jarg2) {
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  int arg2 ;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->eid = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_REPMGR_SITE_eid_get(void * jarg1) {
+  int jresult ;
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  int result;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  result = (int) ((arg1)->eid);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_REPMGR_SITE_host_set(void * jarg1, char * jarg2) {
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  char *arg2 ;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg2) strcpy((char *)arg1->host, (const char *)arg2);
+    else arg1->host[0] = 0;
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_DB_REPMGR_SITE_host_get(void * jarg1) {
+  char * jresult ;
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  result = (char *)(char *) ((arg1)->host);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_REPMGR_SITE_port_set(void * jarg1, unsigned int jarg2) {
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  u_int arg2 ;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  arg2 = (u_int)jarg2; 
+  if (arg1) (arg1)->port = arg2;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_DB_REPMGR_SITE_port_get(void * jarg1) {
+  unsigned int jresult ;
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  u_int result;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  result = (u_int) ((arg1)->port);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_REPMGR_SITE_status_set(void * jarg1, unsigned long jarg2) {
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->status = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_REPMGR_SITE_status_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  result = (u_int32_t) ((arg1)->status);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_REPMGR_SITE() {
+  void * jresult ;
+  DB_REPMGR_SITE *result = 0 ;
+  
+  result = (DB_REPMGR_SITE *)calloc(1, sizeof(DB_REPMGR_SITE));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_REPMGR_SITE(void * jarg1) {
+  DB_REPMGR_SITE *arg1 = (DB_REPMGR_SITE *) 0 ;
+  
+  arg1 = (DB_REPMGR_SITE *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_TXN_abort(void * jarg1) {
+  int jresult ;
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  int result;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  result = (int)DB_TXN_abort(arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_TXN_commit(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_TXN_commit(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_TXN_discard(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_TXN_discard(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_TXN_id(void * jarg1) {
+  unsigned long jresult ;
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  result = (u_int32_t)DB_TXN_id(arg1);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_TXN_prepare(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  u_int8_t *arg2 ;
+  int result;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  arg2 = (u_int8_t *)jarg2; 
+  result = (int)DB_TXN_prepare(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_TXN_get_name(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  char **arg2 = (char **) 0 ;
+  int result;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  arg2 = (char **)jarg2; 
+  result = (int)DB_TXN_get_name(arg1,(char const **)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_TXN_set_name(void * jarg1, char * jarg2) {
+  int jresult ;
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int result;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (int)DB_TXN_set_name(arg1,(char const *)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_TXN_set_timeout(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  db_timeout_t arg2 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  arg2 = (db_timeout_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_TXN_set_timeout(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_TXN() {
+  void * jresult ;
+  DB_TXN *result = 0 ;
+  
+  result = (DB_TXN *)calloc(1, sizeof(DB_TXN));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_TXN(void * jarg1) {
+  DB_TXN *arg1 = (DB_TXN *) 0 ;
+  
+  arg1 = (DB_TXN *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_ENV_api2_internal_set(void * jarg1, void * jarg2) {
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  void *arg2 = (void *) 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (void *)jarg2; 
+  if (arg1) (arg1)->api2_internal = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_api2_internal_get(void * jarg1) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  result = (void *) ((arg1)->api2_internal);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_usercopy(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int (*arg2)(DBT *,u_int32_t,void *,u_int32_t,u_int32_t) = (int (*)(DBT *,u_int32_t,void *,u_int32_t,u_int32_t)) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int (*)(DBT *,u_int32_t,void *,u_int32_t,u_int32_t))jarg2; 
+  result = (int)DB_ENV_set_usercopy(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_ENV(unsigned long jarg1) {
+  void * jresult ;
+  u_int32_t arg1 ;
+  DB_ENV *result = 0 ;
+  
+  arg1 = (u_int32_t)jarg1; 
+  result = (DB_ENV *)new_DB_ENV(arg1);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_ENV(void * jarg1) {
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  delete_DB_ENV(arg1);
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_cdsgroup_begin(void * jarg1, void * jarg2) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int *arg2 = (int *) 0 ;
+  DB_TXN *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (DB_TXN *)DB_ENV_cdsgroup_begin(arg1,arg2);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_close(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_close(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_dbremove(void * jarg1, void * jarg2, char * jarg3, char * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_ENV_dbremove(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_dbrename(void * jarg1, void * jarg2, char * jarg3, char * jarg4, char * jarg5, unsigned long jarg6) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  u_int32_t arg6 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  arg5 = (char *)jarg5; 
+  arg6 = (u_int32_t)jarg6; 
+  result = (int)DB_ENV_dbrename(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,arg6);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_failchk(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_failchk(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_fileid_reset(void * jarg1, char * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_fileid_reset(arg1,(char const *)arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_home(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char **arg2 = (char **) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char **)jarg2; 
+  result = (int)DB_ENV_get_home(arg1,(char const **)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_lock_detect(void * jarg1, unsigned long jarg2, unsigned long jarg3, void * jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  u_int32_t *arg4 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (u_int32_t *)jarg4; 
+  result = (int)DB_ENV_lock_detect(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_lock_get(void * jarg1, unsigned long jarg2, unsigned long jarg3, void * jarg4, int jarg5, void * jarg6) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  DBT *arg4 = (DBT *) 0 ;
+  db_lockmode_t arg5 ;
+  int *arg6 = (int *) 0 ;
+  DB_LOCK result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (DBT *)jarg4; 
+  arg5 = (db_lockmode_t)jarg5; 
+  arg6 = (int *)jarg6; 
+  result = DB_ENV_lock_get(arg1,arg2,arg3,arg4,arg5,arg6);
+  {
+    DB_LOCK * resultptr = (DB_LOCK *) malloc(sizeof(DB_LOCK));
+    memmove(resultptr, &result, sizeof(DB_LOCK));
+    jresult = resultptr;
+  }
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_lock_id(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_lock_id(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_lock_id_free(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_lock_id_free(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_lock_put(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_LOCK *arg2 = (DB_LOCK *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_LOCK *)jarg2; 
+  result = (int)DB_ENV_lock_put(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_lock_stat(void * jarg1, unsigned long jarg2, void * jarg3) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (void *)DB_ENV_lock_stat(arg1,arg2,arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_lock_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_lock_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_lock_vec(void * jarg1, unsigned long jarg2, unsigned long jarg3, void * jarg4, int jarg5, void * jarg6) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  DB_LOCKREQ **arg4 = (DB_LOCKREQ **) 0 ;
+  int arg5 ;
+  DB_LOCKREQ *arg6 = (DB_LOCKREQ *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (DB_LOCKREQ **)jarg4; 
+  arg5 = (int)jarg5; 
+  arg6 = (DB_LOCKREQ *)jarg6; 
+  result = (int)DB_ENV_lock_vec(arg1,arg2,arg3,arg4,arg5,arg6);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_log_archive(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  int *arg4 = (int *) 0 ;
+  char **result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (char **)DB_ENV_log_archive(arg1,arg2,arg3,arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_log_file(void * jarg1, void * jarg2, char * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_LSN *arg2 = (DB_LSN *) 0 ;
+  char *arg3 = (char *) 0 ;
+  size_t arg4 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_LSN *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (size_t)jarg4; 
+  result = (int)DB_ENV_log_file(arg1,(struct __db_lsn const *)arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_log_flush(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_LSN *arg2 = (DB_LSN *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_LSN *)jarg2; 
+  result = (int)DB_ENV_log_flush(arg1,(struct __db_lsn const *)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_log_put(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_LSN *arg2 = (DB_LSN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_LSN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_ENV_log_put(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_log_get_config(void * jarg1, unsigned long jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (int)DB_ENV_log_get_config(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_log_set_config(void * jarg1, unsigned long jarg2, int jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int)jarg3; 
+  result = (int)DB_ENV_log_set_config(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_log_printf(void * jarg1, void * jarg2, char * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  char *arg3 = (char *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (char *)jarg3; 
+  result = (int)DB_ENV_log_printf(arg1,arg2,(char const *)arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_log_stat(void * jarg1, unsigned long jarg2, void * jarg3) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (void *)DB_ENV_log_stat(arg1,arg2,arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_log_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_log_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_lsn_reset(void * jarg1, char * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_lsn_reset(arg1,(char const *)arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_memp_stat(void * jarg1, void * jarg2, unsigned long jarg3, void * jarg4, void * jarg5) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  void ***arg2 = (void ***) 0 ;
+  u_int32_t arg3 ;
+  int *arg4 = (int *) 0 ;
+  int *arg5 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (void ***)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (int *)jarg4; 
+  arg5 = (int *)jarg5; 
+  result = (void *)DB_ENV_memp_stat(arg1,arg2,arg3,arg4,arg5);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_memp_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_memp_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_memp_sync(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_LSN *arg2 = (DB_LSN *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_LSN *)jarg2; 
+  result = (int)DB_ENV_memp_sync(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_memp_trickle(void * jarg1, int jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  int *arg3 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (int)DB_ENV_memp_trickle(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_alloc(void * jarg1, unsigned long jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  db_mutex_t *arg3 = (db_mutex_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (db_mutex_t *)jarg3; 
+  result = (int)DB_ENV_mutex_alloc(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_free(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  db_mutex_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (db_mutex_t)jarg2; 
+  result = (int)DB_ENV_mutex_free(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_lock(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  db_mutex_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (db_mutex_t)jarg2; 
+  result = (int)DB_ENV_mutex_lock(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_mutex_stat(void * jarg1, unsigned long jarg2, void * jarg3) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (void *)DB_ENV_mutex_stat(arg1,arg2,arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_mutex_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_unlock(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  db_mutex_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (db_mutex_t)jarg2; 
+  result = (int)DB_ENV_mutex_unlock(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_get_align(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_mutex_get_align(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_set_align(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_mutex_set_align(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_get_increment(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_mutex_get_increment(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_set_increment(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_mutex_set_increment(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_get_max(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_mutex_get_max(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_set_max(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_mutex_set_max(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_get_tas_spins(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_mutex_get_tas_spins(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_mutex_set_tas_spins(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_mutex_set_tas_spins(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_open(void * jarg1, char * jarg2, unsigned long jarg3, int jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int32_t arg3 ;
+  int arg4 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (int)jarg4; 
+  result = (int)DB_ENV_open(arg1,(char const *)arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_open_flags(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_open_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_remove(void * jarg1, char * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_remove(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_repmgr_add_remote_site(void * jarg1, char * jarg2, unsigned int jarg3, void * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int arg3 ;
+  int *arg4 = (int *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int)jarg3; 
+  arg4 = (int *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_ENV_repmgr_add_remote_site(arg1,(char const *)arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_repmgr_set_ack_policy(void * jarg1, int jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  result = (int)DB_ENV_repmgr_set_ack_policy(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_repmgr_get_ack_policy(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (int)DB_ENV_repmgr_get_ack_policy(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_repmgr_set_local_site(void * jarg1, char * jarg2, unsigned int jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int arg3 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_ENV_repmgr_set_local_site(arg1,(char const *)arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_repmgr_site_list(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int *arg2 = (u_int *) 0 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int *arg4 = (int *) 0 ;
+  DB_REPMGR_SITE *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int *)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (DB_REPMGR_SITE *)DB_ENV_repmgr_site_list(arg1,arg2,arg3,arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_repmgr_start(void * jarg1, int jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_repmgr_start(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_repmgr_stat(void * jarg1, unsigned long jarg2, void * jarg3) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (void *)DB_ENV_repmgr_stat(arg1,arg2,arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_repmgr_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_repmgr_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_elect(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_ENV_rep_elect(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_process_message(void * jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DBT *arg2 = (DBT *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  int arg4 ;
+  DB_LSN *arg5 = (DB_LSN *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DBT *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (int)jarg4; 
+  arg5 = (DB_LSN *)jarg5; 
+  result = (int)DB_ENV_rep_process_message(arg1,arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_start(void * jarg1, void * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DBT *arg2 = (DBT *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DBT *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_rep_start(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_rep_stat(void * jarg1, unsigned long jarg2, void * jarg3) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (void *)DB_ENV_rep_stat(arg1,arg2,arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_rep_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_sync(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_rep_sync(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_set_config(void * jarg1, unsigned long jarg2, int jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int)jarg3; 
+  result = (int)DB_ENV_rep_set_config(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_get_config(void * jarg1, unsigned long jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (int)DB_ENV_rep_get_config(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_set_clockskew(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_rep_set_clockskew(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_get_clockskew(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  result = (int)DB_ENV_rep_get_clockskew(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_set_limit(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_rep_set_limit(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_get_limit(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  result = (int)DB_ENV_rep_get_limit(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_set_nsites(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_rep_set_nsites(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_get_nsites(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_rep_get_nsites(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_set_priority(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_rep_set_priority(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_get_priority(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_rep_get_priority(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_set_request(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_rep_set_request(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_get_request(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  result = (int)DB_ENV_rep_get_request(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_set_timeout(void * jarg1, int jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_rep_set_timeout(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_get_timeout(void * jarg1, int jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  result = (int)DB_ENV_rep_get_timeout(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_rep_set_transport(void * jarg1, int jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  int (*arg3)(DB_ENV *,DBT const *,DBT const *,DB_LSN const *,int,u_int32_t) = (int (*)(DB_ENV *,DBT const *,DBT const *,DB_LSN const *,int,u_int32_t)) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  arg3 = (int (*)(DB_ENV *,DBT const *,DBT const *,DB_LSN const *,int,u_int32_t))jarg3; 
+  result = (int)DB_ENV_rep_set_transport(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_cachesize(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int *arg4 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (int)DB_ENV_get_cachesize(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_cachesize(void * jarg1, unsigned long jarg2, unsigned long jarg3, int jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  int arg4 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (int)jarg4; 
+  result = (int)DB_ENV_set_cachesize(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_cache_max(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  result = (int)DB_ENV_get_cache_max(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_cache_max(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_set_cache_max(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_get_data_dirs(void * jarg1, void * jarg2, void * jarg3) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int *arg3 = (int *) 0 ;
+  char **result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int *)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (char **)DB_ENV_get_data_dirs(arg1,arg2,arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_add_data_dir(void * jarg1, char * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (int)DB_ENV_add_data_dir(arg1,(char const *)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_create_dir(void * jarg1, char * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (int)DB_ENV_set_create_dir(arg1,(char const *)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_encrypt_flags(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_encrypt_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_encrypt(void * jarg1, char * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_set_encrypt(arg1,(char const *)arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_ENV_set_errcall(void * jarg1, void * jarg2) {
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  void (*arg2)(DB_ENV const *,char const *,char const *) = (void (*)(DB_ENV const *,char const *,char const *)) 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (void (*)(DB_ENV const *,char const *,char const *))jarg2; 
+  DB_ENV_set_errcall(arg1,arg2);
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_event_notify(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  void (*arg2)(DB_ENV *,u_int32_t,void *) = (void (*)(DB_ENV *,u_int32_t,void *)) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (void (*)(DB_ENV *,u_int32_t,void *))jarg2; 
+  result = (int)DB_ENV_set_event_notify(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_feedback(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  void (*arg2)(DB_ENV *,int,int) = (void (*)(DB_ENV *,int,int)) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (void (*)(DB_ENV *,int,int))jarg2; 
+  result = (int)DB_ENV_set_feedback(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_flags(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_flags(void * jarg1, unsigned long jarg2, int jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int)jarg3; 
+  result = (int)DB_ENV_set_flags(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_intermediate_dir_mode(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char **arg2 = (char **) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char **)jarg2; 
+  result = (int)DB_ENV_get_intermediate_dir_mode(arg1,(char const **)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_intermediate_dir_mode(void * jarg1, char * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (int)DB_ENV_set_intermediate_dir_mode(arg1,(char const *)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_isalive(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int (*arg2)(DB_ENV *,pid_t,db_threadid_t,u_int32_t) = (int (*)(DB_ENV *,pid_t,db_threadid_t,u_int32_t)) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int (*)(DB_ENV *,pid_t,db_threadid_t,u_int32_t))jarg2; 
+  result = (int)DB_ENV_set_isalive(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lg_bsize(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_lg_bsize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lg_bsize(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_lg_bsize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lg_dir(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char **arg2 = (char **) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char **)jarg2; 
+  result = (int)DB_ENV_get_lg_dir(arg1,(char const **)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lg_dir(void * jarg1, char * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (int)DB_ENV_set_lg_dir(arg1,(char const *)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lg_filemode(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (int)DB_ENV_get_lg_filemode(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lg_filemode(void * jarg1, int jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  result = (int)DB_ENV_set_lg_filemode(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lg_max(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_lg_max(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lg_max(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_lg_max(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lg_regionmax(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_lg_regionmax(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lg_regionmax(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_lg_regionmax(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lk_conflicts_nmodes(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (int)DB_ENV_get_lk_conflicts_nmodes(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lk_conflicts(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int8_t *arg2 = (u_int8_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int8_t *)jarg2; 
+  result = (int)DB_ENV_get_lk_conflicts(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lk_conflicts(void * jarg1, void * jarg2, int jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int8_t *arg2 = (u_int8_t *) 0 ;
+  int arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int8_t *)jarg2; 
+  arg3 = (int)jarg3; 
+  result = (int)DB_ENV_set_lk_conflicts(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lk_detect(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_lk_detect(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lk_detect(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_lk_detect(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lk_max_locks(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_lk_max_locks(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lk_max_locks(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_lk_max_locks(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lk_max_lockers(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_lk_max_lockers(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lk_max_lockers(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_lk_max_lockers(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lk_max_objects(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_lk_max_objects(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lk_max_objects(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_lk_max_objects(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_lk_partitions(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_lk_partitions(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_lk_partitions(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_lk_partitions(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_mp_max_openfd(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int *)jarg2; 
+  result = (int)DB_ENV_get_mp_max_openfd(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_mp_max_openfd(void * jarg1, int jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  result = (int)DB_ENV_set_mp_max_openfd(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_mp_max_write(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int *arg2 = (int *) 0 ;
+  db_timeout_t *arg3 = (db_timeout_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int *)jarg2; 
+  arg3 = (db_timeout_t *)jarg3; 
+  result = (int)DB_ENV_get_mp_max_write(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_mp_max_write(void * jarg1, int jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  int arg2 ;
+  db_timeout_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (int)jarg2; 
+  arg3 = (db_timeout_t)jarg3; 
+  result = (int)DB_ENV_set_mp_max_write(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_mp_mmapsize(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  size_t *arg2 = (size_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (size_t *)jarg2; 
+  result = (int)DB_ENV_get_mp_mmapsize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_mp_mmapsize(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  size_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (size_t)jarg2; 
+  result = (int)DB_ENV_set_mp_mmapsize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_thread_count(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_thread_count(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_thread_count(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_thread_count(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_thread_id(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  void (*arg2)(DB_ENV *,pid_t *,db_threadid_t *) = (void (*)(DB_ENV *,pid_t *,db_threadid_t *)) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (void (*)(DB_ENV *,pid_t *,db_threadid_t *))jarg2; 
+  result = (int)DB_ENV_set_thread_id(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_thread_id_string(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *(*arg2)(DB_ENV *,pid_t,db_threadid_t,char *) = (char *(*)(DB_ENV *,pid_t,db_threadid_t,char *)) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *(*)(DB_ENV *,pid_t,db_threadid_t,char *))jarg2; 
+  result = (int)DB_ENV_set_thread_id_string(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_timeout(void * jarg1, void * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  db_timeout_t *arg2 = (db_timeout_t *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (db_timeout_t *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_get_timeout(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_timeout(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  db_timeout_t arg2 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (db_timeout_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_ENV_set_timeout(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_tmp_dir(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char **arg2 = (char **) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char **)jarg2; 
+  result = (int)DB_ENV_get_tmp_dir(arg1,(char const **)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_tmp_dir(void * jarg1, char * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (int)DB_ENV_set_tmp_dir(arg1,(char const *)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_tx_max(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_tx_max(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_tx_max(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_set_tx_max(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_tx_timestamp(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  time_t *arg2 = (time_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (time_t *)jarg2; 
+  result = (int)DB_ENV_get_tx_timestamp(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_tx_timestamp(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  time_t *arg2 = (time_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (time_t *)jarg2; 
+  result = (int)DB_ENV_set_tx_timestamp(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_get_verbose(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_ENV_get_verbose(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_set_verbose(void * jarg1, unsigned long jarg2, int jarg3) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int arg3 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int)jarg3; 
+  result = (int)DB_ENV_set_verbose(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_txn_begin(void * jarg1, void * jarg2, unsigned long jarg3, void * jarg4) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  u_int32_t arg3 ;
+  int *arg4 = (int *) 0 ;
+  DB_TXN *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (DB_TXN *)DB_ENV_txn_begin(arg1,arg2,arg3,arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_txn_checkpoint(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t arg3 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_ENV_txn_checkpoint(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_txn_recover(void * jarg1, void * jarg2, unsigned long jarg3, void * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  DB_PREPLIST *arg2 ;
+  u_int32_t arg3 ;
+  u_int32_t *arg4 = (u_int32_t *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (DB_PREPLIST *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  arg4 = (u_int32_t *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_ENV_txn_recover(arg1,arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_ENV_txn_stat(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
+  void * jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  u_int32_t *arg3 = (u_int32_t *) 0 ;
+  int *arg4 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (u_int32_t *)jarg3; 
+  arg4 = (int *)jarg4; 
+  result = (void *)DB_ENV_txn_stat(arg1,arg2,arg3,arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_ENV_txn_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_ENV_txn_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_KEY_RANGE_less_set(void * jarg1, double jarg2) {
+  DB_KEY_RANGE *arg1 = (DB_KEY_RANGE *) 0 ;
+  double arg2 ;
+  
+  arg1 = (DB_KEY_RANGE *)jarg1; 
+  arg2 = (double)jarg2; 
+  if (arg1) (arg1)->less = arg2;
+}
+
+
+SWIGEXPORT double SWIGSTDCALL CSharp_DB_KEY_RANGE_less_get(void * jarg1) {
+  double jresult ;
+  DB_KEY_RANGE *arg1 = (DB_KEY_RANGE *) 0 ;
+  double result;
+  
+  arg1 = (DB_KEY_RANGE *)jarg1; 
+  result = (double) ((arg1)->less);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_KEY_RANGE_equal_set(void * jarg1, double jarg2) {
+  DB_KEY_RANGE *arg1 = (DB_KEY_RANGE *) 0 ;
+  double arg2 ;
+  
+  arg1 = (DB_KEY_RANGE *)jarg1; 
+  arg2 = (double)jarg2; 
+  if (arg1) (arg1)->equal = arg2;
+}
+
+
+SWIGEXPORT double SWIGSTDCALL CSharp_DB_KEY_RANGE_equal_get(void * jarg1) {
+  double jresult ;
+  DB_KEY_RANGE *arg1 = (DB_KEY_RANGE *) 0 ;
+  double result;
+  
+  arg1 = (DB_KEY_RANGE *)jarg1; 
+  result = (double) ((arg1)->equal);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_KEY_RANGE_greater_set(void * jarg1, double jarg2) {
+  DB_KEY_RANGE *arg1 = (DB_KEY_RANGE *) 0 ;
+  double arg2 ;
+  
+  arg1 = (DB_KEY_RANGE *)jarg1; 
+  arg2 = (double)jarg2; 
+  if (arg1) (arg1)->greater = arg2;
+}
+
+
+SWIGEXPORT double SWIGSTDCALL CSharp_DB_KEY_RANGE_greater_get(void * jarg1) {
+  double jresult ;
+  DB_KEY_RANGE *arg1 = (DB_KEY_RANGE *) 0 ;
+  double result;
+  
+  arg1 = (DB_KEY_RANGE *)jarg1; 
+  result = (double) ((arg1)->greater);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_KEY_RANGE() {
+  void * jresult ;
+  DB_KEY_RANGE *result = 0 ;
+  
+  result = (DB_KEY_RANGE *)calloc(1, sizeof(DB_KEY_RANGE));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_KEY_RANGE(void * jarg1) {
+  DB_KEY_RANGE *arg1 = (DB_KEY_RANGE *) 0 ;
+  
+  arg1 = (DB_KEY_RANGE *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCK_off_set(void * jarg1, unsigned long jarg2) {
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  roff_t arg2 ;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  arg2 = (roff_t)jarg2; 
+  if (arg1) (arg1)->off = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_LOCK_off_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  roff_t result;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  result = (roff_t) ((arg1)->off);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCK_ndx_set(void * jarg1, unsigned long jarg2) {
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->ndx = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_LOCK_ndx_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  result = (u_int32_t) ((arg1)->ndx);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCK_gen_set(void * jarg1, unsigned long jarg2) {
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  u_int32_t arg2 ;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  if (arg1) (arg1)->gen = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_LOCK_gen_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  u_int32_t result;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  result = (u_int32_t) ((arg1)->gen);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCK_mode_set(void * jarg1, int jarg2) {
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  db_lockmode_t arg2 ;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  arg2 = (db_lockmode_t)jarg2; 
+  if (arg1) (arg1)->mode = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_LOCK_mode_get(void * jarg1) {
+  int jresult ;
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  db_lockmode_t result;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  result = (db_lockmode_t) ((arg1)->mode);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_LOCK() {
+  void * jresult ;
+  DB_LOCK *result = 0 ;
+  
+  result = (DB_LOCK *)calloc(1, sizeof(DB_LOCK));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_LOCK(void * jarg1) {
+  DB_LOCK *arg1 = (DB_LOCK *) 0 ;
+  
+  arg1 = (DB_LOCK *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCKREQ_op_set(void * jarg1, int jarg2) {
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  db_lockop_t arg2 ;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  arg2 = (db_lockop_t)jarg2; 
+  if (arg1) (arg1)->op = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_LOCKREQ_op_get(void * jarg1) {
+  int jresult ;
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  db_lockop_t result;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  result = (db_lockop_t) ((arg1)->op);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCKREQ_mode_set(void * jarg1, int jarg2) {
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  db_lockmode_t arg2 ;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  arg2 = (db_lockmode_t)jarg2; 
+  if (arg1) (arg1)->mode = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_LOCKREQ_mode_get(void * jarg1) {
+  int jresult ;
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  db_lockmode_t result;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  result = (db_lockmode_t) ((arg1)->mode);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCKREQ_timeout_set(void * jarg1, unsigned long jarg2) {
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  db_timeout_t arg2 ;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  arg2 = (db_timeout_t)jarg2; 
+  if (arg1) (arg1)->timeout = arg2;
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DB_LOCKREQ_timeout_get(void * jarg1) {
+  unsigned long jresult ;
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  db_timeout_t result;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  result = (db_timeout_t) ((arg1)->timeout);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCKREQ_obj_set(void * jarg1, void * jarg2) {
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  DBT *arg2 = (DBT *) 0 ;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  arg2 = (DBT *)jarg2; 
+  if (arg1) (arg1)->obj = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_LOCKREQ_obj_get(void * jarg1) {
+  void * jresult ;
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  DBT *result = 0 ;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  result = (DBT *) ((arg1)->obj);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_LOCKREQ_lck_set(void * jarg1, void * jarg2) {
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  DB_LOCK *arg2 = (DB_LOCK *) 0 ;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  arg2 = (DB_LOCK *)jarg2; 
+  if (arg1) (arg1)->lock = *arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_LOCKREQ_lck_get(void * jarg1) {
+  void * jresult ;
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  DB_LOCK *result = 0 ;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  result = (DB_LOCK *)& ((arg1)->lock);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_LOCKREQ() {
+  void * jresult ;
+  DB_LOCKREQ *result = 0 ;
+  
+  result = (DB_LOCKREQ *)calloc(1, sizeof(DB_LOCKREQ));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_LOCKREQ(void * jarg1) {
+  DB_LOCKREQ *arg1 = (DB_LOCKREQ *) 0 ;
+  
+  arg1 = (DB_LOCKREQ *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_db_strerror(int jarg1) {
+  char * jresult ;
+  int arg1 ;
+  char *result = 0 ;
+  
+  arg1 = (int)jarg1; 
+  result = (char *)db_strerror(arg1);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_log_compare(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_LSN *arg1 = (DB_LSN *) 0 ;
+  DB_LSN *arg2 = (DB_LSN *) 0 ;
+  int result;
+  
+  arg1 = (DB_LSN *)jarg1; 
+  arg2 = (DB_LSN *)jarg2; 
+  result = (int)log_compare(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp___os_ufree(void * jarg1, void * jarg2) {
+  DB_ENV *arg1 = (DB_ENV *) 0 ;
+  void *arg2 = (void *) 0 ;
+  
+  arg1 = (DB_ENV *)jarg1; 
+  arg2 = (void *)jarg2; 
+  wrap_ufree(arg1,arg2);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_PREPLIST_txn_set(void * jarg1, void * jarg2) {
+  DB_PREPLIST *arg1 = (DB_PREPLIST *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  
+  arg1 = (DB_PREPLIST *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  if (arg1) (arg1)->txn = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_PREPLIST_txn_get(void * jarg1) {
+  void * jresult ;
+  DB_PREPLIST *arg1 = (DB_PREPLIST *) 0 ;
+  DB_TXN *result = 0 ;
+  
+  arg1 = (DB_PREPLIST *)jarg1; 
+  result = (DB_TXN *) ((arg1)->txn);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_DB_PREPLIST_gid_set(void * jarg1, void * jarg2) {
+  DB_PREPLIST *arg1 = (DB_PREPLIST *) 0 ;
+  u_int8_t *arg2 ;
+  
+  arg1 = (DB_PREPLIST *)jarg1; 
+  arg2 = (u_int8_t *)jarg2; 
+  {
+    size_t ii;
+    u_int8_t *b = (u_int8_t *) arg1->gid;
+    for (ii = 0; ii < (size_t)DB_GID_SIZE; ii++) b[ii] = *((u_int8_t *) arg2 + ii);
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_PREPLIST_gid_get(void * jarg1) {
+  void * jresult ;
+  DB_PREPLIST *arg1 = (DB_PREPLIST *) 0 ;
+  u_int8_t *result = 0 ;
+  
+  arg1 = (DB_PREPLIST *)jarg1; 
+  result = (u_int8_t *)(u_int8_t *) ((arg1)->gid);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_PREPLIST() {
+  void * jresult ;
+  DB_PREPLIST *result = 0 ;
+  
+  result = (DB_PREPLIST *)calloc(1, sizeof(DB_PREPLIST));
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_PREPLIST(void * jarg1) {
+  DB_PREPLIST *arg1 = (DB_PREPLIST *) 0 ;
+  
+  arg1 = (DB_PREPLIST *)jarg1; 
+  free((char *) arg1);
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_DB_SEQUENCE(void * jarg1, unsigned long jarg2) {
+  void * jresult ;
+  DB *arg1 = (DB *) 0 ;
+  u_int32_t arg2 ;
+  DB_SEQUENCE *result = 0 ;
+  
+  arg1 = (DB *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (DB_SEQUENCE *)new_DB_SEQUENCE(arg1,arg2);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_DB_SEQUENCE(void * jarg1) {
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  delete_DB_SEQUENCE(arg1);
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_close(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_SEQUENCE_close(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_get(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned long jarg5) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  int32_t arg3 ;
+  db_seq_t *arg4 = (db_seq_t *) 0 ;
+  u_int32_t arg5 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (int32_t)jarg3; 
+  arg4 = (db_seq_t *)jarg4; 
+  arg5 = (u_int32_t)jarg5; 
+  result = (int)DB_SEQUENCE_get(arg1,arg2,arg3,arg4,arg5);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_SEQUENCE_get_db(void * jarg1) {
+  void * jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  DB *result = 0 ;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  result = (DB *)DB_SEQUENCE_get_db(arg1);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_get_key(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  DBT *arg2 = (DBT *) 0 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (DBT *)jarg2; 
+  result = (int)DB_SEQUENCE_get_key(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_initial_value(void * jarg1, long long jarg2) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  db_seq_t arg2 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (db_seq_t)jarg2; 
+  result = (int)DB_SEQUENCE_initial_value(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_open(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  DBT *arg3 = (DBT *) 0 ;
+  u_int32_t arg4 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (DBT *)jarg3; 
+  arg4 = (u_int32_t)jarg4; 
+  result = (int)DB_SEQUENCE_open(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_remove(void * jarg1, void * jarg2, unsigned long jarg3) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  DB_TXN *arg2 = (DB_TXN *) 0 ;
+  u_int32_t arg3 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (DB_TXN *)jarg2; 
+  arg3 = (u_int32_t)jarg3; 
+  result = (int)DB_SEQUENCE_remove(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_get_cachesize(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  int32_t *arg2 = (int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (int32_t *)jarg2; 
+  result = (int)DB_SEQUENCE_get_cachesize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_set_cachesize(void * jarg1, int jarg2) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (int32_t)jarg2; 
+  result = (int)DB_SEQUENCE_set_cachesize(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_get_flags(void * jarg1, void * jarg2) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  u_int32_t *arg2 = (u_int32_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (u_int32_t *)jarg2; 
+  result = (int)DB_SEQUENCE_get_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_set_flags(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_SEQUENCE_set_flags(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_get_range(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  db_seq_t *arg2 = (db_seq_t *) 0 ;
+  db_seq_t *arg3 = (db_seq_t *) 0 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (db_seq_t *)jarg2; 
+  arg3 = (db_seq_t *)jarg3; 
+  result = (int)DB_SEQUENCE_get_range(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_set_range(void * jarg1, long long jarg2, long long jarg3) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  db_seq_t arg2 ;
+  db_seq_t arg3 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (db_seq_t)jarg2; 
+  arg3 = (db_seq_t)jarg3; 
+  result = (int)DB_SEQUENCE_set_range(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_DB_SEQUENCE_stat(void * jarg1, unsigned long jarg2, void * jarg3) {
+  void * jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  u_int32_t arg2 ;
+  int *arg3 = (int *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  arg3 = (int *)jarg3; 
+  result = (void *)DB_SEQUENCE_stat(arg1,arg2,arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_DB_SEQUENCE_stat_print(void * jarg1, unsigned long jarg2) {
+  int jresult ;
+  DB_SEQUENCE *arg1 = (DB_SEQUENCE *) 0 ;
+  u_int32_t arg2 ;
+  int result;
+  
+  arg1 = (DB_SEQUENCE *)jarg1; 
+  arg2 = (u_int32_t)jarg2; 
+  result = (int)DB_SEQUENCE_stat_print(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+