Lines Matching defs:pOut
10331 ** the "pOut" parameter.
10335 ** the statement - a non-zero value is returned and the variable that pOut
10341 ** that pOut points to unchanged.
10349 void *pOut /* Result written here */
12542 ** int (*xOutput)(void *pOut, const void *pData, int nData),
12543 ** void *pOut
12548 ** pOut pointer supplied by the application. The second parameter, pData,
12597 int (*xOutput)(void *pOut, const void *pData, int nData),
12598 void *pOut
12603 int (*xOutput)(void *pOut, const void *pData, int nData),
12604 void *pOut
12619 int (*xOutput)(void *pOut, const void *pData, int nData),
12620 void *pOut
12624 int (*xOutput)(void *pOut, const void *pData, int nData),
12625 void *pOut
12632 int (*xOutput)(void *pOut, const void *pData, int nData),
12633 void *pOut
12639 int (*xOutput)(void *pOut, const void *pData, int nData),
12640 void *pOut
22779 Mem *pOut; /* The return value is stored here */
22951 sqlite3_value *pOut; /* Register to hold each decoded output value */
32829 void *pOut; /* Result returned by the thread */
32865 p->pOut = xTask(pIn);
32878 *ppOut = p->pOut;
34407 SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
34418 memcpy(pOut, &u, 8);
34423 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
35265 VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int));
35266 if( pOut==0 ) return pIn;
35267 if( pIn==0 ) pOut[1] = 2;
35268 pIn = pOut;
36188 ** written into pOut, which must be at least nOut bytes in length.
52033 unsigned char *pOut;
52054 pOut = pStore->aData;
52056 pOut = sqlite3_malloc64( pStore->sz );
52057 if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
52059 return pOut;
52070 pOut = 0;
52075 pOut = 0;
52077 pOut = sqlite3_malloc64( sz );
52078 if( pOut ){
52084 unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
52097 return pOut;
66604 ** Read the contents of frame iRead from the wal file into buffer pOut
66611 int nOut, /* Size of buffer pOut in bytes */
66612 u8 *pOut /* Buffer to write page data to */
66622 return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
76284 u8 *pOut = &pSpace[4];
76339 while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
76343 insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
78993 static int btreeHeapPull(u32 *aHeap, u32 *pOut){
78996 *pOut = aHeap[1];
81016 ctx.pOut = &t;
81036 SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){
81044 sqlite3VdbeMemSetNull(pOut);
81045 ctx.pOut = pOut;
82056 ctx.pOut = pVal;
82916 pCtx->pOut = 0;
83602 VdbeOp *pOut, *pFirst;
83608 pFirst = pOut = &p->aOp[p->nOp];
83609 for(i=0; i<nOp; i++, aOp++, pOut++){
83610 pOut->opcode = aOp->opcode;
83611 pOut->p1 = aOp->p1;
83612 pOut->p2 = aOp->p2;
83615 pOut->p2 += p->nOp;
83617 pOut->p3 = aOp->p3;
83618 pOut->p4type = P4_NOTUSED;
83619 pOut->p4.p = 0;
83620 pOut->p5 = 0;
83622 pOut->zComment = 0;
83625 pOut->iSrcLine = iLineno+i;
84480 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){
84485 if( pOut==0 ) pOut = stdout;
84497 fprintf(pOut, zFormat1, pc,
84502 fflush(pOut);
88248 Mem *pOut = pCtx->pOut;
88249 int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel);
88261 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
88262 if( sqlite3VdbeMemTooBig(pOut) ){
88289 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88298 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88307 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88308 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
88311 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88313 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
88317 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88319 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
88323 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88324 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
88327 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88328 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
88331 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88332 sqlite3VdbeMemSetNull(pCtx->pOut);
88340 Mem *pOut = pCtx->pOut;
88341 assert( sqlite3_mutex_held(pOut->db->mutex) );
88342 sqlite3VdbeMemRelease(pOut);
88343 pOut->flags = MEM_Null;
88344 sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor);
88347 Mem *pOut = pCtx->pOut;
88348 assert( sqlite3_mutex_held(pOut->db->mutex) );
88349 pOut->eSubtype = eSubtype & 0xff;
88350 pOut->flags |= MEM_Subtype;
88358 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88368 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88384 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88393 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88402 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88407 Mem *pOut = pCtx->pOut;
88408 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88409 sqlite3VdbeMemCopy(pOut, pValue);
88410 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
88411 if( sqlite3VdbeMemTooBig(pOut) ){
88419 Mem *pOut = pCtx->pOut;
88420 assert( sqlite3_mutex_held(pOut->db->mutex) );
88421 if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
88426 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
88429 return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
88437 if( pCtx->pOut->flags & MEM_Null ){
88445 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88447 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
88453 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88454 sqlite3VdbeMemSetNull(pCtx->pOut);
88456 sqlite3OomFault(pCtx->pOut->db);
88465 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88466 if( pCtx->pOut->flags & MEM_Int ){
88467 pCtx->pOut->flags &= ~MEM_Int;
88468 pCtx->pOut->flags |= MEM_IntReal;
88759 assert( p && p->pOut );
88760 return p->pOut->db;
88779 return sqlite3_value_nochange(p->pOut);
88815 sqlite3_value *pOut = pRhs->pOut;
88817 sqlite3VdbeSerialGet(&zBuf[iOff], iSerial, pOut);
88818 pOut->enc = ENC(pOut->db);
88819 if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){
88822 *ppOut = pOut;
88863 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
88897 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
88919 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88953 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
89066 Mem *pOut;
89073 pOut = &pVm->pResultSet[i];
89076 pOut = (Mem*)columnNullValue();
89078 return pOut;
89160 Mem *pOut = columnMem(pStmt, i);
89161 if( pOut->flags&MEM_Static ){
89162 pOut->flags &= ~MEM_Static;
89163 pOut->flags |= MEM_Ephem;
89166 return (sqlite3_value *)pOut;
90013 void *pOut /* OUT: Write the answer here */
90021 *(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop];
90025 *(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit];
90035 *(double*)pOut = r*sqlite3LogEstToInt(x);
90039 *(const char**)pOut = pScan->zName;
90044 *(const char**)pOut = p->aOp[ pScan->addrExplain ].p4.z;
90046 *(const char**)pOut = 0;
90052 *(int*)pOut = p->aOp[ pScan->addrExplain ].p1;
90054 *(int*)pOut = -1;
90979 static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){
90980 sqlite3VdbeMemSetNull(pOut);
90981 pOut->flags = MEM_Int;
90982 return pOut;
90985 Mem *pOut;
90988 pOut = &p->aMem[pOp->p2];
90989 memAboutToChange(p, pOut);
90990 if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/
90991 return out2PrereleaseWithClear(pOut);
90993 pOut->flags = MEM_Int;
90994 return pOut;
91063 Mem *pOut = 0; /* Output operand */
91363 pOut = &aMem[pOp->p1];
91364 assert( !VdbeMemDynamic(pOut) );
91365 pOut->u.i = pOp->p3 - 1;
91366 pOut->flags = MEM_Int;
91544 pOut = out2Prerelease(p, pOp);
91545 pOut->u.i = pOp->p1;
91556 pOut = out2Prerelease(p, pOp);
91558 pOut->u.i = *pOp->p4.pI64;
91570 pOut = out2Prerelease(p, pOp);
91571 pOut->flags = MEM_Real;
91573 pOut->u.r = *pOp->p4.pReal;
91588 pOut = out2Prerelease(p, pOp);
91593 rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
91596 if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
91597 assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
91598 assert( VdbeMemDynamic(pOut)==0 );
91599 pOut->szMalloc = 0;
91600 pOut->flags |= MEM_Static;
91605 pOp->p4.z = pOut->z;
91606 pOp->p1 = pOut->n;
91632 pOut = out2Prerelease(p, pOp);
91633 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
91634 pOut->z = pOp->p4.z;
91635 pOut->n = pOp->p1;
91636 pOut->enc = encoding;
91637 UPDATE_MAX_BLOBSIZE(pOut);
91643 if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
91687 pOut = out2Prerelease(p, pOp);
91690 pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
91691 pOut->n = 0;
91693 pOut->uTemp = 0;
91696 pOut++;
91697 memAboutToChange(p, pOut);
91698 sqlite3VdbeMemSetNull(pOut);
91699 pOut->flags = nullFlag;
91700 pOut->n = 0;
91716 pOut = &aMem[pOp->p1];
91717 pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
91730 pOut = out2Prerelease(p, pOp);
91732 sqlite3VdbeMemSetZeroBlob(pOut, pOp->p1);
91733 if( sqlite3VdbeMemExpandBlob(pOut) ) goto no_mem;
91735 sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
91737 pOut->enc = encoding;
91738 UPDATE_MAX_BLOBSIZE(pOut);
91759 pOut = &aMem[pOp->p2];
91760 if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut);
91761 memcpy(pOut, pVar, MEMCELLSIZE);
91762 pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
91763 pOut->flags |= MEM_Static|MEM_FromBind;
91764 UPDATE_MAX_BLOBSIZE(pOut);
91789 pOut = &aMem[p2];
91791 assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
91794 memAboutToChange(p, pOut);
91795 sqlite3VdbeMemMove(pOut, pIn1);
91801 aMem[i].pScopyFrom = pOut;
91806 Deephemeralize(pOut);
91807 REGISTER_TRACE(p2++, pOut);
91809 pOut++;
91832 pOut = &aMem[pOp->p2];
91833 assert( pOut!=pIn1 );
91835 memAboutToChange(p, pOut);
91836 sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
91837 Deephemeralize(pOut);
91838 if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){
91839 pOut->flags &= ~MEM_Subtype;
91842 pOut->pScopyFrom = 0;
91844 REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
91846 pOut++;
91867 pOut = &aMem[pOp->p2];
91868 assert( pOut!=pIn1 );
91869 sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
91871 pOut->pScopyFrom = pIn1;
91872 pOut->mScopyFlags = pIn1->flags;
91888 pOut = &aMem[pOp->p2];
91889 sqlite3VdbeMemSetInt64(pOut, pIn1->u.i);
92010 pOut = &aMem[pOp->p3];
92011 testcase( pOut==pIn2 );
92012 assert( pIn1!=pOut );
92017 sqlite3VdbeMemSetNull(pOut);
92039 if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){
92042 MemSetTypeFlag(pOut, MEM_Str);
92043 if( pOut!=pIn2 ){
92044 memcpy(pOut->z, pIn2->z, pIn2->n);
92048 memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
92052 pOut->z[nByte]=0;
92053 pOut->z[nByte+1] = 0;
92054 pOut->flags |= MEM_Term;
92055 pOut->n = (int)nByte;
92056 pOut->enc = encoding;
92057 UPDATE_MAX_BLOBSIZE(pOut);
92115 pOut = &aMem[pOp->p3];
92137 pOut->u.i = iB;
92138 MemSetTypeFlag(pOut, MEM_Int);
92168 pOut->u.i = rB;
92169 MemSetTypeFlag(pOut, MEM_Int);
92174 pOut->u.r = rB;
92175 MemSetTypeFlag(pOut, MEM_Real);
92181 sqlite3VdbeMemSetNull(pOut);
92249 pOut = &aMem[pOp->p3];
92251 sqlite3VdbeMemSetNull(pOut);
92285 pOut->u.i = iA;
92286 MemSetTypeFlag(pOut, MEM_Int);
92815 pOut = &aMem[pOp->p3];
92817 MemSetTypeFlag(pOut, MEM_Null);
92819 pOut->u.i = v1;
92820 MemSetTypeFlag(pOut, MEM_Int);
92863 pOut = &aMem[pOp->p2];
92865 sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0));
92867 sqlite3VdbeMemSetNull(pOut);
92881 pOut = &aMem[pOp->p2];
92882 sqlite3VdbeMemSetNull(pOut);
92884 pOut->flags = MEM_Int;
92885 pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
93130 pOut = &p->aMem[pOp->p3];
93132 sqlite3VdbeMemSetNull(pOut);
93139 sqlite3VdbeMemSetNull(pOut);
93141 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
93679 pOut = &aMem[pOp->p3];
93680 memAboutToChange(p, pOut);
93857 if( nByte+nZero<=pOut->szMalloc ){
93860 pOut->z = pOut->zMalloc;
93867 if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
93871 pOut->n = (int)nByte;
93872 pOut->flags = MEM_Blob;
93874 pOut->u.nZero = nZero;
93875 pOut->flags |= MEM_Zero;
93877 UPDATE_MAX_BLOBSIZE(pOut);
93878 zHdr = (u8 *)pOut->z;
93936 assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
93937 assert( nByte==(int)(zPayload - (u8*)pOut->z) );
93940 REGISTER_TRACE(pOp->p3, pOut);
93968 pOut = out2Prerelease(p, pOp);
93969 pOut->u.i = nEntry;
94386 pOut = out2Prerelease(p, pOp);
94387 pOut->u.i = iMeta;
95717 pOut = out2Prerelease(p, pOp);
95718 pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
95750 pOut = out2Prerelease(p, pOp);
95856 pOut->u.i = v;
96203 pOut = &aMem[pOp->p2];
96206 rc = sqlite3VdbeSorterRowkey(pC, pOut);
96207 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
96247 pOut = out2Prerelease(p, pOp);
96274 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut);
96276 if( !pOp->p3 ) Deephemeralize(pOut);
96277 UPDATE_MAX_BLOBSIZE(pOut);
96278 REGISTER_TRACE(pOp->p2, pOut);
96298 pOut = out2Prerelease(p, pOp);
96304 pOut->flags = MEM_Null;
96324 pOut->flags = MEM_Null;
96329 pOut->u.i = v;
96845 pOut = out2Prerelease(p, pOp);
96846 pOut->u.i = rowid;
97025 pOut = out2Prerelease(p, pOp);
97026 pOut->flags = MEM_Null;
97036 pOut->flags = MEM_Int;
97037 pOut->u.i = iMoved;
97127 pOut = out2Prerelease(p, pOp);
97137 pOut->u.i = pgno;
97613 pOut = out2Prerelease(p, pOp);
97616 sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
97740 pOut = out2Prerelease(p, pOp);
97752 pOut->u.i = -1;
97754 pOut->u.i = x;
97861 pCtx->pOut = (Mem*)&(pCtx->argv[n]);
97862 sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
97917 assert( pCtx->pOut->flags==MEM_Null );
97929 sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
97938 sqlite3VdbeMemRelease(pCtx->pOut);
97939 pCtx->pOut->flags = MEM_Null;
97943 assert( pCtx->pOut->flags==MEM_Null );
98060 pOut = out2Prerelease(p, pOp);
98135 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
98136 pOut->z = (char *)sqlite3JournalModename(eNew);
98137 pOut->n = sqlite3Strlen30(pOut->z);
98138 pOut->enc = SQLITE_UTF8;
98139 sqlite3VdbeChangeEncoding(pOut, encoding);
98408 pRhs->pOut = &aMem[pOp->p3];
98409 pOut = out2Prerelease(p, pOp);
98410 pOut->flags = MEM_Null;
98411 sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList", sqlite3_free);
98517 sContext.pOut = pDest;
98709 pOut = out2Prerelease(p, pOp);
98710 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
98729 pOut = out2Prerelease(p, pOp);
98736 pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
98799 pOut = &aMem[pOp->p3];
98800 if( pCtx->pOut != pOut ){
98802 pCtx->pOut = pOut;
98808 memAboutToChange(p, pOut);
98815 MemSetTypeFlag(pOut, MEM_Null);
98822 sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
98830 assert( (pOut->flags&MEM_Str)==0
98831 || pOut->enc==encoding
98833 assert( !sqlite3VdbeMemTooBig(pOut) );
98835 REGISTER_TRACE(pOp->p3, pOut);
98836 UPDATE_MAX_BLOBSIZE(pOut);
101659 SorterFile *pOut = &pIncr->aFile[1];
101667 vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart);
101686 rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof);
102473 ** Copy the current sorter key into the memory cell pOut.
102475 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){
102477 void *pKey; int nKey; /* Sorter key to copy into pOut */
102482 if( sqlite3VdbeMemClearAndResize(pOut, nKey) ){
102485 pOut->n = nKey;
102486 MemSetTypeFlag(pOut, MEM_Blob);
102487 memcpy(pOut->z, pKey, nKey);
149657 sqlite3_value *pOut /* Write results here, if not NULL. VACUUM INTO */
149685 if( pOut ){
149686 if( sqlite3_value_type(pOut)!=SQLITE_TEXT ){
149690 zOut = (const char*)sqlite3_value_text(pOut);
149737 if( pOut ){
149774 rc = sqlite3BtreeBeginTrans(pMain, pOut==0 ? 2 : 0, 0);
149780 && pOut==0
149871 assert( pOut!=0 || SQLITE_TXN_WRITE==sqlite3BtreeTxnState(pMain) );
149882 if( pOut==0 ){
149889 if( pOut==0 ){
149896 if( pOut==0 ){
182399 ** to the output buffer pOut, followed by a position list consisting only
182401 ** The value returned is the number of bytes written to pOut (if any).
182404 sqlite3_int64 iDelta, /* Varint that may be written to pOut */
182407 char *pOut /* Write output here */
182416 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
182417 pOut[nOut++] = 0x02;
182429 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
182432 pOut[nOut++] = 0x01;
182433 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
182434 pOut[nOut++] = 0x02;
182439 pOut[nOut++] = 0x00;
184398 char *pOut = aDoclist;
184400 int res = fts3PoslistPhraseMerge(&pOut, nDist, 0, 1, &pL, &pR);
184402 nList = (int)(pOut - aDoclist);
184861 char *pOut;
184866 p2 = pOut = pPhrase->doclist.pList;
184868 &pOut, aTmp, nParam1, nParam2, paPoslist, &p2
184871 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
196420 ** append it to string buffer pOut.
196431 StrBuffer *pOut /* Write output here */
196487 rc = fts3StringAppend(pOut, &zDoc[iEnd], -1);
196506 rc = fts3StringAppend(pOut, zEllipsis, -1);
196508 rc = fts3StringAppend(pOut, zDoc, iBegin);
196516 rc = fts3StringAppend(pOut, zEllipsis, -1);
196524 if( iCurrent>iPos ) rc = fts3StringAppend(pOut, &zDoc[iEnd], iBegin-iEnd);
196525 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
196526 if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
196527 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
198635 ** append to pOut. Subsubstructure is also included. Return
198640 JsonString *pOut, /* Write JSON here */
198647 jsonAppendValue(pOut, aReplace[pNode->u.iReplace]);
198656 jsonAppendRaw(pOut, "null", 4);
198660 jsonAppendRaw(pOut, "true", 4);
198664 jsonAppendRaw(pOut, "false", 5);
198670 jsonAppendString(pOut, pNode->u.zJContent, pNode->n);
198678 jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n);
198683 jsonAppendChar(pOut, '[');
198687 jsonAppendSeparator(pOut);
198688 jsonRenderNode(&pNode[j], pOut, aReplace);
198697 jsonAppendChar(pOut, ']');
198702 jsonAppendChar(pOut, '{');
198706 jsonAppendSeparator(pOut);
198707 jsonRenderNode(&pNode[j], pOut, aReplace);
198708 jsonAppendChar(pOut, ':');
198709 jsonRenderNode(&pNode[j+1], pOut, aReplace);
198718 jsonAppendChar(pOut, '}');
204816 sqlite3_str *pOut;
204831 pOut = sqlite3_str_new(0);
204837 if( ii>0 ) sqlite3_str_append(pOut, " ", 1);
204838 sqlite3_str_appendf(pOut, "{%lld", cell.iRowid);
204841 sqlite3_str_appendf(pOut, " %g", (double)cell.aCoord[jj].f);
204843 sqlite3_str_appendf(pOut, " %d", cell.aCoord[jj].i);
204846 sqlite3_str_append(pOut, "}", 1);
204848 errCode = sqlite3_str_errcode(pOut);
204849 sqlite3_result_text(ctx, sqlite3_str_finish(pOut), -1, sqlite3_free);
205616 GeoPoly *pOut;
205619 pOut = sqlite3_malloc64( GEOPOLY_SZ((sqlite3_int64)s.nVertex) );
205621 if( pOut==0 ) goto parse_json_err;
205622 pOut->nVertex = s.nVertex;
205623 memcpy(pOut->a, s.a, s.nVertex*2*sizeof(GeoCoord));
205624 pOut->hdr[0] = *(unsigned char*)&x;
205625 pOut->hdr[1] = (s.nVertex>>16)&0xff;
205626 pOut->hdr[2] = (s.nVertex>>8)&0xff;
205627 pOut->hdr[3] = s.nVertex&0xff;
205630 return pOut;
205982 GeoPoly *pOut = 0;
206010 pOut = sqlite3_realloc64(p, GEOPOLY_SZ(4));
206011 if( pOut==0 ){
206017 pOut->nVertex = 4;
206019 pOut->hdr[0] = *(unsigned char*)ⅈ
206020 pOut->hdr[1] = 0;
206021 pOut->hdr[2] = 0;
206022 pOut->hdr[3] = 4;
206023 GeoX(pOut,0) = mnX;
206024 GeoY(pOut,0) = mnY;
206025 GeoX(pOut,1) = mxX;
206026 GeoY(pOut,1) = mnY;
206027 GeoX(pOut,2) = mxX;
206028 GeoY(pOut,2) = mxY;
206029 GeoX(pOut,3) = mnX;
206030 GeoY(pOut,3) = mxY;
206041 return pOut;
218058 int (*xOutput)(void *pOut, const void *pData, int nData),
218059 void *pOut, /* First argument for xOutput */
218145 rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
218167 rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
218204 int (*xOutput)(void *pOut, const void *pData, int nData),
218205 void *pOut
218208 return sessionGenerateChangeset(pSession, 0, xOutput, pOut, 0, 0);
218216 int (*xOutput)(void *pOut, const void *pData, int nData),
218217 void *pOut
218220 return sessionGenerateChangeset(pSession, 1, xOutput, pOut, 0, 0);
219081 int (*xOutput)(void *pOut, const void *pData, int nData),
219082 void *pOut,
219212 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
219224 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
219260 int (*xOutput)(void *pOut, const void *pData, int nData),
219261 void *pOut
219271 rc = sessionChangesetInvert(&sInput, xOutput, pOut, 0, 0);
220509 u8 *pOut = pNew->aRecord;
220513 *pOut++ = 0;
220515 *pOut++ = 0xFF;
220517 memcpy(pOut, pIn, nIn);
220518 pOut += nIn;
220522 pNew->nRecord = pOut - pNew->aRecord;
220536 u8 *pOut;
220541 pOut = pNew->aRecord = (u8*)&pNew[1];
220547 *pOut++ = 0xFF;
220549 memcpy(pOut, a1, n1);
220550 pOut += n1;
220552 memcpy(pOut, a2, n2);
220553 pOut += n2;
220558 pNew->nRecord = pOut - pNew->aRecord;
220787 int (*xOutput)(void *pOut, const void *pData, int nData),
220788 void *pOut,
220812 rc = xOutput(pOut, buf.aBuf, buf.nBuf);
220821 if( buf.nBuf>0 ) rc = xOutput(pOut, buf.aBuf, buf.nBuf);
220901 int (*xOutput)(void *pOut, const void *pData, int nData),
220902 void *pOut
220904 return sessionChangegroupOutput(pGrp, xOutput, pOut, 0, 0);
220954 int (*xOutput)(void *pOut, const void *pData, int nData),
220955 void *pOut
220968 rc = sqlite3changegroup_output_strm(pGrp, xOutput, pOut);
220998 u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
221003 memcpy(pOut, a2, nn2);
221004 pOut += nn2;
221006 memcpy(pOut, a1, nn1);
221007 pOut += nn1;
221013 pBuf->nBuf = pOut-pBuf->aBuf;
221047 u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
221052 *pOut++ = SQLITE_UPDATE;
221053 *pOut++ = pIter->bIndirect;
221059 memcpy(pOut, a1, n1);
221060 pOut += n1;
221063 memcpy(pOut, a2, n2);
221064 pOut += n2;
221066 *pOut++ = '\0';
221077 memcpy(pOut, a1, n1);
221078 pOut += n1;
221080 *pOut++ = '\0';
221085 pBuf->nBuf = (pOut - pBuf->aBuf);
221108 int (*xOutput)(void *pOut, const void *pData, int nData),
221109 void *pOut, /* Context for xOutput callback */
221208 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
221222 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
221294 int (*xOutput)(void *pOut, const void *pData, int nData),
221295 void *pOut
221301 rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
227030 Fts5Buffer *pOut; /* Output poslist */
227086 a[i].pOut = pPoslist;
227116 if( a[i].pOut->n==0 || iPos!=pWriter->iPrev ){
227117 sqlite3Fts5PoslistWriterAppend(a[i].pOut, pWriter, iPos);
227133 int bRet = a[0].pOut->n>0;
231251 Fts5StructureLevel *pOut = &pStruct->aLevel[iPromote];
231253 if( pOut->nMerge==0 ){
231262 memcpy(pOut->aSeg, &pLvl->aSeg[is], sizeof(Fts5StructureSegment));
231263 pOut->nSeg++;