自学教程：C++ sqlite3_mutex_enter函数代码示例

void *sqlite3PageMalloc(int n){  void *p;  assert( n>0 );  assert( (n & (n-1))==0 );  assert( n>=512 && n<=32768 );  if( sqlite3GlobalConfig.szPage<n ){    goto page_overflow;  }else{      sqlite3_mutex_enter(mem0.mutex);    if( mem0.nPageFree==0 ){      sqlite3_mutex_leave(mem0.mutex);      goto page_overflow;    }else{      int i;      i = mem0.aPageFree[--mem0.nPageFree];      sqlite3_mutex_leave(mem0.mutex);      i *= sqlite3GlobalConfig.szPage;      sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, n);      sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, 1);      p = (void*)&((char*)sqlite3GlobalConfig.pPage)[i];    }  }  return p;page_overflow:  if( sqlite3GlobalConfig.bMemstat ){    sqlite3_mutex_enter(mem0.mutex);    sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, n);    n = mallocWithAlarm(n, &p);    if( p ) sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, n);    sqlite3_mutex_leave(mem0.mutex);  }else{    p = sqlite3GlobalConfig.m.xMalloc(n);  }  return p;    }

/*** Allocate memory that is to be used and released right away.** This routine is similar to alloca() in that it is not intended** for situations where the memory might be held long-term.  This** routine is intended to get memory to old large transient data** structures that would not normally fit on the stack of an** embedded processor.*/void *sqlite3ScratchMalloc(int n){  void *p;  assert( n>0 );  sqlite3_mutex_enter(mem0.mutex);  sqlite3StatusHighwater(SQLITE_STATUS_SCRATCH_SIZE, n);  if( mem0.nScratchFree && sqlite3GlobalConfig.szScratch>=n ){    p = mem0.pScratchFree;    mem0.pScratchFree = mem0.pScratchFree->pNext;    mem0.nScratchFree--;    sqlite3StatusUp(SQLITE_STATUS_SCRATCH_USED, 1);    sqlite3_mutex_leave(mem0.mutex);  }else{    sqlite3_mutex_leave(mem0.mutex);    p = sqlite3Malloc(n);    if( sqlite3GlobalConfig.bMemstat && p ){      sqlite3_mutex_enter(mem0.mutex);      sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW, sqlite3MallocSize(p));      sqlite3_mutex_leave(mem0.mutex);    }    sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);  }  assert( sqlite3_mutex_notheld(mem0.mutex) );#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)  /* EVIDENCE-OF: R-12970-05880 SQLite will not use more than one scratch  ** buffers per thread.  **  ** This can only be checked in single-threaded mode.  */  assert( scratchAllocOut==0 );  if( p ) scratchAllocOut++;#endif  return p;}

/*** Bind a blob value to an SQL statement variable.*/int sqlite3_bind_blob(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, 0);}int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){  int rc;  Vdbe *p = (Vdbe *)pStmt;  sqlite3_mutex_enter(p->db->mutex);  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);  }  sqlite3_mutex_leave(p->db->mutex);  return rc;}int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){  return sqlite3_bind_int64(p, i, (i64)iValue);}int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){  int rc;  Vdbe *p = (Vdbe *)pStmt;  sqlite3_mutex_enter(p->db->mutex);  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);  }  sqlite3_mutex_leave(p->db->mutex);  return rc;}int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){  int rc;  Vdbe *p = (Vdbe*)pStmt;  sqlite3_mutex_enter(p->db->mutex);  rc = vdbeUnbind(p, i);  sqlite3_mutex_leave(p->db->mutex);  return rc;}int sqlite3_bind_text(   sqlite3_stmt *pStmt,   int i,   const char *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);}#ifndef SQLITE_OMIT_UTF16int sqlite3_bind_text16(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);}#endif /* SQLITE_OMIT_UTF16 */int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){  int rc;  Vdbe *p = (Vdbe *)pStmt;  sqlite3_mutex_enter(p->db->mutex);  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);    if( rc==SQLITE_OK ){      rc = sqlite3VdbeChangeEncoding(&p->aVar[i-1], ENC(p->db));    }  }  rc = sqlite3ApiExit(p->db, rc);  sqlite3_mutex_leave(p->db->mutex);  return rc;}

