[sql] Import SQLite 3.17.0.

third_party/sqlite/src/src/test1.c

 /*
 ** 2001 September 15
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 ** Code for testing all sorts of SQLite interfaces.  This code
 ** is not included in the SQLite library.  It is used for automated
 ** testing of the SQLite library.
 */
 #include "sqliteInt.h"
 #if SQLITE_OS_WIN
 #  include "os_win.h"
 #endif
 
 #include "vdbeInt.h"
-#include "tcl.h"
+#if defined(INCLUDE_SQLITE_TCL_H)
+#  include "sqlite_tcl.h"
+#else
+#  include "tcl.h"
+#endif
 #include <stdlib.h>
 #include <string.h>
 
 /*
 ** This is a copy of the first part of the SqliteDb structure in 
 ** tclsqlite.c.  We need it here so that the get_sqlite_pointer routine
 ** can extract the sqlite3* pointer from an existing Tcl SQLite
 ** connection.
 */
 struct SqliteDb {
@@ skipping 35 matching lines @@
   }
   return p;
 }
 
 
 /*
 ** A TCL command that returns the address of the sqlite* pointer
 ** for an sqlite connection instance.  Bad things happen if the
 ** input is not an sqlite connection.
 */
-static int get_sqlite_pointer(
+static int SQLITE_TCLAPI get_sqlite_pointer(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   struct SqliteDb *p;
   Tcl_CmdInfo cmdInfo;
   char zBuf[100];
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "SQLITE-CONNECTION");
@@ skipping 125 matching lines @@
 }
 #endif
 
 /*
 ** Usage:  io_trace FILENAME
 **
 ** Turn I/O tracing on or off.  If FILENAME is not an empty string,
 ** I/O tracing begins going into FILENAME. If FILENAME is an empty
 ** string, I/O tracing is turned off.
 */
-static int test_io_trace(
+static int SQLITE_TCLAPI test_io_trace(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
           " FILENAME\"", 0);
     return TCL_ERROR;
@@ skipping 20 matching lines @@
 }
 
 /*
 ** Usage:  clang_sanitize_address 
 **
 ** Returns true if the program was compiled using clang with the 
 ** -fsanitize=address switch on the command line. False otherwise.
 **
 ** Also return true if the OMIT_MISUSE environment variable exists.
 */
