Lines Matching refs:pOut
10589 ** a variable pointed to by the "pOut" parameter.
10606 ** the variable that pOut points to is unchanged.
10614 void *pOut /* Result written here */
10621 void *pOut /* Result written here */
12961 ** int (*xOutput)(void *pOut, const void *pData, int nData),
12962 ** void *pOut
12967 ** pOut pointer supplied by the application. The second parameter, pData,
13016 int (*xOutput)(void *pOut, const void *pData, int nData),
13017 void *pOut
13022 int (*xOutput)(void *pOut, const void *pData, int nData),
13023 void *pOut
13038 int (*xOutput)(void *pOut, const void *pData, int nData),
13039 void *pOut
13043 int (*xOutput)(void *pOut, const void *pData, int nData),
13044 void *pOut
13051 int (*xOutput)(void *pOut, const void *pData, int nData),
13052 void *pOut
13058 int (*xOutput)(void *pOut, const void *pData, int nData),
13059 void *pOut
23489 Mem *pOut; /* The return value is stored here */
23664 sqlite3_value *pOut; /* Register to hold each decoded output value */
34108 void *pOut; /* Result returned by the thread */
34144 p->pOut = xTask(pIn);
34157 *ppOut = p->pOut;
35245 char *pOut = p->u.zToken;
35252 *pOut++ = *pIn;
35824 SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
35835 memcpy(pOut, &u, 8);
35844 return sqlite3Atoi64(z, pOut, n, SQLITE_UTF8);
36744 VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int));
36745 if( pOut==0 ) return pIn;
36746 if( pIn==0 ) pOut[1] = 2;
36747 pIn = pOut;
37771 ** written into pOut, which must be at least nOut bytes in length.
53627 unsigned char *pOut;
53648 pOut = pStore->aData;
53650 pOut = sqlite3_malloc64( pStore->sz );
53651 if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
53653 return pOut;
53664 pOut = 0;
53677 pOut = 0;
53679 pOut = sqlite3_malloc64( sz );
53680 if( pOut ){
53686 unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
53699 return pOut;
68522 ** Read the contents of frame iRead from the wal file into buffer pOut
68529 int nOut, /* Size of buffer pOut in bytes */
68530 u8 *pOut /* Buffer to write page data to */
68540 return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
78466 u8 *pOut = &pSpace[4];
78521 while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
78525 rc = insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
81249 static int btreeHeapPull(u32 *aHeap, u32 *pOut){
81252 *pOut = aHeap[1];
83288 ctx.pOut = &t;
83308 SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){
83316 sqlite3VdbeMemSetNull(pOut);
83317 ctx.pOut = pOut;
84331 ctx.pOut = pVal;
85296 pCtx->pOut = 0;
85984 VdbeOp *pOut, *pFirst;
85990 pFirst = pOut = &p->aOp[p->nOp];
85991 for(i=0; i<nOp; i++, aOp++, pOut++){
85992 pOut->opcode = aOp->opcode;
85993 pOut->p1 = aOp->p1;
85994 pOut->p2 = aOp->p2;
85997 pOut->p2 += p->nOp;
85999 pOut->p3 = aOp->p3;
86000 pOut->p4type = P4_NOTUSED;
86001 pOut->p4.p = 0;
86002 pOut->p5 = 0;
86004 pOut->zComment = 0;
86007 pOut->iSrcLine = iLineno+i;
86928 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){
86933 if( pOut==0 ) pOut = stdout;
86945 fprintf(pOut, zFormat1, pc,
86950 fflush(pOut);
90769 Mem *pOut = pCtx->pOut;
90770 int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel);
90782 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
90783 if( sqlite3VdbeMemTooBig(pOut) ){
90823 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90839 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90850 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90851 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
90857 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90859 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
90866 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90868 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
90875 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90876 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
90882 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90883 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
90889 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90890 sqlite3VdbeMemSetNull(pCtx->pOut);
90898 Mem *pOut;
90905 pOut = pCtx->pOut;
90906 assert( sqlite3_mutex_held(pOut->db->mutex) );
90907 sqlite3VdbeMemRelease(pOut);
90908 pOut->flags = MEM_Null;
90909 sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor);
90912 Mem *pOut;
90928 pOut = pCtx->pOut;
90929 assert( sqlite3_mutex_held(pOut->db->mutex) );
90930 pOut->eSubtype = eSubtype & 0xff;
90931 pOut->flags |= MEM_Subtype;
90945 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90961 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90971 sqlite3VdbeMemZeroTerminateIfAble(pCtx->pOut);
90981 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90990 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90999 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91004 Mem *pOut;
91013 pOut = pCtx->pOut;
91014 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91015 sqlite3VdbeMemCopy(pOut, pValue);
91016 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
91017 if( sqlite3VdbeMemTooBig(pOut) ){
91025 Mem *pOut;
91030 pOut = pCtx->pOut;
91031 assert( sqlite3_mutex_held(pOut->db->mutex) );
91032 if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
91037 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
91040 return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
91051 if( pCtx->pOut->flags & MEM_Null ){
91062 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91064 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
91073 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91074 sqlite3VdbeMemSetNull(pCtx->pOut);
91076 sqlite3OomFault(pCtx->pOut->db);
91085 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91086 if( pCtx->pOut->flags & MEM_Int ){
91087 pCtx->pOut->flags &= ~MEM_Int;
91088 pCtx->pOut->flags |= MEM_IntReal;
91346 assert( p && p->pOut );
91348 return p->pOut->db;
91371 return sqlite3_value_nochange(p->pOut);
91425 sqlite3_value *pOut = pRhs->pOut;
91427 sqlite3VdbeSerialGet(&zBuf[iOff], iSerial, pOut);
91428 pOut->enc = ENC(pOut->db);
91429 if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){
91432 *ppOut = pOut;
91473 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
91507 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
91532 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91570 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91684 Mem *pOut;
91691 pOut = &pVm->pResultRow[i];
91694 pOut = (Mem*)columnNullValue();
91696 return pOut;
91778 Mem *pOut = columnMem(pStmt, i);
91779 if( pOut->flags&MEM_Static ){
91780 pOut->flags &= ~MEM_Static;
91781 pOut->flags |= MEM_Ephem;
91784 return (sqlite3_value *)pOut;
92743 void *pOut /* OUT: Write the answer here */
92752 if( p==0 || pOut==0
92774 *(i64*)pOut = res;
92799 *(sqlite3_int64*)pOut = aOp[pScan->addrLoop].nExec;
92801 *(sqlite3_int64*)pOut = -1;
92807 *(sqlite3_int64*)pOut = aOp[pScan->addrVisit].nExec;
92809 *(sqlite3_int64*)pOut = -1;
92820 *(double*)pOut = r*sqlite3LogEstToInt(x);
92824 *(const char**)pOut = pScan->zName;
92829 *(const char**)pOut = aOp[ pScan->addrExplain ].p4.z;
92831 *(const char**)pOut = 0;
92837 *(int*)pOut = aOp[ pScan->addrExplain ].p1;
92839 *(int*)pOut = -1;
92845 *(int*)pOut = aOp[ pScan->addrExplain ].p2;
92847 *(int*)pOut = -1;
92879 *(i64*)pOut = res;
92896 void *pOut /* OUT: Write the answer here */
92898 return sqlite3_stmt_scanstatus_v2(pStmt, iScan, iScanStatusOp, 0, pOut);
93766 static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){
93767 sqlite3VdbeMemSetNull(pOut);
93768 pOut->flags = MEM_Int;
93769 return pOut;
93772 Mem *pOut;
93775 pOut = &p->aMem[pOp->p2];
93776 memAboutToChange(p, pOut);
93777 if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/
93778 return out2PrereleaseWithClear(pOut);
93780 pOut->flags = MEM_Int;
93781 return pOut;
93938 Mem *pOut = 0; /* Output operand */
94247 pOut = &aMem[pOp->p1];
94248 assert( !VdbeMemDynamic(pOut) );
94249 pOut->u.i = pOp->p3 - 1;
94250 pOut->flags = MEM_Int;
94430 pOut = out2Prerelease(p, pOp);
94431 pOut->u.i = pOp->p1;
94442 pOut = out2Prerelease(p, pOp);
94444 pOut->u.i = *pOp->p4.pI64;
94456 pOut = out2Prerelease(p, pOp);
94457 pOut->flags = MEM_Real;
94459 pOut->u.r = *pOp->p4.pReal;
94474 pOut = out2Prerelease(p, pOp);
94479 rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
94482 if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
94483 assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
94484 assert( VdbeMemDynamic(pOut)==0 );
94485 pOut->szMalloc = 0;
94486 pOut->flags |= MEM_Static;
94491 pOp->p4.z = pOut->z;
94492 pOp->p1 = pOut->n;
94518 pOut = out2Prerelease(p, pOp);
94519 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
94520 pOut->z = pOp->p4.z;
94521 pOut->n = pOp->p1;
94522 pOut->enc = encoding;
94523 UPDATE_MAX_BLOBSIZE(pOut);
94529 if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
94573 pOut = out2Prerelease(p, pOp);
94576 pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
94577 pOut->n = 0;
94579 pOut->uTemp = 0;
94582 pOut++;
94583 memAboutToChange(p, pOut);
94584 sqlite3VdbeMemSetNull(pOut);
94585 pOut->flags = nullFlag;
94586 pOut->n = 0;
94602 pOut = &aMem[pOp->p1];
94603 pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
94616 pOut = out2Prerelease(p, pOp);
94618 sqlite3VdbeMemSetZeroBlob(pOut, pOp->p1);
94619 if( sqlite3VdbeMemExpandBlob(pOut) ) goto no_mem;
94621 sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
94623 pOut->enc = encoding;
94624 UPDATE_MAX_BLOBSIZE(pOut);
94641 pOut = &aMem[pOp->p2];
94642 if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut);
94643 memcpy(pOut, pVar, MEMCELLSIZE);
94644 pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
94645 pOut->flags |= MEM_Static|MEM_FromBind;
94646 UPDATE_MAX_BLOBSIZE(pOut);
94671 pOut = &aMem[p2];
94673 assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
94676 memAboutToChange(p, pOut);
94677 sqlite3VdbeMemMove(pOut, pIn1);
94683 aMem[i].pScopyFrom = pOut;
94688 Deephemeralize(pOut);
94689 REGISTER_TRACE(p2++, pOut);
94691 pOut++;
94714 pOut = &aMem[pOp->p2];
94715 assert( pOut!=pIn1 );
94717 memAboutToChange(p, pOut);
94718 sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
94719 Deephemeralize(pOut);
94720 if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){
94721 pOut->flags &= ~MEM_Subtype;
94724 pOut->pScopyFrom = 0;
94726 REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
94728 pOut++;
94749 pOut = &aMem[pOp->p2];
94750 assert( pOut!=pIn1 );
94751 sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
94753 pOut->pScopyFrom = pIn1;
94754 pOut->mScopyFlags = pIn1->flags;
94770 pOut = &aMem[pOp->p2];
94771 sqlite3VdbeMemSetInt64(pOut, pIn1->u.i);
94854 pOut = &aMem[pOp->p3];
94855 testcase( pOut==pIn2 );
94856 assert( pIn1!=pOut );
94861 sqlite3VdbeMemSetNull(pOut);
94883 if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){
94886 MemSetTypeFlag(pOut, MEM_Str);
94887 if( pOut!=pIn2 ){
94888 memcpy(pOut->z, pIn2->z, pIn2->n);
94892 memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
94896 pOut->z[nByte]=0;
94897 pOut->z[nByte+1] = 0;
94898 pOut->flags |= MEM_Term;
94899 pOut->n = (int)nByte;
94900 pOut->enc = encoding;
94901 UPDATE_MAX_BLOBSIZE(pOut);
94959 pOut = &aMem[pOp->p3];
94981 pOut->u.i = iB;
94982 MemSetTypeFlag(pOut, MEM_Int);
95012 pOut->u.i = rB;
95013 MemSetTypeFlag(pOut, MEM_Int);
95018 pOut->u.r = rB;
95019 MemSetTypeFlag(pOut, MEM_Real);
95025 sqlite3VdbeMemSetNull(pOut);
95093 pOut = &aMem[pOp->p3];
95095 sqlite3VdbeMemSetNull(pOut);
95129 pOut->u.i = iA;
95130 MemSetTypeFlag(pOut, MEM_Int);
95659 pOut = &aMem[pOp->p3];
95661 MemSetTypeFlag(pOut, MEM_Null);
95663 pOut->u.i = v1;
95664 MemSetTypeFlag(pOut, MEM_Int);
95707 pOut = &aMem[pOp->p2];
95709 sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0));
95711 sqlite3VdbeMemSetNull(pOut);
95725 pOut = &aMem[pOp->p2];
95726 sqlite3VdbeMemSetNull(pOut);
95728 pOut->flags = MEM_Int;
95729 pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
95980 pOut = &p->aMem[pOp->p3];
95982 sqlite3VdbeMemSetNull(pOut);
95989 sqlite3VdbeMemSetNull(pOut);
95991 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
96536 pOut = &aMem[pOp->p3];
96537 memAboutToChange(p, pOut);
96714 if( nByte+nZero<=pOut->szMalloc ){
96717 pOut->z = pOut->zMalloc;
96724 if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
96728 pOut->n = (int)nByte;
96729 pOut->flags = MEM_Blob;
96731 pOut->u.nZero = nZero;
96732 pOut->flags |= MEM_Zero;
96734 UPDATE_MAX_BLOBSIZE(pOut);
96735 zHdr = (u8 *)pOut->z;
96802 assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
96803 assert( nByte==(int)(zPayload - (u8*)pOut->z) );
96806 REGISTER_TRACE(pOp->p3, pOut);
96834 pOut = out2Prerelease(p, pOp);
96835 pOut->u.i = nEntry;
97252 pOut = out2Prerelease(p, pOp);
97253 pOut->u.i = iMeta;
98585 pOut = out2Prerelease(p, pOp);
98586 pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
98618 pOut = out2Prerelease(p, pOp);
98724 pOut->u.i = v;
99082 pOut = &aMem[pOp->p2];
99085 rc = sqlite3VdbeSorterRowkey(pC, pOut);
99086 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
99126 pOut = out2Prerelease(p, pOp);
99153 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut);
99155 if( !pOp->p3 ) Deephemeralize(pOut);
99156 UPDATE_MAX_BLOBSIZE(pOut);
99157 REGISTER_TRACE(pOp->p2, pOut);
99177 pOut = out2Prerelease(p, pOp);
99183 pOut->flags = MEM_Null;
99203 pOut->flags = MEM_Null;
99208 pOut->u.i = v;
99740 pOut = out2Prerelease(p, pOp);
99741 pOut->u.i = rowid;
99920 pOut = out2Prerelease(p, pOp);
99921 pOut->flags = MEM_Null;
99931 pOut->flags = MEM_Int;
99932 pOut->u.i = iMoved;
100022 pOut = out2Prerelease(p, pOp);
100032 pOut->u.i = pgno;
100548 pOut = out2Prerelease(p, pOp);
100551 sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
100675 pOut = out2Prerelease(p, pOp);
100687 pOut->u.i = -1;
100689 pOut->u.i = x;
100782 pCtx->pOut = (Mem*)&(pCtx->argv[n]);
100783 sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
100838 assert( pCtx->pOut->flags==MEM_Null );
100850 sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
100859 sqlite3VdbeMemRelease(pCtx->pOut);
100860 pCtx->pOut->flags = MEM_Null;
100864 assert( pCtx->pOut->flags==MEM_Null );
100982 pOut = out2Prerelease(p, pOp);
101057 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
101058 pOut->z = (char *)sqlite3JournalModename(eNew);
101059 pOut->n = sqlite3Strlen30(pOut->z);
101060 pOut->enc = SQLITE_UTF8;
101061 sqlite3VdbeChangeEncoding(pOut, encoding);
101327 pOut = &aMem[pOp->p2];
101328 sqlite3VdbeMemSetNull(pOut); /* Innocent until proven guilty */
101351 sqlite3VdbeMemSetStr(pOut, zErr, -1, SQLITE_UTF8, sqlite3_free);
101376 pRhs->pOut = &aMem[pOp->p3];
101377 pOut = out2Prerelease(p, pOp);
101378 pOut->flags = MEM_Null;
101379 sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList", sqlite3VdbeValueListFree);
101486 sContext.pOut = pDest;
101681 pOut = out2Prerelease(p, pOp);
101682 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
101701 pOut = out2Prerelease(p, pOp);
101708 pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
101771 pOut = &aMem[pOp->p3];
101772 if( pCtx->pOut != pOut ){
101774 pCtx->pOut = pOut;
101780 memAboutToChange(p, pOut);
101787 MemSetTypeFlag(pOut, MEM_Null);
101794 sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
101802 assert( (pOut->flags&MEM_Str)==0
101803 || pOut->enc==encoding
101805 assert( !sqlite3VdbeMemTooBig(pOut) );
101807 REGISTER_TRACE(pOp->p3, pOut);
101808 UPDATE_MAX_BLOBSIZE(pOut);
101831 pOut = &aMem[pOp->p2];
101833 sqlite3VdbeMemSetInt64(pOut, pIn1->eSubtype);
101835 sqlite3VdbeMemSetNull(pOut);
101848 pOut = &aMem[pOp->p2];
101850 pOut->flags &= ~MEM_Subtype;
101853 pOut->flags |= MEM_Subtype;
101854 pOut->eSubtype = (u8)(pIn1->u.i & 0xff);
104682 SorterFile *pOut = &pIncr->aFile[1];
104690 vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart);
104709 rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof);
105496 ** Copy the current sorter key into the memory cell pOut.
105498 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){
105500 void *pKey; int nKey; /* Sorter key to copy into pOut */
105505 if( sqlite3VdbeMemClearAndResize(pOut, nKey) ){
105508 pOut->n = nKey;
105509 MemSetTypeFlag(pOut, MEM_Blob);
105510 memcpy(pOut->z, pKey, nKey);
155114 sqlite3_value *pOut /* Write results here, if not NULL. VACUUM INTO */
155142 if( pOut ){
155143 if( sqlite3_value_type(pOut)!=SQLITE_TEXT ){
155147 zOut = (const char*)sqlite3_value_text(pOut);
155194 if( pOut ){
155221 rc = sqlite3BtreeBeginTrans(pMain, pOut==0 ? 2 : 0, 0);
155227 && pOut==0
155318 assert( pOut!=0 || SQLITE_TXN_WRITE==sqlite3BtreeTxnState(pMain) );
155329 if( pOut==0 ){
155336 if( pOut==0 ){
155343 if( pOut==0 ){
188919 ** to the output buffer pOut, followed by a position list consisting only
188921 ** The value returned is the number of bytes written to pOut (if any).
188924 sqlite3_int64 iDelta, /* Varint that may be written to pOut */
188927 char *pOut /* Write output here */
188936 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
188937 pOut[nOut++] = 0x02;
188949 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
188952 pOut[nOut++] = 0x01;
188953 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
188954 pOut[nOut++] = 0x02;
188959 pOut[nOut++] = 0x00;
190974 char *pOut = aDoclist;
190976 int res = fts3PoslistPhraseMerge(&pOut, nDist, 0, 1, &pL, &pR);
190978 nList = (int)(pOut - aDoclist);
191437 char *pOut;
191442 p2 = pOut = pPhrase->doclist.pList;
191444 &pOut, aTmp, nParam1, nParam2, paPoslist, &p2
191447 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
203036 ** append it to string buffer pOut.
203047 StrBuffer *pOut /* Write output here */
203103 rc = fts3StringAppend(pOut, &zDoc[iEnd], -1);
203122 rc = fts3StringAppend(pOut, zEllipsis, -1);
203124 rc = fts3StringAppend(pOut, zDoc, iBegin);
203132 rc = fts3StringAppend(pOut, zEllipsis, -1);
203140 if( iCurrent>iPos ) rc = fts3StringAppend(pOut, &zDoc[iEnd], iBegin-iEnd);
203141 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
203142 if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
203143 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
206977 ** text onto the end of pOut. Return the index in pParse->aBlob[]
206980 ** If an error is detected in the BLOB input, the pOut->eErr flag
206985 ** The pOut->eErr JSTRING_OOM flag is set on a OOM.
206990 JsonString *pOut /* Write JSON here */
206996 pOut->eErr |= JSTRING_MALFORMED;
207001 jsonAppendRawNZ(pOut, "null", 4);
207005 jsonAppendRawNZ(pOut, "true", 4);
207009 jsonAppendRawNZ(pOut, "false", 5);
207015 jsonAppendRaw(pOut, (const char*)&pParse->aBlob[i+n], sz);
207025 jsonAppendChar(pOut, '-');
207032 pOut->eErr |= JSTRING_MALFORMED;
207040 jsonPrintf(100,pOut,bOverflow?"9.0e999":"%llu", u);
207048 jsonAppendChar(pOut, '-');
207052 jsonAppendChar(pOut, '0');
207055 jsonAppendChar(pOut, zIn[k]);
207057 jsonAppendChar(pOut, '0');
207064 jsonAppendChar(pOut, '"');
207065 jsonAppendRaw(pOut, (const char*)&pParse->aBlob[i+n], sz);
207066 jsonAppendChar(pOut, '"');
207074 jsonAppendChar(pOut, '"');
207078 jsonAppendRawNZ(pOut, zIn, k);
207086 jsonAppendRawNZ(pOut, "\\\"", 2);
207092 if( pOut->nUsed+7>pOut->nAlloc && jsonStringGrow(pOut,7) ) break;
207093 jsonAppendControlChar(pOut, zIn[0]);
207101 pOut->eErr |= JSTRING_MALFORMED;
207106 jsonAppendChar(pOut, '\'');
207109 jsonAppendRawNZ(pOut, "\\u0009", 6);
207113 pOut->eErr |= JSTRING_MALFORMED;
207117 jsonAppendRawNZ(pOut, "\\u00", 4);
207118 jsonAppendRawNZ(pOut, &zIn[2], 2);
207123 jsonAppendRawNZ(pOut, "\\u0000", 6);
207141 pOut->eErr |= JSTRING_MALFORMED;
207149 jsonAppendRawNZ(pOut, zIn, 2);
207156 jsonAppendChar(pOut, '"');
207160 jsonAppendString(pOut, (const char*)&pParse->aBlob[i+n], sz);
207164 jsonAppendChar(pOut, '[');
207167 while( j<iEnd && pOut->eErr==0 ){
207168 j = jsonTranslateBlobToText(pParse, j, pOut);
207169 jsonAppendChar(pOut, ',');
207171 if( j>iEnd ) pOut->eErr |= JSTRING_MALFORMED;
207172 if( sz>0 ) jsonStringTrimOneChar(pOut);
207173 jsonAppendChar(pOut, ']');
207178 jsonAppendChar(pOut, '{');
207181 while( j<iEnd && pOut->eErr==0 ){
207182 j = jsonTranslateBlobToText(pParse, j, pOut);
207183 jsonAppendChar(pOut, (x++ & 1) ? ',' : ':');
207185 if( (x & 1)!=0 || j>iEnd ) pOut->eErr |= JSTRING_MALFORMED;
207186 if( sz>0 ) jsonStringTrimOneChar(pOut);
207187 jsonAppendChar(pOut, '}');
207193 pOut->eErr |= JSTRING_MALFORMED;
207205 JsonString *pOut; /* Generate pretty output into this string */
207215 jsonAppendRaw(pPretty->pOut, pPretty->zIndent, pPretty->szIndent);
207222 ** text onto the end of pOut. Return the index in pParse->aBlob[]
207229 ** If an error is detected in the BLOB input, the pOut->eErr flag
207234 ** The pOut->eErr JSTRING_OOM flag is set on a OOM.
207242 JsonString *pOut = pPretty->pOut;
207245 pOut->eErr |= JSTRING_MALFORMED;
207252 jsonAppendChar(pOut, '[');
207254 jsonAppendChar(pOut, '\n');
207256 while( pOut->eErr==0 ){
207260 jsonAppendRawNZ(pOut, ",\n", 2);
207262 jsonAppendChar(pOut, '\n');
207266 jsonAppendChar(pOut, ']');
207273 jsonAppendChar(pOut, '{');
207275 jsonAppendChar(pOut, '\n');
207277 while( pOut->eErr==0 ){
207279 j = jsonTranslateBlobToText(pParse, j, pOut);
207281 pOut->eErr |= JSTRING_MALFORMED;
207284 jsonAppendRawNZ(pOut, ": ", 2);
207287 jsonAppendRawNZ(pOut, ",\n", 2);
207289 jsonAppendChar(pOut, '\n');
207293 jsonAppendChar(pOut, '}');
207298 i = jsonTranslateBlobToText(pParse, i, pOut);
208432 sqlite3_str *pOut /* Generate output into this sqlite3_str object */
208439 sqlite3_str_appendf(pOut, "%5d:%*s", iStart, nIndent, "");
208449 sqlite3_str_appendf(pOut, " %02x", pParse->aBlob[iStart+i]);
208452 sqlite3_str_appendf(pOut, " ERROR invalid node size\n");
208467 sqlite3_str_appendall(pOut," <-- ");
208469 case JSONB_NULL: sqlite3_str_appendall(pOut,"null"); break;
208470 case JSONB_TRUE: sqlite3_str_appendall(pOut,"true"); break;
208471 case JSONB_FALSE: sqlite3_str_appendall(pOut,"false"); break;
208472 case JSONB_INT: sqlite3_str_appendall(pOut,"int"); break;
208473 case JSONB_INT5: sqlite3_str_appendall(pOut,"int5"); break;
208474 case JSONB_FLOAT: sqlite3_str_appendall(pOut,"float"); break;
208475 case JSONB_FLOAT5: sqlite3_str_appendall(pOut,"float5"); break;
208476 case JSONB_TEXT: sqlite3_str_appendall(pOut,"text"); break;
208477 case JSONB_TEXTJ: sqlite3_str_appendall(pOut,"textj"); break;
208478 case JSONB_TEXT5: sqlite3_str_appendall(pOut,"text5"); break;
208479 case JSONB_TEXTRAW: sqlite3_str_appendall(pOut,"textraw"); break;
208481 sqlite3_str_appendf(pOut,"array, %u bytes\n", sz);
208482 jsonDebugPrintBlob(pParse, iStart+n, iStart+n+sz, nIndent+2, pOut);
208487 sqlite3_str_appendf(pOut, "object, %u bytes\n", sz);
208488 jsonDebugPrintBlob(pParse, iStart+n, iStart+n+sz, nIndent+2, pOut);
208493 sqlite3_str_appendall(pOut, "ERROR: unknown node type\n");
208500 sqlite3_str_append(pOut, "\n", 1);
208503 sqlite3_str_appendall(pOut, ": \"");
208507 sqlite3_str_append(pOut, (char*)&c, 1);
208509 sqlite3_str_append(pOut, "\"\n", 2);
209239 x.pOut = &s;
214068 sqlite3_str *pOut;
214083 pOut = sqlite3_str_new(0);
214089 if( ii>0 ) sqlite3_str_append(pOut, " ", 1);
214090 sqlite3_str_appendf(pOut, "{%lld", cell.iRowid);
214093 sqlite3_str_appendf(pOut, " %g", (double)cell.aCoord[jj].f);
214095 sqlite3_str_appendf(pOut, " %d", cell.aCoord[jj].i);
214098 sqlite3_str_append(pOut, "}", 1);
214100 errCode = sqlite3_str_errcode(pOut);
214101 sqlite3_result_text(ctx, sqlite3_str_finish(pOut), -1, sqlite3_free);
214877 GeoPoly *pOut;
214880 pOut = sqlite3_malloc64( GEOPOLY_SZ((sqlite3_int64)s.nVertex) );
214882 if( pOut==0 ) goto parse_json_err;
214883 pOut->nVertex = s.nVertex;
214884 memcpy(pOut->a, s.a, s.nVertex*2*sizeof(GeoCoord));
214885 pOut->hdr[0] = *(unsigned char*)&x;
214886 pOut->hdr[1] = (s.nVertex>>16)&0xff;
214887 pOut->hdr[2] = (s.nVertex>>8)&0xff;
214888 pOut->hdr[3] = s.nVertex&0xff;
214891 return pOut;
215249 GeoPoly *pOut = 0;
215277 pOut = sqlite3_realloc64(p, GEOPOLY_SZ(4));
215278 if( pOut==0 ){
215284 pOut->nVertex = 4;
215286 pOut->hdr[0] = *(unsigned char*)ⅈ
215287 pOut->hdr[1] = 0;
215288 pOut->hdr[2] = 0;
215289 pOut->hdr[3] = 4;
215290 GeoX(pOut,0) = mnX;
215291 GeoY(pOut,0) = mnY;
215292 GeoX(pOut,1) = mxX;
215293 GeoY(pOut,1) = mnY;
215294 GeoX(pOut,2) = mxX;
215295 GeoY(pOut,2) = mxY;
215296 GeoX(pOut,3) = mnX;
215297 GeoY(pOut,3) = mxY;
215308 return pOut;
227862 int (*xOutput)(void *pOut, const void *pData, int nData),
227863 void *pOut, /* First argument for xOutput */
227948 rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
227969 rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
228006 int (*xOutput)(void *pOut, const void *pData, int nData),
228007 void *pOut
228010 return sessionGenerateChangeset(pSession, 0, xOutput, pOut, 0, 0);
228018 int (*xOutput)(void *pOut, const void *pData, int nData),
228019 void *pOut
228022 return sessionGenerateChangeset(pSession, 1, xOutput, pOut, 0, 0);
228896 int (*xOutput)(void *pOut, const void *pData, int nData),
228897 void *pOut,
229027 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
229039 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
229075 int (*xOutput)(void *pOut, const void *pData, int nData),
229076 void *pOut
229086 rc = sessionChangesetInvert(&sInput, xOutput, pOut, 0, 0);
230366 u8 *pOut = pNew->aRecord;
230370 *pOut++ = 0;
230372 *pOut++ = 0xFF;
230374 memcpy(pOut, pIn, nIn);
230375 pOut += nIn;
230379 pNew->nRecord = pOut - pNew->aRecord;
230393 u8 *pOut;
230398 pOut = pNew->aRecord = (u8*)&pNew[1];
230404 *pOut++ = 0xFF;
230406 memcpy(pOut, a1, n1);
230407 pOut += n1;
230409 memcpy(pOut, a2, n2);
230410 pOut += n2;
230415 pNew->nRecord = pOut - pNew->aRecord;
230544 SessionBuffer *pOut
230552 pOut->nBuf = 0;
230555 sessionAppendBlob(pOut, aRec, nRec, &rc);
230561 sessionAppendByte(pOut, eType, &rc);
230572 if( SQLITE_OK==sessionBufferGrow(pOut, 8, &rc) ){
230573 sessionPutI64(&pOut->aBuf[pOut->nBuf], iVal);
230581 sessionAppendVarint(pOut, n, &rc);
230584 sessionAppendBlob(pOut, z, n, &rc);
230587 sessionAppendBlob(pOut, z, n, &rc);
230605 sessionAppendBlob(pOut, aRec, iOff, &rc);
230607 sessionAppendByte(pOut, 0x00, &rc);
230611 sessionAppendBlob(pOut, &aRec[iOff], nRec-iOff, &rc);
230613 sessionAppendByte(pOut, 0x00, &rc);
230617 sessionAppendBlob(pOut, aRec, nRec, &rc);
230819 int (*xOutput)(void *pOut, const void *pData, int nData),
230820 void *pOut,
230844 rc = xOutput(pOut, buf.aBuf, buf.nBuf);
230853 if( buf.nBuf>0 ) rc = xOutput(pOut, buf.aBuf, buf.nBuf);
230975 int (*xOutput)(void *pOut, const void *pData, int nData),
230976 void *pOut
230978 return sessionChangegroupOutput(pGrp, xOutput, pOut, 0, 0);
231030 int (*xOutput)(void *pOut, const void *pData, int nData),
231031 void *pOut
231044 rc = sqlite3changegroup_output_strm(pGrp, xOutput, pOut);
231074 u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
231079 memcpy(pOut, a2, nn2);
231080 pOut += nn2;
231082 memcpy(pOut, a1, nn1);
231083 pOut += nn1;
231089 pBuf->nBuf = pOut-pBuf->aBuf;
231123 u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
231128 *pOut++ = SQLITE_UPDATE;
231129 *pOut++ = pIter->bIndirect;
231135 memcpy(pOut, a1, n1);
231136 pOut += n1;
231139 memcpy(pOut, a2, n2);
231140 pOut += n2;
231142 *pOut++ = '\0';
231153 memcpy(pOut, a1, n1);
231154 pOut += n1;
231156 *pOut++ = '\0';
231161 pBuf->nBuf = (pOut - pBuf->aBuf);
231184 int (*xOutput)(void *pOut, const void *pData, int nData),
231185 void *pOut, /* Context for xOutput callback */
231284 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
231298 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
231370 int (*xOutput)(void *pOut, const void *pData, int nData),
231371 void *pOut
231377 rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
237391 Fts5Buffer *pOut; /* Output poslist */
237447 a[i].pOut = pPoslist;
237477 if( a[i].pOut->n==0 || iPos!=pWriter->iPrev ){
237478 sqlite3Fts5PoslistWriterAppend(a[i].pOut, pWriter, iPos);
237494 int bRet = a[0].pOut->n>0;
241976 Fts5StructureLevel *pOut = &pStruct->aLevel[iPromote];
241978 if( pOut->nMerge==0 ){
241987 memcpy(pOut->aSeg, &pLvl->aSeg[is], sizeof(Fts5StructureSegment));
241988 pOut->nSeg++;