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"),
39181 int i, nx, pc, op;
39196 pc = 0;
39197 while( (op = aOp[pc])!=0 ){
39203 i = aOp[pc+2] - 1;
39204 aOp[pc+2] += aOp[pc+3];
39215 if( (--aOp[pc+1]) > 0 ) nx = 0;
39216 pc += nx;
54215 int pc; /* Address of the i-th cell */
54247 pc = get2byte(pAddr);
54248 testcase( pc==iCellFirst );
54249 testcase( pc==iCellLast );
54254 if( pc<iCellFirst || pc>iCellLast ){
54258 assert( pc>=iCellFirst && pc<=iCellLast );
54259 size = cellSizePtr(pPage, &src[pc]);
54266 if( cbrk<iCellFirst || pc+size>usableSize ){
54272 testcase( pc+size==usableSize );
54276 if( cbrk==pc ) continue;
54282 memcpy(&data[cbrk], &src[pc], size);
54315 int pc;
54318 for(iAddr=hdr+1; (pc = get2byte(&aData[iAddr]))>0; iAddr=pc){
54322 if( pc>usableSize-4 || pc<iAddr+4 ){
54329 size = get2byte(&aData[pc+2]);
54343 memcpy(&aData[iAddr], &aData[pc], 2);
54345 }else if( size+pc > usableSize ){
54351 put2byte(&aData[pc+2], x);
54353 return &aData[pc + x];
54616 u16 pc; /* Address of a freeblock within pPage->aData[] */
54675 pc = get2byte(&data[cellOffset+i*2]);
54676 testcase( pc==iCellFirst );
54677 testcase( pc==iCellLast );
54678 if( pc<iCellFirst || pc>iCellLast ){
54681 sz = cellSizePtr(pPage, &data[pc]);
54682 testcase( pc+sz==usableSize );
54683 if( pc+sz>usableSize ){
54695 pc = get2byte(&data[hdr+1]);
54697 while( pc>0 ){
54699 if( pc<iCellFirst || pc>iCellLast ){
54707 next = get2byte(&data[pc]);
54708 size = get2byte(&data[pc+2]);
54709 if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){
54715 pc = next;
59048 u32 pc; /* Offset to cell content of cell being deleted */
59062 pc = get2byte(ptr);
59064 testcase( pc==get2byte(&data[hdr+5]) );
59065 testcase( pc+sz==pPage->pBt->usableSize );
59066 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
59070 rc = freeSpace(pPage, pc, sz);
61829 int pc = get2byte(&data[cellStart+i*2]);
61831 if( pc<=usableSize-4 ){
61832 size = cellSizePtr(pPage, &data[pc]);
61834 if( (int)(pc+size-1)>=usableSize ){
61839 btreeHeapInsert(heap, (pc<<16)|(pc+size-1));
66013 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
66028 fprintf(pOut, zFormat1, pc,
66149 ** encountered, but p->pc will eventually catch up to nRow.
66171 i = p->pc++;
66401 p->pc = -1;
66581 VdbeCursor *pC = p->apCsr[i];
66582 if( pC ){
66583 sqlite3VdbeFreeCursor(p, pC);
66612 return pFrame->pc;
67134 if( p->pc>=0 && p->bIsReader ){
67273 if( p->pc>=0 ){
67339 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
67380 if( p->pc>=0 ){
67413 char c, pc = 0;
67416 if( pc=='\n' ) fprintf(out, "-- ");
67418 pc = c;
67420 if( pc!='\n' ) fprintf(out, "\n");
68841 ** Compare the key of the index entry that cursor pC is pointing to against
68843 ** that is negative, zero, or positive if pC is less than, equal to,
68853 VdbeCursor *pC, /* The cursor to compare against */
68859 BtCursor *pCur = pC->pCursor;
68872 rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (u32)nCellKey, 1, &m);
69447 if( p->pc<=0 && p->expired ){
69452 if( p->pc<0 ){
69474 p->pc = 0;
69554 int savedPc = v->pc;
70121 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
70442 return v!=0 && v->pc>=0 && v->magic==VDBE_MAGIC_RUN;
71428 if( p->pc==0
71453 for(pOp=&aOp[p->pc]; rc==SQLITE_OK; pOp++){
71786 p->pc = pcx;
72183 p->pc = (int)(pOp - aOp) + 1;
73132 VdbeCursor *pC; /* The VDBE cursor */
73154 pC = p->apCsr[pOp->p1];
73155 assert( pC!=0 );
73156 assert( p2<pC->nField );
73157 aOffset = pC->aOffset;
73159 assert( pC->pVtabCursor==0 ); /* OP_Column never called on virtual table */
73161 pCrsr = pC->pCursor;
73162 assert( pCrsr!=0 || pC->pseudoTableReg>0 ); /* pCrsr NULL on PseudoTables */
73163 assert( pCrsr!=0 || pC->nullRow ); /* pC->nullRow on PseudoTables */
73166 rc = sqlite3VdbeCursorMoveto(pC);
73168 if( pC->cacheStatus!=p->cacheCtr ){
73169 if( pC->nullRow ){
73171 assert( pC->pseudoTableReg>0 );
73172 pReg = &aMem[pC->pseudoTableReg];
73175 pC->payloadSize = pC->szRow = avail = pReg->n;
73176 pC->aRow = (u8*)pReg->z;
73183 if( pC->isTable==0 ){
73191 pC->aRow = sqlite3BtreeKeyFetch(pCrsr, &avail);
73192 pC->payloadSize = (u32)payloadSize64;
73195 VVA_ONLY(rc =) sqlite3BtreeDataSize(pCrsr, &pC->payloadSize);
73197 pC->aRow = sqlite3BtreeDataFetch(pCrsr, &avail);
73200 if( pC->payloadSize <= (u32)avail ){
73201 pC->szRow = pC->payloadSize;
73203 pC->szRow = avail;
73205 if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
73209 pC->cacheStatus = p->cacheCtr;
73210 pC->iHdrOffset = getVarint32(pC->aRow, offset);
73211 pC->nHdrParsed = 0;
73223 if( offset > 98307 || offset > pC->payloadSize ){
73229 /* pC->aRow does not have to hold the entire row, but it does at least
73230 ** need to cover the header of the record. If pC->aRow does not contain
73233 pC->aRow = 0;
73234 pC->szRow = 0;
73241 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
73246 ** parsed and valid information is in aOffset[] and pC->aType[].
73248 if( pC->nHdrParsed<=p2 ){
73253 if( pC->iHdrOffset<aOffset[0] ){
73255 if( pC->aRow==0 ){
73258 !pC->isTable, &sMem);
73264 zData = pC->aRow;
73267 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
73268 i = pC->nHdrParsed;
73270 zHdr = zData + pC->iHdrOffset;
73280 pC->aType[i] = t;
73290 pC->nHdrParsed = i;
73291 pC->iHdrOffset = (u32)(zHdr - zData);
73292 if( pC->aRow==0 ){
73301 ** (zHdr==zEndHdr && offset!=pC->payloadSize)
73303 ** (offset > pC->payloadSize)
73305 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset!=pC->payloadSize))
73306 || (offset > pC->payloadSize)
73317 if( pC->nHdrParsed<=p2 ){
73328 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
73331 assert( p2<pC->nHdrParsed );
73335 t = pC->aType[p2];
73336 if( pC->szRow>=aOffset[p2+1] ){
73339 sqlite3VdbeSerialGet(pC->aRow+aOffset[p2], t, pDest);
73356 rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, !pC->isTable,
73702 p->pc = (int)(pOp - aOp);
73821 p->pc = (int)(pOp - aOp);
73898 p->pc = (int)(pOp - aOp);
74301 ** Synopsis: if( cursor[P1].ctr++ ) pc = P2
74308 VdbeCursor *pC;
74310 pC = p->apCsr[pOp->p1];
74311 assert( pC->pSorter );
74312 if( (pC
74438 VdbeCursor *pC;
74445 pC = p->apCsr[pOp->p1];
74446 assert( pC!=0 );
74447 assert( pC->pseudoTableReg==0 );
74451 assert( pC->isOrdered );
74452 assert( pC->pCursor!=0 );
74454 pC->nullRow = 0;
74456 pC->seekOp = pOp->opcode;
74464 if( sqlite3BtreeCursorHasHint(pC->pCursor, BTREE_SEEK_EQ) ){
74474 if( pC->isTable ){
74517 rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)iKey, 0, &res);
74518 pC->movetoTarget = iKey; /* Used by OP_Delete */
74526 r.pKeyInfo = pC->pKeyInfo;
74547 rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, &r, 0, 0, &res);
74552 pC->deferredMoveto = 0;
74553 pC->cacheStatus = CACHE_STALE;
74560 rc = sqlite3BtreeNext(pC->pCursor, &res);
74569 rc = sqlite3BtreePrevious(pC->pCursor, &res);
74575 res = sqlite3BtreeEof(pC->pCursor);
74597 VdbeCursor *pC;
74600 pC = p->apCsr[pOp->p1];
74601 assert( pC!=0 );
74602 assert( pC->pCursor!=0 );
74603 assert( pC->isTable );
74604 pC->nullRow = 0;
74606 pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
74607 pC->deferredMoveto = 1;
74677 VdbeCursor *pC;
74690 pC = p->apCsr[pOp->p1];
74691 assert( pC!=0 );
74693 pC->seekOp = pOp->opcode;
74696 assert( pC->pCursor!=0 );
74697 assert( pC->isTable==0 );
74700 r.pKeyInfo = pC->pKeyInfo;
74713 pC->pKeyInfo, aTempRec, sizeof(aTempRec), &pFree
74718 sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
74733 rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, pIdxKey, 0, 0, &res);
74738 pC->seekResult = res;
74740 pC->nullRow = 1-alreadyExists;
74741 pC->deferredMoveto = 0;
74742 pC->cacheStatus = CACHE_STALE;
74772 VdbeCursor *pC;
74780 pC = p->apCsr[pOp->p1];
74781 assert( pC!=0 );
74783 pC->seekOp = 0;
74785 assert( pC->isTable );
74786 assert( pC->pseudoTableReg==0 );
74787 pCrsr = pC->pCursor;
74792 pC->movetoTarget = iKey; /* Used by OP_Delete */
74793 pC->nullRow = 0;
74794 pC->cacheStatus = CACHE_STALE;
74795 pC->deferredMoveto = 0;
74797 pC->seekResult = res;
74836 VdbeCursor *pC; /* Cursor of table to get the new rowid */
74846 pC = p->apCsr[pOp->p1];
74847 assert( pC!=0 );
74848 if( NEVER(pC->pCursor==0) ){
74864 assert( pC->isTable );
74876 if( !pC->useRandomRowid ){
74877 rc = sqlite3BtreeLast(pC->pCursor, &res);
74884 assert( sqlite3BtreeCursorIsValid(pC->pCursor) );
74885 rc = sqlite3BtreeKeySize(pC->pCursor, &v);
74888 pC->useRandomRowid = 1;
74915 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
74925 if( pC->useRandomRowid ){
74936 }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)v,
74946 pC->deferredMoveto = 0;
74947 pC->cacheStatus = CACHE_STALE;
75004 VdbeCursor *pC; /* Cursor to table into which insert is written */
75014 pC = p->apCsr[pOp->p1];
75015 assert( pC!=0 );
75016 assert( pC->pCursor!=0 );
75017 assert( pC->pseudoTableReg==0 );
75018 assert( pC->isTable );
75040 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
75046 rc = sqlite3BtreeInsert(pC->pCursor, 0, iKey,
75050 pC->deferredMoveto = 0;
75051 pC->cacheStatus = CACHE_STALE;
75055 zDb = db->aDb[pC->iDb].zName;
75058 assert( pC->isTable );
75060 assert( pC->iDb>=0 );
75086 VdbeCursor *pC;
75089 pC = p->apCsr[pOp->p1];
75090 assert( pC!=0 );
75091 assert( pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
75092 assert( pC->deferredMoveto==0 );
75096 ** have also set the pC->movetoTarget field to the rowid of the row that
75098 if( pOp->p4.z && pC->isTable ){
75100 sqlite3BtreeKeySize(pC->pCursor, &iKey);
75101 assert( pC->movetoTarget==iKey );
75105 rc = sqlite3BtreeDelete(pC->pCursor);
75106 pC->cacheStatus = CACHE_STALE;
75109 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z && pC->isTable ){
75111 db->aDb[pC->iDb].zName, pOp->p4.z, pC->movetoTarget);
75112 assert( pC->iDb>=0 );
75146 VdbeCursor *pC;
75150 pC = p->apCsr[pOp->p1];
75151 assert( isSorter(pC) );
75156 rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
75175 VdbeCursor *pC;
75178 pC = p->apCsr[pOp->p1];
75179 assert( isSorter(pC) );
75180 rc = sqlite3VdbeSorterRowkey(pC, pOut);
75211 VdbeCursor *pC;
75221 pC = p->apCsr[pOp->p1];
75222 assert( isSorter(pC)==0 );
75223 assert( pC->isTable || pOp->opcode!=OP_RowData );
75224 assert( pC->isTable==0 || pOp->opcode==OP_RowData );
75225 assert( pC!=0 );
75226 assert( pC->nullRow==0 );
75227 assert( pC->pseudoTableReg==0 );
75228 assert( pC->pCursor!=0 );
75229 pCrsr = pC->pCursor;
75238 assert( pC->deferredMoveto==0 );
75241 rc = sqlite3VdbeCursorMoveto(pC);
75245 if( pC->isTable==0 ){
75246 assert( !pC->isTable );
75266 if( pC->isTable==0 ){
75288 VdbeCursor *pC;
75295 pC = p->apCsr[pOp->p1];
75296 assert( pC!=0 );
75297 assert( pC->pseudoTableReg==0 || pC->nullRow );
75298 if( pC->nullRow ){
75301 }else if( pC->deferredMoveto ){
75302 v = pC->movetoTarget;
75304 }else if( pC->pVtabCursor ){
75305 pVtab = pC->pVtabCursor->pVtab;
75308 rc = pModule->xRowid(pC->pVtabCursor, &v);
75312 assert( pC->pCursor!=0 );
75313 rc = sqlite3VdbeCursorRestore(pC);
75315 if( pC->nullRow ){
75319 rc = sqlite3BtreeKeySize(pC->pCursor, &v);
75333 VdbeCursor *pC;
75336 pC = p->apCsr[pOp->p1];
75337 assert( pC!=0 );
75338 pC->nullRow = 1;
75339 pC->cacheStatus = CACHE_STALE;
75340 if( pC->pCursor ){
75341 sqlite3BtreeClearCursor(pC->pCursor);
75359 VdbeCursor *pC;
75364 pC = p->apCsr[pOp->p1];
75365 assert( pC!=0 );
75366 pCrsr = pC->pCursor;
75370 pC->nullRow = (u8)res;
75371 pC->deferredMoveto = 0;
75372 pC->cacheStatus = CACHE_STALE;
75373 pC->seekResult = pOp->p3;
75375 pC->seekOp = OP_Last;
75419 VdbeCursor *pC;
75424 pC = p->apCsr[pOp->p1];
75425 assert( pC!=0 );
75426 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
75429 pC->seekOp = OP_Rewind;
75431 if( isSorter(pC) ){
75432 rc = sqlite3VdbeSorterRewind(pC, &res);
75434 pCrsr = pC->pCursor;
75437 pC->deferredMoveto = 0;
75438 pC->cacheStatus = CACHE_STALE;
75440 pC->nullRow = (u8)res;
75511 VdbeCursor *pC;
75514 pC = p->apCsr[pOp->p1];
75515 assert( isSorter(pC) );
75517 rc = sqlite3VdbeSorterNext(db, pC, &res);
75527 pC = p->apCsr[pOp->p1];
75529 assert( pC!=0 );
75530 assert( pC->deferredMoveto==0 );
75531 assert( pC->pCursor );
75532 assert( res==0 || (res==1 && pC->isTable==0) );
75542 || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
75543 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found);
75545 || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
75546 || pC->seekOp==OP_Last );
75548 rc = pOp->p4.xAdvance(pC->pCursor, &res);
75550 pC->cacheStatus = CACHE_STALE;
75553 pC->nullRow = 0;
75560 pC->nullRow = 1;
75588 VdbeCursor *pC;
75594 pC = p->apCsr[pOp->p1];
75595 assert( pC!=0 );
75596 assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
75599 pCrsr = pC->pCursor;
75602 assert( pC->isTable==0 );
75605 if( isSorter(pC) ){
75606 rc = sqlite3VdbeSorterWrite(pC, pIn2);
75611 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
75613 assert( pC->deferredMoveto==0 );
75614 pC->cacheStatus = CACHE_STALE;
75628 VdbeCursor *pC;
75636 pC = p->apCsr[pOp->p1];
75637 assert( pC!=0 );
75638 pCrsr = pC->pCursor;
75641 r.pKeyInfo = pC->pKeyInfo;
75652 assert( pC->deferredMoveto==0 );
75653 pC->cacheStatus = CACHE_STALE;
75668 VdbeCursor *pC;
75673 pC = p->apCsr[pOp->p1];
75674 assert( pC!=0 );
75675 pCrsr = pC->pCursor;
75678 assert( pC->isTable==0 );
75679 assert( pC->deferredMoveto==0 );
75685 rc = sqlite3VdbeCursorRestore(pC);
75688 if( !pC->nullRow ){
75748 VdbeCursor *pC;
75753 pC = p->apCsr[pOp->p1];
75754 assert( pC!=0 );
75755 assert( pC->isOrdered );
75756 assert( pC->pCursor!=0);
75757 assert( pC->deferredMoveto==0 );
75760 r.pKeyInfo = pC->pKeyInfo;
75774 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
75884 VdbeCursor *pC;
75887 pC = p->apCsr[pOp->p1];
75888 assert( pC!=0 );
75889 if( pC->pSorter ){
75890 sqlite3VdbeSorterReset(db, pC->pSorter);
75892 assert( pC->isEphemeral );
75893 rc = sqlite3BtreeClearTableOfCursor(pC->pCursor);
76299 pFrame->pc = (int)(pOp - aOp);
76322 assert( (int)(pOp - aOp)==pFrame->pc );
76366 pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
77489 VdbeCursor *pC = v->apCsr[0];
77490 u32 type = pC->aType[p->iCol];
77499 p->iOffset = pC->aType[p->iCol + pC->nField];
77501 p->pCsr = pC->pCursor;
106657 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
106679 apAll[2] = pC;
106701 if( pC==0 ){ zSp++; }
106703 "%T %T%s%T", pA, pB, zSp, pC);
111061 struct AggInfo_col *pC;
111112 ** to pC->iMem. But by the time the value is used, the original register
111123 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
111124 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
117563 u8 c, *pC; /* Last character before the first wildcard */
117564 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
117565 c = *pC;
117576 *pC = c + 1;
149197 sqlite3_tokenizer_cursor *pC;
149203 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
149209 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
149211 pMod->xClose(pC);
149251 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
149264 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
149287 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
149339 pMod->xClose(pC);
150065 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
150100 zDoc, nDoc, &pC
150104 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
150129 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
150146 pMod->xClose(pC);
150520 sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */
150527 unicode_cursor *pCsr = (unicode_cursor *)pC;
