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 */
25007 UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
25783 struct vxworksFileId *pNext; /* Next in a list of them all */
25861 for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
25875 pNew->pNext = vxworksFileList;
25891 for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
25893 *pp = pId->pNext;
26024 unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
26136 UnixUnusedFd *pNext;
26137 for(p=pInode->pUnused; p; p=pNext){
26138 pNext = p->pNext;
26160 assert( pInode->pPrev->pNext==pInode );
26161 pInode->pPrev->pNext = pInode->pNext;
26164 inodeList = pInode->pNext;
26166 if( pInode->pNext ){
26167 assert( pInode->pNext->pPrev==pInode );
26168 pInode->pNext->pPrev = pInode->pPrev;
26244 pInode = pInode->pNext;
26254 pInode->pNext = inodeList;
26611 p->pNext = pInode->pUnused;
28728 unixShm *pNext; /* Next unixShm with the same unixShmNode */
28998 p->pNext = pShmNode->pFirst;
29173 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29198 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29223 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29288 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
29289 *pp = p->pNext;
29914 pInode = pInode->pNext;
29918 for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
29921 *pp = pUnused->pNext;
31827 0, /* pNext */ \
31851 ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
34388 ** pNext
34415 winShmNode *pNext; /* Next in list of all winShmNode objects */
34443 winShm *pNext; /* Next winShm with the same winShmNode */
34549 *pp = p->pNext;
34553 pp = &p->pNext;
34595 for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){
34607 pShmNode->pNext = winShmNodeList;
34659 p->pNext = pShmNode->pFirst;
34695 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
34696 *pp = p->pNext;
34747 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
34772 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
34797 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
35770 0, /* pNext */
36657 PgHdr *pNext;
36658 for(p=pCache->pDirty; p; p=pNext){
36659 pNext = p->pDirtyNext;
36942 PgHdr1 *pNext; /* Next in hash table chain */
36953 PgFreeslot *pNext; /* Next free slot */
37020 p->pNext = pcache1.pFree;
37045 pcache1.pFree = pcache1.pFree->pNext;
37080 pSlot->pNext = pcache1.pFree;
37245 PgHdr1 *pNext = p->apHash[i];
37246 while( (pPage = pNext)!=0 ){
37248 pNext = pPage->pNext;
37249 pPage->pNext = apNew[h];
37311 for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
37312 *pp = (*pp)->pNext;
37352 *pp = pPage->pNext;
37356 pp = &pPage->pNext;
37573 for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
37650 pPage->pNext = pCache->apHash[h];
37730 pp = &(*pp)->pNext;
37732 *pp = pPage->pNext;
37736 pPage->pNext = pCache->apHash[h];
41376 PgHdr *pNext = pList->pDirty;
41378 pList = pNext;
48753 BtLock *pNext; /* Next in BtShared.pLock list */
48789 Btree *pNext; /* List of other sharable Btrees from the same db */
48818 ** mutex, except for nRef and pNext which are accessed under the
48869 BtShared *pNext; /* Next on a list of sharable BtShared structs */
48932 BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */
49136 ** by all database connections. The p->pNext is a list of other
49139 ** p, then first unlock all of the others on p->pNext, then wait
49147 ** connected by pNext and pPrev should be in sorted order by
49150 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
49152 assert( p->pNext==0 || p->pNext->db==p->db );
49154 assert( p->sharable || (p->pNext
49186 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
49188 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
49195 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
49533 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
49568 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
49615 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49679 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49696 pLock->pNext = pBt->pLock;
49735 *ppIter = pLock->pNext;
49741 ppIter = &pLock->pNext;
49772 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
49812 for(p=pBt->pCursor; p; p=p->pNext){
49838 for(p=pBt->pCursor; p; p=p->pNext){
49984 for(p=pBt->pCursor; p; p=p->pNext){
50664 int pnext, psize, x;
50667 pnext = get2byte(&data[pbegin]);
50669 if( pbegin + psize + 3 >= pnext && pnext>0 ){
50670 int frag = pnext - (pbegin+psize);
50675 x = get2byte(&data[pnext]);
50677 x = pnext + get2byte(&data[pnext+2]) - pbegin;
51146 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
51263 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
51282 p->pNext = pSib;
51286 while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
51287 pSib = pSib->pNext;
51289 p->pNext = pSib->pNext;
51291 if( p->pNext ){
51292 p->pNext->pPrev = p;
51294 pSib->pNext = p;
51345 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
51348 while( ALWAYS(pList) && pList->pNext!=pBt ){
51349 pList=pList->pNext;
51352 pList->pNext = pBt->pNext;
51398 pCur = pCur->pNext;
51435 if( p->pPrev ) p->pPrev->pNext = p->pNext;
51436 if( p->pNext ) p->pNext->pPrev = p->pPrev;
51942 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
51998 p->lock.pNext = pBt->pLock;
52620 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
52648 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
52861 pCur->pNext = pBt->pCursor;
52862 if( pCur->pNext ){
52863 pCur->pNext->pPrev = pCur;
52922 for(p=pCur->pBt->pCursor; p; p=p->pNext){
52950 pCur->pPrev->pNext = pCur->pNext;
52952 pBt->pCursor = pCur->pNext;
52954 if( pCur->pNext ){
52955 pCur->pNext->pPrev = pCur->pPrev;
57680 sqlite3_backup *pNext; /* Next backup associated with source pager */
57952 p->pNext = *pp;
58199 pp = &(*pp)->pNext;
58201 *pp = p->pNext;
58256 for(p=pBackup; p; p=p->pNext){
58289 for(p=pBackup; p; p=p->pNext){
59553 p->pNext = db->pVdbe;
59591 pTmp = pA->pNext;
59592 pA->pNext = pB->pNext;
59593 pB->pNext = pTmp;
60176 p->pNext = pVdbe->pProgram;
61506 p = p->pNext;
61951 SubProgram *pSub, *pNext;
61956 for(pSub=p->pProgram; pSub; pSub=pNext){
61957 pNext = pSub->pNext;
61983 p->pPrev->pNext = p->pNext;
61986 db->pVdbe = p->pNext;
61988 if( p->pNext ){
61989 p->pNext->pPrev = p->pPrev;
62697 for(p = db->pVdbe; p; p=p->pNext){
64042 sqlite3_stmt *pNext;
64045 pNext = (sqlite3_stmt*)pDb->pVdbe;
64047 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
64050 return pNext;
64919 for(p=db->pSavepoint; p; p=p->pNext) n++;
67548 u.ar.pNew->pNext = db->pSavepoint;
67561 u.ar.pSavepoint = u.ar.pSavepoint->pNext
67582 int isTransaction = u.ar.pSavepoint->pNext==0 && db->isTransactionSavepoint;
67618 db->pSavepoint = u.ar.pTmp->pNext;
67629 db->pSavepoint = u.ar.pSavepoint->pNext;
69626 for(u.bv.pVdbe=db->pVdbe; u.bv.pVdbe; u.bv.pVdbe = u.bv.pVdbe->pNext){
71409 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
71770 ** SorterRecord.pNext pointer.
71775 SorterRecord *pNext;
72061 SorterRecord *pNext;
72062 for(p=pRecord; p; p=pNext){
72063 pNext = p->pNext;
72124 pp = &p1->pNext;
72125 p1 = p1->pNext;
72129 pp = &p2->pNext;
72130 p2 = p2->pNext;
72157 SorterRecord *pNext = p->pNext;
72158 p->pNext = 0;
72164 p = pNext;
72213 SorterRecord *pNext = 0;
72218 for(p=pSorter->pRecord; rc==SQLITE_OK && p; p=pNext){
72219 pNext = p->pNext;
72271 pNew->pNext = pSorter->pRecord;
72454 pSorter->pRecord = pFree->pNext;
72455 pFree->pNext = 0;
72811 FileChunk *pNext; /* Next chunk in the journal */
72858 pChunk=pChunk->pNext
72874 } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
72911 pNew->pNext = 0;
72914 pChunk->pNext = pNew;
72942 pChunk = pChunk->pNext;
73497 pNC = pNC->pNext;
73568 pTopNC = pTopNC->pNext;
73928 pSelect->pNext = 0;
73930 pSelect->pPrior->pNext = pSelect;
73974 pSelect = pSelect->pNext;
74153 sNC.pNext = pOuterNC;
74179 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;
74186 for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
74228 sNC.pNext = 0;
75350 if( pPrior ) pPrior->pNext = pNew;
75351 pNew->pNext = 0;
75898 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
78741 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
78779 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
79536 0, /* pNext */
79629 0, /* pNext */
79671 0, /* pNext */
79756 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
80768 0, /* pNext */
80790 0, /* pNext */
80939 pStep = pStep->pNext;
81576 pIndex->pTable->pIndex = pIndex->pNext;
81582 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
81583 if( ALWAYS(p && p->pNext==pIndex) ){
81584 p->pNext = pIndex->pNext;
81703 Index *pIndex, *pNext;
81712 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
81713 pNext = pIndex->pNext;
82435 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
83130 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83160 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83230 pTrigger = pTrigger->pNext;
83802 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
83974 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
84109 pIndex->pNext = pTab->pIndex;
84113 while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
84114 pOther = pOther->pNext;
84116 pIndex->pNext = pOther->pNext;
84117 pOther->pNext = pIndex;
84873 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
85305 assert( pOther!=pDef && pOther->pNext!=pDef );
85306 pDef->pNext = pOther->pNext;
85307 pOther->pNext = pDef;
85309 pDef->pNext = 0;
85363 p = p->pNext;
85388 p = p->pNext;
85771 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85827 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85891 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
86067 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
87966 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
88926 FKey *pNext; /* Copy of pFKey->pNextFrom */
88929 for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
88956 pNext = pFKey->pNextFrom;
89115 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
89164 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
89168 pInfo->pNext = pToplevel->pAinc;
89199 for(p = pParse->pAinc; p; p = p->pNext){
89247 for(p = pParse->pAinc; p; p = p->pNext){
89979 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
90277 for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
90408 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
90463 for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
90677 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
90681 for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
90769 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
90770 for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
93047 pIdx = pIdx->pNext;
93223 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
93261 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
93288 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
94311 pParse->pTriggerPrg = pT->pNext;
95536 pNC = pNC->pNext;
95575 sNC.pNext = pNC;
95610 sNC.pNext = pNC;
97664 pIdx=pIdx->pNext
98412 pLoop->pNext = pRight;
98893 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
99102 p = p->pNext;
99336 pTriggerStep = pTriggerStep->pNext;
99349 ** the table. The list is connected by Trigger.pNext pointers.
99377 pTrig->pNext = (pList ? pList : pTab->pTrigger);
99604 pStepList = pStepList->pNext;
99647 pLink->pNext = pTab->pTrigger;
99925 for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));
99926 *pp = (*pp)->pNext;
99972 for(p=pList; p; p=p->pNext){
100030 for(pStep=pStepList; pStep; pStep=pStep->pNext){
100152 pPrg->pNext = pTop->pTriggerPrg;
100258 pPrg=pPrg->pNext
100364 for(p=pTrigger; p; p=p->pNext){
100423 for(p=pTrigger; p; p=p->pNext){
100619 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100680 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
100685 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
100791 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100798 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
100973 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
101582 for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
101629 VTable *pNext = pVTable->pNext;
101634 pRet->pNext = 0;
101636 pVTable->pNext = db2->pDisconnect;
101639 pVTable = pNext;
101677 VTable *pNext = p->pNext;
101679 p = pNext;
101968 pVTable->pNext = pTab->pVTable;
102201 assert( pTab->pVTable==p && p->pNext==0 );
104095 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
105463 sPk.pNext = pFirst;
105475 for(; pProbe; pIdx=pProbe=pProbe->pNext){
110828 yymsp[-2].minor.yy327->pLast->pNext = yymsp[-1].minor.yy327;
112049 pParse->pAinc = p->pNext;
112951 p->pNext = db->lookaside.pFree;
113134 db->pSavepoint = pTmp->pNext;
113228 FuncDef *pNext, *pHash, *p;
113233 pNext = p->pNext;
113235 p = pNext;
120539 char *pNext = 0;
120548 pNext = pDocid;
120554 *pnList = (int)(pEnd - pNext);
120555 *ppIter = pNext;
125147 Fts3DeferredToken *pNext; /* Next in list of deferred tokens */
126254 char *pNext
126259 pNext = pReader->aNode;
126261 pNext = &pReader->aDoclist[pReader->nDoclist];
126264 if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){
126301 pNext = pReader->aNode;
126306 rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2);
126311 pNext += sqlite3Fts3GetVarint32(pNext, &nPrefix);
126312 pNext += sqlite3Fts3GetVarint32(pNext, &nSuffix);
126314 || &pNext[nSuffix]>&pReader->aNode[pReader->nNode]
126329 rc = fts3SegReaderRequire(pReader, pNext, nSuffix+FTS3_VARINT_MAX);
126332 memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
126334 pNext += nSuffix;
126335 pNext += sqlite3Fts3GetVarint32(pNext, &pReader->nDoclist);
126336 pReader->aDoclist = pNext;
128270 for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){
128282 Fts3DeferredToken *pNext;
128283 for(pDef=pCsr->pDeferred; pDef; pDef=pNext){
128284 pNext = pDef->pNext;
128325 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
128340 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
128392 pDeferred->pNext = pCsr->pDeferred;
130270 ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree
130376 RtreeNode *pNext; /* Next node in this hash chain */
130525 for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext);
130534 assert( pNode->pNext==0 );
130536 pNode->pNext = pRtree->aHash[iHash];
130547 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
130548 *pp = pNode->pNext;
130549 pNode->pNext = 0;
130615 pNode->pNext = 0;
132239 RtreeCell *pNext;
132240 pNext = PickNext(pRtree, aCell, nCell, pBboxLeft, pBboxRight, aiUsed);
132242 cellGrowth(pRtree, pBboxLeft, pNext) -
132243 cellGrowth(pRtree, pBboxRight, pNext)
132248 nodeInsertCell(pRtree, pRight, pNext);
132249 cellUnion(pRtree, pBboxRight, pNext);
132251 nodeInsertCell(pRtree, pLeft, pNext);
132252 cellUnion(pRtree, pBboxLeft, pNext);
132500 pNode->pNext = pRtree->pDeleted;
132816 pRtree->pDeleted = pLeaf->pNext;
