Lines Matching defs:pNext
1633 ** the pNext pointer. The [sqlite3_vfs_register()]
1637 ** implementation should use the pNext pointer.
1639 ** The pNext field is the only field in the sqlite3_vfs
1782 sqlite3_vfs *pNext; /* Next registered VFS */
16490 SubProgram *pNext; /* Next sub-program already visited */
17497 LookasideSlot *pNext; /* Next buffer in the list of free buffers */
17885 FuncDef *pNext; /* Next function with same name */
18107 Savepoint *pNext; /* Parent savepoint (if any) */
18324 VTable *pNext; /* Next in linked list (see above) */
18677 Index *pNext; /* The next index associated with the same table */
19325 ** Each subquery gets a new NameContext. The pNext field points to the
19339 NameContext *pNext; /* Next outer name context. NULL for outermost */
19446 Select *pNext; /* Next select to the left in a compound */
19616 AutoincInfo *pNext; /* Next info block in a list of them all */
19642 TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
19696 ParseCleanup *pNext; /* Next cleanup task */
19921 ** pNext member of struct Trigger. A pointer to the first element of the
19940 Trigger *pNext; /* Next trigger associated with the table */
19958 ** using the "pNext" member) referenced by the "step_list" member of the
20009 TriggerStep *pNext; /* Next in the link-list */
20335 DbClientData *pNext; /* Next in a linked list */
23909 p = p->pNext;
23952 while( p->pNext ) p = p->pNext;
23953 p->pNext = db->lookaside.pInit;
23960 while( p->pNext ) p = p->pNext;
23961 p->pNext = db->lookaside.pSmallInit;
26133 for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
26149 vfsList = pVfs->pNext;
26152 while( p->pNext && p->pNext!=pVfs ){
26153 p = p->pNext;
26155 if( p->pNext==pVfs ){
26156 p->pNext = pVfs->pNext;
26180 pVfs->pNext = vfsList;
26183 pVfs->pNext = vfsList->pNext;
26184 vfsList->pNext = pVfs;
26711 struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
26914 pHdr->pNext = 0;
26917 mem.pLast->pNext = pHdr;
26966 assert( pHdr->pPrev->pNext==pHdr );
26967 pHdr->pPrev->pNext = pHdr->pNext;
26970 mem.pFirst = pHdr->pNext;
26972 if( pHdr->pNext ){
26973 assert( pHdr->pNext->pPrev==pHdr );
26974 pHdr->pNext->pPrev = pHdr->pPrev;
27119 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
27141 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
30369 pBuf->pNext = db->lookaside.pSmallFree;
30380 pBuf->pNext = db->lookaside.pFree;
30408 pBuf->pNext = db->lookaside.pSmallFree;
30419 pBuf->pNext = db->lookaside.pFree;
30598 db->lookaside.pSmallFree = pBuf->pNext;
30602 db->lookaside.pSmallInit = pBuf->pNext;
30609 db->lookaside.pFree = pBuf->pNext;
30613 db->lookaside.pInit = pBuf->pNext;
33520 moreToFollow || (showFullList && pStep->pNext!=0));
33522 if( cnt++ && pStep->pNext==0 ){
33527 }while( showFullList && (pStep = pStep->pNext)!=0 );
33543 moreToFollow || (showFullList && pTrigger->pNext!=0));
33545 if( cnt++ && pTrigger->pNext==0 ){
33553 }while( showFullList && (pTrigger = pTrigger->pNext)!=0 );
37134 0, /* pNext */
38267 UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
38971 struct vxworksFileId *pNext; /* Next in a list of them all */
39049 for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
39063 pNew->pNext = vxworksFileList;
39079 for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
39081 *pp = pId->pNext;
39236 unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
39373 UnixUnusedFd *pNext;
39375 for(p=pInode->pUnused; p; p=pNext){
39376 pNext = p->pNext;
39401 assert( pInode->pPrev->pNext==pInode );
39402 pInode->pPrev->pNext = pInode->pNext;
39405 inodeList = pInode->pNext;
39407 if( pInode->pNext ){
39408 assert( pInode->pNext->pPrev==pInode );
39409 pInode->pNext->pPrev = pInode->pPrev;
39486 pInode = pInode->pNext;
39504 pInode->pNext = inodeList;
39954 p->pNext = pInode->pUnused;
42390 unixShm *pNext; /* Next unixShm with the same unixShmNode */
42813 p->pNext = pShmNode->pFirst;
42996 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
43263 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
43264 *pp = p->pNext;
44126 pInode = pInode->pNext;
44133 for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
44136 *pp = pUnused->pNext;
46187 0, /* pNext */ \
46211 ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
50014 ** pNext
50044 winShmNode *pNext; /* Next in list of all winShmNode objects */
50072 winShm *pNext; /* Next winShm with the same winShmNode */
50174 *pp = p->pNext;
50178 pp = &p->pNext;
50249 for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){
50264 pShmNode->pNext = winShmNodeList;
50311 p->pNext = pShmNode->pFirst;
50347 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
50348 *pp = p->pNext;
50403 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
50428 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
50453 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
52366 0, /* pNext */
52391 0, /* pNext */
52416 0, /* pNext */
52441 0, /* pNext */
52655 0, /* pNext */
54557 PgHdr *pNext;
54559 for(p=pCache->pDirty; p; p=pNext){
54560 pNext = p->pDirtyNext;
54919 PgHdr1 *pNext; /* Next in hash table chain */
55007 PgFreeslot *pNext; /* Next free slot */
55086 p->pNext = pcache1.pFree;
55123 pX->pNext = pCache->pFree;
55148 pcache1.pFree = pcache1.pFree->pNext;
55186 pSlot->pNext = pcache1.pFree;
55237 pCache->pFree = p->pNext;
55238 p->pNext = 0;
55275 p->pNext = pCache->pFree;
55354 PgHdr1 *pNext = p->apHash[i];
55355 while( (pPage = pNext)!=0 ){
55357 pNext = pPage->pNext;
55358 pPage->pNext = apNew[h];
55407 for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
55408 *pp = (*pp)->pNext;
55474 *pp = pPage->pNext;
55478 pp = &pPage->pNext;
55726 pPage->pNext = pCache->apHash[h];
55809 while( pPage && pPage->iKey!=iKey ){ pPage = pPage->pNext; }
55930 pp = &(*pp)->pNext;
55932 *pp = pPage->pNext;
55937 pPage->pNext = pCache->apHash[hNew];
56358 struct RowSetEntry *pNext, *aBucket[40];
56362 pNext = pIn->pRight;
56369 pIn = pNext;
59900 PgHdr *pNext = pList->pDirty;
59902 pList = pNext;
60854 PgHdr *pNext;
60855 for(p=pPager->pMmapFreelist; p; p=pNext){
60856 pNext = p->pDirty;
61414 PgHdr *pNext = pList->pDirty;
61418 pList = pNext;
69470 BtLock *pNext; /* Next in BtShared.pLock list */
69508 Btree *pNext; /* List of other sharable Btrees from the same db */
69554 ** mutex, except for nRef and pNext which are accessed under the
69607 BtShared *pNext; /* Next on a list of sharable BtShared structs */
69693 BtCursor *pNext; /* Forms a linked list of all cursors */
69935 ** by all database connections. The p->pNext is a list of other
69938 ** p, then first unlock all of the others on p->pNext, then wait
69944 ** connected by pNext and pPrev should be in sorted order by
69947 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
69949 assert( p->pNext==0 || p->pNext->db==p->db );
69951 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
69994 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
69996 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
70003 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
70418 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
70453 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
70500 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
70564 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
70581 pLock->pNext = pBt->pLock;
70620 *ppIter = pLock->pNext;
70626 ppIter = &pLock->pNext;
70657 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
70707 for(p=pBt->pCursor; p; p=p->pNext){
70736 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
70945 for(p=pBt->pCursor; p; p=p->pNext){
70975 p = p->pNext;
72752 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
72880 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
72899 p->pNext = pSib;
72903 while( pSib->pNext && (uptr)pSib->pNext->pBt<(uptr)p->pBt ){
72904 pSib = pSib->pNext;
72906 p->pNext = pSib->pNext;
72908 if( p->pNext ){
72909 p->pNext->pPrev = p;
72911 pSib->pNext = p;
72970 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
72973 while( ALWAYS(pList) && pList->pNext!=pBt ){
72974 pList=pList->pNext;
72977 pList->pNext = pBt->pNext;
73006 pBt->pCursor = pCur->pNext; /* Unlink the cursor */
73058 pCur = pCur->pNext;
73096 if( p->pPrev ) p->pPrev->pNext = p->pNext;
73097 if( p->pNext ) p->pNext->pPrev = p->pPrev;
73597 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
73764 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
73843 p->lock.pNext = pBt->pLock;
74567 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
74827 for(pX=pBt->pCursor; pX; pX=pX->pNext){
74834 pCur->pNext = pBt->pCursor;
74907 pBt->pCursor = pCur->pNext;
74911 if( pPrev->pNext==pCur ){
74912 pPrev->pNext = pCur->pNext;
74915 pPrev = pPrev->pNext;
79110 for(pOther=pCur->pBt->pCursor; pOther; pOther=pOther->pNext){
81612 sqlite3_backup *pNext; /* Next backup associated with source pager */
81878 p->pNext = *pp;
82165 pp = &(*pp)->pNext;
82168 *pp = p->pNext;
82256 }while( (p = p->pNext)!=0 );
82275 for(p=pBackup; p; p=p->pNext){
85808 p->pNext = pVdbe->pProgram;
88062 SubProgram *pSub, *pNext;
88069 for(pSub=p->pProgram; pSub; pSub=pNext){
88070 pNext = pSub->pNext;
91907 sqlite3_stmt *pNext;
91916 pNext = (sqlite3_stmt*)pDb->pVdbe;
91918 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pVNext;
91921 return pNext;
93253 for(p=db->pSavepoint; p; p=p->pNext) n++;
96395 pNew->pNext = db->pSavepoint;
96410 pSavepoint = pSavepoint->pNext
96430 int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
96481 db->pSavepoint = pTmp->pNext;
96492 db->pSavepoint = pSavepoint->pNext;
101970 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
102443 ** are connected using SorterRecord.u.pNext. If aMemory!=0 then all objects
102692 ** SorterRecord.u.pNext pointers.
102700 ** converted to use the SorterRecord.u.pNext pointers. See function
102706 SorterRecord *pNext; /* Pointer to next record in list */
103297 SorterRecord *pNext;
103298 for(p=pRecord; p; p=pNext){
103299 pNext = p->u.pNext;
103625 pp = &p1->u.pNext;
103626 p1 = p1->u.pNext;
103633 pp = &p2->u.pNext;
103634 p2 = p2->u.pNext;
103677 SorterRecord *pNext;
103680 pNext = 0;
103683 pNext = (SorterRecord*)&pList->aMemory[p->u.iNext];
103686 pNext = p->u.pNext;
103689 p->u.pNext = 0;
103695 p = pNext;
103844 SorterRecord *pNext = 0;
103850 for(p=pList->pList; p; p=pNext){
103851 pNext = p->u.pNext;
104125 pNew->u.pNext = pSorter->list.pList;
104921 pSorter->list.pList = pFree->u.pNext;
104922 pFree->u.pNext = 0;
105519 FileChunk *pNext; /* Next chunk in the journal */
105585 pChunk=pChunk->pNext
105602 } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
105614 FileChunk *pNext;
105615 for(pIter=pFirst; pIter; pIter=pNext){
105616 pNext = pIter->pNext;
105635 for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
105713 pNew->pNext = 0;
105716 pChunk->pNext = pNew;
105741 assert( p->endpoint.pChunk==0 || p->endpoint.pChunk->pNext==0 );
105749 for(pIter=p->pFirst; ALWAYS(pIter) && iOff<size; pIter=pIter->pNext){
105753 memjrnlFreeChunks(pIter->pNext);
105754 pIter->pNext = 0;
106855 pNC = pNC->pNext;
106994 pTopNC = pTopNC->pNext;
107157 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
107168 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
107439 pNC2 = pNC2->pNext;
107701 pSelect->pNext = 0;
107703 pSelect->pPrior->pNext = pSelect;
107772 pSelect = pSelect->pNext;
108036 sNC.pNext = pOuterNC;
108101 sNC.pNext = 0;
108156 if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
108157 sqlite3SelectWrongNumTermsError(pParse, p->pNext);
108671 Expr *pNext = p->pRight;
108678 pNext = p->x.pList->a[i].pExpr;
108683 p = pNext;
110308 Select *pNext = 0;
110323 pNew->pNext = pNext;
110343 pNew->pNext = 0;
110349 pNext = pNew;
111483 for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){
116114 RenameToken *pNext; /* Next is a list of all RenameToken objects */
116160 for(p=pParse->pRename; p; p=p->pNext){
116198 pNew->pNext = pParse->pRename;
116214 for(p=pParse->pRename; p; p=p->pNext){
116359 RenameToken *pNext;
116361 for(p=pToken; p; p=pNext){
116362 pNext = p->pNext;
116385 for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){
116389 *pp = pToken->pNext;
116390 pToken->pNext = pCtx->pList;
116455 for(pToken=pBest->pNext; pToken; pToken=pToken->pNext){
116458 for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext);
116459 *pp = pBest->pNext;
116577 for(pToken=p->pRename; pToken; pToken=pToken->pNext){
116741 for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){
116835 for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
116867 pParse->pNewIndex = pIdx->pNext;
116980 for(pIdx=sParse.pNewTable->pIndex; pIdx; pIdx=pIdx->pNext){
116983 for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){
117018 for(pStep=sParse.pNewTrigger->step_list; pStep; pStep=pStep->pNext){
117233 for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
118209 0, /* pNext */
118503 0, /* pNext */
118645 0, /* pNext */
118777 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
119013 for(pX=pTab->pIndex; pX; pX=pX->pNext){
120147 0, /* pNext */
120167 0, /* pNext */
120338 pStep = pStep->pNext;
121204 pIndex->pTable->pIndex = pIndex->pNext;
121210 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
121211 if( ALWAYS(p && p->pNext==pIndex) ){
121212 p->pNext = pIndex->pNext;
121429 Index *pIndex, *pNext;
121447 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
121448 pNext = pIndex->pNext;
121700 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
122234 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
122577 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
123061 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
123390 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
123942 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
124012 pTrigger = pTrigger->pNext;
124699 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
124937 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
124972 pIndex->pNext = pParse->pNewIndex;
125084 pIndex->pNext = pTab->pIndex;
125104 for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
125105 Index *pNext;
125107 while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){
125108 *ppFrom = pNext;
125109 pThis->pNext = pNext->pNext;
125110 pNext->pNext = pThis;
125111 ppFrom = &pNext->pNext;
125119 for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){
125121 || pThis->pNext==0
125122 || pThis->pNext->onError==OE_Replace );
126056 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
126688 assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
126689 aDef[i].pNext = pOther->pNext;
126690 pOther->pNext = &aDef[i];
126692 aDef[i].pNext = 0;
126746 p = p->pNext;
126771 p = p->pNext;
126794 pBest->pNext = pOther;
126991 && (pTrigger==0 || (pTrigger->bReturning && pTrigger->pNext==0))
127269 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
127349 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
127781 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
130884 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
132102 FKey *pNext; /* Copy of pFKey->pNextFrom */
132106 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pNext){
132133 pNext = pFKey->pNextFrom;
132386 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
132574 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
132580 pInfo->pNext = pToplevel->pAinc;
132610 for(p = pParse->pAinc; p; p = p->pNext){
132677 for(p = pParse->pAinc; p; p = p->pNext){
133199 for(i=0, pIdx=pTab->pIndex; i<nIdx; pIdx=pIdx->pNext, i++){
133663 ** of a table in either Index.pNext order, or in some other order established
133669 int eType; /* 0 for Index.pNext list. 1 for an array of IndexListTerm */
133672 struct { /* Use this object for eType==0: A Index.pNext list */
133714 pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
134074 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
134090 pIdx = pIdx->pNext;
134099 for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){
134413 if( (ix==0 && pIdx->pNext==0) /* Condition 3 */
134721 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
134724 || pIdx->pNext==0
134725 || pIdx->pNext->onError==OE_Replace );
134824 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
135102 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
135106 for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
135235 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
135237 for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
138081 for(; p; p=p->pNext){
139077 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
139144 for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
139479 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; }
139493 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
139567 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
139775 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
139862 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
140211 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
140765 for(p=pIndex->pTable->pIndex; p; p=p->pNext){
141290 pParse->pCleanup = pCleanup->pNext;
141340 pCleanup->pNext = pParse->pCleanup;
141529 sParse.pTriggerPrg = pT->pNext;
141948 pNew->pNext = 0;
141979 while( p->pNext ) p = p->pNext;
143708 pNC = pNC->pNext;
143753 sNC.pNext = pNC;
143799 sNC.pNext = pNC;
143833 sNC.pNext = 0;
144128 if( pCol->affinity>=SQLITE_AFF_TEXT && pSelect->pNext ){
144131 for(m=0, pS2=pSelect->pNext; pS2; pS2=pS2->pNext){
144504 pSetup->pNext = 0;
144507 pSetup->pNext = p;
144589 assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr );
144594 assert( p->pPrior->pNext==p );
144604 p = p->pNext;
144934 if( p->pNext==0 ){
144957 assert( p->pNext==0 );
145376 assert( pSplit->pPrior->pNext==pSplit );
145388 pPrior->pNext = 0;
145548 pPrior->pNext = pSplit;
146341 if( pPrior ) pPrior->pNext = pNew;
146342 pNew->pNext = p;
147254 pIdx=pIdx->pNext
147333 p->pNext = 0;
147342 pNew->pPrior->pNext = pNew;
147564 assert( pRecTerm->pNext!=0 );
147565 assert( (pRecTerm->pNext->selFlags & SF_Recursive)!=0 );
148918 pSub->pNext = 0;
149352 if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
150196 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
150582 pTriggerStep = pTriggerStep->pNext;
150598 ** the table. The list is connected by Trigger.pNext pointers.
150626 pTrig->pNext = pList;
150636 pTrig->pNext = pList;
150645 for(pX=pList; pX; pX=pX->pNext){
150894 pStepList = pStepList->pNext;
150924 for(pStep=pTrig->step_list; pStep; pStep=pStep->pNext){
150965 pLink->pNext = pTab->pTrigger;
151281 for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){
151283 *pp = (*pp)->pNext;
151340 || (pList->bReturning && pList->pNext==0) );
151353 while( ALWAYS(p->pNext) && p->pNext!=pTab->pTrigger ) p = p->pNext;
151354 p->pNext = 0;
151381 p = p->pNext;
151614 for(pStep=pStepList; pStep; pStep=pStep->pNext){
151746 pPrg->pNext = pTop->pTriggerPrg;
151853 pPrg=pPrg->pNext
151960 for(p=pTrigger; p; p=p->pNext){
152030 for(p=pTrigger; p; p=p->pNext){
152477 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
152626 for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
153444 Upsert *pNext = p->pNextUpsert;
153451 p = pNext;
153482 Upsert *pNext /* Next ON CONFLICT clause in the list */
153491 sqlite3UpsertDelete(db, pNext);
153499 pNew->pNextUpsert = pNext;
153572 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
153640 Upsert *pNext;
153642 pNext = pUpsert->pNextUpsert;
153643 if( pNext==0 ) return 1;
153644 if( pNext->pUpsertTarget==0 ) return 1;
153645 if( pNext->pUpsertIdx==0 ) return 1;
154297 HashElem *pThis, *pNext;
154301 for(pThis=sqliteHashFirst(&db->aModule); pThis; pThis=pNext){
154303 pNext = sqliteHashNext(pThis);
154351 for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
154403 VTable *pNext = pVTable->pNext;
154408 pRet->pNext = 0;
154410 pVTable->pNext = db2->pDisconnect;
154413 pVTable = pNext;
154435 for(ppVTab=&p->u.vtab.p; *ppVTab; ppVTab=&(*ppVTab)->pNext){
154438 *ppVTab = pVTab->pNext;
154475 VTable *pNext = p->pNext;
154477 p = pNext;
154803 pVTable->pNext = pTab->u.vtab.p;
155023 assert( pIdx->pNext==0 );
155069 for(p=pTab->u.vtab.p; p; p=p->pNext){
155083 assert( pTab->u.vtab.p==p && p->pNext==0 );
155577 WhereMemBlock *pNext; /* Next block in the chain */
159933 for(pIdx=pFrom->a[j].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
159977 for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
161082 pBlock->pNext = pWInfo->pMemToFree;
161449 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
163245 WhereMemBlock *pNext = pWInfo->pMemToFree->pNext;
163247 pWInfo->pMemToFree = pNext;
164563 sPk.pNext = pFirst;
164628 pProbe=(pSrc->fg.isIndexedBy ? 0 : pProbe->pNext), iSortIdx++
166389 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
167330 pJ = pJ->pNext;
169006 Window *pNext = p->pNextWin;
169008 p = pNext;
171067 ** For a compound SELECT statement, make sure p->pPrior->pNext==p for
171074 Select *pNext = 0, *pLoop = p;
171077 pLoop->pNext = pNext;
171079 pNext = pLoop;
171086 sqlite3SelectOpName(pNext->op));
175699 yymsp[-2].minor.yy33->pLast->pNext = yymsp[-1].minor.yy33;
178999 p->pNext = db->lookaside.pInit;
179008 p->pNext = db->lookaside.pSmallInit;
179324 db->pSavepoint = pTmp->pNext;
179445 db->pDbData = p->pNext;
179565 FuncDef *pNext, *p;
179569 pNext = p->pNext;
179571 p = pNext;
181920 for(p=db->pDbData; p; p=p->pNext){
181943 for(p=db->pDbData; p && strcmp(p->zName,zName); p=p->pNext){
181944 pp = &p->pNext;
181950 *pp = p->pNext;
181967 p->pNext = db->pDbData;
189086 char *pNext = 0;
189095 pNext = pDocid;
189101 *pnList = (int)(pEnd - pNext);
189102 *ppIter = pNext;
194969 Fts3DeferredToken *pNext; /* Next in list of deferred tokens */
196171 char *pNext; /* Cursor variable */
196176 pNext = pReader->aNode;
196178 pNext = &pReader->aDoclist[pReader->nDoclist];
196181 if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){
196235 pNext = pReader->aNode;
196240 rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2);
196245 pNext += fts3GetVarint32(pNext, &nPrefix);
196246 pNext += fts3GetVarint32(pNext, &nSuffix);
196248 || (&pReader->aNode[pReader->nNode] - pNext)<nSuffix
196267 rc = fts3SegReaderRequire(pReader, pNext, nSuffix+FTS3_VARINT_MAX);
196270 memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
196272 pNext += nSuffix;
196273 pNext += fts3GetVarint32(pNext, &pReader->nDoclist);
196274 pReader->aDoclist = pNext;
200332 for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){
200344 Fts3DeferredToken *pNext;
200345 for(pDef=pCsr->pDeferred; pDef; pDef=pNext){
200346 pNext = pDef->pNext;
200388 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
200404 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
200456 pDeferred->pNext = pCsr->pDeferred;
208695 ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree
208887 RtreeNode *pNext; /* Next node in this hash collision chain */
209161 for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext);
209170 assert( pNode->pNext==0 );
209172 pNode->pNext = pRtree->aHash[iHash];
209183 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
209184 *pp = pNode->pNext;
209185 pNode->pNext = 0;
209281 pNode->pNext = 0;
211283 pNode->pNext = pRtree->pDeleted;
211495 pRtree->pDeleted = pLeaf->pNext;
213681 GeoEvent *pNext; /* Next event in the sorted list */
213689 GeoSegment *pNext; /* Next segment in a list sorted by y */
213765 head.pNext = 0;
213769 pLast->pNext = pRight;
213771 pRight = pRight->pNext;
213773 pLast->pNext = pLeft;
213775 pLeft = pLeft->pNext;
213778 pLast->pNext = pRight ? pRight : pLeft;
213779 return head.pNext;
213792 p->pNext = 0;
213812 head.pNext = 0;
213818 pLast->pNext = pRight;
213820 pRight = pRight->pNext;
213822 pLast->pNext = pLeft;
213824 pLeft = pLeft->pNext;
213827 pLast->pNext = pRight ? pRight : pLeft;
213828 return head.pNext;
213842 pList = pList->pNext;
213843 p->pNext = 0;
213897 for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){
213908 for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){
213937 pSeg->pNext = pActive;
213943 pActive = ALWAYS(pActive) ? pActive->pNext : 0;
213945 for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){
213946 if( pSeg->pNext==pThisEvent->pSeg ){
213947 pSeg->pNext = ALWAYS(pSeg->pNext) ? pSeg->pNext->pNext : 0;
213953 pThisEvent = pThisEvent->pNext;
216511 RbuUpdateStmt *pNext;
217102 RbuUpdateStmt *pTmp = pUp->pNext;
218879 for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
218882 *pp = pUp->pNext;
218883 pUp->pNext = pIter->pRbuUpdate;
218890 assert( pUp==0 || pUp->pNext==0 );
218893 for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
218908 pUp->pNext = pIter->pRbuUpdate;
221608 0, /* pNext */
223100 sqlite3_session *pNext; /* Next session object on same db. */
223178 SessionTable *pNext;
223362 SessionChange *pNext; /* For hash-table collisions */
224025 SessionChange *pNext;
224026 for(p=pTab->apChange[i]; p; p=pNext){
224029 pNext = p->pNext;
224030 p->pNext = apNew[iHash];
224553 for(pp=&pTab->apChange[ii]; *pp; pp=&((*pp)->pNext)){
224783 for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
224855 pC->pNext = pTab->apChange[iHash];
224895 for(pRet=pSession->pTable; pRet; pRet=pRet->pNext){
224908 while( ALWAYS(pRet) && pRet->pNext ){
224909 pRet = pRet->pNext;
224941 for(pSession=(sqlite3_session *)pCtx; pSession; pSession=pSession->pNext){
225334 pNew->pNext = pOld;
225346 SessionTable *pNext;
225349 for(pTab=pList; pTab; pTab=pNext){
225351 pNext = pTab->pNext;
225356 pNextChange = p->pNext;
225379 for(pp=&pHead; ALWAYS((*pp)!=0); pp=&((*pp)->pNext)){
225381 *pp = (*pp)->pNext;
225434 for(pTab=pSession->pTable; pTab; pTab=pTab->pNext){
225454 for(ppTab=&pSession->pTable; *ppTab; ppTab=&(*ppTab)->pNext);
226037 for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
226066 for(p=pTab->apChange[i]; rc==SQLITE_OK && p; p=p->pNext){
226225 for(pTab=pSession->pTable; pTab && ret==0; pTab=pTab->pNext){
227243 SessionUpdate *pNext;
227317 *pp = pUp->pNext;
227318 pUp->pNext = p->pUp;
227323 if( (*pp)->pNext ){
227324 pp = &(*pp)->pNext;
227396 pUp->pNext = p->pUp;
227418 SessionUpdate *pNext;
227419 for(pUp=p->pUp; pUp; pUp=pNext){
227420 pNext = pUp->pNext;
228811 for(pTab = pGrp->pList; pTab; pTab=pTab->pNext){
228843 for(ppTab=&pGrp->pList; *ppTab; ppTab=&(*ppTab)->pNext);
228872 for(pp=&pTab->apChange[iHash]; *pp; pp=&(*pp)->pNext){
228881 *pp = (*pp)->pNext;
228892 pChange->pNext = pTab->apChange[iHash];
228936 for(pTab=pGrp->pList; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
228943 for(p=pTab->apChange[i]; p; p=p->pNext){
229288 for(pTab=p->grp.pList; pTab; pTab=pTab->pNext){
229308 for(pChange=pTab->apChange[iHash]; pChange; pChange=pChange->pNext){
233625 Fts5TermsetEntry *pNext;
233661 for(pEntry=p->apHash[hash]; pEntry; pEntry=pEntry->pNext){
233678 pEntry->pNext = p->apHash[hash];
233694 pEntry = pEntry->pNext;
236015 Fts5ExprNode *pNext = pNode->apChild[0];
236020 int cmp = fts5NodeCompare(pExpr, pNext, pChild);
236022 pNext = pChild;
236025 pNode->iRowid = pNext->iRowid;
236026 pNode->bEof = pNext->bEof;
236027 pNode->bNomatch = pNext->bNomatch;
236349 Fts5ExprTerm *pNext;
236353 for(pSyn=pTerm->pSynonym; pSyn; pSyn=pNext){
236354 pNext = pSyn->pSynonym;
238134 Fts5HashEntry *pNext;
238136 for(pSlot=pHash->aSlot[i]; pSlot; pSlot=pNext){
238137 pNext = pSlot->pHashNext;
244610 PrefixMerger *pNext; /* Next in docid/poslist order */
244620 pp = &(*pp)->pNext;
244622 p->pNext = *pp;
244634 pp = &(*pp)->pNext;
244636 p->pNext = *pp;
244695 if( pHead->pNext && iLastRowid==pHead->pNext->iter.iRowid ){
244706 PrefixMerger *pNext = pSave->pNext;
244714 pSave = pNext;
244717 if( pHead==0 || pHead->pNext==0 ){
244731 pHead = pThis->pNext;
244736 while( pHead->pNext ){
244742 pHead = pThis->pNext;
244779 pHead = pThis->pNext;
247757 Fts5Auxiliary *pNext; /* Next registered auxiliary function */
247770 Fts5TokenizerModule *pNext; /* Next registered tokenizer module */
247829 Fts5Cursor *pNext; /* Next cursor in Fts5Cursor.pCsr list */
247903 Fts5Auxdata *pNext; /* Next object in linked list */
248354 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
248378 pCsr->pNext = pGlobal->pCsr;
248413 Fts5Auxdata *pNext;
248431 for(pData=pCsr->pAuxdata; pData; pData=pNext){
248432 pNext = pData->pNext;
248462 for(pp=&pTab->pGlobal->pCsr; (*pp)!=pCsr; pp=&(*pp)->pNext);
248463 *pp = pCsr->pNext;
248515 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
248767 for(pAux=pTab->pGlobal->pAux; pAux; pAux=pAux->pNext){
249843 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
249859 pData->pNext = pCsr->pAuxdata;
249873 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
250132 for(pCsr=pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
250430 pAux->pNext = pGlobal->pAux;
250467 pNew->pNext = pGlobal->pTok;
250469 if( pNew->pNext==0 ){
250488 for(pMod=pGlobal->pTok; pMod; pMod=pMod->pNext){
250564 pNextAux = pAux->pNext;
250570 pNextTok = pTok->pNext;
255419 StmtRow *pNext; /* Next row to return */
255519 StmtRow *pNext = 0;
255520 for(pRow=pCur->pRow; pRow; pRow=pNext){
255521 pNext = pRow->pNext;
255542 StmtRow *pNext = pCur->pRow->pNext;
255544 pCur->pRow = pNext;
255645 ppRow = &pNew->pNext;