Lines Matching refs:nByte
1524 void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
1527 int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
3414 int nByte, /* Maximum length of zSql in bytes. */
3421 int nByte, /* Maximum length of zSql in bytes. */
3428 int nByte, /* Maximum length of zSql in bytes. */
3435 int nByte, /* Maximum length of zSql in bytes. */
10150 u8 nByte; /* Size in byte of text or blob. */ member
11538 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
13142 int nByte = 0; /* Used to accumulate return value */ in sqlite3_db_status() local
13145 db->pnBytesFreed = &nByte; in sqlite3_db_status()
13151 nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * ( in sqlite3_db_status()
13157 nByte += sqlite3MallocSize(pSchema->tblHash.ht); in sqlite3_db_status()
13158 nByte += sqlite3MallocSize(pSchema->trigHash.ht); in sqlite3_db_status()
13159 nByte += sqlite3MallocSize(pSchema->idxHash.ht); in sqlite3_db_status()
13160 nByte += sqlite3MallocSize(pSchema->fkeyHash.ht); in sqlite3_db_status()
13174 *pCurrent = nByte; in sqlite3_db_status()
13185 int nByte = 0; /* Used to accumulate return value */ in sqlite3_db_status() local
13187 db->pnBytesFreed = &nByte; in sqlite3_db_status()
13194 *pCurrent = nByte; in sqlite3_db_status()
14502 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ in sqlite3OsDlError() argument
14503 pVfs->xDlError(pVfs, nByte, zBufOut); in sqlite3OsDlError()
14512 SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ in sqlite3OsRandomness() argument
14513 return pVfs->xRandomness(pVfs, nByte, zBufOut); in sqlite3OsRandomness()
14787 static void *sqlite3MemMalloc(int nByte){ return 0; } in sqlite3MemMalloc() argument
14789 static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; } in sqlite3MemRealloc() argument
14854 static void *sqlite3MemMalloc(int nByte){ in sqlite3MemMalloc() argument
14856 assert( nByte>0 ); in sqlite3MemMalloc()
14857 nByte = ROUND8(nByte); in sqlite3MemMalloc()
14858 p = malloc( nByte+8 ); in sqlite3MemMalloc()
14860 p[0] = nByte; in sqlite3MemMalloc()
14864 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); in sqlite3MemMalloc()
14906 static void *sqlite3MemRealloc(void *pPrior, int nByte){ in sqlite3MemRealloc() argument
14908 assert( pPrior!=0 && nByte>0 ); in sqlite3MemRealloc()
14909 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
14911 p = realloc(p, nByte+8 ); in sqlite3MemRealloc()
14913 p[0] = nByte; in sqlite3MemRealloc()
14919 sqlite3MemSize(pPrior), nByte); in sqlite3MemRealloc()
15188 static void randomFill(char *pBuf, int nByte){ in randomFill() argument
15191 y = nByte | 1; in randomFill()
15192 while( nByte >= 4 ){ in randomFill()
15198 nByte -= 4; in randomFill()
15200 while( nByte-- > 0 ){ in randomFill()
15211 static void *sqlite3MemMalloc(int nByte){ in sqlite3MemMalloc() argument
15221 nReserve = ROUND8(nByte); in sqlite3MemMalloc()
15247 mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]); in sqlite3MemMalloc()
15255 pHdr->iSize = nByte; in sqlite3MemMalloc()
15256 adjustStats(nByte, +1); in sqlite3MemMalloc()
15259 randomFill((char*)pInt, nByte); in sqlite3MemMalloc()
15260 memset(((char*)pInt)+nByte, 0x65, nReserve-nByte); in sqlite3MemMalloc()
15312 static void *sqlite3MemRealloc(void *pPrior, int nByte){ in sqlite3MemRealloc() argument
15316 assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
15318 pNew = sqlite3MemMalloc(nByte); in sqlite3MemRealloc()
15320 memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize); in sqlite3MemRealloc()
15321 if( nByte>pOldHdr->iSize ){ in sqlite3MemRealloc()
15322 randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - pOldHdr->iSize); in sqlite3MemRealloc()
15734 static void memsys3OutOfMemory(int nByte){ in memsys3OutOfMemory() argument
15739 sqlite3_release_memory(nByte); in memsys3OutOfMemory()
15853 static void *memsys3MallocUnsafe(int nByte){ in memsys3MallocUnsafe() argument
15860 if( nByte<=12 ){ in memsys3MallocUnsafe()
15863 nBlock = (nByte + 11)/8; in memsys3MallocUnsafe()
16429 static void *memsys5MallocUnsafe(int nByte){ in memsys5MallocUnsafe() argument
16436 assert( nByte>0 ); in memsys5MallocUnsafe()
16440 if( (u32)nByte>mem5.maxRequest ){ in memsys5MallocUnsafe()
16441 mem5.maxRequest = nByte; in memsys5MallocUnsafe()
16447 if( nByte > 0x40000000 ){ in memsys5MallocUnsafe()
16452 for(iFullSz=mem5.szAtom, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){} in memsys5MallocUnsafe()
16461 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte); in memsys5MallocUnsafe()
16478 mem5.totalExcess += iFullSz - nByte; in memsys5MallocUnsafe()
16645 int nByte; /* Number of bytes of memory available to this allocator */ in memsys5Init() local
16660 nByte = sqlite3GlobalConfig.nHeap; in memsys5Init()
16671 mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8))); in memsys5Init()
18338 static void sqlite3MallocAlarm(int nByte){ in sqlite3MallocAlarm() argument
18348 xCallback(pArg, nowUsed, nByte); in sqlite3MallocAlarm()
20439 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){ in sqlite3Utf8CharLen() argument
20443 if( nByte>=0 ){ in sqlite3Utf8CharLen()
20444 zTerm = &z[nByte]; in sqlite3Utf8CharLen()
20493 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){ in sqlite3Utf16to8() argument
20497 sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC); in sqlite3Utf16to8()
22631 static int os2Truncate( sqlite3_file *id, i64 nByte ){
22635 OSTRACE(( "TRUNCATE %d %lld\n", pFile->h, nByte ));
22644 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
22647 rc = DosSetFileSize( pFile->h, nByte );
23280 int nByte /* Number of bytes to lock or unlock */
23292 area.lRange = nByte;
27949 static int unixTruncate(sqlite3_file *id, i64 nByte){
27961 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
27964 rc = robust_ftruncate(pFile->h, (off_t)nByte);
27977 if( pFile->inNormalWrite && nByte==0 ){
28027 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
28034 nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
28546 int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
28561 if( sStat.st_size<nByte ){
28569 if( robust_ftruncate(pShmNode->h, nByte) ){
32013 int nByte;
32016 nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
32017 zFilename = malloc( nByte );
32021 nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
32023 if( nByte == 0 ){
32038 int nByte;
32042 nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
32043 zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );
32047 nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
32048 if( nByte==0 ){
32063 int nByte;
32067 nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
32068 zFilename = malloc( nByte );
32072 nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,
32074 if( nByte == 0 ){
32765 static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
32771 OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
32780 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
32784 if( seekWinFile(pFile, nByte) ){
32791 OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
33370 int nByte /* Number of bytes to lock or unlock */
33388 rc = UnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
33390 rc = LockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
33780 int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
33795 if( sz<nByte ){
33803 rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
33825 NULL, PAGE_READWRITE, 0, nByte, NULL
33828 (int)GetCurrentProcessId(), pShmNode->nRegion, nByte,
34380 int nByte;
34401 nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
34402 zTemp = malloc( nByte*sizeof(zTemp[0]) );
34407 GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
34418 nByte = GetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
34419 zTemp = malloc( nByte*sizeof(zTemp[0]) );
34424 GetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
35397 int nByte;
35398 nByte = pCache->szPage + pCache->szExtra + sizeof(PgHdr);
35399 p = sqlite3GlobalConfig.pcache.xCreate(nByte, pCache->bPurgeable);
35872 int nByte; /* Size of each allocation in bytes */
36051 static void *pcache1Alloc(int nByte){
36054 sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
36055 if( nByte<=pcache1.szSlot ){
36071 p = sqlite3Malloc(nByte);
36165 int nByte = sizeof(PgHdr1) + pCache->szPage;
36175 nByte += sizeof(PGroupBlockList *);
36176 nByte = ROUND8(nByte);
36179 if( pList->nByte==nByte ) break;
36194 assert( pList->nByte!=nByte );
36197 pNew->nByte = nByte;
36213 sz = sizeof(PGroupBlock) + PAGECACHE_BLOCKALLOC_MINENTRY * nByte;
36221 pBlock->nEntry = (sqlite3MallocSize(pBlock) - sizeof(PGroupBlock)) / nByte;
36239 pPg = (void *)&pBlock->aData[pList->nByte * i];
36267 pPg = pcache1Alloc(nByte);
36296 int i = ((u8 *)pPg - pBlock->aData) / pList->nByte;
36298 assert( pPg==(void *)&pBlock->aData[i*pList->nByte] );
38680 static u32 pager_datahash(int nByte, unsigned char *pData){
38683 for(i=0; i<nByte; i++){
41024 i64 nByte = 0;
41027 rc = sqlite3OsFileSize(pPager->fd, &nByte);
41036 pPager->dbSize = (Pgno)(nByte/pageSize);
44886 int nByte = sizeof(u32*)*(iPage+1);
44888 apNew = (volatile u32 **)sqlite3_realloc((void *)pWal->apWiData, nByte);
44960 int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */
44966 u32 *aEnd = (u32 *)&a[nByte];
44975 assert( nByte>=8 );
44976 assert( (nByte&0x00000007)==0 );
45277 int nByte; /* Number of bytes to zero in aPgno[] */
45309 nByte = (int)((char *)aHash - (char *)&aPgno[iLimit+1]);
45310 memset((void *)&aPgno[iLimit+1], 0, nByte);
45357 int nByte = (int)((u8 *)&aHash[HASHTABLE_NSLOT] - (u8 *)&aPgno[1]);
45358 memset((void*)&aPgno[1], 0, nByte);
45879 int nByte; /* Number of bytes to allocate */
45892 nByte = sizeof(WalIterator)
45895 p = (WalIterator *)sqlite3ScratchMalloc(nByte);
45899 memset(p, 0, nByte);
49415 static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
49427 assert( nByte>=0 ); /* Minimum cell size is 4 */
49428 assert( pPage->nFree>=nByte );
49431 assert( nByte < usableSize-8 );
49459 if( size>=nByte ){
49460 int x = size - nByte;
49484 testcase( gap+2+nByte==top );
49485 if( gap+2+nByte>top ){
49489 assert( gap+nByte<=top );
49499 top -= nByte;
49501 assert( top+nByte <= (int)pPage->pBt->usableSize );
52047 int nByte, /* Number of bytes to copy */
52057 memcpy(pPayload, pBuf, nByte);
52060 memcpy(pBuf, pPayload, nByte);
57301 int nByte;
57307 nByte = pMem->n + pMem->u.nZero;
57308 if( nByte<=0 ){
57309 nByte = 1;
57311 if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
57357 const int nByte = 32;
57367 if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
57378 sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
57381 sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
57840 int nByte = n; /* New value for pMem->n */
57859 if( nByte<0 ){
57862 for(nByte=0; nByte<=iLimit && z[nByte]; nByte++){}
57864 for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
57874 int nAlloc = nByte;
57878 if( nByte>iLimit ){
57896 pMem->n = nByte;
57907 if( nByte>iLimit ){
58634 int nByte = (p->nSub+1)*sizeof(SubProgram*);
58640 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
59045 int nField, nByte;
59048 nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField;
59049 pKeyInfo = sqlite3DbMallocRaw(0, nByte);
59053 memcpy((char*)pKeyInfo, zP4, nByte - nField);
59542 int nByte = (nSub+1)*sizeof(SubProgram*);
59547 if( j==nSub && SQLITE_OK==sqlite3VdbeMemGrow(pSub, nByte, 1) ){
59692 int nByte, /* Number of bytes to allocate */
59699 nByte = ROUND8(nByte);
59700 if( &(*ppFrom)[nByte] <= pEnd ){
59702 *ppFrom += nByte;
59704 *pnByte += nByte;
59779 int nByte; /* How much extra memory is needed */
59830 nByte = 0;
59831 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
59832 p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
59833 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
59834 p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), &zCsr, zEnd, &nByte);
59836 &zCsr, zEnd, &nByte);
59837 if( nByte ){
59838 p->pFree = sqlite3DbMallocZero(db, nByte);
59841 zEnd = &zCsr[nByte];
59842 }while( nByte && !db->mallocFailed );
61157 int nByte; /* Number of bytes required for *p */
61164 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
61165 if( nByte>szSpace+nOff ){
61166 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
62112 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
62117 testcase( nByte<0 );
62119 if( nByte<=0 ){
62124 sqlite3VdbeMemGrow(pMem, nByte, 0);
62128 memset(pMem->z, 0, nByte);
63228 int nByte;
63230 nByte =
63240 if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){
63700 i64 nByte;
63779 i64 nByte; /* Data space required for this record */
63998 int nByte; /* Bytes of runtime space required for sub-program */
64698 i64 nByte;
64712 u.ae.nByte = pIn1->n + pIn2->n;
64713 if( u.ae.nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
64717 if( sqlite3VdbeMemGrow(pOut, (int)u.ae.nByte+2, pOut==pIn2) ){
64724 pOut->z[u.ae.nByte] = 0;
64725 pOut->z[u.ae.nByte+1] = 0;
64727 pOut->n = (int)u.ae.nByte;
65997 i64 nByte; /* Data space required for this record */
66070 u.ao.nByte = u.ao.nHdr+u.ao.nData-u.ao.nZero;
66071 if( u.ao.nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
66080 if( sqlite3VdbeMemGrow(pOut, (int)u.ao.nByte, 0) ){
66092 …u.ao.i += sqlite3VdbeSerialPut(&u.ao.zNewRecord[u.ao.i], (int)(u.ao.nByte-u.ao.i), u.ao.pRec,u.ao.…
66094 assert( u.ao.i==u.ao.nByte );
66097 pOut->n = (int)u.ao.nByte;
68686 int nByte; /* Bytes of runtime space required for sub-program */
68734 u.cb.nByte = ROUND8(sizeof(VdbeFrame))
68737 u.cb.pFrame = sqlite3DbMallocZero(db, u.cb.nByte);
69834 int nByte; /* Size of open blob, in bytes */
69884 p->nByte = sqlite3VdbeSerialTypeLen(type);
70181 if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
70233 return (p && p->pStmt) ? p->nByte : 0;
70555 i64 nByte; /* Total size of PMA in bytes */
70556 rc = vdbeSorterReadVarint(pSorter->pTemp1, &pIter->iReadOff, &nByte);
70557 *pnByte += nByte;
70558 pIter->iEof = pIter->iReadOff + nByte;
70940 i64 nByte = 0; /* Total bytes in all opened PMAs */
70945 rc = vdbeSorterIterInit(db, pSorter, pSorter->iReadOff, pIter, &nByte);
70956 *pnByte = nByte;
70970 int nByte; /* Bytes of space required for aIter/aTree */
70993 nByte = N * (sizeof(int) + sizeof(VdbeSorterIter));
70994 pSorter->aIter = (VdbeSorterIter *)sqlite3DbMallocZero(db, nByte);
73727 int nByte = dupedExprStructSize(p, flags) & 0xfff;
73729 nByte += sqlite3Strlen30(p->u.zToken)+1;
73731 return ROUND8(nByte);
73748 int nByte = 0;
73750 nByte = dupedExprNodeSize(p, flags);
73752 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
73755 return nByte;
73909 int nByte;
73911 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
73912 pNew = sqlite3DbMallocRaw(db, nByte );
78297 pSample->nByte = (u8)n;
81329 int nByte;
81354 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
81357 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
81360 pFKey = sqlite3DbMallocZero(db, nByte );
84353 static void *contextMalloc(sqlite3_context *context, i64 nByte){
84356 assert( nByte>0 );
84357 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
84358 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
84359 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
84363 z = sqlite3Malloc((int)nByte);
89883 int nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
89885 aNew = sqlite3_realloc(wsdAutoext.aExt, nByte);
102329 int nByte; /* Byte of memory needed for pIdx */
102394 nByte = sizeof(Index);
102395 nByte += nColumn*sizeof(int); /* Index.aiColumn */
102396 nByte += nColumn*sizeof(char*); /* Index.azColl */
102397 nByte += nColumn; /* Index.aSortOrder */
102398 pIdx = sqlite3DbMallocZero(pParse->db, nByte);
102864 db, pColl->enc, aSample[i].u.z, aSample[i].nByte, &nSample
102875 c = pColl->xCmp(pColl->pUser, aSample[i].nByte, aSample[i].u.z, n, z);
111995 int nByte = nUri+2; /* Bytes of space to allocate */
112001 for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
112002 zFile = sqlite3_malloc(nByte);
115150 int nByte; /* Size of allocation used for *p */
115307 nByte = sizeof(Fts3Table) + /* Fts3Table */
115313 p = (Fts3Table*)sqlite3_malloc(nByte);
115318 memset(p, 0, nByte);
115357 assert( zCsr <= &((char *)p)[nByte] );
116537 int nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
116538 apNew = (Fts3SegReader **)sqlite3_realloc(pCsr->apSegment, nByte);
118063 sqlite3_int64 nByte = 0;
118075 a += sqlite3Fts3GetVarint(a, &nByte);
118077 if( nDoc==0 || nByte==0 ){
118083 pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
119129 int nByte; /* Bytes of space to allocate here */
119151 nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
119152 p = (Fts3auxTable *)sqlite3_malloc(nByte);
119154 memset(p, 0, nByte);
119661 static void *fts3MallocZero(int nByte){
119662 void *pRet = sqlite3_malloc(nByte);
119663 if( pRet ) memset(pRet, 0, nByte);
119698 int nByte; /* total space to allocate */
119704 nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
119705 pRet = (Fts3Expr *)fts3MallocZero(nByte);
119802 int nByte, iBegin, iEnd, iPos;
119803 rc = pModule->xNext(pCursor, &zByte, &nByte, &iBegin, &iEnd, &iPos);
119810 zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte);
119817 memcpy(&zTemp[nTemp], zByte, nByte);
119818 nTemp += nByte;
119820 pToken->n = nByte;
120120 int nByte = 0;
120121 rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
120203 assert( nByte>0 );
120205 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
120206 nIn -= nByte;
120207 zIn += nByte;
123258 int nByte = sqlite3_blob_bytes(p->pSegments);
123259 *pnBlob = nByte;
123261 char *aByte = sqlite3_malloc(nByte + FTS3_NODE_PADDING);
123265 if( pnLoad && nByte>(FTS3_NODE_CHUNK_THRESHOLD) ){
123266 nByte = FTS3_NODE_CHUNKSIZE;
123267 *pnLoad = nByte;
123269 rc = sqlite3_blob_read(p->pSegments, aByte, nByte, 0);
123270 memset(&aByte[nByte], 0, FTS3_NODE_PADDING);
123316 static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){
123322 && (pFrom - pReader->aNode + nByte)>pReader->nPopulate
123762 int nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *);
123763 pReader = (Fts3SegReader *)sqlite3_malloc(nByte);
123767 memset(pReader, 0, nByte);
124829 int nByte;
124858 nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0);
124859 if( nDoclist+nByte>pCsr->nBuffer ){
124861 pCsr->nBuffer = (nDoclist+nByte)*2;
125938 int nByte; /* Number of bytes of space to allocate */
125955 nByte = sizeof(SnippetPhrase) * nList;
125956 sIter.aPhrase = (SnippetPhrase *)sqlite3_malloc(nByte);
125960 memset(sIter.aPhrase, 0, nByte);
127602 int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell;
127603 memmove(pDst, pSrc, nByte);
129035 int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
129037 aaSorted = (int **)sqlite3_malloc(nByte);
129043 memset(aaSorted, 0, nByte);
130998 int nByte = 0;
131023 if( nByte ){
131024 char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
131029 pCsr->nBuffer = nByte;
131033 pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */
131037 } while( nByte>pCsr->nBuffer );
131040 *pnBytes = nByte;