Index: SQLite.NET.Settings.targets
==================================================================
--- SQLite.NET.Settings.targets
+++ SQLite.NET.Settings.targets
@@ -198,16 +198,16 @@
     -->
     <CountHandle Condition="'$(CountHandle)' == ''">false</CountHandle>
 
     <!--
         NOTE: Enable tracking of all outstanding bytes allocated by the
-              SQLiteMarshal class.  By default, this is disabled.  If this is
+              SQLiteMemory class.  By default, this is disabled.  If this is
               enabled, this library will keep track of all outstanding bytes
-              allocated by the SQLiteMarshal class.  This has the potential to
+              allocated by the SQLiteMemory class.  This has the potential to
               slow down the library a bit.
     -->
-    <TrackMarshalBytes Condition="'$(TrackMarshalBytes)' == ''">false</TrackMarshalBytes>
+    <TrackMemoryBytes Condition="'$(TrackMemoryBytes)' == ''">false</TrackMemoryBytes>
 
     <!--
         NOTE: For interaction with the native SQLite implementation, use the
               custom built interop DLL (i.e. "SQLite.Interop.dll")?  By default,
               this is enabled.  This property is mutually exclusive with the

Index: Setup/set_user_mistachkin_Debug.bat
==================================================================
--- Setup/set_user_mistachkin_Debug.bat
+++ Setup/set_user_mistachkin_Debug.bat
@@ -15,6 +15,6 @@
 SET MSBUILD_ARGS=/p:CheckState=true
 SET MSBUILD_ARGS=%MSBUILD_ARGS% /p:CountHandle=true
 SET MSBUILD_ARGS=%MSBUILD_ARGS% /p:TraceConnection=true
 SET MSBUILD_ARGS=%MSBUILD_ARGS% /p:TraceHandle=true
 SET MSBUILD_ARGS=%MSBUILD_ARGS% /p:TraceStatement=true
-SET MSBUILD_ARGS=%MSBUILD_ARGS% /p:TrackMarshalBytes=true
+SET MSBUILD_ARGS=%MSBUILD_ARGS% /p:TrackMemoryBytes=true

Index: System.Data.SQLite/SQLite3.cs
==================================================================
--- System.Data.SQLite/SQLite3.cs
+++ System.Data.SQLite/SQLite3.cs
@@ -1607,11 +1607,11 @@
         }
         finally
         {
             if (pName != IntPtr.Zero)
             {
-                SQLiteMarshal.Free(pName);
+                SQLiteMemory.Free(pName);
                 pName = IntPtr.Zero;
             }
         }
     }
 
@@ -1690,11 +1690,11 @@
         }
         finally
         {
             if (pSql != IntPtr.Zero)
             {
-                SQLiteMarshal.Free(pSql);
+                SQLiteMemory.Free(pSql);
                 pSql = IntPtr.Zero;
             }
         }
     }
 

Index: System.Data.SQLite/SQLiteDefineConstants.cs
==================================================================
--- System.Data.SQLite/SQLiteDefineConstants.cs
+++ System.Data.SQLite/SQLiteDefineConstants.cs
@@ -110,12 +110,12 @@
 
 #if TRACE_WARNING
             "TRACE_WARNING",
 #endif
 
-#if TRACK_MARSHAL_BYTES
-            "TRACK_MARSHAL_BYTES",
+#if TRACK_MEMORY_BYTES
+            "TRACK_MEMORY_BYTES",
 #endif
 
 #if USE_INTEROP_DLL
             "USE_INTEROP_DLL",
 #endif

Index: System.Data.SQLite/SQLiteModuleBase.cs
==================================================================
--- System.Data.SQLite/SQLiteModuleBase.cs
+++ System.Data.SQLite/SQLiteModuleBase.cs
@@ -8,11 +8,11 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Runtime.InteropServices;
 using System.Text;
 