/*** Free memory.*/EXPORT_C void sqlite3_free(void *pPrior){  sqlite3_int64 *p;  int nByte;  if( pPrior==0 ){    return;  }  assert( mem.mutex!=0 );  p = (sqlite3_int64*)pPrior;  p--;  nByte = (int)*p;  sqlite3_mutex_enter(mem.mutex);  mem.nowUsed -= nByte;  free(p);  sqlite3_mutex_leave(mem.mutex);  }

/*** Set or clear the access authorization function.**** The access authorization function is be called during the compilation** phase to verify that the user has read and/or write access permission on** various fields of the database.  The first argument to the auth function** is a copy of the 3rd argument to this routine.  The second argument** to the auth function is one of these constants:****       SQLITE_CREATE_INDEX**       SQLITE_CREATE_TABLE**       SQLITE_CREATE_TEMP_INDEX**       SQLITE_CREATE_TEMP_TABLE**       SQLITE_CREATE_TEMP_TRIGGER**       SQLITE_CREATE_TEMP_VIEW**       SQLITE_CREATE_TRIGGER**       SQLITE_CREATE_VIEW**       SQLITE_DELETE**       SQLITE_DROP_INDEX**       SQLITE_DROP_TABLE**       SQLITE_DROP_TEMP_INDEX**       SQLITE_DROP_TEMP_TABLE**       SQLITE_DROP_TEMP_TRIGGER**       SQLITE_DROP_TEMP_VIEW**       SQLITE_DROP_TRIGGER**       SQLITE_DROP_VIEW**       SQLITE_INSERT**       SQLITE_PRAGMA**       SQLITE_READ**       SQLITE_SELECT**       SQLITE_TRANSACTION**       SQLITE_UPDATE**** The third and fourth arguments to the auth function are the name of** the table and the column that are being accessed.  The auth function** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE.  If** SQLITE_OK is returned, it means that access is allowed.  SQLITE_DENY** means that the SQL statement will never-run - the sqlite3_exec() call** will return with an error.  SQLITE_IGNORE means that the SQL statement** should run but attempts to read the specified column will return NULL** and attempts to write the column will be ignored.**** Setting the auth function to NULL disables this hook.  The default** setting of the auth function is NULL.*/int sqlite3_set_authorizer(  sqlite3 *db,  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),  void *pArg){#ifdef SQLITE_ENABLE_API_ARMOR  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;#endif  sqlite3_mutex_enter(db->mutex);  db->xAuth = (sqlite3_xauth)xAuth;  db->pAuthArg = pArg;  sqlite3ExpirePreparedStatements(db);  sqlite3_mutex_leave(db->mutex);  return SQLITE_OK;}

/*** This routine sets the busy callback for an Sqlite database to the** given callback function with the given argument.*/extern "C" int sqlite3_busy_handler(  sqlite3 *db,  int (*xBusy)(void*,int),  void *pArg){  if( sqlite3SafetyCheck(db) ){    return SQLITE_MISUSE;  }  sqlite3_mutex_enter(db->mutex);  db->busyHandler.xFunc = xBusy;  db->busyHandler.pArg = pArg;  db->busyHandler.nBusy = 0;  sqlite3_mutex_leave(db->mutex);  return SQLITE_OK;}

/*** Register a collation sequence factory callback with the database handle** db. Replace any previously installed collation sequence factory.*/extern "C" int sqlite3_collation_needed16(  sqlite3 *db,   void *pCollNeededArg,   void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)){  if( sqlite3SafetyCheck(db) ){    return SQLITE_MISUSE;  }  sqlite3_mutex_enter(db->mutex);  db->xCollNeeded = 0;  db->xCollNeeded16 = xCollNeeded16;  db->pCollNeededArg = pCollNeededArg;  sqlite3_mutex_leave(db->mutex);  return SQLITE_OK;}

