contrib/sqlite3/sqlite3.c

1643 ** The xRandomness() function attempts to return nBytes bytes
4723 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
16666 ** Called when we are unable to satisfy an allocation of nBytes.
16781 ** Return a block of memory of at least nBytes in size.
16930 ** Allocate nBytes of memory.
16932 static void *memsys3Malloc(int nBytes){
16934   assert( nBytes>0 );          /* malloc.c filters out 0 byte requests */
16936   p = memsys3MallocUnsafe(nBytes);
16954 static void *memsys3Realloc(void *pPrior, int nBytes){
16958     return sqlite3_malloc(nBytes);
16960   if( nBytes<=0 ){
16965   if( nBytes<=nOld && nBytes>=nOld-128 ){
16969   p = memsys3MallocUnsafe(nBytes);
16971     if( nOld<nBytes ){
16974       memcpy(p, pPrior, nBytes);
17354 ** Return a block of memory of at least nBytes in size.
17355 ** Return NULL if unable.  Return NULL if nBytes==0.
17479 ** Allocate nBytes of memory
17481 static void *memsys5Malloc(int nBytes){
17483   if( nBytes>0 ){
17485     p = memsys5MallocUnsafe(nBytes);
17510 ** nBytes is always a value obtained from a prior call to
17511 ** memsys5Round().  Hence nBytes is always a non-negative power
17512 ** of two.  If nBytes==0 that means that an oversize allocation
17516 static void *memsys5Realloc(void *pPrior, int nBytes){
17520   assert( (nBytes&(nBytes-1))==0 );  /* EV: R-46199-30249 */
17521   assert( nBytes>=0 );
17522   if( nBytes==0 ){
17526   if( nBytes<=nOld ){
17530   p = memsys5MallocUnsafe(nBytes);
19279 SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, int nBytes){
19283     return sqlite3Malloc(nBytes); /* IMP: R-28354-25769 */
19285   if( nBytes<=0 ){
19289   if( nBytes>=0x7fffff00 ){
19297   nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
19302     sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
19312       sqlite3MallocAlarm(nBytes);
26742 ** file-control operation.  Enlarge the database to nBytes in size
26744 ** nBytes or larger, this routine is a no-op.
30989 static void *winMemMalloc(int nBytes);
30991 static void *winMemRealloc(void *pPrior, int nBytes);
31799 ** Allocate nBytes of memory.
31801 static void *winMemMalloc(int nBytes){
31812   assert( nBytes>=0 );
31813   p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
31816                 nBytes, osGetLastError(), (void*)hHeap);
31844 static void *winMemRealloc(void *pPrior, int nBytes){
31855   assert( nBytes>=0 );
31857     p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
31859     p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
31863                 pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(),
57848 ** The first time this is called on a shared-btree, nBytes bytes of memory
57850 ** call the nBytes parameter is ignored and a pointer to the same blob
57853 ** If the nBytes parameter is 0 and the blob of memory has not yet been
57862 SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
57865   if( !pBt->pSchema && nBytes ){
57866     pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
82248   int nBytes;
82260   nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
82262       sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
85995   int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
85997   KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(db, nBytes);
86002     assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
92212   void * (*aggregate_context)(sqlite3_context*,int nBytes);
95735   int nBytes,               /* Length of zSql in bytes. */
95798   if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
95801     testcase( nBytes==mxLen );
95802     testcase( nBytes==mxLen+1 );
95803     if( nBytes>mxLen ){
95808     zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
95814       pParse->zTail = &zSql[nBytes];
95894   int nBytes,               /* Length of zSql in bytes. */
95908   rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
95911     rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
95967   int nBytes,               /* Length of zSql in bytes. */
95972   rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
95979   int nBytes,               /* Length of zSql in bytes. */
95984   rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
95997   int nBytes,               /* Length of zSql in bytes. */
96016   zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
96047   int nBytes,               /* Length of zSql in bytes. */
96052   rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
96059   int nBytes,               /* Length of zSql in bytes. */
96064   rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
103552   int nBytes = sizeof(char *)*(1+pTable->nModuleArg);
103554   azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
103894     int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
103895     aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
118877     const char *pInput, int nBytes,      /* Input buffer */
118908   ** nul-terminated.  This should either be fixed, or pInput/nBytes
127982   int nBytes;                  /* size of the input */
128048 ** string to be tokenized is pInput[0..nBytes-1].  A cursor
128054   const char *pInput, int nBytes,        /* String to be tokenized */
128066     c->nBytes = 0;
128067   }else if( nBytes<0 ){
128068     c->nBytes = (int)strlen(pInput);
128070     c->nBytes = nBytes;
128108   while( c->iOffset<c->nBytes ){
128112     while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
128118     while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
135828 ** string to be tokenized is pInput[0..nBytes-1].  A cursor
140283 ** string to be tokenized is pInput[0..nBytes-1].  A cursor