-static int clang_sanitize_address(
+static int SQLITE_TCLAPI clang_sanitize_address(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int res = 0;
 #if defined(__has_feature)
 # if __has_feature(address_sanitizer)
   res = 1;
 # endif
 #endif
 #ifdef __SANITIZE_ADDRESS__
   res = 1;
 #endif
   if( res==0 && getenv("OMIT_MISUSE")!=0 ) res = 1;
   Tcl_SetObjResult(interp, Tcl_NewIntObj(res));
   return TCL_OK;
 }
   
 /*
 ** Usage:  sqlite3_exec_printf  DB  FORMAT  STRING
 **
 ** Invoke the sqlite3_exec_printf() interface using the open database
 ** DB.  The SQL is the string FORMAT.  The format string should contain
 ** one %s or %q.  STRING is the value inserted into %s or %q.
 */
-static int test_exec_printf(
+static int SQLITE_TCLAPI test_exec_printf(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   Tcl_DString str;
   int rc;
   char *zErr = 0;
   char *zSql;
@@ skipping 17 matching lines @@
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_exec_hex  DB  HEX
 **
 ** Invoke the sqlite3_exec() on a string that is obtained by translating
 ** HEX into ASCII.  Most characters are translated as is.  %HH becomes
 ** a hex character.
 */
-static int test_exec_hex(
+static int SQLITE_TCLAPI test_exec_hex(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   Tcl_DString str;
   int rc, i, j;
   char *zErr = 0;
   char *zHex;
@@ skipping 25 matching lines @@
   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
   return TCL_OK;
 }
 
 /*
 ** Usage:  db_enter DB
 **         db_leave DB
 **
 ** Enter or leave the mutex on a database connection.
 */
-static int db_enter(
+static int SQLITE_TCLAPI db_enter(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
        " DB", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   sqlite3_mutex_enter(db->mutex);
   return TCL_OK;
 }
-static int db_leave(
+static int SQLITE_TCLAPI db_leave(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
        " DB", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   sqlite3_mutex_leave(db->mutex);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_exec  DB  SQL
 **
 ** Invoke the sqlite3_exec interface using the open database DB
 */
-static int test_exec(
+static int SQLITE_TCLAPI test_exec(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   Tcl_DString str;
   int rc;
   char *zErr = 0;
   char *zSql;
@@ skipping 26 matching lines @@
   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_exec_nr  DB  SQL
 **
 ** Invoke the sqlite3_exec interface using the open database DB.  Discard
 ** all results
 */
-static int test_exec_nr(
+static int SQLITE_TCLAPI test_exec_nr(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   int rc;
   char *zErr = 0;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
        " DB SQL", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_z_test  SEPARATOR  ARG0  ARG1 ...
 **
 ** Test the %z format of sqlite_mprintf().  Use multiple mprintf() calls to 
 ** concatenate arg0 through argn using separator as the separator.
 ** Return the result.
 */
-static int test_mprintf_z(
+static int SQLITE_TCLAPI test_mprintf_z(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   char *zResult = 0;
   int i;
 
   for(i=2; i<argc && (i==2 || zResult); i++){
     zResult = sqlite3_mprintf("%z%s%s", zResult, argv[1], argv[i]);
   }
   Tcl_AppendResult(interp, zResult, 0);
   sqlite3_free(zResult);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_n_test  STRING
 **
 ** Test the %n format of sqlite_mprintf().  Return the length of the
 ** input string.
 */
-static int test_mprintf_n(
+static int SQLITE_TCLAPI test_mprintf_n(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   char *zStr;
   int n = 0;
   zStr = sqlite3_mprintf("%s%n", argv[1], &n);
   sqlite3_free(zStr);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(n));
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_snprintf_int  SIZE FORMAT  INT
 **
 ** Test the of sqlite3_snprintf() routine.  SIZE is the size of the
 ** output buffer in bytes.  The maximum size is 100.  FORMAT is the
 ** format string.  INT is a single integer argument.  The FORMAT
 ** string must require no more than this one integer argument.  If
 ** You pass in a format string that requires more than one argument,
 ** bad things will happen.
 */
-static int test_snprintf_int(
+static int SQLITE_TCLAPI test_snprintf_int(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   char zStr[100];
   int n = atoi(argv[1]);
   const char *zFormat = argv[2];
   int a1 = atoi(argv[3]);
   if( n>sizeof(zStr) ) n = sizeof(zStr);
   sqlite3_snprintf(sizeof(zStr), zStr, "abcdefghijklmnopqrstuvwxyz");
   sqlite3_snprintf(n, zStr, zFormat, a1);
   Tcl_AppendResult(interp, zStr, 0);
   return TCL_OK;
 }
 
 #ifndef SQLITE_OMIT_GET_TABLE
 
 /*
 ** Usage:  sqlite3_get_table_printf  DB  FORMAT  STRING  ?--no-counts?
 **
 ** Invoke the sqlite3_get_table_printf() interface using the open database
 ** DB.  The SQL is the string FORMAT.  The format string should contain
 ** one %s or %q.  STRING is the value inserted into %s or %q.
 */
-static int test_get_table_printf(
+static int SQLITE_TCLAPI test_get_table_printf(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   Tcl_DString str;
   int rc;
   char *zErr = 0;
   int nRow = 0, nCol = 0;
@@ skipping 42 matching lines @@
 }
 
 #endif /* SQLITE_OMIT_GET_TABLE */
 
 
 /*
 ** Usage:  sqlite3_last_insert_rowid DB
 **
 ** Returns the integer ROWID of the most recent insert.
 */
-static int test_last_rowid(
+static int SQLITE_TCLAPI test_last_rowid(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   char zBuf[30];
 
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", sqlite3_last_insert_rowid(db));
   Tcl_AppendResult(interp, zBuf, 0);
   return SQLITE_OK;
 }
 
 /*
 ** Usage:  sqlite3_key DB KEY
 **
 ** Set the codec key.
 */
-static int test_key(
+static int SQLITE_TCLAPI test_key(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
-#ifdef SQLITE_HAS_CODEC
+#if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_CODEC_FROM_TCL)
   sqlite3 *db;
   const char *zKey;
   int nKey;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FILENAME\"", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   zKey = argv[2];
   nKey = strlen(zKey);
   sqlite3_key(db, zKey, nKey);
 #endif
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_rekey DB KEY
 **
 ** Change the codec key.
 */
-static int test_rekey(
+static int SQLITE_TCLAPI test_rekey(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
 #ifdef SQLITE_HAS_CODEC
   sqlite3 *db;
   const char *zKey;
   int nKey;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FILENAME\"", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   zKey = argv[2];
   nKey = strlen(zKey);
   sqlite3_rekey(db, zKey, nKey);
 #endif
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_close DB
 **
 ** Closes the database opened by sqlite3_open.
 */
-static int sqlite_test_close(
+static int SQLITE_TCLAPI sqlite_test_close(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   int rc;
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FILENAME\"", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   rc = sqlite3_close(db);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_close_v2 DB
 **
 ** Closes the database opened by sqlite3_open.
 */
-static int sqlite_test_close_v2(
+static int SQLITE_TCLAPI sqlite_test_close_v2(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   int rc;
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FILENAME\"", 0);
@@ skipping 263 matching lines @@
 ** as the "coalesce" function.  This function also registers an SQL function
 ** named "x_sqlite_exec" that invokes sqlite3_exec().  Invoking sqlite3_exec()
 ** in this way is illegal recursion and should raise an SQLITE_MISUSE error.
 ** The effect is similar to trying to use the same database connection from
 ** two threads at the same time.
 **
 ** The original motivation for this routine was to be able to call the
 ** sqlite3_create_function function while a query is in progress in order
 ** to test the SQLITE_MISUSE detection logic.
 */
-static int test_create_function(
+static int SQLITE_TCLAPI test_create_function(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int rc;
   sqlite3 *db;
 
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
@@ skipping 136 matching lines @@
 ** sqlite3_create_aggregate function while a query is in progress in order
 ** to test the SQLITE_MISUSE detection logic.  See misuse.test.
 **
 ** This routine was later extended to test the use of sqlite3_result_error()
 ** within aggregate functions.
 **
 ** Later: It is now also extended to register the aggregate function
 ** "legacy_count()" with the supplied database handle. This is used
 ** to test the deprecated sqlite3_aggregate_count() API.
 */
-static int test_create_aggregate(
+static int SQLITE_TCLAPI test_create_aggregate(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   int rc;
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FILENAME\"", 0);
@@ skipping 20 matching lines @@
 
 
 /*
 ** Usage:  printf TEXT
 **
 ** Send output to printf.  Use this rather than puts to merge the output
 ** in the correct sequence with debugging printfs inserted into C code.
 ** Puts uses a separate buffer and debugging statements will be out of
 ** sequence if it is used.
 */
-static int test_printf(
+static int SQLITE_TCLAPI test_printf(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " TEXT\"", 0);
     return TCL_ERROR;
   }
   printf("%s\n", argv[1]);
   return TCL_OK;
 }
 
 
 
 /*
 ** Usage:  sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER
 **
 ** Call mprintf with three integer arguments
 */
-static int sqlite3_mprintf_int(
+static int SQLITE_TCLAPI sqlite3_mprintf_int(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int a[3], i;
   char *z;
   if( argc!=5 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FORMAT INT INT INT\"", 0);
     return TCL_ERROR;
   }
   for(i=2; i<5; i++){
     if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
   }
   z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
   Tcl_AppendResult(interp, z, 0);
   sqlite3_free(z);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_int64 FORMAT INTEGER INTEGER INTEGER
 **
 ** Call mprintf with three 64-bit integer arguments
 */
-static int sqlite3_mprintf_int64(
+static int SQLITE_TCLAPI sqlite3_mprintf_int64(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int i;
   sqlite_int64 a[3];
   char *z;
   if( argc!=5 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FORMAT INT INT INT\"", 0);
     return TCL_ERROR;
   }
   for(i=2; i<5; i++){
-    if( sqlite3Atoi64(argv[i], &a[i-2], 1000000, SQLITE_UTF8) ){
+    if( sqlite3Atoi64(argv[i], &a[i-2], sqlite3Strlen30(argv[i]), SQLITE_UTF8) ){
       Tcl_AppendResult(interp, "argument is not a valid 64-bit integer", 0);
       return TCL_ERROR;
     }
   }
   z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
   Tcl_AppendResult(interp, z, 0);
   sqlite3_free(z);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_long FORMAT INTEGER INTEGER INTEGER
 **
 ** Call mprintf with three long integer arguments.   This might be the
 ** same as sqlite3_mprintf_int or sqlite3_mprintf_int64, depending on
 ** platform.
 */
-static int sqlite3_mprintf_long(
+static int SQLITE_TCLAPI sqlite3_mprintf_long(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int i;
   long int a[3];
   int b[3];
   char *z;
   if( argc!=5 ){
@@ skipping 10 matching lines @@
   Tcl_AppendResult(interp, z, 0);
   sqlite3_free(z);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_str FORMAT INTEGER INTEGER STRING
 **
 ** Call mprintf with two integer arguments and one string argument
 */
-static int sqlite3_mprintf_str(
+static int SQLITE_TCLAPI sqlite3_mprintf_str(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int a[3], i;
   char *z;
   if( argc<4 || argc>5 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FORMAT INT INT ?STRING?\"", 0);
     return TCL_ERROR;
   }
   for(i=2; i<4; i++){
     if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
   }
   z = sqlite3_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL);
   Tcl_AppendResult(interp, z, 0);
   sqlite3_free(z);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_snprintf_str INTEGER FORMAT INTEGER INTEGER STRING
 **
 ** Call mprintf with two integer arguments and one string argument
 */
-static int sqlite3_snprintf_str(
+static int SQLITE_TCLAPI sqlite3_snprintf_str(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int a[3], i;
   int n;
   char *z;
   if( argc<5 || argc>6 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
@@ skipping 13 matching lines @@
   Tcl_AppendResult(interp, z, 0);
   sqlite3_free(z);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_double FORMAT INTEGER INTEGER DOUBLE
 **
 ** Call mprintf with two integer arguments and one double argument
 */
-static int sqlite3_mprintf_double(
+static int SQLITE_TCLAPI sqlite3_mprintf_double(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int a[3], i;
   double r;
   char *z;
   if( argc!=5 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
@@ skipping 10 matching lines @@
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_scaled FORMAT DOUBLE DOUBLE
 **
 ** Call mprintf with a single double argument which is the product of the
 ** two arguments given above.  This is used to generate overflow and underflow
 ** doubles to test that they are converted properly.
 */
-static int sqlite3_mprintf_scaled(
+static int SQLITE_TCLAPI sqlite3_mprintf_scaled(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   int i;
   double r[2];
   char *z;
   if( argc!=4 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FORMAT DOUBLE DOUBLE\"", 0);
     return TCL_ERROR;
   }
   for(i=2; i<4; i++){
     if( Tcl_GetDouble(interp, argv[i], &r[i-2]) ) return TCL_ERROR;
   }
   z = sqlite3_mprintf(argv[1], r[0]*r[1]);
   Tcl_AppendResult(interp, z, 0);
   sqlite3_free(z);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_stronly FORMAT STRING
 **
 ** Call mprintf with a single double argument which is the product of the
 ** two arguments given above.  This is used to generate overflow and underflow
 ** doubles to test that they are converted properly.
 */
-static int sqlite3_mprintf_stronly(
+static int SQLITE_TCLAPI sqlite3_mprintf_stronly(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   char *z;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " FORMAT STRING\"", 0);
     return TCL_ERROR;
   }
   z = sqlite3_mprintf(argv[1], argv[2]);
   Tcl_AppendResult(interp, z, 0);
   sqlite3_free(z);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_mprintf_hexdouble FORMAT HEX
 **
 ** Call mprintf with a single double argument which is derived from the
 ** hexadecimal encoding of an IEEE double.
 */
-static int sqlite3_mprintf_hexdouble(
+static int SQLITE_TCLAPI sqlite3_mprintf_hexdouble(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   char *z;
   double r;
   unsigned int x1, x2;
   sqlite_uint64 d;
   if( argc!=3 ){
@@ skipping 12 matching lines @@
   Tcl_AppendResult(interp, z, 0);
   sqlite3_free(z);
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_enable_shared_cache ?BOOLEAN?
 **
 */
 #if !defined(SQLITE_OMIT_SHARED_CACHE)
-static int test_enable_shared(
+static int SQLITE_TCLAPI test_enable_shared(
   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 *CONST objv[]  /* Command arguments */
 ){
   int rc;
   int enable;
   int ret = 0;
 
   if( objc!=2 && objc!=1 ){
@@ skipping 16 matching lines @@
   return TCL_OK;
 }
 #endif
 
 
 
 /*
 ** Usage: sqlite3_extended_result_codes   DB    BOOLEAN
 **
 */
-static int test_extended_result_codes(
+static int SQLITE_TCLAPI test_extended_result_codes(
   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 *CONST objv[]  /* Command arguments */
 ){
   int enable;
   sqlite3 *db;
 
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB BOOLEAN");
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   if( Tcl_GetBooleanFromObj(interp, objv[2], &enable) ) return TCL_ERROR;
   sqlite3_extended_result_codes(db, enable);
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_libversion_number
 **
 */
-static int test_libversion_number(
+static int SQLITE_TCLAPI test_libversion_number(
   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 *CONST objv[]  /* Command arguments */
 ){
   Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_libversion_number()));
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_table_column_metadata DB dbname tblname colname
 **
 */
-static int test_table_column_metadata(
+static int SQLITE_TCLAPI test_table_column_metadata(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   const char *zDb;
   const char *zTbl;
   const char *zCol;
   int rc;
@@ skipping 30 matching lines @@
   Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(notnull));
   Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(primarykey));
   Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(autoincrement));
   Tcl_SetObjResult(interp, pRet);
 
   return TCL_OK;
 }
 
 #ifndef SQLITE_OMIT_INCRBLOB
 
-static int blobHandleFromObj(
+static int SQLITE_TCLAPI blobHandleFromObj(
   Tcl_Interp *interp, 
   Tcl_Obj *pObj,
   sqlite3_blob **ppBlob
 ){
   char *z;
   int n;
 
   z = Tcl_GetStringFromObj(pObj, &n);
   if( n==0 ){
     *ppBlob = 0;
   }else{
     int notUsed;
     Tcl_Channel channel;
     ClientData instanceData;
     
     channel = Tcl_GetChannel(interp, z, &notUsed);
     if( !channel ) return TCL_ERROR;
 
     Tcl_Flush(channel);
     Tcl_Seek(channel, 0, SEEK_SET);
 
     instanceData = Tcl_GetChannelInstanceData(channel);
     *ppBlob = *((sqlite3_blob **)instanceData);
   }
 
   return TCL_OK;
 }
 
-static int test_blob_reopen(
+static int SQLITE_TCLAPI test_blob_reopen(
   ClientData clientData, /* Not used */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   Tcl_WideInt iRowid;
   sqlite3_blob *pBlob;
   int rc;
 
   if( objc!=3 ){
@@ skipping 55 matching lines @@
 
   if( TCL_OK!=Tcl_EvalObjEx(p->interp, pScript, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL)
    || TCL_OK!=Tcl_GetIntFromObj(p->interp, Tcl_GetObjResult(p->interp), &iRes)
   ){
     Tcl_BackgroundError(p->interp);
   }
   Tcl_DecrRefCount(pScript);
 
   return iRes;
 }
-static int test_create_collation_v2(
+static int SQLITE_TCLAPI test_create_collation_v2(
   ClientData clientData, /* Not used */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   TestCollationX *p;
   sqlite3 *db;
   int rc;
 
   if( objc!=5 ){
@@ skipping 54 matching lines @@
     int rc = Tcl_EvalObjEx(p->interp, p->pDestroy, 0);
     if( rc!=TCL_OK ) Tcl_BackgroundError(p->interp);
   }
 
   if( p->pFunc ) Tcl_DecrRefCount(p->pFunc); 
   if( p->pStep ) Tcl_DecrRefCount(p->pStep); 
   if( p->pFinal ) Tcl_DecrRefCount(p->pFinal); 
   if( p->pDestroy ) Tcl_DecrRefCount(p->pDestroy); 
   sqlite3_free(p);
 }
-static int test_create_function_v2(
+static int SQLITE_TCLAPI test_create_function_v2(
   ClientData clientData,          /* Not used */
   Tcl_Interp *interp,             /* The invoking TCL interpreter */
   int objc,                       /* Number of arguments */
   Tcl_Obj *CONST objv[]           /* Command arguments */
 ){
   sqlite3 *db;
   const char *zFunc;
   int nArg;
   int enc;
   CreateFunctionV2 *p;
@@ skipping 67 matching lines @@
     Tcl_ResetResult(interp);
     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_load_extension DB-HANDLE FILE ?PROC?
 */
-static int test_load_extension(
+static int SQLITE_TCLAPI test_load_extension(
   ClientData clientData, /* Not used */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   Tcl_CmdInfo cmdInfo;
   sqlite3 *db;
   int rc;
   char *zDb;
   char *zFile;
@@ skipping 18 matching lines @@
   db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
   assert(db);
 
   /* Call the underlying C function. If an error occurs, set rc to 
   ** TCL_ERROR and load any error string into the interpreter. If no 
   ** error occurs, set rc to TCL_OK.
   */
 #ifdef SQLITE_OMIT_LOAD_EXTENSION
   rc = SQLITE_ERROR;
   zErr = sqlite3_mprintf("this build omits sqlite3_load_extension()");
+  (void)zProc;
+  (void)zFile;
 #else
   rc = sqlite3_load_extension(db, zFile, zProc, &zErr);
 #endif
   if( rc!=SQLITE_OK ){
     Tcl_SetResult(interp, zErr ? zErr : "", TCL_VOLATILE);
     rc = TCL_ERROR;
   }else{
     rc = TCL_OK;
   }
   sqlite3_free(zErr);
 
   return rc;
 }
 
 /*
 ** Usage: sqlite3_enable_load_extension DB-HANDLE ONOFF
 */
-static int test_enable_load(
+static int SQLITE_TCLAPI test_enable_load(
   ClientData clientData, /* Not used */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   Tcl_CmdInfo cmdInfo;
   sqlite3 *db;
   char *zDb;
   int onoff;
 
@@ skipping 25 matching lines @@
 #endif
 }
 
 /*
 ** Usage:  sqlite_abort
 **
 ** Shutdown the process immediately.  This is not a clean shutdown.
 ** This command is used to test the recoverability of a database in
 ** the event of a program crash.
 */
-static int sqlite_abort(
+static int SQLITE_TCLAPI sqlite_abort(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
 #if defined(_MSC_VER)
   /* We do this, otherwise the test will halt with a popup message
    * that we have to click away before the test will continue.
    */
   _set_abort_behavior( 0, _CALL_REPORTFAULT );
@@ skipping 38 matching lines @@
 error_out:
   sqlite3_result_error(context,"first argument should be one of: "
       "int int64 string double null value", -1);
 }
 
 /*
 ** Usage:   sqlite_register_test_function  DB  NAME
 **
 ** Register the test SQL function on the database DB under the name NAME.
 */
-static int test_register_func(
+static int SQLITE_TCLAPI test_register_func(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3 *db;
   int rc;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
        " DB FUNCTION-NAME", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 
       testFunc, 0, 0);
   if( rc!=0 ){
     Tcl_AppendResult(interp, sqlite3ErrStr(rc), 0);
     return TCL_ERROR;
   }
   if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_finalize  STMT 
 **
 ** Finalize a statement handle.
 */
-static int test_finalize(
+static int SQLITE_TCLAPI test_finalize(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int rc;
   sqlite3 *db = 0;
 
   if( objc!=2 ){
@@ skipping 11 matching lines @@
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
   if( db && sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_stmt_status  STMT  CODE  RESETFLAG
 **
 ** Get the value of a status counter from a statement.
 */
-static int test_stmt_status(
+static int SQLITE_TCLAPI test_stmt_status(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int iValue;
   int i, op = 0, resetFlag;
   const char *zOpName;
   sqlite3_stmt *pStmt;
 
@@ skipping 24 matching lines @@
   if( Tcl_GetBooleanFromObj(interp, objv[3], &resetFlag) ) return TCL_ERROR;
   iValue = sqlite3_stmt_status(pStmt, op, resetFlag);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(iValue));
   return TCL_OK;
 }
 
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
 /*
 ** Usage:  sqlite3_stmt_scanstatus STMT IDX
 */
-static int test_stmt_scanstatus(
+static int SQLITE_TCLAPI test_stmt_scanstatus(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;            /* First argument */
   int idx;                        /* Second argument */
 
   const char *zName;
   const char *zExplain;
@@ skipping 29 matching lines @@
     Tcl_SetObjResult(interp, pRet);
   }else{
     Tcl_ResetResult(interp);
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_stmt_scanstatus_reset  STMT
 */
-static int test_stmt_scanstatus_reset(
+static int SQLITE_TCLAPI test_stmt_scanstatus_reset(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;            /* First argument */
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "STMT");
     return TCL_ERROR;
   }
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   sqlite3_stmt_scanstatus_reset(pStmt);
   return TCL_OK;
 }
 #endif
 
 #ifdef SQLITE_ENABLE_SQLLOG
 /*
 ** Usage:  sqlite3_config_sqllog
 **
 ** Zero the SQLITE_CONFIG_SQLLOG configuration
 */
-static int test_config_sqllog(
+static int SQLITE_TCLAPI test_config_sqllog(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "");
     return TCL_ERROR;
   }
   sqlite3_config(SQLITE_CONFIG_SQLLOG, 0, 0);
   return TCL_OK;
 }
 #endif
 
 /*
 ** Usage: vfs_current_time_int64
 **
 ** Return the value returned by the default VFS's xCurrentTimeInt64 method.
 */
-static int vfsCurrentTimeInt64(
+static int SQLITE_TCLAPI vfsCurrentTimeInt64(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   i64 t;
   sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "");
     return TCL_ERROR;
   }
   pVfs->xCurrentTimeInt64(pVfs, &t);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(t));
   return TCL_OK;
 }
 
 #ifdef SQLITE_ENABLE_SNAPSHOT
 /*
 ** Usage: sqlite3_snapshot_get DB DBNAME
 */
-static int test_snapshot_get(
+static int SQLITE_TCLAPI test_snapshot_get(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;
   sqlite3 *db;
   char *zName;
   sqlite3_snapshot *pSnapshot = 0;
 
@@ skipping 12 matching lines @@
     char zBuf[100];
     if( sqlite3TestMakePointerStr(interp, zBuf, pSnapshot) ) return TCL_ERROR;
     Tcl_SetObjResult(interp, Tcl_NewStringObj(zBuf, -1));
   }
   return TCL_OK;
 }
 #endif /* SQLITE_ENABLE_SNAPSHOT */
 
 #ifdef SQLITE_ENABLE_SNAPSHOT
 /*
+** Usage: sqlite3_snapshot_recover DB DBNAME
+*/
+static int SQLITE_TCLAPI test_snapshot_recover(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int rc;
+  sqlite3 *db;
+  char *zName;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zName = Tcl_GetString(objv[2]);
+
+  rc = sqlite3_snapshot_recover(db, zName);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
+    return TCL_ERROR;
+  }else{
+    Tcl_ResetResult(interp);
+  }
+  return TCL_OK;
+}
+#endif /* SQLITE_ENABLE_SNAPSHOT */
+
+#ifdef SQLITE_ENABLE_SNAPSHOT
+/*
 ** Usage: sqlite3_snapshot_open DB DBNAME SNAPSHOT
 */
-static int test_snapshot_open(
+static int SQLITE_TCLAPI test_snapshot_open(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;
   sqlite3 *db;
   char *zName;
   sqlite3_snapshot *pSnapshot;
 
@@ skipping 11 matching lines @@
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 #endif /* SQLITE_ENABLE_SNAPSHOT */
 
 #ifdef SQLITE_ENABLE_SNAPSHOT
 /*
 ** Usage: sqlite3_snapshot_free SNAPSHOT
 */
-static int test_snapshot_free(
+static int SQLITE_TCLAPI test_snapshot_free(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_snapshot *pSnapshot;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT");
     return TCL_ERROR;
   }
   pSnapshot = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
   sqlite3_snapshot_free(pSnapshot);
   return TCL_OK;
 }
 #endif /* SQLITE_ENABLE_SNAPSHOT */
 
+#ifdef SQLITE_ENABLE_SNAPSHOT
+/*
+** Usage: sqlite3_snapshot_cmp SNAPSHOT1 SNAPSHOT2
+*/
+static int SQLITE_TCLAPI test_snapshot_cmp(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int res;
+  sqlite3_snapshot *p1;
+  sqlite3_snapshot *p2;
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT1 SNAPSHOT2");
+    return TCL_ERROR;
+  }
+  p1 = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
+  p2 = (sqlite3_snapshot*)sqlite3TestTextToPtr(Tcl_GetString(objv[2]));
+  res = sqlite3_snapshot_cmp(p1, p2);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(res));
+  return TCL_OK;
+}
+#endif /* SQLITE_ENABLE_SNAPSHOT */
+
+#ifdef SQLITE_ENABLE_SNAPSHOT
+/*
+** Usage: sqlite3_snapshot_get_blob DB DBNAME
+*/
+static int SQLITE_TCLAPI test_snapshot_get_blob(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int rc;
+  sqlite3 *db;
+  char *zName;
+  sqlite3_snapshot *pSnapshot = 0;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zName = Tcl_GetString(objv[2]);
+
+  rc = sqlite3_snapshot_get(db, zName, &pSnapshot);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
+    return TCL_ERROR;
+  }else{
+    Tcl_SetObjResult(interp, 
+        Tcl_NewByteArrayObj((unsigned char*)pSnapshot, sizeof(sqlite3_snapshot))
+    );
+    sqlite3_snapshot_free(pSnapshot);
+  }
+  return TCL_OK;
+}
+#endif /* SQLITE_ENABLE_SNAPSHOT */
+
+#ifdef SQLITE_ENABLE_SNAPSHOT
+  /*
+  ** Usage: sqlite3_snapshot_open_blob DB DBNAME SNAPSHOT
+*/
+static int SQLITE_TCLAPI test_snapshot_open_blob(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int rc;
+  sqlite3 *db;
+  char *zName;
+  unsigned char *pBlob;
+  int nBlob;
+
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SNAPSHOT");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zName = Tcl_GetString(objv[2]);
+  pBlob = Tcl_GetByteArrayFromObj(objv[3], &nBlob);
+  if( nBlob!=sizeof(sqlite3_snapshot) ){
+    Tcl_AppendResult(interp, "bad SNAPSHOT", 0);
+    return TCL_ERROR;
+  }
+  rc = sqlite3_snapshot_open(db, zName, (sqlite3_snapshot*)pBlob);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+#endif /* SQLITE_ENABLE_SNAPSHOT */
+
+#ifdef SQLITE_ENABLE_SNAPSHOT
+/*
+** Usage: sqlite3_snapshot_cmp_blob SNAPSHOT1 SNAPSHOT2
+*/
+static int SQLITE_TCLAPI test_snapshot_cmp_blob(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int res;
+  unsigned char *p1;
+  unsigned char *p2;
+  int n1;
+  int n2;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "SNAPSHOT1 SNAPSHOT2");
+    return TCL_ERROR;
+  }
+
+  p1 = Tcl_GetByteArrayFromObj(objv[1], &n1);
+  p2 = Tcl_GetByteArrayFromObj(objv[2], &n2);
+
+  if( n1!=sizeof(sqlite3_snapshot) || n1!=n2 ){
+    Tcl_AppendResult(interp, "bad SNAPSHOT", 0);
+    return TCL_ERROR;
+  }
+
+  res = sqlite3_snapshot_cmp((sqlite3_snapshot*)p1, (sqlite3_snapshot*)p2);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(res));
+  return TCL_OK;
+}
+#endif /* SQLITE_ENABLE_SNAPSHOT */
+
+/*
+** Usage: sqlite3_delete_database FILENAME
+*/
+int sqlite3_delete_database(const char*);   /* in test_delete.c */
+static int SQLITE_TCLAPI test_delete_database(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int rc;
+  const char *zFile;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "FILE");
+    return TCL_ERROR;
+  }
+  zFile = (const char*)Tcl_GetString(objv[1]);
+  rc = sqlite3_delete_database(zFile);
+
+  Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
+  return TCL_OK;
+}
+
 /*
 ** Usage:  sqlite3_next_stmt  DB  STMT
 **
 ** Return the next statment in sequence after STMT.
 */
-static int test_next_stmt(
+static int SQLITE_TCLAPI test_next_stmt(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   sqlite3 *db = 0;
   char zBuf[50];
 
   if( objc!=3 ){
@@ skipping 11 matching lines @@
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_stmt_readonly  STMT
 **
 ** Return true if STMT is a NULL pointer or a pointer to a statement
 ** that is guaranteed to leave the database unmodified.
 */
-static int test_stmt_readonly(
+static int SQLITE_TCLAPI test_stmt_readonly(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int rc;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
         Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   rc = sqlite3_stmt_readonly(pStmt);
   Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc));
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_stmt_busy  STMT
 **
 ** Return true if STMT is a non-NULL pointer to a statement
 ** that has been stepped but not to completion.
 */
-static int test_stmt_busy(
+static int SQLITE_TCLAPI test_stmt_busy(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int rc;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
         Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   rc = sqlite3_stmt_busy(pStmt);
   Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc));
   return TCL_OK;
 }
 
 /*
 ** Usage:  uses_stmt_journal  STMT
 **
 ** Return true if STMT uses a statement journal.
 */
-static int uses_stmt_journal(
+static int SQLITE_TCLAPI uses_stmt_journal(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
         Tcl_GetStringFromObj(objv[0], 0), " STMT", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   sqlite3_stmt_readonly(pStmt);
   Tcl_SetObjResult(interp, Tcl_NewBooleanObj(((Vdbe *)pStmt)->usesStmtJournal));
   return TCL_OK;
 }
 
 
 /*
 ** Usage:  sqlite3_reset  STMT 
 **
 ** Reset a statement handle.
 */
-static int test_reset(
+static int SQLITE_TCLAPI test_reset(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int rc;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
@@ skipping 14 matching lines @@
   }
 */
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_expired STMT 
 **
 ** Return TRUE if a recompilation of the statement is recommended.
 */
-static int test_expired(
+static int SQLITE_TCLAPI test_expired(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_DEPRECATED
   sqlite3_stmt *pStmt;
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
         Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
     return TCL_ERROR;
   }
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   Tcl_SetObjResult(interp, Tcl_NewBooleanObj(sqlite3_expired(pStmt)));
 #endif
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_transfer_bindings FROMSTMT TOSTMT
 **
 ** Transfer all bindings from FROMSTMT over to TOSTMT
 */
-static int test_transfer_bind(
+static int SQLITE_TCLAPI test_transfer_bind(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_DEPRECATED
   sqlite3_stmt *pStmt1, *pStmt2;
   if( objc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
         Tcl_GetStringFromObj(objv[0], 0), " FROM-STMT TO-STMT", 0);
     return TCL_ERROR;
   }
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt1)) return TCL_ERROR;
   if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt2)) return TCL_ERROR;
   Tcl_SetObjResult(interp, 
      Tcl_NewIntObj(sqlite3_transfer_bindings(pStmt1,pStmt2)));
 #endif
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_changes DB
 **
 ** Return the number of changes made to the database by the last SQL
 ** execution.
 */
-static int test_changes(
+static int SQLITE_TCLAPI test_changes(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
        Tcl_GetString(objv[0]), " DB", 0);
     return TCL_ERROR;
@@ skipping 14 matching lines @@
 ** Usage:  sqlite3_bind  VM  IDX  VALUE  FLAGS
 **
 ** Sets the value of the IDX-th occurrence of "?" in the original SQL
 ** string.  VALUE is the new value.  If FLAGS=="null" then VALUE is
 ** ignored and the value is set to NULL.  If FLAGS=="static" then
 ** the value is set to the value of a static variable named
 ** "sqlite_static_bind_value".  If FLAGS=="normal" then a copy
 ** of the VALUE is made.  If FLAGS=="blob10" then a VALUE is ignored
 ** an a 10-byte blob "abc\000xyz\000pq" is inserted.
 */
-static int test_bind(
+static int SQLITE_TCLAPI test_bind(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   sqlite3_stmt *pStmt;
   int rc;
   int idx;
   if( argc!=5 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
@@ skipping 101 matching lines @@
         Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
     sqlite3ValueFree(pVal);
   }
   sqlite3EndBenignMalloc();
 
   Tcl_EvalObjEx(i, pX, 0);
   Tcl_DecrRefCount(pX);
   Tcl_GetIntFromObj(i, Tcl_GetObjResult(i), &res);
   return res;
 }
-static int test_collate(
+static int SQLITE_TCLAPI test_collate(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   int val;
   sqlite3_value *pVal;
   int rc;
 
@@ skipping 53 matching lines @@
 static int test_utf16bin_collate_func(
   void *pCtx, 
   int nA, const void *zA,
   int nB, const void *zB
 ){
   int nCmp = (nA>nB ? nB : nA);
   int res = memcmp(zA, zB, nCmp);
   if( res==0 ) res = nA - nB;
   return res;
 }
-static int test_utf16bin_collate(
+static int SQLITE_TCLAPI test_utf16bin_collate(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   int rc;
 
   if( objc!=2 ) goto bad_args;
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
@@ skipping 36 matching lines @@
     if( *z ) zNeededCollation[i++] = *z;
   }
   zNeededCollation[i] = 0;
   sqlite3_create_collation(
       db, "test_collate", ENC(db), SQLITE_INT_TO_PTR(enc), test_collate_func);
 }
 
 /*
 ** Usage: add_test_collate_needed DB
 */
-static int test_collate_needed(
+static int SQLITE_TCLAPI test_collate_needed(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   int rc;
 
   if( objc!=2 ) goto bad_args;
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
@@ skipping 30 matching lines @@
   int rc, n;
   n = nKey1<nKey2 ? nKey1 : nKey2;
   if( nKey1>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey1))) ) unaligned_string_counter++;
   if( nKey2>0 && 1==(1&(SQLITE_PTR_TO_INT(pKey2))) ) unaligned_string_counter++;
   rc = memcmp(pKey1, pKey2, n);
   if( rc==0 ){
     rc = nKey1 - nKey2;
   }
   return rc;
 }
-static int add_alignment_test_collations(
+static int SQLITE_TCLAPI add_alignment_test_collations(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   if( objc>=2 ){
     if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
     sqlite3_create_collation(db, "utf16_unaligned", SQLITE_UTF16, 
         0, alignmentCollFunc);
@@ skipping 97 matching lines @@
       SQLITE_UTF8, SQLITE_STATIC);
   sqlite3_result_text16(pCtx, sqlite3_value_text16le(pVal),
       -1, SQLITE_TRANSIENT);
   sqlite3_result_text16be(pCtx, sqlite3_value_text16le(pVal),
       -1, SQLITE_TRANSIENT);
   sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal),
       -1, SQLITE_TRANSIENT);
   sqlite3ValueFree(pVal);
 }
 #endif /* SQLITE_OMIT_UTF16 */
-static int test_function(
+static int SQLITE_TCLAPI test_function(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_UTF16
   sqlite3 *db;
   int val;
 
   if( objc!=5 ) goto bad_args;
@@ skipping 24 matching lines @@
 }
 
 /*
 ** Usage:         sqlite3_test_errstr <err code>
 **
 ** Test that the english language string equivalents for sqlite error codes
 ** are sane. The parameter is an integer representing an sqlite error code.
 ** The result is a list of two elements, the string representation of the
 ** error code and the english language explanation.
 */
-static int test_errstr(
+static int SQLITE_TCLAPI test_errstr(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   char *zCode;
   int i;
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "<error code>");
   }
@@ skipping 12 matching lines @@
 ** This routine exists for one purpose - to provide a place to put a
 ** breakpoint with GDB that can be triggered using TCL code.  The use
 ** for this is when a particular test fails on (say) the 1485th iteration.
 ** In the TCL test script, we can add code like this:
 **
 **     if {$i==1485} breakpoint
 **
 ** Then run testfixture in the debugger and wait for the breakpoint to
 ** fire.  Then additional breakpoints can be set to trace down the bug.
 */
-static int test_breakpoint(
+static int SQLITE_TCLAPI test_breakpoint(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   char **argv            /* Text of each argument */
 ){
   return TCL_OK;         /* Do nothing */
 }
 
 /*
 ** Usage:   sqlite3_bind_zeroblob  STMT IDX N
 **
 ** Test the sqlite3_bind_zeroblob interface.  STMT is a prepared statement.
 ** IDX is the index of a wildcard in the prepared statement.  This command
 ** binds a N-byte zero-filled BLOB to the wildcard.
 */
-static int test_bind_zeroblob(
+static int SQLITE_TCLAPI test_bind_zeroblob(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int idx;
   int n;
   int rc;
 
@@ skipping 15 matching lines @@
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_bind_zeroblob64  STMT IDX N
 **
 ** Test the sqlite3_bind_zeroblob64 interface.  STMT is a prepared statement.
 ** IDX is the index of a wildcard in the prepared statement.  This command
 ** binds a N-byte zero-filled BLOB to the wildcard.
 */
-static int test_bind_zeroblob64(
+static int SQLITE_TCLAPI test_bind_zeroblob64(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int idx;
-  i64 n;
+  Tcl_WideInt n;
   int rc;
 
   if( objc!=4 ){
     Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N");
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
   if( Tcl_GetWideIntFromObj(interp, objv[3], &n) ) return TCL_ERROR;
 
   rc = sqlite3_bind_zeroblob64(pStmt, idx, n);
   if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
   if( rc!=SQLITE_OK ){
     Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
     return TCL_ERROR;
   }
 
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_bind_int  STMT N VALUE
 **
 ** Test the sqlite3_bind_int interface.  STMT is a prepared statement.
 ** N is the index of a wildcard in the prepared statement.  This command
 ** binds a 32-bit integer VALUE to that wildcard.
 */
-static int test_bind_int(
+static int SQLITE_TCLAPI test_bind_int(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int idx;
   int value;
   int rc;
 
@@ skipping 11 matching lines @@
   if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
   if( rc!=SQLITE_OK ){
     return TCL_ERROR;
   }
 
   return TCL_OK;
 }
 
 
 /*
+** Usage:   intarray_addr  INT  ...
+**
+** Return the address of a C-language array of 32-bit integers.
+**
+** Space to hold the array is obtained from malloc().  Call this procedure once
+** with no arguments in order to release memory.  Each call to this procedure
+** overwrites the previous array.
+*/
+static int SQLITE_TCLAPI test_intarray_addr(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int i;
+  static int *p = 0;
+
+  sqlite3_free(p);
+  p = 0;
+  if( objc>1 ){
+    p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
+    if( p==0 ) return TCL_ERROR;
+    for(i=0; i<objc-1; i++){
+      if( Tcl_GetIntFromObj(interp, objv[1+i], &p[i]) ){
+        sqlite3_free(p);
+        p = 0;
+        return TCL_ERROR;
+      }
+    }
+  }  
+  Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
+  return TCL_OK;
+}
+/*
+** Usage:   intarray_addr  INT  ...
+**
+** Return the address of a C-language array of 32-bit integers.
+**
+** Space to hold the array is obtained from malloc().  Call this procedure once
+** with no arguments in order to release memory.  Each call to this procedure
+** overwrites the previous array.
+*/
+static int SQLITE_TCLAPI test_int64array_addr(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int i;
+  static sqlite3_int64 *p = 0;
+
+  sqlite3_free(p);
+  p = 0;
+  if( objc>1 ){
+    p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
+    if( p==0 ) return TCL_ERROR;
+    for(i=0; i<objc-1; i++){
+      Tcl_WideInt v;
+      if( Tcl_GetWideIntFromObj(interp, objv[1+i], &v) ){
+        sqlite3_free(p);
+        p = 0;
+        return TCL_ERROR;
+      }
+      p[i] = v;
+    }
+  }  
+  Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
+  return TCL_OK;
+}
+/*
+** Usage:   doublearray_addr  INT  ...
+**
+** Return the address of a C-language array of doubles.
+**
+** Space to hold the array is obtained from malloc().  Call this procedure once
+** with no arguments in order to release memory.  Each call to this procedure
+** overwrites the previous array.
+*/
+static int SQLITE_TCLAPI test_doublearray_addr(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int i;
+  static double *p = 0;
+
+  sqlite3_free(p);
+  p = 0;
+  if( objc>1 ){
+    p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
+    if( p==0 ) return TCL_ERROR;
+    for(i=0; i<objc-1; i++){
+      if( Tcl_GetDoubleFromObj(interp, objv[1+i], &p[i]) ){
+        sqlite3_free(p);
+        p = 0;
+        return TCL_ERROR;
+      }
+    }
+  }  
+  Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
+  return TCL_OK;
+}
+/*
+** Usage:   textarray_addr  TEXT ...
+**
+** Return the address of a C-language array of strings.
+**
+** Space to hold the array is obtained from malloc().  Call this procedure once
+** with no arguments in order to release memory.  Each call to this procedure
+** overwrites the previous array.
+*/
+static int SQLITE_TCLAPI test_textarray_addr(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int i;
+  static int n = 0;
+  static char **p = 0;
+
+  for(i=0; i<n; i++) sqlite3_free(p[i]);
+  sqlite3_free(p);
+  p = 0;
+  if( objc>1 ){
+    p = sqlite3_malloc( sizeof(p[0])*(objc-1) );
+    if( p==0 ) return TCL_ERROR;
+    for(i=0; i<objc-1; i++){
+      p[i] = sqlite3_mprintf("%s", Tcl_GetString(objv[1+i]));
+    }
+  }
+  n = objc-1;
+  Tcl_SetObjResult(interp, Tcl_NewWideIntObj((sqlite3_int64)p));
+  return TCL_OK;
+}
+
+
+/*
 ** Usage:   sqlite3_bind_int64  STMT N VALUE
 **
 ** Test the sqlite3_bind_int64 interface.  STMT is a prepared statement.
 ** N is the index of a wildcard in the prepared statement.  This command
 ** binds a 64-bit integer VALUE to that wildcard.
 */
-static int test_bind_int64(
+static int SQLITE_TCLAPI test_bind_int64(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int idx;
   Tcl_WideInt value;
   int rc;
 
@@ skipping 17 matching lines @@
 }
 
 
 /*
 ** Usage:   sqlite3_bind_double  STMT N VALUE
 **
 ** Test the sqlite3_bind_double interface.  STMT is a prepared statement.
 ** N is the index of a wildcard in the prepared statement.  This command
 ** binds a 64-bit integer VALUE to that wildcard.
 */
-static int test_bind_double(
+static int SQLITE_TCLAPI test_bind_double(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int idx;
   double value = 0;
   int rc;
   const char *zVal;
@@ skipping 55 matching lines @@
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_bind_null  STMT N
 **
 ** Test the sqlite3_bind_null interface.  STMT is a prepared statement.
 ** N is the index of a wildcard in the prepared statement.  This command
 ** binds a NULL to the wildcard.
 */
-static int test_bind_null(
+static int SQLITE_TCLAPI test_bind_null(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int idx;
   int rc;
 
   if( objc!=3 ){
@@ skipping 15 matching lines @@
 }
 
 /*
 ** Usage:   sqlite3_bind_text  STMT N STRING BYTES
 **
 ** Test the sqlite3_bind_text interface.  STMT is a prepared statement.
 ** N is the index of a wildcard in the prepared statement.  This command
 ** binds a UTF-8 string STRING to the wildcard.  The string is BYTES bytes
 ** long.
 */
-static int test_bind_text(
+static int SQLITE_TCLAPI test_bind_text(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int idx;
   int bytes;
   char *value;
   int rc;
@@ skipping 20 matching lines @@
 }
 
 /*
 ** Usage:   sqlite3_bind_text16 ?-static? STMT N STRING BYTES
 **
 ** Test the sqlite3_bind_text16 interface.  STMT is a prepared statement.
 ** N is the index of a wildcard in the prepared statement.  This command
 ** binds a UTF-16 string STRING to the wildcard.  The string is BYTES bytes
 ** long.
 */
-static int test_bind_text16(
+static int SQLITE_TCLAPI test_bind_text16(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_UTF16
   sqlite3_stmt *pStmt;
   int idx;
   int bytes;
   char *value;
@@ skipping 27 matching lines @@
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_bind_blob ?-static? STMT N DATA BYTES
 **
 ** Test the sqlite3_bind_blob interface.  STMT is a prepared statement.
 ** N is the index of a wildcard in the prepared statement.  This command
 ** binds a BLOB to the wildcard.  The BLOB is BYTES bytes in size.
 */
-static int test_bind_blob(
+static int SQLITE_TCLAPI test_bind_blob(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
-  int idx;
+  int len, idx;
   int bytes;
   char *value;
   int rc;
   sqlite3_destructor_type xDestructor = SQLITE_TRANSIENT;
 
   if( objc!=5 && objc!=6 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
         Tcl_GetStringFromObj(objv[0], 0), " STMT N DATA BYTES", 0);
     return TCL_ERROR;
   }
 
   if( objc==6 ){
     xDestructor = SQLITE_STATIC;
     objv++;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
-  value = Tcl_GetString(objv[3]);
+
+  value = (char*)Tcl_GetByteArrayFromObj(objv[3], &len);
   if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR;
 
+  if( bytes>len ){
+    char zBuf[200];
+    sqlite3_snprintf(sizeof(zBuf), zBuf,
+                     "cannot use %d blob bytes, have %d", bytes, len);
+    Tcl_AppendResult(interp, zBuf, -1);
+    return TCL_ERROR;
+  }
+
   rc = sqlite3_bind_blob(pStmt, idx, value, bytes, xDestructor);
   if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
   if( rc!=SQLITE_OK ){
     return TCL_ERROR;
   }
 
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_bind_parameter_count  STMT
 **
 ** Return the number of wildcards in the given statement.
 */
-static int test_bind_parameter_count(
+static int SQLITE_TCLAPI test_bind_parameter_count(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "STMT");
     return TCL_ERROR;
   }
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_bind_parameter_count(pStmt)));
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_bind_parameter_name  STMT  N
 **
 ** Return the name of the Nth wildcard.  The first wildcard is 1.
 ** An empty string is returned if N is out of range or if the wildcard
 ** is nameless.
 */
-static int test_bind_parameter_name(
+static int SQLITE_TCLAPI test_bind_parameter_name(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int i;
 
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "STMT N");
     return TCL_ERROR;
   }
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &i) ) return TCL_ERROR;
   Tcl_SetObjResult(interp, 
      Tcl_NewStringObj(sqlite3_bind_parameter_name(pStmt,i),-1)
   );
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_bind_parameter_index  STMT  NAME
 **
 ** Return the index of the wildcard called NAME.  Return 0 if there is
 ** no such wildcard.
 */
-static int test_bind_parameter_index(
+static int SQLITE_TCLAPI test_bind_parameter_index(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
 
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "STMT NAME");
     return TCL_ERROR;
   }
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   Tcl_SetObjResult(interp, 
      Tcl_NewIntObj(
        sqlite3_bind_parameter_index(pStmt,Tcl_GetString(objv[2]))
      )
   );
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_clear_bindings STMT
 **
 */
-static int test_clear_bindings(
+static int SQLITE_TCLAPI test_clear_bindings(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "STMT");
     return TCL_ERROR;
   }
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(pStmt)));
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_sleep MILLISECONDS
 */
-static int test_sleep(
+static int SQLITE_TCLAPI test_sleep(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int ms;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "MILLISECONDS");
     return TCL_ERROR;
   }
   if( Tcl_GetIntFromObj(interp, objv[1], &ms) ){
     return TCL_ERROR;
   }
   Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_sleep(ms)));
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_extended_errcode DB
 **
 ** Return the string representation of the most recent sqlite3_* API
 ** error code. e.g. "SQLITE_ERROR".
 */
-static int test_ex_errcode(
+static int SQLITE_TCLAPI test_ex_errcode(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   int rc;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " DB", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   rc = sqlite3_extended_errcode(db);
   Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0);
   return TCL_OK;
 }
 
 
 /*
 ** Usage: sqlite3_errcode DB
 **
 ** Return the string representation of the most recent sqlite3_* API
 ** error code. e.g. "SQLITE_ERROR".
 */
-static int test_errcode(
+static int SQLITE_TCLAPI test_errcode(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   int rc;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " DB", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   rc = sqlite3_errcode(db);
   Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0);
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_errmsg DB
 **
 ** Returns the UTF-8 representation of the error message string for the
 ** most recent sqlite3_* API call.
 */
-static int test_errmsg(
+static int SQLITE_TCLAPI test_errmsg(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   const char *zErr;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " DB", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
 
   zErr = sqlite3_errmsg(db);
   Tcl_SetObjResult(interp, Tcl_NewStringObj(zErr, -1));
   return TCL_OK;
 }
 
 /*
 ** Usage:   test_errmsg16 DB
 **
 ** Returns the UTF-16 representation of the error message string for the
 ** most recent sqlite3_* API call. This is a byte array object at the TCL 
 ** level, and it includes the 0x00 0x00 terminator bytes at the end of the
 ** UTF-16 string.
 */
-static int test_errmsg16(
+static int SQLITE_TCLAPI test_errmsg16(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_UTF16
   sqlite3 *db;
   const void *zErr;
   const char *z;
   int bytes = 0;
@@ skipping 16 matching lines @@
 }
 
 /*
 ** Usage: sqlite3_prepare DB sql bytes ?tailvar?
 **
 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
 ** database handle <DB>. The parameter <tailval> is the name of a global
 ** variable that is set to the unused portion of <sql> (if any). A
 ** STMT handle is returned.
 */
-static int test_prepare(
+static int SQLITE_TCLAPI test_prepare(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   const char *zSql;
   int bytes;
   const char *zTail = 0;
   sqlite3_stmt *pStmt = 0;
@@ skipping 36 matching lines @@
 }
 
 /*
 ** Usage: sqlite3_prepare_v2 DB sql bytes ?tailvar?
 **
 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
 ** database handle <DB>. The parameter <tailval> is the name of a global
 ** variable that is set to the unused portion of <sql> (if any). A
 ** STMT handle is returned.
 */
-static int test_prepare_v2(
+static int SQLITE_TCLAPI test_prepare_v2(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   const char *zSql;
   char *zCopy = 0;                /* malloc() copy of zSql */
   int bytes;
   const char *zTail = 0;
@@ skipping 47 matching lines @@
   }
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_prepare_tkt3134 DB
 **
 ** Generate a prepared statement for a zero-byte string as a test
 ** for ticket #3134.  The string should be preceded by a zero byte.
 */
-static int test_prepare_tkt3134(
+static int SQLITE_TCLAPI test_prepare_tkt3134(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   static const char zSql[] = "\000SELECT 1";
   sqlite3_stmt *pStmt = 0;
   char zBuf[50];
   int rc;
@@ skipping 22 matching lines @@
 }
 
 /*
 ** Usage: sqlite3_prepare16 DB sql bytes tailvar
 **
 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
 ** database handle <DB>. The parameter <tailval> is the name of a global
 ** variable that is set to the unused portion of <sql> (if any). A
 ** STMT handle is returned.
 */
-static int test_prepare16(
+static int SQLITE_TCLAPI test_prepare16(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_UTF16
   sqlite3 *db;
   const void *zSql;
   const void *zTail = 0;
   Tcl_Obj *pTail = 0;
@@ skipping 39 matching lines @@
 }
 
 /*
 ** Usage: sqlite3_prepare16_v2 DB sql bytes ?tailvar?
 **
 ** Compile up to <bytes> bytes of the supplied SQL string <sql> using
 ** database handle <DB>. The parameter <tailval> is the name of a global
 ** variable that is set to the unused portion of <sql> (if any). A
 ** STMT handle is returned.
 */
-static int test_prepare16_v2(
+static int SQLITE_TCLAPI test_prepare16_v2(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_UTF16
   sqlite3 *db;
   const void *zSql;
   const void *zTail = 0;
   Tcl_Obj *pTail = 0;
@@ skipping 34 matching lines @@
     if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
   }
   Tcl_AppendResult(interp, zBuf, 0);
 #endif /* SQLITE_OMIT_UTF16 */
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_open filename ?options-list?
 */
-static int test_open(
+static int SQLITE_TCLAPI test_open(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zFilename;
   sqlite3 *db;
   char zBuf[100];
 
   if( objc!=3 && objc!=2 && objc!=1 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " filename options-list", 0);
     return TCL_ERROR;
   }
 
   zFilename = objc>1 ? Tcl_GetString(objv[1]) : 0;
   sqlite3_open(zFilename, &db);
   
   if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
   Tcl_AppendResult(interp, zBuf, 0);
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_open_v2 FILENAME FLAGS VFS
 */
-static int test_open_v2(
+static int SQLITE_TCLAPI test_open_v2(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zFilename;
   const char *zVfs;
   int flags = 0;
   sqlite3 *db;
   int rc;
@@ skipping 49 matching lines @@
 
   rc = sqlite3_open_v2(zFilename, &db, flags, zVfs);
   if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
   Tcl_AppendResult(interp, zBuf, 0);
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_open16 filename options
 */
-static int test_open16(
+static int SQLITE_TCLAPI test_open16(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_UTF16
   const void *zFilename;
   sqlite3 *db;
   char zBuf[100];
 
@@ skipping 11 matching lines @@
 #endif /* SQLITE_OMIT_UTF16 */
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_complete16 <UTF-16 string>
 **
 ** Return 1 if the supplied argument is a complete SQL statement, or zero
 ** otherwise.
 */
-static int test_complete16(
+static int SQLITE_TCLAPI test_complete16(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #if !defined(SQLITE_OMIT_COMPLETE) && !defined(SQLITE_OMIT_UTF16)
   char *zBuf;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "<utf-16 sql>");
     return TCL_ERROR;
   }
 
   zBuf = (char*)Tcl_GetByteArrayFromObj(objv[1], 0);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_complete16(zBuf)));
 #endif /* SQLITE_OMIT_COMPLETE && SQLITE_OMIT_UTF16 */
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_step STMT
 **
 ** Advance the statement to the next row.
 */
-static int test_step(
+static int SQLITE_TCLAPI test_step(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int rc;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " STMT", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   rc = sqlite3_step(pStmt);
 
   /* if( rc!=SQLITE_DONE && rc!=SQLITE_ROW ) return TCL_ERROR; */
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
   return TCL_OK;
 }
 
-static int test_sql(
+static int SQLITE_TCLAPI test_sql(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "STMT");
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   Tcl_SetResult(interp, (char *)sqlite3_sql(pStmt), TCL_VOLATILE);
   return TCL_OK;
 }
+static int SQLITE_TCLAPI test_ex_sql(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  char *z;
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "STMT");
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  z = sqlite3_expanded_sql(pStmt);
+  Tcl_SetResult(interp, z, TCL_VOLATILE);
+  sqlite3_free(z);
+  return TCL_OK;
+}
 
 /*
 ** Usage: sqlite3_column_count STMT 
 **
 ** Return the number of columns returned by the sql statement STMT.
 */
-static int test_column_count(
+static int SQLITE_TCLAPI test_column_count(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " STMT column", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
 
   Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_column_count(pStmt)));
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_column_type STMT column
 **
 ** Return the type of the data in column 'column' of the current row.
 */
-static int test_column_type(
+static int SQLITE_TCLAPI test_column_type(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int col;
   int tp;
 
   if( objc!=3 ){
@@ skipping 28 matching lines @@
 
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_column_int64 STMT column
 **
 ** Return the data in column 'column' of the current row cast as an
 ** wide (64-bit) integer.
 */
-static int test_column_int64(
+static int SQLITE_TCLAPI test_column_int64(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int col;
   i64 iVal;
 
   if( objc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " STMT column", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
 
   iVal = sqlite3_column_int64(pStmt, col);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(iVal));
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_column_blob STMT column
 */
-static int test_column_blob(
+static int SQLITE_TCLAPI test_column_blob(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int col;
 
   int len;
   const void *pBlob;
@@ skipping 11 matching lines @@
   pBlob = sqlite3_column_blob(pStmt, col);
   Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pBlob, len));
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_column_double STMT column
 **
 ** Return the data in column 'column' of the current row cast as a double.
 */
-static int test_column_double(
+static int SQLITE_TCLAPI test_column_double(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int col;
   double rVal;
 
   if( objc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " STMT column", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
 
   rVal = sqlite3_column_double(pStmt, col);
   Tcl_SetObjResult(interp, Tcl_NewDoubleObj(rVal));
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_data_count STMT 
 **
 ** Return the number of columns returned by the sql statement STMT.
 */
-static int test_data_count(
+static int SQLITE_TCLAPI test_data_count(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
 
   if( objc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " STMT column", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
 
   Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_data_count(pStmt)));
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_column_text STMT column
 **
 ** Usage: sqlite3_column_decltype STMT column
 **
 ** Usage: sqlite3_column_name STMT column
 */
-static int test_stmt_utf8(
+static int SQLITE_TCLAPI test_stmt_utf8(
   void * clientData,        /* Pointer to SQLite API function to be invoke */
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int col;
   const char *(*xFunc)(sqlite3_stmt*, int);
   const char *zRet;
 
   xFunc = (const char *(*)(sqlite3_stmt*, int))clientData;
   if( objc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " STMT column", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
   zRet = xFunc(pStmt, col);
   if( zRet ){
     Tcl_SetResult(interp, (char *)zRet, 0);
   }
   return TCL_OK;
 }
 
-static int test_global_recover(
+static int SQLITE_TCLAPI test_global_recover(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_DEPRECATED
   int rc;
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "");
     return TCL_ERROR;
   }
   rc = sqlite3_global_recover();
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
 #endif
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_column_text STMT column
 **
 ** Usage: sqlite3_column_decltype STMT column
 **
 ** Usage: sqlite3_column_name STMT column
 */
-static int test_stmt_utf16(
+static int SQLITE_TCLAPI test_stmt_utf16(
   void * clientData,     /* Pointer to SQLite API function to be invoked */
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_UTF16
   sqlite3_stmt *pStmt;
   int col;
   Tcl_Obj *pRet;
   const void *zName16;
@@ skipping 23 matching lines @@
 }
 
 /*
 ** Usage: sqlite3_column_int STMT column
 **
 ** Usage: sqlite3_column_bytes STMT column
 **
 ** Usage: sqlite3_column_bytes16 STMT column
 **
 */
-static int test_stmt_int(
+static int SQLITE_TCLAPI test_stmt_int(
   void * clientData,    /* Pointer to SQLite API function to be invoked */
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_stmt *pStmt;
   int col;
   int (*xFunc)(sqlite3_stmt*, int);
 
   xFunc = (int (*)(sqlite3_stmt*, int))clientData;
   if( objc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", 
        Tcl_GetString(objv[0]), " STMT column", 0);
     return TCL_ERROR;
   }
 
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
 
   Tcl_SetObjResult(interp, Tcl_NewIntObj(xFunc(pStmt, col)));
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite_set_magic  DB  MAGIC-NUMBER
 **
 ** Set the db->magic value.  This is used to test error recovery logic.
 */
-static int sqlite_set_magic(
+static int SQLITE_TCLAPI sqlite_set_magic(
   void * clientData,
   Tcl_Interp *interp,
   int argc,
   char **argv
 ){
   sqlite3 *db;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
          " DB MAGIC", 0);
     return TCL_ERROR;
@@ skipping 11 matching lines @@
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_interrupt  DB 
 **
 ** Trigger an interrupt on DB
 */
-static int test_interrupt(
+static int SQLITE_TCLAPI test_interrupt(
   void * clientData,
   Tcl_Interp *interp,
   int argc,
   char **argv
 ){
   sqlite3 *db;
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB", 0);
     return TCL_ERROR;
   }
@@ skipping 20 matching lines @@
 u64 sqlite3StackDepth(void){
   u8 x;
   return (u64)(sqlite3_stack_baseline - &x);
 }
 
 /*
 ** Usage:  sqlite3_stack_used DB SQL
 **
 ** Try to measure the amount of stack space used by a call to sqlite3_exec
 */
-static int test_stack_used(
+static int SQLITE_TCLAPI test_stack_used(
   void * clientData,
   Tcl_Interp *interp,
   int argc,
   char **argv
 ){
   sqlite3 *db;
   int i;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
         " DB SQL", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   prepStack();
   (void)sqlite3_exec(db, argv[2], 0, 0, 0);
   for(i=65535; i>=0 && ((u32*)sqlite3_stack_baseline)[-i]==0xdeadbeef; i--){}
   Tcl_SetObjResult(interp, Tcl_NewIntObj(i*4));
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite_delete_function DB function-name
 **
 ** Delete the user function 'function-name' from database handle DB. It
 ** is assumed that the user function was created as UTF8, any number of
 ** arguments (the way the TCL interface does it).
 */
-static int delete_function(
+static int SQLITE_TCLAPI delete_function(
   void * clientData,
   Tcl_Interp *interp,
   int argc,
   char **argv
 ){
   int rc;
   sqlite3 *db;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
         " DB function-name", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 0, 0, 0);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite_delete_collation DB collation-name
 **
 ** Delete the collation sequence 'collation-name' from database handle 
 ** DB. It is assumed that the collation sequence was created as UTF8 (the 
 ** way the TCL interface does it).
 */
-static int delete_collation(
+static int SQLITE_TCLAPI delete_collation(
   void * clientData,
   Tcl_Interp *interp,
   int argc,
   char **argv
 ){
   int rc;
   sqlite3 *db;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
         " DB function-name", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   rc = sqlite3_create_collation(db, argv[2], SQLITE_UTF8, 0, 0);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_get_autocommit DB
 **
 ** Return true if the database DB is currently in auto-commit mode.
 ** Return false if not.
 */
-static int get_autocommit(
+static int SQLITE_TCLAPI get_autocommit(
   void * clientData,
   Tcl_Interp *interp,
   int argc,
   char **argv
 ){
   char zBuf[30];
   sqlite3 *db;
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
         " DB", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3_get_autocommit(db));
   Tcl_AppendResult(interp, zBuf, 0);
   return TCL_OK;
 }
 
 /*
 ** Usage: sqlite3_busy_timeout DB MS
 **
 ** Set the busy timeout.  This is more easily done using the timeout
 ** method of the TCL interface.  But we need a way to test the case
 ** where it returns SQLITE_MISUSE.
 */
-static int test_busy_timeout(
+static int SQLITE_TCLAPI test_busy_timeout(
   void * clientData,
   Tcl_Interp *interp,
   int argc,
   char **argv
 ){
   int rc, ms;
   sqlite3 *db;
   if( argc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
         " DB", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   if( Tcl_GetInt(interp, argv[2], &ms) ) return TCL_ERROR;
   rc = sqlite3_busy_timeout(db, ms);
   Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
   return TCL_OK;
 }
 
 /*
 ** Usage:  tcl_variable_type VARIABLENAME
 **
 ** Return the name of the internal representation for the
 ** value of the given variable.
 */
-static int tcl_variable_type(
+static int SQLITE_TCLAPI tcl_variable_type(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   Tcl_Obj *pVar;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "VARIABLE");
     return TCL_ERROR;
   }
   pVar = Tcl_GetVar2Ex(interp, Tcl_GetString(objv[1]), 0, TCL_LEAVE_ERR_MSG);
   if( pVar==0 ) return TCL_ERROR;
   if( pVar->typePtr ){
     Tcl_SetObjResult(interp, Tcl_NewStringObj(pVar->typePtr->name, -1));
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_release_memory ?N?
 **
 ** Attempt to release memory currently held but not actually required.
 ** The integer N is the number of bytes we are trying to release.  The 
 ** return value is the amount of memory actually released.
 */
-static int test_release_memory(
+static int SQLITE_TCLAPI test_release_memory(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO)
   int N;
   int amt;
   if( objc!=1 && objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "?N?");
@@ skipping 10 matching lines @@
   return TCL_OK;
 }
 
 
 /*
 ** Usage:  sqlite3_db_release_memory DB
 **
 ** Attempt to release memory currently held by database DB.  Return the
 ** result code (which in the current implementation is always zero).
 */
-static int test_db_release_memory(
+static int SQLITE_TCLAPI test_db_release_memory(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   int rc;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB");
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   rc = sqlite3_db_release_memory(db);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_db_cacheflush DB
 **
 ** Attempt to flush any dirty pages to disk.
 */
-static int test_db_cacheflush(
+static int SQLITE_TCLAPI test_db_cacheflush(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   int rc;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB");
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   rc = sqlite3_db_cacheflush(db);
   if( rc ){
     Tcl_SetResult(interp, (char *)sqlite3ErrStr(rc), TCL_STATIC);
     return TCL_ERROR;
   }
 
   Tcl_ResetResult(interp);
   return TCL_OK;
 }
 
 /*
+** Usage:  sqlite3_system_errno DB
+**
+** Return the low-level system errno value.
+*/
+static int SQLITE_TCLAPI test_system_errno(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  int iErrno;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  iErrno = sqlite3_system_errno(db);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(iErrno));
+  return TCL_OK;
+}
+
+/*
 ** Usage:  sqlite3_db_filename DB DBNAME
 **
 ** Return the name of a file associated with a database.
 */
-static int test_db_filename(
+static int SQLITE_TCLAPI test_db_filename(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   const char *zDbName;
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   zDbName = Tcl_GetString(objv[2]);
   Tcl_AppendResult(interp, sqlite3_db_filename(db, zDbName), (void*)0);
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_db_readonly DB DBNAME
 **
 ** Return 1 or 0 if DBNAME is readonly or not.  Return -1 if DBNAME does
 ** not exist.
 */
-static int test_db_readonly(
+static int SQLITE_TCLAPI test_db_readonly(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   const char *zDbName;
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME");
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   zDbName = Tcl_GetString(objv[2]);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_db_readonly(db, zDbName)));
   return TCL_OK;
 }
 
 /*
 ** Usage:  sqlite3_soft_heap_limit ?N?
 **
 ** Query or set the soft heap limit for the current thread.  The
 ** limit is only changed if the N is present.  The previous limit
 ** is returned.
 */
-static int test_soft_heap_limit(
+static int SQLITE_TCLAPI test_soft_heap_limit(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_int64 amt;
   Tcl_WideInt N = -1;
   if( objc!=1 && objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "?N?");
     return TCL_ERROR;
   }
   if( objc==2 ){
     if( Tcl_GetWideIntFromObj(interp, objv[1], &N) ) return TCL_ERROR;
   }
   amt = sqlite3_soft_heap_limit64(N);
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(amt));
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_thread_cleanup
 **
 ** Call the sqlite3_thread_cleanup API.
 */
-static int test_thread_cleanup(
+static int SQLITE_TCLAPI test_thread_cleanup(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifndef SQLITE_OMIT_DEPRECATED
   sqlite3_thread_cleanup();
 #endif
   return TCL_OK;
 }
 
 /*
 ** Usage:   sqlite3_pager_refcounts  DB
 **
 ** Return a list of numbers which are the PagerRefcount for all
 ** pagers on each database connection.
 */
-static int test_pager_refcounts(
+static int SQLITE_TCLAPI test_pager_refcounts(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   int i;
   int v, *a;
   Tcl_Obj *pResult;
 
@@ skipping 25 matching lines @@
 **
 ** Some TCL builds (ex: cygwin) do not support 64-bit integers.  This
 ** leads to a number of test failures.  The present command checks the
 ** TCL build to see whether or not it supports 64-bit integers.  It
 ** returns TRUE if it does and FALSE if not.
 **
 ** This command is used to warn users that their TCL build is defective
 ** and that the errors they are seeing in the test scripts might be
 ** a result of their defective TCL rather than problems in SQLite.
 */
-static int working_64bit_int(
+static int SQLITE_TCLAPI working_64bit_int(
   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 *CONST objv[]  /* Command arguments */
 ){
   Tcl_Obj *pTestObj;
   int working = 0;
 
   pTestObj = Tcl_NewWideIntObj(1000000*(i64)1234567890);
   working = strcmp(Tcl_GetString(pTestObj), "1234567890000000")==0;
   Tcl_DecrRefCount(pTestObj);
   Tcl_SetObjResult(interp, Tcl_NewBooleanObj(working));
   return TCL_OK;
 }
 
 
 /*
 ** tclcmd:   vfs_unlink_test
 **
 ** This TCL command unregisters the primary VFS and then registers
 ** it back again.  This is used to test the ability to register a
 ** VFS when none are previously registered, and the ability to 
 ** unregister the only available VFS.  Ticket #2738
 */
-static int vfs_unlink_test(
+static int SQLITE_TCLAPI vfs_unlink_test(
   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 *CONST objv[]  /* Command arguments */
 ){
   int i;
   sqlite3_vfs *pMain;
   sqlite3_vfs *apVfs[20];
   sqlite3_vfs one, two;
 
@@ skipping 81 matching lines @@
 
   return TCL_OK;
 }
 
 /*
 ** tclcmd:   vfs_initfail_test
 **
 ** This TCL command attempts to vfs_find and vfs_register when the
 ** sqlite3_initialize() interface is failing.  All calls should fail.
 */
-static int vfs_initfail_test(
+static int SQLITE_TCLAPI vfs_initfail_test(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3_vfs one;
   one.zName = "__one";
 
   if( sqlite3_vfs_find(0) ) return TCL_ERROR;
   sqlite3_vfs_register(&one, 0);
   if( sqlite3_vfs_find(0) ) return TCL_ERROR;
   sqlite3_vfs_register(&one, 1);
   if( sqlite3_vfs_find(0) ) return TCL_ERROR;
   return TCL_OK;
 }
 
 /*
 ** Saved VFSes
 */
 static sqlite3_vfs *apVfs[20];
 static int nVfs = 0;
 
 /*
 ** tclcmd:   vfs_unregister_all
 **
 ** Unregister all VFSes.
 */
-static int vfs_unregister_all(
+static int SQLITE_TCLAPI vfs_unregister_all(
   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 *CONST objv[]  /* Command arguments */
 ){
   int i;
   for(i=0; i<ArraySize(apVfs); i++){
     apVfs[i] = sqlite3_vfs_find(0);
     if( apVfs[i]==0 ) break;
     sqlite3_vfs_unregister(apVfs[i]);
   }
   nVfs = i;
   return TCL_OK;
 }
 /*
 ** tclcmd:   vfs_reregister_all
 **
-** Restore all VFSes that were removed using vfs_unregister_all
+** Restore all VFSes that were removed using vfs_unregister_all. Taking
+** care to put the linked list back together in the same order as it was
+** in before vfs_unregister_all was invoked.
 */
-static int vfs_reregister_all(
+static int SQLITE_TCLAPI vfs_reregister_all(
   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 *CONST objv[]  /* Command arguments */
 ){
   int i;
-  for(i=0; i<nVfs; i++){
-    sqlite3_vfs_register(apVfs[i], i==0);
+  for(i=nVfs-1; i>=0; i--){
+    sqlite3_vfs_register(apVfs[i], 1);
   }
   return TCL_OK;
 }
 
 
 /*
 ** tclcmd:   file_control_test DB
 **
 ** This TCL command runs the sqlite3_file_control interface and
 ** verifies correct operation of the same.
 */
-static int file_control_test(
+static int SQLITE_TCLAPI file_control_test(
   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 *CONST objv[]  /* Command arguments */
 ){
   int iArg = 0;
   sqlite3 *db;
   int rc;
 
   if( objc!=2 ){
@@ skipping 14 matching lines @@
   return TCL_OK;
 }
 
 
 /*
 ** tclcmd:   file_control_lasterrno_test DB
 **
 ** This TCL command runs the sqlite3_file_control interface and
 ** verifies correct operation of the SQLITE_LAST_ERRNO verb.
 */
-static int file_control_lasterrno_test(
+static int SQLITE_TCLAPI file_control_lasterrno_test(
   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 *CONST objv[]  /* Command arguments */
 ){
   int iArg = 0;
   sqlite3 *db;
   int rc;
 
   if( objc!=2 ){
@@ skipping 17 matching lines @@
   return TCL_OK;  
 }
 
 /*
 ** tclcmd:   file_control_chunksize_test DB DBNAME SIZE
 **
 ** This TCL command runs the sqlite3_file_control interface and
 ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and
 ** SQLITE_SET_LOCKPROXYFILE verbs.
 */
-static int file_control_chunksize_test(
+static int SQLITE_TCLAPI file_control_chunksize_test(
   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 *CONST objv[]  /* Command arguments */
 ){
   int nSize;                      /* New chunk size */
   char *zDb;                      /* Db name ("main", "temp" etc.) */
   sqlite3 *db;                    /* Database handle */
   int rc;                         /* file_control() return code */
 
@@ skipping 16 matching lines @@
   }
   return TCL_OK;
 }
 
 /*
 ** tclcmd:   file_control_sizehint_test DB DBNAME SIZE
 **
 ** This TCL command runs the sqlite3_file_control interface 
 ** with SQLITE_FCNTL_SIZE_HINT
 */
-static int file_control_sizehint_test(
+static int SQLITE_TCLAPI file_control_sizehint_test(
   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 *CONST objv[]  /* Command arguments */
 ){
   Tcl_WideInt nSize;              /* Hinted size */
   char *zDb;                      /* Db name ("main", "temp" etc.) */
   sqlite3 *db;                    /* Database handle */
   int rc;                         /* file_control() return code */
 
@@ skipping 17 matching lines @@
   return TCL_OK;
 }
 
 /*
 ** tclcmd:   file_control_lockproxy_test DB PWD
 **
 ** This TCL command runs the sqlite3_file_control interface and
 ** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and
 ** SQLITE_SET_LOCKPROXYFILE verbs.
 */
-static int file_control_lockproxy_test(
+static int SQLITE_TCLAPI file_control_lockproxy_test(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   
   if( objc!=3 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
                      Tcl_GetStringFromObj(objv[0], 0), " DB PWD", 0);
@@ skipping 49 matching lines @@
   return TCL_OK;  
 }
 
 #if SQLITE_OS_WIN
 /*
 ** tclcmd:   file_control_win32_av_retry DB  NRETRY  DELAY
 **
 ** This TCL command runs the sqlite3_file_control interface with
 ** the SQLITE_FCNTL_WIN32_AV_RETRY opcode.
 */
-static int file_control_win32_av_retry(
+static int SQLITE_TCLAPI file_control_win32_av_retry(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   int rc;
   int a[2];
   char z[100];
 
   if( objc!=4 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"",
         Tcl_GetStringFromObj(objv[0], 0), " DB NRETRY DELAY", 0);
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
     return TCL_ERROR;
   }
   if( Tcl_GetIntFromObj(interp, objv[2], &a[0]) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[3], &a[1]) ) return TCL_ERROR;
   rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_AV_RETRY, (void*)a);
   sqlite3_snprintf(sizeof(z), z, "%d %d %d", rc, a[0], a[1]);
   Tcl_AppendResult(interp, z, (char*)0);
   return TCL_OK;  
 }
 
 /*
+** tclcmd:   file_control_win32_get_handle DB
+**
+** This TCL command runs the sqlite3_file_control interface with
+** the SQLITE_FCNTL_WIN32_GET_HANDLE opcode.
+*/
+static int file_control_win32_get_handle(
+  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 *CONST objv[]  /* Command arguments */
+){
+  sqlite3 *db;
+  int rc;
+  HANDLE hFile = NULL;
+  char z[100];
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
+    return TCL_ERROR;
+  }
+  rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_WIN32_GET_HANDLE,
+                            (void*)&hFile);
+  sqlite3_snprintf(sizeof(z), z, "%d %p", rc, (void*)hFile);
+  Tcl_AppendResult(interp, z, (char*)0);
+  return TCL_OK;
+}
+
+/*
 ** tclcmd:   file_control_win32_set_handle DB HANDLE
 **
 ** This TCL command runs the sqlite3_file_control interface with
 ** the SQLITE_FCNTL_WIN32_SET_HANDLE opcode.
 */
-static int file_control_win32_set_handle(
+static int SQLITE_TCLAPI file_control_win32_set_handle(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   int rc;
   HANDLE hFile = NULL;
   char z[100];
 
@@ skipping 15 matching lines @@
   return TCL_OK;  
 }
 #endif
 
 /*
 ** tclcmd:   file_control_persist_wal DB PERSIST-FLAG
 **
 ** This TCL command runs the sqlite3_file_control interface with
 ** the SQLITE_FCNTL_PERSIST_WAL opcode.
 */
-static int file_control_persist_wal(
+static int SQLITE_TCLAPI file_control_persist_wal(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   int rc;
   int bPersist;
   char z[100];
 
@@ skipping 11 matching lines @@
   Tcl_AppendResult(interp, z, (char*)0);
   return TCL_OK;  
 }
 
 /*
 ** tclcmd:   file_control_powersafe_overwrite DB PSOW-FLAG
 **
 ** This TCL command runs the sqlite3_file_control interface with
 ** the SQLITE_FCNTL_POWERSAFE_OVERWRITE opcode.
 */
-static int file_control_powersafe_overwrite(
+static int SQLITE_TCLAPI file_control_powersafe_overwrite(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   int rc;
   int b;
   char z[100];
 
@@ skipping 11 matching lines @@
   Tcl_AppendResult(interp, z, (char*)0);
   return TCL_OK;  
 }
 
 
 /*
 ** tclcmd:   file_control_vfsname DB ?AUXDB?
 **
 ** Return a string that describes the stack of VFSes.
 */
-static int file_control_vfsname(
+static int SQLITE_TCLAPI file_control_vfsname(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   const char *zDbName = "main";
   char *zVfsName = 0;
 
   if( objc!=2 && objc!=3 ){
@@ skipping 11 matching lines @@
   Tcl_AppendResult(interp, zVfsName, (char*)0);
   sqlite3_free(zVfsName);
   return TCL_OK;  
 }
 
 /*
 ** tclcmd:   file_control_tempfilename DB ?AUXDB?
 **
 ** Return a string that is a temporary filename
 */
-static int file_control_tempfilename(
+static int SQLITE_TCLAPI file_control_tempfilename(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   const char *zDbName = "main";
   char *zTName = 0;
 
   if( objc!=2 && objc!=3 ){
@@ skipping 12 matching lines @@
   sqlite3_free(zTName);
   return TCL_OK;  
 }
 
 
 /*
 ** tclcmd:   sqlite3_vfs_list
 **
 **   Return a tcl list containing the names of all registered vfs's.
 */
-static int vfs_list(
+static int SQLITE_TCLAPI vfs_list(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3_vfs *pVfs;
   Tcl_Obj *pRet = Tcl_NewObj();
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "");
     return TCL_ERROR;
   }
   for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
     Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(pVfs->zName, -1));
   }
   Tcl_SetObjResult(interp, pRet);
   return TCL_OK;  
 }
 
 /*
 ** tclcmd:   sqlite3_limit DB ID VALUE
 **
 ** This TCL command runs the sqlite3_limit interface and
 ** verifies correct operation of the same.
 */
-static int test_limit(
+static int SQLITE_TCLAPI test_limit(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   int rc;
   static const struct {
      char *zName;
      int id;
@@ skipping 42 matching lines @@
   return TCL_OK;  
 }
 
 /*
 ** tclcmd:  save_prng_state
 **
 ** Save the state of the pseudo-random number generator.
 ** At the same time, verify that sqlite3_test_control works even when
 ** called with an out-of-range opcode.
 */
-static int save_prng_state(
+static int SQLITE_TCLAPI save_prng_state(
   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 *CONST objv[]  /* Command arguments */
 ){
   int rc = sqlite3_test_control(9999);
   assert( rc==0 );
   rc = sqlite3_test_control(-1);
   assert( rc==0 );
   sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SAVE);
   return TCL_OK;
 }
 /*
 ** tclcmd:  restore_prng_state
 */
-static int restore_prng_state(
+static int SQLITE_TCLAPI restore_prng_state(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3_test_control(SQLITE_TESTCTRL_PRNG_RESTORE);
   return TCL_OK;
 }
 /*
 ** tclcmd:  reset_prng_state
 */
-static int reset_prng_state(
+static int SQLITE_TCLAPI reset_prng_state(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3_test_control(SQLITE_TESTCTRL_PRNG_RESET);
   return TCL_OK;
 }
 
 /*
 ** tclcmd:  database_may_be_corrupt
 **
 ** Indicate that database files might be corrupt.  In other words, set the normal
 ** state of operation.
 */
-static int database_may_be_corrupt(
+static int SQLITE_TCLAPI database_may_be_corrupt(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, 0);
   return TCL_OK;
 }
 /*
 ** tclcmd:  database_never_corrupt
 **
 ** Indicate that database files are always well-formed.  This enables extra assert()
 ** statements that test conditions that are always true for well-formed databases.
 */
-static int database_never_corrupt(
+static int SQLITE_TCLAPI database_never_corrupt(
   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 *CONST objv[]  /* Command arguments */
 ){
   sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, 1);
   return TCL_OK;
 }
 
 /*
 ** tclcmd:  pcache_stats
 */
-static int test_pcache_stats(
+static int SQLITE_TCLAPI test_pcache_stats(
   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 *CONST objv[]  /* Command arguments */
 ){
   int nMin;
   int nMax;
   int nCurrent;
   int nRecyclable;
   Tcl_Obj *pRet;
@@ skipping 21 matching lines @@
   for(ii=0; ii<nArg; ii++){
     Tcl_EvalEx((Tcl_Interp *)aArg[ii], "unlock_notify", -1, TCL_EVAL_GLOBAL);
   }
 }
 #endif /* SQLITE_ENABLE_UNLOCK_NOTIFY */
 
 /*
 ** tclcmd:  sqlite3_unlock_notify db
 */
 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
-static int test_unlock_notify(
+static int SQLITE_TCLAPI test_unlock_notify(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   int rc;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB");
     return TCL_ERROR;
   }
 
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
     return TCL_ERROR;
   }
   rc = sqlite3_unlock_notify(db, test_unlock_notify_cb, (void *)interp);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
   return TCL_OK;
 }
 #endif
 
 /*
 ** tclcmd:  sqlite3_wal_checkpoint db ?NAME?
 */
-static int test_wal_checkpoint(
+static int SQLITE_TCLAPI test_wal_checkpoint(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   char *zDb = 0;
   sqlite3 *db;
   int rc;
 
   if( objc!=3 && objc!=2 ){
@@ skipping 23 matching lines @@
 ** If wal_checkpoint_v2() returns any value other than SQLITE_BUSY or
 ** SQLITE_OK, then this command returns TCL_ERROR. The Tcl result is set
 ** to the error message obtained from sqlite3_errmsg().
 **
 ** Otherwise, this command returns a list of three integers. The first integer
 ** is 1 if SQLITE_BUSY was returned, or 0 otherwise. The following two integers
 ** are the values returned via the output parameters by wal_checkpoint_v2() -
 ** the number of frames in the log and the number of frames in the log
 ** that have been checkpointed.
 */
-static int test_wal_checkpoint_v2(
+static int SQLITE_TCLAPI test_wal_checkpoint_v2(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   char *zDb = 0;
   sqlite3 *db;
   int rc;
 
   int eMode;
@@ skipping 35 matching lines @@
   Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nLog));
   Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nCkpt));
   Tcl_SetObjResult(interp, pRet);
 
   return TCL_OK;
 }
 
 /*
 ** tclcmd:  sqlite3_wal_autocheckpoint db VALUE
 */
-static int test_wal_autocheckpoint(
+static int SQLITE_TCLAPI test_wal_autocheckpoint(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   sqlite3 *db;
   int rc;
   int iVal;
 
 
@@ skipping 30 matching lines @@
 static void xLogcallback(void *unused, int err, char *zMsg){
   Tcl_Obj *pNew = Tcl_DuplicateObj(logcallback.pObj);
   Tcl_IncrRefCount(pNew);
   Tcl_ListObjAppendElement(
       0, pNew, Tcl_NewStringObj(sqlite3ErrName(err), -1)
   );
   Tcl_ListObjAppendElement(0, pNew, Tcl_NewStringObj(zMsg, -1));
   Tcl_EvalObjEx(logcallback.pInterp, pNew, TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT);
   Tcl_DecrRefCount(pNew);
 }
-static int test_sqlite3_log(
+static int SQLITE_TCLAPI test_sqlite3_log(
   ClientData clientData,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   if( objc>2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "SCRIPT");
     return TCL_ERROR;
   }
   if( logcallback.pObj ){
@@ skipping 10 matching lines @@
   }
   return TCL_OK;
 }
 
 /*
 **     tcl_objproc COMMANDNAME ARGS...
 **
 ** Run a TCL command using its objProc interface.  Throw an error if
 ** the command has no objProc interface.
 */
-static int runAsObjProc(
+static int SQLITE_TCLAPI runAsObjProc(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   Tcl_CmdInfo cmdInfo;
   if( objc<2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "COMMAND ...");
     return TCL_ERROR;
   }
@@ skipping 42 matching lines @@
     int iOrder = sqlite3_column_int(pExplain, 1);
     int iFrom = sqlite3_column_int(pExplain, 2);
     const char *zDetail = (const char *)sqlite3_column_text(pExplain, 3);
 
     printf("%d %d %d %s\n", iSelectid, iOrder, iFrom, zDetail);
   }
 
   return sqlite3_finalize(pExplain);
 }
 
-static int test_print_eqp(
+static int SQLITE_TCLAPI test_print_eqp(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;
   sqlite3_stmt *pStmt;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "STMT");
     return TCL_ERROR;
   }
   if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
   rc = printExplainQueryPlan(pStmt);
   /* This is needed on Windows so that a test case using this 
   ** function can open a read pipe and get the output of
   ** printExplainQueryPlan() immediately.
   */
   fflush(stdout);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
   return TCL_OK;
 }
 #endif /* SQLITE_OMIT_EXPLAIN */
 
 /*
 ** sqlite3_test_control VERB ARGS...
 */
-static int test_test_control(
+static int SQLITE_TCLAPI test_test_control(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   struct Verb {
     const char *zName;
     int i;
   } aVerb[] = {
     { "SQLITE_TESTCTRL_LOCALTIME_FAULT", SQLITE_TESTCTRL_LOCALTIME_FAULT }, 
@@ skipping 58 matching lines @@
   }
 
   Tcl_ResetResult(interp);
   return TCL_OK;
 }
 
 #if SQLITE_OS_UNIX
 #include <sys/time.h>
 #include <sys/resource.h>
 
-static int test_getrusage(
+static int SQLITE_TCLAPI test_getrusage(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   char buf[1024];
   struct rusage r;
   memset(&r, 0, sizeof(r));
   getrusage(RUSAGE_SELF, &r);
 
@@ skipping 22 matching lines @@
   int err;            /* True if an error occurs */
 };
 #endif
 
 
 #if SQLITE_OS_WIN
 #include <process.h>
 /*
 ** The background thread that does file locking.
 */
-static void win32_file_locker(void *pAppData){
+static void SQLITE_CDECL win32_file_locker(void *pAppData){
   struct win32FileLocker *p = (struct win32FileLocker*)pAppData;
   if( p->evName ){
     HANDLE ev = OpenEvent(EVENT_MODIFY_STATE, FALSE, p->evName);
     if ( ev ){
       SetEvent(ev);
       CloseHandle(ev);
     }
   }
   if( p->delay1 ) Sleep(p->delay1);
   if( LockFile(p->h, 0, 0, 100000000, 0) ){
@@ skipping 10 matching lines @@
 }
 #endif
 
 #if SQLITE_OS_WIN
 /*
 **      lock_win32_file FILENAME DELAY1 DELAY2
 **
 ** Get an exclusive manditory lock on file for DELAY2 milliseconds.
 ** Wait DELAY1 milliseconds before acquiring the lock.
 */
-static int win32_file_lock(
+static int SQLITE_TCLAPI win32_file_lock(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   static struct win32FileLocker x = { "win32_file_lock", 0, 0, 0, 0, 0 };
   const char *zFilename;
   char zBuf[200];
   int retry = 0;
   HANDLE ev;
@@ skipping 43 matching lines @@
   CloseHandle(ev);
   return TCL_OK;
 }
 
 /*
 **      exists_win32_path PATH
 **
 ** Returns non-zero if the specified path exists, whose fully qualified name
 ** may exceed 260 characters if it is prefixed with "\\?\".
 */
-static int win32_exists_path(
+static int SQLITE_TCLAPI win32_exists_path(
   void *clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "PATH");
     return TCL_ERROR;
   }
   Tcl_SetObjResult(interp, Tcl_NewBooleanObj(
       GetFileAttributesW( Tcl_GetUnicode(objv[1]))!=INVALID_FILE_ATTRIBUTES ));
   return TCL_OK;
 }
 
 /*
 **      find_win32_file PATTERN
 **
 ** Returns a list of entries in a directory that match the specified pattern,
 ** whose fully qualified name may exceed 248 characters if it is prefixed with
 ** "\\?\".
 */
-static int win32_find_file(
+static int SQLITE_TCLAPI win32_find_file(
   void *clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   HANDLE hFindFile = INVALID_HANDLE_VALUE;
   WIN32_FIND_DATAW findData;
   Tcl_Obj *listObj;
   DWORD lastErrno;
   if( objc!=2 ){
@@ skipping 24 matching lines @@
   Tcl_SetObjResult(interp, listObj);
   return TCL_OK;
 }
 
 /*
 **      delete_win32_file FILENAME
 **
 ** Deletes the specified file, whose fully qualified name may exceed 260
 ** characters if it is prefixed with "\\?\".
 */
-static int win32_delete_file(
+static int SQLITE_TCLAPI win32_delete_file(
   void *clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
     return TCL_ERROR;
   }
   if( !DeleteFileW(Tcl_GetUnicode(objv[1])) ){
     Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError()));
     return TCL_ERROR;
   }
   Tcl_ResetResult(interp);
   return TCL_OK;
 }
 
 /*
 **      make_win32_dir DIRECTORY
 **
 ** Creates the specified directory, whose fully qualified name may exceed 248
 ** characters if it is prefixed with "\\?\".
 */
-static int win32_mkdir(
+static int SQLITE_TCLAPI win32_mkdir(
   void *clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DIRECTORY");
     return TCL_ERROR;
   }
   if( !CreateDirectoryW(Tcl_GetUnicode(objv[1]), NULL) ){
     Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError()));
     return TCL_ERROR;
   }
   Tcl_ResetResult(interp);
   return TCL_OK;
 }
 
 /*
 **      remove_win32_dir DIRECTORY
 **
 ** Removes the specified directory, whose fully qualified name may exceed 248
 ** characters if it is prefixed with "\\?\".
 */
-static int win32_rmdir(
+static int SQLITE_TCLAPI win32_rmdir(
   void *clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DIRECTORY");
     return TCL_ERROR;
   }
   if( !RemoveDirectoryW(Tcl_GetUnicode(objv[1])) ){
     Tcl_SetObjResult(interp, Tcl_NewWideIntObj(GetLastError()));
     return TCL_ERROR;
   }
   Tcl_ResetResult(interp);
   return TCL_OK;
 }
 #endif
 
 
 /*
 **      optimization_control DB OPT BOOLEAN
 **
 ** Enable or disable query optimizations using the sqlite3_test_control()
 ** interface.  Disable if BOOLEAN is false and enable if BOOLEAN is true.
 ** OPT is the name of the optimization to be disabled.
 */
-static int optimization_control(
+static int SQLITE_TCLAPI optimization_control(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int i;
   sqlite3 *db;
   const char *zOpt;
   int onoff;
   int mask = 0;
@@ skipping 36 matching lines @@
                      (char*)0);
     for(i=0; i<sizeof(aOpt)/sizeof(aOpt[0]); i++){
       Tcl_AppendResult(interp, " ", aOpt[i].zOptName, (char*)0);
     }
     return TCL_ERROR;
   }
   sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, db, mask);
   return TCL_OK;
 }
 
-typedef struct sqlite3_api_routines sqlite3_api_routines;
 /*
 **     load_static_extension DB NAME ...
 **
 ** Load one or more statically linked extensions.
 */
-static int tclLoadStaticExtensionCmd(
+static int SQLITE_TCLAPI tclLoadStaticExtensionCmd(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   extern int sqlite3_amatch_init(sqlite3*,char**,const sqlite3_api_routines*);
+  extern int sqlite3_carray_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_closure_init(sqlite3*,char**,const sqlite3_api_routines*);
+  extern int sqlite3_csv_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_eval_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_fileio_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_fuzzer_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_ieee_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_nextchar_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_percentile_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_regexp_init(sqlite3*,char**,const sqlite3_api_routines*);
+  extern int sqlite3_remember_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_series_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_spellfix_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_totype_init(sqlite3*,char**,const sqlite3_api_routines*);
   extern int sqlite3_wholenumber_init(sqlite3*,char**,const sqlite3_api_routines*);
   static const struct {
     const char *zExtName;
     int (*pInit)(sqlite3*,char**,const sqlite3_api_routines*);
   } aExtension[] = {
     { "amatch",                sqlite3_amatch_init               },
+    { "carray",                sqlite3_carray_init               },
     { "closure",               sqlite3_closure_init              },
+    { "csv",                   sqlite3_csv_init                  },
     { "eval",                  sqlite3_eval_init                 },
     { "fileio",                sqlite3_fileio_init               },
     { "fuzzer",                sqlite3_fuzzer_init               },
     { "ieee754",               sqlite3_ieee_init                 },
     { "nextchar",              sqlite3_nextchar_init             },
     { "percentile",            sqlite3_percentile_init           },
     { "regexp",                sqlite3_regexp_init               },
+    { "remember",              sqlite3_remember_init             },
     { "series",                sqlite3_series_init               },
     { "spellfix",              sqlite3_spellfix_init             },
     { "totype",                sqlite3_totype_init               },
     { "wholenumber",           sqlite3_wholenumber_init          },
   };
   sqlite3 *db;
   const char *zName;
   int i, j, rc;
   char *zErrMsg = 0;
   if( objc<3 ){
@@ skipping 22 matching lines @@
       return TCL_ERROR;
     }
   }
   return TCL_OK;
 }
 
 /*
 **     sorter_test_fakeheap BOOL
 **
 */
-static int sorter_test_fakeheap(
+static int SQLITE_TCLAPI sorter_test_fakeheap(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int bArg;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "BOOL");
     return TCL_ERROR;
   }
@@ skipping 19 matching lines @@
 /*
 **     sorter_test_sort4_helper DB SQL1 NSTEP SQL2
 **
 ** Compile SQL statement $SQL1 and step it $NSTEP times. For each row, 
 ** check that the leftmost and rightmost columns returned are both integers,
 ** and that both contain the same value.
 **
 ** Then execute statement $SQL2. Check that the statement returns the same
 ** set of integers in the same order as in the previous step (using $SQL1).
 */
-static int sorter_test_sort4_helper(
+static int SQLITE_TCLAPI sorter_test_sort4_helper(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zSql1;
   const char *zSql2;
   int nStep; 
   int iStep; 
-  int iCksum1 = 0; 
-  int iCksum2 = 0; 
+  unsigned int iCksum1 = 0; 
+  unsigned int iCksum2 = 0; 
   int rc;
   int iB;
   sqlite3 *db;
   sqlite3_stmt *pStmt;
   
   if( objc!=5 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB SQL1 NSTEP SQL2");
     return TCL_ERROR;
   }
 
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   zSql1 = Tcl_GetString(objv[2]);
   if( Tcl_GetIntFromObj(interp, objv[3], &nStep) ) return TCL_ERROR;
   zSql2 = Tcl_GetString(objv[4]);
 
   rc = sqlite3_prepare_v2(db, zSql1, -1, &pStmt, 0);
   if( rc!=SQLITE_OK ) goto sql_error;
 
   iB = sqlite3_column_count(pStmt)-1;
   for(iStep=0; iStep<nStep && SQLITE_ROW==sqlite3_step(pStmt); iStep++){
     int a = sqlite3_column_int(pStmt, 0);
     if( a!=sqlite3_column_int(pStmt, iB) ){
       Tcl_AppendResult(interp, "data error: (a!=b)", 0);
       return TCL_ERROR;
     }
 
-    iCksum1 += (iCksum1 << 3) + a;
+    iCksum1 += (iCksum1 << 3) + (unsigned int)a;
   }
   rc = sqlite3_finalize(pStmt);
   if( rc!=SQLITE_OK ) goto sql_error;
 
   rc = sqlite3_prepare_v2(db, zSql2, -1, &pStmt, 0);
   if( rc!=SQLITE_OK ) goto sql_error;
   for(iStep=0; SQLITE_ROW==sqlite3_step(pStmt); iStep++){
     int a = sqlite3_column_int(pStmt, 0);
-    iCksum2 += (iCksum2 << 3) + a;
+    iCksum2 += (iCksum2 << 3) + (unsigned int)a;
   }
   rc = sqlite3_finalize(pStmt);
   if( rc!=SQLITE_OK ) goto sql_error;
 
   if( iCksum1!=iCksum2 ){
     Tcl_AppendResult(interp, "checksum mismatch", 0);
     return TCL_ERROR;
   }
 
   return TCL_OK;
  sql_error:
   Tcl_AppendResult(interp, "sql error: ", sqlite3_errmsg(db), 0);
   return TCL_ERROR;
 }
 
 
 #ifdef SQLITE_USER_AUTHENTICATION
 #include "sqlite3userauth.h"
 /*
 ** tclcmd:  sqlite3_user_authenticate DB USERNAME PASSWORD
 */
-static int test_user_authenticate(
+static int SQLITE_TCLAPI test_user_authenticate(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   char *zUser = 0;
   char *zPasswd = 0;
   int nPasswd = 0;
   sqlite3 *db;
   int rc;
@@ skipping 10 matching lines @@
   rc = sqlite3_user_authenticate(db, zUser, zPasswd, nPasswd);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
   return TCL_OK;
 }
 #endif /* SQLITE_USER_AUTHENTICATION */
 
 #ifdef SQLITE_USER_AUTHENTICATION
 /*
 ** tclcmd:  sqlite3_user_add DB USERNAME PASSWORD ISADMIN
 */
-static int test_user_add(
+static int SQLITE_TCLAPI test_user_add(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   char *zUser = 0;
   char *zPasswd = 0;
   int nPasswd = 0;
   int isAdmin = 0;
   sqlite3 *db;
@@ skipping 12 matching lines @@
   rc = sqlite3_user_add(db, zUser, zPasswd, nPasswd, isAdmin);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
   return TCL_OK;
 }
 #endif /* SQLITE_USER_AUTHENTICATION */
 
 #ifdef SQLITE_USER_AUTHENTICATION
 /*
 ** tclcmd:  sqlite3_user_change DB USERNAME PASSWORD ISADMIN
 */
-static int test_user_change(
+static int SQLITE_TCLAPI test_user_change(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   char *zUser = 0;
   char *zPasswd = 0;
   int nPasswd = 0;
   int isAdmin = 0;
   sqlite3 *db;
@@ skipping 12 matching lines @@
   rc = sqlite3_user_change(db, zUser, zPasswd, nPasswd, isAdmin);
   Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
   return TCL_OK;
 }
 #endif /* SQLITE_USER_AUTHENTICATION */
 
 #ifdef SQLITE_USER_AUTHENTICATION
 /*
 ** tclcmd:  sqlite3_user_delete DB USERNAME
 */
-static int test_user_delete(
+static int SQLITE_TCLAPI test_user_delete(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   char *zUser = 0;
   sqlite3 *db;
   int rc;
 
   if( objc!=3 ){
@@ skipping 16 matching lines @@
 ** Do some things that should trigger a valgrind or -fsanitize=undefined
 ** warning.  This is used to verify that errors and warnings output by those
 ** tools are detected by the test scripts.
 **
 **       TYPE       BEHAVIOR
 **       1          Overflow a signed integer
 **       2          Jump based on an uninitialized variable
 **       3          Read after free
 **       4          Panic
 */
-static int test_bad_behavior(
+static int SQLITE_TCLAPI test_bad_behavior(
   ClientData clientData, /* Pointer to an integer containing zero */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   int iType;
   int xyz;
   int i = *(int*)clientData;
   int j;
   int w[10];
@@ skipping 29 matching lines @@
     }
   }
   return TCL_OK;
 }  
 
 /*
 ** tclcmd:   register_dbstat_vtab DB
 **
 ** Cause the dbstat virtual table to be available on the connection DB
 */
-static int test_register_dbstat_vtab(
+static int SQLITE_TCLAPI test_register_dbstat_vtab(
   void *clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifdef SQLITE_OMIT_VIRTUALTABLE
   Tcl_AppendResult(interp, "dbstat not available because of "
                            "SQLITE_OMIT_VIRTUALTABLE", (void*)0);
   return TCL_ERROR;
 #else
   struct SqliteDb { sqlite3 *db; };
   char *zDb;
   Tcl_CmdInfo cmdInfo;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB");
     return TCL_ERROR;
   }
 
   zDb = Tcl_GetString(objv[1]);
   if( Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
     sqlite3* db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
     sqlite3DbstatRegister(db);
   }
   return TCL_OK;
 #endif /* SQLITE_OMIT_VIRTUALTABLE */
 }
 
 /*
+** tclcmd:   sqlite3_db_config DB SETTING VALUE
+**
+** Invoke sqlite3_db_config() for one of the setting values.
+*/
+static int SQLITE_TCLAPI test_sqlite3_db_config(
+  void *clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  static const struct {
+    const char *zName;
+    int eVal;
+  } aSetting[] = {
+    { "FKEY",            SQLITE_DBCONFIG_ENABLE_FKEY },
+    { "TRIGGER",         SQLITE_DBCONFIG_ENABLE_TRIGGER },
+    { "FTS3_TOKENIZER",  SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER },
+    { "LOAD_EXTENSION",  SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION },
+    { "NO_CKPT_ON_CLOSE",SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE },
+  };
+  int i;
+  int v;
+  const char *zSetting;
+  sqlite3 *db;
+
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB SETTING VALUE");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zSetting = Tcl_GetString(objv[2]);
+  if( sqlite3_strglob("SQLITE_*", zSetting)==0 ) zSetting += 7;
+  if( sqlite3_strglob("DBCONFIG_*", zSetting)==0 ) zSetting += 9;
+  if( sqlite3_strglob("ENABLE_*", zSetting)==0 ) zSetting += 7;
+  for(i=0; i<ArraySize(aSetting); i++){
+    if( strcmp(zSetting, aSetting[i].zName)==0 ) break;
+  }
+  if( i>=ArraySize(aSetting) ){
+    Tcl_SetObjResult(interp,
+      Tcl_NewStringObj("unknown sqlite3_db_config setting", -1));
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[3], &v) ) return TCL_ERROR;
+  sqlite3_db_config(db, aSetting[i].eVal, v, &v);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(v));
+  return TCL_OK;
+}
+
+/*
+** Change the name of the main database schema from "main" to "icecube".
+*/
+static int SQLITE_TCLAPI test_dbconfig_maindbname_icecube(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int rc;
+  sqlite3 *db;
+  extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB");
+    return TCL_ERROR;
+  }else{
+    if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+    rc = sqlite3_db_config(db, SQLITE_DBCONFIG_MAINDBNAME, "icecube");
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
+    return TCL_OK;
+  }
+}
+
+/*
 ** Register commands with the TCL interpreter.
 */
 int Sqlitetest1_Init(Tcl_Interp *interp){
   extern int sqlite3_search_count;
   extern int sqlite3_found_count;
   extern int sqlite3_interrupt_count;
   extern int sqlite3_open_file_count;
   extern int sqlite3_sort_count;
   extern int sqlite3_current_time;
 #if SQLITE_OS_UNIX && defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
   extern int sqlite3_hostid_num;
 #endif
   extern int sqlite3_max_blobsize;
-  extern int sqlite3BtreeSharedCacheReport(void*,
+  extern int SQLITE_TCLAPI sqlite3BtreeSharedCacheReport(void*,
                                           Tcl_Interp*,int,Tcl_Obj*CONST*);
   static int iZero = 0;
   static struct {
      char *zName;
      Tcl_CmdProc *xProc;
   } aCmd[] = {
      { "db_enter",                      (Tcl_CmdProc*)db_enter               },
      { "db_leave",                      (Tcl_CmdProc*)db_leave               },
      { "sqlite3_mprintf_int",           (Tcl_CmdProc*)sqlite3_mprintf_int    },
      { "sqlite3_mprintf_int64",         (Tcl_CmdProc*)sqlite3_mprintf_int64  },
@@ skipping 34 matching lines @@
      { "sqlite3_busy_timeout",          (Tcl_CmdProc*)test_busy_timeout     },
      { "printf",                        (Tcl_CmdProc*)test_printf           },
      { "sqlite3IoTrace",              (Tcl_CmdProc*)test_io_trace         },
      { "clang_sanitize_address",        (Tcl_CmdProc*)clang_sanitize_address },
   };
   static struct {
      char *zName;
      Tcl_ObjCmdProc *xProc;
      void *clientData;
   } aObjCmd[] = {
+     { "sqlite3_db_config",             test_sqlite3_db_config, 0 },
      { "bad_behavior",                  test_bad_behavior,  (void*)&iZero },
      { "register_dbstat_vtab",          test_register_dbstat_vtab  },
      { "sqlite3_connection_pointer",    get_sqlite_pointer, 0 },
+     { "intarray_addr",                 test_intarray_addr, 0 },
+     { "int64array_addr",               test_int64array_addr, 0 },
+     { "doublearray_addr",              test_doublearray_addr, 0 },
+     { "textarray_addr",                test_textarray_addr, 0 },
      { "sqlite3_bind_int",              test_bind_int,      0 },
      { "sqlite3_bind_zeroblob",         test_bind_zeroblob, 0 },
      { "sqlite3_bind_zeroblob64",       test_bind_zeroblob64, 0 },
      { "sqlite3_bind_int64",            test_bind_int64,    0 },
      { "sqlite3_bind_double",           test_bind_double,   0 },
      { "sqlite3_bind_null",             test_bind_null     ,0 },
      { "sqlite3_bind_text",             test_bind_text     ,0 },
      { "sqlite3_bind_text16",           test_bind_text16   ,0 },
      { "sqlite3_bind_blob",             test_bind_blob     ,0 },
      { "sqlite3_bind_parameter_count",  test_bind_parameter_count, 0},
@@ skipping 16 matching lines @@
      { "sqlite3_prepare_tkt3134",       test_prepare_tkt3134, 0},
      { "sqlite3_prepare16_v2",          test_prepare16_v2  ,0 },
      { "sqlite3_finalize",              test_finalize      ,0 },
      { "sqlite3_stmt_status",           test_stmt_status   ,0 },
      { "sqlite3_reset",                 test_reset         ,0 },
      { "sqlite3_expired",               test_expired       ,0 },
      { "sqlite3_transfer_bindings",     test_transfer_bind ,0 },
      { "sqlite3_changes",               test_changes       ,0 },
      { "sqlite3_step",                  test_step          ,0 },
      { "sqlite3_sql",                   test_sql           ,0 },
+     { "sqlite3_expanded_sql",          test_ex_sql        ,0 },
      { "sqlite3_next_stmt",             test_next_stmt     ,0 },
      { "sqlite3_stmt_readonly",         test_stmt_readonly ,0 },
      { "sqlite3_stmt_busy",             test_stmt_busy     ,0 },
      { "uses_stmt_journal",             uses_stmt_journal ,0 },
 
      { "sqlite3_release_memory",        test_release_memory,     0},
      { "sqlite3_db_release_memory",     test_db_release_memory,  0},
      { "sqlite3_db_cacheflush",         test_db_cacheflush,      0},
+     { "sqlite3_system_errno",          test_system_errno,       0},
      { "sqlite3_db_filename",           test_db_filename,        0},
      { "sqlite3_db_readonly",           test_db_readonly,        0},
      { "sqlite3_soft_heap_limit",       test_soft_heap_limit,    0},
      { "sqlite3_thread_cleanup",        test_thread_cleanup,     0},
      { "sqlite3_pager_refcounts",       test_pager_refcounts,    0},
 
      { "sqlite3_load_extension",        test_load_extension,     0},
      { "sqlite3_enable_load_extension", test_enable_load,        0},
      { "sqlite3_extended_result_codes", test_extended_result_codes, 0},
      { "sqlite3_limit",                 test_limit,                 0},
+     { "dbconfig_maindbname_icecube",   test_dbconfig_maindbname_icecube },
 
      { "save_prng_state",               save_prng_state,    0 },
      { "restore_prng_state",            restore_prng_state, 0 },
      { "reset_prng_state",              reset_prng_state,   0 },
      { "database_never_corrupt",        database_never_corrupt, 0},
      { "database_may_be_corrupt",       database_may_be_corrupt, 0},
      { "optimization_control",          optimization_control,0},
 #if SQLITE_OS_WIN
      { "lock_win32_file",               win32_file_lock,    0 },
      { "exists_win32_path",             win32_exists_path,  0 },
@@ skipping 46 matching lines @@
      { "vfs_initfail_test",          vfs_initfail_test,   0   },
      { "vfs_unregister_all",         vfs_unregister_all,  0   },
      { "vfs_reregister_all",         vfs_reregister_all,  0   },
      { "file_control_test",          file_control_test,   0   },
      { "file_control_lasterrno_test", file_control_lasterrno_test,  0   },
      { "file_control_lockproxy_test", file_control_lockproxy_test,  0   },
      { "file_control_chunksize_test", file_control_chunksize_test,  0   },
      { "file_control_sizehint_test",  file_control_sizehint_test,   0   },
 #if SQLITE_OS_WIN
      { "file_control_win32_av_retry", file_control_win32_av_retry,  0   },
+     { "file_control_win32_get_handle", file_control_win32_get_handle, 0  },
      { "file_control_win32_set_handle", file_control_win32_set_handle, 0  },
 #endif
      { "file_control_persist_wal",    file_control_persist_wal,     0   },
      { "file_control_powersafe_overwrite",file_control_powersafe_overwrite,0},
      { "file_control_vfsname",        file_control_vfsname,         0   },
      { "file_control_tempfilename",   file_control_tempfilename,    0   },
      { "sqlite3_vfs_list",           vfs_list,     0   },
      { "sqlite3_create_function_v2", test_create_function_v2, 0 },
 
      /* Functions from os.h */
@@ skipping 43 matching lines @@
      { "sqlite3_stmt_scanstatus_reset", test_stmt_scanstatus_reset,   0 },
 #endif
 #ifdef SQLITE_ENABLE_SQLLOG
      { "sqlite3_config_sqllog",         test_config_sqllog,   0 },
 #endif
      { "vfs_current_time_int64",           vfsCurrentTimeInt64,   0 },
 #ifdef SQLITE_ENABLE_SNAPSHOT
      { "sqlite3_snapshot_get", test_snapshot_get, 0 },
      { "sqlite3_snapshot_open", test_snapshot_open, 0 },
      { "sqlite3_snapshot_free", test_snapshot_free, 0 },
+     { "sqlite3_snapshot_cmp", test_snapshot_cmp, 0 },
+     { "sqlite3_snapshot_recover", test_snapshot_recover, 0 },
+     { "sqlite3_snapshot_get_blob", test_snapshot_get_blob, 0 },
+     { "sqlite3_snapshot_open_blob", test_snapshot_open_blob, 0 },
+     { "sqlite3_snapshot_cmp_blob", test_snapshot_cmp_blob, 0 },
 #endif
+     { "sqlite3_delete_database", test_delete_database, 0 },
   };
   static int bitmask_size = sizeof(Bitmask)*8;
   static int longdouble_size = sizeof(LONGDOUBLE_TYPE);
   int i;
   extern int sqlite3_sync_count, sqlite3_fullsync_count;
   extern int sqlite3_opentemp_count;
   extern int sqlite3_like_count;
   extern int sqlite3_xferopt_count;
   extern int sqlite3_pager_readdb_count;
   extern int sqlite3_pager_writedb_count;
@@ skipping 95 matching lines @@
   Tcl_LinkVar(interp, "sqlite_sync_count",
       (char*)&sqlite3_sync_count, TCL_LINK_INT);
   Tcl_LinkVar(interp, "sqlite_fullsync_count",
       (char*)&sqlite3_fullsync_count, TCL_LINK_INT);
 #if defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_TEST)
   Tcl_LinkVar(interp, "sqlite_fts3_enable_parentheses",
       (char*)&sqlite3_fts3_enable_parentheses, TCL_LINK_INT);
 #endif
   return TCL_OK;
 }