Lines Matching defs:nByte
1588 void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
1591 int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
2112 #define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */
3442 ** ^If the nByte argument is less than zero, then zSql is read up to the
3443 ** first zero terminator. ^If nByte is non-negative, then it is the maximum
3444 ** number of bytes read from zSql. ^When nByte is non-negative, the
3446 ** the nByte-th byte, whichever comes first. If the caller knows
3448 ** performance advantage to be gained by passing an nByte parameter that
3510 int nByte, /* Maximum length of zSql in bytes. */
3517 int nByte, /* Maximum length of zSql in bytes. */
3524 int nByte, /* Maximum length of zSql in bytes. */
3531 int nByte, /* Maximum length of zSql in bytes. */
10405 int nByte; /* Size in byte of text or blob. */
11822 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
13451 int nByte = 0; /* Used to accumulate return value */
13454 db->pnBytesFreed = &nByte;
13460 nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (
13466 nByte += sqlite3MallocSize(pSchema->tblHash.ht);
13467 nByte += sqlite3MallocSize(pSchema->trigHash.ht);
13468 nByte += sqlite3MallocSize(pSchema->idxHash.ht);
13469 nByte += sqlite3MallocSize(pSchema->fkeyHash.ht);
13483 *pCurrent = nByte;
13494 int nByte = 0; /* Used to accumulate return value */
13496 db->pnBytesFreed = &nByte;
13503 *pCurrent = nByte;
14861 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
14862 pVfs->xDlError(pVfs, nByte, zBufOut);
14871 SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
14872 return pVfs->xRandomness(pVfs, nByte, zBufOut);
15146 static void *sqlite3MemMalloc(int nByte){ return 0; }
15148 static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; }
15282 ** For this low-level routine, we are guaranteed that nByte>0 because
15283 ** cases of nByte<=0 will be intercepted and dealt with by higher level
15286 static void *sqlite3MemMalloc(int nByte){
15288 void *p = SQLITE_MALLOC( nByte );
15291 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
15296 assert( nByte>0 );
15297 nByte = ROUND8(nByte);
15298 p = SQLITE_MALLOC( nByte+8 );
15300 p[0] = nByte;
15304 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
15351 ** redirected to xMalloc. Similarly, we know that nByte>0 becauses
15352 ** cases where nByte<=0 will have been intercepted by higher-level
15355 static void *sqlite3MemRealloc(void *pPrior, int nByte){
15357 void *p = SQLITE_REALLOC(pPrior, nByte);
15362 SQLITE_MALLOCSIZE(pPrior), nByte);
15367 assert( pPrior!=0 && nByte>0 );
15368 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
15370 p = SQLITE_REALLOC(p, nByte+8 );
15372 p[0] = nByte;
15378 sqlite3MemSize(pPrior), nByte);
15676 static void randomFill(char *pBuf, int nByte){
15679 y = nByte | 1;
15680 while( nByte >= 4 ){
15686 nByte -= 4;
15688 while( nByte-- > 0 ){
15697 ** Allocate nByte bytes of memory.
15699 static void *sqlite3MemMalloc(int nByte){
15709 nReserve = ROUND8(nByte);
15735 mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
15743 pHdr->iSize = nByte;
15744 adjustStats(nByte, +1);
15747 randomFill((char*)pInt, nByte);
15748 memset(((char*)pInt)+nByte, 0x65, nReserve-nByte);
15800 static void *sqlite3MemRealloc(void *pPrior, int nByte){
15804 assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */
15806 pNew = sqlite3MemMalloc(nByte);
15808 memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
15809 if( nByte>pOldHdr->iSize ){
15810 randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - pOldHdr->iSize);
16222 static void memsys3OutOfMemory(int nByte){
16227 sqlite3_release_memory(nByte);
16341 static void *memsys3MallocUnsafe(int nByte){
16348 if( nByte<=12 ){
16351 nBlock = (nByte + 11)/8;
16911 ** The caller guarantees that nByte positive.
16917 static void *memsys5MallocUnsafe(int nByte){
16923 /* nByte must be a positive */
16924 assert( nByte>0 );
16928 if( (u32)nByte>mem5.maxRequest ){
16929 mem5.maxRequest = nByte;
16935 if( nByte > 0x40000000 ){
16939 /* Round nByte up to the next valid power of two */
16940 for(iFullSz=mem5.szAtom, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){}
16949 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte);
16966 mem5.totalExcess += iFullSz - nByte;
17133 int nByte; /* Number of bytes of memory available to this allocator */
17148 nByte = sqlite3GlobalConfig.nHeap;
17159 mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8)));
18827 static void sqlite3MallocAlarm(int nByte){
18837 xCallback(pArg, nowUsed, nByte);
20863 ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
20865 ** the first 0x00 byte. If nByte is not less than zero, return the
20866 ** number of unicode characters in the first nByte of pZ (or up to
20869 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){
20873 if( nByte>=0 ){
20874 zTerm = &z[nByte];
20923 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
20927 sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
23066 static int os2Truncate( sqlite3_file *id, i64 nByte ){
23070 OSTRACE(( "TRUNCATE %d %lld\n", pFile->h, nByte ));
23079 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
23082 rc = DosSetFileSize( pFile->h, nByte );
23715 int nByte /* Number of bytes to lock or unlock */
23727 area.lRange = nByte;
28446 static int unixTruncate(sqlite3_file *id, i64 nByte){
28458 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
28461 rc = robust_ftruncate(pFile->h, (off_t)nByte);
28474 if( pFile->inNormalWrite && nByte==0 ){
28524 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
28533 nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
29078 int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
29093 if( sStat.st_size<nByte ){
29102 if( osFallocate(pShmNode->h, sStat.st_size, nByte)!=0 ){
29108 if( robust_ftruncate(pShmNode->h, nByte) ){
33080 int nByte;
33083 nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
33084 if( nByte == 0 ){
33087 zFilename = sqlite3_malloc( nByte );
33091 nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
33093 if( nByte == 0 ){
33108 int nByte;
33112 nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, NULL,
33114 if( nByte==0 ){
33117 zMbcsFilename = sqlite3_malloc( nByte*sizeof(zMbcsFilename[0]) );
33121 nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename,
33122 nByte);
33123 if( nByte==0 ){
33138 int nByte;
33142 nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
33143 if( nByte == 0 ){
33146 zFilename = sqlite3_malloc( nByte );
33150 nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename,
33151 nByte, 0, 0);
33152 if( nByte == 0 ){
33864 static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
33870 OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
33879 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
33883 if( seekWinFile(pFile, nByte) ){
33892 OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
34496 int nByte /* Number of bytes to lock or unlock */
34514 rc = osUnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
34516 rc = osLockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
34908 int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
34924 if( sz<nByte ){
34932 rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
34955 NULL, PAGE_READWRITE, 0, nByte, NULL
34957 OSTRACE(("SHM-MAP pid-%d create region=%d nbyte=%d %s\n",
34958 (int)osGetCurrentProcessId(), pShmNode->nRegion, nByte,
35525 int nByte;
35549 nByte = osGetFullPathNameW((LPCWSTR)zConverted, 0, 0, 0) + 3;
35550 zTemp = sqlite3_malloc( nByte*sizeof(zTemp[0]) );
35555 osGetFullPathNameW((LPCWSTR)zConverted, nByte, zTemp, 0);
35566 nByte = osGetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
35567 zTemp = sqlite3_malloc( nByte*sizeof(zTemp[0]) );
35572 osGetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
37065 static void *pcache1Alloc(int nByte){
37068 sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
37069 if( nByte<=pcache1.szSlot ){
37085 p = sqlite3Malloc(nByte);
39598 static u32 pager_datahash(int nByte, unsigned char *pData){
39601 for(i=0; i<nByte; i++){
41962 i64 nByte = 0;
41965 rc = sqlite3OsFileSize(pPager->fd, &nByte);
41974 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
45883 int nByte = sizeof(u32*)*(iPage+1);
45885 apNew = (volatile u32 **)sqlite3_realloc((void *)pWal->apWiData, nByte);
45952 ** nByte must be a positive multiple of 8.
45957 int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */
45963 u32 *aEnd = (u32 *)&a[nByte];
45972 assert( nByte>=8 );
45973 assert( (nByte&0x00000007)==0 );
46274 int nByte; /* Number of bytes to zero in aPgno[] */
46306 nByte = (int)((char *)aHash - (char *)&aPgno[iLimit+1]);
46307 memset((void *)&aPgno[iLimit+1], 0, nByte);
46354 int nByte = (int)((u8 *)&aHash[HASHTABLE_NSLOT] - (u8 *)&aPgno[1]);
46355 memset((void*)&aPgno[1], 0, nByte);
46884 int nByte; /* Number of bytes to allocate */
46897 nByte = sizeof(WalIterator)
46900 p = (WalIterator *)sqlite3ScratchMalloc(nByte);
46904 memset(p, 0, nByte);
50532 ** Allocate nByte bytes of space from within the B-Tree page passed
50544 static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
50556 assert( nByte>=0 ); /* Minimum cell size is 4 */
50557 assert( pPage->nFree>=nByte );
50560 assert( nByte < usableSize-8 );
50588 if( size>=nByte ){
50589 int x = size - nByte;
50613 testcase( gap+2+nByte==top );
50614 if( gap+2+nByte>top ){
50618 assert( gap+nByte<=top );
50628 top -= nByte;
50630 assert( top+nByte <= (int)pPage->pBt->usableSize );
53180 ** If argument eOp is false, then nByte bytes of data are copied
53182 ** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
53190 int nByte, /* Number of bytes to copy */
53200 memcpy(pPayload, pBuf, nByte);
53203 memcpy(pBuf, pPayload, nByte);
58342 i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom);
58343 rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte);
58527 int nByte;
58532 /* Set nByte to the number of bytes required to store the expanded blob. */
58533 nByte = pMem->n + pMem->u.nZero;
58534 if( nByte<=0 ){
58535 nByte = 1;
58537 if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
58583 const int nByte = 32;
58593 if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
58604 sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
58607 sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
59073 int nByte = n; /* New value for pMem->n */
59092 if( nByte<0 ){
59095 for(nByte=0; nByte<=iLimit && z[nByte]; nByte++){}
59097 for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
59107 int nAlloc = nByte;
59111 if( nByte>iLimit ){
59129 pMem->n = nByte;
59140 if( nByte>iLimit ){
59865 int nByte = (p->nSub+1)*sizeof(SubProgram*);
59871 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
60276 int nField, nByte;
60279 nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField;
60280 pKeyInfo = sqlite3DbMallocRaw(0, nByte);
60284 memcpy((char*)pKeyInfo, zP4, nByte - nField);
60775 int nByte = (nSub+1)*sizeof(SubProgram*);
60780 if( j==nSub && SQLITE_OK==sqlite3VdbeMemGrow(pSub, nByte, 1) ){
60914 ** nByte is the number of bytes of space needed.
60926 int nByte, /* Number of bytes to allocate */
60933 nByte = ROUND8(nByte);
60934 if( &(*ppFrom)[nByte] <= pEnd ){
60936 *ppFrom += nByte;
60938 *pnByte += nByte;
61014 int nByte; /* How much extra memory is needed */
61067 nByte = 0;
61068 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
61069 p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
61070 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
61071 p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), &zCsr, zEnd, &nByte);
61073 &zCsr, zEnd, &nByte);
61074 p->aOnceFlag = allocSpace(p->aOnceFlag, nOnce, &zCsr, zEnd, &nByte);
61075 if( nByte ){
61076 p->pFree = sqlite3DbMallocZero(db, nByte);
61079 zEnd = &zCsr[nByte];
61080 }while( nByte && !db->mallocFailed );
62400 int nByte; /* Number of bytes required for *p */
62407 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
62408 if( nByte>szSpace+nOff ){
62409 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
63343 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
63348 testcase( nByte<0 );
63350 if( nByte<=0 ){
63355 sqlite3VdbeMemGrow(pMem, nByte, 0);
63359 memset(pMem->z, 0, nByte);
64578 int nByte;
64580 nByte =
64590 if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){
65053 i64 nByte;
65132 i64 nByte; /* Data space required for this record */
65351 int nByte; /* Bytes of runtime space required for sub-program */
66067 i64 nByte;
66081 u.af.nByte = pIn1->n + pIn2->n;
66082 if( u.af.nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
66086 if( sqlite3VdbeMemGrow(pOut, (int)u.af.nByte+2, pOut==pIn2) ){
66093 pOut->z[u.af.nByte] = 0;
66094 pOut->z[u.af.nByte+1] = 0;
66096 pOut->n = (int)u.af.nByte;
67373 i64 nByte; /* Data space required for this record */
67446 u.ap.nByte = u.ap.nHdr+u.ap.nData-u.ap.nZero;
67447 if( u.ap.nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
67456 if( sqlite3VdbeMemGrow(pOut, (int)u.ap.nByte, 0) ){
67468 u.ap.i += sqlite3VdbeSerialPut(&u.ap.zNewRecord[u.ap.i], (int)(u.ap.nByte-u.ap.i), u.ap.pRec,u.ap.file_format);
67470 assert( u.ap.i==u.ap.nByte );
67473 pOut->n = (int)u.ap.nByte;
70064 int nByte; /* Bytes of runtime space required for sub-program */
70111 u.cc.nByte = ROUND8(sizeof(VdbeFrame))
70115 u.cc.pFrame = sqlite3DbMallocZero(db, u.cc.nByte);
71228 int nByte; /* Size of open blob, in bytes */
71278 p->nByte = sqlite3VdbeSerialTypeLen(type);
71575 if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
71622 ** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
71627 return (p && p->pStmt) ? p->nByte : 0;
71949 i64 nByte; /* Total size of PMA in bytes */
71950 rc = vdbeSorterReadVarint(pSorter->pTemp1, &pIter->iReadOff, &nByte);
71951 *pnByte += nByte;
71952 pIter->iEof = pIter->iReadOff + nByte;
72334 i64 nByte = 0; /* Total bytes in all opened PMAs */
72339 rc = vdbeSorterIterInit(db, pSorter, pSorter->iReadOff, pIter, &nByte);
72350 *pnByte = nByte;
72364 int nByte; /* Bytes of space required for aIter/aTree */
72387 nByte = N * (sizeof(int) + sizeof(VdbeSorterIter));
72388 pSorter->aIter = (VdbeSorterIter *)sqlite3DbMallocZero(db, nByte);
75135 int nByte = dupedExprStructSize(p, flags) & 0xfff;
75137 nByte += sqlite3Strlen30(p->u.zToken)+1;
75139 return ROUND8(nByte);
75156 int nByte = 0;
75158 nByte = dupedExprNodeSize(p, flags);
75160 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
75163 return nByte;
75318 int nByte;
75320 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
75321 pNew = sqlite3DbMallocRaw(db, nByte );
80326 pSample->nByte = n;
83439 int nByte;
83464 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
83467 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
83470 pFKey = sqlite3DbMallocZero(db, nByte );
86463 ** Allocate nByte bytes of space using sqlite3_malloc(). If the
86466 ** If nByte is larger than the maximum string or blob length, then
86469 static void *contextMalloc(sqlite3_context *context, i64 nByte){
86472 assert( nByte>0 );
86473 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
86474 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
86475 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
86479 z = sqlite3Malloc((int)nByte);
92022 int nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
92024 aNew = sqlite3_realloc(wsdAutoext.aExt, nByte);
104573 int nByte; /* Byte of memory needed for pIdx */
104636 nByte = sizeof(Index);
104637 nByte += nColumn*sizeof(int); /* Index.aiColumn */
104638 nByte += nColumn*sizeof(char*); /* Index.azColl */
104639 nByte += nColumn; /* Index.aSortOrder */
104640 pIdx = sqlite3DbMallocZero(pParse->db, nByte);
105124 db, pColl->enc, aSample[i].u.z, aSample[i].nByte, &nSample
105135 c = pColl->xCmp(pColl->pUser, aSample[i].nByte, aSample[i].u.z, n, z);
114366 int nByte = nUri+2; /* Bytes of space to allocate */
114372 for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
114373 zFile = sqlite3_malloc(nByte);
117723 int nByte; /* Size of allocation used for *p */
117929 nByte = sizeof(Fts3Table) + /* Fts3Table */
117935 p = (Fts3Table*)sqlite3_malloc(nByte);
117940 memset(p, 0, nByte);
117983 assert( zCsr <= &((char *)p)[nByte] );
119250 int nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
119251 apNew = (Fts3SegReader **)sqlite3_realloc(pCsr->apSegment, nByte);
120832 sqlite3_int64 nByte = 0;
120844 a += sqlite3Fts3GetVarint(a, &nByte);
120846 if( nDoc==0 || nByte==0 ){
120852 pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
121923 int nByte; /* Bytes of space to allocate here */
121945 nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
121946 p = (Fts3auxTable *)sqlite3_malloc(nByte);
121948 memset(p, 0, nByte);
122453 ** Allocate nByte bytes of memory using sqlite3_malloc(). If successful,
122457 static void *fts3MallocZero(int nByte){
122458 void *pRet = sqlite3_malloc(nByte);
122459 if( pRet ) memset(pRet, 0, nByte);
122521 int nByte; /* total space to allocate */
122525 nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
122526 pRet = (Fts3Expr *)fts3MallocZero(nByte);
122635 int nByte, iBegin, iEnd, iPos;
122636 rc = pModule->xNext(pCursor, &zByte, &nByte, &iBegin, &iEnd, &iPos);
122643 zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte);
122650 memcpy(&zTemp[nTemp], zByte, nByte);
122651 nTemp += nByte;
122653 pToken->n = nByte;
122958 int nByte = 0;
122959 rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
123041 assert( nByte>0 );
123043 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
123044 nIn -= nByte;
123045 zIn += nByte;
126206 int nByte = sqlite3_blob_bytes(p->pSegments);
126207 *pnBlob = nByte;
126209 char *aByte = sqlite3_malloc(nByte + FTS3_NODE_PADDING);
126213 if( pnLoad && nByte>(FTS3_NODE_CHUNK_THRESHOLD) ){
126214 nByte = FTS3_NODE_CHUNKSIZE;
126215 *pnLoad = nByte;
126217 rc = sqlite3_blob_read(p->pSegments, aByte, nByte, 0);
126218 memset(&aByte[nByte], 0, FTS3_NODE_PADDING);
126264 static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){
126270 && (pFrom - pReader->aNode + nByte)>pReader->nPopulate
126718 int nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *);
126719 pReader = (Fts3SegReader *)sqlite3_malloc(nByte);
126723 memset(pReader, 0, nByte);
127815 int nByte;
127844 nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0);
127845 if( nDoclist+nByte>pCsr->nBuffer ){
127847 pCsr->nBuffer = (nDoclist+nByte)*2;
128226 int nByte = sizeof(u32) * (p->nColumn+1)*3;
128227 aSz = (u32 *)sqlite3_malloc(nByte);
128231 memset(aSz, 0, nByte);
129066 int nByte; /* Number of bytes of space to allocate */
129083 nByte = sizeof(SnippetPhrase) * nList;
129084 sIter.aPhrase = (SnippetPhrase *)sqlite3_malloc(nByte);
129088 memset(sIter.aPhrase, 0, nByte);
130732 int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell;
130733 memmove(pDst, pSrc, nByte);
132170 int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
132172 aaSorted = (int **)sqlite3_malloc(nByte);
132178 memset(aaSorted, 0, nByte);
134133 int nByte = 0;
134158 if( nByte ){
134159 char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
134164 pCsr->nBuffer = nByte;
134168 pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */
134172 } while( nByte>pCsr->nBuffer );
134175 *pnBytes = nByte;
