wasCSharpSQLite – Rev 1
?pathlinks?
using System.Diagnostics;
namespace Community.CsharpSqlite
{
#if TCLSH
using tcl.lang;
using Tcl_Interp = tcl.lang.Interp;
using Tcl_Obj = tcl.lang.TclObject;
public partial class Sqlite3
{
/*
** 2007 August 15
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
**
** This file contains code used to implement test interfaces to the
** memory allocation subsystem.
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2
**
*************************************************************************
*/
//#include "sqliteInt.h"
//#include "tcl.h"
//#include <stdlib.h>
//#include <string.h>
//#include <assert.h>
/*
** This structure is used to encapsulate the global state variables used
** by malloc() fault simulation.
*/
struct MemFault
{
public int iCountdown; /* Number of pending successes before a failure */
public int nRepeat; /* Number of times to repeat the failure */
public int nBenign; /* Number of benign failures seen since last config */
public int nFail; /* Number of failures seen since last config */
public int enable; /* True if enabled */
public int isInstalled; /* True if the fault simulation layer is installed */
public int isBenignMode; /* True if malloc failures are considered benign */
public sqlite3_mem_methods m; /* 'Real' malloc implementation */
}
static MemFault memfault;
/*
** This routine exists as a place to set a breakpoint that will
** fire on any simulated malloc() failure.
*/
static int cnt = 0;
static void sqlite3Fault()
{
cnt++;
}
/*
** Check to see if a fault should be simulated. Return true to simulate
** the fault. Return false if the fault should not be simulated.
*/
static int faultsimStep()
{
if ( likely( memfault.enable != 0 ) )
{
return 0;
}
if ( memfault.iCountdown > 0 )
{
memfault.iCountdown--;
return 0;
}
sqlite3Fault();
memfault.nFail++;
if ( memfault.isBenignMode > 0 )
{
memfault.nBenign++;
}
memfault.nRepeat--;
if ( memfault.nRepeat <= 0 )
{
memfault.enable = 0;
}
return 1;
}
/*
** A version of sqlite3_mem_methods.xMalloc() that includes fault simulation
** logic.
*/
static byte[] faultsimMalloc( int n )
{
byte[] p = null;
if ( faultsimStep() != 0 )
{
p = memfault.m.xMalloc( n );
}
return p;
}
static int[] faultsimMallocInt( int n )
{
int[] p = null;
if ( faultsimStep() != 0 )
{
p = memfault.m.xMallocInt( n );
}
return p;
}
static Mem faultsimMallocMem( Mem n )
{
Mem p = null;
if ( faultsimStep() != 0 )
{
p = memfault.m.xMallocMem( n );
}
return p;
}
/*
** A version of sqlite3_mem_methods.xRealloc() that includes fault simulation
** logic.
*/
static byte[] faultsimRealloc( byte[] pOld, int n )
{
byte[] p = null;
if ( faultsimStep() != 0 )
{
p = memfault.m.xRealloc( pOld, n );
}
return p;
}
/*
** The following method calls are passed directly through to the underlying
** malloc system:
**
** xFree
** xSize
** xRoundup
** xInit
** xShutdown
*/
static void faultsimFree( ref byte[] p )
{
memfault.m.xFree( ref p );
}
static void faultsimFreeInt( ref int[] p )
{
memfault.m.xFreeInt( ref p );
}
static void faultsimFreeMem( ref Mem p )
{
memfault.m.xFreeMem( ref p );
}
static int faultsimSize( byte[] p )
{
return memfault.m.xSize( p );
}
static int faultsimRoundup( int n )
{
return memfault.m.xRoundup( n );
}
static int faultsimInit( object p )
{
return memfault.m.xInit( memfault.m.pAppData );
}
static void faultsimShutdown( object p )
{
memfault.m.xShutdown( memfault.m.pAppData );
}
/*
** This routine configures the malloc failure simulation. After
** calling this routine, the next nDelay mallocs will succeed, followed
** by a block of nRepeat failures, after which malloc() calls will begin
** to succeed again.
*/
static void faultsimConfig( int nDelay, int nRepeat )
{
memfault.iCountdown = nDelay;
memfault.nRepeat = nRepeat;
memfault.nBenign = 0;
memfault.nFail = 0;
memfault.enable = ( nDelay >= 0 ) ? 1 : 0;
/* Sometimes, when running multi-threaded tests, the isBenignMode
** variable is not properly incremented/decremented so that it is
** 0 when not inside a benign malloc block. This doesn't affect
** the multi-threaded tests, as they do not use this system. But
** it does affect OOM tests run later in the same process. So
** zero the variable here, just to be sure.
*/
memfault.isBenignMode = 0;
}
/*
** Return the number of faults (both hard and benign faults) that have
** occurred since the injector was last configured.
*/
static int faultsimFailures()
{
return memfault.nFail;
}
/*
** Return the number of benign faults that have occurred since the
** injector was last configured.
*/
static int faultsimBenignFailures()
{
return memfault.nBenign;
}
/*
** Return the number of successes that will occur before the next failure.
** If no failures are scheduled, return -1.
*/
static int faultsimPending()
{
if ( memfault.enable != 0 )
{
return memfault.iCountdown;
}
else
{
return -1;
}
}
static void faultsimBeginBenign()
{
memfault.isBenignMode++;
}
static void faultsimEndBenign()
{
memfault.isBenignMode--;
}
/*
** Add or remove the fault-simulation layer using sqlite3_config(). If
** the argument is non-zero, the
*/
static int faultsimInstall( int install )
{
sqlite3_mem_methods m = new sqlite3_mem_methods(
(dxMalloc)faultsimMalloc, /* xMalloc */
(dxMallocInt)faultsimMallocInt, /* xMalloc */
(dxMallocMem)faultsimMallocMem, /* xMalloc */
(dxFree)faultsimFree, /* xFree */
(dxFreeInt)faultsimFreeInt, /* xFree */
(dxFreeMem)faultsimFreeMem,
(dxRealloc)faultsimRealloc, /* xRealloc */
(dxSize)faultsimSize, /* xSize */
(dxRoundup)faultsimRoundup, /* xRoundup */
(dxMemInit)faultsimInit, /* xInit */
(dxMemShutdown)faultsimShutdown, /* xShutdown */
null /* pAppData */
);
int rc;
//install = ( install != 0 ? 1 : 0 );
Debug.Assert( memfault.isInstalled == 1 || memfault.isInstalled == 0 );
if ( install == memfault.isInstalled )
{
return SQLITE_ERROR;
}
if ( install != 0 )
{
rc = sqlite3_config( SQLITE_CONFIG_GETMALLOC, ref memfault.m );
Debug.Assert( memfault.m.xMalloc != null );
if ( rc == SQLITE_OK )
{
rc = sqlite3_config( SQLITE_CONFIG_MALLOC, m );
}
sqlite3_test_control( SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS,
(void_function)faultsimBeginBenign, (void_function)faultsimEndBenign
);
}
else
{
//sqlite3_mem_methods m;
Debug.Assert( memfault.m.xMalloc != null );
/* One should be able to reset the default memory allocator by storing
** a zeroed allocator then calling GETMALLOC. */
m = new sqlite3_mem_methods();// memset( &m, 0, sizeof( m ) );
sqlite3_config( SQLITE_CONFIG_MALLOC, m );
sqlite3_config( SQLITE_CONFIG_GETMALLOC, ref m );
Debug.Assert( m.GetHashCode() == memfault.m.GetHashCode() );//memcmp(&m, &memfault.m, sizeof(m))==0 );
rc = sqlite3_config( SQLITE_CONFIG_MALLOC, ref memfault.m );
sqlite3_test_control( SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, 0, 0 );
}
if ( rc == SQLITE_OK )
{
memfault.isInstalled = 1;
}
return rc;
}
#if SQLITE_TEST
/*
** This function is implemented in test1.c. Returns a pointer to a static
** buffer containing the symbolic SQLite error code that corresponds to
** the least-significant 8-bits of the integer passed as an argument.
** For example:
**
** sqlite3TestErrorName(1) -> "SQLITE_ERROR"
*/
//string sqlite3TestErrorName(int);
/*
** Transform pointers to text and back again
*/
//static void pointerToText(object p, string z){
// static const char zHex[] = "0123456789abcdef";
// int i, k;
// unsigned int u;
// sqlite3_u3264 n;
// if( p==0 ){
// strcpy(z, "0");
// return;
//}
// if( sizeof(n)==sizeof(p) ){
// memcpy(&n, ref p, sizeof(p));
// }else if( sizeof(u)==sizeof(p) ){
// memcpy(&u, ref p, sizeof(u));
// n = u;
// }else{
// Debug.Assert( 0 );
// }
// for(i=0, k=sizeof(p)*2-1; i<sizeof(p)*2; i++, k--){
// z[k] = zHex[n&0xf];
// n >>= 4;
// }
// z[sizeof(p)*2] = 0;
//}
//static int hexToInt(int h){
// if( h>='0' && h<='9' ){
// return h - '0';
// }else if( h>='a' && h<='f' ){
// return h - 'a' + 10;
// }else{
// return -1;
// }
//}
//static int textToPointer(string z, object **pp){
// sqlite3_u3264 n = 0;
// int i;
// unsigned int u;
// for(i=0; i<sizeof(void)*2 && z[0]; i++){
// int v;
// v = hexToInt(*z++);
// if( v<0 ) return TCL.TCL_ERROR;
// n = n*16 + v;
// }
// if( *z!=0 ) return TCL.TCL_ERROR;
// if( sizeof(n)==sizeof(*pp) ){
// memcpy(pp, ref n, sizeof(n));
// }else if( sizeof(u)==sizeof(*pp) ){
// u = (unsigned int)n;
// memcpy(pp, ref u, sizeof(u));
// }else{
// Debug.Assert( 0 );
// }
// return TCL.TCL_OK;
//}
/*
** Usage: sqlite3Malloc NBYTES
**
** Raw test interface for sqlite3Malloc().
*/
//static int test_malloc(
// object clientdata,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// int nByte;
// object p;
// char zOut[100];
// if( objc!=2 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "NBYTES");
// return TCL.TCL_ERROR;
// }
// if( TCL.Tcl_GetIntFromObj(interp, objv[1], out nByte) ) return TCL.TCL_ERROR;
// p = sqlite3Malloc((unsigned)nByte);
// pointerToText(p, zOut);
// TCL.TCL_AppendResult(interp, zOut, NULL);
// return TCL.TCL_OK;
//}
/*
** Usage: sqlite3_realloc PRIOR NBYTES
**
** Raw test interface for sqlite3_realloc().
*/
//static int test_realloc(
// object clientdata,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// int nByte;
// void pPrior, p;
// char zOut[100];
// if( objc!=3 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "PRIOR NBYTES");
// return TCL.TCL_ERROR;
// }
// if( TCL.Tcl_GetIntFromObj(interp, objv[2], out nByte) ) return TCL.TCL_ERROR;
// if( textToPointer(Tcl_GetString(objv[1]), out pPrior) ){
// TCL.TCL_AppendResult(interp, "bad pointer: ", TCL.Tcl_GetString(objv[1]));
// return TCL.TCL_ERROR;
// }
// p = sqlite3_realloc(pPrior, (unsigned)nByte);
// pointerToText(p, zOut);
// TCL.TCL_AppendResult(interp, zOut, NULL);
// return TCL.TCL_OK;
//}
/*
** tclcmd: sqlite3_config_uri BOOLEAN
**
** Invoke sqlite3_config() or sqlite3_db_config() with invalid
** opcodes and verify that they return errors.
*/
static int test_config_uri(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
){
int rc;
bool bOpenUri = false;
if( objc!=2 ){
TCL.Tcl_WrongNumArgs(interp, 1, objv, "BOOL");
return TCL.TCL_ERROR;
}
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[1], out bOpenUri ) )
{
return TCL.TCL_ERROR;
}
rc = sqlite3_config(SQLITE_CONFIG_URI, bOpenUri);
TCL.Tcl_SetResult( interp, sqlite3TestErrorName( rc ), TCL.TCL_VOLATILE );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_free PRIOR
**
** Raw test interface for sqlite3DbFree(db,).
*/
//static int test_free(
// object clientdata,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// void pPrior;
// if( objc!=2 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "PRIOR");
// return TCL.TCL_ERROR;
// }
// if( textToPointer(Tcl_GetString(objv[1]), out pPrior) ){
// TCL.TCL_AppendResult(interp, "bad pointer: ", TCL.Tcl_GetString(objv[1]));
// return TCL.TCL_ERROR;
// }
// sqlite3DbFree(db,pPrior);
// return TCL.TCL_OK;
//}
/*
** These routines are in test_hexio.c
*/
//int sqlite3TestHexToBin(string , int, char );
//int sqlite3TestBinToHex(char*,int);
/*
** Usage: memset ADDRESS SIZE HEX
**
** Set a chunk of memory (obtained from malloc, probably) to a
** specified hex pattern.
*/
//static int test_memset(
// object clientdata,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// object p;
// int size, n, i;
// string zHex;
// string zOut;
// char zBin[100];
// if( objc!=4 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "ADDRESS SIZE HEX");
// return TCL.TCL_ERROR;
// }
// if( textToPointer(Tcl_GetString(objv[1]), out p) ){
// TCL.TCL_AppendResult(interp, "bad pointer: ", TCL.Tcl_GetString(objv[1]));
// return TCL.TCL_ERROR;
// }
// if( TCL.Tcl_GetIntFromObj(interp, objv[2], out size) ){
// return TCL.TCL_ERROR;
// }
// if( size<=0 ){
// TCL.TCL_AppendResult(interp, "size must be positive");
// return TCL.TCL_ERROR;
// }
// zHex = TCL.Tcl_GetStringFromObj(objv[3], out n);
// if( n>sizeof(zBin)*2 ) n = sizeof(zBin)*2;
// n = sqlite3TestHexToBin(zHex, n, zBin);
// if( n==0 ){
// TCL.TCL_AppendResult(interp, "no data");
// return TCL.TCL_ERROR;
// }
// zOut = p;
// for(i=0; i<size; i++){
// zOut[i] = zBin[i%n];
// }
// return TCL.TCL_OK;
//}
/*
** Usage: memget ADDRESS SIZE
**
** Return memory as hexadecimal text.
*/
//static int test_memget(
// object clientdata,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// object p;
// int size, n;
// string zBin;
// char zHex[100];
// if( objc!=3 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "ADDRESS SIZE");
// return TCL.TCL_ERROR;
// }
// if( textToPointer(Tcl_GetString(objv[1]), out p) ){
// TCL.TCL_AppendResult(interp, "bad pointer: ", TCL.Tcl_GetString(objv[1]));
// return TCL.TCL_ERROR;
// }
// if( TCL.Tcl_GetIntFromObj(interp, objv[2], out size) ){
// return TCL.TCL_ERROR;
// }
// if( size<=0 ){
// TCL.TCL_AppendResult(interp, "size must be positive");
// return TCL.TCL_ERROR;
// }
// zBin = p;
// while( size>0 ){
// if( size>(sizeof(zHex)-1)/2 ){
// n = (sizeof(zHex)-1)/2;
// }else{
// n = size;
// }
// memcpy(zHex, zBin, n);
// zBin += n;
// size -= n;
// sqlite3TestBinToHex(zHex, n);
// TCL.TCL_AppendResult(interp, zHex);
// }
// return TCL.TCL_OK;
//}
#if FALSE
/*
** Usage: sqlite3_memory_used
**
** Raw test interface for sqlite3_memory_used().
*/
static int test_memory_used(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewWideIntObj( sqlite3_memory_used() ) );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_memory_highwater ?RESETFLAG?
**
** Raw test interface for sqlite3_memory_highwater().
*/
static int test_memory_highwater(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
bool resetFlag = false;
if ( objc != 1 && objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "?RESET?" );
return TCL.TCL_ERROR;
}
if ( objc == 2 )
{
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[1], out resetFlag ) ) return TCL.TCL_ERROR;
}
TCL.Tcl_SetObjResult( interp,
TCL.Tcl_NewWideIntObj( sqlite3_memory_highwater( resetFlag ? 1 : 0 ) ) );
return TCL.TCL_OK;
}
#endif
/*
** Usage: sqlite3_memdebug_backtrace DEPTH
**
** Set the depth of backtracing. If SQLITE_MEMDEBUG is not defined
** then this routine is a no-op.
*/
//static int test_memdebug_backtrace(
// object clientdata,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// int depth;
// if( objc!=2 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "DEPT");
// return TCL.TCL_ERROR;
// }
// if( TCL.Tcl_GetIntFromObj(interp, objv[1], out depth) ) return TCL.TCL_ERROR;
//#if SQLITE_MEMDEBUG
// {
// extern void sqlite3MemdebugBacktrace(int);
// sqlite3MemdebugBacktrace(depth);
// }
//#endif
// return TCL.TCL_OK;
//}
/*
** Usage: sqlite3_memdebug_dump FILENAME
**
** Write a summary of unfreed memory to FILENAME.
*/
static int test_memdebug_dump(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "FILENAME" );
return TCL.TCL_ERROR;
}
#if (SQLITE_MEMDEBUG) || (SQLITE_MEMORY_SIZE) || (SQLITE_POW2_MEMORY_SIZE)
{
extern void sqlite3MemdebugDump(const char);
sqlite3MemdebugDump(Tcl_GetString(objv[1]));
}
#endif
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_memdebug_malloc_count
**
** Return the total number of times malloc() has been called.
*/
static int test_memdebug_malloc_count(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int nMalloc = -1;
if ( objc != 1 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "" );
return TCL.TCL_ERROR;
}
#if SQLITE_MEMDEBUG
{
extern int sqlite3MemdebugMallocCount();
nMalloc = sqlite3MemdebugMallocCount();
}
#endif
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( nMalloc ) );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_memdebug_fail COUNTER ?OPTIONS?
**
** where options are:
**
** -repeat <count>
** -benigncnt <varname>
**
** Arrange for a simulated malloc() failure after COUNTER successes.
** If a repeat count is specified, the fault is repeated that many
** times.
**
** Each call to this routine overrides the prior counter value.
** This routine returns the number of simulated failures that have
** happened since the previous call to this routine.
**
** To disable simulated failures, use a COUNTER of -1.
*/
static int test_memdebug_fail(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int ii;
int iFail = 0;
int nRepeat = 1;
Tcl_Obj pBenignCnt = null;
int nBenign;
int nFail = 0;
if ( objc < 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "COUNTER ?OPTIONS?" );
return TCL.TCL_ERROR;
}
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[1], out iFail ) )
return TCL.TCL_ERROR;
for ( ii = 2; ii < objc; ii += 2 )
{
int nOption = 0;
string zOption = TCL.Tcl_GetStringFromObj( objv[ii], out nOption );
string zErr = "";
if ( nOption > 1 && zOption == "-repeat" )
{
if ( ii == ( objc - 1 ) )
{
zErr = "option requires an argument: ";
}
else
{
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[ii + 1], out nRepeat ) )
{
return TCL.TCL_ERROR;
}
}
}
else if ( nOption > 1 && zOption == "-benigncnt" )
{
if ( ii == ( objc - 1 ) )
{
zErr = "option requires an argument: ";
}
else
{
pBenignCnt = objv[ii + 1];
}
}
else
{
zErr = "unknown option: ";
}
if ( zErr != "" )
{
TCL.Tcl_AppendResult( interp, zErr, zOption );
return TCL.TCL_ERROR;
}
}
nBenign = faultsimBenignFailures();
nFail = faultsimFailures();
faultsimConfig( iFail, nRepeat );
if ( pBenignCnt != null )
{
TCL.Tcl_ObjSetVar2( interp, pBenignCnt, null, TCL.Tcl_NewIntObj( nBenign ), 0 );
}
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( nFail ) );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_memdebug_pending
**
** Return the number of malloc() calls that will succeed before a
** simulated failure occurs. A negative return value indicates that
** no malloc() failure is scheduled.
*/
// static int test_memdebug_pending(
// object clientData,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// int nPending;
// if( objc!=1 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "");
// return TCL.TCL_ERROR;
// }
// nPending = faultsimPending();
// TCL.Tcl_SetObjResult(interp, TCL.Tcl_NewIntObj(nPending));
// return TCL.TCL_OK;
//}
/*
** Usage: sqlite3_memdebug_settitle TITLE
**
** Set a title string stored with each allocation. The TITLE is
** typically the name of the test that was running when the
** allocation occurred. The TITLE is stored with the allocation
** and can be used to figure out which tests are leaking memory.
**
** Each title overwrite the previous.
*/
static int test_memdebug_settitle(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
string zTitle;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "TITLE" );
return TCL.TCL_ERROR;
}
zTitle = TCL.Tcl_GetString( objv[1] );
#if SQLITE_MEMDEBUG
{
extern int sqlite3MemdebugSettitle(const char);
sqlite3MemdebugSettitle(zTitle);
}
#endif
return TCL.TCL_OK;
}
//#define MALLOC_LOG_FRAMES 10
//static TCL.Tcl_HashTable aMallocLog;
//static int mallocLogEnabled = 0;
//typedef struct MallocLog MallocLog;
//struct MallocLog {
// int nCall;
// int nByte;
//};
//#if SQLITE_MEMDEBUG
//static void test_memdebug_callback(int nByte, int nFrame, object **aFrame){
// if( mallocLogEnabled ){
// MallocLog pLog;
// TCL.Tcl_HashEntry pEntry;
// int isNew;
// int aKey[MALLOC_LOG_FRAMES];
// int nKey = sizeof(int)*MALLOC_LOG_FRAMES;
// memset(aKey, 0, nKey);
// if( (sizeof(void)*nFrame)<nKey ){
// nKey = nFrame*sizeof(void);
// }
// memcpy(aKey, aFrame, nKey);
// pEntry = TCL.Tcl_CreateHashEntry(&aMallocLog, (string )aKey, ref isNew);
// if( isNew ){
// pLog = (MallocLog )Tcl_Alloc(sizeof(MallocLog));
// memset(pLog, 0, sizeof(MallocLog));
// TCL.Tcl_SetHashValue(pEntry, (ClientData)pLog);
// }else{
// pLog = (MallocLog )Tcl_GetHashValue(pEntry);
// }
// pLog->nCall++;
// pLog->nByte += nByte;
// }
//}
//#endif //* SQLITE_MEMDEBUG */
//static void test_memdebug_log_clear(){
// TCL.Tcl_HashSearch search;
// TCL.Tcl_HashEntry pEntry;
// for(
// pEntry=Tcl_FirstHashEntry(&aMallocLog, ref search);
// pEntry;
// pEntry=Tcl_NextHashEntry(&search)
// ){
// MallocLog pLog = (MallocLog )Tcl_GetHashValue(pEntry);
// TCL.Tcl_Free((char )pLog);
// }
// TCL.Tcl_DeleteHashTable(&aMallocLog);
// TCL.Tcl_InitHashTable(&aMallocLog, MALLOC_LOG_FRAMES);
//}
//static int test_memdebug_log(
// object clientData,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// static int isInit = 0;
// int iSub;
// static string MB_strs[] = { "start", "stop", "dump", "clear", "sync" };
// enum MB_enum {
// MB_LOG_START, MB_LOG_STOP, MB_LOG_DUMP, MB_LOG_CLEAR, MB_LOG_SYNC
// };
// if( null==isInit ){
//#if SQLITE_MEMDEBUG
// extern void sqlite3MemdebugBacktraceCallback(
// void (*xBacktrace)(int, int, object *));
// sqlite3MemdebugBacktraceCallback(test_memdebug_callback);
//#endif
// TCL.Tcl_InitHashTable(&aMallocLog, MALLOC_LOG_FRAMES);
// isInit = 1;
// }
// if( objc<2 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ...");
// }
// if( TCL.Tcl_GetIndexFromObj(interp, objv[1], MB_strs, "sub-command", 0, out iSub) ){
// return TCL.TCL_ERROR;
// }
// switch( (enum MB_enum)iSub ){
// case MB_LOG_START:
// mallocLogEnabled = 1;
// break;
// case MB_LOG_STOP:
// mallocLogEnabled = 0;
// break;
// case MB_LOG_DUMP: {
// TCL.Tcl_HashSearch search;
// TCL.Tcl_HashEntry pEntry;
// Tcl_Obj pRet = TCL.Tcl_NewObj();
// Debug.Assert(sizeof(int)==sizeof(void));
// for(
// pEntry=Tcl_FirstHashEntry(&aMallocLog, ref search);
// pEntry;
// pEntry=Tcl_NextHashEntry(&search)
// ){
// Tcl_Obj *apElem[MALLOC_LOG_FRAMES+2];
// MallocLog pLog = (MallocLog )Tcl_GetHashValue(pEntry);
// int *aKey = (int )Tcl_GetHashKey(&aMallocLog, pEntry);
// int ii;
// apElem[0] = TCL.Tcl_NewIntObj(pLog->nCall);
// apElem[1] = TCL.Tcl_NewIntObj(pLog->nByte);
// for(ii=0; ii<MALLOC_LOG_FRAMES; ii++){
// apElem[ii+2] = TCL.Tcl_NewIntObj(aKey[ii]);
// }
// TCL.Tcl_ListObjAppendElement(interp, pRet,
// TCL.Tcl_NewListObj(MALLOC_LOG_FRAMES+2, apElem)
// );
// }
// TCL.Tcl_SetObjResult(interp, pRet);
// break;
// }
// case MB_LOG_CLEAR: {
// test_memdebug_log_clear();
// break;
// }
// case MB_LOG_SYNC: {
//#if SQLITE_MEMDEBUG
// extern void sqlite3MemdebugSync();
// test_memdebug_log_clear();
// mallocLogEnabled = 1;
// sqlite3MemdebugSync();
//#endif
// break;
// }
// }
// return TCL.TCL_OK;
//}
/*
** Usage: sqlite3_config_scratch SIZE N
**
** Set the scratch memory buffer using SQLITE_CONFIG_SCRATCH.
** The buffer is static and is of limited size. N might be
** adjusted downward as needed to accomodate the requested size.
** The revised value of N is returned.
**
** A negative SIZE causes the buffer pointer to be NULL.
*/
static int test_config_scratch(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int sz = 0, N = 0, rc;
Tcl_Obj pResult;
byte[][] buf = null;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "SIZE N" );
return TCL.TCL_ERROR;
}
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[1], out sz ) )
return TCL.TCL_ERROR;
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], out N ) )
return TCL.TCL_ERROR;
//free(buf);
if ( sz < 0 )
{
buf = null;
rc = sqlite3_config( SQLITE_CONFIG_SCRATCH, 0, 0, 0 );
}
else
{
buf = new byte[2][];//// malloc( sz * N + 1 );
rc = sqlite3_config( SQLITE_CONFIG_SCRATCH, buf, sz, N );
}
pResult = TCL.Tcl_NewObj();
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( rc ) );
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( N ) );
TCL.Tcl_SetObjResult( interp, pResult );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_config_pagecache SIZE N
**
** Set the page-cache memory buffer using SQLITE_CONFIG_PAGECACHE.
** The buffer is static and is of limited size. N might be
** adjusted downward as needed to accomodate the requested size.
** The revised value of N is returned.
**
** A negative SIZE causes the buffer pointer to be NULL.
*/
static int test_config_pagecache(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int sz = 0, N = 0, rc;
Tcl_Obj pResult;
MemPage buf; // byte[] buf = null;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "SIZE N" );
return TCL.TCL_ERROR;
}
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[1], out sz ) )
return TCL.TCL_ERROR;
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], out N ) )
return TCL.TCL_ERROR;
//free(buf);
if ( sz < 0 )
{
buf = null;
rc = sqlite3_config( SQLITE_CONFIG_PAGECACHE, 0, 0, 0 );
}
else
{
buf = new MemPage();// new byte[sz * N]; //malloc( sz * N );
rc = sqlite3_config( SQLITE_CONFIG_PAGECACHE, buf, sz, N );
}
pResult = TCL.Tcl_NewObj();
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( rc ) );
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( N ) );
TCL.Tcl_SetObjResult( interp, pResult );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_config_alt_pcache INSTALL_FLAG DISCARD_CHANCE PRNG_SEED
**
** Set up the alternative test page cache. Install if INSTALL_FLAG is
** true and uninstall (reverting to the default page cache) if INSTALL_FLAG
** is false. DISCARD_CHANGE is an integer between 0 and 100 inclusive
** which determines the chance of discarding a page when unpinned. 100
** is certainty. 0 is never. PRNG_SEED is the pseudo-random number generator
** seed.
*/
//static int test_alt_pcache(
// object clientData,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// int installFlag;
// int discardChance = 0;
// int prngSeed = 0;
// int highStress = 0;
// extern void installTestPCache(int,unsigned,unsigned,unsigned);
// if( objc<2 || objc>5 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv,
// "INSTALLFLAG DISCARDCHANCE PRNGSEEED HIGHSTRESS");
// return TCL.TCL_ERROR;
// }
// if( TCL.Tcl_GetIntFromObj(interp, objv[1], &installFlag) ) return TCL.TCL_ERROR;
// if( objc>=3 && TCL.Tcl_GetIntFromObj(interp, objv[2], &discardChance) ){
// return TCL.TCL_ERROR;
// }
// if( objc>=4 && TCL.Tcl_GetIntFromObj(interp, objv[3], &prngSeed) ){
// return TCL.TCL_ERROR;
// }
// if( objc>=5 && TCL.Tcl_GetIntFromObj(interp, objv[4], &highStress) ){
// return TCL.TCL_ERROR;
// }
// if( discardChance<0 || discardChance>100 ){
// TCL.Tcl_AppendResult(interp, "discard-chance should be between 0 and 100",
// (char)0);
// return TCL.TCL_ERROR;
// }
// installTestPCache(installFlag, (unsigned)discardChance, (unsigned)prngSeed,
// (unsigned)highStress);
// return TCL.TCL_OK;
//}
/*
** Usage: sqlite3_config_memstatus BOOLEAN
**
** Enable or disable memory status reporting using SQLITE_CONFIG_MEMSTATUS.
*/
static int test_config_memstatus(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
bool enable = false;
int rc;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "BOOLEAN" );
return TCL.TCL_ERROR;
}
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[1], out enable ) )
return TCL.TCL_ERROR;
rc = sqlite3_config( SQLITE_CONFIG_MEMSTATUS, enable );
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( rc ) );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_config_lookaside SIZE COUNT
**
*/
static int test_config_lookaside(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int rc;
int sz = 0, cnt = 0;
Tcl_Obj pRet;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "SIZE COUNT" );
return TCL.TCL_ERROR;
}
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[1], out sz ) )
return TCL.TCL_ERROR;
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], out cnt ) )
return TCL.TCL_ERROR;
pRet = TCL.Tcl_NewObj();
TCL.Tcl_ListObjAppendElement(
interp, pRet, TCL.Tcl_NewIntObj( sqlite3GlobalConfig.szLookaside )
);
TCL.Tcl_ListObjAppendElement(
interp, pRet, TCL.Tcl_NewIntObj( sqlite3GlobalConfig.nLookaside )
);
rc = sqlite3_config( SQLITE_CONFIG_LOOKASIDE, sz, cnt );
TCL.Tcl_SetObjResult( interp, pRet );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_db_config_lookaside CONNECTION BUFID SIZE COUNT
**
** There are two static buffers with BUFID 1 and 2. Each static buffer
** is 10KB in size. A BUFID of 0 indicates that the buffer should be NULL
** which will cause sqlite3_db_config() to allocate space on its own.
*/
static int test_db_config_lookaside(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int rc;
int sz = 0, cnt = 0;
sqlite3 db = new sqlite3();
int bufid = 0;
byte[][] azBuf = new byte[2][];
//int getDbPointer(Tcl_Interp*, const char*, sqlite3*);
if ( objc != 5 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "BUFID SIZE COUNT" );
return TCL.TCL_ERROR;
}
if ( getDbPointer( interp, TCL.Tcl_GetString( objv[1] ), out db ) != 0 )
return TCL.TCL_ERROR;
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], out bufid ) )
return TCL.TCL_ERROR;
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[3], out sz ) )
return TCL.TCL_ERROR;
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[4], out cnt ) )
return TCL.TCL_ERROR;
if ( bufid == 0 )
{
rc = sqlite3_db_config( db, SQLITE_DBCONFIG_LOOKASIDE, null, sz, cnt );
}
else if ( bufid >= 1 && bufid <= 2 && sz * cnt <= azBuf[0].Length )
{
rc = sqlite3_db_config( db, SQLITE_DBCONFIG_LOOKASIDE, azBuf[bufid], sz, cnt );
}
else
{
TCL.Tcl_AppendResult( interp, "illegal arguments - see documentation" );
return TCL.TCL_ERROR;
}
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( rc ) );
return TCL.TCL_OK;
}
/*
** Usage:
**
** sqlite3_config_heap NBYTE NMINALLOC
*/
//static int test_config_heap(
// object clientData,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// static string zBuf; /* Use this memory */
// static int szBuf; /* Bytes allocated for zBuf */
// int nByte; /* Size of buffer to pass to sqlite3_config() */
// int nMinAlloc; /* Size of minimum allocation */
// int rc; /* Return code of sqlite3_config() */
// Tcl_Obj * CONST *aArg = objv[1];
// int nArg = objc-1;
// if( nArg!=2 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "NBYTE NMINALLOC");
// return TCL.TCL_ERROR;
// }
// if( TCL.Tcl_GetIntFromObj(interp, aArg[0], out nByte) ) return TCL.TCL_ERROR;
// if( TCL.Tcl_GetIntFromObj(interp, aArg[1], out nMinAlloc) ) return TCL.TCL_ERROR;
// if( nByte==0 ){
// free( zBuf );
// zBuf = 0;
// szBuf = 0;
// rc = sqlite3_config(SQLITE_CONFIG_HEAP, (void)0, 0, 0);
// }else{
// zBuf = realloc(zBuf, nByte);
// szBuf = nByte;
// rc = sqlite3_config(SQLITE_CONFIG_HEAP, zBuf, nByte, nMinAlloc);
// }
// TCL.Tcl_SetResult(interp, (char )sqlite3TestErrorName(rc), TCL.Tcl_VOLATILE);
// return TCL.TCL_OK;
//}
/*
** tclcmd: sqlite3_config_error [DB]
**
** Invoke sqlite3_config() or sqlite3_db_config() with invalid
** opcodes and verify that they return errors.
*/
//static int test_config_error(
// object clientData,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// sqlite3 db;
// int getDbPointer(Tcl_Interp*, const char*, sqlite3*);
// if( objc!=2 && objc!=1 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "[DB]");
// return TCL.TCL_ERROR;
// }
// if( objc==2 ){
// if( getDbPointer(interp, TCL.Tcl_GetString(objv[1]), out db) ) return TCL.TCL_ERROR;
// if( sqlite3_db_config(db, 99999)!=SQLITE_ERROR ){
// TCL.Tcl_AppendResult(interp,
// "sqlite3_db_config(db, 99999) does not return SQLITE_ERROR",
// (char)0);
// return TCL.TCL_ERROR;
// }
// }else{
// if( sqlite3_config(99999)!=SQLITE_ERROR ){
// TCL.Tcl_AppendResult(interp,
// "sqlite3_config(99999) does not return SQLITE_ERROR",
// (char)0);
// return TCL.TCL_ERROR;
// }
// }
// return TCL.TCL_OK;
//}
/*
** Usage:
**
** sqlite3_dump_memsys3 FILENAME
** sqlite3_dump_memsys5 FILENAME
**
** Write a summary of unfreed memsys3 allocations to FILENAME.
*/
//static int test_dump_memsys3(
// object clientData,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// if( objc!=2 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
// return TCL.TCL_ERROR;
// }
// switch( (int)clientData ){
// case 3: {
//#if SQLITE_ENABLE_MEMSYS3
// extern void sqlite3Memsys3Dump(const char);
// sqlite3Memsys3Dump(Tcl_GetString(objv[1]));
// break;
//#endif
// }
// case 5: {
//#if SQLITE_ENABLE_MEMSYS5
// extern void sqlite3Memsys5Dump(const char);
// sqlite3Memsys5Dump(Tcl_GetString(objv[1]));
// break;
//#endif
// }
// }
// return TCL.TCL_OK;
//}
/*
** Usage: sqlite3_status OPCODE RESETFLAG
**
** Return a list of three elements which are the sqlite3_status() return
** code, the current value, and the high-water mark value.
*/
class _aOp
{
public string zName;
public int op;
public _aOp( string zName, int op )
{
this.zName = zName;
this.op = op;
}
}
static int test_status(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int rc, iValue, mxValue;
int i, op = 0;
bool resetFlag = false;
string zOpName;
_aOp[] aOp = new _aOp[] {
new _aOp( "SQLITE_STATUS_MEMORY_USED", SQLITE_STATUS_MEMORY_USED ),
new _aOp( "SQLITE_STATUS_MALLOC_SIZE", SQLITE_STATUS_MALLOC_SIZE ),
new _aOp( "SQLITE_STATUS_PAGECACHE_USED", SQLITE_STATUS_PAGECACHE_USED ),
new _aOp( "SQLITE_STATUS_PAGECACHE_OVERFLOW", SQLITE_STATUS_PAGECACHE_OVERFLOW ),
new _aOp( "SQLITE_STATUS_PAGECACHE_SIZE", SQLITE_STATUS_PAGECACHE_SIZE ),
new _aOp( "SQLITE_STATUS_SCRATCH_USED", SQLITE_STATUS_SCRATCH_USED ),
new _aOp( "SQLITE_STATUS_SCRATCH_OVERFLOW", SQLITE_STATUS_SCRATCH_OVERFLOW ),
new _aOp( "SQLITE_STATUS_SCRATCH_SIZE", SQLITE_STATUS_SCRATCH_SIZE ),
new _aOp( "SQLITE_STATUS_PARSER_STACK", SQLITE_STATUS_PARSER_STACK ),
new _aOp("SQLITE_STATUS_MALLOC_COUNT", SQLITE_STATUS_MALLOC_COUNT ),
};
Tcl_Obj pResult;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "PARAMETER RESETFLAG" );
return TCL.TCL_ERROR;
}
zOpName = TCL.Tcl_GetString( objv[1] );
for ( i = 0; i < ArraySize( aOp ); i++ )
{
if ( aOp[i].zName == zOpName )
{//strcmp(aOp[i].zName, zOpName)==0 ){
op = aOp[i].op;
break;
}
}
if ( i >= ArraySize( aOp ) )
{
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[1], out op ) )
return TCL.TCL_ERROR;
}
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[2], out resetFlag ) )
return TCL.TCL_ERROR;
iValue = 0;
mxValue = 0;
rc = sqlite3_status( op, ref iValue, ref mxValue, resetFlag ? 1 : 0 );
pResult = TCL.Tcl_NewObj();
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( rc ) );
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( iValue ) );
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( mxValue ) );
TCL.Tcl_SetObjResult( interp, pResult );
return TCL.TCL_OK;
}
/*
** Usage: sqlite3_db_status DATABASE OPCODE RESETFLAG
**
** Return a list of three elements which are the sqlite3_db_status() return
** code, the current value, and the high-water mark value.
*/
static int test_db_status(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int rc, iValue, mxValue;
int i, op = 0;
bool resetFlag = false;
string zOpName;
sqlite3 db = null;
//int getDbPointer (Tcl_Interp*, const char*, sqlite3*);
//static const struct {
//string zName;
//int op;
//}
_aOp[] aOp = {
new _aOp( "LOOKASIDE_USED", SQLITE_DBSTATUS_LOOKASIDE_USED ),
new _aOp( "CACHE_USED", SQLITE_DBSTATUS_CACHE_USED ),
new _aOp( "SCHEMA_USED", SQLITE_DBSTATUS_SCHEMA_USED ),
new _aOp( "STMT_USED", SQLITE_DBSTATUS_STMT_USED ),
new _aOp( "LOOKASIDE_HIT", SQLITE_DBSTATUS_LOOKASIDE_HIT ),
new _aOp( "LOOKASIDE_MISS_SIZE", SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE ),
new _aOp( "LOOKASIDE_MISS_FULL", SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL )
};
Tcl_Obj pResult;
if ( objc != 4 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "PARAMETER RESETFLAG" );
return TCL.TCL_ERROR;
}
if ( getDbPointer( interp, TCL.Tcl_GetString( objv[1] ), out db ) != 0 )
return TCL.TCL_ERROR;
zOpName = TCL.Tcl_GetString( objv[2] );
if ( zOpName.StartsWith( "SQLITE_" ) )
zOpName = zOpName.Remove( 0, 7 ); //zOpName += 7;
if ( zOpName.StartsWith( "DBSTATUS_" ) )
zOpName = zOpName.Remove( 0, 9 ); //zOpName += 9;
for ( i = 0; i < ArraySize( aOp ); i++ )
{
if ( aOp[i].zName == zOpName )
{
op = aOp[i].op;
break;
}
}
if ( i >= ArraySize( aOp ) )
{
if ( TCL.Tcl_GetIntFromObj( interp, objv[2], out op ) != 0 )
return TCL.TCL_ERROR;
}
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[3], out resetFlag ) )
return TCL.TCL_ERROR;
iValue = 0;
mxValue = 0;
rc = sqlite3_db_status( db, op, ref iValue, ref mxValue, resetFlag ? 1 : 0 );
pResult = TCL.Tcl_NewObj();
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( rc ) );
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( iValue ) );
TCL.Tcl_ListObjAppendElement( null, pResult, TCL.Tcl_NewIntObj( mxValue ) );
TCL.Tcl_SetObjResult( interp, pResult );
return TCL.TCL_OK;
}
/*
** install_malloc_faultsim BOOLEAN
*/
static int test_install_malloc_faultsim(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int rc;
int isInstall;
bool bisInstall = false;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "BOOLEAN" );
return TCL.TCL_ERROR;
}
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[1], out bisInstall ) )
{
return TCL.TCL_ERROR;
}
isInstall = bisInstall ? 1 : 0;
rc = faultsimInstall( isInstall );
TCL.Tcl_SetResult( interp, sqlite3TestErrorName( rc ), TCL.TCL_VOLATILE );
return TCL.TCL_OK;
}
static int test_vfs_oom_test(
object clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
//extern int sqlite3_memdebug_vfs_oom_test;
if ( objc > 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "?INTEGER?" );
return TCL.TCL_ERROR;
}
else if ( objc == 2 )
{
int iNew = 0;
if ( TCL.Tcl_GetIntFromObj( interp, objv[1], out iNew ) != 0 )
return TCL.TCL_ERROR;
sqlite3_memdebug_vfs_oom_test = iNew;
}
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( sqlite3_memdebug_vfs_oom_test ) );
return TCL.TCL_OK;
}
/*
** Register commands with the TCL interpreter.
*/
static public int Sqlitetest_malloc_Init( Tcl_Interp interp )
{
//static struct {
// string zName;
// Tcl_ObjCmdProc *xProc;
// int clientData;
//} aObjCmd[] = {
_aObjCmd[] aObjCmd = new _aObjCmd[] {
//{ "sqlite3_malloc", test_malloc ,0 },
//{ "sqlite3_realloc", test_realloc ,0 },
//{ "sqlite3_free", test_free ,0 },
//{ "memset", test_memset ,0 },
//{ "memget", test_memget ,0 },
//{ "sqlite3_memory_used", test_memory_used ,0 },
#if FALSE
new _aObjCmd( "sqlite3_memory_used", test_memory_used ,0 ),
new _aObjCmd( "sqlite3_memory_highwater", test_memory_highwater ,0),
#endif
//{ "sqlite3_memory_highwater", test_memory_highwater ,0 },
//{ "sqlite3_memdebug_backtrace", test_memdebug_backtrace ,0 },
new _aObjCmd( "sqlite3_memdebug_dump", test_memdebug_dump ,0 ),
new _aObjCmd( "sqlite3_memdebug_fail", test_memdebug_fail ,0 ),
//{ "sqlite3_memdebug_pending", test_memdebug_pending ,0 },
new _aObjCmd( "sqlite3_memdebug_settitle", test_memdebug_settitle ,0 ),
new _aObjCmd( "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count ,0),
//{ "sqlite3_memdebug_log", test_memdebug_log ,0 },
new _aObjCmd( "sqlite3_config_scratch", test_config_scratch ,0 ),
new _aObjCmd("sqlite3_config_pagecache", test_config_pagecache ,0 ),
//{ "sqlite3_config_alt_pcache", test_alt_pcache ,0 },
new _aObjCmd( "sqlite3_status", test_status,0 ),
new _aObjCmd( "sqlite3_db_status", test_db_status, 0 ),
new _aObjCmd( "install_malloc_faultsim", test_install_malloc_faultsim ,0),
//{ "sqlite3_config_heap", test_config_heap ,0 },
new _aObjCmd( "sqlite3_config_memstatus", test_config_memstatus ,0 ),
new _aObjCmd( "sqlite3_config_lookaside", test_config_lookaside ,0 ),
//{ "sqlite3_config_error", test_config_error ,0 },
new _aObjCmd( "sqlite3_config_uri",test_config_uri ,0 ),
new _aObjCmd( "sqlite3_db_config_lookaside",test_db_config_lookaside ,0 ),
//{ "sqlite3_dump_memsys3", test_dump_memsys3 ,3 },
//{ "sqlite3_dump_memsys5", test_dump_memsys3 ,5 },
//{ "sqlite3_install_memsys3", test_install_memsys3 ,0 },
//{ "sqlite3_memdebug_vfs_oom_test", test_vfs_oom_test ,0 },
};
int i;
for ( i = 0; i < aObjCmd.Length; i++ )
{//<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
object c = (object)aObjCmd[i].clientData;
TCL.Tcl_CreateObjCommand( interp, aObjCmd[i].zName, aObjCmd[i].xProc, c, null );
}
return TCL.TCL_OK;
}
#endif
}
#endif
}