Lines Matching defs:pc
9843 #define OP_SequenceTest 59 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */
14643 int pc; /* Program Counter in parent (calling) frame */
14838 int pc; /* The program counter */
25142 /* 59 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
39199 int i, nx, pc, op;
39214 pc = 0;
39215 while( (op = aOp[pc])!=0 ){
39221 i = aOp[pc+2] - 1;
39222 aOp[pc+2] += aOp[pc+3];
39233 if( (--aOp[pc+1]) > 0 ) nx = 0;
39234 pc += nx;
54233 int pc; /* Address of the i-th cell */
54265 pc = get2byte(pAddr);
54266 testcase( pc==iCellFirst );
54267 testcase( pc==iCellLast );
54272 if( pc<iCellFirst || pc>iCellLast ){
54276 assert( pc>=iCellFirst && pc<=iCellLast );
54277 size = cellSizePtr(pPage, &src[pc]);
54284 if( cbrk<iCellFirst || pc+size>usableSize ){
54290 testcase( pc+size==usableSize );
54294 if( cbrk==pc ) continue;
54300 memcpy(&data[cbrk], &src[pc], size);
54333 int pc;
54336 for(iAddr=hdr+1; (pc = get2byte(&aData[iAddr]))>0; iAddr=pc){
54340 if( pc>usableSize-4 || pc<iAddr+4 ){
54347 size = get2byte(&aData[pc+2]);
54361 memcpy(&aData[iAddr], &aData[pc], 2);
54363 }else if( size+pc > usableSize ){
54369 put2byte(&aData[pc+2], x);
54371 return &aData[pc + x];
54634 u16 pc; /* Address of a freeblock within pPage->aData[] */
54693 pc = get2byte(&data[cellOffset+i*2]);
54694 testcase( pc==iCellFirst );
54695 testcase( pc==iCellLast );
54696 if( pc<iCellFirst || pc>iCellLast ){
54699 sz = cellSizePtr(pPage, &data[pc]);
54700 testcase( pc+sz==usableSize );
54701 if( pc+sz>usableSize ){
54713 pc = get2byte(&data[hdr+1]);
54715 while( pc>0 ){
54717 if( pc<iCellFirst || pc>iCellLast ){
54725 next = get2byte(&data[pc]);
54726 size = get2byte(&data[pc+2]);
54727 if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){
54733 pc = next;
59066 u32 pc; /* Offset to cell content of cell being deleted */
59080 pc = get2byte(ptr);
59082 testcase( pc==get2byte(&data[hdr+5]) );
59083 testcase( pc+sz==pPage->pBt->usableSize );
59084 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
59088 rc = freeSpace(pPage, pc, sz);
61847 int pc = get2byte(&data[cellStart+i*2]);
61849 if( pc<=usableSize-4 ){
61850 size = cellSizePtr(pPage, &data[pc]);
61852 if( (int)(pc+size-1)>=usableSize ){
61857 btreeHeapInsert(heap, (pc<<16)|(pc+size-1));
66031 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
66046 fprintf(pOut, zFormat1, pc,
66167 ** encountered, but p->pc will eventually catch up to nRow.
66189 i = p->pc++;
66419 p->pc = -1;
66599 VdbeCursor *pC = p->apCsr[i];
66600 if( pC ){
66601 sqlite3VdbeFreeCursor(p, pC);
66630 return pFrame->pc;
67152 if( p->pc>=0 && p->bIsReader ){
67291 if( p->pc>=0 ){
67357 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
67398 if( p->pc>=0 ){
67431 char c, pc = 0;
67434 if( pc=='\n' ) fprintf(out, "-- ");
67436 pc = c;
67438 if( pc!='\n' ) fprintf(out, "\n");
68859 ** Compare the key of the index entry that cursor pC is pointing to against
68861 ** that is negative, zero, or positive if pC is less than, equal to,
68871 VdbeCursor *pC, /* The cursor to compare against */
68877 BtCursor *pCur = pC->pCursor;
68890 rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (u32)nCellKey, 1, &m);
69465 if( p->pc<=0 && p->expired ){
69470 if( p->pc<0 ){
69492 p->pc = 0;
69572 int savedPc = v->pc;
70139 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
70460 return v!=0 && v->pc>=0 && v->magic==VDBE_MAGIC_RUN;
71446 if( p->pc==0
71471 for(pOp=&aOp[p->pc]; rc==SQLITE_OK; pOp++){
71804 p->pc = pcx;
72201 p->pc = (int)(pOp - aOp) + 1;
73150 VdbeCursor *pC; /* The VDBE cursor */
73172 pC = p->apCsr[pOp->p1];
73173 assert( pC!=0 );
73174 assert( p2<pC->nField );
73175 aOffset = pC->aOffset;
73177 assert( pC->pVtabCursor==0 ); /* OP_Column never called on virtual table */
73179 pCrsr = pC->pCursor;
73180 assert( pCrsr!=0 || pC->pseudoTableReg>0 ); /* pCrsr NULL on PseudoTables */
73181 assert( pCrsr!=0 || pC->nullRow ); /* pC->nullRow on PseudoTables */
73184 rc = sqlite3VdbeCursorMoveto(pC);
73186 if( pC->cacheStatus!=p->cacheCtr ){
73187 if( pC->nullRow ){
73189 assert( pC->pseudoTableReg>0 );
73190 pReg = &aMem[pC->pseudoTableReg];
73193 pC->payloadSize = pC->szRow = avail = pReg->n;
73194 pC->aRow = (u8*)pReg->z;
73201 if( pC->isTable==0 ){
73209 pC->aRow = sqlite3BtreeKeyFetch(pCrsr, &avail);
73210 pC->payloadSize = (u32)payloadSize64;
73213 VVA_ONLY(rc =) sqlite3BtreeDataSize(pCrsr, &pC->payloadSize);
73215 pC->aRow = sqlite3BtreeDataFetch(pCrsr, &avail);
73218 if( pC->payloadSize <= (u32)avail ){
73219 pC->szRow = pC->payloadSize;
73221 pC->szRow = avail;
73223 if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
73227 pC->cacheStatus = p->cacheCtr;
73228 pC->iHdrOffset = getVarint32(pC->aRow, offset);
73229 pC->nHdrParsed = 0;
73241 if( offset > 98307 || offset > pC->payloadSize ){
73247 /* pC->aRow does not have to hold the entire row, but it does at least
73248 ** need to cover the header of the record. If pC->aRow does not contain
73251 pC->aRow = 0;
73252 pC->szRow = 0;
73259 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
73264 ** parsed and valid information is in aOffset[] and pC->aType[].
73266 if( pC->nHdrParsed<=p2 ){
73271 if( pC->iHdrOffset<aOffset[0] ){
73273 if( pC->aRow==0 ){
73276 !pC->isTable, &sMem);
73282 zData = pC->aRow;
73285 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
73286 i = pC->nHdrParsed;
73288 zHdr = zData + pC->iHdrOffset;
73298 pC->aType[i] = t;
73308 pC->nHdrParsed = i;
73309 pC->iHdrOffset = (u32)(zHdr - zData);
73310 if( pC->aRow==0 ){
73319 ** (zHdr==zEndHdr && offset!=pC->payloadSize)
73321 ** (offset > pC->payloadSize)
73323 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset!=pC->payloadSize))
73324 || (offset > pC->payloadSize)
73335 if( pC->nHdrParsed<=p2 ){
73346 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
73349 assert( p2<pC->nHdrParsed );
73353 t = pC->aType[p2];
73354 if( pC->szRow>=aOffset[p2+1] ){
73357 sqlite3VdbeSerialGet(pC->aRow+aOffset[p2], t, pDest);
73374 rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, !pC->isTable,
73720 p->pc = (int)(pOp - aOp);
73839 p->pc = (int)(pOp - aOp);
73916 p->pc = (int)(pOp - aOp);
74319 ** Synopsis: if( cursor[P1].ctr++ ) pc = P2
74326 VdbeCursor *pC;
74328 pC = p->apCsr[pOp->p1];
74329 assert( pC->pSorter );
74330 if( (pC->seqCount++)==0 ){
74456 VdbeCursor *pC;
74463 pC = p->apCsr[pOp->p1];
74464 assert( pC!=0 );
74465 assert( pC->pseudoTableReg==0 );
74469 assert( pC->isOrdered );
74470 assert( pC->pCursor!=0 );
74472 pC->nullRow = 0;
74474 pC->seekOp = pOp->opcode;
74482 if( sqlite3BtreeCursorHasHint(pC->pCursor, BTREE_SEEK_EQ) ){
74492 if( pC->isTable ){
74535 rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)iKey, 0, &res);
74536 pC->movetoTarget = iKey; /* Used by OP_Delete */
74544 r.pKeyInfo = pC->pKeyInfo;
74565 rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, &r, 0, 0, &res);
74570 pC->deferredMoveto = 0;
74571 pC->cacheStatus = CACHE_STALE;
74578 rc = sqlite3BtreeNext(pC->pCursor, &res);
74587 rc = sqlite3BtreePrevious(pC->pCursor, &res);
74593 res = sqlite3BtreeEof(pC->pCursor);
74615 VdbeCursor *pC;
74618 pC = p->apCsr[pOp->p1];
74619 assert( pC!=0 );
74620 assert( pC->pCursor!=0 );
74621 assert( pC->isTable );
74622 pC->nullRow = 0;
74624 pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
74625 pC->deferredMoveto = 1;
74695 VdbeCursor *pC;
74708 pC = p->apCsr[pOp->p1];
74709 assert( pC!=0 );
74711 pC->seekOp = pOp->opcode;
74714 assert( pC->pCursor!=0 );
74715 assert( pC->isTable==0 );
74718 r.pKeyInfo = pC->pKeyInfo;
74731 pC->pKeyInfo, aTempRec, sizeof(aTempRec), &pFree
74736 sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
74751 rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, pIdxKey, 0, 0, &res);
74756 pC->seekResult = res;
74758 pC->nullRow = 1-alreadyExists;
74759 pC->deferredMoveto = 0;
74760 pC->cacheStatus = CACHE_STALE;
74790 VdbeCursor *pC;
74798 pC = p->apCsr[pOp->p1];
74799 assert( pC!=0 );
74801 pC->seekOp = 0;
74803 assert( pC->isTable );
74804 assert( pC->pseudoTableReg==0 );
74805 pCrsr = pC->pCursor;
74810 pC->movetoTarget = iKey; /* Used by OP_Delete */
74811 pC->nullRow = 0;
74812 pC->cacheStatus = CACHE_STALE;
74813 pC->deferredMoveto = 0;
74815 pC->seekResult = res;
74854 VdbeCursor *pC; /* Cursor of table to get the new rowid */
74864 pC = p->apCsr[pOp->p1];
74865 assert( pC!=0 );
74866 if( NEVER(pC->pCursor==0) ){
74882 assert( pC->isTable );
74894 if( !pC->useRandomRowid ){
74895 rc = sqlite3BtreeLast(pC->pCursor, &res);
74902 assert( sqlite3BtreeCursorIsValid(pC->pCursor) );
74903 rc = sqlite3BtreeKeySize(pC->pCursor, &v);
74906 pC->useRandomRowid = 1;
74933 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
74943 if( pC->useRandomRowid ){
74954 }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)v,
74964 pC->deferredMoveto = 0;
74965 pC->cacheStatus = CACHE_STALE;
75022 VdbeCursor *pC; /* Cursor to table into which insert is written */
75032 pC = p->apCsr[pOp->p1];
75033 assert( pC!=0 );
75034 assert( pC->pCursor!=0 );
75035 assert( pC->pseudoTableReg==0 );
75036 assert( pC->isTable );
75058 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
75064 rc = sqlite3BtreeInsert(pC->pCursor, 0, iKey,
75068 pC->deferredMoveto = 0;
75069 pC->cacheStatus = CACHE_STALE;
75073 zDb = db->aDb[pC->iDb].zName;
75076 assert( pC->isTable );
75078 assert( pC->iDb>=0 );
75104 VdbeCursor *pC;
75107 pC = p->apCsr[pOp->p1];
75108 assert( pC!=0 );
75109 assert( pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
75110 assert( pC->deferredMoveto==0 );
75114 ** have also set the pC->movetoTarget field to the rowid of the row that
75116 if( pOp->p4.z && pC->isTable ){
75118 sqlite3BtreeKeySize(pC->pCursor, &iKey);
75119 assert( pC->movetoTarget==iKey );
75123 rc = sqlite3BtreeDelete(pC->pCursor);
75124 pC->cacheStatus = CACHE_STALE;
75127 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z && pC->isTable ){
75129 db->aDb[pC->iDb].zName, pOp->p4.z, pC->movetoTarget);
75130 assert( pC->iDb>=0 );
75164 VdbeCursor *pC;
75168 pC = p->apCsr[pOp->p1];
75169 assert( isSorter(pC) );
75174 rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
75193 VdbeCursor *pC;
75196 pC = p->apCsr[pOp->p1];
75197 assert( isSorter(pC) );
75198 rc = sqlite3VdbeSorterRowkey(pC, pOut);
75229 VdbeCursor *pC;
75239 pC = p->apCsr[pOp->p1];
75240 assert( isSorter(pC)==0 );
75241 assert( pC->isTable || pOp->opcode!=OP_RowData );
75242 assert( pC->isTable==0 || pOp->opcode==OP_RowData );
75243 assert( pC!=0 );
75244 assert( pC->nullRow==0 );
75245 assert( pC->pseudoTableReg==0 );
75246 assert( pC->pCursor!=0 );
75247 pCrsr = pC->pCursor;
75256 assert( pC->deferredMoveto==0 );
75259 rc = sqlite3VdbeCursorMoveto(pC);
75263 if( pC->isTable==0 ){
75264 assert( !pC->isTable );
75284 if( pC->isTable==0 ){
75306 VdbeCursor *pC;
75313 pC = p->apCsr[pOp->p1];
75314 assert( pC!=0 );
75315 assert( pC->pseudoTableReg==0 || pC->nullRow );
75316 if( pC->nullRow ){
75319 }else if( pC->deferredMoveto ){
75320 v = pC->movetoTarget;
75322 }else if( pC->pVtabCursor ){
75323 pVtab = pC->pVtabCursor->pVtab;
75326 rc = pModule->xRowid(pC->pVtabCursor, &v);
75330 assert( pC->pCursor!=0 );
75331 rc = sqlite3VdbeCursorRestore(pC);
75333 if( pC->nullRow ){
75337 rc = sqlite3BtreeKeySize(pC->pCursor, &v);
75351 VdbeCursor *pC;
75354 pC = p->apCsr[pOp->p1];
75355 assert( pC!=0 );
75356 pC->nullRow = 1;
75357 pC->cacheStatus = CACHE_STALE;
75358 if( pC->pCursor ){
75359 sqlite3BtreeClearCursor(pC->pCursor);
75377 VdbeCursor *pC;
75382 pC = p->apCsr[pOp->p1];
75383 assert( pC!=0 );
75384 pCrsr = pC->pCursor;
75388 pC->nullRow = (u8)res;
75389 pC->deferredMoveto = 0;
75390 pC->cacheStatus = CACHE_STALE;
75391 pC->seekResult = pOp->p3;
75393 pC->seekOp = OP_Last;
75437 VdbeCursor *pC;
75442 pC = p->apCsr[pOp->p1];
75443 assert( pC!=0 );
75444 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
75447 pC->seekOp = OP_Rewind;
75449 if( isSorter(pC) ){
75450 rc = sqlite3VdbeSorterRewind(pC, &res);
75452 pCrsr = pC->pCursor;
75455 pC->deferredMoveto = 0;
75456 pC->cacheStatus = CACHE_STALE;
75458 pC->nullRow = (u8)res;
75529 VdbeCursor *pC;
75532 pC = p->apCsr[pOp->p1];
75533 assert( isSorter(pC) );
75535 rc = sqlite3VdbeSorterNext(db, pC, &res);
75545 pC = p->apCsr[pOp->p1];
75547 assert( pC!=0 );
75548 assert( pC->deferredMoveto==0 );
75549 assert( pC->pCursor );
75550 assert( res==0 || (res==1 && pC->isTable==0) );
75560 || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
75561 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found);
75563 || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
75564 || pC->seekOp==OP_Last );
75566 rc = pOp->p4.xAdvance(pC->pCursor, &res);
75568 pC->cacheStatus = CACHE_STALE;
75571 pC->nullRow = 0;
75578 pC->nullRow = 1;
75606 VdbeCursor *pC;
75612 pC = p->apCsr[pOp->p1];
75613 assert( pC!=0 );
75614 assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
75617 pCrsr = pC->pCursor;
75620 assert( pC->isTable==0 );
75623 if( isSorter(pC) ){
75624 rc = sqlite3VdbeSorterWrite(pC, pIn2);
75629 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
75631 assert( pC->deferredMoveto==0 );
75632 pC->cacheStatus = CACHE_STALE;
75646 VdbeCursor *pC;
75654 pC = p->apCsr[pOp->p1];
75655 assert( pC!=0 );
75656 pCrsr = pC->pCursor;
75659 r.pKeyInfo = pC->pKeyInfo;
75670 assert( pC->deferredMoveto==0 );
75671 pC->cacheStatus = CACHE_STALE;
75686 VdbeCursor *pC;
75691 pC = p->apCsr[pOp->p1];
75692 assert( pC!=0 );
75693 pCrsr = pC->pCursor;
75696 assert( pC->isTable==0 );
75697 assert( pC->deferredMoveto==0 );
75703 rc = sqlite3VdbeCursorRestore(pC);
75706 if( !pC->nullRow ){
75766 VdbeCursor *pC;
75771 pC = p->apCsr[pOp->p1];
75772 assert( pC!=0 );
75773 assert( pC->isOrdered );
75774 assert( pC->pCursor!=0);
75775 assert( pC->deferredMoveto==0 );
75778 r.pKeyInfo = pC->pKeyInfo;
75792 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
75902 VdbeCursor *pC;
75905 pC = p->apCsr[pOp->p1];
75906 assert( pC!=0 );
75907 if( pC->pSorter ){
75908 sqlite3VdbeSorterReset(db, pC->pSorter);
75910 assert( pC->isEphemeral );
75911 rc = sqlite3BtreeClearTableOfCursor(pC->pCursor);
76317 pFrame->pc = (int)(pOp - aOp);
76340 assert( (int)(pOp - aOp)==pFrame->pc );
76384 pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
77507 VdbeCursor *pC = v->apCsr[0];
77508 u32 type = pC->aType[p->iCol];
77517 p->iOffset = pC->aType[p->iCol + pC->nField];
77519 p->pCsr = pC->pCursor;
106675 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
106697 apAll[2] = pC;
106719 if( pC==0 ){ zSp++; }
106721 "%T %T%s%T", pA, pB, zSp, pC);
111079 struct AggInfo_col *pC;
111130 ** to pC->iMem. But by the time the value is used, the original register
111141 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
111142 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
117581 u8 c, *pC; /* Last character before the first wildcard */
117582 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
117583 c = *pC;
117594 *pC = c + 1;
149227 sqlite3_tokenizer_cursor *pC;
149233 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
149239 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
149241 pMod->xClose(pC);
149281 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
149294 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
149317 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
149369 pMod->xClose(pC);
150095 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
150130 zDoc, nDoc, &pC
150134 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
150159 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
150176 pMod->xClose(pC);
150550 sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */
150557 unicode_cursor *pCsr = (unicode_cursor *)pC;
