Lines Matching refs:nByte
1389 void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
1392 int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
3499 int nByte, /* Maximum length of zSql in bytes. */
3506 int nByte, /* Maximum length of zSql in bytes. */
3513 int nByte, /* Maximum length of zSql in bytes. */
3520 int nByte, /* Maximum length of zSql in bytes. */
13372 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
15222 int nByte = 0; /* Used to accumulate return value */ in sqlite3_db_status() local
15225 db->pnBytesFreed = &nByte; in sqlite3_db_status()
15231 nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * ( in sqlite3_db_status()
15237 nByte += sqlite3MallocSize(pSchema->tblHash.ht); in sqlite3_db_status()
15238 nByte += sqlite3MallocSize(pSchema->trigHash.ht); in sqlite3_db_status()
15239 nByte += sqlite3MallocSize(pSchema->idxHash.ht); in sqlite3_db_status()
15240 nByte += sqlite3MallocSize(pSchema->fkeyHash.ht); in sqlite3_db_status()
15254 *pCurrent = nByte; in sqlite3_db_status()
15265 int nByte = 0; /* Used to accumulate return value */ in sqlite3_db_status() local
15267 db->pnBytesFreed = &nByte; in sqlite3_db_status()
15275 *pCurrent = nByte; in sqlite3_db_status()
16692 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ in sqlite3OsDlError() argument
16693 pVfs->xDlError(pVfs, nByte, zBufOut); in sqlite3OsDlError()
16702 SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ in sqlite3OsRandomness() argument
16703 return pVfs->xRandomness(pVfs, nByte, zBufOut); in sqlite3OsRandomness()
16981 static void *sqlite3MemMalloc(int nByte){ return 0; } in sqlite3MemMalloc() argument
16983 static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; } in sqlite3MemRealloc() argument
17137 static void *sqlite3MemMalloc(int nByte){ in sqlite3MemMalloc() argument
17139 void *p = SQLITE_MALLOC( nByte ); in sqlite3MemMalloc()
17142 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); in sqlite3MemMalloc()
17147 assert( nByte>0 ); in sqlite3MemMalloc()
17148 nByte = ROUND8(nByte); in sqlite3MemMalloc()
17149 p = SQLITE_MALLOC( nByte+8 ); in sqlite3MemMalloc()
17151 p[0] = nByte; in sqlite3MemMalloc()
17155 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); in sqlite3MemMalloc()
17206 static void *sqlite3MemRealloc(void *pPrior, int nByte){ in sqlite3MemRealloc() argument
17208 void *p = SQLITE_REALLOC(pPrior, nByte); in sqlite3MemRealloc()
17213 SQLITE_MALLOCSIZE(pPrior), nByte); in sqlite3MemRealloc()
17218 assert( pPrior!=0 && nByte>0 ); in sqlite3MemRealloc()
17219 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
17221 p = SQLITE_REALLOC(p, nByte+8 ); in sqlite3MemRealloc()
17223 p[0] = nByte; in sqlite3MemRealloc()
17229 sqlite3MemSize(pPrior), nByte); in sqlite3MemRealloc()
17527 static void randomFill(char *pBuf, int nByte){ in randomFill() argument
17530 y = nByte | 1; in randomFill()
17531 while( nByte >= 4 ){ in randomFill()
17537 nByte -= 4; in randomFill()
17539 while( nByte-- > 0 ){ in randomFill()
17550 static void *sqlite3MemMalloc(int nByte){ in sqlite3MemMalloc() argument
17560 nReserve = ROUND8(nByte); in sqlite3MemMalloc()
17586 mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]); in sqlite3MemMalloc()
17594 pHdr->iSize = nByte; in sqlite3MemMalloc()
17595 adjustStats(nByte, +1); in sqlite3MemMalloc()
17598 randomFill((char*)pInt, nByte); in sqlite3MemMalloc()
17599 memset(((char*)pInt)+nByte, 0x65, nReserve-nByte); in sqlite3MemMalloc()
17651 static void *sqlite3MemRealloc(void *pPrior, int nByte){ in sqlite3MemRealloc() argument
17655 assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
17657 pNew = sqlite3MemMalloc(nByte); in sqlite3MemRealloc()
17659 memcpy(pNew, pPrior, (int)(nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize)); in sqlite3MemRealloc()
17660 if( nByte>pOldHdr->iSize ){ in sqlite3MemRealloc()
17661 randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - (int)pOldHdr->iSize); in sqlite3MemRealloc()
18073 static void memsys3OutOfMemory(int nByte){ in memsys3OutOfMemory() argument
18078 sqlite3_release_memory(nByte); in memsys3OutOfMemory()
18192 static void *memsys3MallocUnsafe(int nByte){ in memsys3MallocUnsafe() argument
18199 if( nByte<=12 ){ in memsys3MallocUnsafe()
18202 nBlock = (nByte + 11)/8; in memsys3MallocUnsafe()
18749 static void *memsys5MallocUnsafe(int nByte){ in memsys5MallocUnsafe() argument
18756 assert( nByte>0 ); in memsys5MallocUnsafe()
18760 if( (u32)nByte>mem5.maxRequest ){ in memsys5MallocUnsafe()
18761 mem5.maxRequest = nByte; in memsys5MallocUnsafe()
18767 if( nByte > 0x40000000 ){ in memsys5MallocUnsafe()
18772 for(iFullSz=mem5.szAtom, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){} in memsys5MallocUnsafe()
18781 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte); in memsys5MallocUnsafe()
18799 mem5.totalExcess += iFullSz - nByte; in memsys5MallocUnsafe()
18979 int nByte; /* Number of bytes of memory available to this allocator */ in memsys5Init() local
18994 nByte = sqlite3GlobalConfig.nHeap; in memsys5Init()
19005 mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8))); in memsys5Init()
20766 static void sqlite3MallocAlarm(int nByte){
20776 xCallback(pArg, nowUsed, nByte);
23277 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){
23281 if( nByte>=0 ){
23282 zTerm = &z[nByte];
23331 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
23335 sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
27383 static int unixMapfile(unixFile *pFd, i64 nByte);
29078 static int unixTruncate(sqlite3_file *id, i64 nByte){
29090 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
29093 rc = robust_ftruncate(pFile->h, nByte);
29106 if( pFile->inNormalWrite && nByte==0 ){
29116 if( nByte<pFile->mmapSize ){
29117 pFile->mmapSize = nByte;
29166 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
29175 nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
29216 if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){
29219 if( robust_ftruncate(pFile->h, nByte) ){
29225 rc = unixMapfile(pFile, nByte);
29906 int nByte = nReqRegion*szRegion; /* Minimum required file size */
29921 if( sStat.st_size<nByte ){
29941 assert( (nByte % pgsz)==0 );
29942 for(iPg=(sStat.st_size/pgsz); iPg<(nByte/pgsz); iPg++){
30308 static int unixMapfile(unixFile *pFd, i64 nByte){
30309 i64 nMap = nByte;
34861 int nByte;
34864 nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
34865 if( nByte == 0 ){
34868 zFilename = sqlite3MallocZero( nByte );
34872 nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
34874 if( nByte == 0 ){
34889 int nByte;
34893 nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, NULL,
34895 if( nByte==0 ){
34898 zMbcsFilename = sqlite3MallocZero( nByte*sizeof(zMbcsFilename[0]) );
34902 nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename,
34903 nByte);
34904 if( nByte==0 ){
34919 int nByte;
34923 nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
34924 if( nByte == 0 ){
34927 zFilename = sqlite3MallocZero( nByte );
34931 nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename,
34932 nByte, 0, 0);
34933 if( nByte == 0 ){
35921 static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
35929 osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));
35937 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
35941 if( winSeekFile(pFile, nByte) ){
35956 if( pFile->pMapRegion && nByte<pFile->mmapSize ){
35957 pFile->mmapSize = nByte;
36715 int nByte /* Number of bytes to lock or unlock */
36723 pFile->hFile.h, lockType, ofst, nByte));
36727 rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);
36732 rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0);
37121 int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
37137 if( sz<nByte ){
37145 rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
37169 NULL, PAGE_READWRITE, nByte, NULL
37173 NULL, PAGE_READWRITE, 0, nByte, NULL
37177 NULL, PAGE_READWRITE, 0, nByte, NULL
37181 osGetCurrentProcessId(), pShmNode->nRegion, nByte,
37287 static int winMapfile(winFile *pFd, sqlite3_int64 nByte){
37288 sqlite3_int64 nMap = nByte;
37293 osGetCurrentProcessId(), pFd, nByte));
38430 DWORD nByte;
38464 nByte = osGetFullPathNameW((LPCWSTR)zConverted, 0, 0, 0);
38465 if( nByte==0 ){
38470 nByte += 3;
38471 zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) );
38476 nByte = osGetFullPathNameW((LPCWSTR)zConverted, nByte, zTemp, 0);
38477 if( nByte==0 ){
38490 nByte = osGetFullPathNameA((char*)zConverted, 0, 0, 0);
38491 if( nByte==0 ){
38496 nByte += 3;
38497 zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) );
38502 nByte = osGetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
38503 if( nByte==0 ){
40138 static void *pcache1Alloc(int nByte){
40141 if( nByte<=pcache1.szSlot ){
40149 sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
40158 p = sqlite3Malloc(nByte);
40163 sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
42828 static u32 pager_datahash(int nByte, unsigned char *pData){
42831 for(i=0; i<nByte; i++){
45272 i64 nByte = 0;
45275 rc = sqlite3OsFileSize(pPager->fd, &nByte);
45289 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
49443 int nByte = sizeof(u32*)*(iPage+1);
49445 apNew = (volatile u32 **)sqlite3_realloc64((void *)pWal->apWiData, nByte);
49517 int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */
49523 u32 *aEnd = (u32 *)&a[nByte];
49532 assert( nByte>=8 );
49533 assert( (nByte&0x00000007)==0 );
49835 int nByte; /* Number of bytes to zero in aPgno[] */
49867 nByte = (int)((char *)aHash - (char *)&aPgno[iLimit+1]);
49868 memset((void *)&aPgno[iLimit+1], 0, nByte);
49915 int nByte = (int)((u8 *)&aHash[HASHTABLE_NSLOT] - (u8 *)&aPgno[1]);
49916 memset((void*)&aPgno[1], 0, nByte);
50447 int nByte; /* Number of bytes to allocate */
50460 nByte = sizeof(WalIterator)
50463 p = (WalIterator *)sqlite3_malloc64(nByte);
50467 memset(p, 0, nByte);
54329 static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc, int *pbDefrag){
54348 if( size>=nByte ){
54349 int x = size - nByte;
54391 static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
54401 assert( nByte>=0 ); /* Minimum cell size is 4 */
54402 assert( pPage->nFree>=nByte );
54404 assert( nByte < (int)(pPage->pBt->usableSize-8) );
54426 u8 *pSpace = pageFindSlot(pPage, nByte, &rc, &bDefrag);
54439 testcase( gap+2+nByte==top );
54440 if( gap+2+nByte>top ){
54446 assert( gap+nByte<=top );
54456 top -= nByte;
54458 assert( top+nByte <= (int)pPage->pBt->usableSize );
57211 int nByte, /* Number of bytes to copy */
57221 memcpy(pPayload, pBuf, nByte);
57224 memcpy(pBuf, pPayload, nByte);
63064 i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom);
63065 rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte);
63323 int nByte;
63329 nByte = pMem->n + pMem->u.nZero;
63330 if( nByte<=0 ){
63331 nByte = 1;
63333 if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
63389 const int nByte = 32;
63399 if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){
63410 sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
63413 sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->u.r);
63961 int nByte = n; /* New value for pMem->n */
63980 if( nByte<0 ){
63983 nByte = sqlite3Strlen30(z);
63984 if( nByte>iLimit ) nByte = iLimit+1;
63986 for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
63996 int nAlloc = nByte;
64000 if( nByte>iLimit ){
64021 pMem->n = nByte;
64031 if( nByte>iLimit ){
64208 int nByte; /* Bytes of space to allocate */
64212 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
64213 pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte);
65158 int nByte = (p->nSub+1)*sizeof(SubProgram*);
65164 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
65415 int nByte = (p->nScan+1) * sizeof(ScanStatus);
65417 aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);
66233 int nByte = (nSub+1)*sizeof(SubProgram*);
66238 if( j==nSub && SQLITE_OK==sqlite3VdbeMemGrow(pSub, nByte, nSub!=0) ){
66379 int nByte, /* Number of bytes to allocate */
66386 nByte = ROUND8(nByte);
66387 if( &(*ppFrom)[nByte] <= pEnd ){
66389 *ppFrom += nByte;
66391 *pnByte += nByte;
66467 int nByte; /* How much extra memory is needed */
66521 nByte = 0;
66522 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
66523 p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
66524 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
66525 p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), &zCsr, zEnd, &nByte);
66527 &zCsr, zEnd, &nByte);
66528 p->aOnceFlag = allocSpace(p->aOnceFlag, nOnce, &zCsr, zEnd, &nByte);
66530 p->anExec = allocSpace(p->anExec, p->nOp*sizeof(i64), &zCsr, zEnd, &nByte);
66532 if( nByte ){
66533 p->pFree = sqlite3DbMallocZero(db, nByte);
66536 zEnd = &zCsr[nByte];
66537 }while( nByte && !db->mallocFailed );
67992 int nByte; /* Number of bytes required for *p */
67999 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
68000 if( nByte>szSpace+nOff ){
68001 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
69677 static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){
69680 if( nByte<=0 ){
69684 sqlite3VdbeMemClearAndResize(pMem, nByte);
69688 memset(pMem->z, 0, nByte);
69699 SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context *p, int nByte){
69702 testcase( nByte<0 );
69704 return createAggContext(p, nByte);
70962 int nByte;
70964 nByte =
70973 if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){
72220 i64 nByte;
72233 nByte = pIn1->n + pIn2->n;
72234 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
72237 if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){
72245 pOut->z[nByte]=0;
72246 pOut->z[nByte+1] = 0;
72248 pOut->n = (int)nByte;
73454 i64 nByte; /* Data space required for this record */
73546 nByte = nHdr+nData;
73547 if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){
73556 if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
73576 assert( j==nByte );
73579 pOut->n = (int)nByte;
76256 int nByte; /* Bytes of runtime space required for sub-program */
76302 nByte = ROUND8(sizeof(VdbeFrame))
76306 pFrame = sqlite3DbMallocZero(db, nByte);
77467 int nByte; /* Size of open blob, in bytes */
77518 p->nByte = sqlite3VdbeSerialTypeLen(type);
77821 if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){
77872 return (p && p->pStmt) ? p->nByte : 0;
78404 int nByte, /* Bytes of data to read */
78412 p->iReadOff += nByte;
78441 if( nByte<=nAvail ){
78446 p->iReadOff += nByte;
78454 if( p->nAlloc<nByte ){
78457 while( nByte>nNew ) nNew = nNew*2;
78468 nRem = nByte - nAvail;
78482 memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy);
78656 u64 nByte; /* Size of PMA in bytes */
78657 rc = vdbePmaReadVarint(pReadr, &nByte);
78658 pReadr->iEof = pReadr->iReadOff + nByte;
78659 *pnByte += nByte;
79082 int nByte; /* Total bytes of space to allocate */
79088 nByte = sizeof(MergeEngine) + N * (sizeof(int) + sizeof(PmaReader));
79090 pNew = sqlite3FaultSim(100) ? 0 : (MergeEngine*)sqlite3MallocZero(nByte);
79187 static void vdbeSorterExtendFile(sqlite3 *db, sqlite3_file *pFd, i64 nByte){
79188 if( nByte<=(i64)(db->nMaxSorterMmap) && pFd->pMethods->iVersion>=3 ){
79192 sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_SIZE_HINT, &nByte);
79193 sqlite3OsFetch(pFd, 0, (int)nByte, &p);
79431 int nByte;
79433 nByte = sqlite3PutVarint(aByte, iVal);
79434 vdbePmaWriteBlob(p, aByte, nByte);
83636 int nByte = dupedExprStructSize(p, flags) & 0xfff;
83638 nByte += sqlite3Strlen30(p->u.zToken)+1;
83640 return ROUND8(nByte);
83657 int nByte = 0;
83659 nByte = dupedExprNodeSize(p, flags);
83661 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
83664 return nByte;
83767 int nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1);
83768 pRet = sqlite3DbMallocZero(db, nByte);
83844 int nByte;
83846 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
83847 pNew = sqlite3DbMallocRaw(db, nByte );
89771 int nByte; /* Bytes of space required */
89792 nByte = sizeof(IndexSample) * nSample;
89793 nByte += sizeof(tRowcnt) * nIdxCol * 3 * nSample;
89794 nByte += nIdxCol * sizeof(tRowcnt); /* Space for Index.aAvgEq[] */
89796 pIdx->aSample = sqlite3DbMallocZero(db, nByte);
89808 assert( ((u8*)pSpace)-nByte==(u8*)(pIdx->aSample) );
92414 int nByte;
92417 nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
92418 zExtra = sqlite3DbMallocZero(db, nByte);
93391 int nByte;
93416 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
93419 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
93422 pFKey = sqlite3DbMallocZero(db, nByte );
93615 int nByte; /* Bytes of space for Index object + arrays */
93617 nByte = ROUND8(sizeof(Index)) + /* Index structure */
93622 p = sqlite3DbMallocZero(db, nByte + nExtra);
93631 *ppExtra = ((char*)p) + nByte;
95082 int nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
95083 pNew = sqlite3DbRealloc(db, pWith, nByte);
96839 static void *contextMalloc(sqlite3_context *context, i64 nByte){
96842 assert( nByte>0 );
96843 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
96844 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
96845 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
96849 z = sqlite3Malloc(nByte);
103039 u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
103041 aNew = sqlite3_realloc64(wsdAutoext.aExt, nByte);
130443 u64 nByte = nUri+2; /* Bytes of space to allocate */
130449 for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
130450 zFile = sqlite3_malloc64(nByte);
134133 int nByte; /* Size of allocation used for *p */
134166 nByte = sizeof(const char *) * (argc-2);
134167 aCol = (const char **)sqlite3_malloc(nByte);
134169 memset((void*)aCol, 0, nByte);
134170 azNotindexed = (char **)sqlite3_malloc(nByte);
134173 memset(azNotindexed, 0, nByte);
134357 nByte = sizeof(Fts3Table) + /* Fts3Table */
134364 p = (Fts3Table*)sqlite3_malloc(nByte);
134369 memset(p, 0, nByte);
134415 assert( zCsr <= &((char *)p)[nByte] );
135793 int nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
135794 apNew = (Fts3SegReader **)sqlite3_realloc(pCsr->apSegment, nByte);
137567 int nByte = a[p->nToken-1].nList;
137568 char *aDoclist = sqlite3_malloc(nByte+1);
137570 memcpy(aDoclist, a[p->nToken-1].pList, nByte+1);
137771 sqlite3_int64 nByte = 0;
137783 a += sqlite3Fts3GetVarint(a, &nByte);
137785 if( nDoc==0 || nByte==0 ){
137791 pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
138987 int nByte; /* Bytes of space to allocate here */
139018 nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
139019 p = (Fts3auxTable *)sqlite3_malloc(nByte);
139021 memset(p, 0, nByte);
139595 static void *fts3MallocZero(int nByte){
139596 void *pRet = sqlite3_malloc(nByte);
139597 if( pRet ) memset(pRet, 0, nByte);
139671 int nByte; /* total space to allocate */
139675 nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
139676 pRet = (Fts3Expr *)fts3MallocZero(nByte);
139786 int nByte = 0, iBegin = 0, iEnd = 0, iPos = 0;
139787 rc = pModule->xNext(pCursor, &zByte, &nByte, &iBegin, &iEnd, &iPos);
139794 zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte);
139801 memcpy(&zTemp[nTemp], zByte, nByte);
139802 nTemp += nByte;
139804 pToken->n = nByte;
140097 int nByte = 0;
140099 rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
140100 assert( nByte>0 || (rc!=SQLITE_OK && p==0) );
140187 assert( nByte>0 );
140189 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
140190 nIn -= nByte;
140191 zIn += nByte;
142651 int nByte = 0;
142655 nByte += (int)(strlen(argv[i]) + 1);
142658 *pazDequote = azDequote = sqlite3_malloc(sizeof(char *)*argc + nByte);
142881 int nByte = sqlite3_value_bytes(apVal[0]);
142882 pCsr->zInput = sqlite3_malloc(nByte+1);
142886 memcpy(pCsr->zInput, zByte, nByte);
142887 pCsr->zInput[nByte] = 0;
142888 rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
144201 int nByte = sqlite3_blob_bytes(p->pSegments);
144202 *pnBlob = nByte;
144204 char *aByte = sqlite3_malloc(nByte + FTS3_NODE_PADDING);
144208 if( pnLoad && nByte>(FTS3_NODE_CHUNK_THRESHOLD) ){
144209 nByte = FTS3_NODE_CHUNKSIZE;
144210 *pnLoad = nByte;
144212 rc = sqlite3_blob_read(p->pSegments, aByte, nByte, 0);
144213 memset(&aByte[nByte], 0, FTS3_NODE_PADDING);
144259 static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){
144265 && (pFrom - pReader->aNode + nByte)>pReader->nPopulate
144718 int nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *);
144719 pReader = (Fts3SegReader *)sqlite3_malloc(nByte);
144723 memset(pReader, 0, nByte);
145902 int nByte;
145931 nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0);
145932 if( nDoclist+nByte>pCsr->nBuffer ){
145934 pCsr->nBuffer = (nDoclist+nByte)*2;
146040 sqlite3_int64 nByte /* Size of new segment at iAbsLevel */
146050 i64 nLimit = (nByte*3)/2;
146490 int nByte = sizeof(u32) * (p->nColumn+1)*3;
146491 aSz = (u32 *)sqlite3_malloc(nByte);
146495 memset(aSz, 0, nByte);
146557 int nByte; /* Bytes allocated at pCsr->apSegment[] */
146561 nByte = sizeof(Fts3SegReader *) * nSeg;
146562 pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc(nByte);
146567 memset(pCsr->apSegment, 0, nByte);
149069 int nByte; /* Number of bytes of space to allocate */
149086 nByte = sizeof(SnippetPhrase) * nList;
149087 sIter.aPhrase = (SnippetPhrase *)sqlite3_malloc(nByte);
149091 memset(sIter.aPhrase, 0, nByte);
151616 int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell;
151617 memmove(pDst, pSrc, nByte);
153111 int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
153113 aaSorted = (int **)sqlite3_malloc(nByte);
153119 memset(aaSorted, 0, nByte);
155171 int nByte = 0;
155196 if( nByte ){
155197 char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
155202 pCsr->nBuffer = nByte;
155206 pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */
155210 } while( nByte>pCsr->nBuffer );
155213 *pnBytes = nByte;