Lines Matching defs:pC
12953 int pc; /* Program Counter in parent (calling) frame */
13141 int pc; /* The program counter */
36177 int i, nx, pc, op;
36193 pc = 0;
36194 while( (op = aOp[pc])!=0 ){
36200 i = aOp[pc+2] - 1;
36201 aOp[pc+2] += aOp[pc+3];
36212 if( (--aOp[pc+1]) > 0 ) nx = 0;
36213 pc += nx;
50456 int pc; /* Address of a i-th cell */
50489 pc = get2byte(pAddr);
50490 testcase( pc==iCellFirst );
50491 testcase( pc==iCellLast );
50496 if( pc<iCellFirst || pc>iCellLast ){
50500 assert( pc>=iCellFirst && pc<=iCellLast );
50501 size = cellSizePtr(pPage, &temp[pc]);
50508 if( cbrk<iCellFirst || pc+size>usableSize ){
50514 testcase( pc+size==usableSize );
50515 memcpy(&data[cbrk], &temp[pc], size);
50581 int pc, addr;
50582 for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){
50584 if( pc>usableSize-4 || pc<addr+4 ){
50587 size = get2byte(&data[pc+2]);
50595 memcpy(&data[addr], &data[pc], 2);
50597 }else if( size+pc > usableSize ){
50602 put2byte(&data[pc+2], x);
50604 *pIdx = pc + x;
50780 u16 pc; /* Address of a freeblock within pPage->aData[] */
50827 pc = get2byte(&data[cellOffset+i*2]);
50828 testcase( pc==iCellFirst );
50829 testcase( pc==iCellLast );
50830 if( pc<iCellFirst || pc>iCellLast ){
50833 sz = cellSizePtr(pPage, &data[pc]);
50834 testcase( pc+sz==usableSize );
50835 if( pc+sz>usableSize ){
50844 pc = get2byte(&data[hdr+1]);
50846 while( pc>0 ){
50848 if( pc<iCellFirst || pc>iCellLast ){
50852 next = get2byte(&data[pc]);
50853 size = get2byte(&data[pc+2]);
50854 if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){
50860 pc = next;
54864 u32 pc; /* Offset to cell content of cell being deleted */
54879 pc = get2byte(ptr);
54881 testcase( pc==get2byte(&data[hdr+5]) );
54882 testcase( pc+sz==pPage->pBt->usableSize );
54883 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
54887 rc = freeSpace(pPage, pc, sz);
57254 int pc = get2byte(&data[cellStart+i*2]);
57257 if( pc<=usableSize-4 ){
57258 size = cellSizePtr(pPage, &data[pc]);
57260 if( (int)(pc+size-1)>=usableSize ){
57264 for(j=pc+size-1; j>=pc; j--) hit[j]++;
60581 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
60587 fprintf(pOut, zFormat1, pc,
60707 ** encountered, but p->pc will eventually catch up to nRow.
60729 i = p->pc++;
60966 p->pc = -1;
61152 return pFrame->pc;
61175 VdbeCursor *pC = p->apCsr[i];
61176 if( pC ){
61177 sqlite3VdbeFreeCursor(p, pC);
61530 if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
61674 if( p->pc>=0 ){
61807 if( p->pc>=0 ){
61891 if( p->pc>=0 ){
62655 ** Compare the key of the index entry that cursor pC is pointing to against
62657 ** that is negative, zero, or positive if pC is less than, equal to,
62666 VdbeCursor *pC, /* The cursor to compare against */
62672 BtCursor *pCur = pC->pCursor;
62685 rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (int)nCellKey, 1, &m);
63156 if( p->pc<=0 && p->expired ){
63161 if( p->pc<0 ){
63180 p->pc = 0;
63769 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
64060 return v!=0 && v->pc>0 && v->magic==VDBE_MAGIC_RUN;
65001 int pc=0; /* The program counter */
65103 VdbeCursor *pC; /* The VDBE cursor */
65201 VdbeCursor *pC;
65207 VdbeCursor *pC;
65211 VdbeCursor *pC;
65228 VdbeCursor *pC;
65235 VdbeCursor *pC; /* Cursor of table to get the new rowid */
65245 VdbeCursor *pC; /* Cursor to table into which insert is written */
65254 VdbeCursor *pC;
65257 VdbeCursor *pC;
65261 VdbeCursor *pC;
65264 VdbeCursor *pC;
65270 VdbeCursor *pC;
65276 VdbeCursor *pC;
65279 VdbeCursor *pC;
65284 VdbeCursor *pC;
65289 VdbeCursor *pC;
65293 VdbeCursor *pC;
65299 VdbeCursor *pC;
65306 VdbeCursor *pC;
65310 VdbeCursor *pC;
65467 if( p->pc==0 && (p->db->flags & SQLITE_VdbeListing)!=0 ){
65477 for(pc=p->pc; rc==SQLITE_OK; pc++){
65478 assert( pc>=0 && pc<p->nOp );
65481 origPc = pc;
65484 pOp = &aOp[pc];
65490 if( pc==0 ){
65494 sqlite3VdbePrintOp(p->trace, pc, pOp);
65625 pc = pOp->p2 - 1;
65640 pIn1->u.i = pc;
65642 pc = pOp->p2 - 1;
65653 pc = (int)pIn1->u.i;
65669 pIn1->u.i = pc;
65671 pc = u.aa.pcDest;
65713 pc = sqlite3VdbeFrameRestore(pFrame);
65716 /* Instruction pc is the OP_Program that invoked the sub-program
65721 pc = p->aOp[pc].p2-1;
65730 p->pc = pc;
65735 sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pc, p->zSql, pOp->p4.z);
65738 sqlite3_log(pOp->p1, "constraint failed at %d in [%s]", pc, p->zSql);
66048 p->pc = pc + 1;
66474 pc = pOp->p2 - 1;
66710 pc = pOp->p2-1;
66744 pc = pOp->p2-1;
66839 pc = pOp->p1 - 1;
66841 pc = pOp->p2 - 1;
66843 pc = pOp->p3 - 1;
66946 pc = pOp->p2-1;
66982 pc = pOp->p2-1;
66994 pc = pOp->p2 - 1;
67006 pc = pOp->p2 - 1;
67036 VdbeCursor *pC; /* The VDBE cursor */
67060 u.an.pC = 0;
67074 ** might be available in the u.an.pC->aRow cache. Or it might not be.
67080 u.an.pC = p->apCsr[u.an.p1];
67081 assert( u.an.pC!=0 );
67083 assert( u.an.pC->pVtabCursor==0 );
67085 u.an.pCrsr = u.an.pC->pCursor;
67088 rc = sqlite3VdbeCursorMoveto(u.an.pC);
67090 if( u.an.pC->nullRow ){
67092 }else if( u.an.pC->cacheStatus==p->cacheCtr ){
67093 u.an.payloadSize = u.an.pC->payloadSize;
67094 u.an.zRec = (char*)u.an.pC->aRow;
67095 }else if( u.an.pC->isIndex ){
67109 }else if( ALWAYS(u.an.pC->pseudoTableReg>0) ){
67110 u.an.pReg = &aMem[u.an.pC->pseudoTableReg];
67115 u.an.pC->cacheStatus = (pOp->p5&OPFLAG_CLEARCACHE) ? CACHE_STALE : p->cacheCtr;
67133 u.an.nField = u.an.pC->nField;
67139 u.an.aType = u.an.pC->aType;
67140 if( u.an.pC->cacheStatus==p->cacheCtr ){
67141 u.an.aOffset = u.an.pC->aOffset;
67145 u.an.pC->aOffset = u.an.aOffset = &u.an.aType[u.an.nField];
67146 u.an.pC->payloadSize = u.an.payloadSize;
67147 u.an.pC->cacheStatus = p->cacheCtr;
67153 if( u.an.pC->isIndex ){
67159 ** save the payload in the u.an.pC->aRow cache. That will save us from
67166 u.an.pC->aRow = (u8*)u.an.zData;
67168 u.an.pC->aRow = 0;
67215 rc = sqlite3VdbeMemFromBtree(u.an.pCrsr, 0, u.an.len, u.an.pC->isIndex, &u.an.sMem);
67285 rc = sqlite3VdbeMemFromBtree(u.an.pCrsr, u.an.aOffset[u.an.p2], u.an.len, u.an.pC->isIndex, &u.an.sMem);
67617 p->pc = pc;
67727 p->pc = pc;
67795 p->pc = pc;
68188 pc--;
68294 VdbeCursor *pC;
68302 u.bb.pC = p->apCsr[pOp->p1];
68303 assert( u.bb.pC!=0 );
68304 assert( u.bb.pC->pseudoTableReg==0 );
68308 assert( u.bb.pC->isOrdered );
68309 if( ALWAYS(u.bb.pC->pCursor!=0) ){
68311 u.bb.pC->nullRow = 0;
68312 if( u.bb.pC->isTable ){
68319 u.bb.pC->rowidIsValid = 0;
68327 pc = pOp->p2 - 1;
68340 rc = sqlite3BtreeFirst(u.bb.pC->pCursor, &u.bb.res);
68345 rc = sqlite3BtreeLast(u.bb.pC->pCursor, &u.bb.res);
68350 pc = pOp->p2 - 1;
68362 rc = sqlite3BtreeMovetoUnpacked(u.bb.pC->pCursor, 0, (u64)u.bb.iKey, 0, &u.bb.res);
68367 u.bb.pC->rowidIsValid = 1;
68368 u.bb.pC->lastRowid = u.bb.iKey;
68374 u.bb.r.pKeyInfo = u.bb.pC->pKeyInfo;
68395 rc = sqlite3BtreeMovetoUnpacked(u.bb.pC->pCursor, &u.bb.r, 0, 0, &u.bb.res);
68399 u.bb.pC->rowidIsValid = 0;
68401 u.bb.pC->deferredMoveto = 0;
68402 u.bb.pC->cacheStatus = CACHE_STALE;
68408 rc = sqlite3BtreeNext(u.bb.pC->pCursor, &u.bb.res);
68410 u.bb.pC->rowidIsValid = 0;
68417 rc = sqlite3BtreePrevious(u.bb.pC->pCursor, &u.bb.res);
68419 u.bb.pC->rowidIsValid = 0;
68424 u.bb.res = sqlite3BtreeEof(u.bb.pC->pCursor);
68429 pc = pOp->p2 - 1;
68436 pc = pOp->p2 - 1;
68452 VdbeCursor *pC;
68456 u.bc.pC = p->apCsr[pOp->p1];
68457 assert( u.bc.pC!=0 );
68458 if( ALWAYS(u.bc.pC->pCursor!=0) ){
68459 assert( u.bc.pC->isTable );
68460 u.bc.pC->nullRow = 0;
68462 u.bc.pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
68463 u.bc.pC->rowidIsValid = 0;
68464 u.bc.pC->deferredMoveto = 1;
68498 VdbeCursor *pC;
68513 u.bd.pC = p->apCsr[pOp->p1];
68514 assert( u.bd.pC!=0 );
68516 if( ALWAYS(u.bd.pC->pCursor!=0) ){
68518 assert( u.bd.pC->isTable==0 );
68520 u.bd.r.pKeyInfo = u.bd.pC->pKeyInfo;
68530 u.bd.pC->pKeyInfo, u.bd.aTempRec, sizeof(u.bd.aTempRec), &u.bd.pFree
68535 sqlite3VdbeRecordUnpack(u.bd.pC->pKeyInfo, pIn3->n, pIn3->z, u.bd.pIdxKey);
68538 rc = sqlite3BtreeMovetoUnpacked(u.bd.pC->pCursor, u.bd.pIdxKey, 0, 0, &u.bd.res);
68546 u.bd.pC->deferredMoveto = 0;
68547 u.bd.pC->cacheStatus = CACHE_STALE;
68550 if( u.bd.alreadyExists ) pc = pOp->p2 - 1;
68552 if( !u.bd.alreadyExists ) pc = pOp->p2 - 1;
68612 pc = pOp->p2 - 1;
68638 pc = pOp->p2 - 1;
68662 VdbeCursor *pC;
68671 u.bf.pC = p->apCsr[pOp->p1];
68672 assert( u.bf.pC!=0 );
68673 assert( u.bf.pC->isTable );
68674 assert( u.bf.pC->pseudoTableReg==0 );
68675 u.bf.pCrsr = u.bf.pC->pCursor;
68680 u.bf.pC->lastRowid = pIn3->u.i;
68681 u.bf.pC->rowidIsValid = u.bf.res==0 ?1:0;
68682 u.bf.pC->nullRow = 0;
68683 u.bf.pC->cacheStatus = CACHE_STALE;
68684 u.bf.pC->deferredMoveto = 0;
68686 pc = pOp->p2 - 1;
68687 assert( u.bf.pC->rowidIsValid==0 );
68689 u.bf.pC->seekResult = u.bf.res;
68694 pc = pOp->p2 - 1;
68695 assert( u.bf.pC->rowidIsValid==0 );
68696 u.bf.pC->seekResult = 0;
68733 VdbeCursor *pC; /* Cursor of table to get the new rowid */
68743 u.bg.pC = p->apCsr[pOp->p1];
68744 assert( u.bg.pC!=0 );
68745 if( NEVER(u.bg.pC->pCursor==0) ){
68761 assert( u.bg.pC->isTable );
68773 if( !u.bg.pC->useRandomRowid ){
68774 u.bg.v = sqlite3BtreeGetCachedRowid(u.bg.pC->pCursor);
68776 rc = sqlite3BtreeLast(u.bg.pC->pCursor, &u.bg.res);
68783 assert( sqlite3BtreeCursorIsValid(u.bg.pC->pCursor) );
68784 rc = sqlite3BtreeKeySize(u.bg.pC->pCursor, &u.bg.v);
68787 u.bg.pC->useRandomRowid = 1;
68814 if( u.bg.pMem->u.i==MAX_ROWID || u.bg.pC->useRandomRowid ){
68825 sqlite3BtreeSetCachedRowid(u.bg.pC->pCursor, u.bg.v<MAX_ROWID ? u.bg.v+1 : 0);
68827 if( u.bg.pC->useRandomRowid ){
68839 while( ((rc = sqlite3BtreeMovetoUnpacked(u.bg.pC->pCursor, 0, (u64)u.bg.v,
68859 u.bg.pC->rowidIsValid = 0;
68860 u.bg.pC->deferredMoveto = 0;
68861 u.bg.pC->cacheStatus = CACHE_STALE;
68917 VdbeCursor *pC; /* Cursor to table into which insert is written */
68928 u.bh.pC = p->apCsr[pOp->p1];
68929 assert( u.bh.pC!=0 );
68930 assert( u.bh.pC->pCursor!=0 );
68931 assert( u.bh.pC->pseudoTableReg==0 );
68932 assert( u.bh.pC->isTable );
68954 u.bh.seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bh.pC->seekResult : 0);
68960 sqlite3BtreeSetCachedRowid(u.bh.pC->pCursor, 0);
68961 rc = sqlite3BtreeInsert(u.bh.pC->pCursor, 0, u.bh.iKey,
68965 u.bh.pC->rowidIsValid = 0;
68966 u.bh.pC->deferredMoveto = 0;
68967 u.bh.pC->cacheStatus = CACHE_STALE;
68971 u.bh.zDb = db->aDb[u.bh.pC->iDb].zName;
68974 assert( u.bh.pC->isTable );
68976 assert( u.bh.pC->iDb>=0 );
69004 VdbeCursor *pC;
69009 u.bi.pC = p->apCsr[pOp->p1];
69010 assert( u.bi.pC!=0 );
69011 assert( u.bi.pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
69017 assert( u.bi.pC->isTable );
69018 assert( u.bi.pC->rowidIsValid ); /* lastRowid set by previous OP_NotFound */
69019 u.bi.iKey = u.bi.pC->lastRowid;
69024 ** might move or invalidate the cursor. Hence cursor u.bi.pC is always pointing
69029 assert( u.bi.pC->deferredMoveto==0 );
69030 rc = sqlite3VdbeCursorMoveto(u.bi.pC);
69033 sqlite3BtreeSetCachedRowid(u.bi.pC->pCursor, 0);
69034 rc = sqlite3BtreeDelete(u.bi.pC->pCursor);
69035 u.bi.pC->cacheStatus = CACHE_STALE;
69039 const char *zDb = db->aDb[u.bi.pC->iDb].zName;
69042 assert( u.bi.pC->iDb>=0 );
69069 VdbeCursor *pC;
69073 u.bj.pC = p->apCsr[pOp->p1];
69074 assert( isSorter(u.bj.pC) );
69076 rc = sqlite3VdbeSorterCompare(u.bj.pC, pIn3, &u.bj.res);
69078 pc = pOp->p2-1;
69089 VdbeCursor *pC;
69093 u.bk.pC = p->apCsr[pOp->p1];
69094 assert( u.bk.pC->isSorter );
69095 rc = sqlite3VdbeSorterRowkey(u.bk.pC, pOut);
69098 pc--;
69126 VdbeCursor *pC;
69137 u.bl.pC = p->apCsr[pOp->p1];
69138 assert( u.bl.pC->isSorter==0 );
69139 assert( u.bl.pC->isTable || pOp->opcode!=OP_RowData );
69140 assert( u.bl.pC->isIndex || pOp->opcode==OP_RowData );
69141 assert( u.bl.pC!=0 );
69142 assert( u.bl.pC->nullRow==0 );
69143 assert( u.bl.pC->pseudoTableReg==0 );
69144 assert( !u.bl.pC->isSorter );
69145 assert( u.bl.pC->pCursor!=0 );
69146 u.bl.pCrsr = u.bl.pC->pCursor;
69154 assert( u.bl.pC->deferredMoveto==0 );
69155 rc = sqlite3VdbeCursorMoveto(u.bl.pC);
69158 if( u.bl.pC->isIndex ){
69159 assert( !u.bl.pC->isTable );
69178 if( u.bl.pC->isIndex ){
69199 VdbeCursor *pC;
69206 u.bm.pC = p->apCsr[pOp->p1];
69207 assert( u.bm.pC!=0 );
69208 assert( u.bm.pC->pseudoTableReg==0 );
69209 if( u.bm.pC->nullRow ){
69212 }else if( u.bm.pC->deferredMoveto ){
69213 u.bm.v = u.bm.pC->movetoTarget;
69215 }else if( u.bm.pC->pVtabCursor ){
69216 u.bm.pVtab = u.bm.pC->pVtabCursor->pVtab;
69219 rc = u.bm.pModule->xRowid(u.bm.pC->pVtabCursor, &u.bm.v);
69223 assert( u.bm.pC->pCursor!=0 );
69224 rc = sqlite3VdbeCursorMoveto(u.bm.pC);
69226 if( u.bm.pC->rowidIsValid ){
69227 u.bm.v = u.bm.pC->lastRowid;
69229 rc = sqlite3BtreeKeySize(u.bm.pC->pCursor, &u.bm.v);
69245 VdbeCursor *pC;
69249 u.bn.pC = p->apCsr[pOp->p1];
69250 assert( u.bn.pC!=0 );
69251 u.bn.pC->nullRow = 1;
69252 u.bn.pC->rowidIsValid = 0;
69253 assert( u.bn.pC->pCursor || u.bn.pC->pVtabCursor );
69254 if( u.bn.pC->pCursor ){
69255 sqlite3BtreeClearCursor(u.bn.pC->pCursor);
69270 VdbeCursor *pC;
69276 u.bo.pC = p->apCsr[pOp->p1];
69277 assert( u.bo.pC!=0 );
69278 u.bo.pCrsr = u.bo.pC->pCursor;
69283 u.bo.pC->nullRow = (u8)u.bo.res;
69284 u.bo.pC->deferredMoveto = 0;
69285 u.bo.pC->rowidIsValid = 0;
69286 u.bo.pC->cacheStatus = CACHE_STALE;
69288 pc = pOp->p2 - 1;
69328 VdbeCursor *pC;
69334 u.bp.pC = p->apCsr[pOp->p1];
69335 assert( u.bp.pC!=0 );
69336 assert( u.bp.pC->isSorter==(pOp->opcode==OP_SorterSort) );
69338 if( isSorter(u.bp.pC) ){
69339 rc = sqlite3VdbeSorterRewind(db, u.bp.pC, &u.bp.res);
69341 u.bp.pCrsr = u.bp.pC->pCursor;
69344 u.bp.pC->atFirst = u.bp.res==0 ?1:0;
69345 u.bp.pC->deferredMoveto = 0;
69346 u.bp.pC->cacheStatus = CACHE_STALE;
69347 u.bp.pC->rowidIsValid = 0;
69349 u.bp.pC->nullRow = (u8)u.bp.res;
69352 pc = pOp->p2 - 1;
69396 VdbeCursor *pC;
69403 u.bq.pC = p->apCsr[pOp->p1];
69404 if( u.bq.pC==0 ){
69407 assert( u.bq.pC->isSorter==(pOp->opcode==OP_SorterNext) );
69408 if( isSorter(u.bq.pC) ){
69410 rc = sqlite3VdbeSorterNext(db, u.bq.pC, &u.bq.res);
69413 assert( u.bq.pC->deferredMoveto==0 );
69414 assert( u.bq.pC->pCursor );
69417 rc = pOp->p4.xAdvance(u.bq.pC->pCursor, &u.bq.res);
69419 u.bq.pC->nullRow = (u8)u.bq.res;
69420 u.bq.pC->cacheStatus = CACHE_STALE;
69422 pc = pOp->p2 - 1;
69428 u.bq.pC->rowidIsValid = 0;
69450 VdbeCursor *pC;
69457 u.br.pC = p->apCsr[pOp->p1];
69458 assert( u.br.pC!=0 );
69459 assert( u.br.pC->isSorter==(pOp->opcode==OP_SorterInsert) );
69462 u.br.pCrsr = u.br.pC->pCursor;
69464 assert( u.br.pC->isTable==0 );
69467 if( isSorter(u.br.pC) ){
69468 rc = sqlite3VdbeSorterWrite(db, u.br.pC, pIn2);
69473 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.br.pC->seekResult : 0)
69475 assert( u.br.pC->deferredMoveto==0 );
69476 u.br.pC->cacheStatus = CACHE_STALE;
69491 VdbeCursor *pC;
69500 u.bs.pC = p->apCsr[pOp->p1];
69501 assert( u.bs.pC!=0 );
69502 u.bs.pCrsr = u.bs.pC->pCursor;
69504 u.bs.r.pKeyInfo = u.bs.pC->pKeyInfo;
69515 assert( u.bs.pC->deferredMoveto==0 );
69516 u.bs.pC->cacheStatus = CACHE_STALE;
69532 VdbeCursor *pC;
69537 u.bt.pC = p->apCsr[pOp->p1];
69538 assert( u.bt.pC!=0 );
69539 u.bt.pCrsr = u.bt.pC->pCursor;
69542 rc = sqlite3VdbeCursorMoveto(u.bt.pC);
69544 assert( u.bt.pC->deferredMoveto==0 );
69545 assert( u.bt.pC->isTable==0 );
69546 if( !u.bt.pC->nullRow ){
69587 VdbeCursor *pC;
69593 u.bu.pC = p->apCsr[pOp->p1];
69594 assert( u.bu.pC!=0 );
69595 assert( u.bu.pC->isOrdered );
69596 if( ALWAYS(u.bu.pC->pCursor!=0) ){
69597 assert( u.bu.pC->deferredMoveto==0 );
69600 u.bu.r.pKeyInfo = u.bu.pC->pKeyInfo;
69611 rc = sqlite3VdbeIdxKeyCompare(u.bu.pC, &u.bu.r, &u.bu.res);
69619 pc = pOp->p2 - 1 ;
69655 if( u.bv.pVdbe->magic==VDBE_MAGIC_RUN && u.bv.pVdbe->inVtabMethod<2 && u.bv.pVdbe->pc>=0 ){
69978 pc = pOp->p2 - 1;
70035 pc = pOp->p2 - 1;
70126 u.cc.pFrame->pc = pc;
70146 assert( pc==u.cc.pFrame->pc );
70163 pc = -1;
70187 u.cd.pIn = &u.cd.pFrame->aMem[pOp->p1 + u.cd.pFrame->aOp[u.cd.pFrame->pc].p1];
70224 if( db->nDeferredCons==0 ) pc = pOp->p2-1;
70226 if( p->nFkConstraint==0 ) pc = pOp->p2-1;
70276 pc = pOp->p2 - 1;
70292 pc = pOp->p2 - 1;
70310 pc = pOp->p2 - 1;
70583 pc = pOp->p2 - 1;
70794 pc = pOp->p2 - 1;
70903 pc = pOp->p2 - 1;
71124 assert( pc>=-1 && pc<p->nOp );
71148 pc, p->zSql, p->zErrMsg);
94665 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
94687 apAll[2] = pC;
94709 if( pC==0 ){ zSp++; }
94711 "%T %T%s%T", pA, pB, zSp, pC);
98139 struct AggInfo_col *pC;
98190 ** to pC->iMem. But by the time the value is used, the original register
98201 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
98202 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
103851 u8 c, *pC; /* Last character before the first wildcard */
103852 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
103853 c = *pC;
103866 *pC = c + 1;
129221 sqlite3_tokenizer_cursor *pC;
129227 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
129233 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
129235 pMod->xClose(pC);
129275 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
129290 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
129300 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
129348 pMod->xClose(pC);
130018 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
130051 zDoc, nDoc, &pC
130055 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
130080 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
130097 pMod->xClose(pC);
