Lines Matching refs:nNew
31253 int nOld, nNew, nDiff; in sqlite3Realloc() local
31272 nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes); in sqlite3Realloc()
31273 if( nOld==nNew ){ in sqlite3Realloc()
31279 nDiff = nNew - nOld; in sqlite3Realloc()
31289 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); in sqlite3Realloc()
31293 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); in sqlite3Realloc()
31297 nNew = sqlite3MallocSize(pNew); in sqlite3Realloc()
31298 sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld); in sqlite3Realloc()
31302 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); in sqlite3Realloc()
44149 i64 nNew /* Required mapping size */ in unixRemapfile() argument
44159 assert( nNew>pFd->mmapSize ); in unixRemapfile()
44160 assert( nNew<=pFd->mmapSizeMax ); in unixRemapfile()
44161 assert( nNew>0 ); in unixRemapfile()
44184 pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE); in unixRemapfile()
44187 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse); in unixRemapfile()
44190 osMunmap(pNew, nNew - nReuse); in unixRemapfile()
44206 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0); in unixRemapfile()
44211 nNew = 0; in unixRemapfile()
44220 pFd->mmapSize = pFd->mmapSizeActual = nNew; in unixRemapfile()
56644 u64 nNew; local
56649 nNew = 2*(u64)p->nHash;
56650 if( nNew<256 ){
56651 nNew = 256;
56656 apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew);
56664 unsigned int h = pPage->iKey % nNew;
56672 p->nHash = nNew;
64705 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager)); local
64707 rc = pager_truncate(pPager, nNew);
65059 int nNew; /* Number of remaining savepoints after this op. */ local
65065 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
65066 for(ii=nNew; ii<pPager->nSavepoint; ii++){
65069 pPager->nSavepoint = nNew;
65074 PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
65091 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
79362 int nNew, /* Final number of cells on page */
79367 u8 *pBegin = &pPg->aCellIdx[nNew * 2];
79373 int iNewEnd = iNew + nNew;
79400 int nAdd = MIN(nNew,iOld-iNew);
79401 assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
79415 if( iCell>=0 && iCell<nNew ){
79434 iNew+nCell, nNew-nCell, pCArray
79440 assert( nNew < 10922 );
79441 pPg->nCell = (u16)nNew;
79448 for(i=0; i<nNew && !CORRUPT_DB; i++){
79462 if( nNew<1 ) return SQLITE_CORRUPT_BKPT;
79463 populateCellCache(pCArray, iNew, nNew);
79464 return rebuildPage(pCArray, iNew, nNew, pPg);
79739 int nNew = 0; /* Number of pages in apNew[] */ local
80157 nNew++;
80170 nNew++;
80195 for(i=0; i<nNew; i++){
80200 for(i=0; i<nNew-1; i++){
80202 for(j=i+1; j<nNew; j++){
80228 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
80229 nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0,
80230 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
80231 nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0,
80232 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
80233 nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0,
80234 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
80235 nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0
80239 assert( nNew>=1 && nNew<=ArraySize(apNew) );
80240 assert( apNew[nNew-1]!=0 );
80241 put4byte(pRight, apNew[nNew-1]->pgno);
80246 if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){
80247 MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1];
80248 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
80278 assert( iOld<nNew || iOld<nOld );
80280 pOld = iOld<nNew ? apNew[iOld] : apOld[iOld];
80294 if( iOld>=nNew
80310 for(i=0; i<nNew-1; i++){
80392 for(i=1-nNew; i<nNew; i++){
80394 assert( iPg>=0 && iPg<nNew );
80432 assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 );
80435 assert( nNew>0 );
80453 assert( nNew==1 || CORRUPT_DB );
80467 for(i=0; i<nNew; i++){
80475 nOld, nNew, b.nCell));
80479 for(i=nNew; i<nOld; i++){
80489 ptrmapCheckPages(apNew, nNew);
80502 for(i=0; i<nNew; i++){
86070 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc local
86073 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc local
86079 if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
86085 assert( nNew>=(v->nOpAlloc+nOp) );
86086 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
104641 sqlite3_int64 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc);
104642 while( nByte>nNew ) nNew = nNew*2;
104643 aNew = sqlite3Realloc(p->aAlloc, nNew);
104645 p->nAlloc = nNew;
105945 sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory;
105950 while( nNew < nMin ) nNew = nNew*2;
105951 if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
105952 if( nNew < nMin ) nNew = nMin;
105953 aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
105959 pSorter->nMemory = nNew;
118944 i64 nNew = sqlite3Strlen30(zNew);
118967 assert( nQuot>=nNew && nSql>=0 && nNew>=0 );
118994 nReplace = nNew;
166357 static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){
166358 LogEst nRet = nNew;
166542 LogEst nNew;
166643 nNew = sqlite3LogEst(iUpper - iLower);
166648 if( iLwrIdx==iUprIdx ){ nNew -= 20; }
166651 nNew = 10; assert( 10==sqlite3LogEst(2) );
166653 if( nNew<nOut ){
166654 nOut = nNew;
166671 nNew = whereRangeAdjust(pLower, nOut);
166672 nNew = whereRangeAdjust(pUpper, nNew);
166681 nNew -= 20;
166685 if( nNew<10 ) nNew = 10;
166686 if( nNew<nOut ) nOut = nNew;
191869 int nNew;
191873 pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew
191884 nOut = nNew;
191952 int nNew;
191955 pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew
191967 nMerge = nNew;
194314 int nNew;
194326 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
194327 assert_fts3_nc( nNew<=pPhrase->doclist.nList && nNew>0 );
194328 if( nNew>=0 && nNew<=pPhrase->doclist.nList ){
194329 assert( pPhrase->doclist.pList[nNew]=='\0' );
194330 memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
194331 pPhrase->doclist.nList = nNew;
196089 static void *fts3ReallocOrFree(void *pOrig, sqlite3_int64 nNew){
196090 void *pRet = sqlite3_realloc64(pOrig, nNew);
198378 sqlite3_int64 nNew = sizeof(char *)*(iArg+1);
198379 char const **aNew = (const char **)sqlite3_realloc64((void *)aArg, nNew);
200058 i64 nNew = p->nSpace * 2;
200059 p = sqlite3_realloc64(p, sizeof(*p) + nNew);
200065 p->nSpace = (int)nNew;
200802 i64 nNew = ((i64)nPrefix+nSuffix)*2;
200803 char *zNew = sqlite3_realloc64(pReader->zTerm, nNew);
200808 pReader->nTermAlloc = nNew;
202069 int nNew = nList*2 + FTS3_NODE_PADDING;
202070 pNew = (char *)sqlite3_realloc64(pMsr->aBuffer, nNew);
202073 pMsr->nBuffer = nNew;
207175 int nNew; /* Number of valid entries in array aNew[] */
207179 nNew = p->nException;
207188 for(i=0; i<nNew && aNew[i]<(int)iCode; i++);
207189 for(j=nNew; j>i; j--) aNew[j] = aNew[j-1];
207191 nNew++;
207195 p->nException = nNew;
212922 u64 nNew;
212923 nNew = p->nParentAlloc*2 + 3;
212924 pNew = sqlite3DbRealloc(p->db, p->aParent, sizeof(JsonParent)*nNew);
212926 p->nParentAlloc = (u32)nNew;
214904 int nNew = pCur->nPointAlloc*2 + 8;
214905 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
214908 pCur->nPointAlloc = nNew;
224357 int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
224359 aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame));
224362 pRbu->nFrameAlloc = nNew;
225777 static int rbuUpdateTempSize(rbu_file *pFd, sqlite3_int64 nNew){
225779 i64 nDiff = nNew - pFd->sz;
225781 pFd->sz = nNew;
228923 int nNew;
228927 aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
228928 if( pTab->abPK[i] || nOld!=nNew || memcmp(aOld, aNew, nNew) ){
228948 int nNew;
228952 aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
228954 && (pTab->abPK[i] || (nOld==nNew && 0==memcmp(aOld, aNew, nNew)))
228958 memcpy(aOut, aNew, nNew);
228959 aOut += nNew;
229069 sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
229072 pSession, sizeof(SessionChange*) * nNew
229080 memset(apNew, 0, sizeof(SessionChange *) * nNew);
229087 int iHash = sessionChangeHash(pTab, bPkOnly, p->aRecord, nNew);
229095 pTab->nChange = nNew;
229505 i64 nNew = p->nAlloc ? p->nAlloc : 128;
229508 nNew = nNew*2;
229509 }while( nNew<nReq );
229516 if( nNew>SESSION_MAX_BUFFER_SZ ){
229517 nNew = SESSION_MAX_BUFFER_SZ;
229518 if( nNew<nReq ){
229524 aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
229529 p->nAlloc = nNew;
229692 i64 nNew = 2;
229694 if( pTab->bRowid ) nNew += 9;
229700 sessionSerializeValue(0, p, &nNew);
229704 nNew += pC->nRecord;
229706 nNew += pC->nRecord;
229712 nNew += 9 + 1;
229767 nNew = pC->nRecord + 2;
229772 nNew += 1 + nOld;
229773 sessionSerializeValue(0, p, &nNew);
229775 nNew += 2 + nOld;
229777 nNew += 2;
229782 if( nNew>pC->nMaxSize ){
229783 int nIncr = nNew - pC->nMaxSize;
229784 pC->nMaxSize = nNew;
231517 int nNew = sessions_strm_chunk_size;
231520 if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
231521 rc = pIn->xInput(pIn->pIn, &pIn->buf.aBuf[pIn->buf.nBuf], &nNew);
231522 if( nNew==0 ){
231525 pIn->buf.nBuf += nNew;
238293 int nNew = p->nFirstAlloc ? p->nFirstAlloc*2 : 64;
238296 aNew = (int*)sqlite3_realloc64(p->aFirst, nNew*sizeof(int));
238299 p->nFirstAlloc = nNew;
238824 u64 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
238826 while( nNew<nByte ){
238827 nNew = nNew * 2;
238829 pNew = sqlite3_realloc64(pBuf->p, nNew);
238834 pBuf->nSpace = (int)nNew;
242016 int nNew = pNear->nPhrase + SZALLOC;
242019 nByte = SZ_FTS5EXPRNEARSET(nNew+1);
242107 int nNew = SZALLOC + (pPhrase ? pPhrase->nTerm : 0);
242110 SZ_FTS5EXPRPHRASE(nNew+1)
242117 pNew->nTerm = nNew - SZALLOC;
243790 int nNew = pHash->nSlot*2;
243795 apNew = (Fts5HashEntry**)sqlite3_malloc64(nNew*sizeof(Fts5HashEntry*));
243797 memset(apNew, 0, nNew*sizeof(Fts5HashEntry*));
243804 iHash = fts5HashKey(nNew, (u8*)fts5EntryKey(p), p->nKey);
243811 pHash->nSlot = nNew;
243948 sqlite3_int64 nNew = p->nAlloc * 2;
243951 pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew);
243953 pNew->nAlloc = (int)nNew;
246120 int nNew; /* Bytes of new data */
246122 iOff += fts5GetVarint32(&a[iOff], nNew);
246123 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
246128 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
246130 iOff += nNew;
246272 int nNew = pIter->nRowidOffset + 8;
246273 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
246279 pIter->nRowidOffset = nNew;
246731 u32 nNew = 0;
246749 fts5FastGetVarint32(a, iOff, nNew);
246758 nCmp = (u32)MIN(nNew, nTerm-nMatch);
246765 if( i==nNew ){
246770 }else if( i<nNew && a[iOff+i]>pTerm[nMatch] ){
246813 iOff += fts5GetVarint32(&a[iOff], nNew);
246821 if( (i64)iOff+nNew>n || nNew<1 ){
246825 pIter->iLeafOffset = iOff + nNew;
246830 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
250519 int nNew = 0;
250526 nNew = pSeg->term.n;
250528 if( nNew<nToken || memcmp(pToken, pNew, nToken) ) break;
250531 xVisit(p, pCtx, p1, pNew, nNew);
250655 int nNew = pT->nMapAlloc ? pT->nMapAlloc*2 : 64;
250656 int nAlloc = nNew * sizeof(Fts5TokenDataMap);
250666 pT->nMapAlloc = nNew;
250762 int nNew
250769 pSetup->nTermByte = nNew-1;
250771 fts5BufferAppendBlob(&p->rc, &pSetup->pT->terms, nNew-1, pNew+1);
250807 int nNew
250843 prefixIterSetupTokendataCb(p, (void*)pSetup->pTokendata, p1, pNew, nNew);
251315 int nNew = (pT->nMapAlloc + nByte) * 2;
251317 pT->aMap, nNew*sizeof(Fts5TokenDataMap)
251324 pT->nMapAlloc = nNew;
259341 int nNew = p->nException;
259356 for(i=0; i<nNew; i++){
259359 memmove(&aNew[i+1], &aNew[i], (nNew-i)*sizeof(int));
259361 nNew++;
259366 p->nException = nNew;