-#if TRACK_MARSHAL_BYTES
+#if TRACK_MEMORY_BYTES
 using System.Threading;
 #endif
 
 namespace System.Data.SQLite
 {
@@ -1341,142 +1341,28 @@
     }
     #endregion
 
     ///////////////////////////////////////////////////////////////////////////
 
-    #region SQLiteMarshal Class
-    internal static class SQLiteMarshal
-    {
-        #region Private Constants
-        private static int ThirtyBits = 0x3fffffff;
-        private static readonly Encoding Utf8Encoding = Encoding.UTF8;
-        #endregion
-
-        ///////////////////////////////////////////////////////////////////////
-
-        #region Private Data
-#if TRACK_MARSHAL_BYTES
+    #region SQLiteMemory Class
+    internal static class SQLiteMemory
+    {
+        #region Private Data
+#if TRACK_MEMORY_BYTES
         private static int bytesAllocated;
         private static int maximumBytesAllocated;
 #endif
         #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
-        #region IntPtr Helper Methods
-        internal static IntPtr IntPtrForOffset(
-            IntPtr pointer,
-            int offset
-            )
-        {
-            return new IntPtr(pointer.ToInt64() + offset);
-        }
-        #endregion
-
-        ///////////////////////////////////////////////////////////////////////
-
-        #region Marshal Read Helper Methods
-        internal static int ReadInt32(
-            IntPtr pointer,
-            int offset
-            )
-        {
-#if !PLATFORM_COMPACTFRAMEWORK
-            return Marshal.ReadInt32(pointer, offset);
-#else
-            return Marshal.ReadInt32(IntPtrForOffset(pointer, offset));
-#endif
-        }
-
-        ///////////////////////////////////////////////////////////////////////
-
-        internal static double ReadDouble(
-            IntPtr pointer,
-            int offset
-            )
-        {
-#if !PLATFORM_COMPACTFRAMEWORK
-            return BitConverter.Int64BitsToDouble(Marshal.ReadInt64(
-                pointer, offset));
-#else
-            return BitConverter.ToDouble(BitConverter.GetBytes(
-                Marshal.ReadInt64(IntPtrForOffset(pointer, offset))), 0);
-#endif
-        }
-
-        ///////////////////////////////////////////////////////////////////////
-
-        internal static IntPtr ReadIntPtr(
-            IntPtr pointer,
-            int offset
-            )
-        {
-#if !PLATFORM_COMPACTFRAMEWORK
-            return Marshal.ReadIntPtr(pointer, offset);
-#else
-            return Marshal.ReadIntPtr(IntPtrForOffset(pointer, offset));
-#endif
-        }
-        #endregion
-
-        ///////////////////////////////////////////////////////////////////////
-
-        #region Marshal Write Helper Methods
-        internal static void WriteInt32(
-            IntPtr pointer,
-            int offset,
-            int value
-            )
-        {
-#if !PLATFORM_COMPACTFRAMEWORK
-            Marshal.WriteInt32(pointer, offset, value);
-#else
-            Marshal.WriteInt32(IntPtrForOffset(pointer, offset), value);
-#endif
-        }
-
-        ///////////////////////////////////////////////////////////////////////
-
-        internal static void WriteDouble(
-            IntPtr pointer,
-            int offset,
-            double value
-            )
-        {
-#if !PLATFORM_COMPACTFRAMEWORK
-            Marshal.WriteInt64(pointer, offset,
-                BitConverter.DoubleToInt64Bits(value));
-#else
-            Marshal.WriteInt64(IntPtrForOffset(pointer, offset),
-                BitConverter.ToInt64(BitConverter.GetBytes(value), 0));
-#endif
-        }
-
-        ///////////////////////////////////////////////////////////////////////
-
-        internal static void WriteIntPtr(
-            IntPtr pointer,
-            int offset,
-            IntPtr value
-            )
-        {
-#if !PLATFORM_COMPACTFRAMEWORK
-            Marshal.WriteIntPtr(pointer, offset, value);
-#else
-            Marshal.WriteIntPtr(IntPtrForOffset(pointer, offset), value);
-#endif
-        }
-        #endregion
-
-        ///////////////////////////////////////////////////////////////////////
-
         #region Memory Allocation Helper Methods
-        internal static IntPtr Allocate(int size)
+        public static IntPtr Allocate(int size)
         {
             IntPtr pMemory = UnsafeNativeMethods.sqlite3_malloc(size);
 
-#if TRACK_MARSHAL_BYTES
+#if TRACK_MEMORY_BYTES
             if (pMemory != IntPtr.Zero)
             {
                 int blockSize = Size(pMemory);
 
                 if (blockSize > 0)
@@ -1490,32 +1376,24 @@
             return pMemory;
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static int Size(IntPtr pMemory)
+        public static int Size(IntPtr pMemory)
         {
 #if !SQLITE_STANDARD
-            try
-            {
-                return UnsafeNativeMethods.sqlite3_malloc_size_interop(
-                    pMemory);
-            }
-            catch
-            {
-                // do nothing.
-            }
-#endif
-
+            return UnsafeNativeMethods.sqlite3_malloc_size_interop(pMemory);
+#else
             return 0;
+#endif
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static void Free(IntPtr pMemory)
+        public static void Free(IntPtr pMemory)
         {
-#if TRACK_MARSHAL_BYTES
+#if TRACK_MEMORY_BYTES
             if (pMemory != IntPtr.Zero)
             {
                 int blockSize = Size(pMemory);
 
                 if (blockSize > 0)
@@ -1524,15 +1402,134 @@
 #endif
 
             UnsafeNativeMethods.sqlite3_free(pMemory);
         }
         #endregion
+    }
+    #endregion
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    #region SQLiteMarshal Class
+    internal static class SQLiteMarshal
+    {
+        #region Private Constants
+        private static int ThirtyBits = 0x3fffffff;
+        private static readonly Encoding Utf8Encoding = Encoding.UTF8;
+        #endregion
+
+        ///////////////////////////////////////////////////////////////////////
+
+        #region IntPtr Helper Methods
+        public static IntPtr IntPtrForOffset(
+            IntPtr pointer,
+            int offset
+            )
+        {
+            return new IntPtr(pointer.ToInt64() + offset);
+        }
+        #endregion
+
+        ///////////////////////////////////////////////////////////////////////
+
+        #region Marshal Read Helper Methods
+        public static int ReadInt32(
+            IntPtr pointer,
+            int offset
+            )
+        {
+#if !PLATFORM_COMPACTFRAMEWORK
+            return Marshal.ReadInt32(pointer, offset);
+#else
+            return Marshal.ReadInt32(IntPtrForOffset(pointer, offset));
+#endif
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+
+        public static double ReadDouble(
+            IntPtr pointer,
+            int offset
+            )
+        {
+#if !PLATFORM_COMPACTFRAMEWORK
+            return BitConverter.Int64BitsToDouble(Marshal.ReadInt64(
+                pointer, offset));
+#else
+            return BitConverter.ToDouble(BitConverter.GetBytes(
+                Marshal.ReadInt64(IntPtrForOffset(pointer, offset))), 0);
+#endif
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+
+        public static IntPtr ReadIntPtr(
+            IntPtr pointer,
+            int offset
+            )
+        {
+#if !PLATFORM_COMPACTFRAMEWORK
+            return Marshal.ReadIntPtr(pointer, offset);
+#else
+            return Marshal.ReadIntPtr(IntPtrForOffset(pointer, offset));
+#endif
+        }
+        #endregion
+
+        ///////////////////////////////////////////////////////////////////////
+
+        #region Marshal Write Helper Methods
+        public static void WriteInt32(
+            IntPtr pointer,
+            int offset,
+            int value
+            )
+        {
+#if !PLATFORM_COMPACTFRAMEWORK
+            Marshal.WriteInt32(pointer, offset, value);
+#else
+            Marshal.WriteInt32(IntPtrForOffset(pointer, offset), value);
+#endif
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+
+        public static void WriteDouble(
+            IntPtr pointer,
+            int offset,
+            double value
+            )
+        {
+#if !PLATFORM_COMPACTFRAMEWORK
+            Marshal.WriteInt64(pointer, offset,
+                BitConverter.DoubleToInt64Bits(value));
+#else
+            Marshal.WriteInt64(IntPtrForOffset(pointer, offset),
+                BitConverter.ToInt64(BitConverter.GetBytes(value), 0));
+#endif
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+
+        public static void WriteIntPtr(
+            IntPtr pointer,
+            int offset,
+            IntPtr value
+            )
+        {
+#if !PLATFORM_COMPACTFRAMEWORK
+            Marshal.WriteIntPtr(pointer, offset, value);
+#else
+            Marshal.WriteIntPtr(IntPtrForOffset(pointer, offset), value);
+#endif
+        }
+        #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
         #region Byte Array Helper Methods
-        internal static byte[] BytesFromIntPtr(
+        public static byte[] BytesFromIntPtr(
             IntPtr pValue,
             int length
             )
         {
             if (pValue == IntPtr.Zero)
@@ -1548,11 +1545,11 @@
             return result;
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static IntPtr BytesToIntPtr(
+        public static IntPtr BytesToIntPtr(
             byte[] value
             )
         {
             if (value == null)
                 return IntPtr.Zero;
@@ -1560,11 +1557,11 @@
             int length = value.Length;
 
             if (length == 0)
                 return IntPtr.Zero;
 
-            IntPtr result = Allocate(length);
+            IntPtr result = SQLiteMemory.Allocate(length);
 
             if (result == IntPtr.Zero)
                 return IntPtr.Zero;
 
             Marshal.Copy(value, 0, result, length);
@@ -1574,11 +1571,11 @@
         #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
         #region UTF-8 Encoding Helper Methods
-        internal static byte[] GetUtf8BytesFromString(
+        public static byte[] GetUtf8BytesFromString(
             string value
             )
         {
             if (value == null)
                 return null;
@@ -1586,11 +1583,11 @@
             return Utf8Encoding.GetBytes(value);
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static string GetStringFromUtf8Bytes(
+        public static string GetStringFromUtf8Bytes(
             byte[] bytes
             )
         {
             if (bytes == null)
                 return null;
@@ -1604,11 +1601,11 @@
         #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
         #region UTF-8 String Helper Methods
-        internal static int ProbeForUtf8ByteLength(
+        public static int ProbeForUtf8ByteLength(
             IntPtr pValue,
             int limit
             )
         {
             int length = 0;
@@ -1630,21 +1627,21 @@
             return length;
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static string StringFromUtf8IntPtr(
+        public static string StringFromUtf8IntPtr(
             IntPtr pValue
             )
         {
             return StringFromUtf8IntPtr(pValue,
                 ProbeForUtf8ByteLength(pValue, ThirtyBits));
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static string StringFromUtf8IntPtr(
+        public static string StringFromUtf8IntPtr(
             IntPtr pValue,
             int length
             )
         {
             if (pValue == IntPtr.Zero)
@@ -1662,11 +1659,11 @@
             return String.Empty;
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static IntPtr Utf8IntPtrFromString(
+        public static IntPtr Utf8IntPtrFromString(
             string value
             )
         {
             if (value == null)
                 return IntPtr.Zero;
@@ -1677,11 +1674,11 @@
             if (bytes == null)
                 return IntPtr.Zero;
 
             int length = bytes.Length;
 
-            result = Allocate(length + 1);
+            result = SQLiteMemory.Allocate(length + 1);
 
             if (result == IntPtr.Zero)
                 return IntPtr.Zero;
 
             Marshal.Copy(bytes, 0, result, length);
@@ -1692,11 +1689,11 @@
         #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
         #region UTF-8 String Array Helper Methods
-        internal static string[] StringArrayFromUtf8IntPtrArray(
+        public static string[] StringArrayFromUtf8IntPtrArray(
             IntPtr[] pValues
             )
         {
             if (pValues == null)
                 return null;
@@ -1709,11 +1706,11 @@
             return result;
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static IntPtr[] Utf8IntPtrArrayFromStringArray(
+        public static IntPtr[] Utf8IntPtrArrayFromStringArray(
             string[] values
             )
         {
             if (values == null)
                 return null;
@@ -1728,11 +1725,11 @@
         #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
         #region SQLiteValue Helper Methods
-        internal static SQLiteValue[] ValueArrayFromSizeAndIntPtr(
+        public static SQLiteValue[] ValueArrayFromSizeAndIntPtr(
             int nData,
             IntPtr apData
             )
         {
             if (nData < 0)
@@ -1756,11 +1753,11 @@
             return result;
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static SQLiteValue[] ValueArrayFromIntPtrArray(
+        public static SQLiteValue[] ValueArrayFromIntPtrArray(
             IntPtr[] values
             )
         {
             if (values == null)
                 return null;
@@ -1775,11 +1772,11 @@
         #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
         #region SQLiteIndex Helper Methods
-        internal static void IndexFromIntPtr(
+        public static void IndexFromIntPtr(
             IntPtr pIndex,
             ref SQLiteIndex index
             )
         {
             if (pIndex == IntPtr.Zero)
@@ -1874,11 +1871,11 @@
             }
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        internal static void IndexToIntPtr(
+        public static void IndexToIntPtr(
             SQLiteIndex index,
             IntPtr pIndex
             )
         {
             if ((index == null) || (index.Inputs == null) ||
@@ -2057,11 +2054,11 @@
         protected virtual IntPtr AllocateTable()
         {
             int size = Marshal.SizeOf(typeof(
                 UnsafeNativeMethods.sqlite3_vtab));
 
-            return SQLiteMarshal.Allocate(size);
+            return SQLiteMemory.Allocate(size);
         }
 
         ///////////////////////////////////////////////////////////////////////
 
         protected virtual void ZeroTable(IntPtr pVtab)
@@ -2085,11 +2082,11 @@
         ///////////////////////////////////////////////////////////////////////
 
         protected virtual void FreeTable(IntPtr pVtab)
         {
             SetTableError(pVtab, null);
-            SQLiteMarshal.Free(pVtab);
+            SQLiteMemory.Free(pVtab);
         }
         #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
@@ -2097,18 +2094,18 @@
         protected virtual IntPtr AllocateCursor()
         {
             int size = Marshal.SizeOf(typeof(
                 UnsafeNativeMethods.sqlite3_vtab_cursor));
 
-            return SQLiteMarshal.Allocate(size);
+            return SQLiteMemory.Allocate(size);
         }
 
         ///////////////////////////////////////////////////////////////////////
 
         protected virtual void FreeCursor(IntPtr pCursor)
         {
-            SQLiteMarshal.Free(pCursor);
+            SQLiteMemory.Free(pCursor);
         }
         #endregion
 
         ///////////////////////////////////////////////////////////////////////
 
@@ -2291,11 +2288,11 @@
             int offset = IntPtr.Size + sizeof(int);
             IntPtr pError = SQLiteMarshal.ReadIntPtr(pVtab, offset);
 
             if (pError != IntPtr.Zero)
             {
-                SQLiteMarshal.Free(pError); pError = IntPtr.Zero;
+                SQLiteMemory.Free(pError); pError = IntPtr.Zero;
                 SQLiteMarshal.WriteIntPtr(pVtab, offset, pError);
             }
 
             if (error == null)
                 return true;
@@ -2310,11 +2307,11 @@
             }
             finally
             {
                 if (!success && (pError != IntPtr.Zero))
                 {
-                    SQLiteMarshal.Free(pError);
+                    SQLiteMemory.Free(pError);
                     pError = IntPtr.Zero;
                 }
             }
 
             return success;

Index: System.Data.SQLite/System.Data.SQLite.Properties.targets
==================================================================
--- System.Data.SQLite/System.Data.SQLite.Properties.targets
+++ System.Data.SQLite/System.Data.SQLite.Properties.targets
@@ -76,14 +76,14 @@
   <PropertyGroup Condition="'$(CountHandle)' != 'false'">
     <DefineConstants>$(DefineConstants);COUNT_HANDLE</DefineConstants>
   </PropertyGroup>
 
   <!--
-      NOTE: Enable tracking of bytes allocated by the SQLiteMarshal class?
+      NOTE: Enable tracking of bytes allocated by the SQLiteMemory class?
   -->
-  <PropertyGroup Condition="'$(TrackMarshalBytes)' != 'false'">
-    <DefineConstants>$(DefineConstants);TRACK_MARSHAL_BYTES</DefineConstants>
+  <PropertyGroup Condition="'$(TrackMemoryBytes)' != 'false'">
+    <DefineConstants>$(DefineConstants);TRACK_MEMORY_BYTES</DefineConstants>
   </PropertyGroup>
 
   <!--
       NOTE: For interaction with the native SQLite implementation, use the
             custom build interop DLL (i.e. "SQLite.Interop.DLL")?

Index: Tests/common.eagle
==================================================================
--- Tests/common.eagle
+++ Tests/common.eagle
@@ -1476,17 +1476,17 @@
     proc reportSQLiteResources { channel {quiet false} {collect true} } {
       #
       # NOTE: Skip all output if we are running in "quiet" mode.
       #
       if {[haveConstraint \
-              defineConstant.System.Data.SQLite.TRACK_MARSHAL_BYTES]} then {
+              defineConstant.System.Data.SQLite.TRACK_MEMORY_BYTES]} then {
         if {!$quiet} then {
-          tputs $channel "---- current memory in use by SQLiteMarshal... "
+          tputs $channel "---- current memory in use by SQLiteMemory... "
         }
 
         if {[catch {object invoke -flags +NonPublic \
-                System.Data.SQLite.SQLiteMarshal \
+                System.Data.SQLite.SQLiteMemory \
                 bytesAllocated} memory] == 0} then {
           if {!$quiet} then {
             tputs $channel [appendArgs $memory " bytes\n"]
           }
         } else {
@@ -1496,15 +1496,15 @@
             tputs $channel [appendArgs $memory \n]
           }
         }
 
         if {!$quiet} then {
-          tputs $channel "---- maximum memory in use by SQLiteMarshal... "
+          tputs $channel "---- maximum memory in use by SQLiteMemory... "
         }
 
         if {[catch {object invoke -flags +NonPublic \
-                System.Data.SQLite.SQLiteMarshal \
+                System.Data.SQLite.SQLiteMemory \
                 maximumBytesAllocated} memory] == 0} then {
           if {!$quiet} then {
             tputs $channel [appendArgs $memory " bytes\n"]
           }
         } else {
@@ -1953,11 +1953,11 @@
             INTEROP_EXTENSION_FUNCTIONS INTEROP_LEGACY_CLOSE INTEROP_LOG \
             INTEROP_TEST_EXTENSION NET_20 NET_35 NET_40 NET_45 NET_COMPACT_20 \
             PLATFORM_COMPACTFRAMEWORK PRELOAD_NATIVE_LIBRARY RETARGETABLE \
             SQLITE_STANDARD THROW_ON_DISPOSED TRACE TRACE_CONNECTION \
             TRACE_HANDLE TRACE_PRELOAD TRACE_STATEMENT TRACE_WARNING \
-            TRACK_MARSHAL_BYTES USE_INTEROP_DLL USE_PREPARE_V2 WINDOWS] {
+            TRACK_MEMORY_BYTES USE_INTEROP_DLL USE_PREPARE_V2 WINDOWS] {
           #
           # NOTE: Check if the compile-time option is listed in the list of
           #       "define constants" kept track of by the managed assembly.
           #
           checkForSQLiteDefineConstant $::test_channel $defineConstant