/*** Register a new collation sequence with the database handle db.*/extern "C" int sqlite3_create_collation(  sqlite3* db,   const char *zName,   int enc,   void* pCtx,  int(*xCompare)(void*,int,const void*,int,const void*)){  int rc;  sqlite3_mutex_enter(db->mutex);  assert( !db->mallocFailed );  rc = createCollation(db, zName, enc, pCtx, xCompare, 0);  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

int spmemvfs_open_db( spmemvfs_db_t * db, const char * path, spmembuffer_t * mem ){	int ret = 0;	spmembuffer_link_t * iter = NULL;	memset( db, 0, sizeof( spmemvfs_db_t ) );	iter = (spmembuffer_link_t*)calloc( sizeof( spmembuffer_link_t ), 1 );	iter->path = strdup( path );	iter->mem = mem;	sqlite3_mutex_enter( g_spmemvfs_env->mutex );	{		iter->next = g_spmemvfs_env->head;		g_spmemvfs_env->head = iter;	}	sqlite3_mutex_leave( g_spmemvfs_env->mutex );	ret = sqlite3_open_v2( path, &(db->handle),			SQLITE_OPEN_READONLY, SPMEMVFS_NAME);			//SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, SPMEMVFS_NAME );	if( 0 == ret ) {		db->mem = mem;	} else {		sqlite3_mutex_enter( g_spmemvfs_env->mutex );		{			iter = spmembuffer_link_remove( &(g_spmemvfs_env->head), path );			if( NULL != iter ) spmembuffer_link_free( iter );		}		sqlite3_mutex_leave( g_spmemvfs_env->mutex );	}	return ret;}

/*** Terminate the current execution of an SQL statement and reset it** back to its starting state so that it can be reused. A success code from** the prior execution is returned.**** This routine sets the error code and string returned by** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().*/int sqlite3_reset(sqlite3_stmt *pStmt){  int rc;  if( pStmt==0 ){    rc = SQLITE_OK;  }else{    Vdbe *v = (Vdbe*)pStmt;    sqlite3_mutex_enter(v->db->mutex);    rc = sqlite3VdbeReset(v);    stmtLruAdd(v);    sqlite3VdbeMakeReady(v, -1, 0, 0, 0);    assert( (rc & (v->db->errMask))==rc );    sqlite3_mutex_leave(v->db->mutex);  }  return rc;}

/*** Change the alarm callback*/static int sqlite3MemoryAlarm(  void(*xCallback)(void *pArg, sqlite3_int64 used,int N),  void *pArg,  sqlite3_int64 iThreshold){  int nUsed;  sqlite3_mutex_enter(mem0.mutex);  mem0.alarmCallback = xCallback;  mem0.alarmArg = pArg;  mem0.alarmThreshold = iThreshold;  nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);  mem0.nearlyFull = (iThreshold>0 && iThreshold<=nUsed);  sqlite3_mutex_leave(mem0.mutex);  return SQLITE_OK;}

/*** Free an allocated buffer obtained from pcache1Alloc().*/static void pcache1Free(void *p){  if( p==0 ) return;  if( p>=pcache1.pStart && p<pcache1.pEnd ){    PgFreeslot *pSlot;    sqlite3_mutex_enter(pcache1.mutex);    sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, -1);    pSlot = (PgFreeslot*)p;    pSlot->pNext = pcache1.pFree;    pcache1.pFree = pSlot;    pcache1.nFreeSlot++;    pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;    assert( pcache1.nFreeSlot<=pcache1.nSlot );    sqlite3_mutex_leave(pcache1.mutex);  }else{    int iSize;    assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);    iSize = sqlite3MallocSize(p);    sqlite3_mutex_enter(pcache1.mutex);    sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -iSize);    sqlite3_mutex_leave(pcache1.mutex);    sqlite3_free(p);  }}

/*** Trigger the alarm */static void sqlite3MallocAlarm(int nByte){  void (*xCallback)(void*,sqlite3_int64,int);  sqlite3_int64 nowUsed;  void *pArg;  if( mem0.alarmCallback==0 ) return;  xCallback = mem0.alarmCallback;  nowUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);  pArg = mem0.alarmArg;  mem0.alarmCallback = 0;  sqlite3_mutex_leave(mem0.mutex);  xCallback(pArg, nowUsed, nByte);  sqlite3_mutex_enter(mem0.mutex);  mem0.alarmCallback = xCallback;  mem0.alarmArg = pArg;}

