Lines Matching refs:zOut
1746 ** of good-quality randomness into zOut. The return value is
1785 int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1790 int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
30177 char *zOut; /* Rendering buffer */
30404 zOut = buf;
30409 zOut = zExtra = printfTempBuf(pAccum, n);
30410 if( zOut==0 ) return;
30413 bufpt = &zOut[nOut-1];
30431 length = (int)(&zOut[nOut-1]-bufpt);
30457 length = (int)(&zOut[nOut-1]-bufpt);
30552 zOut = bufpt;
30584 assert( bufpt>zOut );
30613 length = (int)(bufpt-zOut);
30614 bufpt = zOut;
33125 #define WRITE_UTF8(zOut, c) { \
33127 *zOut++ = (u8)(c&0xFF); \
33130 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \
33131 *zOut++ = 0x80 + (u8)(c & 0x3F); \
33134 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \
33135 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
33136 *zOut++ = 0x80 + (u8)(c & 0x3F); \
33138 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \
33139 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \
33140 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
33141 *zOut++ = 0x80 + (u8)(c & 0x3F); \
33145 #define WRITE_UTF16LE(zOut, c) { \
33147 *zOut++ = (u8)(c&0x00FF); \
33148 *zOut++ = (u8)((c>>8)&0x00FF); \
33150 *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
33151 *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
33152 *zOut++ = (u8)(c&0x00FF); \
33153 *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \
33157 #define WRITE_UTF16BE(zOut, c) { \
33159 *zOut++ = (u8)((c>>8)&0x00FF); \
33160 *zOut++ = (u8)(c&0x00FF); \
33162 *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
33163 *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
33164 *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \
33165 *zOut++ = (u8)(c&0x00FF); \
33245 unsigned char *zOut; /* Output buffer */
33312 ** Variable zOut is set to point at the output buffer, space obtained
33317 zOut = sqlite3DbMallocRaw(pMem->db, len);
33318 if( !zOut ){
33321 z = zOut;
33338 pMem->n = (int)(z - zOut);
33401 pMem->n = (int)(z - zOut);
33410 pMem->z = (char*)zOut;
33507 unsigned char *zOut = zIn;
33511 while( zIn[0] && zOut<=zIn ){
33514 WRITE_UTF8(zOut, c);
33517 *zOut = 0;
33518 return (int)(zOut - zStart);
34234 ** Render an signed 64-bit integer as text. Store the result in zOut[].
34236 ** The caller must ensure that zOut[] is at least 21 bytes in size.
34238 SQLITE_PRIVATE void sqlite3Int64ToText(i64 v, char *zOut){
34254 memcpy(zOut, &zTemp[i+1], sizeof(zTemp)-1-i);
35880 static int kvvfsFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
35882 static int kvvfsRandomness(sqlite3_vfs*, int nByte, char *zOut);
36482 char *zOut;
36487 zOut = sqlite3_malloc64( pFile->nJrnl*2 + 50 );
36488 if( zOut==0 ){
36494 zOut[i++] = 'a' + (n%26);
36497 zOut[i++] = ' ';
36498 kvvfsEncode(pFile->aJrnl, pFile->nJrnl, &zOut[i]);
36499 i = sqlite3KvvfsMethods.xWrite(pFile->zClass, "jrnl", zOut);
36500 sqlite3_free(zOut);
36685 ** Populate buffer zOut with the full canonical pathname corresponding
36686 ** to the pathname in zPath. zOut is guaranteed to point to a buffer
36693 char *zOut
36702 memcpy(zOut, zPath, nPath);
36703 zOut[nPath] = 0;
43362 char *zOut, /* Output buffer */
43363 int nOut /* Allocated size of buffer zOut */
43369 if( osGetcwd(zOut, nOut-2)==0 ){
43372 iOff = sqlite3Strlen30(zOut);
43373 zOut[iOff++] = '/';
43378 zOut[iOff] = '\0';
43381 sqlite3_snprintf(nOut-iOff, &zOut[iOff], "%s", zPath);
43385 for(i=j=1; zOut[i]; i++){
43386 zOut[j++] = zOut[i];
43387 while( zOut[i]=='/' && zOut[i+1]=='/' ) i++;
43389 zOut[j] = 0;
43391 assert( zOut[0]=='/' );
43392 for(i=j=0; zOut[i]; i++){
43393 if( zOut[i]=='/' ){
43395 if( zOut[i+1]=='.' && zOut[i+2]=='/' ){
43403 if( zOut[i+1]=='.'
43404 && zOut[i+2]=='.'
43405 && zOut[i+3]=='/'
43406 && unixBackupDir(zOut, &j)
43412 if( ALWAYS(j>=0) ) zOut[j] = zOut[i];
43415 if( NEVER(j==0) ) zOut[j++] = '/';
43416 zOut[j] = 0;
43425 ** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes
43433 char *zOut /* Output buffer */
43436 return mkFullPathname(zPath, zOut, nOut);
43500 assert( rc!=SQLITE_OK || zIn!=zOut || zIn[0]=='/' );
43501 if( rc==SQLITE_OK && zIn!=zOut ){
43502 rc = mkFullPathname(zIn, zOut, nOut);
43505 zIn = zOut;
47073 char *zOut = 0;
47101 zOut = winUnicodeToUtf8(zTempWide);
47124 zOut = winMbcsToUtf8(zTemp, osAreFileApisANSI());
47135 sqlite3_snprintf(nBuf, zBuf, "%s", zOut);
47137 sqlite3_free(zOut);
50651 ** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
50663 char *zOut;
50685 char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 );
50686 if( !zOut ){
50691 CCP_RELATIVE, zRelative, zOut, pVfs->mxPathname+1)<0 ){
50692 sqlite3_free(zOut);
50696 char *zUtf8 = winConvertToUtf8Filename(zOut);
50698 sqlite3_free(zOut);
50704 sqlite3_free(zOut);
50707 char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 );
50708 if( !zOut ){
50713 zRelative, zOut, pVfs->mxPathname+1)<0 ){
50714 sqlite3_free(zOut);
50718 char *zUtf8 = winConvertToUtf8Filename(zOut);
50720 sqlite3_free(zOut);
50725 sqlite3_free(zOut);
50794 zOut = winUnicodeToUtf8(zTemp);
50820 zOut = winMbcsToUtf8(zTemp, osAreFileApisANSI());
50824 if( zOut ){
50825 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut);
50826 sqlite3_free(zOut);
51397 static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
51402 static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut);
51924 ** Populate buffer zOut with the full canonical pathname corresponding
51925 ** to the pathname in zPath. zOut is guaranteed to point to a buffer
51932 char *zOut
51935 sqlite3_snprintf(nOut, zOut, "%s", zPath);
80037 u8 *zOut = &zDestData[iOff%nDestPgsz];
80046 memcpy(zOut, zIn, nCopy);
80049 sqlite3Put4byte(&zOut[28], sqlite3BtreeLastPage(p->pSrc));
103065 u8 *zOut = zBuf;
103091 memcpy(zOut, (u8*)pChunk->zChunk + iChunkOffset, nCopy);
103092 zOut += nCopy;
113518 char *zOut;
113537 zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1);
113539 zOut = (char*)sqlite3DbMallocZero(db, (nSql*2+1) * 3);
113540 if( zOut ){
113541 zBuf1 = &zOut[nSql*2+1];
113542 zBuf2 = &zOut[nSql*4+2];
113550 if( zOut ){
113552 memcpy(zOut, zSql, nSql);
113554 int iOff; /* Offset of token to replace in zOut */
113587 memmove(&zOut[iOff + nReplace], &zOut[iOff + pBest->t.n],
113591 zOut[nOut] = '\0';
113593 memcpy(&zOut[iOff], zReplace, nReplace);
113597 sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT);
113598 sqlite3DbFree(db, zOut);
125881 unsigned char *z, *zOut;
125883 zOut = z = sqlite3_malloc64( argc*4+1 );
125895 *zOut++ = (u8)(c&0xFF);
125897 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
125898 *zOut++ = 0x80 + (u8)(c & 0x3F);
125900 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
125901 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
125902 *zOut++ = 0x80 + (u8)(c & 0x3F);
125904 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
125905 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);
125906 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
125907 *zOut++ = 0x80 + (u8)(c & 0x3F);
125910 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
125976 unsigned char *zOut; /* The output */
125980 i64 nOut; /* Maximum size of zOut */
125983 unsigned cntExpand; /* Number zOut expansions */
126011 zOut = contextMalloc(context, (i64)nOut);
126012 if( zOut==0 ){
126019 zOut[j++] = zStr[i];
126027 sqlite3_free(zOut);
126035 zOld = zOut;
126036 zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1));
126037 if( zOut==0 ){
126044 memcpy(&zOut[j], zRep, nRep);
126050 memcpy(&zOut[j], &zStr[i], nStr-i);
126053 zOut[j] = 0;
126054 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
149673 const char *zOut; /* Name of output file */
149690 zOut = (const char*)sqlite3_value_text(pOut);
149694 zOut = "";
149730 rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS vacuum_db", zOut);
188295 static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
188301 zOut[i] = c - 'A' + 'a';
188304 zOut[i] = c;
188310 zOut[j] = zOut[i];
188314 zOut[i] = 0;
188320 ** Stem the input word zIn[0..nIn-1]. Store the output in zOut.
188321 ** zOut is at least big enough to hold nIn bytes. Write the actual
188340 ** no chance of overflowing the zOut buffer.
188342 static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
188349 copy_stemmer(zIn, nIn, zOut, pnOut);
188361 copy_stemmer(zIn, nIn, zOut, pnOut);
188569 zOut[i] = 0;
188571 zOut[--i] = *(z++);
197516 #define WRITE_UTF8(zOut, c) { \
197518 *zOut++ = (u8)(c&0xFF); \
197521 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \
197522 *zOut++ = 0x80 + (u8)(c & 0x3F); \
197525 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \
197526 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
197527 *zOut++ = 0x80 + (u8)(c & 0x3F); \
197529 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \
197530 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \
197531 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
197532 *zOut++ = 0x80 + (u8)(c & 0x3F); \
197784 char *zOut;
197800 zOut = pCsr->zToken;
197805 if( (zOut-pCsr->zToken)>=(pCsr->nAlloc-4) ){
197808 zOut = &zNew[zOut - pCsr->zToken];
197817 WRITE_UTF8(zOut, iOut);
197830 *pnToken = (int)(zOut - pCsr->zToken);
198856 char *zOut;
198860 zOut = sqlite3_malloc( n+1 );
198861 if( zOut==0 ){
198868 zOut[j++] = c;
198876 zOut[j++] = (char)v;
198878 zOut[j++] = (char)(0xc0 | (v>>6));
198879 zOut[j++] = 0x80 | (v&0x3f);
198891 zOut[j++] = 0xf0 | (v>>18);
198892 zOut[j++] = 0x80 | ((v>>12)&0x3f);
198893 zOut[j++] = 0x80 | ((v>>6)&0x3f);
198894 zOut[j++] = 0x80 | (v&0x3f);
198896 zOut[j++] = 0xe0 | (v>>12);
198897 zOut[j++] = 0x80 | ((v>>6)&0x3f);
198898 zOut[j++] = 0x80 | (v&0x3f);
198913 zOut[j++] = c;
198917 zOut[j] = 0;
198918 sqlite3_result_text(pCtx, zOut, j, sqlite3_free);
209382 char *zOut /* Write the output into this preallocated buffer */
209387 char *zOrigOut = zOut;
209417 memcpy(zOut, &zSrc[ofst], cnt);
209418 zOut += cnt;
209432 memcpy(zOut, zDelta, cnt);
209433 zOut += cnt;
209440 zOut[0] = 0;
213683 char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
213684 *(char**)pArg = zOut;
213685 if( zOut==0 ) rc = SQLITE_NOMEM;
213984 ** Populate buffer zOut with the full canonical pathname corresponding
213985 ** to the pathname in zPath. zOut is guaranteed to point to a buffer
213992 char *zOut
213995 return pRealVfs->xFullPathname(pRealVfs, zPath, nOut, zOut);
217669 char *zOut = (char *)&p->aBuf[p->nBuf];
217671 *zOut++ = '"';
217673 if( *zIn=='"' ) *zOut++ = '"';
217674 *zOut++ = *(zIn++);
217676 *zOut++ = '"';
217677 p->nBuf = (int)((u8 *)zOut - p->aBuf);
224404 char *zOut; /* Output value */
224408 ** Append text to the HighlightContext output string - p->zOut. Argument
224423 p->zOut = sqlite3_mprintf("%z%.*s", p->zOut, n, z);
224424 if( p->zOut==0 ) *pRc = SQLITE_NOMEM;
224519 sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
224521 sqlite3_free(ctx.zOut);
224800 sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
224804 sqlite3_free(ctx.zOut);
225833 char *zOut = sqlite3_malloc64(nIn+1);
225839 if( zOut==0 ){
225842 memcpy(zOut, zIn, (size_t)(nIn+1));
225843 if( fts5_isopenquote(zOut[0]) ){
225844 int ii = fts5Dequote(zOut);
225850 zOut[zRet-zIn] = '\0';
225856 sqlite3_free(zOut);
225858 *pzOut = zOut;
241134 #define WRITE_UTF8(zOut, c) { \
241136 *zOut++ = (unsigned char)(c&0xFF); \
241139 *zOut++ = 0xC0 + (unsigned char)((c>>6)&0x1F); \
241140 *zOut++ = 0x80 + (unsigned char)(c & 0x3F); \
241143 *zOut++ = 0xE0 + (unsigned char)((c>>12)&0x0F); \
241144 *zOut++ = 0x80 + (unsigned char)((c>>6) & 0x3F); \
241145 *zOut++ = 0x80 + (unsigned char)(c & 0x3F); \
241147 *zOut++ = 0xF0 + (unsigned char)((c>>18) & 0x07); \
241148 *zOut++ = 0x80 + (unsigned char)((c>>12) & 0x3F); \
241149 *zOut++ = 0x80 + (unsigned char)((c>>6) & 0x3F); \
241150 *zOut++ = 0x80 + (unsigned char)(c & 0x3F); \
241387 char *zOut = aFold;
241417 if( zOut>pEnd ){
241423 zOut = &aFold[zOut - p->aFold];
241438 if( iCode ) WRITE_UTF8(zOut, iCode);
241448 *zOut++ = *zCsr + 32;
241450 *zOut++ = *zCsr;
241458 rc = xToken(pCtx, 0, aFold, zOut-aFold, is, ie);
242257 char *zOut = aBuf;
242266 WRITE_UTF8(zOut, iCode);
242274 WRITE_UTF8(zOut, iCode);
242278 WRITE_UTF8(zOut, iCode);
242282 rc = xToken(pCtx, 0, aBuf, zOut-aBuf, iStart, iStart + zOut-aBuf);