wasCSharpSQLite – Rev 1
?pathlinks?
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using sqlite3_int64 = System.Int64;
using u32 = System.UInt32;
using System.Text;
namespace Community.CsharpSqlite
{
public partial class Sqlite3
{
/*
*************************************************************************
**
** This file contains low-level memory & pool allocation drivers
**
** This file contains implementations of the low-level memory allocation
** routines specified in the sqlite3_mem_methods object.
**
*************************************************************************
*/
/*
** Like malloc(), but remember the size of the allocation
** so that we can find it later using sqlite3MemSize().
**
** For this low-level routine, we are guaranteed that nByte>0 because
** cases of nByte<=0 will be intercepted and dealt with by higher level
** routines.
*/
#if SQLITE_POOL_MEM
#if TRUE
static byte[] sqlite3MemMalloc( u32 nByte )
{
return new byte[nByte];
}
static byte[] sqlite3MemMalloc( int nByte )
{
return new byte[nByte];
}
static int[] sqlite3MemMallocInt( int nInt )
{
return new int[nInt];
}
#else
static byte[] sqlite3MemMalloc(int nByte)
{
byte[] pByte = null;
int savej = -1;
int BestSize = int.MaxValue;
if (nByte > mem0.aByteSize[0])
{
int i;
for (i = 0; i < mem0.aByteSize.Length - 1; i++) if (nByte <= mem0.aByteSize[i]) break;
mem0.mr_Byte++;
for (int j = 0; j <= mem0.aByte_used[i]; j++)
if (mem0.aByte[i][j] != null)
{
if (mem0.aByte[i][j].Length == nByte)
{
pByte = mem0.aByte[i][j]; mem0.aByte[i][j] = null; mem0.cf_Byte++;
if (j == mem0.aByte_used[i]) mem0.aByte_used[i]--;
break;
}
if (mem0.aByte[i][j].Length > nByte)
{
if (mem0.aByte[i][j].Length < BestSize)
{
BestSize = mem0.aByte[i][j].Length;
savej = j;
}
}
}
if (pByte == null && savej >= 0)
{
pByte = mem0.aByte[i][savej]; mem0.aByte[i][savej] = null; mem0.cf_Byte++;
Array.Resize(ref pByte, nByte);
}
if (mem0.aByte_used[i] >=0 && mem0.aByte[i][mem0.aByte_used[i]] == null) mem0.aByte_used[i]--;
}
if (pByte == null) pByte = new byte[nByte];
return pByte;
}
static int[] sqlite3MemMallocInt(int nInt)
{
int[] pInt = null;
int savei = -1;
int BestSize = int.MaxValue;
if (nInt >=10)
{
mem0.mr_Int++;
int i;
for (i = 0; i < mem0.hw_Int; i++)
if (mem0.aInt[i] != null)
{
if (mem0.aInt[i].Length == nInt)
{
pInt = mem0.aInt[i]; mem0.aInt[i] = null; mem0.cf_Int++; break;
}
if (mem0.aInt[i].Length > nInt)
{
if (mem0.aInt[i].Length < BestSize)
{
BestSize = mem0.aInt[i].Length;
savei = i;
}
}
}
if (pInt == null && savei >= 0)
{
pInt = mem0.aInt[savei]; mem0.aInt[savei] = null; mem0.cf_Int++;
}
}
if (pInt == null) pInt = new int[nInt];
return pInt;
}
#endif
static Mem sqlite3MemMallocMem( Mem dummy )
{
Mem pMem;
mem0.msMem.alloc++;
if ( mem0.msMem.next > 0 && mem0.aMem[mem0.msMem.next] != null )
{
pMem = mem0.aMem[mem0.msMem.next];
mem0.aMem[mem0.msMem.next] = null;
mem0.msMem.cached++;
mem0.msMem.next--;
}
else
pMem = new Mem();
return pMem;
}
static BtCursor sqlite3MemMallocBtCursor( BtCursor dummy )
{
BtCursor pBtCursor;
mem0.msBtCursor.alloc++;
if ( mem0.msBtCursor.next > 0 && mem0.aBtCursor[mem0.msBtCursor.next] != null )
{
pBtCursor = mem0.aBtCursor[mem0.msBtCursor.next];
Debug.Assert( pBtCursor.pNext == null && pBtCursor.pPrev == null && pBtCursor.wrFlag == 0 );
mem0.aBtCursor[mem0.msBtCursor.next] = null;
mem0.msBtCursor.cached++;
mem0.msBtCursor.next--;
}
else
pBtCursor = new BtCursor();
return pBtCursor;
}
#endif
/*
** Free memory.
*/
// -- overloads ---------------------------------------
static void sqlite3MemFree<T>( ref T x ) where T : class
{
x = null;
}
static void sqlite3MemFree( ref string x )
{
x = null;
}
//
/*
** Like free() but works for allocations obtained from sqlite3MemMalloc()
** or sqlite3MemRealloc().
**
** For this low-level routine, we already know that pPrior!=0 since
** cases where pPrior==0 will have been intecepted and dealt with
** by higher-level routines.
*/
#if SQLITE_POOL_MEM
#if TRUE
static void sqlite3MemFreeInt( ref int[] pPrior )
{
pPrior = null;
}
#else
static void sqlite3MemFree(ref byte[] pPrior)
{
if (pPrior == null) return;
if (pPrior.Length > mem0.aByteSize[0])
{
int savej = -1;
int Smallest = int.MaxValue;
int i;
for (i = 0; i < mem0.aByteSize.Length - 1; i++) if (pPrior.Length <= mem0.aByteSize[i]) break;
#if DEBUG
for (int j = 0; j < mem0.aByte[i].Length; j++) if (mem0.aByte[i][j] != null && mem0.aByte[i][j] == pPrior) Debugger.Break();
#endif
mem0.mf_Byte++;
for (int j = 0; j <= mem0.aByte_used[i]; j++)
{
if (mem0.aByte[i][j] == null)
{
mem0.aByte[i][j] = pPrior;
pPrior = null;
return;
}
if (mem0.aByte[i][j].Length < Smallest)
{
savej = j;
Smallest = mem0.aByte[i][j].Length;
}
}
if (mem0.aByte_used[i] < mem0.aByte[i].Length - 1) mem0.aByte[i][++mem0.aByte_used[i]] = pPrior;
else if (savej >= 0) mem0.aByte[i][savej] = pPrior;
}
pPrior = null;
return;
}
static void sqlite3MemFreeInt(ref int[] pPrior)
{
if (pPrior == null) return;
if (pPrior.Length >= 10)
{
int savei = -1;
int Smallest = int.MaxValue;
#if DEBUG
for (int i = 0; i < mem0.aInt.Length; i++) if (mem0.aInt[i] != null && mem0.aInt[i] == pPrior) Debugger.Break();
#endif
mem0.mf_Int++;
for (int i = 0; i < mem0.aInt.Length; i++)
{
if (mem0.aInt[i] == null)
{
mem0.aInt[i] = pPrior;
pPrior = null;
return;
}
if (mem0.aInt[i].Length < Smallest)
{
savei = i;
Smallest = mem0.aInt[i].Length;
}
}
if (savei >= 0) mem0.aInt[savei] = pPrior;
}
pPrior = null;
return;
}
#endif
static void sqlite3MemFreeMem( ref Mem pPrior )
{
if ( pPrior == null )
return;
#if FALSE && DEBUG
for (int i = mem0.msMem.next - 1; i >= 0; i--) if (mem0.aMem[i] != null && mem0.aMem[i] == pPrior) Debugger.Break();
#endif
mem0.msMem.dealloc++;
if ( mem0.msMem.next < mem0.aMem.Length - 1 )
{
pPrior.db = null;
pPrior._SumCtx = null;
pPrior._MD5Context = null;
pPrior._SubProgram = null;
pPrior.flags = MEM_Null;
pPrior.r = 0;
pPrior.u.i = 0;
pPrior.n = 0;
if ( pPrior.zBLOB != null )
sqlite3MemFree( ref pPrior.zBLOB );
mem0.aMem[++mem0.msMem.next] = pPrior;
if ( mem0.msMem.next > mem0.msMem.max )
mem0.msMem.max = mem0.msMem.next;
}
//Array.Resize( ref mem0.aMem, (int)(mem0.hw_Mem * 1.5 + 1 ));
//mem0.aMem[mem0.hw_Mem] = pPrior;
//mem0.hw_Mem = mem0.aMem.Length;
pPrior = null;
return;
}
static void sqlite3MemFreeBtCursor( ref BtCursor pPrior )
{
if ( pPrior == null )
return;
#if FALSE && DEBUG
for ( int i = mem0.msBtCursor.next - 1; i >= 0; i-- ) if ( mem0.aBtCursor[i] != null && mem0.aBtCursor[i] == pPrior ) Debugger.Break();
#endif
mem0.msBtCursor.dealloc++;
if ( mem0.msBtCursor.next < mem0.aBtCursor.Length - 1 )
{
mem0.aBtCursor[++mem0.msBtCursor.next] = pPrior;
if ( mem0.msBtCursor.next > mem0.msBtCursor.max )
mem0.msBtCursor.max = mem0.msBtCursor.next;
}
//Array.Resize( ref mem0.aBtCursor, (int)(mem0.hw_BtCursor * 1.5 + 1 ));
//mem0.aBtCursor[mem0.hw_BtCursor] = pPrior;
//mem0.hw_BtCursor = mem0.aBtCursor.Length;
pPrior = null;
return;
}
/*
** Like realloc(). Resize an allocation previously obtained from
** sqlite3MemMalloc().
**
** For this low-level interface, we know that pPrior!=0. Cases where
** pPrior==0 while have been intercepted by higher-level routine and
** redirected to xMalloc. Similarly, we know that nByte>0 becauses
** cases where nByte<=0 will have been intercepted by higher-level
** routines and redirected to xFree.
*/
static byte[] sqlite3MemRealloc( ref byte[] pPrior, int nByte )
{
// sqlite3_int64 p = (sqlite3_int64*)pPrior;
// Debug.Assert(pPrior!=0 && nByte>0 );
// nByte = ROUND8( nByte );
// p = (sqlite3_int64*)pPrior;
// p--;
// p = realloc(p, nByte+8 );
// if( p ){
// p[0] = nByte;
// p++;
// }
// return (void*)p;
Array.Resize( ref pPrior, nByte );
return pPrior;
}
#else
/*
** No-op versions of all memory allocation routines
*/
static byte[] sqlite3MemMalloc(int nByte) { return new byte[nByte]; }
static int[] sqlite3MemMallocInt(int nInt) { return new int[nInt]; }
static Mem sqlite3MemMallocMem( Mem pMem) { return new Mem(); }
static void sqlite3MemFree( ref byte[] pPrior ) { pPrior = null; }
static void sqlite3MemFreeInt( ref int[] pPrior ) { pPrior = null; }
static void sqlite3MemFreeMem(ref Mem pPrior) { pPrior = null; }
static int sqlite3MemInit() { return SQLITE_OK; }
static void sqlite3MemShutdown() { }
static BtCursor sqlite3MemMallocBtCursor( BtCursor dummy ){return new BtCursor();}
static void sqlite3MemFreeBtCursor(ref BtCursor pPrior) { pPrior = null; }
#endif
static byte[] sqlite3MemRealloc( byte[] pPrior, int nByte )
{
Array.Resize( ref pPrior, nByte );
return pPrior;
}
/*
** Report the allocated size of a prior return from xMalloc()
** or xRealloc().
*/
static int sqlite3MemSize( byte[] pPrior )
{
// sqlite3_int64 p;
// if( pPrior==0 ) return 0;
// p = (sqlite3_int64*)pPrior;
// p--;
// return p[0];
return pPrior == null ? 0 : (int)pPrior.Length;
}
/*
** Round up a request size to the next valid allocation size.
*/
static int sqlite3MemRoundup( int n )
{
return n;// ROUND8( n );
}
/*
** Initialize this module.
*/
static int sqlite3MemInit( object NotUsed )
{
UNUSED_PARAMETER( NotUsed );
if ( !sqlite3GlobalConfig.bMemstat )
{
/* If memory status is enabled, then the malloc.c wrapper will already
** hold the STATIC_MEM mutex when the routines here are invoked. */
mem0.mutex = sqlite3MutexAlloc( SQLITE_MUTEX_STATIC_MEM );
}
return SQLITE_OK;
}
/*
** Deinitialize this module.
*/
static void sqlite3MemShutdown( object NotUsed )
{
UNUSED_PARAMETER( NotUsed );
return;
}
/*
** This routine is the only routine in this file with external linkage.
**
** Populate the low-level memory allocation function pointers in
** sqlite3GlobalConfig.m with pointers to the routines in this file.
*/
static void sqlite3MemSetDefault()
{
sqlite3_mem_methods defaultMethods = new sqlite3_mem_methods(
sqlite3MemMalloc,
sqlite3MemMallocInt,
sqlite3MemMallocMem,
sqlite3MemFree,
sqlite3MemFreeInt,
sqlite3MemFreeMem,
sqlite3MemRealloc,
sqlite3MemSize,
sqlite3MemRoundup,
(dxMemInit)sqlite3MemInit,
(dxMemShutdown)sqlite3MemShutdown,
0
);
sqlite3_config( SQLITE_CONFIG_MALLOC, defaultMethods );
}
static void sqlite3DbFree( sqlite3 db, ref int[] pPrior )
{
if ( pPrior != null )
sqlite3MemFreeInt( ref pPrior );
}
static void sqlite3DbFree( sqlite3 db, ref Mem pPrior )
{
if ( pPrior != null )
sqlite3MemFreeMem( ref pPrior );
}
static void sqlite3DbFree( sqlite3 db, ref Mem[] pPrior )
{
if ( pPrior != null )
for ( int i = 0; i < pPrior.Length; i++ )
sqlite3MemFreeMem( ref pPrior[i] );
}
static void sqlite3DbFree<T>( sqlite3 db, ref T pT ) where T : class
{
}
static void sqlite3DbFree( sqlite3 db, ref string pString )
{
}
}
}