Lines Matching defs:pnext
1436 ** the pNext pointer. The [sqlite3_vfs_register()]
1440 ** implementation should use the pNext pointer.
1442 ** The pNext field is the only field in the sqlite3_vfs
1579 sqlite3_vfs *pNext; /* Next registered VFS */
8506 SubProgram *pNext; /* Next sub-program already visited */
9697 LookasideSlot *pNext; /* Next buffer in the list of free buffers */
9894 FuncDef *pNext; /* Next function with same name */
9979 Savepoint *pNext; /* Parent savepoint (if any) */
10141 VTable *pNext; /* Next in linked list (see above) */
10377 Index *pNext; /* The next index associated with the same table */
10904 ** Each subquery gets a new NameContext. The pNext field points to the
10920 NameContext *pNext; /* Next outer name context. NULL for outermost */
10957 Select *pNext; /* Next select to the left in a compound */
11019 AutoincInfo *pNext; /* Next info block in a list of them all */
11052 TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
11208 * pNext member of struct Trigger. A pointer to the first element of the
11226 Trigger *pNext; /* Next trigger associated with the table */
11244 * using the "pNext" member) referenced by the "step_list" member of the
11286 TriggerStep *pNext; /* Next in the link-list */
13134 Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
13497 for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
14959 for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
14975 vfsList = pVfs->pNext;
14978 while( p->pNext && p->pNext!=pVfs ){
14979 p = p->pNext;
14981 if( p->pNext==pVfs ){
14982 p->pNext = pVfs->pNext;
15002 pVfs->pNext = vfsList;
15005 pVfs->pNext = vfsList->pNext;
15006 vfsList->pNext = pVfs;
15514 struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
15717 pHdr->pNext = 0;
15720 mem.pLast->pNext = pHdr;
15769 assert( pHdr->pPrev->pNext==pHdr );
15770 pHdr->pPrev->pNext = pHdr->pNext;
15773 mem.pFirst = pHdr->pNext;
15775 if( pHdr->pNext ){
15776 assert( pHdr->pNext->pPrev==pHdr );
15777 pHdr->pNext->pPrev = pHdr->pPrev;
15922 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
15944 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
18625 struct ScratchFreeslot *pNext; /* Next unused scratch buffer */
18761 pSlot->pNext = (ScratchFreeslot*)(sz+(char*)pSlot);
18762 pSlot = pSlot->pNext;
18764 pSlot->pNext = 0;
18942 mem0.pScratchFree = mem0.pScratchFree->pNext;
18990 pSlot->pNext = mem0.pScratchFree;
19079 pBuf->pNext = db->lookaside.pFree;
19212 db->lookaside.pFree = pBuf->pNext;
23632 ** pNext
23647 os2ShmNode *pNext; /* Next in list of all os2ShmNode objects */
23677 os2ShmLink *pNext; /* Next os2Shm with the same os2ShmNode */
23790 pNode = pNode->pNext ) ;
23825 pNode->pNext = os2ShmNodeList;
23841 pLink->pNext = pNode->pFirst;
23879 *ppNode = pNode->pNext;
23921 ppNode = &pNode->pNext;
24055 ppLink = &(*ppLink)->pNext ) ;
24060 *ppLink = pLink->pNext;
24118 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
24143 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
24168 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
24774 0, /* pNext */
25014 UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
25801 struct vxworksFileId *pNext; /* Next in a list of them all */
25879 for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
25893 pNew->pNext = vxworksFileList;
25909 for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
25911 *pp = pId->pNext;
26042 unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
26154 UnixUnusedFd *pNext;
26155 for(p=pInode->pUnused; p; p=pNext){
26156 pNext = p->pNext;
26178 assert( pInode->pPrev->pNext==pInode );
26179 pInode->pPrev->pNext = pInode->pNext;
26182 inodeList = pInode->pNext;
26184 if( pInode->pNext ){
26185 assert( pInode->pNext->pPrev==pInode );
26186 pInode->pNext->pPrev = pInode->pPrev;
26262 pInode = pInode->pNext;
26272 pInode->pNext = inodeList;
26629 p->pNext = pInode->pUnused;
28748 unixShm *pNext
29018 p->pNext = pShmNode->pFirst;
29201 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29226 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29251 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29316 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
29317 *pp = p->pNext;
29942 pInode = pInode->pNext;
29946 for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
29949 *pp = pUnused->pNext;
31855 0, /* pNext */ \
31879 ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
34416 ** pNext
34443 winShmNode *pNext; /* Next in list of all winShmNode objects */
34471 winShm *pNext; /* Next winShm with the same winShmNode */
34577 *pp = p->pNext;
34581 pp = &p->pNext;
34623 for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){
34635 pShmNode->pNext = winShmNodeList;
34687 p->pNext = pShmNode->pFirst;
34723 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
34724 *pp = p->pNext;
34775 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
34800 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
34825 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
35798 0, /* pNext */
36685 PgHdr *pNext;
36686 for(p=pCache->pDirty; p; p=pNext){
36687 pNext = p->pDirtyNext;
36970 PgHdr1 *pNext; /* Next in hash table chain */
36981 PgFreeslot *pNext; /* Next free slot */
37048 p->pNext = pcache1.pFree;
37073 pcache1.pFree = pcache1.pFree->pNext;
37108 pSlot->pNext = pcache1.pFree;
37273 PgHdr1 *pNext = p->apHash[i];
37274 while( (pPage = pNext)!=0 ){
37276 pNext = pPage->pNext;
37277 pPage->pNext = apNew[h];
37339 for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
37340 *pp = (*pp)->pNext;
37380 *pp = pPage->pNext;
37384 pp = &pPage->pNext;
37601 for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
37678 pPage->pNext = pCache->apHash[h];
37758 pp = &(*pp)->pNext;
37760 *pp = pPage->pNext;
37764 pPage->pNext = pCache->apHash[h];
41404 PgHdr *pNext = pList->pDirty;
41406 pList = pNext;
48781 BtLock *pNext; /* Next in BtShared.pLock list */
48817 Btree *pNext; /* List of other sharable Btrees from the same db */
48846 ** mutex, except for nRef and pNext which are accessed under the
48897 BtShared *pNext; /* Next on a list of sharable BtShared structs */
48960 BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */
49164 pNext is a list of other
49167 ** p, then first unlock all of the others on p->pNext, then wait
49175 ** connected by pNext and pPrev should be in sorted order by
49178 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
49180 assert( p->pNext==0 || p->pNext->db==p->db );
49182 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
49214 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
49216 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
49223 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
49561 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
49596 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
49643 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49707 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49724 pLock->pNext = pBt->pLock;
49763 *ppIter = pLock->pNext;
49769 ppIter = &pLock->pNext;
49800 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
49840 for(p=pBt->pCursor; p; p=p->pNext){
49866 for(p=pBt->pCursor; p; p=p->pNext){
50012 for(p=pBt->pCursor; p; p=p->pNext){
50692 int pnext, psize, x;
50695 pnext = get2byte(&data[pbegin]);
50697 if( pbegin + psize + 3 >= pnext && pnext>0 ){
50698 int frag = pnext - (pbegin+psize);
50703 x = get2byte(&data[pnext]);
50705 x = pnext + get2byte(&data[pnext+2]) - pbegin;
51174 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
51291 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
51310 p->pNext = pSib;
51314 while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
51315 pSib = pSib->pNext;
51317 p->pNext = pSib->pNext;
51319 if( p->pNext ){
51320 p->pNext->pPrev = p;
51322 pSib->pNext = p;
51373 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
51376 while( ALWAYS(pList) && pList->pNext!=pBt ){
51377 pList=pList->pNext;
51380 pList->pNext = pBt->pNext;
51426 pCur = pCur->pNext;
51463 if( p->pPrev ) p->pPrev->pNext = p->pNext;
51464 if( p->pNext ) p->pNext->pPrev = p->pPrev;
51970 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
52026 p->lock.pNext = pBt->pLock;
52648 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
52676 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
52889 pCur->pNext = pBt->pCursor;
52890 if( pCur->pNext ){
52891 pCur->pNext->pPrev = pCur;
52950 for(p=pCur->pBt->pCursor; p; p=p->pNext){
52978 pCur->pPrev->pNext = pCur->pNext;
52980 pBt->pCursor = pCur->pNext;
52982 if( pCur->pNext ){
52983 pCur->pNext->pPrev = pCur->pPrev;
57708 sqlite3_backup *pNext; /* Next backup associated with source pager */
57980 p->pNext = *pp;
58227 pp = &(*pp)->pNext;
58229 *pp = p->pNext;
58284 for(p=pBackup; p; p=p->pNext){
58317 for(p=pBackup; p; p=p->pNext){
59581 p->pNext = db->pVdbe;
59619 pTmp = pA->pNext;
59620 pA->pNext = pB->pNext;
59621 pB->pNext = pTmp;
60204 p->pNext = pVdbe->pProgram;
61534 p = p->pNext;
61979 SubProgram *pSub, *pNext;
61984 for(pSub=p->pProgram; pSub; pSub=pNext){
61985 pNext = pSub->pNext;
62011 p->pPrev->pNext = p->pNext;
62014 db->pVdbe = p->pNext;
62016 if( p->pNext ){
62017 p->pNext->pPrev = p->pPrev;
62725 for(p = db->pVdbe; p; p=p->pNext){
64070 sqlite3_stmt *pNext;
64073 pNext = (sqlite3_stmt*)pDb->pVdbe;
64075 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
64078 return pNext;
64947 for(p=db->pSavepoint; p; p=p->pNext) n++;
67576 u.ar.pNew->pNext = db->pSavepoint;
67589 u.ar.pSavepoint = u.ar.pSavepoint->pNext
67610 int isTransaction = u.ar.pSavepoint->pNext==0 && db->isTransactionSavepoint;
67646 db->pSavepoint = u.ar.pTmp->pNext;
67657 db->pSavepoint = u.ar.pSavepoint->pNext;
69654 for(u.bv.pVdbe=db->pVdbe; u.bv.pVdbe; u.bv.pVdbe = u.bv.pVdbe->pNext){
71437 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
71798 ** SorterRecord.pNext pointer.
71803 SorterRecord *pNext;
72089 SorterRecord *pNext;
72090 for(p=pRecord; p; p=pNext){
72091 pNext = p->pNext;
72152 pp = &p1->pNext;
72153 p1 = p1->pNext;
72157 pp = &p2->pNext;
72158 p2 = p2->pNext;
72185 SorterRecord *pNext = p->pNext;
72186 p->pNext = 0;
72192 p = pNext;
72241 SorterRecord *pNext = 0;
72246 for(p=pSorter->pRecord; rc==SQLITE_OK && p; p=pNext){
72247 pNext = p->pNext;
72299 pNew->pNext = pSorter->pRecord;
72482 pSorter->pRecord = pFree->pNext;
72483 pFree->pNext = 0;
72847 FileChunk *pNext; /* Next chunk in the journal */
72894 pChunk=pChunk->pNext
72910 } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
72947 pNew->pNext = 0;
72950 pChunk->pNext = pNew;
72978 pChunk = pChunk->pNext;
73533 pNC = pNC->pNext;
73604 pTopNC = pTopNC->pNext;
73964 pSelect->pNext = 0;
73966 pSelect->pPrior->pNext = pSelect;
74010 pSelect = pSelect->pNext;
74189 sNC.pNext = pOuterNC;
74215 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;
74222 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
74264 sNC.pNext = 0;
75386 if( pPrior ) pPrior->pNext = pNew;
75387 pNew->pNext = 0;
75934 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
78777 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
78815 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
79572 0, /* pNext */
79665 0, /* pNext */
79707 0, /* pNext */
79792 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
80804 0, /* pNext */
80826 0, /* pNext */
80975 pStep = pStep->pNext;
81612 pIndex->pTable->pIndex = pIndex->pNext;
81618 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
81619 if( ALWAYS(p && p->pNext==pIndex) ){
81620 p->pNext = pIndex->pNext;
81739 Index *pIndex, *pNext;
81748 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
81749 pNext = pIndex->pNext;
82471 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
83166 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83196 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83266 pTrigger = pTrigger->pNext;
83838 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
84010 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
84145 pIndex->pNext = pTab->pIndex;
84149 while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
84150 pOther = pOther->pNext;
84152 pIndex->pNext = pOther->pNext;
84153 pOther->pNext = pIndex;
84909 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
85341 assert( pOther!=pDef && pOther->pNext!=pDef );
85342 pDef->pNext = pOther->pNext;
85343 pNext = pDef;
85345 pDef->pNext = 0;
85399 p = p->pNext;
85424 p = p->pNext;
85807 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85863 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85927 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
86103 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
88002 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
88962 FKey *pNext; /* Copy of pFKey->pNextFrom */
88965 for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
88992 pNext = pFKey->pNextFrom;
89151 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
89200 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
89204 pInfo->pNext = pToplevel->pAinc;
89235 for(p = pParse->pAinc; p; p = p->pNext){
89283 for(p = pParse->pAinc; p; p = p->pNext){
90015 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
90313 for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
90444 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
90499 for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
90713 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
90717 for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
90805 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
90806 for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
93083 pIdx = pIdx->pNext;
93259 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
93297 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
93324 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
94347 pParse->pTriggerPrg = pT->pNext;
95572 pNC = pNC->pNext;
95611 sNC.pNext = pNC;
95646 sNC.pNext = pNC;
97700 pIdx=pIdx->pNext
98448 pLoop->pNext = pRight;
98929 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
99138 p = p->pNext;
99372 pTriggerStep = pTriggerStep->pNext;
99385 ** the table. The list is connected by Trigger.pNext pointers.
99413 pTrig->pNext = (pList ? pList : pTab->pTrigger);
99640 pStepList = pStepList->pNext;
99683 pLink->pNext = pTab->pTrigger;
99961 for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));
99962 *pp = (*pp)->pNext;
100008 for(p=pList; p; p=p->pNext){
100066 for(pStep=pStepList; pStep; pStep=pStep->pNext){
100188 pPrg->pNext = pTop->pTriggerPrg;
100294 pPrg=pPrg->pNext
100400 for(p=pTrigger; p; p=p->pNext){
100459 for(p=pTrigger; p; p=p->pNext){
100655 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100716 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
100721 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
100827 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100834 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
101009 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
101618 for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
101665 VTable *pNext = pVTable->pNext;
101670 pRet->pNext = 0;
101672 pVTable->pNext = db2->pDisconnect;
101675 pVTable = pNext;
101713 VTable *pNext = p->pNext;
101715 p = pNext;
102004 pVTable->pNext = pTab->pVTable;
102237 assert( pTab->pVTable==p && p->pNext==0 );
104131 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
105499 sPk.pNext = pFirst;
105511 for(; pProbe; pIdx=pProbe=pProbe->pNext){
110864 yymsp[-2].minor.yy327->pLast->pNext = yymsp[-1].minor.yy327;
112085 pParse->pAinc = p->pNext;
112987 p->pNext = db->lookaside.pFree;
113170 db->pSavepoint = pTmp->pNext;
113264 FuncDef *pNext, *pHash, *p;
113269 pNext = p->pNext;
113271 p = pNext;
120587 char *pNext = 0;
120596 pNext = pDocid;
120602 *pnList = (int)(pEnd - pNext);
120603 *ppIter = pNext;
125195 Fts3DeferredToken *pNext; /* Next in list of deferred tokens */
126302 char *pNext; /* Cursor variable */
126307 pNext = pReader->aNode;
126309 pNext = &pReader->aDoclist[pReader->nDoclist];
126312 if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){
126349 pNext = pReader->aNode;
126354 rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2);
126359 pNext += sqlite3Fts3GetVarint32(pNext, &nPrefix);
126360 pNext += sqlite3Fts3GetVarint32(pNext, &nSuffix);
126362 || &pNext[nSuffix]>&pReader->aNode[pReader->nNode]
126377 rc = fts3SegReaderRequire(pReader, pNext, nSuffix+FTS3_VARINT_MAX);
126380 memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
126382 pNext += nSuffix;
126383 pNext += sqlite3Fts3GetVarint32(pNext, &pReader->nDoclist);
126384 pReader->aDoclist = pNext;
128318 for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){
128330 Fts3DeferredToken *pNext;
128331 for(pDef=pCsr->pDeferred; pDef; pDef=pNext){
128332 pNext = pDef->pNext;
128373 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
128388 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
128440 pDeferred->pNext = pCsr->pDeferred;
130318 ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree
130424 RtreeNode *pNext; /* Next node in this hash chain */
130573 for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext);
130582 assert( pNode->pNext==0 );
130584 pNode->pNext = pRtree->aHash[iHash];
130595 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
130596 *pp = pNode->pNext;
130597 pNode->pNext = 0;
130663 pNode->pNext = 0;
132287 RtreeCell *pNext;
132288 pNext = PickNext(pRtree, aCell, nCell, pBboxLeft, pBboxRight, aiUsed);
132290 cellGrowth(pRtree, pBboxLeft, pNext) -
132291 cellGrowth(pRtree, pBboxRight, pNext)
132296 nodeInsertCell(pRtree, pRight, pNext);
132297 cellUnion(pRtree, pBboxRight, pNext);
132299 nodeInsertCell(pRtree, pLeft, pNext);
132300 cellUnion(pRtree, pBboxLeft, pNext);
132548 pNode->pNext = pRtree->pDeleted;
132864 pRtree->pDeleted = pLeaf->pNext;
