Lines Matching defs:pC
12953 int pc; /* Program Counter in parent (calling) frame */
13141 int pc; /* The program counter */
36149 int i, nx, pc, op;
36165 pc = 0;
36166 while( (op = aOp[pc])!=0 ){
36172 i = aOp[pc+2] - 1;
36173 aOp[pc+2] += aOp[pc+3];
36184 if( (--aOp[pc+1]) > 0 ) nx = 0;
36185 pc += nx;
50428 int pc; /* Address of a i-th cell */
50461 pc = get2byte(pAddr);
50462 testcase( pc==iCellFirst );
50463 testcase( pc==iCellLast );
50468 if( pc<iCellFirst || pc>iCellLast ){
50472 assert( pc>=iCellFirst && pc<=iCellLast );
50473 size = cellSizePtr(pPage, &temp[pc]);
50480 if( cbrk<iCellFirst || pc+size>usableSize ){
50486 testcase( pc+size==usableSize );
50487 memcpy(&data[cbrk], &temp[pc], size);
50553 int pc, addr;
50554 for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){
50556 if( pc>usableSize-4 || pc<addr+4 ){
50559 size = get2byte(&data[pc+2]);
50567 memcpy(&data[addr], &data[pc], 2);
50569 }else if( size+pc > usableSize ){
50574 put2byte(&data[pc+2], x);
50576 *pIdx = pc + x;
50752 u16 pc; /* Address of a freeblock within pPage->aData[] */
50799 pc = get2byte(&data[cellOffset+i*2]);
50800 testcase( pc==iCellFirst );
50801 testcase( pc==iCellLast );
50802 if( pc<iCellFirst || pc>iCellLast ){
50805 sz = cellSizePtr(pPage, &data[pc]);
50806 testcase( pc+sz==usableSize );
50807 if( pc+sz>usableSize ){
50816 pc = get2byte(&data[hdr+1]);
50818 while( pc>0 ){
50820 if( pc<iCellFirst || pc>iCellLast ){
50824 next = get2byte(&data[pc]);
50825 size = get2byte(&data[pc+2]);
50826 if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){
50832 pc = next;
54836 u32 pc; /* Offset to cell content of cell being deleted */
54851 pc = get2byte(ptr);
54853 testcase( pc==get2byte(&data[hdr+5]) );
54854 testcase( pc+sz==pPage->pBt->usableSize );
54855 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
54859 rc = freeSpace(pPage, pc, sz);
57226 int pc = get2byte(&data[cellStart+i*2]);
57229 if( pc<=usableSize-4 ){
57230 size = cellSizePtr(pPage, &data[pc]);
57232 if( (int)(pc+size-1)>=usableSize ){
57236 for(j=pc+size-1; j>=pc; j--) hit[j]++;
60553 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
60559 fprintf(pOut, zFormat1, pc,
60679 ** encountered, but p->pc will eventually catch up to nRow.
60701 i = p->pc++;
60938 p->pc = -1;
61124 return pFrame->pc;
61147 VdbeCursor *pC = p->apCsr[i];
61148 if( pC ){
61149 sqlite3VdbeFreeCursor(p, pC);
61502 if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
61646 if( p->pc>=0 ){
61779 if( p->pc>=0 ){
61863 if( p->pc>=0 ){
62627 ** Compare the key of the index entry that cursor pC is pointing to against
62629 ** that is negative, zero, or positive if pC is less than, equal to,
62638 VdbeCursor *pC, /* The cursor to compare against */
62644 BtCursor *pCur = pC->pCursor;
62657 rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (int)nCellKey, 1, &m);
63128 if( p->pc<=0 && p->expired ){
63133 if( p->pc<0 ){
63152 p->pc = 0;
63741 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
64032 return v!=0 && v->pc>0 && v->magic==VDBE_MAGIC_RUN;
64973 int pc=0; /* The program counter */
65075 VdbeCursor *pC; /* The VDBE cursor */
65173 VdbeCursor *pC;
65179 VdbeCursor *pC;
65183 VdbeCursor *pC;
65200 VdbeCursor *pC;
65207 VdbeCursor *pC; /* Cursor of table to get the new rowid */
65217 VdbeCursor *pC; /* Cursor to table into which insert is written */
65226 VdbeCursor *pC;
65229 VdbeCursor *pC;
65233 VdbeCursor *pC;
65236 VdbeCursor *pC;
65242 VdbeCursor *pC;
65248 VdbeCursor *pC;
65251 VdbeCursor *pC;
65256 VdbeCursor *pC;
65261 VdbeCursor *pC;
65265 VdbeCursor *pC;
65271 VdbeCursor *pC;
65278 VdbeCursor *pC;
65282 VdbeCursor *pC;
65439 if( p->pc==0 && (p->db->flags & SQLITE_VdbeListing)!=0 ){
65449 for(pc=p->pc; rc==SQLITE_OK; pc++){
65450 assert( pc>=0 && pc<p->nOp );
65453 origPc = pc;
65456 pOp = &aOp[pc];
65462 if( pc==0 ){
65466 sqlite3VdbePrintOp(p->trace, pc, pOp);
65597 pc = pOp->p2 - 1;
65612 pIn1->u.i = pc;
65614 pc = pOp->p2 - 1;
65625 pc = (int)pIn1->u.i;
65641 pIn1->u.i = pc;
65643 pc = u.aa.pcDest;
65685 pc = sqlite3VdbeFrameRestore(pFrame);
65688 /* Instruction pc is the OP_Program that invoked the sub-program
65693 pc = p->aOp[pc].p2-1;
65702 p->pc = pc;
65707 sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pc, p->zSql, pOp->p4.z);
65710 sqlite3_log(pOp->p1, "constraint failed at %d in [%s]", pc, p->zSql);
66020 p->pc = pc + 1;
66446 pc = pOp->p2 - 1;
66682 pc = pOp->p2-1;
66716 pc = pOp->p2-1;
66811 pc = pOp->p1 - 1;
66813 pc = pOp->p2 - 1;
66815 pc = pOp->p3 - 1;
66918 pc = pOp->p2-1;
66954 pc = pOp->p2-1;
66966 pc = pOp->p2 - 1;
66978 pc = pOp->p2 - 1;
67008 VdbeCursor *pC; /* The VDBE cursor */
67032 u.an.pC = 0;
67046 ** might be available in the u.an.pC->aRow cache. Or it might not be.
67052 u.an.pC = p->apCsr[u.an.p1];
67053 assert( u.an.pC!=0 );
67055 assert( u.an.pC->pVtabCursor==0 );
67057 u.an.pCrsr = u.an.pC->pCursor;
67060 rc = sqlite3VdbeCursorMoveto(u.an.pC);
67062 if( u.an.pC->nullRow ){
67064 }else if( u.an.pC->cacheStatus==p->cacheCtr ){
67065 u.an.payloadSize = u.an.pC->payloadSize;
67066 u.an.zRec = (char*)u.an.pC->aRow;
67067 }else if( u.an.pC->isIndex ){
67081 }else if( ALWAYS(u.an.pC->pseudoTableReg>0) ){
67082 u.an.pReg = &aMem[u.an.pC->pseudoTableReg];
67087 u.an.pC->cacheStatus = (pOp->p5&OPFLAG_CLEARCACHE) ? CACHE_STALE : p->cacheCtr;
67105 u.an.nField = u.an.pC->nField;
67111 u.an.aType = u.an.pC->aType;
67112 if( u.an.pC->cacheStatus==p->cacheCtr ){
67113 u.an.aOffset = u.an.pC->aOffset;
67117 u.an.pC->aOffset = u.an.aOffset = &u.an.aType[u.an.nField];
67118 u.an.pC->payloadSize = u.an.payloadSize;
67119 u.an.pC->cacheStatus = p->cacheCtr;
67125 if( u.an.pC->isIndex ){
67131 ** save the payload in the u.an.pC->aRow cache. That will save us from
67138 u.an.pC->aRow = (u8*)u.an.zData;
67140 u.an.pC->aRow = 0;
67187 rc = sqlite3VdbeMemFromBtree(u.an.pCrsr, 0, u.an.len, u.an.pC->isIndex, &u.an.sMem);
67257 rc = sqlite3VdbeMemFromBtree(u.an.pCrsr, u.an.aOffset[u.an.p2], u.an.len, u.an.pC->isIndex, &u.an.sMem);
67589 p->pc = pc;
67699 p->pc = pc;
67767 p->pc = pc;
68160 pc--;
68266 VdbeCursor *pC;
68274 u.bb.pC = p->apCsr[pOp->p1];
68275 assert( u.bb.pC!=0 );
68276 assert( u.bb.pC->pseudoTableReg==0 );
68280 assert( u.bb.pC->isOrdered );
68281 if( ALWAYS(u.bb.pC->pCursor!=0) ){
68283 u.bb.pC->nullRow = 0;
68284 if( u.bb.pC->isTable ){
68291 u.bb.pC->rowidIsValid = 0;
68299 pc = pOp->p2 - 1;
68312 rc = sqlite3BtreeFirst(u.bb.pC->pCursor, &u.bb.res);
68317 rc = sqlite3BtreeLast(u.bb.pC->pCursor, &u.bb.res);
68322 pc = pOp->p2 - 1;
68334 rc = sqlite3BtreeMovetoUnpacked(u.bb.pC->pCursor, 0, (u64)u.bb.iKey, 0, &u.bb.res);
68339 u.bb.pC->rowidIsValid = 1;
68340 u.bb.pC->lastRowid = u.bb.iKey;
68346 u.bb.r.pKeyInfo = u.bb.pC->pKeyInfo;
68367 rc = sqlite3BtreeMovetoUnpacked(u.bb.pC->pCursor, &u.bb.r, 0, 0, &u.bb.res);
68371 u.bb.pC->rowidIsValid = 0;
68373 u.bb.pC->deferredMoveto = 0;
68374 u.bb.pC->cacheStatus = CACHE_STALE;
68380 rc = sqlite3BtreeNext(u.bb.pC->pCursor, &u.bb.res);
68382 u.bb.pC->rowidIsValid = 0;
68389 rc = sqlite3BtreePrevious(u.bb.pC->pCursor, &u.bb.res);
68391 u.bb.pC->rowidIsValid = 0;
68396 u.bb.res = sqlite3BtreeEof(u.bb.pC->pCursor);
68401 pc = pOp->p2 - 1;
68408 pc = pOp->p2 - 1;
68424 VdbeCursor *pC;
68428 u.bc.pC = p->apCsr[pOp->p1];
68429 assert( u.bc.pC!=0 );
68430 if( ALWAYS(u.bc.pC->pCursor!=0) ){
68431 assert( u.bc.pC->isTable );
68432 u.bc.pC->nullRow = 0;
68434 u.bc.pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
68435 u.bc.pC->rowidIsValid = 0;
68436 u.bc.pC->deferredMoveto = 1;
68470 VdbeCursor *pC;
68485 u.bd.pC = p->apCsr[pOp->p1];
68486 assert( u.bd.pC!=0 );
68488 if( ALWAYS(u.bd.pC->pCursor!=0) ){
68490 assert( u.bd.pC->isTable==0 );
68492 u.bd.r.pKeyInfo = u.bd.pC->pKeyInfo;
68502 u.bd.pC->pKeyInfo, u.bd.aTempRec, sizeof(u.bd.aTempRec), &u.bd.pFree
68507 sqlite3VdbeRecordUnpack(u.bd.pC->pKeyInfo, pIn3->n, pIn3->z, u.bd.pIdxKey);
68510 rc = sqlite3BtreeMovetoUnpacked(u.bd.pC->pCursor, u.bd.pIdxKey, 0, 0, &u.bd.res);
68518 u.bd.pC->deferredMoveto = 0;
68519 u.bd.pC->cacheStatus = CACHE_STALE;
68522 if( u.bd.alreadyExists ) pc = pOp->p2 - 1;
68524 if( !u.bd.alreadyExists ) pc = pOp->p2 - 1;
68584 pc = pOp->p2 - 1;
68610 pc = pOp->p2 - 1;
68634 VdbeCursor *pC;
68643 u.bf.pC = p->apCsr[pOp->p1];
68644 assert( u.bf.pC!=0 );
68645 assert( u.bf.pC->isTable );
68646 assert( u.bf.pC->pseudoTableReg==0 );
68647 u.bf.pCrsr = u.bf.pC->pCursor;
68652 u.bf.pC->lastRowid = pIn3->u.i;
68653 u.bf.pC->rowidIsValid = u.bf.res==0 ?1:0;
68654 u.bf.pC->nullRow = 0;
68655 u.bf.pC->cacheStatus = CACHE_STALE;
68656 u.bf.pC->deferredMoveto = 0;
68658 pc = pOp->p2 - 1;
68659 assert( u.bf.pC->rowidIsValid==0 );
68661 u.bf.pC->seekResult = u.bf.res;
68666 pc = pOp->p2 - 1;
68667 assert( u.bf.pC->rowidIsValid==0 );
68668 u.bf.pC->seekResult = 0;
68705 VdbeCursor *pC; /* Cursor of table to get the new rowid */
68715 u.bg.pC = p->apCsr[pOp->p1];
68716 assert( u.bg.pC!=0 );
68717 if( NEVER(u.bg.pC->pCursor==0) ){
68733 assert( u.bg.pC->isTable );
68745 if( !u.bg.pC->useRandomRowid ){
68746 u.bg.v = sqlite3BtreeGetCachedRowid(u.bg.pC->pCursor);
68748 rc = sqlite3BtreeLast(u.bg.pC->pCursor, &u.bg.res);
68755 assert( sqlite3BtreeCursorIsValid(u.bg.pC->pCursor) );
68756 rc = sqlite3BtreeKeySize(u.bg.pC->pCursor, &u.bg.v);
68759 u.bg.pC->useRandomRowid = 1;
68786 if( u.bg.pMem->u.i==MAX_ROWID || u.bg.pC->useRandomRowid ){
68797 sqlite3BtreeSetCachedRowid(u.bg.pC->pCursor, u.bg.v<MAX_ROWID ? u.bg.v+1 : 0);
68799 if( u.bg.pC->useRandomRowid ){
68811 while( ((rc = sqlite3BtreeMovetoUnpacked(u.bg.pC->pCursor, 0, (u64)u.bg.v,
68831 u.bg.pC->rowidIsValid = 0;
68832 u.bg.pC->deferredMoveto = 0;
68833 u.bg.pC->cacheStatus = CACHE_STALE;
68889 VdbeCursor *pC; /* Cursor to table into which insert is written */
68900 u.bh.pC = p->apCsr[pOp->p1];
68901 assert( u.bh.pC!=0 );
68902 assert( u.bh.pC->pCursor!=0 );
68903 assert( u.bh.pC->pseudoTableReg==0 );
68904 assert( u.bh.pC->isTable );
68926 u.bh.seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bh.pC->seekResult : 0);
68932 sqlite3BtreeSetCachedRowid(u.bh.pC->pCursor, 0);
68933 rc = sqlite3BtreeInsert(u.bh.pC->pCursor, 0, u.bh.iKey,
68937 u.bh.pC->rowidIsValid = 0;
68938 u.bh.pC->deferredMoveto = 0;
68939 u.bh.pC->cacheStatus = CACHE_STALE;
68943 u.bh.zDb = db->aDb[u.bh.pC->iDb].zName;
68946 assert( u.bh.pC->isTable );
68948 assert( u.bh.pC->iDb>=0 );
68976 VdbeCursor *pC;
68981 u.bi.pC = p->apCsr[pOp->p1];
68982 assert( u.bi.pC!=0 );
68983 assert( u.bi.pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
68989 assert( u.bi.pC->isTable );
68990 assert( u.bi.pC->rowidIsValid ); /* lastRowid set by previous OP_NotFound */
68991 u.bi.iKey = u.bi.pC->lastRowid;
68996 ** might move or invalidate the cursor. Hence cursor u.bi.pC is always pointing
69001 assert( u.bi.pC->deferredMoveto==0 );
69002 rc = sqlite3VdbeCursorMoveto(u.bi.pC);
69005 sqlite3BtreeSetCachedRowid(u.bi.pC->pCursor, 0);
69006 rc = sqlite3BtreeDelete(u.bi.pC->pCursor);
69007 u.bi.pC->cacheStatus = CACHE_STALE;
69011 const char *zDb = db->aDb[u.bi.pC->iDb].zName;
69014 assert( u.bi.pC->iDb>=0 );
69041 VdbeCursor *pC;
69045 u.bj.pC = p->apCsr[pOp->p1];
69046 assert( isSorter(u.bj.pC) );
69048 rc = sqlite3VdbeSorterCompare(u.bj.pC, pIn3, &u.bj.res);
69050 pc = pOp->p2-1;
69061 VdbeCursor *pC;
69065 u.bk.pC = p->apCsr[pOp->p1];
69066 assert( u.bk.pC->isSorter );
69067 rc = sqlite3VdbeSorterRowkey(u.bk.pC, pOut);
69070 pc--;
69098 VdbeCursor *pC;
69109 u.bl.pC = p->apCsr[pOp->p1];
69110 assert( u.bl.pC->isSorter==0 );
69111 assert( u.bl.pC->isTable || pOp->opcode!=OP_RowData );
69112 assert( u.bl.pC->isIndex || pOp->opcode==OP_RowData );
69113 assert( u.bl.pC!=0 );
69114 assert( u.bl.pC->nullRow==0 );
69115 assert( u.bl.pC->pseudoTableReg==0 );
69116 assert( !u.bl.pC->isSorter );
69117 assert( u.bl.pC->pCursor!=0 );
69118 u.bl.pCrsr = u.bl.pC->pCursor;
69126 assert( u.bl.pC->deferredMoveto==0 );
69127 rc = sqlite3VdbeCursorMoveto(u.bl.pC);
69130 if( u.bl.pC->isIndex ){
69131 assert( !u.bl.pC->isTable );
69150 if( u.bl.pC->isIndex ){
69171 VdbeCursor *pC;
69178 u.bm.pC = p->apCsr[pOp->p1];
69179 assert( u.bm.pC!=0 );
69180 assert( u.bm.pC->pseudoTableReg==0 );
69181 if( u.bm.pC->nullRow ){
69184 }else if( u.bm.pC->deferredMoveto ){
69185 u.bm.v = u.bm.pC->movetoTarget;
69187 }else if( u.bm.pC->pVtabCursor ){
69188 u.bm.pVtab = u.bm.pC->pVtabCursor->pVtab;
69191 rc = u.bm.pModule->xRowid(u.bm.pC->pVtabCursor, &u.bm.v);
69195 assert( u.bm.pC->pCursor!=0 );
69196 rc = sqlite3VdbeCursorMoveto(u.bm.pC);
69198 if( u.bm.pC->rowidIsValid ){
69199 u.bm.v = u.bm.pC->lastRowid;
69201 rc = sqlite3BtreeKeySize(u.bm.pC->pCursor, &u.bm.v);
69217 VdbeCursor *pC;
69221 u.bn.pC = p->apCsr[pOp->p1];
69222 assert( u.bn.pC!=0 );
69223 u.bn.pC->nullRow = 1;
69224 u.bn.pC->rowidIsValid = 0;
69225 assert( u.bn.pC->pCursor || u.bn.pC->pVtabCursor );
69226 if( u.bn.pC->pCursor ){
69227 sqlite3BtreeClearCursor(u.bn.pC->pCursor);
69242 VdbeCursor *pC;
69248 u.bo.pC = p->apCsr[pOp->p1];
69249 assert( u.bo.pC!=0 );
69250 u.bo.pCrsr = u.bo.pC->pCursor;
69255 u.bo.pC->nullRow = (u8)u.bo.res;
69256 u.bo.pC->deferredMoveto = 0;
69257 u.bo.pC->rowidIsValid = 0;
69258 u.bo.pC->cacheStatus = CACHE_STALE;
69260 pc = pOp->p2 - 1;
69300 VdbeCursor *pC;
69306 u.bp.pC = p->apCsr[pOp->p1];
69307 assert( u.bp.pC!=0 );
69308 assert( u.bp.pC->isSorter==(pOp->opcode==OP_SorterSort) );
69310 if( isSorter(u.bp.pC) ){
69311 rc = sqlite3VdbeSorterRewind(db, u.bp.pC, &u.bp.res);
69313 u.bp.pCrsr = u.bp.pC->pCursor;
69316 u.bp.pC->atFirst = u.bp.res==0 ?1:0;
69317 u.bp.pC->deferredMoveto = 0;
69318 u.bp.pC->cacheStatus = CACHE_STALE;
69319 u.bp.pC->rowidIsValid = 0;
69321 u.bp.pC->nullRow = (u8)u.bp.res;
69324 pc = pOp->p2 - 1;
69368 VdbeCursor *pC;
69375 u.bq.pC = p->apCsr[pOp->p1];
69376 if( u.bq.pC==0 ){
69379 assert( u.bq.pC->isSorter==(pOp->opcode==OP_SorterNext) );
69380 if( isSorter(u.bq.pC) ){
69382 rc = sqlite3VdbeSorterNext(db, u.bq.pC, &u.bq.res);
69385 assert( u.bq.pC->deferredMoveto==0 );
69386 assert( u.bq.pC->pCursor );
69389 rc = pOp->p4.xAdvance(u.bq.pC->pCursor, &u.bq.res);
69391 u.bq.pC->nullRow = (u8)u.bq.res;
69392 u.bq.pC->cacheStatus = CACHE_STALE;
69394 pc = pOp->p2 - 1;
69400 u.bq.pC->rowidIsValid = 0;
69422 VdbeCursor *pC;
69429 u.br.pC = p->apCsr[pOp->p1];
69430 assert( u.br.pC!=0 );
69431 assert( u.br.pC->isSorter==(pOp->opcode==OP_SorterInsert) );
69434 u.br.pCrsr = u.br.pC->pCursor;
69436 assert( u.br.pC->isTable==0 );
69439 if( isSorter(u.br.pC) ){
69440 rc = sqlite3VdbeSorterWrite(db, u.br.pC, pIn2);
69445 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.br.pC->seekResult : 0)
69447 assert( u.br.pC->deferredMoveto==0 );
69448 u.br.pC->cacheStatus = CACHE_STALE;
69463 VdbeCursor *pC;
69472 u.bs.pC = p->apCsr[pOp->p1];
69473 assert( u.bs.pC!=0 );
69474 u.bs.pCrsr = u.bs.pC->pCursor;
69476 u.bs.r.pKeyInfo = u.bs.pC->pKeyInfo;
69487 assert( u.bs.pC->deferredMoveto==0 );
69488 u.bs.pC->cacheStatus = CACHE_STALE;
69504 VdbeCursor *pC;
69509 u.bt.pC = p->apCsr[pOp->p1];
69510 assert( u.bt.pC!=0 );
69511 u.bt.pCrsr = u.bt.pC->pCursor;
69514 rc = sqlite3VdbeCursorMoveto(u.bt.pC);
69516 assert( u.bt.pC->deferredMoveto==0 );
69517 assert( u.bt.pC->isTable==0 );
69518 if( !u.bt.pC->nullRow ){
69559 VdbeCursor *pC;
69565 u.bu.pC = p->apCsr[pOp->p1];
69566 assert( u.bu.pC!=0 );
69567 assert( u.bu.pC->isOrdered );
69568 if( ALWAYS(u.bu.pC->pCursor!=0) ){
69569 assert( u.bu.pC->deferredMoveto==0 );
69572 u.bu.r.pKeyInfo = u.bu.pC->pKeyInfo;
69583 rc = sqlite3VdbeIdxKeyCompare(u.bu.pC, &u.bu.r, &u.bu.res);
69591 pc = pOp->p2 - 1 ;
69627 if( u.bv.pVdbe->magic==VDBE_MAGIC_RUN && u.bv.pVdbe->inVtabMethod<2 && u.bv.pVdbe->pc>=0 ){
69950 pc = pOp->p2 - 1;
70007 pc = pOp->p2 - 1;
70098 u.cc.pFrame->pc = pc;
70118 assert( pc==u.cc.pFrame->pc );
70135 pc = -1;
70159 u.cd.pIn = &u.cd.pFrame->aMem[pOp->p1 + u.cd.pFrame->aOp[u.cd.pFrame->pc].p1];
70196 if( db->nDeferredCons==0 ) pc = pOp->p2-1;
70198 if( p->nFkConstraint==0 ) pc = pOp->p2-1;
70248 pc = pOp->p2 - 1;
70264 pc = pOp->p2 - 1;
70282 pc = pOp->p2 - 1;
70555 pc = pOp->p2 - 1;
70766 pc = pOp->p2 - 1;
70875 pc = pOp->p2 - 1;
71096 assert( pc>=-1 && pc<p->nOp );
71120 pc, p->zSql, p->zErrMsg);
94629 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
94651 apAll[2] = pC;
94673 if( pC==0 ){ zSp++; }
94675 "%T %T%s%T", pA, pB, zSp, pC);
98103 struct AggInfo_col *pC;
98154 ** to pC->iMem. But by the time the value is used, the original register
98165 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
98166 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
103815 u8 c, *pC; /* Last character before the first wildcard */
103816 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
103817 c = *pC;
103830 *pC = c + 1;
129175 sqlite3_tokenizer_cursor *pC;
129181 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
129187 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
129189 pMod->xClose(pC);
129229 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
129244 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
129254 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
129302 pMod->xClose(pC);
129972 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
130005 zDoc, nDoc, &pC
130009 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
130034 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
130051 pMod->xClose(pC);
