[sql] Import reference version of SQLite 3.8.7.4.

third_party/sqlite/sqlite-src-3080704/src/test_init.c

 /*
 ** 2009 August 17
 **
 ** 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.
 **
@@ skipping 12 matching lines @@
 **      of those subsystems that were initialized, and
 **   3) A subsequent call to sqlite3_initialize() attempts to initialize
 **      the remaining, uninitialized, subsystems.
 */
 
 #include "sqliteInt.h"
 #include <string.h>
 #include <tcl.h>
 
 static struct Wrapped {
-  sqlite3_pcache_methods pcache;
-  sqlite3_mem_methods    mem;
-  sqlite3_mutex_methods  mutex;
+  sqlite3_pcache_methods2 pcache;
+  sqlite3_mem_methods     mem;
+  sqlite3_mutex_methods   mutex;
 
   int mem_init;                /* True if mem subsystem is initalized */
   int mem_fail;                /* True to fail mem subsystem inialization */
   int mutex_init;              /* True if mutex subsystem is initalized */
   int mutex_fail;              /* True to fail mutex subsystem inialization */
   int pcache_init;             /* True if pcache subsystem is initalized */
   int pcache_fail;             /* True to fail pcache subsystem inialization */
 } wrapped;
 
 static int wrMemInit(void *pAppData){
@@ skipping 70 matching lines @@
   if( rc==SQLITE_OK ){
     wrapped.pcache_init = 1;
   }
   return rc;
 }
 static void wrPCacheShutdown(void *pArg){
   wrapped.pcache.xShutdown(wrapped.pcache.pArg);
   wrapped.pcache_init = 0;
 }
 
-static sqlite3_pcache *wrPCacheCreate(int a, int b){
-  return wrapped.pcache.xCreate(a, b);
+static sqlite3_pcache *wrPCacheCreate(int a, int b, int c){
+  return wrapped.pcache.xCreate(a, b, c);
 }  
 static void wrPCacheCachesize(sqlite3_pcache *p, int n){
   wrapped.pcache.xCachesize(p, n);
 }  
 static int wrPCachePagecount(sqlite3_pcache *p){
   return wrapped.pcache.xPagecount(p);
 }  
-static void *wrPCacheFetch(sqlite3_pcache *p, unsigned a, int b){
+static sqlite3_pcache_page *wrPCacheFetch(sqlite3_pcache *p, unsigned a, int b){
   return wrapped.pcache.xFetch(p, a, b);
 }  
-static void wrPCacheUnpin(sqlite3_pcache *p, void *a, int b){
+static void wrPCacheUnpin(sqlite3_pcache *p, sqlite3_pcache_page *a, int b){
   wrapped.pcache.xUnpin(p, a, b);
 }  
-static void wrPCacheRekey(sqlite3_pcache *p, void *a, unsigned b, unsigned c){
+static void wrPCacheRekey(
+  sqlite3_pcache *p, 
+  sqlite3_pcache_page *a, 
+  unsigned b, 
+  unsigned c
+){
   wrapped.pcache.xRekey(p, a, b, c);
 }  
 static void wrPCacheTruncate(sqlite3_pcache *p, unsigned a){
   wrapped.pcache.xTruncate(p, a);
 }  
 static void wrPCacheDestroy(sqlite3_pcache *p){
   wrapped.pcache.xDestroy(p);
 }  
 
 static void installInitWrappers(void){
   sqlite3_mutex_methods mutexmethods = {
     wrMutexInit,  wrMutexEnd,   wrMutexAlloc,
     wrMutexFree,  wrMutexEnter, wrMutexTry,
     wrMutexLeave, wrMutexHeld,  wrMutexNotheld
   };
-  sqlite3_pcache_methods pcachemethods = {
-    0,
+  sqlite3_pcache_methods2 pcachemethods = {
+    1, 0,
     wrPCacheInit,      wrPCacheShutdown,  wrPCacheCreate, 
     wrPCacheCachesize, wrPCachePagecount, wrPCacheFetch,
     wrPCacheUnpin,     wrPCacheRekey,     wrPCacheTruncate,  
     wrPCacheDestroy
   };
   sqlite3_mem_methods memmethods = {
     wrMemMalloc,   wrMemFree,    wrMemRealloc,
     wrMemSize,     wrMemRoundup, wrMemInit,
     wrMemShutdown,
     0
   };
 
   memset(&wrapped, 0, sizeof(wrapped));
 
   sqlite3_shutdown();
   sqlite3_config(SQLITE_CONFIG_GETMUTEX, &wrapped.mutex);
   sqlite3_config(SQLITE_CONFIG_GETMALLOC, &wrapped.mem);
-  sqlite3_config(SQLITE_CONFIG_GETPCACHE, &wrapped.pcache);
+  sqlite3_config(SQLITE_CONFIG_GETPCACHE2, &wrapped.pcache);
   sqlite3_config(SQLITE_CONFIG_MUTEX, &mutexmethods);
   sqlite3_config(SQLITE_CONFIG_MALLOC, &memmethods);
-  sqlite3_config(SQLITE_CONFIG_PCACHE, &pcachemethods);
+  sqlite3_config(SQLITE_CONFIG_PCACHE2, &pcachemethods);
 }
 
 static int init_wrapper_install(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   int i;
   installInitWrappers();
@@ skipping 17 matching lines @@
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   if( objc!=1 ){
     Tcl_WrongNumArgs(interp, 1, objv, "");
     return TCL_ERROR;
   }
 
-  memset(&wrapped, 0, sizeof(&wrapped));
   sqlite3_shutdown();
   sqlite3_config(SQLITE_CONFIG_MUTEX, &wrapped.mutex);
   sqlite3_config(SQLITE_CONFIG_MALLOC, &wrapped.mem);
-  sqlite3_config(SQLITE_CONFIG_PCACHE, &wrapped.pcache);
+  sqlite3_config(SQLITE_CONFIG_PCACHE2, &wrapped.pcache);
   return TCL_OK;
 }
 
 static int init_wrapper_clear(
   ClientData clientData, /* Unused */
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int objc,              /* Number of arguments */
   Tcl_Obj *CONST objv[]  /* Command arguments */
 ){
   if( objc!=1 ){
@@ skipping 46 matching lines @@
     {"init_wrapper_clear",     init_wrapper_clear}
   };
   int i;
 
   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
   }
 
   return TCL_OK;
 }