1 /*

     2 ** 2001 September 15

     3 **

     4 ** The author disclaims copyright to this source code.  In place of

     5 ** a legal notice, here is a blessing:

     6 **

     7 **    May you do good and not evil.

     8 **    May you find forgiveness for yourself and forgive others.

     9 **    May you share freely, never taking more than you give.

    10 **

    11 *************************************************************************

    12 ** Utility functions used throughout sqlite.

    13 **

    14 ** This file contains functions for allocating memory, comparing

    15 ** strings, and stuff like that.

    16 **

    17 ** $Id: util.c,v 1.192 2006/07/26 01:39:30 drh Exp $

    18 */

    19 #include "sqliteInt.h"

    20 #include "os.h"

    21 #include <stdarg.h>

    22 #include <ctype.h>

    23 

    24 /*

    25 ** MALLOC WRAPPER ARCHITECTURE

    26 **

    27 ** The sqlite code accesses dynamic memory allocation/deallocation by invoking

    28 ** the following six APIs (which may be implemented as macros).

    29 **

    30 **     sqlite3Malloc()

    31 **     sqlite3MallocRaw()

    32 **     sqlite3Realloc()

    33 **     sqlite3ReallocOrFree()

    34 **     sqlite3Free()

    35 **     sqlite3AllocSize()

    36 **

    37 ** The function sqlite3FreeX performs the same task as sqlite3Free and is

    38 ** guaranteed to be a real function. The same holds for sqlite3MallocX

    39 **

    40 ** The above APIs are implemented in terms of the functions provided in the

    41 ** operating-system interface. The OS interface is never accessed directly

    42 ** by code outside of this file.

    43 **

    44 **     sqlite3OsMalloc()

    45 **     sqlite3OsRealloc()

    46 **     sqlite3OsFree()

    47 **     sqlite3OsAllocationSize()

    48 **

    49 ** Functions sqlite3MallocRaw() and sqlite3Realloc() may invoke 

    50 ** sqlite3_release_memory() if a call to sqlite3OsMalloc() or

    51 ** sqlite3OsRealloc() fails (or if the soft-heap-limit for the thread is

    52 ** exceeded). Function sqlite3Malloc() usually invokes

    53 ** sqlite3MallocRaw().

    54 **

    55 ** MALLOC TEST WRAPPER ARCHITECTURE

    56 **

    57 ** The test wrapper provides extra test facilities to ensure the library 

    58 ** does not leak memory and handles the failure of the underlying OS level

    59 ** allocation system correctly. It is only present if the library is 

    60 ** compiled with the SQLITE_MEMDEBUG macro set.

    61 **

    62 **     * Guardposts to detect overwrites.

    63 **     * Ability to cause a specific Malloc() or Realloc() to fail.

    64 **     * Audit outstanding memory allocations (i.e check for leaks).

    65 */

    66 

    67 #define MAX(x,y) ((x)>(y)?(x):(y))

    68 

    69 #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO)

    70 /*

    71 ** Set the soft heap-size limit for the current thread. Passing a negative

    72 ** value indicates no limit.

    73 */

    74 void sqlite3_soft_heap_limit(int n){

    75   ThreadData *pTd = sqlite3ThreadData();

    76   if( pTd ){

    77     pTd->nSoftHeapLimit = n;

    78   }

    79   sqlite3ReleaseThreadData();

    80 }

    81 

    82 /*

    83 ** Release memory held by SQLite instances created by the current thread.

    84 */

    85 int sqlite3_release_memory(int n){

    86   return sqlite3pager_release_memory(n);

    87 }

    88 #else

    89 /* If SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined, then define a version

    90 ** of sqlite3_release_memory() to be used by other code in this file.

    91 ** This is done for no better reason than to reduce the number of 

    92 ** pre-processor #ifndef statements.

    93 */

    94 #define sqlite3_release_memory(x) 0    /* 0 == no memory freed */

    95 #endif

    96 

    97 #ifdef SQLITE_MEMDEBUG

    98 /*--------------------------------------------------------------------------

    99 ** Begin code for memory allocation system test layer.

   100 **

   101 ** Memory debugging is turned on by defining the SQLITE_MEMDEBUG macro.

   102 **

   103 ** SQLITE_MEMDEBUG==1    -> Fence-posting only (thread safe) 

   104 ** SQLITE_MEMDEBUG==2    -> Fence-posting + linked list of allocations (not ts)

   105 ** SQLITE_MEMDEBUG==3    -> Above + backtraces (not thread safe, req. glibc)

   106 */

   107 

   108 /* Figure out whether or not to store backtrace() information for each malloc.

   109 ** The backtrace() function is only used if SQLITE_MEMDEBUG is set to 2 or 

   110 ** greater and glibc is in use. If we don't want to use backtrace(), then just

   111 ** define it as an empty macro and set the amount of space reserved to 0.

   112 */

   113 #if defined(__GLIBC__) && SQLITE_MEMDEBUG>2

   114   extern int backtrace(void **, int);

   115   #define TESTALLOC_STACKSIZE 128

   116   #define TESTALLOC_STACKFRAMES ((TESTALLOC_STACKSIZE-8)/sizeof(void*))

   117 #else

   118   #define backtrace(x, y)

   119   #define TESTALLOC_STACKSIZE 0

   120   #define TESTALLOC_STACKFRAMES 0

   121 #endif

   122 

   123 /*

   124 ** Number of 32-bit guard words.  This should probably be a multiple of

   125 ** 2 since on 64-bit machines we want the value returned by sqliteMalloc()

   126 ** to be 8-byte aligned.

   127 */

   128 #ifndef TESTALLOC_NGUARD

   129 # define TESTALLOC_NGUARD 2

   130 #endif

   131 

   132 /*

   133 ** Size reserved for storing file-name along with each malloc()ed blob.

   134 */

   135 #define TESTALLOC_FILESIZE 64

   136 

   137 /*

   138 ** Size reserved for storing the user string. Each time a Malloc() or Realloc()

   139 ** call succeeds, up to TESTALLOC_USERSIZE bytes of the string pointed to by

   140 ** sqlite3_malloc_id are stored along with the other test system metadata.

   141 */

   142 #define TESTALLOC_USERSIZE 64

   143 const char *sqlite3_malloc_id = 0;

   144 

   145 /*

   146 ** Blocks used by the test layer have the following format:

   147 **

   148 **        <sizeof(void *) pNext pointer>

   149 **        <sizeof(void *) pPrev pointer>

   150 **        <TESTALLOC_NGUARD 32-bit guard words>

   151 **            <The application level allocation>

   152 **        <TESTALLOC_NGUARD 32-bit guard words>

   153 **        <32-bit line number>

   154 **        <TESTALLOC_FILESIZE bytes containing null-terminated file name>

   155 **        <TESTALLOC_STACKSIZE bytes of backtrace() output>

   156 */ 

   157 

   158 #define TESTALLOC_OFFSET_GUARD1(p)    (sizeof(void *) * 2)

   159 #define TESTALLOC_OFFSET_DATA(p) ( \

   160   TESTALLOC_OFFSET_GUARD1(p) + sizeof(u32) * TESTALLOC_NGUARD \

   161 )

   162 #define TESTALLOC_OFFSET_GUARD2(p) ( \

   163   TESTALLOC_OFFSET_DATA(p) + sqlite3OsAllocationSize(p) - TESTALLOC_OVERHEAD \

   164 )

   165 #define TESTALLOC_OFFSET_LINENUMBER(p) ( \

   166   TESTALLOC_OFFSET_GUARD2(p) + sizeof(u32) * TESTALLOC_NGUARD \

   167 )

   168 #define TESTALLOC_OFFSET_FILENAME(p) ( \

   169   TESTALLOC_OFFSET_LINENUMBER(p) + sizeof(u32) \

   170 )

   171 #define TESTALLOC_OFFSET_USER(p) ( \

   172   TESTALLOC_OFFSET_FILENAME(p) + TESTALLOC_FILESIZE \

   173 )

   174 #define TESTALLOC_OFFSET_STACK(p) ( \

   175   TESTALLOC_OFFSET_USER(p) + TESTALLOC_USERSIZE + 8 - \

   176   (TESTALLOC_OFFSET_USER(p) % 8) \

   177 )

   178 

   179 #define TESTALLOC_OVERHEAD ( \

   180   sizeof(void *)*2 +                   /* pPrev and pNext pointers */   \

   181   TESTALLOC_NGUARD*sizeof(u32)*2 +              /* Guard words */       \

   182   sizeof(u32) + TESTALLOC_FILESIZE +   /* File and line number */       \

   183   TESTALLOC_USERSIZE +                 /* User string */                \

   184   TESTALLOC_STACKSIZE                  /* backtrace() stack */          \

   185 )

   186 

   187 

   188 /*

   189 ** For keeping track of the number of mallocs and frees.   This

   190 ** is used to check for memory leaks.  The iMallocFail and iMallocReset

   191 ** values are used to simulate malloc() failures during testing in 

   192 ** order to verify that the library correctly handles an out-of-memory

   193 ** condition.

   194 */

   195 int sqlite3_nMalloc;         /* Number of sqliteMalloc() calls */

   196 int sqlite3_nFree;           /* Number of sqliteFree() calls */

   197 int sqlite3_memUsed;         /* TODO Total memory obtained from malloc */

   198 int sqlite3_memMax;          /* TODO Mem usage high-water mark */

   199 int sqlite3_iMallocFail;     /* Fail sqliteMalloc() after this many calls */

   200 int sqlite3_iMallocReset = -1; /* When iMallocFail reaches 0, set to this */

   201 

   202 void *sqlite3_pFirst = 0;         /* Pointer to linked list of allocations */

   203 int sqlite3_nMaxAlloc = 0;        /* High water mark of ThreadData.nAlloc */

   204 int sqlite3_mallocDisallowed = 0; /* assert() in sqlite3Malloc() if set */

   205 int sqlite3_isFail = 0;           /* True if all malloc calls should fail */

   206 const char *sqlite3_zFile = 0;    /* Filename to associate debug info with */

   207 int sqlite3_iLine = 0;            /* Line number for debug info */

   208 

   209 /*

   210 ** Check for a simulated memory allocation failure.  Return true if

   211 ** the failure should be simulated.  Return false to proceed as normal.

   212 */

   213 int sqlite3TestMallocFail(){

   214   if( sqlite3_isFail ){

   215     return 1;

   216   }

   217   if( sqlite3_iMallocFail>=0 ){

   218     sqlite3_iMallocFail--;

   219     if( sqlite3_iMallocFail==0 ){

   220       sqlite3_iMallocFail = sqlite3_iMallocReset;

   221       sqlite3_isFail = 1;

   222       return 1;

   223     }

   224   }

   225   return 0;

   226 }

   227 

   228 /*

   229 ** The argument is a pointer returned by sqlite3OsMalloc() or xRealloc().

   230 ** assert() that the first and last (TESTALLOC_NGUARD*4) bytes are set to the

   231 ** values set by the applyGuards() function.

   232 */

   233 static void checkGuards(u32 *p)

   234 {

   235   int i;

   236   char *zAlloc = (char *)p;

   237   char *z;

   238 

   239   /* First set of guard words */

   240   z = &zAlloc[TESTALLOC_OFFSET_GUARD1(p)];

   241   for(i=0; i<TESTALLOC_NGUARD; i++){

   242     assert(((u32 *)z)[i]==0xdead1122);

   243   }

   244 

   245   /* Second set of guard words */

   246   z = &zAlloc[TESTALLOC_OFFSET_GUARD2(p)];

   247   for(i=0; i<TESTALLOC_NGUARD; i++){

   248     u32 guard = 0;

   249     memcpy(&guard, &z[i*sizeof(u32)], sizeof(u32));

   250     assert(guard==0xdead3344);

   251   }

   252 }

   253 

   254 /*

   255 ** The argument is a pointer returned by sqlite3OsMalloc() or Realloc(). The

   256 ** first and last (TESTALLOC_NGUARD*4) bytes are set to known values for use as 

   257 ** guard-posts.

   258 */

   259 static void applyGuards(u32 *p)

   260 {

   261   int i;

   262   char *z;

   263   char *zAlloc = (char *)p;

   264 

   265   /* First set of guard words */

   266   z = &zAlloc[TESTALLOC_OFFSET_GUARD1(p)];

   267   for(i=0; i<TESTALLOC_NGUARD; i++){

   268     ((u32 *)z)[i] = 0xdead1122;

   269   }

   270 

   271   /* Second set of guard words */

   272   z = &zAlloc[TESTALLOC_OFFSET_GUARD2(p)];

   273   for(i=0; i<TESTALLOC_NGUARD; i++){

   274     static const int guard = 0xdead3344;

   275     memcpy(&z[i*sizeof(u32)], &guard, sizeof(u32));

   276   }

   277 

   278   /* Line number */

   279   z = &((char *)z)[TESTALLOC_NGUARD*sizeof(u32)];             /* Guard words */

   280   z = &zAlloc[TESTALLOC_OFFSET_LINENUMBER(p)];

   281   memcpy(z, &sqlite3_iLine, sizeof(u32));

   282 

   283   /* File name */

   284   z = &zAlloc[TESTALLOC_OFFSET_FILENAME(p)];

   285   strncpy(z, sqlite3_zFile, TESTALLOC_FILESIZE);

   286   z[TESTALLOC_FILESIZE - 1] = '\0';

   287 

   288   /* User string */

   289   z = &zAlloc[TESTALLOC_OFFSET_USER(p)];

   290   z[0] = 0;

   291   if( sqlite3_malloc_id ){

   292     strncpy(z, sqlite3_malloc_id, TESTALLOC_USERSIZE);

   293     z[TESTALLOC_USERSIZE-1] = 0;

   294   }

   295 

   296   /* backtrace() stack */

   297   z = &zAlloc[TESTALLOC_OFFSET_STACK(p)];

   298   backtrace((void **)z, TESTALLOC_STACKFRAMES);

   299 

   300   /* Sanity check to make sure checkGuards() is working */

   301   checkGuards(p);

   302 }

   303 

   304 /*

   305 ** The argument is a malloc()ed pointer as returned by the test-wrapper.

   306 ** Return a pointer to the Os level allocation.

   307 */

   308 static void *getOsPointer(void *p)

   309 {

   310   char *z = (char *)p;

   311   return (void *)(&z[-1 * TESTALLOC_OFFSET_DATA(p)]);

   312 }

   313 

   314 

   315 #if SQLITE_MEMDEBUG>1

   316 /*

   317 ** The argument points to an Os level allocation. Link it into the threads list

   318 ** of allocations.

   319 */

   320 static void linkAlloc(void *p){

   321   void **pp = (void **)p;

   322   pp[0] = 0;

   323   pp[1] = sqlite3_pFirst;

   324   if( sqlite3_pFirst ){

   325     ((void **)sqlite3_pFirst)[0] = p;

   326   }

   327   sqlite3_pFirst = p;

   328 }

   329 

   330 /*

   331 ** The argument points to an Os level allocation. Unlinke it from the threads

   332 ** list of allocations.

   333 */

   334 static void unlinkAlloc(void *p)

   335 {

   336   void **pp = (void **)p;

   337   if( p==sqlite3_pFirst ){

   338     assert(!pp[0]);

   339     assert(!pp[1] || ((void **)(pp[1]))[0]==p);

   340     sqlite3_pFirst = pp[1];

   341     if( sqlite3_pFirst ){

   342       ((void **)sqlite3_pFirst)[0] = 0;

   343     }

   344   }else{

   345     void **pprev = pp[0];

   346     void **pnext = pp[1];

   347     assert(pprev);

   348     assert(pprev[1]==p);

   349     pprev[1] = (void *)pnext;

   350     if( pnext ){

   351       assert(pnext[0]==p);

   352       pnext[0] = (void *)pprev;

   353     }

   354   }

   355 }

   356 

   357 /*

   358 ** Pointer p is a pointer to an OS level allocation that has just been

   359 ** realloc()ed. Set the list pointers that point to this entry to it's new

   360 ** location.

   361 */

   362 static void relinkAlloc(void *p)

   363 {

   364   void **pp = (void **)p;

   365   if( pp[0] ){

   366     ((void **)(pp[0]))[1] = p;

   367   }else{

   368     sqlite3_pFirst = p;

   369   }

   370   if( pp[1] ){

   371     ((void **)(pp[1]))[0] = p;

   372   }

   373 }

   374 #else

   375 #define linkAlloc(x)

   376 #define relinkAlloc(x)

   377 #define unlinkAlloc(x)

   378 #endif

   379 

   380 /*

   381 ** This function sets the result of the Tcl interpreter passed as an argument

   382 ** to a list containing an entry for each currently outstanding call made to 

   383 ** sqliteMalloc and friends by the current thread. Each list entry is itself a

   384 ** list, consisting of the following (in order):

   385 **

   386 **     * The number of bytes allocated

   387 **     * The __FILE__ macro at the time of the sqliteMalloc() call.

   388 **     * The __LINE__ macro ...

   389 **     * The value of the sqlite3_malloc_id variable ...

   390 **     * The output of backtrace() (if available) ...

   391 **

   392 ** Todo: We could have a version of this function that outputs to stdout, 

   393 ** to debug memory leaks when Tcl is not available.

   394 */

   395 #if defined(TCLSH) && defined(SQLITE_DEBUG) && SQLITE_MEMDEBUG>1

   396 #include <tcl.h>

   397 int sqlite3OutstandingMallocs(Tcl_Interp *interp){

   398   void *p;

   399   Tcl_Obj *pRes = Tcl_NewObj();

   400   Tcl_IncrRefCount(pRes);

   401 

   402 

   403   for(p=sqlite3_pFirst; p; p=((void **)p)[1]){

   404     Tcl_Obj *pEntry = Tcl_NewObj();

   405     Tcl_Obj *pStack = Tcl_NewObj();

   406     char *z;

   407     u32 iLine;

   408     int nBytes = sqlite3OsAllocationSize(p) - TESTALLOC_OVERHEAD;

   409     char *zAlloc = (char *)p;

   410     int i;

   411 

   412     Tcl_ListObjAppendElement(0, pEntry, Tcl_NewIntObj(nBytes));

   413 

   414     z = &zAlloc[TESTALLOC_OFFSET_FILENAME(p)];

   415     Tcl_ListObjAppendElement(0, pEntry, Tcl_NewStringObj(z, -1));

   416 

   417     z = &zAlloc[TESTALLOC_OFFSET_LINENUMBER(p)];

   418     memcpy(&iLine, z, sizeof(u32));

   419     Tcl_ListObjAppendElement(0, pEntry, Tcl_NewIntObj(iLine));

   420 

   421     z = &zAlloc[TESTALLOC_OFFSET_USER(p)];

   422     Tcl_ListObjAppendElement(0, pEntry, Tcl_NewStringObj(z, -1));

   423 

   424     z = &zAlloc[TESTALLOC_OFFSET_STACK(p)];

   425     for(i=0; i<TESTALLOC_STACKFRAMES; i++){

   426       char zHex[128];

   427       sprintf(zHex, "%p", ((void **)z)[i]);

   428       Tcl_ListObjAppendElement(0, pStack, Tcl_NewStringObj(zHex, -1));

   429     }

   430 

   431     Tcl_ListObjAppendElement(0, pEntry, pStack);

   432     Tcl_ListObjAppendElement(0, pRes, pEntry);

   433   }

   434 

   435   Tcl_ResetResult(interp);

   436   Tcl_SetObjResult(interp, pRes);

   437   Tcl_DecrRefCount(pRes);

   438   return TCL_OK;

   439 }

   440 #endif

   441 

   442 /*

   443 ** This is the test layer's wrapper around sqlite3OsMalloc().

   444 */

   445 static void * OSMALLOC(int n){

   446   sqlite3OsEnterMutex();

   447 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   448   sqlite3_nMaxAlloc = 

   449       MAX(sqlite3_nMaxAlloc, sqlite3ThreadDataReadOnly()->nAlloc);

   450 #endif

   451   assert( !sqlite3_mallocDisallowed );

   452   if( !sqlite3TestMallocFail() ){

   453     u32 *p;

   454     p = (u32 *)sqlite3OsMalloc(n + TESTALLOC_OVERHEAD);

   455     assert(p);

   456     sqlite3_nMalloc++;

   457     applyGuards(p);

   458     linkAlloc(p);

   459     sqlite3OsLeaveMutex();

   460     return (void *)(&p[TESTALLOC_NGUARD + 2*sizeof(void *)/sizeof(u32)]);

   461   }

   462   sqlite3OsLeaveMutex();

   463   return 0;

   464 }

   465 

   466 static int OSSIZEOF(void *p){

   467   if( p ){

   468     u32 *pOs = (u32 *)getOsPointer(p);

   469     return sqlite3OsAllocationSize(pOs) - TESTALLOC_OVERHEAD;

   470   }

   471   return 0;

   472 }

   473 

   474 /*

   475 ** This is the test layer's wrapper around sqlite3OsFree(). The argument is a

   476 ** pointer to the space allocated for the application to use.

   477 */

   478 static void OSFREE(void *pFree){

   479   u32 *p;         /* Pointer to the OS-layer allocation */

   480   sqlite3OsEnterMutex();

   481   p = (u32 *)getOsPointer(pFree);

   482   checkGuards(p);

   483   unlinkAlloc(p);

   484   memset(pFree, 0x55, OSSIZEOF(pFree));

   485   sqlite3OsFree(p);

   486   sqlite3_nFree++;

   487   sqlite3OsLeaveMutex();

   488 }

   489 

   490 /*

   491 ** This is the test layer's wrapper around sqlite3OsRealloc().

   492 */

   493 static void * OSREALLOC(void *pRealloc, int n){

   494 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   495   sqlite3_nMaxAlloc = 

   496       MAX(sqlite3_nMaxAlloc, sqlite3ThreadDataReadOnly()->nAlloc);

   497 #endif

   498   assert( !sqlite3_mallocDisallowed );

   499   if( !sqlite3TestMallocFail() ){

   500     u32 *p = (u32 *)getOsPointer(pRealloc);

   501     checkGuards(p);

   502     p = sqlite3OsRealloc(p, n + TESTALLOC_OVERHEAD);

   503     applyGuards(p);

   504     relinkAlloc(p);

   505     return (void *)(&p[TESTALLOC_NGUARD + 2*sizeof(void *)/sizeof(u32)]);

   506   }

   507   return 0;

   508 }

   509 

   510 static void OSMALLOC_FAILED(){

   511   sqlite3_isFail = 0;

   512 }

   513 

   514 #else

   515 /* Define macros to call the sqlite3OsXXX interface directly if 

   516 ** the SQLITE_MEMDEBUG macro is not defined.

   517 */

   518 #define OSMALLOC(x)        sqlite3OsMalloc(x)

   519 #define OSREALLOC(x,y)     sqlite3OsRealloc(x,y)

   520 #define OSFREE(x)          sqlite3OsFree(x)

   521 #define OSSIZEOF(x)        sqlite3OsAllocationSize(x)

   522 #define OSMALLOC_FAILED()

   523 

   524 #endif  /* SQLITE_MEMDEBUG */

   525 /*

   526 ** End code for memory allocation system test layer.

   527 **--------------------------------------------------------------------------*/

   528 

   529 /*

   530 ** This routine is called when we are about to allocate n additional bytes

   531 ** of memory.  If the new allocation will put is over the soft allocation

   532 ** limit, then invoke sqlite3_release_memory() to try to release some

   533 ** memory before continuing with the allocation.

   534 **

   535 ** This routine also makes sure that the thread-specific-data (TSD) has

   536 ** be allocated.  If it has not and can not be allocated, then return

   537 ** false.  The updateMemoryUsedCount() routine below will deallocate

   538 ** the TSD if it ought to be.

   539 **

   540 ** If SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined, this routine is

   541 ** a no-op

   542 */ 

   543 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   544 static int enforceSoftLimit(int n){

   545   ThreadData *pTsd = sqlite3ThreadData();

   546   if( pTsd==0 ){

   547     return 0;

   548   }

   549   assert( pTsd->nAlloc>=0 );

   550   if( n>0 && pTsd->nSoftHeapLimit>0 ){

   551     while( pTsd->nAlloc+n>pTsd->nSoftHeapLimit && sqlite3_release_memory(n) ){}

   552   }

   553   return 1;

   554 }

   555 #else

   556 # define enforceSoftLimit(X)  1

   557 #endif

   558 

   559 /*

   560 ** Update the count of total outstanding memory that is held in

   561 ** thread-specific-data (TSD).  If after this update the TSD is

   562 ** no longer being used, then deallocate it.

   563 **

   564 ** If SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined, this routine is

   565 ** a no-op

   566 */

   567 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   568 static void updateMemoryUsedCount(int n){

   569   ThreadData *pTsd = sqlite3ThreadData();

   570   if( pTsd ){

   571     pTsd->nAlloc += n;

   572     assert( pTsd->nAlloc>=0 );

   573     if( pTsd->nAlloc==0 && pTsd->nSoftHeapLimit==0 ){

   574       sqlite3ReleaseThreadData();

   575     }

   576   }

   577 }

   578 #else

   579 #define updateMemoryUsedCount(x)  /* no-op */

   580 #endif

   581 

   582 /*

   583 ** Allocate and return N bytes of uninitialised memory by calling

   584 ** sqlite3OsMalloc(). If the Malloc() call fails, attempt to free memory 

   585 ** by calling sqlite3_release_memory().

   586 */

   587 void *sqlite3MallocRaw(int n, int doMemManage){

   588   void *p = 0;

   589   if( n>0 && !sqlite3MallocFailed() && (!doMemManage || enforceSoftLimit(n)) ){

   590     while( (p = OSMALLOC(n))==0 && sqlite3_release_memory(n) ){}

   591     if( !p ){

   592       sqlite3FailedMalloc();

   593       OSMALLOC_FAILED();

   594     }else if( doMemManage ){

   595       updateMemoryUsedCount(OSSIZEOF(p));

   596     }

   597   }

   598   return p;

   599 }

   600 

   601 /*

   602 ** Resize the allocation at p to n bytes by calling sqlite3OsRealloc(). The

   603 ** pointer to the new allocation is returned.  If the Realloc() call fails,

   604 ** attempt to free memory by calling sqlite3_release_memory().

   605 */

   606 void *sqlite3Realloc(void *p, int n){

   607   if( sqlite3MallocFailed() ){

   608     return 0;

   609   }

   610 

   611   if( !p ){

   612     return sqlite3Malloc(n, 1);

   613   }else{

   614     void *np = 0;

   615 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   616     int origSize = OSSIZEOF(p);

   617 #endif

   618     if( enforceSoftLimit(n - origSize) ){

   619       while( (np = OSREALLOC(p, n))==0 && sqlite3_release_memory(n) ){}

   620       if( !np ){

   621         sqlite3FailedMalloc();

   622         OSMALLOC_FAILED();

   623       }else{

   624         updateMemoryUsedCount(OSSIZEOF(np) - origSize);

   625       }

   626     }

   627     return np;

   628   }

   629 }

   630 

   631 /*

   632 ** Free the memory pointed to by p. p must be either a NULL pointer or a 

   633 ** value returned by a previous call to sqlite3Malloc() or sqlite3Realloc().

   634 */

   635 void sqlite3FreeX(void *p){

   636   if( p ){

   637     updateMemoryUsedCount(0 - OSSIZEOF(p));

   638     OSFREE(p);

   639   }

   640 }

   641 

   642 /*

   643 ** A version of sqliteMalloc() that is always a function, not a macro.

   644 ** Currently, this is used only to alloc to allocate the parser engine.

   645 */

   646 void *sqlite3MallocX(int n){

   647   return sqliteMalloc(n);

   648 }

   649 

   650 /*

   651 ** sqlite3Malloc

   652 ** sqlite3ReallocOrFree

   653 **

   654 ** These two are implemented as wrappers around sqlite3MallocRaw(), 

   655 ** sqlite3Realloc() and sqlite3Free().

   656 */ 

   657 void *sqlite3Malloc(int n, int doMemManage){

   658   void *p = sqlite3MallocRaw(n, doMemManage);

   659   if( p ){

   660     memset(p, 0, n);

   661   }

   662   return p;

   663 }

   664 void sqlite3ReallocOrFree(void **pp, int n){

   665   void *p = sqlite3Realloc(*pp, n);

   666   if( !p ){

   667     sqlite3FreeX(*pp);

   668   }

   669   *pp = p;

   670 }

   671 

   672 /*

   673 ** sqlite3ThreadSafeMalloc() and sqlite3ThreadSafeFree() are used in those

   674 ** rare scenarios where sqlite may allocate memory in one thread and free

   675 ** it in another. They are exactly the same as sqlite3Malloc() and 

   676 ** sqlite3Free() except that:

   677 **

   678 **   * The allocated memory is not included in any calculations with 

   679 **     respect to the soft-heap-limit, and

   680 **

   681 **   * sqlite3ThreadSafeMalloc() must be matched with ThreadSafeFree(),

   682 **     not sqlite3Free(). Calling sqlite3Free() on memory obtained from

   683 **     ThreadSafeMalloc() will cause an error somewhere down the line.

   684 */

   685 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   686 void *sqlite3ThreadSafeMalloc(int n){

   687   (void)ENTER_MALLOC;

   688   return sqlite3Malloc(n, 0);

   689 }

   690 void sqlite3ThreadSafeFree(void *p){

   691   (void)ENTER_MALLOC;

   692   if( p ){

   693     OSFREE(p);

   694   }

   695 }

   696 #endif

   697 

   698 

   699 /*

   700 ** Return the number of bytes allocated at location p. p must be either 

   701 ** a NULL pointer (in which case 0 is returned) or a pointer returned by 

   702 ** sqlite3Malloc(), sqlite3Realloc() or sqlite3ReallocOrFree().

   703 **

   704 ** The number of bytes allocated does not include any overhead inserted by 

   705 ** any malloc() wrapper functions that may be called. So the value returned

   706 ** is the number of bytes that were available to SQLite using pointer p, 

   707 ** regardless of how much memory was actually allocated.

   708 */

   709 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

   710 int sqlite3AllocSize(void *p){

   711   return OSSIZEOF(p);

   712 }

   713 #endif

   714 

   715 /*

   716 ** Make a copy of a string in memory obtained from sqliteMalloc(). These 

   717 ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This

   718 ** is because when memory debugging is turned on, these two functions are 

   719 ** called via macros that record the current file and line number in the

   720 ** ThreadData structure.

   721 */

   722 char *sqlite3StrDup(const char *z){

   723   char *zNew;

   724   if( z==0 ) return 0;

   725   zNew = sqlite3MallocRaw(strlen(z)+1, 1);

   726   if( zNew ) strcpy(zNew, z);

   727   return zNew;

   728 }

   729 char *sqlite3StrNDup(const char *z, int n){

   730   char *zNew;

   731   if( z==0 ) return 0;

   732   zNew = sqlite3MallocRaw(n+1, 1);

   733   if( zNew ){

   734     memcpy(zNew, z, n);

   735     zNew[n] = 0;

   736   }

   737   return zNew;

   738 }

   739 

   740 /*

   741 ** Create a string from the 2nd and subsequent arguments (up to the

   742 ** first NULL argument), store the string in memory obtained from

   743 ** sqliteMalloc() and make the pointer indicated by the 1st argument

   744 ** point to that string.  The 1st argument must either be NULL or 

   745 ** point to memory obtained from sqliteMalloc().

   746 */

   747 void sqlite3SetString(char **pz, ...){

   748   va_list ap;

   749   int nByte;

   750   const char *z;

   751   char *zResult;

   752 

   753   if( pz==0 ) return;

   754   nByte = 1;

   755   va_start(ap, pz);

   756   while( (z = va_arg(ap, const char*))!=0 ){

   757     nByte += strlen(z);

   758   }

   759   va_end(ap);

   760   sqliteFree(*pz);

   761   *pz = zResult = sqliteMallocRaw( nByte );

   762   if( zResult==0 ){

   763     return;

   764   }

   765   *zResult = 0;

   766   va_start(ap, pz);

   767   while( (z = va_arg(ap, const char*))!=0 ){

   768     strcpy(zResult, z);

   769     zResult += strlen(zResult);

   770   }

   771   va_end(ap);

   772 }

   773 

   774 /*

   775 ** Set the most recent error code and error string for the sqlite

   776 ** handle "db". The error code is set to "err_code".

   777 **

   778 ** If it is not NULL, string zFormat specifies the format of the

   779 ** error string in the style of the printf functions: The following

   780 ** format characters are allowed:

   781 **

   782 **      %s      Insert a string

   783 **      %z      A string that should be freed after use

   784 **      %d      Insert an integer

   785 **      %T      Insert a token

   786 **      %S      Insert the first element of a SrcList

   787 **

   788 ** zFormat and any string tokens that follow it are assumed to be

   789 ** encoded in UTF-8.

   790 **

   791 ** To clear the most recent error for sqlite handle "db", sqlite3Error

   792 ** should be called with err_code set to SQLITE_OK and zFormat set

   793 ** to NULL.

   794 */

   795 void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){

   796   if( db && (db->pErr || (db->pErr = sqlite3ValueNew())!=0) ){

   797     db->errCode = err_code;

   798     if( zFormat ){

   799       char *z;

   800       va_list ap;

   801       va_start(ap, zFormat);

   802       z = sqlite3VMPrintf(zFormat, ap);

   803       va_end(ap);

   804       sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, sqlite3FreeX);

   805     }else{

   806       sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);

   807     }

   808   }

   809 }

   810 

   811 /*

   812 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.

   813 ** The following formatting characters are allowed:

   814 **

   815 **      %s      Insert a string

   816 **      %z      A string that should be freed after use

   817 **      %d      Insert an integer

   818 **      %T      Insert a token

   819 **      %S      Insert the first element of a SrcList

   820 **

   821 ** This function should be used to report any error that occurs whilst

   822 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The

   823 ** last thing the sqlite3_prepare() function does is copy the error

   824 ** stored by this function into the database handle using sqlite3Error().

   825 ** Function sqlite3Error() should be used during statement execution

   826 ** (sqlite3_step() etc.).

   827 */

   828 void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){

   829   va_list ap;

   830   pParse->nErr++;

   831   sqliteFree(pParse->zErrMsg);

   832   va_start(ap, zFormat);

   833   pParse->zErrMsg = sqlite3VMPrintf(zFormat, ap);

   834   va_end(ap);

   835 }

   836 

   837 /*

   838 ** Clear the error message in pParse, if any

   839 */

   840 void sqlite3ErrorClear(Parse *pParse){

   841   sqliteFree(pParse->zErrMsg);

   842   pParse->zErrMsg = 0;

   843   pParse->nErr = 0;

   844 }

   845 

   846 /*

   847 ** Convert an SQL-style quoted string into a normal string by removing

   848 ** the quote characters.  The conversion is done in-place.  If the

   849 ** input does not begin with a quote character, then this routine

   850 ** is a no-op.

   851 **

   852 ** 2002-Feb-14: This routine is extended to remove MS-Access style

   853 ** brackets from around identifers.  For example:  "[a-b-c]" becomes

   854 ** "a-b-c".

   855 */

   856 void sqlite3Dequote(char *z){

   857   int quote;

   858   int i, j;

   859   if( z==0 ) return;

   860   quote = z[0];

   861   switch( quote ){

   862     case '\'':  break;

   863     case '"':   break;

   864     case '`':   break;                /* For MySQL compatibility */

   865     case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */

   866     default:    return;

   867   }

   868   for(i=1, j=0; z[i]; i++){

   869     if( z[i]==quote ){

   870       if( z[i+1]==quote ){

   871         z[j++] = quote;

   872         i++;

   873       }else{

   874         z[j++] = 0;

   875         break;

   876       }

   877     }else{

   878       z[j++] = z[i];

   879     }

   880   }

   881 }

   882 

   883 /* An array to map all upper-case characters into their corresponding

   884 ** lower-case character. 

   885 */

   886 const unsigned char sqlite3UpperToLower[] = {

   887 #ifdef SQLITE_ASCII

   888       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,

   889      18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,

   890      36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,

   891      54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,

   892     104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,

   893     122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,

   894     108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,

   895     126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,

   896     144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,

   897     162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,

   898     180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,

   899     198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,

   900     216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,

   901     234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,

   902     252,253,254,255

   903 #endif

   904 #ifdef SQLITE_EBCDIC

   905       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* 0x */

   906      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */

   907      32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */

   908      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */

   909      64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */

   910      80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */

   911      96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */

   912     112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */

   913     128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */

   914     144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */

   915     160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */

   916     176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */

   917     192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */

   918     208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */

   919     224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */

   920     239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */

   921 #endif

   922 };

   923 #define UpperToLower sqlite3UpperToLower

   924 

   925 /*

   926 ** Some systems have stricmp().  Others have strcasecmp().  Because

   927 ** there is no consistency, we will define our own.

   928 */

   929 int sqlite3StrICmp(const char *zLeft, const char *zRight){

   930   register unsigned char *a, *b;

   931   a = (unsigned char *)zLeft;

   932   b = (unsigned char *)zRight;

   933   while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }

   934   return UpperToLower[*a] - UpperToLower[*b];

   935 }

   936 int sqlite3StrNICmp(const char *zLeft, const char *zRight, int N){

   937   register unsigned char *a, *b;

   938   a = (unsigned char *)zLeft;

   939   b = (unsigned char *)zRight;

   940   while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }

   941   return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];

   942 }

   943 

   944 /*

   945 ** Return TRUE if z is a pure numeric string.  Return FALSE if the

   946 ** string contains any character which is not part of a number. If

   947 ** the string is numeric and contains the '.' character, set *realnum

   948 ** to TRUE (otherwise FALSE).

   949 **

   950 ** An empty string is considered non-numeric.

   951 */

   952 int sqlite3IsNumber(const char *z, int *realnum, u8 enc){

   953   int incr = (enc==SQLITE_UTF8?1:2);

   954   if( enc==SQLITE_UTF16BE ) z++;

   955   if( *z=='-' || *z=='+' ) z += incr;

   956   if( !isdigit(*(u8*)z) ){

   957     return 0;

   958   }

   959   z += incr;

   960   if( realnum ) *realnum = 0;

   961   while( isdigit(*(u8*)z) ){ z += incr; }

   962   if( *z=='.' ){

   963     z += incr;

   964     if( !isdigit(*(u8*)z) ) return 0;

   965     while( isdigit(*(u8*)z) ){ z += incr; }

   966     if( realnum ) *realnum = 1;

   967   }

   968   if( *z=='e' || *z=='E' ){

   969     z += incr;

   970     if( *z=='+' || *z=='-' ) z += incr;

   971     if( !isdigit(*(u8*)z) ) return 0;

   972     while( isdigit(*(u8*)z) ){ z += incr; }

   973     if( realnum ) *realnum = 1;

   974   }

   975   return *z==0;

   976 }

   977 

   978 /*

   979 ** The string z[] is an ascii representation of a real number.

   980 ** Convert this string to a double.

   981 **

   982 ** This routine assumes that z[] really is a valid number.  If it

   983 ** is not, the result is undefined.

   984 **

   985 ** This routine is used instead of the library atof() function because

   986 ** the library atof() might want to use "," as the decimal point instead

   987 ** of "." depending on how locale is set.  But that would cause problems

   988 ** for SQL.  So this routine always uses "." regardless of locale.

   989 */

   990 int sqlite3AtoF(const char *z, double *pResult){

   991 #ifndef SQLITE_OMIT_FLOATING_POINT

   992   int sign = 1;

   993   const char *zBegin = z;

   994   LONGDOUBLE_TYPE v1 = 0.0;

   995   while( isspace(*z) ) z++;

   996   if( *z=='-' ){

   997     sign = -1;

   998     z++;

   999   }else if( *z=='+' ){

  1000     z++;

  1001   }

  1002   while( isdigit(*(u8*)z) ){

  1003     v1 = v1*10.0 + (*z - '0');

  1004     z++;

  1005   }

  1006   if( *z=='.' ){

  1007     LONGDOUBLE_TYPE divisor = 1.0;

  1008     z++;

  1009     while( isdigit(*(u8*)z) ){

  1010       v1 = v1*10.0 + (*z - '0');

  1011       divisor *= 10.0;

  1012       z++;

  1013     }

  1014     v1 /= divisor;

  1015   }

  1016   if( *z=='e' || *z=='E' ){

  1017     int esign = 1;

  1018     int eval = 0;

  1019     LONGDOUBLE_TYPE scale = 1.0;

  1020     z++;

  1021     if( *z=='-' ){

  1022       esign = -1;

  1023       z++;

  1024     }else if( *z=='+' ){

  1025       z++;

  1026     }

  1027     while( isdigit(*(u8*)z) ){

  1028       eval = eval*10 + *z - '0';

  1029       z++;

  1030     }

  1031     while( eval>=64 ){ scale *= 1.0e+64; eval -= 64; }

  1032     while( eval>=16 ){ scale *= 1.0e+16; eval -= 16; }

  1033     while( eval>=4 ){ scale *= 1.0e+4; eval -= 4; }

  1034     while( eval>=1 ){ scale *= 1.0e+1; eval -= 1; }

  1035     if( esign<0 ){

  1036       v1 /= scale;

  1037     }else{

  1038       v1 *= scale;

  1039     }

  1040   }

  1041   *pResult = sign<0 ? -v1 : v1;

  1042   return z - zBegin;

  1043 #else

  1044   return sqlite3atoi64(z, pResult);

  1045 #endif /* SQLITE_OMIT_FLOATING_POINT */

  1046 }

  1047 

  1048 /*

  1049 ** Return TRUE if zNum is a 64-bit signed integer and write

  1050 ** the value of the integer into *pNum.  If zNum is not an integer

  1051 ** or is an integer that is too large to be expressed with 64 bits,

  1052 ** then return false.  If n>0 and the integer is string is not

  1053 ** exactly n bytes long, return false.

  1054 **

  1055 ** When this routine was originally written it dealt with only

  1056 ** 32-bit numbers.  At that time, it was much faster than the

  1057 ** atoi() library routine in RedHat 7.2.

  1058 */

  1059 int sqlite3atoi64(const char *zNum, i64 *pNum){

  1060   i64 v = 0;

  1061   int neg;

  1062   int i, c;

  1063   while( isspace(*zNum) ) zNum++;

  1064   if( *zNum=='-' ){

  1065     neg = 1;

  1066     zNum++;

  1067   }else if( *zNum=='+' ){

  1068     neg = 0;

  1069     zNum++;

  1070   }else{

  1071     neg = 0;

  1072   }

  1073   for(i=0; (c=zNum[i])>='0' && c<='9'; i++){

  1074     v = v*10 + c - '0';

  1075   }

  1076   *pNum = neg ? -v : v;

  1077   return c==0 && i>0 && 

  1078       (i<19 || (i==19 && memcmp(zNum,"9223372036854775807",19)<=0));

  1079 }

  1080 

  1081 /*

  1082 ** The string zNum represents an integer.  There might be some other

  1083 ** information following the integer too, but that part is ignored.

  1084 ** If the integer that the prefix of zNum represents will fit in a

  1085 ** 32-bit signed integer, return TRUE.  Otherwise return FALSE.

  1086 **

  1087 ** This routine returns FALSE for the string -2147483648 even that

  1088 ** that number will in fact fit in a 32-bit integer.  But positive

  1089 ** 2147483648 will not fit in 32 bits.  So it seems safer to return

  1090 ** false.

  1091 */

  1092 static int sqlite3FitsIn32Bits(const char *zNum){

  1093   int i, c;

  1094   if( *zNum=='-' || *zNum=='+' ) zNum++;

  1095   for(i=0; (c=zNum[i])>='0' && c<='9'; i++){}

  1096   return i<10 || (i==10 && memcmp(zNum,"2147483647",10)<=0);

  1097 }

  1098 

  1099 /*

  1100 ** If zNum represents an integer that will fit in 32-bits, then set

  1101 ** *pValue to that integer and return true.  Otherwise return false.

  1102 */

  1103 int sqlite3GetInt32(const char *zNum, int *pValue){

  1104   if( sqlite3FitsIn32Bits(zNum) ){

  1105     *pValue = atoi(zNum);

  1106     return 1;

  1107   }

  1108   return 0;

  1109 }

  1110 

  1111 /*

  1112 ** The string zNum represents an integer.  There might be some other

  1113 ** information following the integer too, but that part is ignored.

  1114 ** If the integer that the prefix of zNum represents will fit in a

  1115 ** 64-bit signed integer, return TRUE.  Otherwise return FALSE.

  1116 **

  1117 ** This routine returns FALSE for the string -9223372036854775808 even that

  1118 ** that number will, in theory fit in a 64-bit integer.  Positive

  1119 ** 9223373036854775808 will not fit in 64 bits.  So it seems safer to return

  1120 ** false.

  1121 */

  1122 int sqlite3FitsIn64Bits(const char *zNum){

  1123   int i, c;

  1124   if( *zNum=='-' || *zNum=='+' ) zNum++;

  1125   for(i=0; (c=zNum[i])>='0' && c<='9'; i++){}

  1126   return i<19 || (i==19 && memcmp(zNum,"9223372036854775807",19)<=0);

  1127 }

  1128 

  1129 

  1130 /*

  1131 ** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY.

  1132 ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN

  1133 ** when this routine is called.

  1134 **

  1135 ** This routine is a attempt to detect if two threads use the