[sql] Import SQLite 3.17.0.

third_party/sqlite/src/src/test_malloc.c

 /*
 ** 2007 August 15
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 **
 ** This file contains code used to implement test interfaces to the
 ** memory allocation subsystem.
 */
 #include "sqliteInt.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>
 #include <assert.h>
 
 /*
 ** This structure is used to encapsulate the global state variables used 
 ** by malloc() fault simulation.
 */
 static struct MemFault {
   int iCountdown;         /* Number of pending successes before a failure */
@@ skipping 271 matching lines @@
     assert( 0 );
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_malloc  NBYTES
 **
 ** Raw test interface for sqlite3_malloc().
 */
-static int test_malloc(
+static int SQLITE_TCLAPI test_malloc(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int nByte;
   void *p;
   char zOut[100];
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "NBYTES");
     return TCL_ERROR;
   }
   if( Tcl_GetIntFromObj(interp, objv[1], &nByte) ) return TCL_ERROR;
   p = sqlite3_malloc((unsigned)nByte);
   pointerToText(p, zOut);
   Tcl_AppendResult(interp, zOut, NULL);
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_realloc  PRIOR  NBYTES
 **
 ** Raw test interface for sqlite3_realloc().
 */
-static int test_realloc(
+static int SQLITE_TCLAPI test_realloc(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int nByte;
   void *pPrior, *p;
   char zOut[100];
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "PRIOR NBYTES");
     return TCL_ERROR;
   }
   if( Tcl_GetIntFromObj(interp, objv[2], &nByte) ) return TCL_ERROR;
   if( textToPointer(Tcl_GetString(objv[1]), &pPrior) ){
     Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0);
     return TCL_ERROR;
   }
   p = sqlite3_realloc(pPrior, (unsigned)nByte);
   pointerToText(p, zOut);
   Tcl_AppendResult(interp, zOut, NULL);
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_free  PRIOR
 **
 ** Raw test interface for sqlite3_free().
 */
-static int test_free(
+static int SQLITE_TCLAPI test_free(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   void *pPrior;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "PRIOR");
     return TCL_ERROR;
   }
@@ skipping 10 matching lines @@
 */
 int sqlite3TestHexToBin(const char *, int, char *);
 int sqlite3TestBinToHex(char*,int);
 
 /*
 ** Usage:    memset  ADDRESS  SIZE  HEX
 **
 ** Set a chunk of memory (obtained from malloc, probably) to a
 ** specified hex pattern.
 */
