lib/sqlite/sqlite3.c

1482 ** The xRandomness() function attempts to return nBytes bytes
4421 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
15732 ** Called when we are unable to satisfy an allocation of nBytes.
15847 ** Return a block of memory of at least nBytes in size.
15996 ** Allocate nBytes of memory.
15998 static void *memsys3Malloc(int nBytes){
16000   assert( nBytes>0 );          /* malloc.c filters out 0 byte requests */
16002   p = memsys3MallocUnsafe(nBytes);
16020 static void *memsys3Realloc(void *pPrior, int nBytes){
16024     return sqlite3_malloc(nBytes);
16026   if( nBytes<=0 ){
16031   if( nBytes<=nOld && nBytes>=nOld-128 ){
16035   p = memsys3MallocUnsafe(nBytes);
16037     if( nOld<nBytes ){
16040       memcpy(p, pPrior, nBytes);
16420 ** Return a block of memory of at least nBytes in size.
16421 ** Return NULL if unable.  Return NULL if nBytes==0.
16545 ** Allocate nBytes of memory
16547 static void *memsys5Malloc(int nBytes){
16549   if( nBytes>0 ){
16551     p = memsys5MallocUnsafe(nBytes);
16576 ** nBytes is always a value obtained from a prior call to
16577 ** memsys5Round().  Hence nBytes is always a non-negative power
16578 ** of two.  If nBytes==0 that means that an oversize allocation
16582 static void *memsys5Realloc(void *pPrior, int nBytes){
16586   assert( (nBytes&(nBytes-1))==0 );  /* EV: R-46199-30249 */
16587   assert( nBytes>=0 );
16588   if( nBytes==0 ){
16592   if( nBytes<=nOld ){
16596   p = memsys5MallocUnsafe(nBytes);
18606 SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, int nBytes){
18610     return sqlite3Malloc(nBytes); /* IMP: R-28354-25769 */
18612   if( nBytes<=0 ){
18616   if( nBytes>=0x7fffff00 ){
18624   nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
18629     sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
18639       sqlite3MallocAlarm(nBytes);
28023 ** file-control operation.  Enlarge the database to nBytes in size
28025 ** nBytes or larger, this routine is a no-op.
31742 static void *winMemMalloc(int nBytes);
31744 static void *winMemRealloc(void *pPrior, int nBytes);
31806 ** Allocate nBytes of memory.
31808 static void *winMemMalloc(int nBytes){
31819   assert( nBytes>=0 );
31820   p = HeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
31823         nBytes, GetLastError(), (void*)hHeap);
31851 static void *winMemRealloc(void *pPrior, int nBytes){
31862   assert( nBytes>=0 );
31864     p = HeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
31866     p = HeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
31870         pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, GetLastError(),
56283 ** The first time this is called on a shared-btree, nBytes bytes of memory
56285 ** call the nBytes parameter is ignored and a pointer to the same blob
56288 ** If the nBytes parameter is 0 and the blob of memory has not yet been
56297 SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
56300   if( !pBt->pSchema && nBytes ){
56301     pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
79203   int nBytes;
79215   nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
79217       sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
82915   int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
82917   KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(db, nBytes);
82922     assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
88927   void * (*aggregate_context)(sqlite3_context*,int nBytes);
92011   int nBytes,               /* Length of zSql in bytes. */
92074   if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
92077     testcase( nBytes==mxLen );
92078     testcase( nBytes==mxLen+1 );
92079     if( nBytes>mxLen ){
92084     zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
92090       pParse->zTail = &zSql[nBytes];
92171   int nBytes,               /* Length of zSql in bytes. */
92185   rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
92188     rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
92243   int nBytes,               /* Length of zSql in bytes. */
92248   rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
92255   int nBytes,               /* Length of zSql in bytes. */
92260   rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
92273   int nBytes,               /* Length of zSql in bytes. */
92292   zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
92323   int nBytes,               /* Length of zSql in bytes. */
92328   rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
92335   int nBytes,               /* Length of zSql in bytes. */
92340   rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
99531   int nBytes = sizeof(char *)*(1+pTable->nModuleArg);
99533   azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
99867     int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
99868     aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
113861     const char *pInput, int nBytes,      /* Input buffer */
113892   ** nul-terminated.  This should either be fixed, or pInput/nBytes
122067   int nBytes;                  /* size of the input */
122133 ** string to be tokenized is pInput[0..nBytes-1].  A cursor
122139   const char *pInput, int nBytes,        /* String to be tokenized */
122151     c->nBytes = 0;
122152   }else if( nBytes<0 ){
122153     c->nBytes = (int)strlen(pInput);
122155     c->nBytes = nBytes;
122193   while( c->iOffset<c->nBytes ){
122197     while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
122203     while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
130902 ** string to be tokenized is pInput[0..nBytes-1].  A cursor