System.Data.SQLite

        /// </param>
        /// <returns>
        /// The actual size, in bytes, of the memory block specified via the
        /// native pointer.
        /// </returns>
        public static int Size(IntPtr pMemory)
        {
#if DEBUG
            SQLiteMarshal.CheckAlignment("Size", pMemory, 0, IntPtr.Size);
#endif

#if !SQLITE_STANDARD
            return UnsafeNativeMethods.sqlite3_malloc_size_interop(pMemory);
#elif TRACK_MEMORY_BYTES
            //
            // HACK: Ok, we cannot determine the size of the memory block;
            //       therefore, just track number of allocations instead.
            //

        /// </summary>
        /// <param name="pMemory">
        /// The native pointer to the memory block previously obtained from the
        /// <see cref="Allocate" /> method.
        /// </param>
        public static void Free(IntPtr pMemory)
        {
#if DEBUG
            SQLiteMarshal.CheckAlignment("Free", pMemory, 0, IntPtr.Size);
#endif

#if TRACK_MEMORY_BYTES
            if (pMemory != IntPtr.Zero)
            {
                int blockSize = Size(pMemory);

                if (blockSize > 0)
                {

        /// </summary>
        /// <param name="pMemory">
        /// The native pointer to the memory block previously obtained from the
        /// SQLite core library.
        /// </param>
        public static void FreeUntracked(IntPtr pMemory)
        {
#if DEBUG
            SQLiteMarshal.CheckAlignment(
                "FreeUntracked", pMemory, 0, IntPtr.Size);
#endif

            UnsafeNativeMethods.sqlite3_free(pMemory);
        }
        #endregion
    }
    #endregion

    ///////////////////////////////////////////////////////////////////////////

        /// </returns>
        public static int ReadInt32(
            IntPtr pointer,
            int offset
            )
        {
#if DEBUG
            CheckAlignment("ReadInt32", pointer, offset, sizeof(int));
#endif

#if !PLATFORM_COMPACTFRAMEWORK
            return Marshal.ReadInt32(pointer, offset);
#else
            return Marshal.ReadInt32(IntPtrForOffset(pointer, offset));
#endif

        /// </returns>
        public static long ReadInt64(
            IntPtr pointer,
            int offset
            )
        {
#if DEBUG
            CheckAlignment("ReadInt64", pointer, offset, sizeof(long));
#endif

#if !PLATFORM_COMPACTFRAMEWORK
            return Marshal.ReadInt64(pointer, offset);
#else
            return Marshal.ReadInt64(IntPtrForOffset(pointer, offset));
#endif

        /// </returns>
        public static double ReadDouble(
            IntPtr pointer,
            int offset
            )
        {
#if DEBUG
            CheckAlignment("ReadDouble", pointer, offset, sizeof(double));
#endif

#if !PLATFORM_COMPACTFRAMEWORK
            return BitConverter.Int64BitsToDouble(Marshal.ReadInt64(
                pointer, offset));
#else
            return BitConverter.ToDouble(BitConverter.GetBytes(

        /// </returns>
        public static IntPtr ReadIntPtr(
            IntPtr pointer,
            int offset
            )
        {
#if DEBUG
            CheckAlignment("ReadIntPtr", pointer, offset, IntPtr.Size);
#endif

#if !PLATFORM_COMPACTFRAMEWORK
            return Marshal.ReadIntPtr(pointer, offset);
#else
            return Marshal.ReadIntPtr(IntPtrForOffset(pointer, offset));
#endif

        public static void WriteInt32(
            IntPtr pointer,
            int offset,
            int value
            )
        {
#if DEBUG
            CheckAlignment("WriteInt32", pointer, offset, sizeof(int));
#endif

#if !PLATFORM_COMPACTFRAMEWORK
            Marshal.WriteInt32(pointer, offset, value);
#else
            Marshal.WriteInt32(IntPtrForOffset(pointer, offset), value);
#endif

        public static void WriteInt64(
            IntPtr pointer,
            int offset,
            long value
            )
        {
#if DEBUG
            CheckAlignment("WriteInt64", pointer, offset, sizeof(long));
#endif

#if !PLATFORM_COMPACTFRAMEWORK
            Marshal.WriteInt64(pointer, offset, value);
#else
            Marshal.WriteInt64(IntPtrForOffset(pointer, offset), value);
#endif

        public static void WriteDouble(
            IntPtr pointer,
            int offset,
            double value
            )
        {
#if DEBUG
            CheckAlignment("WriteDouble", pointer, offset, sizeof(double));
#endif

#if !PLATFORM_COMPACTFRAMEWORK
            Marshal.WriteInt64(pointer, offset,
                BitConverter.DoubleToInt64Bits(value));
#else
            Marshal.WriteInt64(IntPtrForOffset(pointer, offset),

        public static void WriteIntPtr(
            IntPtr pointer,
            int offset,
            IntPtr value
            )
        {
#if DEBUG
            CheckAlignment(
                "WriteIntPtr(pointer)", pointer, offset, IntPtr.Size);

            CheckAlignment("WriteIntPtr(value)", value, 0, IntPtr.Size);
#endif

#if !PLATFORM_COMPACTFRAMEWORK
            Marshal.WriteIntPtr(pointer, offset, value);
#else
            Marshal.WriteIntPtr(IntPtrForOffset(pointer, offset), value);
#endif

        }
        #endregion

        ///////////////////////////////////////////////////////////////////////

        #region Private Methods
#if DEBUG
        internal static void CheckAlignment(
            string type,
            IntPtr pointer,
            int offset,
            int size
            )
        {
            IntPtr savedPointer = pointer;


            if (offset != 0)

                pointer = new IntPtr(pointer.ToInt64() + offset);


            if ((pointer.ToInt64() % size) != 0)

            {
                SQLiteLog.LogMessage(SQLiteErrorCode.Warning,
                    HelperMethods.StringFormat(CultureInfo.CurrentCulture,

                    "{0}: pointer {1} and offset {2} not aligned to {3}: {4}",
                    type, savedPointer, offset, size, Environment.StackTrace));
            }
        }
#endif
        #endregion
    }
    #endregion