Lines Matching refs:pNew
4921 ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
15802 void *pNew;
15806 pNew = sqlite3MemMalloc(nByte);
15807 if( pNew ){
15808 memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
15810 randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - pOldHdr->iSize);
15814 return pNew;
17525 sqlite3_debug_mutex *pNew = 0;
17529 pNew = sqlite3Malloc(sizeof(*pNew));
17530 if( pNew ){
17531 pNew->id = id;
17532 pNew->cnt = 0;
17539 pNew = &aStatic[id-2];
17540 pNew->id = id;
17544 return (sqlite3_mutex*)pNew;
19097 void *pNew;
19115 pNew = pOld;
19126 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
19127 if( pNew==0 && mem0.alarmCallback ){
19129 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
19131 if( pNew ){
19132 nNew = sqlite3MallocSize(pNew);
19137 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
19139 assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-04675-44850 */
19140 return pNew;
19241 void *pNew = 0;
19252 pNew = sqlite3DbMallocRaw(db, n);
19253 if( pNew ){
19254 memcpy(pNew, p, db->lookaside.sz);
19261 pNew = sqlite3_realloc(p, n);
19262 if( !pNew ){
19266 sqlite3MemdebugSetType(pNew, MEMTYPE_DB |
19270 return pNew;
19278 void *pNew;
19279 pNew = sqlite3DbRealloc(db, p, n);
19280 if( !pNew ){
19283 return pNew;
22253 ** "pNew" is a pointer to the hash table that is to be initialized.
22255 SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){
22256 assert( pNew!=0 );
22257 pNew->first = 0;
22258 pNew->count = 0;
22259 pNew->htsize = 0;
22260 pNew->ht = 0;
22298 /* Link pNew element into the hash table pH. If pEntry!=0 then also
22299 ** insert pNew into the pEntry hash bucket.
22303 struct _ht *pEntry, /* The entry into which pNew is inserted */
22304 HashElem *pNew /* The element to be inserted */
22310 pEntry->chain = pNew;
22315 pNew->next = pHead;
22316 pNew->prev = pHead->prev;
22317 if( pHead->prev ){ pHead->prev->next = pNew; }
22318 else { pH->first = pNew; }
22319 pHead->prev = pNew;
22321 pNew->next = pH->first;
22322 if( pH->first ){ pH->first->prev = pNew; }
22323 pNew->prev = 0;
22324 pH->first = pNew;
25844 struct vxworksFileId *pNew; /* search key and new file ID */
25850 pNew = sqlite3_malloc( sizeof(*pNew) + (n+1) );
25851 if( pNew==0 ) return 0;
25852 pNew->zCanonicalName = (char*)&pNew[1];
25853 memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
25854 n = vxworksSimplifyName(pNew->zCanonicalName, n);
25863 && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
25865 sqlite3_free(pNew);
25873 pNew->nRef = 1;
25874 pNew->nName = n;
25875 pNew->pNext = vxworksFileList;
25876 vxworksFileList = pNew;
25878 return pNew;
29502 unixFile *pNew /* open file object for the database file */
29543 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
29568 unixFile *pNew /* the open file object */
29585 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
29620 unixFile *pNew = (unixFile *)pId;
29623 assert( pNew->pInode==NULL );
29640 pNew->h = h;
29641 pNew->pVfs = pVfs;
29642 pNew->zPath = zFilename;
29643 pNew->ctrlFlags = (u8)ctrlFlags;
29646 pNew->ctrlFlags |= UNIXFILE_PSOW;
29649 pNew->ctrlFlags |= UNIXFILE_EXCL;
29653 pNew->pId = vxworksFindFileId(zFilename);
29654 if( pNew->pId==0 ){
29663 pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
29668 pNew->lockingContext = (void*)zFilename;
29678 rc = findInodeInfo(pNew, &pNew->pInode);
29698 robust_close(pNew, h, __LINE__);
29710 pNew->lockingContext = pCtx = sqlite3_malloc( sizeof(*pCtx) );
29721 rc = findInodeInfo(pNew, &pNew->pInode);
29723 sqlite3_free(pNew->lockingContext);
29724 robust_close(pNew, h, __LINE__);
29746 pNew->lockingContext = zLockFile;
29755 rc = findInodeInfo(pNew, &pNew->pInode);
29756 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
29757 char *zSemName = pNew->pInode->aSemName;
29760 pNew->pId->zCanonicalName);
29763 pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
29764 if( pNew->pInode->pSem == SEM_FAILED ){
29766 pNew->pInode->aSemName[0] = '\0';
29773 pNew->lastErrno = 0;
29776 if( h>=0 ) robust_close(pNew, h, __LINE__);
29781 if( isDelete ) pNew->ctrlFlags |= UNIXFILE_DELETE;
29784 if( h>=0 ) robust_close(pNew, h, __LINE__);
29786 pNew->pMethod = pLockingStyle;
30880 unixFile *pNew;
30930 pNew = (unixFile *)sqlite3_malloc(sizeof(*pNew));
30931 if( pNew==NULL ){
30935 memset(pNew, 0, sizeof(unixFile));
30936 pNew->openFlags = openFlags;
30942 pNew->pUnused = pUnused;
30944 rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0);
30946 *ppFile = pNew;
30950 robust_close(pNew, fd, __LINE__);
30951 sqlite3_free(pNew);
34569 struct winShmNode *pNew; /* Newly allocated winShmNode */
34581 pNew = sqlite3_malloc( sizeof(*pShmNode) + nName + 17 );
34582 if( pNew==0 ){
34586 memset(pNew, 0, sizeof(*pNew) + nName + 17);
34587 pNew->zFilename = (char*)&pNew[1];
34588 sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
34589 sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);
34599 if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
34602 sqlite3_free(pNew);
34604 pShmNode = pNew;
34605 pNew = 0;
34669 sqlite3_free(pNew);
38035 struct RowSetChunk *pNew;
38036 pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
38037 if( pNew==0 ){
38040 pNew->pNextChunk = p->pChunk;
38041 p->pChunk = pNew;
38042 p->pFresh = pNew->aEntry;
41933 char *pNew = NULL; /* New temp space */
41940 pNew = (char *)sqlite3PageMalloc(pageSize);
41941 if( !pNew ) rc = SQLITE_NOMEM;
41949 pPager->pTmpSpace = pNew;
55064 MemPage *pNew; /* Newly allocated page */
55066 Pgno pgnoNew; /* Page number of pNew */
55079 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
55088 assert( sqlite3PagerIswriteable(pNew->pDbPage) );
55090 zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
55091 assemblePage(pNew, 1, &pCell, &szCell);
55104 if( szCell>pNew->minLocal ){
55105 ptrmapPutOvflPtr(pNew, pCell, &rc);
55136 releasePage(pNew);
55609 MemPage *pNew;
55611 pNew = apNew[i] = apOld[i];
55613 rc = sqlite3PagerWrite(pNew->pDbPage);
55618 rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0);
55620 apNew[i] = pNew;
55625 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
55690 MemPage *pNew = apNew[i];
55692 zeroPage(pNew, pageFlags);
55693 assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
55694 assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
55695 assert( pNew->nOverflow==0 );
55712 if( !pNew->leaf ){
55713 memcpy(&pNew->aData[8], pCell, 4);
55722 btreeParseCellPtr(pNew, apCell[j], &info);
55747 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
55816 MemPage *pNew = apNew[0];
55853 pNew = apNew[++k];
55863 if( isDivider || pOld->pgno!=pNew->pgno ){
55865 ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
55867 if( szCell[i]>pNew->minLocal ){
55868 ptrmapPutOvflPtr(pNew, apCell[i], &rc);
59622 VdbeOp *pNew;
59624 pNew = sqlite3DbRealloc(p->db, p->aOp, nNew*sizeof(Op));
59625 if( pNew ){
59626 p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op);
59627 p->aOp = pNew;
59629 return (pNew ? SQLITE_OK : SQLITE_NOMEM);
65124 Savepoint *pNew;
67492 Savepoint *pNew;
67533 u.ar.pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+u.ar.nName+1);
67534 if( u.ar.pNew ){
67535 u.ar.pNew->zName = (char *)&u.ar.pNew[1];
67536 memcpy(u.ar.pNew->zName, u.ar.zName, u.ar.nName+1);
67548 u.ar.pNew->pNext = db->pSavepoint;
67549 db->pSavepoint = u.ar.pNew;
67550 u.ar.pNew->nDeferredCons = db->nDeferredCons;
72259 SorterRecord *pNew; /* New list element */
72264 pNew = (SorterRecord *)sqlite3DbMallocRaw(db, pVal->n + sizeof(SorterRecord));
72265 if( pNew==0 ){
72268 pNew->pVal = (void *)&pNew[1];
72269 memcpy(pNew->pVal, pVal->z, pVal->n);
72270 pNew->nVal = pVal->n;
72271 pNew->pNext = pSorter->pRecord;
72272 pSorter->pRecord = pNew;
72907 FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk));
72908 if( !pNew ){
72911 pNew->pNext = 0;
72914 pChunk->pNext = pNew;
72917 p->pFirst = pNew;
72919 p->endpoint.pChunk = pNew;
74775 Expr *pNew;
74786 pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
74787 if( pNew ){
74788 pNew->op = (u8)op;
74789 pNew->iAgg = -1;
74792 pNew->flags |= EP_IntValue;
74793 pNew->u.iValue = iValue;
74796 pNew->u.zToken = (char*)&pNew[1];
74798 if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
74799 pNew->u.zToken[pToken->n] = 0;
74802 sqlite3Dequote(pNew->u.zToken);
74803 if( c=='"' ) pNew->flags |= EP_DblQuoted;
74808 pNew->nHeight = 1;
74811 return pNew;
74896 Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
74897 sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
74898 return pNew;
74907 Expr *pNew;
74910 pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
74911 if( pNew==0 ){
74915 pNew->x.pList = pList;
74916 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
74917 sqlite3ExprSetHeight(pParse, pNew);
74918 return pNew;
75139 Expr *pNew = 0; /* Value to return */
75154 pNew = (Expr *)zAlloc;
75156 if( pNew ){
75158 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
75180 pNew
75181 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
75182 pNew->flags |= staticFlag;
75186 char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
75190 if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
75191 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
75193 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
75195 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
75199 /* Fill in pNew->pLeft and pNew->pRight. */
75200 if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
75202 if( ExprHasProperty(pNew, EP_Reduced) ){
75203 pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
75204 pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
75210 pNew->flags2 = 0;
75212 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
75213 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
75219 return pNew;
75243 ExprList *pNew;
75247 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
75248 if( pNew==0 ) return 0;
75249 pNew->iECursor = 0;
75250 pNew->nExpr = i = p->nExpr;
75252 pNew->a = pItem = sqlite3DbMallocRaw(db, i*sizeof(p->a[0]) );
75254 sqlite3DbFree(db, pNew);
75268 return pNew;
75280 SrcList *pNew;
75285 pNew = sqlite3DbMallocRaw(db, nByte );
75286 if( pNew==0 ) return 0;
75287 pNew->nSrc = pNew->nAlloc = p->nSrc;
75289 struct SrcList_item *pNewItem = &pNew->a[i];
75312 return pNew;
75315 IdList *pNew;
75318 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
75319 if( pNew==0 ) return 0;
75320 pNew->nId = p->nId;
75321 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
75322 if( pNew->a==0 ){
75323 sqlite3DbFree(db, pNew);
75330 struct IdList_item *pNewItem = &pNew->a[i];
75335 return pNew;
75338 Select *pNew, *pPrior;
75340 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
75341 if( pNew==0 ) return 0;
75342 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
75343 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
75344 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
75345 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
75346 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
75347 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
75348 pNew->op = p->op;
75349 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
75350 if( pPrior ) pPrior->pNext = pNew;
75351 pNew->pNext = 0;
75352 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
75353 pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
75354 pNew->iLimit = 0;
75355 pNew->iOffset = 0;
75356 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
75357 pNew->pRightmost = 0;
75358 pNew->addrOpenEphm[0] = -1;
75359 pNew->addrOpenEphm[1] = -1;
75360 pNew->addrOpenEphm[2] = -1;
75361 return pNew;
79055 Table *pNew; /* Copy of pParse->pNewTable */
79067 pNew = pParse->pNewTable;
79068 assert( pNew );
79071 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
79073 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
79074 pCol = &pNew->aCol[pNew->nCol-1];
79102 if( pNew->pIndex ){
79106 if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
79146 zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
79179 Table *pNew;
79220 pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
79221 if( !pNew ) goto exit_begin_add_column;
79222 pParse->pNewTable = pNew;
79223 pNew->nRef = 1;
79224 pNew->nCol = pTab->nCol;
79225 assert( pNew->nCol>0 );
79226 nAlloc = (((pNew->nCol-1)/8)*8)+8;
79227 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
79228 pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
79229 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
79230 if( !pNew->aCol || !pNew->zName ){
79234 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
79235 for(i=0; i<pNew->nCol; i++){
79236 Column *pCol = &pNew->aCol[i];
79243 pNew->pSchema = db->aDb[iDb].pSchema;
79244 pNew->addColOffset = pTab->addColOffset;
79245 pNew->nRef = 1;
84264 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
84265 if( pNew==0 ){
84269 pArray = pNew;
84366 SrcList *pNew;
84369 pNew = sqlite3DbRealloc(db, pSrc,
84371 if( pNew==0 ){
84375 pSrc = pNew;
84376 nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
88789 Expr *pNew;
88791 pNew = sqlite3PExpr(pParse, TK_DOT,
88798 pNew = sqlite3ExprDup(db, pDflt, 0);
88800 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
88803 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
88805 pList = sqlite3ExprListAppend(pParse, pList, pNew);
94359 sqlite3_stmt *pNew;
94368 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
94373 assert( pNew==0 );
94376 assert( pNew!=0 );
94378 sqlite3VdbeSwap((Vdbe*)pNew, p);
94379 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
94380 sqlite3VdbeResetStepResult((Vdbe*)pNew);
94381 sqlite3VdbeFinalize((Vdbe*)pNew);
94563 Select *pNew;
94566 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
94568 if( pNew==0 ){
94570 pNew = &standin;
94571 memset(pNew, 0, sizeof(*pNew));
94576 pNew->pEList = pEList;
94578 pNew->pSrc = pSrc;
94579 pNew->pWhere = pWhere;
94580 pNew->pGroupBy = pGroupBy;
94581 pNew->pHaving = pHaving;
94582 pNew->pOrderBy = pOrderBy;
94583 pNew->selFlags = isDistinct ? SF_Distinct : 0;
94584 pNew->op = TK_SELECT;
94585 pNew->pLimit = pLimit;
94586 pNew->pOffset = pOffset;
94588 pNew->addrOpenEphm[0] = -1;
94589 pNew->addrOpenEphm[1] = -1;
94590 pNew->addrOpenEphm[2] = -1;
94592 clearSelect(db, pNew);
94593 if( pNew!=&standin ) sqlite3DbFree(db, pNew);
94594 pNew = 0;
94596 assert( pNew->pSrc!=0 || pParse->nErr>0 );
94598 assert( pNew!=&standin );
94599 return pNew;
96732 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
96733 if( pNew==0 ) return SQLITE_NOMEM;
96734 pNew->flags |= EP_IntValue;
96735 pNew->u.iValue = i;
96736 pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
97036 Expr *pNew;
97039 pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
97040 if( pNew && pExpr->pColl ){
97041 pNew->pColl = pExpr->pColl;
97044 pExpr = pNew;
97384 Select *pNew;
97392 pNew = sqlite3SelectDup(db, p, 0);
97398 if( pNew==0 ){
97399 pNew = pPrior;
97401 pNew->pPrior = pPrior;
97402 pNew->pRightmost = 0;
97404 p->pPrior = pNew;
97806 ExprList *pNew = 0;
97817 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
97818 if( pNew ){
97819 pNew->a[pNew->nExpr-1].zName = a[k].zName;
97820 pNew->a[pNew->nExpr-1].zSpan = a[k].zSpan;
97892 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
97895 sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
97909 p->pEList = pNew;
102405 FuncDef *pNew;
102440 pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
102442 if( pNew==0 ){
102445 *pNew = *pDef;
102446 pNew->zName = (char *)&pNew[1];
102447 memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
102448 pNew->xFunc = xFunc;
102449 pNew->pUserData = pArg;
102450 pNew->flags |= SQLITE_FUNC_EPHEM;
102451 return pNew;
103599 Expr *pNew; /* The complete IN operator */
103612 pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0, 0);
103613 if( pNew ){
103615 transferJoinMarkings(pNew, pExpr);
103616 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
103617 pNew->x.pList = pList;
103618 idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
103710 WhereTerm *pNew;
103721 pNew = &pWC->a[idxNew];
103722 pNew->iParent = idxTerm;
103728 pNew = pTerm;
103732 pNew->leftCursor = pLeft->iTable;
103733 pNew->u.leftColumn = pLeft->iColumn;
103735 pNew->prereqRight = prereqLeft | extraRight;
103736 pNew->prereqAll = prereqAll;
103737 pNew->eOperator = operatorMask(pDup->op);
109117 yyStackEntry *pNew;
109120 pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
109121 if( pNew ){
109122 p->yystack = pNew;
115361 /* sqlite3_test_control(SQLITE_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree);
115364 ** If sz>0 then allocate a scratch buffer into pNew.
115751 void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
115752 if( pNew ){
115753 memcpy(pNew, aArg, nArg*sizeof(void *));
115755 aDyn = aArg = pNew;
116394 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
119206 ** Append SegReader object pNew to the end of the pCsr->apSegment[] array.
119210 Fts3SegReader *pNew
119217 sqlite3Fts3SegReaderFree(pNew);
119222 pCsr->apSegment[pCsr->nSegment++] = pNew;
122860 ** inserted into the tree. This function adds pNew, which is always a binary
122862 ** of pNew and the existing nodes of the tree. This may result in the head
122868 Fts3Expr *pNew /* New binary node to insert into expression tree */
122871 while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){
122877 pSplit->pParent->pRight = pNew;
122878 pNew->pParent = pSplit->pParent;
122880 *ppHead = pNew;
122882 pNew->pLeft = pSplit;
122883 pSplit->pParent = pNew;
123352 ** "pNew" is a pointer to the hash table that is to be initialized.
123359 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
123360 assert( pNew!=0 );
123362 pNew->keyClass = keyClass;
123363 pNew->copyKey = copyKey;
123364 pNew->first = 0;
123365 pNew->count = 0;
123366 pNew->htsize = 0;
123367 pNew->ht = 0;
123468 struct _fts3ht *pEntry, /* The entry into which pNew is inserted */
123469 Fts3HashElem *pNew /* The element to be inserted */
123474 pNew->next = pHead;
123475 pNew->prev = pHead->prev;
123476 if( pHead->prev ){ pHead->prev->next = pNew; }
123477 else { pH->first = pNew; }
123478 pHead->prev = pNew;
123480 pNew->next = pH->first;
123481 if( pH->first ){ pH->first->prev = pNew; }
123482 pNew->prev = 0;
123483 pH->first = pNew;
123486 pEntry->chain = pNew;
124290 char *pNew;
124292 pNew = sqlite3_realloc(c->zToken, c->nAllocated);
124293 if( !pNew ) return SQLITE_NOMEM;
124294 c->zToken = pNew;
125007 char *pNew;
125009 pNew = sqlite3_realloc(c->pToken, c->nTokenAllocated);
125010 if( !pNew ) return SQLITE_NOMEM;
125011 c->pToken = pNew;
126905 SegmentNode *pNew;
126975 pNew = (SegmentNode *)sqlite3_malloc(sizeof(SegmentNode) + p->nNodeSize);
126976 if( !pNew ){
126979 memset(pNew, 0, sizeof(SegmentNode));
126980 pNew->nData = 1 + FTS3_VARINT_MAX;
126981 pNew->aData = (char *)&pNew[1];
126989 pTree->pRight = pNew;
126990 pNew->pLeftmost = pTree->pLeftmost;
126991 pNew->pParent = pParent;
126992 pNew->zMalloc = pTree->zMalloc;
126993 pNew->nMalloc = pTree->nMalloc;
126996 pNew->pLeftmost = pNew;
126997 rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm);
127000 *ppTree = pNew;
127471 char *pNew;
127473 pNew = (char *)sqlite3_realloc(pMsr->aBuffer, pMsr->nBuffer);
127474 if( !pNew ) return SQLITE_NOMEM;
127475 pMsr->aBuffer = pNew;