/*** Reset the automatic extension loading mechanism.*/void sqlite3_reset_auto_extension(void){#ifndef SQLITE_OMIT_AUTOINIT  if( sqlite3_initialize()==SQLITE_OK )#endif  {#ifndef SQLITE_MUTEX_NOOP    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);#endif    sqlite3_mutex_enter(mutex);    sqlite3_free(autoext.aExt);    autoext.aExt = 0;    autoext.nExt = 0;    sqlite3_mutex_leave(mutex);  }}

/*** Terminate the current execution of an SQL statement and reset it** back to its starting state so that it can be reused. A success code from** the prior execution is returned.**** This routine sets the error code and string returned by** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().*/int sqlite3_reset(sqlite3_stmt *pStmt){  int rc;  if( pStmt==0 ){    rc = SQLITE_OK;  }else{    Vdbe *v = (Vdbe*)pStmt;    sqlite3_mutex_enter(v->db->mutex);    rc = sqlite3VdbeReset(v);    sqlite3VdbeRewind(v);    assert( (rc & (v->db->errMask))==rc );    rc = sqlite3ApiExit(v->db, rc);    sqlite3_mutex_leave(v->db->mutex);  }  return rc;}

/*** Check to see if column iCol of the given statement is valid.  If** it is, return a pointer to the Mem for the value of that column.** If iCol is not valid, return a pointer to a Mem which has a value** of NULL.*/static Mem *columnMem(sqlite3_stmt *pStmt, int i){  Vdbe *pVm;  Mem *pOut;  pVm = (Vdbe *)pStmt;  if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){    sqlite3_mutex_enter(pVm->db->mutex);    pOut = &pVm->pResultSet[i];  }else{    /* If the value passed as the second argument is out of range, return    ** a pointer to the following static Mem object which contains the    ** value SQL NULL. Even though the Mem structure contains an element    ** of type i64, on certain architectures (x86) with certain compiler    ** switches (-Os), gcc may align this Mem object on a 4-byte boundary    ** instead of an 8-byte one. This all works fine, except that when    ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s    ** that a Mem structure is located on an 8-byte boundary. To prevent    ** these assert()s from failing, when building with SQLITE_DEBUG defined    ** using gcc, we force nullMem to be 8-byte aligned using the magical    ** __attribute__((aligned(8))) macro.  */    static const Mem nullMem #if defined(SQLITE_DEBUG) && defined(__GNUC__)      __attribute__((aligned(8))) #endif      = {0, "", (double)0, {0}, 0, MEM_Null, SQLITE_NULL, 0,#ifdef SQLITE_DEBUG         0, 0,  /* pScopyFrom, pFiller */#endif         0, 0 };    if( pVm && ALWAYS(pVm->db) ){      sqlite3_mutex_enter(pVm->db->mutex);      sqlite3Error(pVm->db, SQLITE_RANGE, 0);    }    pOut = (Mem*)&nullMem;  }

/*** Set all the parameters in the compiled SQL statement to NULL.*/int sqlite3_clear_bindings(sqlite3_stmt *pStmt){  int i;  int rc = SQLITE_OK;  Vdbe *p = (Vdbe*)pStmt;#ifndef SQLITE_MUTEX_NOOP  sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;#endif  sqlite3_mutex_enter(mutex);  for(i=0; i<p->nVar; i++){    sqlite3VdbeMemRelease(&p->aVar[i]);    p->aVar[i].flags = MEM_Null;  }  sqlite3_mutex_leave(mutex);  return rc;}

/*** Declare that a function has been overloaded by a virtual table.**** If the function already exists as a regular global function, then** this routine is a no-op.  If the function does not exist, then create** a new one that always throws a run-time error.  **** When virtual tables intend to provide an overloaded function, they** should call this routine to make sure the global function exists.** A global function must exist in order for name resolution to work** properly.*/EXPORT_C int sqlite3_overload_function(  sqlite3 *db,  const char *zName,  int nArg){  int nName = strlen(zName);  int rc;  sqlite3_mutex_enter(db->mutex);  if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){    sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,                      0, sqlite3InvalidFunction, 0, 0);  }  rc = sqlite3ApiExit(db, SQLITE_OK);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** Close a blob handle that was previously created using** sqlite3_blob_open().*/int sqlite3_blob_close(sqlite3_blob *pBlob){  Incrblob *p = (Incrblob *)pBlob;  int rc;  sqlite3 *db;  if( p ){    db = p->db;    sqlite3_mutex_enter(db->mutex);    rc = sqlite3_finalize(p->pStmt);    sqlite3DbFree(db, p);    sqlite3_mutex_leave(db->mutex);  }else{    rc = SQLITE_OK;  }  return rc;}

/*** The following routine destroys a virtual machine that is created by** the sqlite3_compile() routine. The integer returned is an SQLITE_** success/failure code that describes the result of executing the virtual** machine.**** This routine sets the error code and string returned by** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().*/int sqlite3_finalize(sqlite3_stmt *pStmt){  int rc;  if( pStmt==0 ){    rc = SQLITE_OK;  }else{    Vdbe *v = (Vdbe*)pStmt;#ifndef SQLITE_MUTEX_NOOP    sqlite3_mutex *mutex = v->db->mutex;#endif    sqlite3_mutex_enter(mutex);    stmtLruRemove(v);    rc = sqlite3VdbeFinalize(v);    sqlite3_mutex_leave(mutex);  }  return rc;}

void *sqlite3Malloc(int n){  void *p;  if( n<=0                   || n>=0x7fffff00  ){    p = 0;  }else if( sqlite3GlobalConfig.bMemstat ){    sqlite3_mutex_enter(mem0.mutex);    mallocWithAlarm(n, &p);    sqlite3_mutex_leave(mem0.mutex);  }else{    p = sqlite3GlobalConfig.m.xMalloc(n);  }  assert( EIGHT_BYTE_ALIGNMENT(p) );    return p;}

/* ** Reset the automatic extension loading mechanism. */SQLITE_API void sqlite3_reset_auto_extension(void){#ifndef SQLITE_OMIT_AUTOINIT    if( sqlite3_initialize()==SQLITE_OK )#endif    {#if SQLITE_THREADSAFE        sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);#endif        wsdAutoextInit;        sqlite3_mutex_enter(mutex);        sqlite3_free(wsdAutoext.aExt);        wsdAutoext.aExt = 0;        wsdAutoext.nExt = 0;        sqlite3_mutex_leave(mutex);    }}

/*** Change the size of an existing memory allocation*/void *sqlite3Realloc(void *pOld, int nBytes){  int nOld, nNew, nDiff;  void *pNew;  if( pOld==0 ){    return sqlite3Malloc(nBytes); /* IMP: R-28354-25769 */  }  if( nBytes<=0 ){    sqlite3_free(pOld); /* IMP: R-31593-10574 */    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(nBytes);  if( nOld==nNew ){    pNew = pOld;  }else if( sqlite3GlobalConfig.bMemstat ){    sqlite3_mutex_enter(mem0.mutex);    sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);    nDiff = nNew - nOld;    if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >=           mem0.alarmThreshold-nDiff ){      sqlite3MallocAlarm(nDiff);    }    assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );    assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );    pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);    if( pNew==0 && mem0.alarmCallback ){      sqlite3MallocAlarm(nBytes);      pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);    }    if( pNew ){      nNew = sqlite3MallocSize(pNew);      sqlite3StatusAdd(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-04675-44850 */  return pNew;}

/*** This function is used to set the schema of a virtual table.  It is only** valid to call this function from within the xCreate() or xConnect() of a** virtual table module.*/int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){  Parse sParse;  int rc = SQLITE_OK;  Table *pTab;  char *zErr = 0;  sqlite3_mutex_enter(db->mutex);  pTab = db->pVTab;  if( !pTab ){    sqlite3Error(db, SQLITE_MISUSE, 0);    sqlite3_mutex_leave(db->mutex);    return SQLITE_MISUSE;  }  assert(pTab->isVirtual && pTab->nCol==0 && pTab->aCol==0);  memset(&sParse, 0, sizeof(Parse));  sParse.declareVtab = 1;  sParse.db = db;  if(       SQLITE_OK == sqlite3RunParser(&sParse, zCreateTable, &zErr) &&       sParse.pNewTable &&       !sParse.pNewTable->pSelect &&       !sParse.pNewTable->isVirtual   ){    pTab->aCol = sParse.pNewTable->aCol;    pTab->nCol = sParse.pNewTable->nCol;    sParse.pNewTable->nCol = 0;    sParse.pNewTable->aCol = 0;    db->pVTab = 0;  } else {    sqlite3Error(db, SQLITE_ERROR, zErr);    sqlite3_free(zErr);    rc = SQLITE_ERROR;  }  sParse.declareVtab = 0;  sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);  sqlite3DeleteTable(sParse.pNewTable);  sParse.pNewTable = 0;  assert( (rc&0xff)==rc );  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

static int codec_set_btree_to_codec_pagesize(sqlite3 *db, Db *pDb, codec_ctx *ctx) {  int rc, page_sz, reserve_sz;   page_sz = sqlcipher_codec_ctx_get_pagesize(ctx);  reserve_sz = sqlcipher_codec_ctx_get_reservesize(ctx);  sqlite3_mutex_enter(db->mutex);  db->nextPagesize = page_sz;   /* before forcing the page size we need to unset the BTS_PAGESIZE_FIXED flag, else       sqliteBtreeSetPageSize will block the change  */  pDb->pBt->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;  CODEC_TRACE(("codec_set_btree_to_codec_pagesize: sqlite3BtreeSetPageSize() size=%d reserve=%d/n", page_sz, reserve_sz));  rc = sqlite3BtreeSetPageSize(pDb->pBt, page_sz, reserve_sz, 0);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** Perform a read or write operation on a blob*/static int blobReadWrite(  sqlite3_blob *pBlob,   void *z,   int n,   int iOffset,   int (*xCall)(BtCursor*, u32, u32, void*)){  int rc;  Incrblob *p = (Incrblob *)pBlob;  Vdbe *v;  sqlite3 *db;  if( p==0 ) return SQLITE_MISUSE;  db = p->db;  sqlite3_mutex_enter(db->mutex);  v = (Vdbe*)p->pStmt;  if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){    /* Request is out of range. Return a transient error. */    rc = SQLITE_ERROR;    sqlite3Error(db, SQLITE_ERROR, 0);  } else if( v==0 ){    /* If there is no statement handle, then the blob-handle has    ** already been invalidated. Return SQLITE_ABORT in this case.    */    rc = SQLITE_ABORT;  }else{    /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is    ** returned, clean-up the statement handle.    */    assert( db == v->db );    sqlite3BtreeEnterCursor(p->pCsr);    rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);    sqlite3BtreeLeaveCursor(p->pCsr);    if( rc==SQLITE_ABORT ){      sqlite3VdbeFinalize(v);      p->pStmt = 0;    }else{      db->errCode = rc;      v->rc = rc;    }  }  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

/* generate a defined number of random bytes */static int sqlcipher_openssl_random (void *ctx, void *buffer, int length) {  int rc = 0;  /* concurrent calls to RAND_bytes can cause a crash under some openssl versions when a      naive application doesn't use CRYPTO_set_locking_callback and     CRYPTO_THREADID_set_callback to ensure openssl thread safety.      This is simple workaround to prevent this common crash     but a more proper solution is that applications setup platform-appropriate     thread saftey in openssl externally */#ifndef SQLCIPHER_OPENSSL_NO_MUTEX_RAND  sqlite3_mutex_enter(openssl_rand_mutex);#endif  rc = RAND_bytes((unsigned char *)buffer, length);#ifndef SQLCIPHER_OPENSSL_NO_MUTEX_RAND  sqlite3_mutex_leave(openssl_rand_mutex);#endif  return (rc == 1) ? SQLITE_OK : SQLITE_ERROR;}

/*** The following routine destroys a virtual machine that is created by** the sqlite3_compile() routine. The integer returned is an SQLITE_** success/failure code that describes the result of executing the virtual** machine.**** This routine sets the error code and string returned by** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().*/int sqlite3_finalize(sqlite3_stmt *pStmt){  int rc;  if( pStmt==0 ){    /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL    ** pointer is a harmless no-op. */    rc = SQLITE_OK;  }else{    Vdbe *v = (Vdbe*)pStmt;    sqlite3 *db = v->db;    if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;    sqlite3_mutex_enter(db->mutex);    rc = sqlite3VdbeFinalize(v);    rc = sqlite3ApiExit(db, rc);    sqlite3LeaveMutexAndCloseZombie(db);  }  return rc;}

/*** Return a pointer to the next prepared statement after pStmt associated** with database connection pDb.  If pStmt is NULL, return the first** prepared statement for the database connection.  Return NULL if there** are no more.*/sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){  sqlite3_stmt *pNext;#ifdef SQLITE_ENABLE_API_ARMOR  if( !sqlite3SafetyCheckOk(pDb) ){    (void)SQLITE_MISUSE_BKPT;    return 0;  }#endif  sqlite3_mutex_enter(pDb->mutex);  if( pStmt==0 ){    pNext = (sqlite3_stmt*)pDb->pVdbe;  }else{    pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;  }  sqlite3_mutex_leave(pDb->mutex);  return pNext;}