lib/sqlite/sqlite3.c

15025   i64 iSize;                          /* Size of this allocation */
15098 static void adjustStats(int iSize, int increment){
15099   int i = ROUND8(iSize)/8;
15130   nReserve = ROUND8(p->iSize);
15138   while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 );
15151   return pHdr->iSize;
15255     pHdr->iSize = nByte;
15296   adjustStats(pHdr->iSize, -1);
15298                 pHdr->iSize + sizeof(int) + pHdr->nTitle);
15320     memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
15321     if( nByte>pOldHdr->iSize ){
15322       randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - pOldHdr->iSize);
15437     mem.xBacktrace(pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
15460             pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???");
16391   int iSize = 0;
16395     iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
16397   return iSize;
18513         int iSize = sqlite3MallocSize(p);
18515         sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, -iSize);
18516         sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
34841 ** with values between 1 and iSize, inclusive.
34844 ** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight
34847 ** If iSize>BITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is
34859   u32 iSize;      /* Maximum bit index.  Max iSize is 4,294,967,296. */
34875 ** Create a new bitmap object able to handle bits between 0 and iSize,
34879 SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32 iSize){
34884     p->iSize = iSize;
34896   if( i>p->iSize || i==0 ) return 0;
34906   if( p->iSize<=BITVEC_NBIT ){
34934   assert( i<=p->iSize );
34936   while((p->iSize > BITVEC_NBIT) && p->iDivisor) {
34945   if( p->iSize<=BITVEC_NBIT ){
34980       p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR;
35013   if( p->iSize<=BITVEC_NBIT ){
35050 ** Return the value of the iSize parameter specified when Bitvec *p
35054   return p->iSize;
36100     int iSize;
36103     iSize = sqlite3MallocSize(p);
36105     sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -iSize);
36119     int iSize;
36122     iSize = sqlite3MallocSize(p);
36124     return iSize;
56739 ** If pFile is currently larger than iSize bytes, then truncate it to
56740 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
56746 static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){
56749   if( rc==SQLITE_OK && iCurrent>iSize ){
56750     rc = sqlite3OsTruncate(pFile, iSize);
56905           const i64 iSize = (i64)pgszSrc * (i64)nSrcPage;
56911           assert( (i64)nDestTruncate*(i64)pgszDest >= iSize || (
56913              && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest
56925           iEnd = MIN(PENDING_BYTE + pgszDest, iSize);
56941             rc = backupTruncateFile(pFile, iSize);
71200   int iSize;                      /* Amount of zBuf[] currently used */
71219       if( p->iSize>0 ){
71220         assert(p->iSize<=p->nBuf);
71221         rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0);
71253   }else if( (iAmt+iOfst)>p->iSize ){
71280       if( p->iSize<(iOfst+iAmt) ){
71281         p->iSize = (iOfst+iAmt);
71296   }else if( size<p->iSize ){
71297     p->iSize = size;
71325     *pSize = (sqlite_int64) p->iSize;