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; }