-static int test_memset(
+static int SQLITE_TCLAPI test_memset(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   void *p;
   int size, n, i;
   char *zHex;
   char *zOut;
   char zBin[100];
@@ skipping 25 matching lines @@
     zOut[i] = zBin[i%n];
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:    memget  ADDRESS  SIZE
 **
 ** Return memory as hexadecimal text.
 */
-static int test_memget(
+static int SQLITE_TCLAPI test_memget(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   void *p;
   int size, n;
   char *zBin;
   char zHex[100];
 
@@ skipping 26 matching lines @@
     Tcl_AppendResult(interp, zHex, (char*)0);
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_memory_used
 **
 ** Raw test interface for sqlite3_memory_used().
 */
-static int test_memory_used(
+static int SQLITE_TCLAPI test_memory_used(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   Tcl_SetObjResult(interp, Tcl_NewWideIntObj(sqlite3_memory_used()));
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_memory_highwater ?RESETFLAG?
 **
 ** Raw test interface for sqlite3_memory_highwater().
 */
-static int test_memory_highwater(
+static int SQLITE_TCLAPI test_memory_highwater(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int resetFlag = 0;
   if( objc!=1 && objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "?RESET?");
     return TCL_ERROR;
   }
   if( objc==2 ){
     if( Tcl_GetBooleanFromObj(interp, objv[1], &resetFlag) ) return TCL_ERROR;
   } 
   Tcl_SetObjResult(interp, 
      Tcl_NewWideIntObj(sqlite3_memory_highwater(resetFlag)));
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_memdebug_backtrace DEPTH
 **
 ** Set the depth of backtracing.  If SQLITE_MEMDEBUG is not defined
 ** then this routine is a no-op.
 */
-static int test_memdebug_backtrace(
+static int SQLITE_TCLAPI test_memdebug_backtrace(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int depth;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DEPT");
     return TCL_ERROR;
   }
   if( Tcl_GetIntFromObj(interp, objv[1], &depth) ) return TCL_ERROR;
 #ifdef SQLITE_MEMDEBUG
   {
     extern void sqlite3MemdebugBacktrace(int);
     sqlite3MemdebugBacktrace(depth);
   }
 #endif
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_memdebug_dump  FILENAME
 **
 ** Write a summary of unfreed memory to FILENAME.
 */
-static int test_memdebug_dump(
+static int SQLITE_TCLAPI test_memdebug_dump(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
     return TCL_ERROR;
   }
 #if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE) \
      || defined(SQLITE_POW2_MEMORY_SIZE)
   {
     extern void sqlite3MemdebugDump(const char*);
     sqlite3MemdebugDump(Tcl_GetString(objv[1]));
   }
 #endif
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_memdebug_malloc_count
 **
 ** Return the total number of times malloc() has been called.
 */
-static int test_memdebug_malloc_count(
+static int SQLITE_TCLAPI test_memdebug_malloc_count(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int nMalloc = -1;
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "");
     return TCL_ERROR;
   }
@@ skipping 19 matching lines @@
 ** Arrange for a simulated malloc() failure after COUNTER successes.
 ** If a repeat count is specified, the fault is repeated that many
 ** times.
 **
 ** Each call to this routine overrides the prior counter value.
 ** This routine returns the number of simulated failures that have
 ** happened since the previous call to this routine.
 **
 ** To disable simulated failures, use a COUNTER of -1.
 */
-static int test_memdebug_fail(
+static int SQLITE_TCLAPI test_memdebug_fail(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int ii;
   int iFail;
   int nRepeat = 1;
   Tcl_Obj *pBenignCnt = 0;
   int nBenign;
@@ skipping 45 matching lines @@
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_memdebug_pending
 **
 ** Return the number of malloc() calls that will succeed before a 
 ** simulated failure occurs. A negative return value indicates that
 ** no malloc() failure is scheduled.
 */
-static int test_memdebug_pending(
+static int SQLITE_TCLAPI test_memdebug_pending(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int nPending;
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "");
     return TCL_ERROR;
   }
@@ skipping 12 matching lines @@
 /*
 ** Usage:    sqlite3_memdebug_settitle TITLE
 **
 ** Set a title string stored with each allocation.  The TITLE is
 ** typically the name of the test that was running when the
 ** allocation occurred.  The TITLE is stored with the allocation
 ** and can be used to figure out which tests are leaking memory.
 **
 ** Each title overwrite the previous.
 */
-static int test_memdebug_settitle(
+static int SQLITE_TCLAPI test_memdebug_settitle(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3_memdebug_title_count++;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "TITLE");
     return TCL_ERROR;
   }
@@ skipping 60 matching lines @@
     pEntry;
     pEntry=Tcl_NextHashEntry(&search)
   ){
     MallocLog *pLog = (MallocLog *)Tcl_GetHashValue(pEntry);
     Tcl_Free((char *)pLog);
   }
   Tcl_DeleteHashTable(&aMallocLog);
   Tcl_InitHashTable(&aMallocLog, MALLOC_LOG_KEYINTS);
 }
 
-static int test_memdebug_log(
+static int SQLITE_TCLAPI test_memdebug_log(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   static int isInit = 0;
   int iSub;
 
   static const char *MB_strs[] = { "start", "stop", "dump", "clear", "sync" };
   enum MB_enum { 
@@ skipping 77 matching lines @@
 /*
 ** Usage:    sqlite3_config_scratch SIZE N
 **
 ** Set the scratch memory buffer using SQLITE_CONFIG_SCRATCH.
 ** The buffer is static and is of limited size.  N might be
 ** adjusted downward as needed to accommodate the requested size.
 ** The revised value of N is returned.
 **
 ** A negative SIZE causes the buffer pointer to be NULL.
 */
-static int test_config_scratch(
+static int SQLITE_TCLAPI test_config_scratch(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int sz, N, rc;
   Tcl_Obj *pResult;
   static char *buf = 0;
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "SIZE N");
@@ skipping 19 matching lines @@
 /*
 ** Usage:    sqlite3_config_pagecache SIZE N
 **
 ** Set the page-cache memory buffer using SQLITE_CONFIG_PAGECACHE.
 ** The buffer is static and is of limited size.  N might be
 ** adjusted downward as needed to accommodate the requested size.
 ** The revised value of N is returned.
 **
 ** A negative SIZE causes the buffer pointer to be NULL.
 */
-static int test_config_pagecache(
+static int SQLITE_TCLAPI test_config_pagecache(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int sz, N;
   Tcl_Obj *pRes;
   static char *buf = 0;
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "SIZE N");
@@ skipping 22 matching lines @@
 /*
 ** Usage:    sqlite3_config_alt_pcache INSTALL_FLAG DISCARD_CHANCE PRNG_SEED
 **
 ** Set up the alternative test page cache.  Install if INSTALL_FLAG is
 ** true and uninstall (reverting to the default page cache) if INSTALL_FLAG
 ** is false.  DISCARD_CHANGE is an integer between 0 and 100 inclusive
 ** which determines the chance of discarding a page when unpinned.  100
 ** is certainty.  0 is never.  PRNG_SEED is the pseudo-random number generator
 ** seed.
 */
-static int test_alt_pcache(
+static int SQLITE_TCLAPI test_alt_pcache(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int installFlag;
   int discardChance = 0;
   int prngSeed = 0;
   int highStress = 0;
   extern void installTestPCache(int,unsigned,unsigned,unsigned);
@@ skipping 20 matching lines @@
   installTestPCache(installFlag, (unsigned)discardChance, (unsigned)prngSeed,
                     (unsigned)highStress);
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_config_memstatus BOOLEAN
 **
 ** Enable or disable memory status reporting using SQLITE_CONFIG_MEMSTATUS.
 */
-static int test_config_memstatus(
+static int SQLITE_TCLAPI test_config_memstatus(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int enable, rc;
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN");
     return TCL_ERROR;
   }
   if( Tcl_GetBooleanFromObj(interp, objv[1], &enable) ) return TCL_ERROR;
   rc = sqlite3_config(SQLITE_CONFIG_MEMSTATUS, enable);
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_config_lookaside  SIZE  COUNT
 **
 */
-static int test_config_lookaside(
+static int SQLITE_TCLAPI test_config_lookaside(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int sz, cnt;
   Tcl_Obj *pRet;
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "SIZE COUNT");
     return TCL_ERROR;
@@ skipping 13 matching lines @@
 }
 
 
 /*
 ** Usage:    sqlite3_db_config_lookaside  CONNECTION  BUFID  SIZE  COUNT
 **
 ** There are two static buffers with BUFID 1 and 2.   Each static buffer
 ** is 10KB in size.  A BUFID of 0 indicates that the buffer should be NULL
 ** which will cause sqlite3_db_config() to allocate space on its own.
 */
-static int test_db_config_lookaside(
+static int SQLITE_TCLAPI test_db_config_lookaside(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;
   int sz, cnt;
   sqlite3 *db;
   int bufid;
   static char azBuf[2][10000];
   extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
   if( objc!=5 ){
     Tcl_WrongNumArgs(interp, 1, objv, "BUFID SIZE COUNT");
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &bufid) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[3], &sz) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[4], &cnt) ) return TCL_ERROR;
   if( bufid==0 ){
-    rc = sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE, 0, sz, cnt);
+    rc = sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE, (void*)0, sz, cnt);
   }else if( bufid>=1 && bufid<=2 && sz*cnt<=sizeof(azBuf[0]) ){
     rc = sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE, azBuf[bufid], sz,cnt);
   }else{
     Tcl_AppendResult(interp, "illegal arguments - see documentation", (char*)0);
     return TCL_ERROR;
   }
   Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_config_heap NBYTE NMINALLOC
 */
-static int test_config_heap(
+static int SQLITE_TCLAPI test_config_heap(
   void * clientData, 
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   static char *zBuf; /* Use this memory */
   int nByte;         /* Size of buffer to pass to sqlite3_config() */
   int nMinAlloc;     /* Size of minimum allocation */
   int rc;            /* Return code of sqlite3_config() */
 
@@ skipping 16 matching lines @@
     rc = sqlite3_config(SQLITE_CONFIG_HEAP, zBuf, nByte, nMinAlloc);
   }
 
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_config_heap_size NBYTE
 */
-static int test_config_heap_size(
+static int SQLITE_TCLAPI test_config_heap_size(
   void * clientData, 
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int nByte;         /* Size to pass to sqlite3_config() */
   int rc;            /* Return code of sqlite3_config() */
 
   Tcl_Obj * CONST *aArg = &objv[1];
   int nArg = objc-1;
 
   if( nArg!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "NBYTE");
     return TCL_ERROR;
   }
   if( Tcl_GetIntFromObj(interp, aArg[0], &nByte) ) return TCL_ERROR;
 
   rc = sqlite3_config(SQLITE_CONFIG_WIN32_HEAPSIZE, nByte);
 
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_config_error  [DB]
 **
 ** Invoke sqlite3_config() or sqlite3_db_config() with invalid
 ** opcodes and verify that they return errors.
 */
-static int test_config_error(
+static int SQLITE_TCLAPI test_config_error(
   void * clientData, 
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   sqlite3 *db;
   extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
 
   if( objc!=2 && objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "[DB]");
@@ skipping 17 matching lines @@
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_config_uri  BOOLEAN
 **
 ** Enables or disables interpretation of URI parameters by default using
 ** SQLITE_CONFIG_URI.
 */
-static int test_config_uri(
+static int SQLITE_TCLAPI test_config_uri(
   void * clientData, 
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;
   int bOpenUri;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "BOOL");
     return TCL_ERROR;
   }
   if( Tcl_GetBooleanFromObj(interp, objv[1], &bOpenUri) ){
     return TCL_ERROR;
   }
 
   rc = sqlite3_config(SQLITE_CONFIG_URI, bOpenUri);
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
 
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_config_cis  BOOLEAN
 **
 ** Enables or disables the use of the covering-index scan optimization.
 ** SQLITE_CONFIG_COVERING_INDEX_SCAN.
 */
-static int test_config_cis(
+static int SQLITE_TCLAPI test_config_cis(
   void * clientData, 
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;
   int bUseCis;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "BOOL");
     return TCL_ERROR;
   }
   if( Tcl_GetBooleanFromObj(interp, objv[1], &bUseCis) ){
     return TCL_ERROR;
   }
 
   rc = sqlite3_config(SQLITE_CONFIG_COVERING_INDEX_SCAN, bUseCis);
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
 
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_config_pmasz  INTEGER
 **
 ** Set the minimum PMA size.
 */
-static int test_config_pmasz(
+static int SQLITE_TCLAPI test_config_pmasz(
   void * clientData, 
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;
   int iPmaSz;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "BOOL");
     return TCL_ERROR;
   }
   if( Tcl_GetIntFromObj(interp, objv[1], &iPmaSz) ){
     return TCL_ERROR;
   }
 
   rc = sqlite3_config(SQLITE_CONFIG_PMASZ, iPmaSz);
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
 
   return TCL_OK;
 }
 
 
 /*
 ** Usage:    sqlite3_dump_memsys3  FILENAME
 **           sqlite3_dump_memsys5  FILENAME
 **
 ** Write a summary of unfreed memsys3 allocations to FILENAME.
 */
-static int test_dump_memsys3(
+static int SQLITE_TCLAPI test_dump_memsys3(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
     return TCL_ERROR;
   }
 
@@ skipping 15 matching lines @@
   }
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_status  OPCODE  RESETFLAG
 **
 ** Return a list of three elements which are the sqlite3_status() return
 ** code, the current value, and the high-water mark value.
 */
-static int test_status(
+static int SQLITE_TCLAPI test_status(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc, iValue, mxValue;
   int i, op = 0, resetFlag;
   const char *zOpName;
   static const struct {
     const char *zName;
@@ skipping 36 matching lines @@
   Tcl_SetObjResult(interp, pResult);
   return TCL_OK;
 }
 
 /*
 ** Usage:    sqlite3_db_status  DATABASE  OPCODE  RESETFLAG
 **
 ** Return a list of three elements which are the sqlite3_db_status() return
 ** code, the current value, and the high-water mark value.
 */
-static int test_db_status(
+static int SQLITE_TCLAPI test_db_status(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc, iValue, mxValue;
   int i, op = 0, resetFlag;
   const char *zOpName;
   sqlite3 *db;
   extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
   static const struct {
     const char *zName;
     int op;
   } aOp[] = {
     { "LOOKASIDE_USED",      SQLITE_DBSTATUS_LOOKASIDE_USED      },
     { "CACHE_USED",          SQLITE_DBSTATUS_CACHE_USED          },
     { "SCHEMA_USED",         SQLITE_DBSTATUS_SCHEMA_USED         },
     { "STMT_USED",           SQLITE_DBSTATUS_STMT_USED           },
     { "LOOKASIDE_HIT",       SQLITE_DBSTATUS_LOOKASIDE_HIT       },
     { "LOOKASIDE_MISS_SIZE", SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE },
     { "LOOKASIDE_MISS_FULL", SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL },
     { "CACHE_HIT",           SQLITE_DBSTATUS_CACHE_HIT           },
     { "CACHE_MISS",          SQLITE_DBSTATUS_CACHE_MISS          },
     { "CACHE_WRITE",         SQLITE_DBSTATUS_CACHE_WRITE         },
-    { "DEFERRED_FKS",        SQLITE_DBSTATUS_DEFERRED_FKS        }
+    { "DEFERRED_FKS",        SQLITE_DBSTATUS_DEFERRED_FKS        },
+    { "CACHE_USED_SHARED",   SQLITE_DBSTATUS_CACHE_USED_SHARED   },
   };
   Tcl_Obj *pResult;
   if( objc!=4 ){
     Tcl_WrongNumArgs(interp, 1, objv, "DB PARAMETER RESETFLAG");
     return TCL_ERROR;
   }
   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
   zOpName = Tcl_GetString(objv[2]);
   if( memcmp(zOpName, "SQLITE_", 7)==0 ) zOpName += 7;
   if( memcmp(zOpName, "DBSTATUS_", 9)==0 ) zOpName += 9;
@@ skipping 14 matching lines @@
   Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc));
   Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(iValue));
   Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(mxValue));
   Tcl_SetObjResult(interp, pResult);
   return TCL_OK;
 }
 
 /*
 ** install_malloc_faultsim BOOLEAN
 */
-static int test_install_malloc_faultsim(
+static int SQLITE_TCLAPI test_install_malloc_faultsim(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;
   int isInstall;
 
   if( objc!=2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN");
     return TCL_ERROR;
   }
   if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[1], &isInstall) ){
     return TCL_ERROR;
   }
   rc = faultsimInstall(isInstall);
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
   return TCL_OK;
 }
 
 /*
 ** sqlite3_install_memsys3
 */
-static int test_install_memsys3(
+static int SQLITE_TCLAPI test_install_memsys3(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc = SQLITE_MISUSE;
 #ifdef SQLITE_ENABLE_MEMSYS3
   const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
   rc = sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetMemsys3());
 #endif
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
   return TCL_OK;
 }
 
-static int test_vfs_oom_test(
+static int SQLITE_TCLAPI test_vfs_oom_test(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   extern int sqlite3_memdebug_vfs_oom_test;
   if( objc>2 ){
     Tcl_WrongNumArgs(interp, 1, objv, "?INTEGER?");
     return TCL_ERROR;
   }else if( objc==2 ){
@@ skipping 49 matching lines @@
      { "sqlite3_memdebug_vfs_oom_test", test_vfs_oom_test          ,0 },
   };
   int i;
   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
     ClientData c = (ClientData)SQLITE_INT_TO_PTR(aObjCmd[i].clientData);
     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, c, 0);
   }
   return TCL_OK;
 }
 #endif