Lines Matching defs:pC
17627 int pc; /* Program Counter */
17819 int pc; /* The program counter */
29580 int i, nx, pc, op;
29596 pc = 0;
29597 while( (op = aOp[pc])!=0 ){
29603 i = aOp[pc+2] - 1;
29604 aOp[pc+2] += aOp[pc+3];
29615 if( (--aOp[pc+1]) > 0 ) nx = 0;
29616 pc += nx;
38834 int pc; /* Address of a i-th cell */
38867 pc = get2byte(pAddr);
38868 testcase( pc==iCellFirst );
38869 testcase( pc==iCellLast );
38874 if( pc<iCellFirst || pc>iCellLast ){
38878 assert( pc>=iCellFirst && pc<=iCellLast );
38879 size = cellSizePtr(pPage, &temp[pc]);
38886 if( cbrk<iCellFirst || pc+size>usableSize ){
38892 testcase( pc+size==usableSize );
38893 memcpy(&data[cbrk], &temp[pc], size);
38959 int pc, addr;
38960 for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){
38962 if( pc>usableSize-4 || pc<addr+4 ){
38965 size = get2byte(&data[pc+2]);
38973 memcpy(&data[addr], &data[pc], 2);
38975 }else if( size+pc > usableSize ){
38980 pc+2], x);
38982 *pIdx = pc + x;
39157 u16 pc; /* Address of a freeblock within pPage->aData[] */
39202 pc = get2byte(&data[cellOffset+i*2]);
39203 testcase( pc==iCellFirst );
39204 testcase( pc==iCellLast );
39205 if( pc<iCellFirst || pc>iCellLast ){
39208 sz = cellSizePtr(pPage, &data[pc]);
39209 testcase( pc+sz==usableSize );
39210 if( pc+sz>usableSize ){
39219 pc = get2byte(&data[hdr+1]);
39221 while( pc>0 ){
39223 if( pc<iCellFirst || pc>iCellLast ){
39227 next = get2byte(&data[pc]);
39228 size = get2byte(&data[pc+2]);
39229 if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){
39235 pc = next;
43017 int pc; /* Offset to cell content of cell being deleted */
43031 pc = get2byte(ptr);
43033 testcase( pc==get2byte(&data[hdr+5]) );
43034 testcase( pc+sz==pPage->pBt->usableSize );
43035 if( pc < get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
43039 rc = freeSpace(pPage, pc, sz);
45346 int pc = get2byte(&data[cellStart+i*2]);
45349 if( pc<=usableSize-4 ){
45350 size = cellSizePtr(pPage, &data[pc]);
45352 if( (pc+size-1)>=usableSize ){
45356 for(j=pc+size-1; j>=pc; j--) hit[j]++;
48393 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
48399 fprintf(pOut, zFormat1, pc,
48512 ** encountered, but p->pc will eventually catch up to nRow.
48534 i = p->pc++;
48866 p->pc = -1;
48927 return pFrame->pc;
48950 VdbeCursor *pC = p->apCsr[i];
48951 if( pC ){
48952 sqlite3VdbeFreeCursor(p, pC);
49279 if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
49466 if( p->pc>=0 ){
49588 if( p->pc>=0 ){
49648 if( p->pc>=0 ){
50416 ** Compare the key of the index entry that cursor pC is pointing to against
50418 ** that is negative, zero, or positive if pC is less than, equal to,
50427 VdbeCursor *pC, /* The cursor to compare against */
50433 BtCursor *pCur = pC->pCursor;
50446 rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (int)nCellKey, 1, &m);
50871 if( p->pc<=0 && p->expired ){
50878 if( p->pc<0 ){
50899 p->pc = 0;
51467 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
52565 int pc; /* The program counter */
52662 VdbeCursor *pC; /* The VDBE cursor */
52755 VdbeCursor *pC;
52761 VdbeCursor *pC;
52765 VdbeCursor *pC;
52781 VdbeCursor *pC;
52788 VdbeCursor *pC; /* Cursor of table to get the new rowid */
52798 VdbeCursor *pC; /* Cursor to table into which insert is written */
52807 VdbeCursor *pC;
52810 VdbeCursor *pC;
52816 VdbeCursor *pC;
52822 VdbeCursor *pC;
52825 VdbeCursor *pC;
52830 VdbeCursor *pC;
52835 VdbeCursor *pC;
52840 VdbeCursor *pC;
52846 VdbeCursor *pC;
52853 VdbeCursor *pC;
52857 VdbeCursor *pC;
53006 if( p->pc==0
53021 for(pc=p->pc; rc==SQLITE_OK; pc++){
53022 assert( pc>=0 && pc<p->nOp );
53025 origPc = pc;
53028 pOp = &aOp[pc];
53034 if( pc==0 ){
53038 sqlite3VdbePrintOp(p->trace, pc, pOp);
53040 if( p->trace==0 && pc==0 ){
53170 pc = pOp->p2 - 1;
53183 pIn1->u.i = pc;
53185 pc = pOp->p2 - 1;
53196 pc = (int)pIn1->u.i;
53212 pIn1->u.i = pc;
53214 pc = u.aa.pcDest;
53256 pc = sqlite3VdbeFrameRestore(pFrame);
53258 /* Instruction pc is the OP_Program that invoked the sub-program
53263 pc = p->aOp[pc].p2-1;
53272 p->pc = pc;
53277 sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pc, p->zSql, pOp->p4.z);
53280 sqlite3_log(pOp->p1, "constraint failed at %d in [%s]", pc, p->zSql);
53577 p->pc = pc + 1;
53957 pc = pOp->p2 - 1;
54187 pc = pOp->p2-1;
54220 pc = pOp->p2-1;
54309 pc = pOp->p1 - 1;
54311 pc = pOp->p2 - 1;
54313 pc = pOp->p3 - 1;
54435 pc = pOp->p2-1;
54447 pc = pOp->p2 - 1;
54459 pc = pOp->p2 - 1;
54489 VdbeCursor *pC; /* The VDBE cursor */
54512 u.am.pC = 0;
54526 ** might be available in the u.am.pC->aRow cache. Or it might not be.
54532 u.am.pC = p->apCsr[u.am.p1];
54533 assert( u.am.pC!=0 );
54535 assert( u.am.pC->pVtabCursor==0 );
54537 u.am.pCrsr = u.am.pC->pCursor;
54540 rc = sqlite3VdbeCursorMoveto(u.am.pC);
54542 if( u.am.pC->nullRow ){
54544 }else if( u.am.pC->cacheStatus==p->cacheCtr ){
54545 u.am.payloadSize = u.am.pC->payloadSize;
54546 u.am.zRec = (char*)u.am.pC->aRow;
54547 }else if( u.am.pC->isIndex ){
54561 }else if( u.am.pC->pseudoTableReg>0 ){
54562 u.am.pReg = &aMem[u.am.pC->pseudoTableReg];
54566 u.am.pC->cacheStatus = (pOp->p5&OPFLAG_CLEARCACHE) ? CACHE_STALE : p->cacheCtr;
54583 u.am.nField = u.am.pC->nField;
54589 u.am.aType = u.am.pC->aType;
54590 if( u.am.pC->cacheStatus==p->cacheCtr ){
54591 u.am.aOffset = u.am.pC->aOffset;
54595 u.am.pC->aOffset = u.am.aOffset = &u.am.aType[u.am.nField];
54596 u.am.pC->payloadSize = u.am.payloadSize;
54597 u.am.pC->cacheStatus = p->cacheCtr;
54603 if( u.am.pC->isIndex ){
54609 ** save the payload in the u.am.pC->aRow cache. That will save us from
54616 u.am.pC->aRow = (u8*)u.am.zData;
54618 u.am.pC->aRow = 0;
54665 rc = sqlite3VdbeMemFromBtree(u.am.pCrsr, 0, u.am.len, u.am.pC->isIndex, &u.am.sMem);
54729 rc = sqlite3VdbeMemFromBtree(u.am.pCrsr, u.am.aOffset[u.am.p2], u.am.len, u.am.pC->isIndex, &u.am.sMem);
55053 p->pc = pc;
55151 p->pc = pc;
55219 p->pc = pc;
55671 VdbeCursor *pC;
55679 u.az.pC = p->apCsr[pOp->p1];
55680 assert( u.az.pC!=0 );
55681 assert( u.az.pC->pseudoTableReg==0 );
55685 if( u.az.pC->pCursor!=0 ){
55687 u.az.pC->nullRow = 0;
55688 if( u.az.pC->isTable ){
55695 u.az.pC->rowidIsValid = 0;
55703 pc = pOp->p2 - 1;
55716 rc = sqlite3BtreeFirst(u.az.pC->pCursor, &u.az.res);
55721 rc = sqlite3BtreeLast(u.az.pC->pCursor, &u.az.res);
55726 pc = pOp->p2 - 1;
55738 rc = sqlite3BtreeMovetoUnpacked(u.az.pC->pCursor, 0, (u64)u.az.iKey, 0, &u.az.res);
55743 u.az.pC->rowidIsValid = 1;
55744 u.az.pC->lastRowid = u.az.iKey;
55750 u.az.r.pKeyInfo = u.az.pC->pKeyInfo;
55768 rc = sqlite3BtreeMovetoUnpacked(u.az.pC->pCursor, &u.az.r, 0, 0, &u.az.res);
55772 u.az.pC->rowidIsValid = 0;
55774 u.az.pC->deferredMoveto = 0;
55775 u.az.pC->cacheStatus = CACHE_STALE;
55781 rc = sqlite3BtreeNext(u.az.pC->pCursor, &u.az.res);
55783 u.az.pC->rowidIsValid = 0;
55790 rc = sqlite3BtreePrevious(u.az.pC->pCursor, &u.az.res);
55792 u.az.pC->rowidIsValid = 0;
55797 u.az.res = sqlite3BtreeEof(u.az.pC->pCursor);
55802 pc = pOp->p2 - 1;
55809 pc = pOp->p2 - 1;
55825 VdbeCursor *pC;
55829 u.ba.pC = p->apCsr[pOp->p1];
55830 assert( u.ba.pC!=0 );
55831 if( ALWAYS(u.ba.pC->pCursor!=0) ){
55832 assert( u.ba.pC->isTable );
55833 u.ba.pC->nullRow = 0;
55835 u.ba.pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
55836 u.ba.pC->rowidIsValid = 0;
55837 u.ba.pC->deferredMoveto = 1;
55871 VdbeCursor *pC;
55885 u.bb.pC = p->apCsr[pOp->p1];
55886 assert( u.bb.pC!=0 );
55888 if( ALWAYS(u.bb.pC->pCursor!=0) ){
55890 assert( u.bb.pC->isTable==0 );
55892 u.bb.r.pKeyInfo = u.bb.pC->pKeyInfo;
55900 u.bb.pIdxKey = sqlite3VdbeRecordUnpack(u.bb.pC->pKeyInfo, pIn3->n, pIn3->z,
55907 rc = sqlite3BtreeMovetoUnpacked(u.bb.pC->pCursor, u.bb.pIdxKey, 0, 0, &u.bb.res);
55915 u.bb.pC->deferredMoveto = 0;
55916 u.bb.pC->cacheStatus = CACHE_STALE;
55919 if( u.bb.alreadyExists ) pc = pOp->p2 - 1;
55921 if( !u.bb.alreadyExists ) pc = pOp->p2 - 1;
55981 pc = pOp->p2 - 1;
56004 pc = pOp->p2 - 1;
56028 VdbeCursor *pC;
56037 u.bd.pC = p->apCsr[pOp->p1];
56038 assert( u.bd.pC!=0 );
56039 assert( u.bd.pC->isTable );
56040 assert( u.bd.pC->pseudoTableReg==0 );
56041 u.bd.pCrsr = u.bd.pC->pCursor;
56046 u.bd.pC->lastRowid = pIn3->u.i;
56047 u.bd.pC->rowidIsValid = u.bd.res==0 ?1:0;
56048 u.bd.pC->nullRow = 0;
56049 u.bd.pC->cacheStatus = CACHE_STALE;
56050 u.bd.pC->deferredMoveto = 0;
56052 pc = pOp->p2 - 1;
56053 assert( u.bd.pC->rowidIsValid==0 );
56055 u.bd.pC->seekResult = u.bd.res;
56060 pc = pOp->p2 - 1;
56061 assert( u.bd.pC->rowidIsValid==0 );
56062 u.bd.pC->seekResult = 0;
56099 VdbeCursor *pC; /* Cursor of table to get the new rowid */
56109 u.be.pC = p->apCsr[pOp->p1];
56110 assert( u.be.pC!=0 );
56111 if( NEVER(u.be.pC->pCursor==0) ){
56127 assert( u.be.pC->isTable );
56140 pC->useRandomRowid ){
56141 u.be.v = sqlite3BtreeGetCachedRowid(u.be.pC->pCursor);
56143 rc = sqlite3BtreeLast(u.be.pC->pCursor, &u.be.res);
56150 assert( sqlite3BtreeCursorIsValid(u.be.pC->pCursor) );
56151 rc = sqlite3BtreeKeySize(u.be.pC->pCursor, &u.be.v);
56154 u.be.pC->useRandomRowid = 1;
56179 if( u.be.pMem->u.i==MAX_ROWID || u.be.pC->useRandomRowid ){
56190 sqlite3BtreeSetCachedRowid(u.be.pC->pCursor, u.be.v<MAX_ROWID ? u.be.v+1 : 0);
56192 if( u.be.pC->useRandomRowid ){
56209 rc = sqlite3BtreeMovetoUnpacked(u.be.pC->pCursor, 0, (u64)u.be.v, 0, &u.be.res);
56217 u.be.pC->rowidIsValid = 0;
56218 u.be.pC->deferredMoveto = 0;
56219 u.be.pC->cacheStatus = CACHE_STALE;
56275 VdbeCursor *pC; /* Cursor to table into which insert is written */
56285 u.bf.pC = p->apCsr[pOp->p1];
56286 assert( u.bf.pC!=0 );
56287 assert( u.bf.pC->pCursor!=0 );
56288 assert( u.bf.pC->pseudoTableReg==0 );
56289 assert( u.bf.pC->isTable );
56310 u.bf.seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bf.pC->seekResult : 0);
56316 sqlite3BtreeSetCachedRowid(u.bf.pC->pCursor, 0);
56317 rc = sqlite3BtreeInsert(u.bf.pC->pCursor, 0, u.bf.iKey,
56321 u.bf.pC->rowidIsValid = 0;
56322 u.bf.pC->deferredMoveto = 0;
56323 u.bf.pC->cacheStatus = CACHE_STALE;
56327 u.bf.zDb = db->aDb[u.bf.pC->iDb].zName;
56330 assert( u.bf.pC->isTable );
56332 assert( u.bf.pC->iDb>=0 );
56360 VdbeCursor *pC;
56365 u.bg.pC = p->apCsr[pOp->p1];
56366 assert( u.bg.pC!=0 );
56367 assert( u.bg.pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
56373 assert( u.bg.pC->isTable );
56374 assert( u.bg.pC->rowidIsValid ); /* lastRowid set by previous OP_NotFound */
56375 u.bg.iKey = u.bg.pC->lastRowid;
56380 ** might move or invalidate the cursor. Hence cursor u.bg.pC is always pointing
56385 assert( u.bg.pC->deferredMoveto==0 );
56386 rc = sqlite3VdbeCursorMoveto(u.bg.pC);
56389 sqlite3BtreeSetCachedRowid(u.bg.pC->pCursor, 0);
56390 rc = sqlite3BtreeDelete(u.bg.pC->pCursor);
56391 u.bg.pC->cacheStatus = CACHE_STALE;
56395 const char *zDb = db->aDb[u.bg.pC->iDb].zName;
56398 assert( u.bg.pC->iDb>=0 );
56439 VdbeCursor *pC;
56449 u.bh.pC = p->apCsr[pOp->p1];
56450 assert( u.bh.pC->isTable || pOp->opcode==OP_RowKey );
56451 assert( u.bh.pC->isIndex || pOp->opcode==OP_RowData );
56452 assert( u.bh.pC!=0 );
56453 assert( u.bh.pC->nullRow==0 );
56454 assert( u.bh.pC->pseudoTableReg==0 );
56455 assert( u.bh.pC->pCursor!=0 );
56456 u.bh.pCrsr = u.bh.pC->pCursor;
56464 assert( u.bh.pC->deferredMoveto==0 );
56465 rc = sqlite3VdbeCursorMoveto(u.bh.pC);
56468 if( u.bh.pC->isIndex ){
56469 assert( !u.bh.pC->isTable );
56488 if( u.bh.pC->isIndex ){
56509 VdbeCursor *pC;
56516 u.bi.pC = p->apCsr[pOp->p1];
56517 assert( u.bi.pC!=0 );
56518 assert( u.bi.pC->pseudoTableReg==0 );
56519 if( u.bi.pC->nullRow ){
56522 }else if( u.bi.pC->deferredMoveto ){
56523 u.bi.v = u.bi.pC->movetoTarget;
56525 }else if( u.bi.pC->pVtabCursor ){
56526 u.bi.pVtab = u.bi.pC->pVtabCursor->pVtab;
56529 rc = u.bi.pModule->xRowid(u.bi.pC->pVtabCursor, &u.bi.v);
56535 assert( u.bi.pC->pCursor!=0 );
56536 rc = sqlite3VdbeCursorMoveto(u.bi.pC);
56538 if( u.bi.pC->rowidIsValid ){
56539 u.bi.v = u.bi.pC->lastRowid;
56541 rc = sqlite3BtreeKeySize(u.bi.pC->pCursor, &u.bi.v);
56557 VdbeCursor *pC;
56561 u.bj.pC = p->apCsr[pOp->p1];
56562 assert( u.bj.pC!=0 );
56563 u.bj.pC->nullRow = 1;
56564 u.bj.pC->rowidIsValid = 0;
56565 if( u.bj.pC->pCursor ){
56566 sqlite3BtreeClearCursor(u.bj.pC->pCursor);
56581 VdbeCursor *pC;
56587 u.bk.pC = p->apCsr[pOp->p1];
56588 assert( u.bk.pC!=0 );
56589 u.bk.pCrsr = u.bk.pC->pCursor;
56595 u.bk.pC->nullRow = (u8)u.bk.res;
56596 u.bk.pC->deferredMoveto = 0;
56597 u.bk.pC->rowidIsValid = 0;
56598 u.bk.pC->cacheStatus = CACHE_STALE;
56600 pc = pOp->p2 - 1;
56636 VdbeCursor *pC;
56642 u.bl.pC = p->apCsr[pOp->p1];
56643 assert( u.bl.pC!=0 );
56644 if( (u.bl.pCrsr = u.bl.pC->pCursor)!=0 ){
56646 u.bl.pC->atFirst = u.bl.res==0 ?1:0;
56647 u.bl.pC->deferredMoveto = 0;
56648 u.bl.pC->cacheStatus = CACHE_STALE;
56649 u.bl.pC->rowidIsValid = 0;
56653 u.bl.pC->nullRow = (u8)u.bl.res;
56656 pc = pOp->p2 - 1;
56684 VdbeCursor *pC;
56691 u.bm.pC = p->apCsr[pOp->p1];
56692 if( u.bm.pC==0 ){
56695 u.bm.pCrsr = u.bm.pC->pCursor;
56697 u.bm.pC->nullRow = 1;
56701 assert( u.bm.pC->deferredMoveto==0 );
56704 u.bm.pC->nullRow = (u8)u.bm.res;
56705 u.bm.pC->cacheStatus = CACHE_STALE;
56707 pc = pOp->p2 - 1;
56713 u.bm.pC->rowidIsValid = 0;
56731 VdbeCursor *pC;
56738 u.bn.pC = p->apCsr[pOp->p1];
56739 assert( u.bn.pC!=0 );
56742 u.bn.pCrsr = u.bn.pC->pCursor;
56744 assert( u.bn.pC->isTable==0 );
56750 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bn.pC->seekResult : 0)
56752 assert( u.bn.pC->deferredMoveto==0 );
56753 u.bn.pC->cacheStatus = CACHE_STALE;
56767 VdbeCursor *pC;
56776 u.bo.pC = p->apCsr[pOp->p1];
56777 assert( u.bo.pC!=0 );
56778 u.bo.pCrsr = u.bo.pC->pCursor;
56780 u.bo.r.pKeyInfo = u.bo.pC->pKeyInfo;
56788 assert( u.bo.pC->deferredMoveto==0 );
56789 u.bo.pC->cacheStatus = CACHE_STALE;
56805 VdbeCursor *pC;
56810 u.bp.pC = p->apCsr[pOp->p1];
56811 assert( u.bp.pC!=0 );
56812 u.bp.pCrsr = u.bp.pC->pCursor;
56815 rc = sqlite3VdbeCursorMoveto(u.bp.pC);
56817 assert( u.bp.pC->deferredMoveto==0 );
56818 assert( u.bp.pC->isTable==0 );
56819 if( !u.bp.pC->nullRow ){
56860 VdbeCursor *pC;
56866 u.bq.pC = p->apCsr[pOp->p1];
56867 assert( u.bq.pC!=0 );
56868 if( ALWAYS(u.bq.pC->pCursor!=0) ){
56869 assert( u.bq.pC->deferredMoveto==0 );
56872 u.bq.r.pKeyInfo = u.bq.pC->pKeyInfo;
56880 rc = sqlite3VdbeIdxKeyCompare(u.bq.pC, &u.bq.r, &u.bq.res);
56888 pc = pOp->p2 - 1 ;
56924 if( u.br.pVdbe->magic==VDBE_MAGIC_RUN && u.br.pVdbe->inVtabMethod<2 && u.br.pVdbe->pc>=0 ){
57260 pc = pOp->p2 - 1;
57317 pc = pOp->p2 - 1;
57407 u.by.pFrame->pc = pc;
57425 assert( pc==u.by.pFrame->pc );
57440 pc = -1;
57463 u.bz.pIn = &u.bz.pFrame->aMem[pOp->p1 + u.bz.pFrame->aOp[u.bz.pFrame->pc].p1];
57500 if( db->nDeferredCons==0 ) pc = pOp->p2-1;
57502 if( p->nFkConstraint==0 ) pc = pOp->p2-1;
57551 pc = pOp->p2 - 1;
57567 pc = pOp->p2 - 1;
57585 pc = pOp->p2 - 1;
57707 pc = pOp->p2 - 1;
57925 pc = pOp->p2 - 1;
58037 pc = pOp->p2 - 1;
58226 assert( pc>=-1 && pc<p->nOp );
58248 sqlite3_log(rc, "prepared statement aborts at %d: [%s]", pc, p->zSql);
79363 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
79385 apAll[2] = pC;
79407 if( pC==0 ){ zSp++; }
79409 "%T %T%s%T", pA, pB, zSp, pC);
82694 struct AggInfo_col *pC;
82740 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
82741 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
88004 u8 c, *pC; /* Last character before the first wildcard */
88005 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
88006 c = *pC;
88018 *pC = c + 1;
107273 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
107284 rc = pMod->xOpen(pTab->pTokenizer, zDoc, nDoc, &pC);
107286 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iStart, &DUMMY2, &iCurrent);
107297 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
107321 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
107330 pMod->xClose(pC);
