Lines Matching defs:pC
12840 #define OP_SequenceTest 110 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */
18081 int pc; /* Program Counter in parent (calling) frame */
18263 int pc; /* The program counter */
29580 /* 110 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
44005 int i, nx, pc, op;
44020 pc = 0;
44021 while( (op = aOp[pc])!=0 ){
44027 i = aOp[pc+2] - 1;
44028 aOp[pc+2] += aOp[pc+3];
44039 if( (--aOp[pc+1]) > 0 ) nx = 0;
44040 pc += nx;
60291 int pc; /* Address of the i-th cell */
60355 pc = get2byte(pAddr);
60356 if( pc<iFree ){ put2byte(pAddr, pc+sz); }
60357 else if( pc<iFree2 ){ put2byte(pAddr, pc+sz2); }
60369 pc = get2byte(pAddr);
60370 testcase( pc==iCellFirst );
60371 testcase( pc==iCellLast );
60375 if( pc<iCellFirst || pc>iCellLast ){
60378 assert( pc>=iCellFirst && pc<=iCellLast );
60379 size = pPage->xCellSize(pPage, &src[pc]);
60381 if( cbrk<iCellFirst || pc+size>usableSize ){
60386 testcase( pc+size==usableSize );
60390 if( cbrk==pc ) continue;
60396 memcpy(&data[cbrk], &src[pc], size);
60431 int pc = get2byte(&aData[iAddr]);
60435 assert( pc>0 );
60440 if( pc>usableSize-4 || pc<iAddr+4 ){
60447 size = get2byte(&aData[pc+2]);
60451 if( pc < pPg->cellOffset+2*pPg->nCell || size+pc > usableSize ){
60461 memcpy(&aData[iAddr], &aData[pc], 2);
60466 put2byte(&aData[pc+2], x);
60468 return &aData[pc + x];
60470 iAddr = pc;
60471 pc = get2byte(&aData[pc]);
60472 }while( pc );
60750 int pc; /* Address of a freeblock within pPage->aData[] */
60809 pc = get2byteAligned(&data[cellOffset+i*2]);
60810 testcase( pc==iCellFirst );
60811 testcase( pc==iCellLast );
60812 if( pc<iCellFirst || pc>iCellLast ){
60815 sz = pPage->xCellSize(pPage, &data[pc]);
60816 testcase( pc+sz==usableSize );
60817 if( pc+sz>usableSize ){
60828 pc = get2byte(&data[hdr+1]);
60830 if( pc>0 ){
60832 if( pc<iCellFirst ){
60839 if( pc>iCellLast ){
60842 next = get2byte(&data[pc]);
60843 size = get2byte(&data[pc+2]);
60845 if( next<=pc+size+3 ) break;
60846 pc = next;
60851 if( pc+size>(unsigned int)usableSize ){
65315 u32 pc; /* Offset to cell content of cell being deleted */
65328 pc = get2byte(ptr);
65330 testcase( pc==get2byte(&data[hdr+5]) );
65331 testcase( pc+sz==pPage->pBt->usableSize );
65332 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
65336 rc = freeSpace(pPage, pc, sz);
68178 u32 pc; /* Address of a cell */
68257 pc
68259 if( pc<contentOffset || pc>usableSize-4 ){
68261 pc, contentOffset, usableSize-4);
68265 pCell = &data[pc];
68267 if( pc+info.nSize>usableSize ){
68285 assert( pc + info.nSize - 4 <= usableSize );
68312 btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1));
68329 pc = get2byteAligned(&data[cellStart+i*2]);
68330 size = pPage->xCellSize(pPage, &data[pc]);
68331 btreeHeapInsert(heap, (pc<<16)|(pc+size-1));
72820 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
72835 fprintf(pOut, zFormat1, pc,
72970 ** encountered, but p->pc will eventually catch up to nRow.
72992 i = p->pc++;
73226 p->pc = -1;
73400 VdbeCursor *pC = p->apCsr[i];
73401 if( pC ){
73402 sqlite3VdbeFreeCursor(p, pC);
73432 return pFrame->pc;
73963 if( p->pc>=0 && p->bIsReader ){
74102 if( p->pc>=0 ){
74168 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
74209 if( p->pc>=0 ){
74242 char c, pc = 0;
74245 if( pc=='\n' ) fprintf(out, "-- ");
74247 pc = c;
74249 if( pc!='\n' ) fprintf(out, "\n");
75779 ** Compare the key of the index entry that cursor pC is pointing to against
75781 ** that is negative, zero, or positive if pC is less than, equal to,
75791 VdbeCursor *pC, /* The cursor to compare against */
75800 assert( pC->eCurType==CURTYPE_BTREE );
75801 pCur = pC->uc.pCursor;
76568 if( p->pc<=0 && p->expired ){
76573 if( p->pc<0 ){
76598 p->pc = 0;
76673 int savedPc = v->pc;
77242 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
77568 return v!=0 && v->magic==VDBE_MAGIC_RUN && v->pc>=0;
78798 if( p->pc==0
78823 for(pOp=&aOp[p->pc]; 1; pOp++){
79158 p->pc = pcx;
79573 p->pc = (int)(pOp - aOp) + 1;
80646 VdbeCursor *pC; /* The VDBE cursor */
80662 pC = p->apCsr[pOp->p1];
80666 rc = sqlite3VdbeCursorMoveto(&pC, &p2);
80673 assert( pC!=0 );
80674 assert( p2<pC->nField );
80675 aOffset = pC->aOffset;
80676 assert( pC->eCurType!=CURTYPE_VTAB );
80677 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
80678 assert( pC->eCurType!=CURTYPE_SORTER );
80680 if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/
80681 if( pC->nullRow ){
80682 if( pC->eCurType==CURTYPE_PSEUDO ){
80683 assert( pC->uc.pseudoTableReg>0 );
80684 pReg = &aMem[pC->uc.pseudoTableReg];
80687 pC->payloadSize = pC->szRow = avail = pReg->n;
80688 pC->aRow = (u8*)pReg->z;
80694 pCrsr = pC->uc.pCursor;
80695 assert( pC->eCurType==CURTYPE_BTREE );
80698 pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
80699 pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &avail);
80701 if( pC->payloadSize <= (u32)avail ){
80702 pC->szRow = pC->payloadSize;
80703 }else if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
80706 pC->szRow = avail;
80709 pC->cacheStatus = p->cacheCtr;
80710 pC->iHdrOffset = getVarint32(pC->aRow, offset);
80711 pC->nHdrParsed = 0;
80716 /* pC->aRow does not have to hold the entire row, but it does at least
80717 ** need to cover the header of the record. If pC->aRow does not contain
80720 pC->aRow = 0;
80721 pC->szRow = 0;
80732 if( offset > 98307 || offset > pC->payloadSize ){
80741 zData = pC->aRow;
80742 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
80748 ** parsed and valid information is in aOffset[] and pC->aType[].
80750 if( pC->nHdrParsed<=p2 ){
80754 if( pC->iHdrOffset<aOffset[0] ){
80756 if( pC->aRow==0 ){
80758 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, 0, aOffset[0], &sMem);
80762 zData = pC->aRow;
80765 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
80767 i = pC->nHdrParsed;
80769 zHdr = zData + pC->iHdrOffset;
80779 pC->aType[i++] = t;
80788 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
80789 || (offset64 > pC->payloadSize)
80791 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
80796 pC->nHdrParsed = i;
80797 pC->iHdrOffset = (u32)(zHdr - zData);
80798 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
80807 if( pC->nHdrParsed<=p2 ){
80816 t = pC->aType[p2];
80820 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
80823 assert( p2<pC->nHdrParsed );
80829 assert( t==pC->aType[p2] );
80830 if( pC->szRow>=aOffset[p2+1] ){
80833 zData = pC->aRow + aOffset[p2];
80876 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
81217 p->pc = (int)(pOp - aOp);
81326 p->pc = (int)(pOp - aOp);
81406 p->pc = (int)(pOp - aOp);
81815 ** Synopsis: if( cursor[P1].ctr++ ) pc = P2
81822 VdbeCursor *pC;
81824 pC = p->apCsr[pOp->p1];
81825 assert( isSorter(pC) );
81826 if( (pC->seqCount++)==0 ){
81886 VdbeCursor *pC;
81887 pC = p->apCsr[pOp->p1];
81888 assert( pC->eCurType==CURTYPE_BTREE );
81889 pC->maskUsed = *(u64*)pOp->p4.pI64;
81986 VdbeCursor *pC; /* The cursor to seek */
81994 pC = p->apCsr[pOp->p1];
81995 assert( pC!=0 );
81996 assert( pC->eCurType==CURTYPE_BTREE );
82000 assert( pC->isOrdered );
82001 assert( pC->uc.pCursor!=0 );
82004 pC->nullRow = 0;
82006 pC->seekOp = pOp->opcode;
82009 if( pC->isTable ){
82011 assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
82056 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res);
82057 pC->movetoTarget = iKey; /* Used by OP_Delete */
82066 if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
82079 r.pKeyInfo = pC->pKeyInfo;
82100 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res);
82109 pC->deferredMoveto = 0;
82110 pC->cacheStatus = CACHE_STALE;
82117 rc = sqlite3BtreeNext(pC->uc.pCursor, &res);
82126 rc = sqlite3BtreePrevious(pC->uc.pCursor, &res);
82132 res = sqlite3BtreeEof(pC->uc.pCursor);
82212 VdbeCursor *pC;
82224 pC = p->apCsr[pOp->p1];
82225 assert( pC!=0 );
82227 pC->seekOp = pOp->opcode;
82230 assert( pC->eCurType==CURTYPE_BTREE );
82231 assert( pC->uc.pCursor!=0 );
82232 assert( pC->isTable==0 );
82234 r.pKeyInfo = pC->pKeyInfo;
82247 pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
82251 sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
82266 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res);
82271 pC->seekResult = res;
82273 pC->nullRow = 1-alreadyExists;
82274 pC->deferredMoveto = 0;
82275 pC->cacheStatus = CACHE_STALE;
82334 VdbeCursor *pC;
82349 pC = p->apCsr[pOp->p1];
82350 assert( pC!=0 );
82352 pC->seekOp = 0;
82354 assert( pC->isTable );
82355 assert( pC->eCurType==CURTYPE_BTREE );
82356 pCrsr = pC->uc.pCursor;
82362 pC->movetoTarget = iKey; /* Used by OP_Delete */
82363 pC->nullRow = 0;
82364 pC->cacheStatus = CACHE_STALE;
82365 pC->deferredMoveto = 0;
82367 pC->seekResult = res;
82415 VdbeCursor *pC; /* Cursor of table to get the new rowid */
82425 pC = p->apCsr[pOp->p1];
82426 assert( pC!=0 );
82427 assert( pC->eCurType==CURTYPE_BTREE );
82428 assert( pC->uc.pCursor!=0 );
82443 assert( pC->isTable );
82455 if( !pC->useRandomRowid ){
82456 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
82463 assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
82464 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
82466 pC->useRandomRowid = 1;
82493 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
82503 if( pC->useRandomRowid ){
82514 }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v,
82525 pC->deferredMoveto = 0;
82526 pC->cacheStatus = CACHE_STALE;
82579 VdbeCursor *pC; /* Cursor to table into which insert is written */
82590 pC = p->apCsr[pOp->p1];
82591 assert( pC!=0 );
82592 assert( pC->eCurType==CURTYPE_BTREE );
82593 assert( pC->uc.pCursor!=0 );
82594 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
82610 assert( pC->iDb>=0 );
82611 zDb = db->aDb[pC->iDb].zDbSName;
82626 sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey, pOp->p2);
82641 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
82648 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
82651 pC->deferredMoveto = 0;
82652 pC->cacheStatus = CACHE_STALE;
82698 VdbeCursor *pC;
82705 pC = p->apCsr[pOp->p1];
82706 assert( pC!=0 );
82707 assert( pC->eCurType==CURTYPE_BTREE );
82708 assert( pC->uc.pCursor!=0 );
82709 assert( pC->deferredMoveto==0 );
82714 ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
82716 i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
82717 assert( pC->movetoTarget==iKey );
82727 assert( pC->iDb>=0 );
82729 zDb = db->aDb[pC->iDb].zDbSName;
82731 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
82732 pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
82746 sqlite3VdbePreUpdateHook(p, pC,
82748 zDb, pTab, pC->movetoTarget,
82762 if( pC->isEphemeral==0
82764 && (pC->wrFlag & OPFLAG_FORDELETE)==0
82774 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
82775 pC->cacheStatus = CACHE_STALE;
82776 pC->seekResult = 0;
82784 pC->movetoTarget);
82785 assert( pC->iDb>=0 );
82820 VdbeCursor *pC;
82824 pC = p->apCsr[pOp->p1];
82825 assert( isSorter(pC) );
82830 rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
82850 VdbeCursor *pC;
82853 pC = p->apCsr[pOp->p1];
82854 assert( isSorter(pC) );
82855 rc = sqlite3VdbeSorterRowkey(pC, pOut);
82892 VdbeCursor *pC;
82899 pC = p->apCsr[pOp->p1];
82900 assert( pC!=0 );
82901 assert( pC->eCurType==CURTYPE_BTREE );
82902 assert( isSorter(pC)==0 );
82903 assert( pC->nullRow==0 );
82904 assert( pC->uc.pCursor!=0 );
82905 pCrsr = pC->uc.pCursor;
82915 assert( pC->deferredMoveto==0 );
82918 rc = sqlite3VdbeCursorMoveto(pC);
82946 VdbeCursor *pC;
82953 pC = p->apCsr[pOp->p1];
82954 assert( pC!=0 );
82955 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
82956 if( pC->nullRow ){
82959 }else if( pC->deferredMoveto ){
82960 v = pC->movetoTarget;
82962 }else if( pC->eCurType==CURTYPE_VTAB ){
82963 assert( pC->uc.pVCur!=0 );
82964 pVtab = pC->uc.pVCur->pVtab;
82967 rc = pModule->xRowid(pC->uc.pVCur, &v);
82972 assert( pC->eCurType==CURTYPE_BTREE );
82973 assert( pC->uc.pCursor!=0 );
82974 rc = sqlite3VdbeCursorRestore(pC);
82976 if( pC->nullRow ){
82980 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
82993 VdbeCursor *pC;
82996 pC = p->apCsr[pOp->p1];
82997 assert( pC!=0 );
82998 pC->nullRow = 1;
82999 pC->cacheStatus = CACHE_STALE;
83000 if( pC->eCurType==CURTYPE_BTREE ){
83001 assert( pC->uc.pCursor!=0 );
83002 sqlite3BtreeClearCursor(pC->uc.pCursor);
83027 VdbeCursor *pC;
83032 pC = p->apCsr[pOp->p1];
83033 assert( pC!=0 );
83034 assert( pC->eCurType==CURTYPE_BTREE );
83035 pCrsr = pC->uc.pCursor;
83038 pC->seekResult = pOp->p3;
83040 pC->seekOp = OP_Last;
83044 pC->nullRow = (u8)res;
83045 pC->deferredMoveto = 0;
83046 pC->cacheStatus = CACHE_STALE;
83064 VdbeCursor *pC;
83070 pC = p->apCsr[pOp->p1];
83071 assert( pC!=0 );
83072 pCrsr = pC->uc.pCursor;
83129 VdbeCursor *pC;
83134 pC = p->apCsr[pOp->p1];
83135 assert( pC!=0 );
83136 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
83139 pC->seekOp = OP_Rewind;
83141 if( isSorter(pC) ){
83142 rc = sqlite3VdbeSorterRewind(pC, &res);
83144 assert( pC->eCurType==CURTYPE_BTREE );
83145 pCrsr = pC->uc.pCursor;
83148 pC->deferredMoveto = 0;
83149 pC->cacheStatus = CACHE_STALE;
83152 pC->nullRow = (u8)res;
83230 VdbeCursor *pC;
83233 pC = p->apCsr[pOp->p1];
83234 assert( isSorter(pC) );
83236 rc = sqlite3VdbeSorterNext(db, pC, &res);
83246 pC = p->apCsr[pOp->p1];
83248 assert( pC!=0 );
83249 assert( pC->deferredMoveto==0 );
83250 assert( pC->eCurType==CURTYPE_BTREE );
83251 assert( res==0 || (res==1 && pC->isTable==0) );
83261 || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
83262 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found);
83264 || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
83265 || pC->seekOp==OP_Last );
83267 rc = pOp->p4.xAdvance(pC->uc.pCursor, &res);
83269 pC->cacheStatus = CACHE_STALE;
83273 pC->nullRow = 0;
83280 pC->nullRow = 1;
83322 VdbeCursor *pC;
83326 pC = p->apCsr[pOp->p1];
83327 assert( pC!=0 );
83328 assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
83332 assert( pC->eCurType==CURTYPE_BTREE || pOp->opcode==OP_SorterInsert );
83333 assert( pC->isTable==0 );
83337 rc = sqlite3VdbeSorterWrite(pC, pIn2);
83343 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
83345 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
83347 assert( pC->deferredMoveto==0 );
83348 pC->cacheStatus = CACHE_STALE;
83362 VdbeCursor *pC;
83370 pC = p->apCsr[pOp->p1];
83371 assert( pC!=0 );
83372 assert( pC->eCurType==CURTYPE_BTREE );
83373 pCrsr = pC->uc.pCursor;
83376 r.pKeyInfo = pC->pKeyInfo;
83386 assert( pC->deferredMoveto==0 );
83387 pC->cacheStatus = CACHE_STALE;
83388 pC->seekResult = 0;
83422 VdbeCursor *pC; /* The P1 index cursor */
83427 pC = p->apCsr[pOp->p1];
83428 assert( pC!=0 );
83429 assert( pC->eCurType==CURTYPE_BTREE );
83430 assert( pC->uc.pCursor!=0 );
83431 assert( pC->isTable==0 );
83432 assert( pC->deferredMoveto==0 );
83433 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
83437 rc = sqlite3VdbeCursorRestore(pC);
83444 if( !pC->nullRow ){
83446 rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
83462 pTabCur->pAltCursor = pC;
83522 VdbeCursor *pC;
83527 pC = p->apCsr[pOp->p1];
83528 assert( pC!=0 );
83529 assert( pC->isOrdered );
83530 assert( pC->eCurType==CURTYPE_BTREE );
83531 assert( pC->uc.pCursor!=0);
83532 assert( pC->deferredMoveto==0 );
83535 r.pKeyInfo = pC->pKeyInfo;
83549 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
83664 VdbeCursor *pC;
83667 pC = p->apCsr[pOp->p1];
83668 assert( pC!=0 );
83669 if( isSorter(pC) ){
83670 sqlite3VdbeSorterReset(db, pC->uc.pSorter);
83672 assert( pC->eCurType==CURTYPE_BTREE );
83673 assert( pC->isEphemeral );
83674 rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
84093 pFrame->pc = (int)(pOp - aOp);
84115 assert( (int)(pOp - aOp)==pFrame->pc );
84161 pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
85209 VdbeCursor *pC;
85213 pC = p->apCsr[pOp->p1];
85214 if( pC ){
85215 assert( pC->eCurType==CURTYPE_BTREE );
85216 sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
85409 if( v->pc>3 ){
85410 v->pc = 3;
85416 VdbeCursor *pC = v->apCsr[0];
85417 u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
85418 testcase( pC->nHdrParsed==p->iCol );
85419 testcase( pC->nHdrParsed==p->iCol+1 );
85428 p->iOffset = pC->aType[p->iCol + pC->nField];
85430 p->pCsr = pC->uc.pCursor;
116451 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
116473 apAll[2] = pC;
116495 if( pC==0 ){ zSp++; }
116497 "%T %T%s%T", pA, pB, zSp, pC);
121001 struct AggInfo_col *pC;
121052 ** to pC->iMem. But by the time the value is used, the original register
121063 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
121064 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
129495 u8 c, *pC; /* Last character before the first wildcard */
129496 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
129497 c = *pC;
129508 *pC = c + 1;
161688 sqlite3_tokenizer_cursor *pC;
161694 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
161700 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
161702 pMod->xClose(pC);
161742 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
161755 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
161778 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
161830 pMod->xClose(pC);
162592 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
162627 zDoc, nDoc, &pC
162631 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
162656 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
162673 pMod->xClose(pC);
163032 sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */
163039 unicode_cursor *pCsr = (unicode_cursor *)pC;
175250 SessionChange *pC;
175251 for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
175252 if( sessionPreupdateEqual(pSession, pTab, pC, op) ) break;
175255 if( pC==0 ){
175318 }else if( pC->bIndirect ){
175324 pC->bIndirect = 0;
196188 struct Constraint *pC = &aConstraint[j];
196189 if( p->iColumn==aColMap[pC->iCol] && p->op & pC->op ){
196191 pC->iConsIndex = i;
196192 idxFlags |= pC->fts5op;
196235 struct Constraint *pC = &aConstraint[i];
196236 if( pC->iConsIndex>=0 ){
196237 pInfo->aConstraintUsage[pC->iConsIndex].argvIndex = iNext++;
196238 pInfo->aConstraintUsage[pC->iConsIndex].omit = (unsigned char)pC->omit;
198466 Fts5Config *pC = p->pConfig;
198472 pC->zContentExprlist, pC->zContent
198478 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zContentExprlist,
198479 pC->zContent, pC->zContentRowid, pC->zContentRowid,
198480 pC->zContentRowid
198486 pC->zContentExprlist, pC->zContent, pC->zContentRowid
198492 int nCol = pC->nCol + 1;
198503 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
198510 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
198517 rc = sqlite3_prepare_v2(pC->db, zSql, -1, &p->aStmt[eStmt], 0);
198520 *pzErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pC->db));
