Lines Matching refs:pNew
4788 ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
15314 void *pNew;
15318 pNew = sqlite3MemMalloc(nByte);
15319 if( pNew ){
15320 memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
15322 randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - pOldHdr->iSize);
15326 return pNew;
17037 sqlite3_debug_mutex *pNew = 0;
17041 pNew = sqlite3Malloc(sizeof(*pNew));
17042 if( pNew ){
17043 pNew->id = id;
17044 pNew->cnt = 0;
17051 pNew = &aStatic[id-2];
17052 pNew->id = id;
17056 return (sqlite3_mutex*)pNew;
18608 void *pNew;
18626 pNew = pOld;
18637 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
18638 if( pNew==0 && mem0.alarmCallback ){
18640 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
18642 if( pNew ){
18643 nNew = sqlite3MallocSize(pNew);
18648 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
18650 assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-04675-44850 */
18651 return pNew;
18752 void *pNew = 0;
18763 pNew = sqlite3DbMallocRaw(db, n);
18764 if( pNew ){
18765 memcpy(pNew, p, db->lookaside.sz);
18772 pNew = sqlite3_realloc(p, n);
18773 if( !pNew ){
18777 sqlite3MemdebugSetType(pNew, MEMTYPE_DB |
18781 return pNew;
18789 void *pNew;
18790 pNew = sqlite3DbRealloc(db, p, n);
18791 if( !pNew ){
18794 return pNew;
21818 ** "pNew" is a pointer to the hash table that is to be initialized.
21820 SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){
21821 assert( pNew!=0 );
21822 pNew->first = 0;
21823 pNew->count = 0;
21824 pNew->htsize = 0;
21825 pNew->ht = 0;
21863 /* Link pNew element into the hash table pH. If pEntry!=0 then also
21864 ** insert pNew into the pEntry hash bucket.
21868 struct _ht *pEntry, /* The entry into which pNew is inserted */
21869 HashElem *pNew /* The element to be inserted */
21875 pEntry->chain = pNew;
21880 pNew->next = pHead;
21881 pNew->prev = pHead->prev;
21882 if( pHead->prev ){ pHead->prev->next = pNew; }
21883 else { pH->first = pNew; }
21884 pHead->prev = pNew;
21886 pNew->next = pH->first;
21887 if( pH->first ){ pH->first->prev = pNew; }
21888 pNew->prev = 0;
21889 pH->first = pNew;
25366 struct vxworksFileId *pNew; /* search key and new file ID */
25372 pNew = sqlite3_malloc( sizeof(*pNew) + (n+1) );
25373 if( pNew==0 ) return 0;
25374 pNew->zCanonicalName = (char*)&pNew[1];
25375 memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
25376 n = vxworksSimplifyName(pNew->zCanonicalName, n);
25385 && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
25387 sqlite3_free(pNew);
25395 pNew->nRef = 1;
25396 pNew->nName = n;
25397 pNew->pNext = vxworksFileList;
25398 vxworksFileList = pNew;
25400 return pNew;
28990 unixFile *pNew /* open file object for the database file */
29031 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
29056 unixFile *pNew /* the open file object */
29073 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
29111 unixFile *pNew = (unixFile *)pId;
29114 assert( pNew->pInode==NULL );
29133 pNew->h = h;
29134 pNew->zPath = zFilename;
29136 pNew->ctrlFlags = UNIXFILE_EXCL;
29138 pNew->ctrlFlags = 0;
29141 pNew->ctrlFlags |= UNIXFILE_RDONLY;
29144 pNew->ctrlFlags |= UNIXFILE_DIRSYNC;
29148 pNew->pId = vxworksFindFileId(zFilename);
29149 if( pNew->pId==0 ){
29158 pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
29163 pNew->lockingContext = (void*)zFilename;
29173 rc = findInodeInfo(pNew, &pNew->pInode);
29193 robust_close(pNew, h, __LINE__);
29205 pNew->lockingContext = pCtx = sqlite3_malloc( sizeof(*pCtx) );
29216 rc = findInodeInfo(pNew, &pNew->pInode);
29218 sqlite3_free(pNew->lockingContext);
29219 robust_close(pNew, h, __LINE__);
29240 pNew->lockingContext = zLockFile;
29249 rc = findInodeInfo(pNew, &pNew->pInode);
29250 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
29251 char *zSemName = pNew->pInode->aSemName;
29254 pNew->pId->zCanonicalName);
29257 pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
29258 if( pNew->pInode->pSem == SEM_FAILED ){
29260 pNew->pInode->aSemName[0] = '\0';
29267 pNew->lastErrno = 0;
29270 if( h>=0 ) robust_close(pNew, h, __LINE__);
29275 pNew->isDelete = isDelete;
29278 if( h>=0 ) robust_close(pNew, h, __LINE__);
29280 pNew->pMethod = pLockingStyle;
30325 unixFile *pNew;
30375 pNew = (unixFile *)sqlite3_malloc(sizeof(*pNew));
30376 if( pNew==NULL ){
30380 memset(pNew, 0, sizeof(unixFile));
30381 pNew->openFlags = openFlags;
30387 pNew->pUnused = pUnused;
30389 rc = fillInUnixFile(&dummyVfs, fd, 0, (sqlite3_file*)pNew, path, 0, 0, 0);
30391 *ppFile = pNew;
30395 robust_close(pNew, fd, __LINE__);
30396 sqlite3_free(pNew);
33469 struct winShmNode *pNew; /* Newly allocated winShmNode */
33481 pNew = sqlite3_malloc( sizeof(*pShmNode) + nName + 15 );
33482 if( pNew==0 ){
33486 memset(pNew, 0, sizeof(*pNew));
33487 pNew->zFilename = (char*)&pNew[1];
33488 sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
33489 sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);
33499 if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
33502 sqlite3_free(pNew);
33504 pShmNode = pNew;
33505 pNew = 0;
33569 sqlite3_free(pNew);
36182 PGroupBlockList *pNew;
36186 pNew = (PGroupBlockList *)sqlite3MallocZero(sizeof(PGroupBlockList));
36188 if( pNew==0 ){
36197 pNew->nByte = nByte;
36198 pNew->pNext = pGroup->pBlockList;
36199 pGroup->pBlockList = pNew;
36200 pList = pNew;
37159 struct RowSetChunk *pNew;
37160 pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
37161 if( pNew==0 ){
37164 pNew->pNextChunk = p->pChunk;
37165 p->pChunk = pNew;
37166 p->pFresh = pNew->aEntry;
41023 char *pNew = NULL; /* New temp space */
41030 pNew = (char *)sqlite3PageMalloc(pageSize);
41031 if( !pNew ) rc = SQLITE_NOMEM;
41039 pPager->pTmpSpace = pNew;
53892 MemPage *pNew; /* Newly allocated page */
53894 Pgno pgnoNew; /* Page number of pNew */
53907 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
53916 assert( sqlite3PagerIswriteable(pNew->pDbPage) );
53918 zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
53919 assemblePage(pNew, 1, &pCell, &szCell);
53932 if( szCell>pNew->minLocal ){
53933 ptrmapPutOvflPtr(pNew, pCell, &rc);
53964 releasePage(pNew);
54429 MemPage *pNew;
54431 pNew = apNew[i] = apOld[i];
54433 rc = sqlite3PagerWrite(pNew->pDbPage);
54438 rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0);
54440 apNew[i] = pNew;
54445 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
54510 MemPage *pNew = apNew[i];
54512 zeroPage(pNew, pageFlags);
54513 assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
54514 assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
54515 assert( pNew->nOverflow==0 );
54532 if( !pNew->leaf ){
54533 memcpy(&pNew->aData[8], pCell, 4);
54542 btreeParseCellPtr(pNew, apCell[j], &info);
54567 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
54636 MemPage *pNew = apNew[0];
54672 pNew = apNew[++k];
54682 if( isDivider || pOld->pgno!=pNew->pgno ){
54684 ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
54686 if( szCell[i]>pNew->minLocal ){
54687 ptrmapPutOvflPtr(pNew, apCell[i], &rc);
58417 VdbeOp *pNew;
58419 pNew = sqlite3DbRealloc(p->db, p->aOp, nNew*sizeof(Op));
58420 if( pNew ){
58421 p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op);
58422 p->aOp = pNew;
58424 return (pNew ? SQLITE_OK : SQLITE_NOMEM);
63799 Savepoint *pNew;
66144 Savepoint *pNew;
66185 u.aq.pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+u.aq.nName+1);
66186 if( u.aq.pNew ){
66187 u.aq.pNew->zName = (char *)&u.aq.pNew[1];
66188 memcpy(u.aq.pNew->zName, u.aq.zName, u.aq.nName+1);
66200 u.aq.pNew->pNext = db->pSavepoint;
66201 db->pSavepoint = u.aq.pNew;
66202 u.aq.pNew->nDeferredCons = db->nDeferredCons;
70893 SorterRecord *pNew; /* New list element */
70898 pNew = (SorterRecord *)sqlite3DbMallocRaw(db, pVal->n + sizeof(SorterRecord));
70899 if( pNew==0 ){
70902 pNew->pVal = (void *)&pNew[1];
70903 memcpy(pNew->pVal, pVal->z, pVal->n);
70904 pNew->nVal = pVal->n;
70905 pNew->pNext = pSorter->pRecord;
70906 pSorter->pRecord = pNew;
71541 FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk));
71542 if( !pNew ){
71545 pNew->pNext = 0;
71548 pChunk->pNext = pNew;
71551 p->pFirst = pNew;
71553 p->endpoint.pChunk = pNew;
73404 Expr *pNew;
73415 pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
73416 if( pNew ){
73417 pNew->op = (u8)op;
73418 pNew->iAgg = -1;
73421 pNew->flags |= EP_IntValue;
73422 pNew->u.iValue = iValue;
73425 pNew->u.zToken = (char*)&pNew[1];
73426 memcpy(pNew->u.zToken, pToken->z, pToken->n);
73427 pNew->u.zToken[pToken->n] = 0;
73430 sqlite3Dequote(pNew->u.zToken);
73431 if( c=='"' ) pNew->flags |= EP_DblQuoted;
73436 pNew->nHeight = 1;
73439 return pNew;
73524 Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
73525 sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
73526 return pNew;
73535 Expr *pNew;
73538 pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
73539 if( pNew==0 ){
73543 pNew->x.pList = pList;
73544 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
73545 sqlite3ExprSetHeight(pParse, pNew);
73546 return pNew;
73767 Expr *pNew = 0; /* Value to return */
73782 pNew = (Expr *)zAlloc;
73784 if( pNew ){
73786 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
73808 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
73809 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
73810 pNew->flags |= staticFlag;
73814 char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
73818 if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
73819 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
73821 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
73823 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
73827 /* Fill in pNew->pLeft and pNew->pRight. */
73828 if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
73830 if( ExprHasProperty(pNew, EP_Reduced) ){
73831 pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
73832 pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
73838 pNew->flags2 = 0;
73840 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
73841 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
73847 return pNew;
73871 ExprList *pNew;
73875 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
73876 if( pNew==0 ) return 0;
73877 pNew->iECursor = 0;
73878 pNew->nExpr = pNew->nAlloc = p->nExpr;
73879 pNew->a = pItem = sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) );
73881 sqlite3DbFree(db, pNew);
73895 return pNew;
73907 SrcList *pNew;
73912 pNew = sqlite3DbMallocRaw(db, nByte );
73913 if( pNew==0 ) return 0;
73914 pNew->nSrc = pNew->nAlloc = p->nSrc;
73916 struct SrcList_item *pNewItem = &pNew->a[i];
73939 return pNew;
73942 IdList *pNew;
73945 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
73946 if( pNew==0 ) return 0;
73947 pNew->nId = pNew->nAlloc = p->nId;
73948 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
73949 if( pNew->a==0 ){
73950 sqlite3DbFree(db, pNew);
73954 struct IdList_item *pNewItem = &pNew->a[i];
73959 return pNew;
73962 Select *pNew;
73964 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
73965 if( pNew==0 ) return 0;
73966 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
73967 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
73968 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
73969 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
73970 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
73971 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
73972 pNew->op = p->op;
73973 pNew->pPrior = sqlite3SelectDup(db, p->pPrior, flags);
73974 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
73975 pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
73976 pNew->iLimit = 0;
73977 pNew->iOffset = 0;
73978 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
73979 pNew->pRightmost = 0;
73980 pNew->addrOpenEphm[0] = -1;
73981 pNew->addrOpenEphm[1] = -1;
73982 pNew->addrOpenEphm[2] = -1;
73983 return pNew;
77401 Table *pNew; /* Copy of pParse->pNewTable */
77413 pNew = pParse->pNewTable;
77414 assert( pNew );
77417 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
77419 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
77420 pCol = &pNew->aCol[pNew->nCol-1];
77448 if( pNew->pIndex ){
77452 if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
77492 zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
77525 Table *pNew;
77566 pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
77567 if( !pNew ) goto exit_begin_add_column;
77568 pParse->pNewTable = pNew;
77569 pNew->nRef = 1;
77570 pNew->nCol = pTab->nCol;
77571 assert( pNew->nCol>0 );
77572 nAlloc = (((pNew->nCol-1)/8)*8)+8;
77573 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
77574 pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
77575 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
77576 if( !pNew->aCol || !pNew->zName ){
77580 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
77581 for(i=0; i<pNew->nCol; i++){
77582 Column *pCol = &pNew->aCol[i];
77589 pNew->pSchema = db->aDb[iDb].pSchema;
77590 pNew->addColOffset = pTab->addColOffset;
77591 pNew->nRef = 1;
82178 void *pNew;
82181 pNew = sqlite3DbRealloc(db, pArray, newSize*szEntry);
82182 if( pNew==0 ){
82186 *pnAlloc = sqlite3DbMallocSize(db, pNew)/szEntry;
82187 pArray = pNew;
82287 SrcList *pNew;
82290 pNew = sqlite3DbRealloc(db, pSrc,
82292 if( pNew==0 ){
82296 pSrc = pNew;
82297 nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
86708 Expr *pNew;
86710 pNew = sqlite3PExpr(pParse, TK_DOT,
86717 pNew = sqlite3ExprDup(db, pDflt, 0);
86719 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
86722 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
86724 pList = sqlite3ExprListAppend(pParse, pList, pNew);
92205 sqlite3_stmt *pNew;
92214 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
92219 assert( pNew==0 );
92222 assert( pNew!=0 );
92224 sqlite3VdbeSwap((Vdbe*)pNew, p);
92225 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
92226 sqlite3VdbeResetStepResult((Vdbe*)pNew);
92227 sqlite3VdbeFinalize((Vdbe*)pNew);
92409 Select *pNew;
92412 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
92414 if( pNew==0 ){
92415 pNew = &standin;
92416 memset(pNew, 0, sizeof(*pNew));
92421 pNew->pEList = pEList;
92422 pNew->pSrc = pSrc;
92423 pNew->pWhere = pWhere;
92424 pNew->pGroupBy = pGroupBy;
92425 pNew->pHaving = pHaving;
92426 pNew->pOrderBy = pOrderBy;
92427 pNew->selFlags = isDistinct ? SF_Distinct : 0;
92428 pNew->op = TK_SELECT;
92429 pNew->pLimit = pLimit;
92430 pNew->pOffset = pOffset;
92432 pNew->addrOpenEphm[0] = -1;
92433 pNew->addrOpenEphm[1] = -1;
92434 pNew->addrOpenEphm[2] = -1;
92436 clearSelect(db, pNew);
92437 if( pNew!=&standin ) sqlite3DbFree(db, pNew);
92438 pNew = 0;
92440 assert( pNew->pSrc!=0 || pParse->nErr>0 );
92442 return pNew;
94568 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
94569 if( pNew==0 ) return SQLITE_NOMEM;
94570 pNew->flags |= EP_IntValue;
94571 pNew->u.iValue = i;
94572 pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
94872 Expr *pNew;
94875 pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
94876 if( pNew && pExpr->pColl ){
94877 pNew->pColl = pExpr->pColl;
94880 pExpr = pNew;
95213 Select *pNew;
95221 pNew = sqlite3SelectDup(db, p, 0);
95227 if( pNew==0 ){
95228 pNew = pPrior;
95230 pNew->pPrior = pPrior;
95231 pNew->pRightmost = 0;
95233 p->pPrior = pNew;
95635 ExprList *pNew = 0;
95646 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
95647 if( pNew ){
95648 pNew->a[pNew->nExpr-1].zName = a[k].zName;
95649 pNew->a[pNew->nExpr-1].zSpan = a[k].zSpan;
95721 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
95724 sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
95738 p->pEList = pNew;
100218 FuncDef *pNew;
100253 pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
100255 if( pNew==0 ){
100258 *pNew = *pDef;
100259 pNew->zName = (char *)&pNew[1];
100260 memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
100261 pNew->xFunc = xFunc;
100262 pNew->pUserData = pArg;
100263 pNew->flags |= SQLITE_FUNC_EPHEM;
100264 return pNew;
101396 Expr *pNew; /* The complete IN operator */
101409 pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0, 0);
101410 if( pNew ){
101412 transferJoinMarkings(pNew, pExpr);
101413 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
101414 pNew->x.pList = pList;
101415 idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
101507 WhereTerm *pNew;
101518 pNew = &pWC->a[idxNew];
101519 pNew->iParent = idxTerm;
101525 pNew = pTerm;
101529 pNew->leftCursor = pLeft->iTable;
101530 pNew->u.leftColumn = pLeft->iColumn;
101532 pNew->prereqRight = prereqLeft | extraRight;
101533 pNew->prereqAll = prereqAll;
101534 pNew->eOperator = operatorMask(pDup->op);
106856 yyStackEntry *pNew;
106859 pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
106860 if( pNew ){
106861 p->yystack = pNew;
113044 /* sqlite3_test_control(SQLITE_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree);
113047 ** If sz>0 then allocate a scratch buffer into pNew.
113359 void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
113360 if( pNew ){
113361 memcpy(pNew, aArg, nArg*sizeof(void *));
113363 aDyn = aArg = pNew;
113997 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
116529 ** Append SegReader object pNew to the end of the pCsr->apSegment[] array.
116533 Fts3SegReader *pNew
116540 sqlite3Fts3SegReaderFree(pNew);
116545 pCsr->apSegment[pCsr->nSegment++] = pNew;
120068 ** inserted into the tree. This function adds pNew, which is always a binary
120070 ** of pNew and the existing nodes of the tree. This may result in the head
120076 Fts3Expr *pNew /* New binary node to insert into expression tree */
120079 while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){
120085 pSplit->pParent->pRight = pNew;
120086 pNew->pParent = pSplit->pParent;
120088 *ppHead = pNew;
120090 pNew->pLeft = pSplit;
120091 pSplit->pParent = pNew;
120555 ** "pNew" is a pointer to the hash table that is to be initialized.
120562 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
120563 assert( pNew!=0 );
120565 pNew->keyClass = keyClass;
120566 pNew->copyKey = copyKey;
120567 pNew->first = 0;
120568 pNew->count = 0;
120569 pNew->htsize = 0;
120570 pNew->ht = 0;
120671 struct _fts3ht *pEntry, /* The entry into which pNew is inserted */
120672 Fts3HashElem *pNew /* The element to be inserted */
120677 pNew->next = pHead;
120678 pNew->prev = pHead->prev;
120679 if( pHead->prev ){ pHead->prev->next = pNew; }
120680 else { pH->first = pNew; }
120681 pHead->prev = pNew;
120683 pNew->next = pH->first;
120684 if( pH->first ){ pH->first->prev = pNew; }
120685 pNew->prev = 0;
120686 pH->first = pNew;
120689 pEntry->chain = pNew;
121493 char *pNew;
121495 pNew = sqlite3_realloc(c->zToken, c->nAllocated);
121496 if( !pNew ) return SQLITE_NOMEM;
121497 c->zToken = pNew;
122210 char *pNew;
122212 pNew = sqlite3_realloc(c->pToken, c->nTokenAllocated);
122213 if( !pNew ) return SQLITE_NOMEM;
122214 c->pToken = pNew;
123995 SegmentNode *pNew;
124065 pNew = (SegmentNode *)sqlite3_malloc(sizeof(SegmentNode) + p->nNodeSize);
124066 if( !pNew ){
124069 memset(pNew, 0, sizeof(SegmentNode));
124070 pNew->nData = 1 + FTS3_VARINT_MAX;
124071 pNew->aData = (char *)&pNew[1];
124079 pTree->pRight = pNew;
124080 pNew->pLeftmost = pTree->pLeftmost;
124081 pNew->pParent = pParent;
124082 pNew->zMalloc = pTree->zMalloc;
124083 pNew->nMalloc = pTree->nMalloc;
124086 pNew->pLeftmost = pNew;
124087 rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm);
124090 *ppTree = pNew;
124543 char *pNew;
124545 pNew = (char *)sqlite3_realloc(pMsr->aBuffer, pMsr->nBuffer);
124546 if( !pNew ) return SQLITE_NOMEM;
124547 pMsr->aBuffer = pNew;