public static int Tcl_VarEval(Interp interp, string Scriptname, params string[] argv)
{
try
{
//Tcl_Obj[] aArg = null;
int rc = 0;
Tcl_Obj pCmd = Tcl_NewStringObj(Scriptname, -1);
Tcl_IncrRefCount(pCmd);
for (int i = 0; i < argv.Length; i++)
{
if (argv[i] != null && argv[i] != " ")
{
rc = Tcl_ListObjAppendElement(interp, pCmd, Tcl_NewStringObj(argv[i], -1)) ? 1 : 0;
}
if (rc != 0)
{
Tcl_DecrRefCount(ref pCmd);
return(1);
}
}
rc = Tcl_EvalObjEx(interp, pCmd, TCL_EVAL_DIRECT);
Tcl_DecrRefCount(ref pCmd);
return(rc == TCL_BREAK ? 1 : 0);
}
catch { return(1); }
}
/*
** Returns 1 if data is ready, or 0 if not.
*/
static int next2(Tcl_Interp interp, tclvar_cursor pCur, Tcl_Obj pObj)
{
Tcl_Obj p;
if (pObj != null)
{
if (null == pCur.pList2)
{
p = TCL.Tcl_NewStringObj("array names", -1);
TCL.Tcl_IncrRefCount(p);
TCL.Tcl_ListObjAppendElement(null, p, pObj);
TCL.Tcl_EvalObjEx(interp, p, TCL.TCL_EVAL_GLOBAL);
TCL.Tcl_DecrRefCount(ref p);
pCur.pList2 = TCL.Tcl_GetObjResult(interp);
TCL.Tcl_IncrRefCount(pCur.pList2);
Debug.Assert(pCur.i2 == 0);
}
else
{
int n = 0;
pCur.i2++;
TCL.Tcl_ListObjLength(null, pCur.pList2, out n);
if (pCur.i2 >= n)
{
TCL.Tcl_DecrRefCount(ref pCur.pList2);
pCur.pList2 = null;
pCur.i2 = 0;
return(0);
}
}
}
return(1);
}
/*
** 2007 March 29
**
** 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 obscure tests of the C-interface required
** for completeness. Test code is written in C for these cases
** as there is not much point in binding to Tcl.
*************************************************************************
** 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: 2010-08-23 18:52:01 42537b60566f288167f1b5864a5435986838e3a3
**
*************************************************************************
*/
//#include "sqliteInt.h"
//#include "tcl.h"
//#include <stdlib.h>
//#include <string.h>
/*
** c_collation_test
*/
static int c_collation_test(
object clientdata, /* Pointer to sqlite3_enable_XXX function */
Tcl_Interp interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj[] objv /* Command arguments */
)
{
string zErrFunction = "N/A";
sqlite3 db = null;
int rc;
if ( objc != 1 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "" );
return TCL.TCL_ERROR;
}
/* Open a database. */
rc = sqlite3_open( ":memory:", out db );
if ( rc != SQLITE_OK )
{
zErrFunction = "sqlite3_open";
goto error_out;
}
rc = sqlite3_create_collation( db, "collate", 456, null, null );
if ( rc != SQLITE_MISUSE )
{
sqlite3_close( db );
zErrFunction = "sqlite3_create_collation";
goto error_out;
}
sqlite3_close( db );
return TCL.TCL_OK;
error_out:
TCL.Tcl_ResetResult( interp );
TCL.Tcl_AppendResult( interp, "Error testing function: ", zErrFunction, null );
return TCL.TCL_ERROR;
}
static int tclvarNext(sqlite3_vtab_cursor cur)
{
Tcl_Obj pObj = null;
int n = 0;
int ok = 0;
tclvar_cursor pCur = (tclvar_cursor )cur;
Tcl_Interp interp = ((tclvar_vtab )(cur.pVtab)).interp;
TCL.Tcl_ListObjLength(null, pCur.pList1, out n);
while (0 == ok && pCur.i1 < n)
{
TCL.Tcl_ListObjIndex(null, pCur.pList1, pCur.i1, out pObj);
ok = next2(interp, pCur, pObj);
if (0 == ok)
{
pCur.i1++;
}
}
return(0);
}
static int tclvarFilter(
sqlite3_vtab_cursor pVtabCursor,
int idxNum, string idxStr,
int argc, sqlite3_value[] argv
)
{
tclvar_cursor pCur = (tclvar_cursor )pVtabCursor;
Tcl_Interp interp = ((tclvar_vtab )(pVtabCursor.pVtab)).interp;
Tcl_Obj p = TCL.Tcl_NewStringObj("info vars", -1);
TCL.Tcl_IncrRefCount(p);
Debug.Assert(argc == 0 || argc == 1);
if (argc == 1)
{
Tcl_Obj pArg = TCL.Tcl_NewStringObj((string)sqlite3_value_text(argv[0]), -1);
TCL.Tcl_ListObjAppendElement(null, p, pArg);
}
TCL.Tcl_EvalObjEx(interp, p, TCL.TCL_EVAL_GLOBAL);
if (pCur.pList1 != null)
{
TCL.Tcl_DecrRefCount(ref pCur.pList1);
}
if (pCur.pList2 != null)
{
TCL.Tcl_DecrRefCount(ref pCur.pList2);
pCur.pList2 = null;
}
pCur.i1 = 0;
pCur.i2 = 0;
pCur.pList1 = TCL.Tcl_GetObjResult(interp);
TCL.Tcl_IncrRefCount(pCur.pList1);
Debug.Assert(pCur.i1 == 0 && pCur.i2 == 0 && pCur.pList2 == null);
TCL.Tcl_DecrRefCount(ref p);
return(tclvarNext(pVtabCursor));
}
static int tclvarColumn(sqlite3_vtab_cursor cur, sqlite3_context ctx, int i)
{
Tcl_Obj p1 = null;
Tcl_Obj p2 = null;
string z1;
string z2 = "";
tclvar_cursor pCur = (tclvar_cursor)cur;
Tcl_Interp interp = ((tclvar_vtab )cur.pVtab).interp;
TCL.Tcl_ListObjIndex(interp, pCur.pList1, pCur.i1, out p1);
TCL.Tcl_ListObjIndex(interp, pCur.pList2, pCur.i2, out p2);
z1 = TCL.Tcl_GetString(p1);
if (p2 != null)
{
z2 = TCL.Tcl_GetString(p2);
}
switch (i)
{
case 0: {
sqlite3_result_text(ctx, z1, -1, SQLITE_TRANSIENT);
break;
}
case 1: {
sqlite3_result_text(ctx, z2, -1, SQLITE_TRANSIENT);
break;
}
case 2: {
Tcl_Obj pVal = TCL.Tcl_GetVar2Ex(interp, z1, z2 == "" ? null : z2, (TCL.VarFlag)TCL.TCL_GLOBAL_ONLY);
sqlite3_result_text(ctx, TCL.Tcl_GetString(pVal), -1, SQLITE_TRANSIENT);
break;
}
}
return(SQLITE_OK);
}
/*
** Register the echo virtual table module.
*/
static int register_echo_module(
ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
Tcl_Interp interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj[] objv /* Command arguments */
)
{
sqlite3 db = null;
;
;
EchoModule pMod;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "DB" );
return TCL.TCL_ERROR;
}
if ( getDbPointer( interp, TCL.Tcl_GetString( objv[1] ), out db ) != 0 )
return TCL.TCL_ERROR;
pMod = new EchoModule();//sqlite3_malloc(sizeof(EchoModule));
pMod.interp = interp;
sqlite3_create_module_v2( db, "echo", echoModule, pMod, moduleDestroy );
return TCL.TCL_OK;
}
/*
** sqlite3_backup CMDNAME DESTHANDLE DESTNAME SRCHANDLE SRCNAME
**
*/
static int backupTestInit(
ClientData clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
sqlite3_backup pBackup;
sqlite3 pDestDb = null;
sqlite3 pSrcDb = null;
string zDestName;
string zSrcName;
string zCmd;
if ( objc != 6 )
{
TCL.Tcl_WrongNumArgs(
interp, 1, objv, "CMDNAME DESTHANDLE DESTNAME SRCHANDLE SRCNAME"
);
return TCL.TCL_ERROR;
}
zCmd = TCL.Tcl_GetString( objv[1] );
getDbPointer( interp, TCL.Tcl_GetString( objv[2] ), ref pDestDb );
zDestName = TCL.Tcl_GetString( objv[3] );
getDbPointer( interp, TCL.Tcl_GetString( objv[4] ), ref pSrcDb );
zSrcName = TCL.Tcl_GetString( objv[5] );
pBackup = sqlite3_backup_init( pDestDb, zDestName, pSrcDb, zSrcName );
if ( null == pBackup )
{
TCL.Tcl_AppendResult( interp, "sqlite3_backup_init() failed" );
return TCL.TCL_ERROR;
}
TCL.Tcl_CreateObjCommand( interp, zCmd, (Interp.dxObjCmdProc)backupTestCmd, pBackup, (Interp.dxCmdDeleteProc)backupTestFinish );
TCL.Tcl_SetObjResult( interp, objv[1] );
return TCL.TCL_OK;
}
/*
** sqlite3_intarray_bind INTARRAY ?VALUE ...?
**
** Invoke the sqlite3_intarray_bind interface on the given array of integers.
*/
static int test_intarray_bind(
ClientData clientData, /* Not used */
Tcl_Interp interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj[] objv /* Command arguments */
)
{
sqlite3_intarray pArray;
int rc = SQLITE_OK;
int i, n;
sqlite3_int64[] a;
if ( objc < 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "INTARRAY" );
return TCL.TCL_ERROR;
}
pArray = (sqlite3_intarray)sqlite3TestTextToPtr( interp, TCL.Tcl_GetString( objv[1] ) );
n = objc - 2;
#if !SQLITE_OMIT_VIRTUALTABLE
a = new sqlite3_int64[n];//sqlite3_malloc( sizeof(a[0])*n );
//if( a==0 ){
// Tcl_AppendResult(interp, "SQLITE_NOMEM", (char*)0);
// return TCL_ERROR;
//}
for ( i = 0; i < n; i++ )
{
//a[i] = 0;
TCL.Tcl_GetWideIntFromObj( null, objv[i + 2], out a[i] );
}
rc = sqlite3_intarray_bind( pArray, n, a, sqlite3_free );
if ( rc != SQLITE_OK )
{
TCL.Tcl_AppendResult( interp, sqlite3TestErrorName( rc ), null );
return TCL.TCL_ERROR;
}
#endif
return TCL.TCL_OK;
}
/*
** A TCL command to take the md5 hash of a file. The argument is the
** name of the file.
*/
static int md5file_cmd( object cd, Tcl_Interp interp, int argc, Tcl_Obj[] argv )
{
StreamReader _in = null;
byte[] digest = new byte[16];
StringBuilder zBuf = new StringBuilder( 10240 );
if ( argc != 2 )
{
TCL.Tcl_AppendResult( interp, "wrong # args: should be \"", argv[0],
" FILENAME\"", 0 );
return TCL.TCL_ERROR;
}
Debugger.Break(); // TODO -- _in = fopen( argv[1], "rb" );
if ( _in == null )
{
TCL.Tcl_AppendResult( interp, "unable to open file \"", argv[1],
"\" for reading", 0 );
return TCL.TCL_ERROR;
}
Debugger.Break(); // TODO
//MD5Init( ctx );
//for(;;){
// int n;
// n = fread(zBuf, 1, zBuf.Capacity, _in);
// if( n<=0 ) break;
// MD5Update(ctx, zBuf.ToString(), (unsigned)n);
//}
//fclose(_in);
//MD5Final(digest, ctx);
// DigestToBase16(digest, zBuf);
//Tcl_AppendResult( interp, zBuf );
return TCL.TCL_OK;
}
static void tvfsExecTcl(
Testvfs p,
string zMethod,
Tcl_Obj arg1,
Tcl_Obj arg2,
Tcl_Obj arg3
){
int rc; /* Return code from Tcl_EvalObj() */
Tcl_Obj pEval;
Debug.Assert( p.pScript!=null );
Debug.Assert( zMethod != null );
Debug.Assert( p != null );
Debug.Assert( arg2 == null || arg1 != null );
Debug.Assert( arg3 == null || arg2 != null );
pEval = TCL.Tcl_DuplicateObj(p.pScript);
TCL.Tcl_IncrRefCount(p.pScript);
TCL.Tcl_ListObjAppendElement( p.interp, pEval, TCL.Tcl_NewStringObj( zMethod, -1 ) );
if ( arg1!=null )
TCL.Tcl_ListObjAppendElement( p.interp, pEval, arg1 );
if ( arg2 !=null )
TCL.Tcl_ListObjAppendElement( p.interp, pEval, arg2 );
if ( arg3 != null )
TCL.Tcl_ListObjAppendElement( p.interp, pEval, arg3 );
rc = TCL.Tcl_EvalObjEx(p.interp, pEval, TCL.TCL_EVAL_GLOBAL);
if ( rc != TCL.TCL_OK )
{
TCL.Tcl_BackgroundError( p.interp );
TCL.Tcl_ResetResult( p.interp );
}
}
public Tcl_Obj[] apColName; /* Array of column names */
public void Clear()
{
pDb = null;
pSql = null;
zSql = null;
pPreStmt = null;
pArray = null;
apColName = null;
}
/*
** Usage: hexio_write FILENAME OFFSET DATA
**
** Write DATA into file FILENAME beginning at OFFSET from the
** beginning of the file. DATA is expressed _in hexadecimal.
*/
static int hexio_write(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int offset = 0;
int nIn = 0, nOut, written;
string zFile;
string zIn;
byte[] aOut;
FileStream _out;
if ( objc != 4 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "FILENAME OFFSET HEXDATA" );
return TCL.TCL_ERROR;
}
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], out offset ) )
return TCL.TCL_ERROR;
zFile = TCL.Tcl_GetString( objv[1] );
zIn = TCL.Tcl_GetStringFromObj( objv[3], out nIn );
aOut = new byte[nIn / 2 + 1];//sqlite3Malloc( nIn/2 );
if ( aOut == null )
{
return TCL.TCL_ERROR;
}
nOut = sqlite3TestHexToBin( zIn, nIn, aOut );
_out = new FileStream( zFile, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite );// fopen( zFile, "r+b" );
//if( _out==0 ){
// _out = fopen(zFile, "r+");
//}
if ( _out == null )
{
TCL.Tcl_AppendResult( interp, "cannot open output file ", zFile );
return TCL.TCL_ERROR;
}
_out.Seek( offset, SeekOrigin.Begin );// fseek( _out, offset, SEEK_SET );
written = (int)_out.Position;
_out.Write( aOut, 0, nOut );// written = fwrite( aOut, 1, nOut, _out );
written = (int)_out.Position - written;
aOut = null;// sqlite3DbFree( db, ref aOut );
_out.Flush();
_out.Close();// fclose( _out );
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( written ) );
return TCL.TCL_OK;
}
/*
** Usage: hexio_read FILENAME OFFSET AMT
**
** Read AMT bytes from file FILENAME beginning at OFFSET from the
** beginning of the file. Convert that information to hexadecimal
** and return the resulting HEX string.
*/
static int hexio_read(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int offset = 0;
int amt = 0, got;
string zFile;
byte[] zBuf;
FileStream _in;
if ( objc != 4 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "FILENAME OFFSET AMT" );
return TCL.TCL_ERROR;
}
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], out offset ) )
return TCL.TCL_ERROR;
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[3], out amt ) )
return TCL.TCL_ERROR;
zFile = TCL.Tcl_GetString( objv[1] );
zBuf = new byte[amt * 2 + 1];// sqlite3Malloc( amt * 2 + 1 );
if ( zBuf == null )
{
return TCL.TCL_ERROR;
}
_in = new FileStream( zFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite );
//if( _in==null){
// _in = fopen(zFile, "r");
//}
if ( _in == null )
{
TCL.Tcl_AppendResult( interp, "cannot open input file ", zFile );
return TCL.TCL_ERROR;
}
_in.Seek( offset, SeekOrigin.Begin ); //fseek(_in, offset, SEEK_SET);
got = _in.Read( zBuf, 0, amt ); // got = fread( zBuf, 1, amt, _in );
_in.Flush();
_in.Close();// fclose( _in );
if ( got < 0 )
{
got = 0;
}
sqlite3TestBinToHex( zBuf, got );
TCL.Tcl_AppendResult( interp, System.Text.Encoding.UTF8.GetString( zBuf, 0, zBuf.Length ).Substring( 0, got * 2 ) );
zBuf = null;// sqlite3DbFree( db, ref zBuf );
return TCL.TCL_OK;
}
/*
** Decode a pointer to an sqlite3 object.
*/
//extern int getDbPointer(Tcl_Interp *interp, string zA, sqlite3 **ppDb);
/*
** Register the echo virtual table module.
*/
static int register_tclvar_module(
ClientData clientData,/* Pointer to sqlite3_enable_XXX function */
Tcl_Interp interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj[] objv /* Command arguments */
){
sqlite3 db=null;
if( objc!=2 ){
TCL.Tcl_WrongNumArgs(interp, 1, objv, "DB");
return TCL.TCL_ERROR;
}
if( getDbPointer(interp, TCL.Tcl_GetString(objv[1]), out db) !=0) return TCL.TCL_ERROR;
#if !SQLITE_OMIT_VIRTUALTABLE
sqlite3_create_module(db, "tclvar", tclvarModule, interp);
#endif
return TCL.TCL_OK;
}
/*
** Returns 1 if data is ready, or 0 if not.
*/
static int next2(Tcl_Interp interp, tclvar_cursor pCur, Tcl_Obj pObj){
Tcl_Obj p;
if( pObj != null){
if( null==pCur.pList2 ){
p = TCL.Tcl_NewStringObj("array names", -1);
TCL.Tcl_IncrRefCount(p);
TCL.Tcl_ListObjAppendElement(null, p, pObj);
TCL.Tcl_EvalObjEx(interp, p, TCL.TCL_EVAL_GLOBAL);
TCL.Tcl_DecrRefCount(ref p);
pCur.pList2 = TCL.Tcl_GetObjResult(interp);
TCL.Tcl_IncrRefCount(pCur.pList2);
Debug.Assert( pCur.i2 == 0 );
}
else
{
int n = 0;
pCur.i2++;
TCL.Tcl_ListObjLength(null, pCur.pList2, out n);
if( pCur.i2>=n ){
TCL.Tcl_DecrRefCount(ref pCur.pList2);
pCur.pList2 = null;
pCur.i2 = 0;
return 0;
}
}
}
return 1;
}
// static void sqlite3_reset_auto_extension() { }
#endif //* SQLITE_OMIT_LOAD_EXTENSION */
/*
** tclcmd: sqlite3_reset_auto_extension
**
** Reset all auto-extensions
*/
static int resetAutoExtObjCmd(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
sqlite3_reset_auto_extension();
return SQLITE_OK;
}
/*
** USAGE: hexio_get_int HEXDATA
**
** Interpret the HEXDATA argument as a big-endian integer. Return
** the value of that integer. HEXDATA can contain between 2 and 8
** hexadecimal digits.
*/
static int hexio_get_int(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int val;
int nIn = 0, nOut;
string zIn;
byte[] aOut;
byte[] aNum = new byte[4];
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "HEXDATA" );
return TCL.TCL_ERROR;
}
zIn = TCL.Tcl_GetStringFromObj( objv[1], out nIn );
aOut = new byte[nIn / 2];// sqlite3Malloc( nIn / 2 );
if ( aOut == null )
{
return TCL.TCL_ERROR;
}
nOut = sqlite3TestHexToBin( zIn, nIn, aOut );
if ( nOut >= 4 )
{
aNum[0] = aOut[0]; // memcpy( aNum, aOut, 4 );
aNum[1] = aOut[1];
aNum[2] = aOut[2];
aNum[3] = aOut[3];
}
else
{
//memset(aNum, 0, sizeof(aNum));
//memcpy(&aNum[4-nOut], aOut, nOut);
aNum[4 - nOut] = aOut[0];
if ( nOut > 1 )
aNum[4 - nOut + 1] = aOut[1];
if ( nOut > 2 )
aNum[4 - nOut + 2] = aOut[2];
if ( nOut > 3 )
aNum[4 - nOut + 3] = aOut[3];
}
aOut = null;// sqlite3DbFree( db, ref aOut );
val = ( aNum[0] << 24 ) | ( aNum[1] << 16 ) | ( aNum[2] << 8 ) | aNum[3];
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( val ) );
return TCL.TCL_OK;
}
static int testvfs_obj_cmd(
ClientData cd,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
){
Debugger.Break();//TODO
// Testvfs p = (Testvfs)cd;
// TestvfsSubcmd[] aSubcmd = new TestvfsSubcmd[] {
// new TestvfsSubcmd( "shm", DB_enum_CMD.CMD_SHM ),
// new TestvfsSubcmd( "delete", DB_enum_CMD.CMD_DELETE ),
// new TestvfsSubcmd( "filter", DB_enum_CMD.CMD_FILTER ),
// new TestvfsSubcmd( "ioerr", DB_enum_CMD.CMD_IOERR ),
// new TestvfsSubcmd( "fullerr", DB_enum_CMD.CMD_FULLERR ),
// new TestvfsSubcmd( "cantopenerr", DB_enum_CMD.CMD_CANTOPENERR ),
// new TestvfsSubcmd( "script", DB_enum_CMD.CMD_SCRIPT ),
// new TestvfsSubcmd( "devchar", DB_enum_CMD.CMD_DEVCHAR ),
// new TestvfsSubcmd( "sectorsize", DB_enum_CMD.CMD_SECTORSIZE ),
// new TestvfsSubcmd( 0, 0 )
// };
// int i=0;
// if( objc<2 ){
// TCL.Tcl_WrongNumArgs( interp, 1, objv, "SUBCOMMAND ..." );
// return TCL.TCL_ERROR;
// }
// if ( TCL.Tcl_GetIndexFromObjStruct(
// interp, objv[1], aSubcmd, aSubcmd.Length, "subcommand", 0, ref i)
// ){
// return TCL.TCL_ERROR;
// }
// TCL.Tcl_ResetResult( interp );
// switch( aSubcmd[i].eCmd ){
// case DB_enum_CMD.CMD_SHM: {
// Tcl_Obj pObj;
// int i;
// TestvfsBuffer pBuffer;
// string zName;
// if( objc!=3 && objc!=4 ){
// TCL.Tcl_WrongNumArgs( interp, 2, objv, "FILE ?VALUE?" );
// return TCL.TCL_ERROR;
// }
// zName = ckalloc(p.pParent.mxPathname);
// p.pParent.xFullPathname(
// p.pParent, TCL.Tcl_GetString(objv[2]),
// p.pParent.mxPathname, zName
// );
// for(pBuffer=p.pBuffer; pBuffer; pBuffer=pBuffer.pNext){
// if( 0==strcmp(pBuffer.zFile, zName) ) break;
// }
// ckfree(zName);
// if( null==pBuffer ){
// TCL.Tcl_AppendResult( interp, "no such file: ", TCL.Tcl_GetString( objv[2] ), 0 );
// return TCL.TCL_ERROR;
// }
// if( objc==4 ){
// int n;
// u8 *a = TCL.Tcl_GetByteArrayFromObj(objv[3], &n);
// int pgsz = pBuffer.pgsz;
// if( pgsz==0 ) pgsz = 65536;
// for(i=0; ipgsz<n; i++){
// int nByte = pgsz;
// tvfsAllocPage(pBuffer, i, pgsz);
// if( n-ipgsz<pgsz ){
// nByte = n;
// }
// memcpy(pBuffer.aPage[i], &a[ipgsz], nByte);
// }
// }
// pObj = TCL.Tcl_NewObj();
// for(i=0; pBuffer.aPage[i]!=null; i++){
// int pgsz = pBuffer.pgsz;
// if( pgsz==0 ) pgsz = 65536;
// TCL.Tcl_AppendObjToObj(pObj, TCL.Tcl_NewByteArrayObj(pBuffer.aPage[i], pgsz));
// }
// TCL.Tcl_SetObjResult( interp, pObj );
// break;
// }
// case DB_enum_CMD.CMD_FILTER: {
//VfsMethod[] vfsmethod = new VfsMethod[] {
// new VfsMethod( "xShmOpen", TESTVFS_SHMOPEN_MASK ),
// new VfsMethod( "xShmLock", TESTVFS_SHMLOCK_MASK ),
// new VfsMethod( "xShmBarrier", TESTVFS_SHMBARRIER_MASK ),
// new VfsMethod( "xShmUnmap", TESTVFS_SHMCLOSE_MASK ),
// new VfsMethod( "xShmMap", TESTVFS_SHMMAP_MASK ),
// new VfsMethod( "xSync", TESTVFS_SYNC_MASK ),
// new VfsMethod( "xDelete", TESTVFS_DELETE_MASK ),
// new VfsMethod( "xWrite", TESTVFS_WRITE_MASK ),
// new VfsMethod( "xTruncate", TESTVFS_TRUNCATE_MASK ),
// new VfsMethod( "xOpen", TESTVFS_OPEN_MASK ),
// new VfsMethod( "xClose", TESTVFS_CLOSE_MASK ),
// new VfsMethod( "xAccess", TESTVFS_ACCESS_MASK ),
// new VfsMethod( "xFullPathname", TESTVFS_FULLPATHNAME_MASK ),
//};
// Tcl_Obj[] apElem = null;
// int nElem = 0;
// int i;
// int mask = 0;
// if( objc!=3 ){
// TCL.Tcl_WrongNumArgs( interp, 2, objv, "LIST" );
// return TCL.TCL_ERROR;
// }
// if ( TCL.Tcl_ListObjGetElements( interp, objv[2], ref nElem, ref apElem ) )
// {
// return TCL.TCL_ERROR;
// }
// TCL.Tcl_ResetResult( interp );
// for(i=0; i<nElem; i++){
// int iMethod;
// string zElem = TCL.Tcl_GetString(apElem[i]);
// for(iMethod=0; iMethod<ArraySize(vfsmethod); iMethod++){
// if( strcmp(zElem, vfsmethod[iMethod].zName)==0 ){
// mask |= vfsmethod[iMethod].mask;
// break;
// }
// }
// if( iMethod==ArraySize(vfsmethod) ){
// TCL.Tcl_AppendResult( interp, "unknown method: ", zElem, 0 );
// return TCL.TCL_ERROR;
// }
// }
// p.mask = mask;
// break;
// }
// case DB_enum_CMD.CMD_SCRIPT: {
// if( objc==3 ){
// int nByte;
// if( p.pScript !=null){
// TCL.Tcl_DecrRefCount( p.pScript );
// p.pScript = 0;
// }
// TCL.Tcl_GetStringFromObj( objv[2], &nByte );
// if( nByte>0 ){
// p.pScript = TCL.Tcl_DuplicateObj(objv[2]);
// TCL.Tcl_IncrRefCount( p.pScript );
// }
// }else if( objc!=2 ){
// TCL.Tcl_WrongNumArgs( interp, 2, objv, "?SCRIPT?" );
// return TCL.TCL_ERROR;
// }
// TCL.Tcl_ResetResult( interp );
// if( p.pScript !=null) if( p.pScript )TCL.Tcl_SetObjResult(interp, p.pScript);
// break;
// }
// /*
// ** TESTVFS ioerr ?IFAIL PERSIST?
// **
// ** Where IFAIL is an integer and PERSIST is boolean.
// */
// case DB_enum_CMD.CMD_CANTOPENERR:
// case DB_enum_CMD.CMD_IOERR:
// case DB_enum_CMD.CMD_FULLERR: {
// TestFaultInject pTest;
// int iRet;
// switch( aSubcmd[i].eCmd ){
// case DB_enum_CMD.CMD_IOERR: pTest = p.ioerr_err; break;
// case DB_enum_CMD.CMD_FULLERR: pTest = p.full_err; break;
// case DB_enum_CMD.CMD_CANTOPENERR: pTest = p.cantopen_err; break;
// default: Debug.Assert(false);
// }
// iRet = pTest.nFail;
// pTest.nFail = 0;
// pTest.eFault = 0;
// pTest.iCnt = 0;
// if( objc==4 ){
// int iCnt, iPersist;
// if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], &iCnt )
// || TCL.TCL_OK != TCL.Tcl_GetBooleanFromObj( interp, objv[3], &iPersist )
// ){
// return TCL.TCL_ERROR;
// }
// pTest.eFault = iPersist != 0 ? FAULT_INJECT_PERSISTENT : FAULT_INJECT_TRANSIENT;
// pTest.iCnt = iCnt;
// }else if( objc!=2 ){
// TCL.Tcl_WrongNumArgs( interp, 2, objv, "?CNT PERSIST?" );
// return TCL.TCL_ERROR;
// }
// TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( iRet ) );
// break;
// }
// case DB_enum_CMD.CMD_DELETE: {
// TCL.Tcl_DeleteCommand( interp, TCL.Tcl_GetString( objv[0] ) );
// break;
// }
// case DB_enum_CMD.CMD_DEVCHAR: {
//_aFlag[] aFlag = new _aFlag[] {
// new _aFlag( "default", -1 ),
// new _aFlag( "atomic", SQLITE_IOCAP_ATOMIC ),
// new _aFlag( "atomic512", SQLITE_IOCAP_ATOMIC512 ),
// new _aFlag( "atomic1k", SQLITE_IOCAP_ATOMIC1K ),
// new _aFlag( "atomic2k", SQLITE_IOCAP_ATOMIC2K ),
// new _aFlag( "atomic4k", SQLITE_IOCAP_ATOMIC4K ),
// new _aFlag( "atomic8k", SQLITE_IOCAP_ATOMIC8K ),
// new _aFlag( "atomic16k", SQLITE_IOCAP_ATOMIC16K ),
// new _aFlag( "atomic32k", SQLITE_IOCAP_ATOMIC32K ),
// new _aFlag( "atomic64k", SQLITE_IOCAP_ATOMIC64K ),
// new _aFlag( "sequential", SQLITE_IOCAP_SEQUENTIAL ),
// new _aFlag( "safe_append", SQLITE_IOCAP_SAFE_APPEND ),
// new _aFlag( "undeletable_when_open", SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN ),
// new _aFlag( 0, 0 )
// };
// Tcl_Obj pRet;
// int iFlag;
// if( objc>3 ){
// Tcl_WrongNumArgs(interp, 2, objv, "?ATTR-LIST?");
// return TCL.TCL_ERROR;
// }
// if( objc==3 ){
// int j;
// int iNew = 0;
// Tcl_Obj[] flags = null;
// int nFlags = 0;
// if ( TCL.Tcl_ListObjGetElements( interp, objv[2], ref nFlags, ref flags ) )
// {
// return TCL.TCL_ERROR;
// }
// for(j=0; j<nFlags; j++){
// int idx = 0;
// if( Tcl_GetIndexFromObjStruct(interp, flags[j], aFlag,
// aFlag.Length, "flag", 0, ref idx)
// ){
// return TCL.TCL_ERROR;
// }
// if( aFlag[idx].iValue<0 && nFlags>1 ){
// TCL.Tcl_AppendResult( interp, "bad flags: ", TCL.Tcl_GetString( objv[2] ), 0 );
// return TCL.TCL_ERROR;
// }
// iNew |= aFlag[idx].iValue;
// }
// p.iDevchar = iNew;
// }
// pRet = TCL.Tcl_NewObj();
// for(iFlag=0; iFlag<aFlag.Length ; iFlag++)//sizeof(aFlag)/sizeof(aFlag[0]); iFlag++)
// {
// if( p.iDevchar & aFlag[iFlag].iValue ){
// TCL.Tcl_ListObjAppendElement(
// interp, pRet, TCL.Tcl_NewStringObj(aFlag[iFlag].zName, -1)
// );
// }
// }
// TCL.Tcl_SetObjResult( interp, pRet );
// break;
// }
// case DB_enum_CMD.CMD_SECTORSIZE: {
// if( objc>3 ){
// TCL.Tcl_WrongNumArgs( interp, 2, objv, "?VALUE?" );
// return TCL.TCL_ERROR;
// }
// if( objc==3 ){
// int iNew = 0;
// if( Tcl_GetIntFromObj(interp, objv[2], ref iNew) ){
// return TCL.TCL_ERROR;
// }
// p.iSectorsize = iNew;
// }
// TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( p.iSectorsize ) );
// break;
// }
// }
return TCL.TCL_OK;
}
/*
** Look at the script prefix in pCmd. We will be executing this script
** after first appending one or more arguments. This routine analyzes
** the script to see if it is safe to use TCL.Tcl_EvalObjv() on the script
** rather than the more general TCL.Tcl_EvalEx(). TCL.Tcl_EvalObjv() is much
** faster.
**
** Scripts that are safe to use with TCL.Tcl_EvalObjv() consists of a
** command name followed by zero or more arguments with no [...] or $
** or {...} or ; to be seen anywhere. Most callback scripts consist
** of just a single procedure name and they meet this requirement.
*/
static int safeToUseEvalObjv( Tcl_Interp interp, Tcl_Obj pCmd )
{
/* We could try to do something with TCL.Tcl_Parse(). But we will instead
** just do a search for forbidden characters. If any of the forbidden
** characters appear in pCmd, we will report the string as unsafe.
*/
string z;
int n = 0;
z = TCL.Tcl_GetStringFromObj( pCmd, ref n );
while ( n-- > 0 )
{
int c = z[n];// *( z++ );
if ( c == '$' || c == '[' || c == ';' ) return 0;
}
return 1;
}
/*
** USAGE: hexio_render_int32 INTEGER
**
** Render INTEGER has a 32-bit big-endian integer _in hexadecimal.
*/
static int hexio_render_int32(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int val = 0;
byte[] aNum = new byte[10];
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "INTEGER" );
return TCL.TCL_ERROR;
}
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[1], out val ) )
return TCL.TCL_ERROR;
aNum[0] = (byte)( val >> 24 );
aNum[1] = (byte)( val >> 16 );
aNum[2] = (byte)( val >> 8 );
aNum[3] = (byte)val;
sqlite3TestBinToHex( aNum, 4 );
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewStringObj( aNum, 8 ) );
return TCL.TCL_OK;
}
/*
** Usage: testvfs VFSNAME ?SWITCHES?
**
** Switches are:
**
** -noshm BOOLEAN (True to omit shm methods. Default false)
** -default BOOLEAN (True to make the vfs default. Default false)
**
** This command creates two things when it is invoked: an SQLite VFS, and
** a Tcl command. Both are named VFSNAME. The VFS is installed. It is not
** installed as the default VFS.
**
** The VFS passes all file I/O calls through to the underlying VFS.
**
** Whenever the xShmMap method of the VFS
** is invoked, the SCRIPT is executed as follows:
**
** SCRIPT xShmMap FILENAME ID
**
** The value returned by the invocation of SCRIPT above is interpreted as
** an SQLite error code and returned to SQLite. Either a symbolic
** "SQLITE_OK" or numeric "0" value may be returned.
**
** The contents of the shared-memory buffer associated with a given file
** may be read and set using the following command:
**
** VFSNAME shm FILENAME ?NEWVALUE?
**
** When the xShmLock method is invoked by SQLite, the following script is
** run:
**
** SCRIPT xShmLock FILENAME ID LOCK
**
** where LOCK is of the form "OFFSET NBYTE lock/unlock shared/exclusive"
*/
static int testvfs_cmd(
ClientData cd,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
){
Debugger.Break();//TODO
// sqlite3_vfs tvfs_vfs = new sqlite3_vfs(
// 2, /* iVersion */
// 0, /* szOsFile */
// 0, /* mxPathname */
// null, /* pNext */
// null, /* zName */
// 0, /* pAppData */
// tvfsOpen, /* xOpen */
// tvfsDelete, /* xDelete */
// tvfsAccess, /* xAccess */
// tvfsFullPathname, /* xFullPathname */
//#if !SQLITE_OMIT_LOAD_EXTENSION
// tvfsDlOpen, /* xDlOpen */
// tvfsDlError, /* xDlError */
// tvfsDlSym, /* xDlSym */
// tvfsDlClose, /* xDlClose */
//#else
// null, /* xDlOpen */
// null, /* xDlError */
// null, /* xDlSym */
// null, /* xDlClose */
//#endif //* SQLITE_OMIT_LOAD_EXTENSION */
// tvfsRandomness, /* xRandomness */
// tvfsSleep, /* xSleep */
// tvfsCurrentTime, /* xCurrentTime */
// null, /* xGetLastError */
// null, /* xCurrentTimeInt64 */
// null, null, null
// );
// Testvfs p; /* New object */
// sqlite3_vfs pVfs; /* New VFS */
// string zVfs;
// int nByte; /* Bytes of space to allocate at p */
// int i;
// int isNoshm = 0; /* True if -noshm is passed */
// int isDefault = 0; /* True if -default is passed */
// int szOsFile = 0; /* Value passed to -szosfile */
// int mxPathname = -1; /* Value passed to -mxpathname */
// int iVersion = 2; /* Value passed to -iversion */
// if( objc<2 || 0!=(objc%2) ) goto bad_args;
// for(i=2; i<objc; i += 2){
// int nSwitch;
// string zSwitch;
// zSwitch = TCL.Tcl_GetStringFromObj(objv[i], &nSwitch);
// if( nSwitch>2 && 0==strncmp("-noshm", zSwitch, nSwitch) ){
// if ( TCL.Tcl_GetBooleanFromObj( interp, objv[i + 1], &isNoshm ) )
// {
// return TCL.TCL_ERROR;
// }
// }
// else if( nSwitch>2 && 0==strncmp("-default", zSwitch, nSwitch) ){
// if ( TCL.Tcl_GetBooleanFromObj( interp, objv[i + 1], &isDefault ) )
// {
// return TCL.TCL_ERROR;
// }
// }
// else if( nSwitch>2 && 0==strncmp("-szosfile", zSwitch, nSwitch) ){
// if ( TCL.Tcl_GetIntFromObj( interp, objv[i + 1], &szOsFile ) )
// {
// return TCL.TCL_ERROR;
// }
// }
// else if( nSwitch>2 && 0==strncmp("-mxpathname", zSwitch, nSwitch) ){
// if ( TCL.Tcl_GetIntFromObj( interp, objv[i + 1], &mxPathname ) )
// {
// return TCL.TCL_ERROR;
// }
// }
// else if( nSwitch>2 && 0==strncmp("-iversion", zSwitch, nSwitch) ){
// if ( TCL.Tcl_GetIntFromObj( interp, objv[i + 1], &iVersion ) )
// {
// return TCL.TCL_ERROR;
// }
// }
// else{
// goto bad_args;
// }
// }
// if( szOsFile<sizeof(TestvfsFile) ){
// szOsFile = sizeof(TestvfsFile);
// }
// zVfs = TCL.Tcl_GetString(objv[1]);
// nByte = sizeof(Testvfs) + strlen(zVfs)+1;
// p = (Testvfs )ckalloc(nByte);
// memset(p, 0, nByte);
// p.iDevchar = -1;
// p.iSectorsize = -1;
// /* Create the new object command before querying SQLite for a default VFS
// ** to use for 'real' IO operations. This is because creating the new VFS
// ** may delete an existing [testvfs] VFS of the same name. If such a VFS
// ** is currently the default, the new [testvfs] may end up calling the
// ** methods of a deleted object.
// */
// TCL.Tcl_CreateObjCommand( interp, zVfs, testvfs_obj_cmd, p, testvfs_obj_del );
// p.pParent = sqlite3_vfs_find("");
// p.interp = interp;
// p.zName = (char )&p[1];
// memcpy(p.zName, zVfs, strlen(zVfs)+1);
// pVfs = new sqlite3_vfs();//(sqlite3_vfs )ckalloc(sizeof(sqlite3_vfs));
// tvfs_vfs.CopyTo(pVfs);//memcpy( pVfs, &tvfs_vfs, sizeof( sqlite3_vfs ) );
// pVfs.pAppData = p;
// pVfs.iVersion = iVersion;
// pVfs.zName = p.zName;
// pVfs.mxPathname = p.pParent.mxPathname;
// if( mxPathname>=0 && mxPathname<pVfs.mxPathname ){
// pVfs.mxPathname = mxPathname;
// }
// pVfs.szOsFile = szOsFile;
// p.pVfs = pVfs;
// p.isNoshm = isNoshm;
// p.mask = TESTVFS_ALL_MASK;
// sqlite3_vfs_register(pVfs, isDefault);
// return TCL.TCL_OK;
// bad_args:
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "VFSNAME ?-noshm BOOL? ?-default BOOL? ?-mxpathname INT? ?-szosfile INT? ?-iversion INT?");
return TCL.TCL_ERROR;
}
/*
** USAGE: utf8_to_utf8 HEX
**
** The argument is a UTF8 string represented _in hexadecimal.
** The UTF8 might not be well-formed. Run this string through
** sqlite3Utf8to8() convert it back to hex and return the result.
*/
static int utf8_to_utf8(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
){
#if SQLITE_DEBUG
int n = 0;
int nOut;
string zOrig;
byte[] z;
if( objc!=2 ){
TCL.Tcl_WrongNumArgs(interp, 1, objv, "HEX");
return TCL.TCL_ERROR;
}
zOrig = TCL.Tcl_GetStringFromObj(objv[1], out n);
z = new byte[2 * n + 1];//sqlite3Malloc( n + 3 );
nOut = sqlite3TestHexToBin( zOrig, n, z );
//z[n] = 0;
nOut = sqlite3Utf8To8(z);
sqlite3TestBinToHex( z, zOrig.Length );
TCL.Tcl_AppendResult(interp, Encoding.ASCII.GetString(z,0,n));
//sqlite3_free( z );
return TCL.TCL_OK;
#else
Tcl_AppendResult(interp,
"[utf8_to_utf8] unavailable - SQLITE_DEBUG not defined", 0
);
return TCL.TCL_ERROR;
#endif
}
/*
** A TCL command for md5. The argument is the text to be hashed. The
** Result is the hash in base64.
*/
static int md5_cmd( object cd, Tcl_Interp interp, int argc, Tcl_Obj[] argv )
{
MD5Context ctx = new MD5Context();
byte[] digest = new byte[16];
byte[] zBuf = new byte[32];
if ( argc != 2 )
{
TCL.Tcl_AppendResult( interp, "wrong # args: should be \"", argv[0],
" TEXT\"" );
return TCL.TCL_ERROR;
}
MD5Init( ctx );
MD5Update( ctx, Encoding.UTF8.GetBytes( argv[1].ToString() ), Encoding.UTF8.GetByteCount( argv[1].ToString() ) );
MD5Final( digest, ctx );
DigestToBase16( digest, zBuf );
TCL.Tcl_AppendResult( interp, Encoding.UTF8.GetString( zBuf ) );
return TCL.TCL_OK;
}
/*
** TCLCMD: autoinstall_test_functions
**
** Invoke this TCL command to use sqlite3_auto_extension() to cause
** the standard set of test functions to be loaded into each new
** database connection.
*/
static int autoinstall_test_funcs(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
//extern int Md5_Register(sqlite3);
int rc = sqlite3_auto_extension( (dxInit)registerTestFunctions );
if ( rc == SQLITE_OK )
{
rc = sqlite3_auto_extension( (dxInit)Md5_Register );
}
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( rc ) );
return TCL.TCL_OK;
}
/*****************************************************************************
** Everything below is interface for testing this module.
*/
#if SQLITE_TEST
//#include <tcl.h>
/*
** Routines to encode and decode pointers
*/
//extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
//extern void *sqlite3TestTextToPtr(const char*);
//extern int sqlite3TestMakePointerStr(Tcl_Interp*, char *zPtr, void*);
//extern const char *sqlite3TestErrorName(int);
/*
** sqlite3_intarray_create DB NAME
**
** Invoke the sqlite3_intarray_create interface. A string that becomes
** the first parameter to sqlite3_intarray_bind.
*/
static int test_intarray_create(
ClientData clientData, /* Not used */
Tcl_Interp interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj[] objv /* Command arguments */
)
{
sqlite3 db;
string zName;
sqlite3_intarray pArray;
int rc = SQLITE_OK;
StringBuilder zPtr = new StringBuilder( 100 );
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "DB" );
return TCL.TCL_ERROR;
}
if ( getDbPointer( interp, TCL.Tcl_GetString( objv[1] ), out db ) != 0 )
return TCL.TCL_ERROR;
zName = TCL.Tcl_GetString( objv[2] );
#if !SQLITE_OMIT_VIRTUALTABLE
rc = sqlite3_intarray_create( db, zName, out pArray );
#endif
if ( rc != SQLITE_OK )
{
Debug.Assert( pArray == null );
TCL.Tcl_AppendResult( interp, sqlite3TestErrorName( rc ), null );
return TCL.TCL_ERROR;
}
sqlite3TestMakePointerStr( interp, zPtr, pArray );
TCL.Tcl_AppendResult( interp, zPtr, null );
return TCL.TCL_OK;
}
/*
** tclcmd: abuse_create_function
**
** Make various calls to sqlite3_create_function that do not have valid
** parameters. Verify that the error condition is detected and reported.
*/
static int abuse_create_function(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
//extern int getDbPointer(Tcl_Interp*, const char*, sqlite3*);
sqlite3 db = null;
int rc;
int mxArg;
if ( getDbPointer( interp, TCL.Tcl_GetString( objv[1] ), out db ) != 0 )
return TCL.TCL_ERROR;
rc = sqlite3_create_function( db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, tFinal );
if ( rc != SQLITE_MISUSE )
goto abuse_err;
rc = sqlite3_create_function( db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, null );
if ( rc != SQLITE_MISUSE )
goto abuse_err;
rc = sqlite3_create_function( db, "tx", 1, SQLITE_UTF8, 0, tStep, null, tFinal );
if ( rc != SQLITE_MISUSE )
goto abuse_err;
rc = sqlite3_create_function( db, "tx", 1, SQLITE_UTF8, 0, null, null, tFinal );
if ( rc != SQLITE_MISUSE )
goto abuse_err;
rc = sqlite3_create_function( db, "tx", 1, SQLITE_UTF8, 0, null, tStep, null );
if ( rc != SQLITE_MISUSE )
goto abuse_err;
rc = sqlite3_create_function( db, "tx", -2, SQLITE_UTF8, 0, tStep, null, null );
if ( rc != SQLITE_MISUSE )
goto abuse_err;
rc = sqlite3_create_function( db, "tx", 128, SQLITE_UTF8, 0, tStep, null, null );
if ( rc != SQLITE_MISUSE )
goto abuse_err;
rc = sqlite3_create_function( db, "funcxx" +
"_123456789_123456789_123456789_123456789_123456789" +
"_123456789_123456789_123456789_123456789_123456789" +
"_123456789_123456789_123456789_123456789_123456789" +
"_123456789_123456789_123456789_123456789_123456789" +
"_123456789_123456789_123456789_123456789_123456789",
1, SQLITE_UTF8, 0, tStep, null, null );
if ( rc != SQLITE_MISUSE )
goto abuse_err;
/* This last function registration should actually work. Generate
** a no-op function (that always returns NULL) and which has the
** maximum-length function name and the maximum number of parameters.
*/
sqlite3_limit( db, SQLITE_LIMIT_FUNCTION_ARG, 10000 );
mxArg = sqlite3_limit( db, SQLITE_LIMIT_FUNCTION_ARG, -1 );
rc = sqlite3_create_function( db, "nullx" +
"_123456789_123456789_123456789_123456789_123456789" +
"_123456789_123456789_123456789_123456789_123456789" +
"_123456789_123456789_123456789_123456789_123456789" +
"_123456789_123456789_123456789_123456789_123456789" +
"_123456789_123456789_123456789_123456789_123456789",
mxArg, SQLITE_UTF8, 0, tStep, null, null );
if ( rc != SQLITE_OK )
goto abuse_err;
return TCL.TCL_OK;
abuse_err:
TCL.Tcl_AppendResult( interp, "sqlite3_create_function abused test failed"
);
return TCL.TCL_ERROR;
}
/*
** c_misuse_test
*/
static int c_misuse_test(
object clientdata, /* Pointer to sqlite3_enable_XXX function */
Tcl_Interp interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj[] objv /* Command arguments */
)
{
string zErrFunction = "N/A";
sqlite3 db = null;
sqlite3_stmt pStmt;
int rc;
if ( objc != 1 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "" );
return TCL.TCL_ERROR;
}
/* Open a database. Then close it again. We need to do this so that
** we have a "closed database handle" to pass to various API functions.
*/
rc = sqlite3_open( ":memory:", out db );
if ( rc != SQLITE_OK )
{
zErrFunction = "sqlite3_open";
goto error_out;
}
sqlite3_close( db );
rc = sqlite3_errcode( db );
if ( rc != SQLITE_MISUSE )
{
zErrFunction = "sqlite3_errcode";
goto error_out;
}
pStmt = new sqlite3_stmt();
pStmt.pc = 1234;
rc = sqlite3_prepare( db, (StringBuilder)null, 0, ref pStmt, 0 );
if ( rc != SQLITE_MISUSE )
{
zErrFunction = "sqlite3_prepare";
goto error_out;
}
Debug.Assert( pStmt == null ); /* Verify that pStmt is zeroed even on a MISUSE error */
pStmt = new sqlite3_stmt();
pStmt.pc = 1234;
rc = sqlite3_prepare_v2( db, null, 0, ref pStmt, 0 );
if ( rc != SQLITE_MISUSE )
{
zErrFunction = "sqlite3_prepare_v2";
goto error_out;
}
Debug.Assert( pStmt == null );
#if !SQLITE_OMIT_UTF16
pStmt = (sqlite3_stmt)1234;
rc = sqlite3_prepare16( db, null, 0, ref pStmt, 0 );
if( rc!=SQLITE_MISUSE ){
zErrFunction = "sqlite3_prepare16";
goto error_out;
}
Debug.Assert( pStmt==0 );
pStmt = (sqlite3_stmt)1234;
rc = sqlite3_prepare16_v2( db, null, 0, ref pStmt, 0 );
if( rc!=SQLITE_MISUSE ){
zErrFunction = "sqlite3_prepare16_v2";
goto error_out;
}
Debug.Assert( pStmt==0 );
#endif
return TCL.TCL_OK;
error_out:
TCL.Tcl_ResetResult( interp );
TCL.Tcl_AppendResult( interp, "Error testing function: ", zErrFunction );
return TCL.TCL_ERROR;
}
/*
** sqlite3_initialize
*/
static int test_initialize(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv )
{
int rc;
if ( objc != 1 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "" );
return TCL.TCL_ERROR;
}
rc = sqlite3_initialize();
TCL.Tcl_SetResult( interp, sqlite3TestErrorName( rc ), TCL.TCL_VOLATILE );
return TCL.TCL_OK;
}
/*
** c_realloc_test
*/
static int c_realloc_test(
object clientdata, /* Pointer to sqlite3_enable_XXX function */
Tcl_Interp interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj[] objv /* Command arguments */
)
{
object p;
string zErrFunction = "N/A";
if ( objc != 1 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "" );
return TCL.TCL_ERROR;
}
p = sqlite3Malloc( 5 );
if ( p == null )
{
zErrFunction = "sqlite3Malloc";
goto error_out;
}
/* Test that realloc()ing a block of memory to a negative size is
** the same as free()ing that memory.
*/
//TODO -- ignore realloc
//p = sqlite3_realloc(p, -1);
//if( p!=null ){
// zErrFunction = "sqlite3_realloc";
// goto error_out;
//}
return TCL.TCL_OK;
error_out:
TCL.Tcl_ResetResult( interp );
TCL.Tcl_AppendResult( interp, "Error testing function: ", zErrFunction );
return TCL.TCL_ERROR;
}
/*
** install_mutex_counters BOOLEAN
*/
//static int test_install_mutex_counters(
// void * clientData,
// Tcl_Interp *interp,
// int objc,
// Tcl_Obj *CONST objv[]
//){
// int rc = SQLITE_OK;
// int isInstall;
// sqlite3_mutex_methods counter_methods = {
// counterMutexInit,
// counterMutexEnd,
// counterMutexAlloc,
// counterMutexFree,
// counterMutexEnter,
// counterMutexTry,
// counterMutexLeave,
// counterMutexHeld,
// counterMutexNotheld
// };
// if( objc!=2 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN");
// return TCL.TCL_ERROR;
// }
// if( TCL.TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[1], isInstall) ){
// return TCL.TCL_ERROR;
// }
// Debug.Assert(isInstall==0 || isInstall==1);
// Debug.Assert(g.isInstalled==0 || g.isInstalled==1);
// if( isInstall==g.isInstalled ){
// TCL.Tcl_AppendResult(interp, "mutex counters are ");
// TCL.Tcl_AppendResult(interp, isInstall?"already installed":"not installed");
// return TCL.TCL_ERROR;
// }
// if( isInstall ){
// Debug.Assert( g.m.xMutexAlloc==0 );
// rc = sqlite3_config(SQLITE_CONFIG_GETMUTEX, g.m);
// if( rc==SQLITE_OK ){
// sqlite3_config(SQLITE_CONFIG_MUTEX, counter_methods);
// }
// g.disableTry = 0;
// }else{
// Debug.Assert( g.m.xMutexAlloc );
// rc = sqlite3_config(SQLITE_CONFIG_MUTEX, g.m);
// memset(&g.m, 0, sizeof(sqlite3_mutex_methods));
// }
// if( rc==SQLITE_OK ){
// g.isInstalled = isInstall;
// }
// TCL.Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL.Tcl_VOLATILE);
// return TCL.TCL_OK;
//}
/*
** read_mutex_counters
*/
//static int test_read_mutex_counters(
// object clientdata,
// Tcl_Interp interp,
// int objc,
// Tcl_Obj[] objv
//){
// Tcl_Obj pRet;
// int ii;
// char *aName[8] = {
// "fast", "recursive", "static_master", "static_mem",
// "static_open", "static_prng", "static_lru", "static_lru2"
// };
// if( objc!=1 ){
// TCL.Tcl_WrongNumArgs(interp, 1, objv, "");
// return TCL.TCL_ERROR;
// }
// pRet = TCL.Tcl_NewObj();
// TCL.Tcl_IncrRefCount(pRet);
// for(ii=0; ii<8; ii++){
// TCL.Tcl_ListObjAppendElement(interp, pRet, TCL.Tcl_NewStringObj(aName[ii], -1));
// TCL.Tcl_ListObjAppendElement(interp, pRet, TCL.Tcl_NewIntObj(g.aCounter[ii]));
// }
// TCL.Tcl_SetObjResult(interp, pRet);
// TCL.Tcl_DecrRefCount(pRet);
// return TCL.TCL_OK;
//}
/*
** clear_mutex_counters
*/
static int test_clear_mutex_counters(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
int ii;
if ( objc != 1 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "" );
return TCL.TCL_ERROR;
}
for ( ii = 0 ; ii < 8 ; ii++ )
{
g.aCounter[ii] = 0;
}
return TCL.TCL_OK;
}
static int backupTestCmd(
ClientData clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
BackupSubCommand[] aSub = new BackupSubCommand[] {
new BackupSubCommand("step", BackupSubCommandEnum.BACKUP_STEP , 1, "npage" ),
new BackupSubCommand("finish", BackupSubCommandEnum.BACKUP_FINISH , 0, "" ),
new BackupSubCommand("remaining", BackupSubCommandEnum.BACKUP_REMAINING , 0, "" ),
new BackupSubCommand("pagecount", BackupSubCommandEnum.BACKUP_PAGECOUNT , 0, "" ),
new BackupSubCommand(null,0,0,null)
};
sqlite3_backup p = (sqlite3_backup)clientData;
int iCmd = 0;
int rc;
rc = Tcl_GetIndexFromObjStruct(
interp, objv[1], aSub, aSub.Length, "option", 0, ref iCmd
);
if ( rc != TCL.TCL_OK )
{
return rc;
}
if ( objc != ( 2 + aSub[iCmd].nArg ) )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, aSub[iCmd].zArg );
return TCL.TCL_ERROR;
}
switch ( aSub[iCmd].eCmd )
{
case BackupSubCommandEnum.BACKUP_FINISH:
{
string zCmdName;
WrappedCommand cmdInfo = null;
zCmdName = TCL.Tcl_GetString( objv[0] );
TCL.Tcl_GetCommandInfo( interp, zCmdName, ref cmdInfo );
cmdInfo.deleteProc = null;
TCL.Tcl_SetCommandInfo( interp, zCmdName, cmdInfo );
TCL.Tcl_DeleteCommand( interp, zCmdName );
rc = sqlite3_backup_finish( p );
TCL.Tcl_SetResult( interp, sqlite3TestErrorName( rc ), TCL.TCL_STATIC );
break;
}
case BackupSubCommandEnum.BACKUP_STEP:
{
int nPage = 0;
if ( TCL.Tcl_GetIntFromObj( interp, objv[2], ref nPage ) )
{
return TCL.TCL_ERROR;
}
rc = sqlite3_backup_step( p, nPage );
TCL.Tcl_SetResult( interp, sqlite3TestErrorName( rc ), TCL.TCL_STATIC );
break;
}
case BackupSubCommandEnum.BACKUP_REMAINING:
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( sqlite3_backup_remaining( p ) ) );
break;
case BackupSubCommandEnum.BACKUP_PAGECOUNT:
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( sqlite3_backup_pagecount( p ) ) );
break;
}
return TCL.TCL_OK;
}
/*
** Create and free a mutex. Return the mutex pointer. The pointer
** will be invalid since the mutex has already been freed. The
** return pointer just checks to see if the mutex really was allocated.
*/
static int test_alloc_mutex(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv )
{
#if SQLITE_THREADSAFE
sqlite3_mutex p = sqlite3_mutex_alloc( SQLITE_MUTEX_FAST );
string zBuf = "";//[100];
sqlite3_mutex_free( ref p );
sqlite3_snprintf( 100, ref zBuf, "%p", p );
TCL.Tcl_AppendResult( interp, zBuf );
#endif
return TCL.TCL_OK;
}
/*
** Tcl interface to sqlite3_declare_vtab, invoked as follows from Tcl:
**
** sqlite3_declare_vtab DB SQL
*/
static int declare_vtab(
ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
Tcl_Interp interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj[] objv /* Command arguments */
)
{
sqlite3 db = null;
int rc;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "DB SQL" );
return TCL.TCL_ERROR;
}
if ( getDbPointer( interp, TCL.Tcl_GetString( objv[1] ), out db ) != 0 )
return TCL.TCL_ERROR;
rc = sqlite3_declare_vtab( db, TCL.Tcl_GetString( objv[2] ) );
if ( rc != SQLITE_OK )
{
TCL.Tcl_SetResult( interp, sqlite3_errmsg( db ), TCL.TCL_VOLATILE );
return TCL.TCL_ERROR;
}
return TCL.TCL_OK;
}
static int test_config(
object clientdata,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
ConfigOption[] aOpt = new ConfigOption[] {
new ConfigOption("singlethread", SQLITE_CONFIG_SINGLETHREAD),
new ConfigOption("multithread", SQLITE_CONFIG_MULTITHREAD),
new ConfigOption("serialized", SQLITE_CONFIG_SERIALIZED),
new ConfigOption(null,0)
};
int s = aOpt.Length;//sizeof(struct ConfigOption);
int i = 0;
int rc;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "" );
return TCL.TCL_ERROR;
}
if ( Tcl_GetIndexFromObjStruct( interp, objv[1], aOpt, s, "flag", 0, ref i ) )
{
if ( TCL.Tcl_GetIntFromObj( interp, objv[1], ref i ) )
{
return TCL.TCL_ERROR;
}
}
else
{
i = aOpt[i].iValue;
}
rc = sqlite3_config( i );
TCL.Tcl_SetResult( interp, sqlite3TestErrorName( rc ), TCL.TCL_VOLATILE );
return TCL.TCL_OK;
}
