text: /*
  ** 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.
  **
  *************************************************************************
  **
  ** Memory allocation functions used throughout sqlite.
  */
  #include "sqliteInt.h"
  #include <stdarg.h>
  
  /*
  ** Attempt to release up to n bytes of non-essential memory currently
  ** held by SQLite. An example of non-essential memory is memory used to
  ** cache database pages that are not currently in use.
  */
  int sqlite3_release_memory(int n){
  #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
    return sqlite3PcacheReleaseMemory(n);
  #else
    /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine
    ** is a no-op returning zero if SQLite is not compiled with
    ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */
    UNUSED_PARAMETER(n);
    return 0;
  #endif
  }
  
  /*
  ** State information local to the memory allocation subsystem.
  */
  static SQLITE_WSD struct Mem0Global {
    sqlite3_mutex *mutex;         /* Mutex to serialize access */
    sqlite3_int64 alarmThreshold; /* The soft heap limit */
  
    /*
    ** True if heap is nearly "full" where "full" is defined by the
    ** sqlite3_soft_heap_limit() setting.
    */
    int nearlyFull;
  } mem0 = { 0, 0, 0 };
  
  #define mem0 GLOBAL(struct Mem0Global, mem0)
  
  /*
  ** Return the memory allocator mutex. sqlite3_status() needs it.
  */
  sqlite3_mutex *sqlite3MallocMutex(void){
    return mem0.mutex;
  }
  
  #ifndef SQLITE_OMIT_DEPRECATED
  /*
  ** Deprecated external interface.  It used to set an alarm callback
  ** that was invoked when memory usage grew too large.  Now it is a
  ** no-op.
  */
  int sqlite3_memory_alarm(
    void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
    void *pArg,
    sqlite3_int64 iThreshold
  ){
    (void)xCallback;
    (void)pArg;
    (void)iThreshold;
    return SQLITE_OK;
  }
  #endif
  
  /*
  ** Set the soft heap-size limit for the library. Passing a zero or 
  ** negative value indicates no limit.
  */
  sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){
    sqlite3_int64 priorLimit;
    sqlite3_int64 excess;
    sqlite3_int64 nUsed;
  #ifndef SQLITE_OMIT_AUTOINIT
    int rc = sqlite3_initialize();
    if( rc ) return -1;
  #endif
    sqlite3_mutex_enter(mem0.mutex);
    priorLimit = mem0.alarmThreshold;
    if( n<0 ){
      sqlite3_mutex_leave(mem0.mutex);
      return priorLimit;
    }
    mem0.alarmThreshold = n;
    nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
    mem0.nearlyFull = (n>0 && n<=nUsed);
    sqlite3_mutex_leave(mem0.mutex);
    excess = sqlite3_memory_used() - n;
    if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
    return priorLimit;
  }
  void sqlite3_soft_heap_limit(int n){
    if( n<0 ) n = 0;
    sqlite3_soft_heap_limit64(n);
  }
  
  /*
  ** Initialize the memory allocation subsystem.
  */
  int sqlite3MallocInit(void){
    int rc;
    if( sqlite3GlobalConfig.m.xMalloc==0 ){
      sqlite3MemSetDefault();
    }
    memset(&mem0, 0, sizeof(mem0));
    mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
    if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
        || sqlite3GlobalConfig.nPage<=0 ){
      sqlite3GlobalConfig.pPage = 0;
      sqlite3GlobalConfig.szPage = 0;
    }
    rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
    if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0));
    return rc;
  }
  
  /*
  ** Return true if the heap is currently under memory pressure - in other
  ** words if the amount of heap used is close to the limit set by
  ** sqlite3_soft_heap_limit().
  */
  int sqlite3HeapNearlyFull(void){
    return mem0.nearlyFull;
  }
  
  /*
  ** Deinitialize the memory allocation subsystem.
  */
  void sqlite3MallocEnd(void){
    if( sqlite3GlobalConfig.m.xShutdown ){
      sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
    }
    memset(&mem0, 0, sizeof(mem0));
  }
  
  /*
  ** Return the amount of memory currently checked out.
  */
  sqlite3_int64 sqlite3_memory_used(void){
    sqlite3_int64 res, mx;
    sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, 0);
    return res;
  }
  
  /*
  ** Return the maximum amount of memory that has ever been
  ** checked out since either the beginning of this process
  ** or since the most recent reset.
  */
  sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
    sqlite3_int64 res, mx;
    sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, resetFlag);
    return mx;
  }
  
  /*
  ** Trigger the alarm 
  */
  static void sqlite3MallocAlarm(int nByte){
    if( mem0.alarmThreshold<=0 ) return;
    sqlite3_mutex_leave(mem0.mutex);
    sqlite3_release_memory(nByte);
    sqlite3_mutex_enter(mem0.mutex);
  }
  
  /*
  ** Do a memory allocation with statistics and alarms.  Assume the
  ** lock is already held.
  */
  static void mallocWithAlarm(int n, void **pp){
    void *p;
    int nFull;
    assert( sqlite3_mutex_held(mem0.mutex) );
    assert( n>0 );
  
    /* In Firefox (circa 2017-02-08), xRoundup() is remapped to an internal
    ** implementation of malloc_good_size(), which must be called in debug
    ** mode and specifically when the DMD "Dark Matter Detector" is enabled
    ** or else a crash results.  Hence, do not attempt to optimize out the
    ** following xRoundup() call. */
    nFull = sqlite3GlobalConfig.m.xRoundup(n);
  
  #ifdef SQLITE_MAX_MEMORY
    if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)+nFull>SQLITE_MAX_MEMORY ){
      *pp = 0;
      return;
    }
  #endif
  
    sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
    if( mem0.alarmThreshold>0 ){
      sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
      if( nUsed >= mem0.alarmThreshold - nFull ){
        mem0.nearlyFull = 1;
        sqlite3MallocAlarm(nFull);
      }else{
        mem0.nearlyFull = 0;
      }
    }
    p = sqlite3GlobalConfig.m.xMalloc(nFull);
  #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
    if( p==0 && mem0.alarmThreshold>0 ){
      sqlite3MallocAlarm(nFull);
      p = sqlite3GlobalConfig.m.xMalloc(nFull);
    }
  #endif
    if( p ){
      nFull = sqlite3MallocSize(p);
      sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull);
      sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1);
    }
    *pp = p;
  }
  
  /*
  ** Allocate memory.  This routine is like sqlite3_malloc() except that it
  ** assumes the memory subsystem has already been initialized.
  */
  void *sqlite3Malloc(u64 n){
    void *p;
    if( n==0 || n>=0x7fffff00 ){
      /* A memory allocation of a number of bytes which is near the maximum
      ** signed integer value might cause an integer overflow inside of the
      ** xMalloc().  Hence we limit the maximum size to 0x7fffff00, giving
      ** 255 bytes of overhead.  SQLite itself will never use anything near
      ** this amount.  The only way to reach the limit is with sqlite3_malloc() */
      p = 0;
    }else if( sqlite3GlobalConfig.bMemstat ){
      sqlite3_mutex_enter(mem0.mutex);
      mallocWithAlarm((int)n, &p);
      sqlite3_mutex_leave(mem0.mutex);
    }else{
      p = sqlite3GlobalConfig.m.xMalloc((int)n);
    }
    assert( EIGHT_BYTE_ALIGNMENT(p) );  /* IMP: R-11148-40995 */
    return p;
  }
  
  /*
  ** This version of the memory allocation is for use by the application.
  ** First make sure the memory subsystem is initialized, then do the
  ** allocation.
  */
  void *sqlite3_malloc(int n){
  #ifndef SQLITE_OMIT_AUTOINIT
    if( sqlite3_initialize() ) return 0;
  #endif
    return n<=0 ? 0 : sqlite3Malloc(n);
  }
  void *sqlite3_malloc64(sqlite3_uint64 n){
  #ifndef SQLITE_OMIT_AUTOINIT
    if( sqlite3_initialize() ) return 0;
  #endif
    return sqlite3Malloc(n);
  }
  
  /*
  ** TRUE if p is a lookaside memory allocation from db
  */
  #ifndef SQLITE_OMIT_LOOKASIDE
  static int isLookaside(sqlite3 *db, void *p){
    return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pEnd);
  }
  #else
  #define isLookaside(A,B) 0
  #endif
  
  /*
  ** Return the size of a memory allocation previously obtained from
  ** sqlite3Malloc() or sqlite3_malloc().
  */
  int sqlite3MallocSize(void *p){
    assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
    return sqlite3GlobalConfig.m.xSize(p);
  }
  int sqlite3DbMallocSize(sqlite3 *db, void *p){
    assert( p!=0 );
    if( db==0 || !isLookaside(db,p) ){
  #ifdef SQLITE_DEBUG
      if( db==0 ){
        assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
        assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
      }else{
        assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
        assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
      }
  #endif
      return sqlite3GlobalConfig.m.xSize(p);
    }else{
      assert( sqlite3_mutex_held(db->mutex) );
      return db->lookaside.sz;
    }
  }
  sqlite3_uint64 sqlite3_msize(void *p){
    assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
    assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
    return p ? sqlite3GlobalConfig.m.xSize(p) : 0;
  }
  
  /*
  ** Free memory previously obtained from sqlite3Malloc().
  */
  void sqlite3_free(void *p){
    if( p==0 ) return;  /* IMP: R-49053-54554 */
    assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
    assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
    if( sqlite3GlobalConfig.bMemstat ){
      sqlite3_mutex_enter(mem0.mutex);
      sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
      sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
      sqlite3GlobalConfig.m.xFree(p);
      sqlite3_mutex_leave(mem0.mutex);
    }else{
      sqlite3GlobalConfig.m.xFree(p);
    }
  }
  
  /*
  ** Add the size of memory allocation "p" to the count in
  ** *db->pnBytesFreed.
  */
  static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){
    *db->pnBytesFreed += sqlite3DbMallocSize(db,p);
  }
  
  /*
  ** Free memory that might be associated with a particular database
  ** connection.  Calling sqlite3DbFree(D,X) for X==0 is a harmless no-op.
  ** The sqlite3DbFreeNN(D,X) version requires that X be non-NULL.
  */
  void sqlite3DbFreeNN(sqlite3 *db, void *p){
    assert( db==0 || sqlite3_mutex_held(db->mutex) );
    assert( p!=0 );
    if( db ){
      if( db->pnBytesFreed ){
        measureAllocationSize(db, p);
        return;
      }
      if( isLookaside(db, p) ){
        LookasideSlot *pBuf = (LookasideSlot*)p;
  #ifdef SQLITE_DEBUG
        /* Trash all content in the buffer being freed */
        memset(p, 0xaa, db->lookaside.sz);
  #endif
        pBuf->pNext = db->lookaside.pFree;
        db->lookaside.pFree = pBuf;
        return;
      }
    }
    assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
    assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
    assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
    sqlite3_free(p);
  }
  void sqlite3DbFree(sqlite3 *db, void *p){
    assert( db==0 || sqlite3_mutex_held(db->mutex) );
    if( p ) sqlite3DbFreeNN(db, p);
  }
  
  /*
  ** Change the size of an existing memory allocation
  */
  void *sqlite3Realloc(void *pOld, u64 nBytes){
    int nOld, nNew, nDiff;
    void *pNew;
    assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
    assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
    if( pOld==0 ){
      return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */
    }
    if( nBytes==0 ){
      sqlite3_free(pOld); /* IMP: R-26507-47431 */
      return 0;
    }
    if( nBytes>=0x7fffff00 ){
      /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
      return 0;
    }
    nOld = sqlite3MallocSize(pOld);
    /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
    ** argument to xRealloc is always a value returned by a prior call to
    ** xRoundup. */
    nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
    if( nOld==nNew ){
      pNew = pOld;
    }else if( sqlite3GlobalConfig.bMemstat ){
      sqlite3_mutex_enter(mem0.mutex);
      sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes);
      nDiff = nNew - nOld;
      if( nDiff>0 && sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >= 
            mem0.alarmThreshold-nDiff ){
        sqlite3MallocAlarm(nDiff);
      }
      pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
      if( pNew==0 && mem0.alarmThreshold>0 ){
        sqlite3MallocAlarm((int)nBytes);
        pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
      }
      if( pNew ){
        nNew = sqlite3MallocSize(pNew);
        sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
      }
      sqlite3_mutex_leave(mem0.mutex);
    }else{
      pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
    }
    assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */
    return pNew;
  }
  
  /*
  ** The public interface to sqlite3Realloc.  Make sure that the memory
  ** subsystem is initialized prior to invoking sqliteRealloc.
  */
  void *sqlite3_realloc(void *pOld, int n){
  #ifndef SQLITE_OMIT_AUTOINIT
    if( sqlite3_initialize() ) return 0;
  #endif
    if( n<0 ) n = 0;  /* IMP: R-26507-47431 */
    return sqlite3Realloc(pOld, n);
  }
  void *sqlite3_realloc64(void *pOld, sqlite3_uint64 n){
  #ifndef SQLITE_OMIT_AUTOINIT
    if( sqlite3_initialize() ) return 0;
  #endif
    return sqlite3Realloc(pOld, n);
  }
  
  
  /*
  ** Allocate and zero memory.
  */ 
  void *sqlite3MallocZero(u64 n){
    void *p = sqlite3Malloc(n);
    if( p ){
      memset(p, 0, (size_t)n);
    }
    return p;
  }
  
  /*
  ** Allocate and zero memory.  If the allocation fails, make
  ** the mallocFailed flag in the connection pointer.
  */
  void *sqlite3DbMallocZero(sqlite3 *db, u64 n){
    void *p;
    testcase( db==0 );
    p = sqlite3DbMallocRaw(db, n);
    if( p ) memset(p, 0, (size_t)n);
    return p;
  }
  
  
  /* Finish the work of sqlite3DbMallocRawNN for the unusual and
  ** slower case when the allocation cannot be fulfilled using lookaside.
  */
  static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){
    void *p;
    assert( db!=0 );
    p = sqlite3Malloc(n);
    if( !p ) sqlite3OomFault(db);
    sqlite3MemdebugSetType(p, 
           (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
    return p;
  }
  
  /*
  ** Allocate memory, either lookaside (if possible) or heap.  
  ** If the allocation fails, set the mallocFailed flag in
  ** the connection pointer.
  **
  ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
  ** failure on the same database connection) then always return 0.
  ** Hence for a particular database connection, once malloc starts
  ** failing, it fails consistently until mallocFailed is reset.
  ** This is an important assumption.  There are many places in the
  ** code that do things like this:
  **
  **         int *a = (int*)sqlite3DbMallocRaw(db, 100);
  **         int *b = (int*)sqlite3DbMallocRaw(db, 200);
  **         if( b ) a[10] = 9;
  **
  ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
  ** that all prior mallocs (ex: "a") worked too.
  **
  ** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is
  ** not a NULL pointer.
  */
  void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){
    void *p;
    if( db ) return sqlite3DbMallocRawNN(db, n);
    p = sqlite3Malloc(n);
    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
    return p;
  }
  void *sqlite3DbMallocRawNN(sqlite3 *db, u64 n){
  #ifndef SQLITE_OMIT_LOOKASIDE
    LookasideSlot *pBuf;
    assert( db!=0 );
    assert( sqlite3_mutex_held(db->mutex) );
    assert( db->pnBytesFreed==0 );
    if( db->lookaside.bDisable==0 ){
      assert( db->mallocFailed==0 );
      if( n>db->lookaside.sz ){
        db->lookaside.anStat[1]++;
      }else if( (pBuf = db->lookaside.pFree)!=0 ){
        db->lookaside.pFree = pBuf->pNext;
        db->lookaside.anStat[0]++;
        return (void*)pBuf;
      }else if( (pBuf = db->lookaside.pInit)!=0 ){
        db->lookaside.pInit = pBuf->pNext;
        db->lookaside.anStat[0]++;
        return (void*)pBuf;
      }else{
        db->lookaside.anStat[2]++;
      }
    }else if( db->mallocFailed ){
      return 0;
    }
  #else
    assert( db!=0 );
    assert( sqlite3_mutex_held(db->mutex) );
    assert( db->pnBytesFreed==0 );
    if( db->mallocFailed ){
      return 0;
    }
  #endif
    return dbMallocRawFinish(db, n);
  }
  
  /* Forward declaration */
  static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n);
  
  /*
  ** Resize the block of memory pointed to by p to n bytes. If the
  ** resize fails, set the mallocFailed flag in the connection object.
  */
  void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
    assert( db!=0 );
    if( p==0 ) return sqlite3DbMallocRawNN(db, n);
    assert( sqlite3_mutex_held(db->mutex) );
    if( isLookaside(db,p) && n<=db->lookaside.sz ) return p;
    return dbReallocFinish(db, p, n);
  }
  static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){
    void *pNew = 0;
    assert( db!=0 );
    assert( p!=0 );
    if( db->mallocFailed==0 ){
      if( isLookaside(db, p) ){
        pNew = sqlite3DbMallocRawNN(db, n);
        if( pNew ){
          memcpy(pNew, p, db->lookaside.sz);
          sqlite3DbFree(db, p);
        }
      }else{
        assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
        assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
        sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
        pNew = sqlite3_realloc64(p, n);
        if( !pNew ){
          sqlite3OomFault(db);
        }
        sqlite3MemdebugSetType(pNew,
              (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
      }
    }
    return pNew;
  }
  
  /*
  ** Attempt to reallocate p.  If the reallocation fails, then free p
  ** and set the mallocFailed flag in the database connection.
  */
  void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){
    void *pNew;
    pNew = sqlite3DbRealloc(db, p, n);
    if( !pNew ){
      sqlite3DbFree(db, p);
    }
    return pNew;
  }
  
  /*
  ** Make a copy of a string in memory obtained from sqliteMalloc(). These 
  ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
  ** is because when memory debugging is turned on, these two functions are 
  ** called via macros that record the current file and line number in the
  ** ThreadData structure.
  */
  char *sqlite3DbStrDup(sqlite3 *db, const char *z){
    char *zNew;
    size_t n;
    if( z==0 ){
      return 0;
    }
    n = strlen(z) + 1;
    zNew = sqlite3DbMallocRaw(db, n);
    if( zNew ){
      memcpy(zNew, z, n);
    }
    return zNew;
  }
  char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
    char *zNew;
    assert( db!=0 );
    if( z==0 ){
      return 0;
    }
    assert( (n&0x7fffffff)==n );
    zNew = sqlite3DbMallocRawNN(db, n+1);
    if( zNew ){
      memcpy(zNew, z, (size_t)n);
      zNew[n] = 0;
    }
    return zNew;
  }
  
  /*
  ** Free any prior content in *pz and replace it with a copy of zNew.
  */
  void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){
    sqlite3DbFree(db, *pz);
    *pz = sqlite3DbStrDup(db, zNew);
  }
  
  /*
  ** Call this routine to record the fact that an OOM (out-of-memory) error
  ** has happened.  This routine will set db->mallocFailed, and also
  ** temporarily disable the lookaside memory allocator and interrupt
  ** any running VDBEs.
  */
  void sqlite3OomFault(sqlite3 *db){
    if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
      db->mallocFailed = 1;
      if( db->nVdbeExec>0 ){
        db->u1.isInterrupted = 1;
      }
      db->lookaside.bDisable++;
    }
  }
  
  /*
  ** This routine reactivates the memory allocator and clears the
  ** db->mallocFailed flag as necessary.
  **
  ** The memory allocator is not restarted if there are running
  ** VDBEs.
  */
  void sqlite3OomClear(sqlite3 *db){
    if( db->mallocFailed && db->nVdbeExec==0 ){
      db->mallocFailed = 0;
      db->u1.isInterrupted = 0;
      assert( db->lookaside.bDisable>0 );
      db->lookaside.bDisable--;
    }
  }
  
  /*
  ** Take actions at the end of an API call to indicate an OOM error
  */
  static SQLITE_NOINLINE int apiOomError(sqlite3 *db){
    sqlite3OomClear(db);
    sqlite3Error(db, SQLITE_NOMEM);
    return SQLITE_NOMEM_BKPT;
  }
  
  /*
  ** This function must be called before exiting any API function (i.e. 
  ** returning control to the user) that has called sqlite3_malloc or
  ** sqlite3_realloc.
  **
  ** The returned value is normally a copy of the second argument to this
  ** function. However, if a malloc() failure has occurred since the previous
  ** invocation SQLITE_NOMEM is returned instead. 
  **
  ** If an OOM as occurred, then the connection error-code (the value
  ** returned by sqlite3_errcode()) is set to SQLITE_NOMEM.
  */
  int sqlite3ApiExit(sqlite3* db, int rc){
    /* If the db handle must hold the connection handle mutex here.
    ** Otherwise the read (and possible write) of db->mallocFailed 
    ** is unsafe, as is the call to sqlite3Error().
    */
    assert( db!=0 );
    assert( sqlite3_mutex_held(db->mutex) );
    if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){
      return apiOomError(db);
    }
    return rc & db->errMask;
  }
  