Lines Matching defs:pVfs
15468 sqlite3_vfs *pVfs, /* VFS to use with this b-tree */
17011 sqlite3_vfs *pVfs; /* OS Interface */
25079 sqlite3_vfs *pVfs,
25092 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut);
25096 SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
25099 return pVfs->xDelete!=0 ? pVfs->xDelete(pVfs, zPath, dirSync) : SQLITE_OK;
25102 sqlite3_vfs *pVfs,
25108 return pVfs->xAccess(pVfs, zPath, flags, pResOut);
25111 sqlite3_vfs *pVfs,
25118 return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
25121 SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
25124 return pVfs->xDlOpen(pVfs, zPath);
25126 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
25127 pVfs->xDlError(pVfs, nByte, zBufOut);
25129 SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){
25130 return pVfs->xDlSym(pVfs, pHdle, zSym);
25132 SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
25133 pVfs->xDlClose(pVfs, pHandle);
25136 SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
25143 return pVfs->xRandomness(pVfs, nByte, zBufOut);
25147 SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
25148 return pVfs->xSleep(pVfs, nMicro);
25150 SQLITE_PRIVATE int sqlite3OsGetLastError(sqlite3_vfs *pVfs){
25151 return pVfs->xGetLastError ? pVfs->xGetLastError(pVfs, 0, 0) : 0;
25153 SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
25161 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
25162 rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut);
25165 rc = pVfs->xCurrentTime(pVfs, &r);
25172 sqlite3_vfs *pVfs,
25180 pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
25182 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
25226 sqlite3_vfs *pVfs = 0;
25238 for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
25240 if( strcmp(zVfs, pVfs->zName)==0 ) break;
25243 return pVfs;
25249 static void vfsUnlink(sqlite3_vfs *pVfs){
25251 if( pVfs==0 ){
25253 }else if( vfsList==pVfs ){
25254 vfsList = pVfs->pNext;
25257 while( p->pNext && p->pNext!=pVfs ){
25260 if( p->pNext==pVfs ){
25261 p->pNext = pVfs->pNext;
25271 SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
25278 if( pVfs==0 ) return SQLITE_MISUSE_BKPT;
25283 vfsUnlink(pVfs);
25285 pVfs->pNext = vfsList;
25286 vfsList = pVfs;
25288 pVfs->pNext = vfsList->pNext;
25289 vfsList->pNext = pVfs;
25299 SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
25307 vfsUnlink(pVfs);
32722 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
32727 if( NEVER(pVfs==0) ){
32730 sqlite3OsRandomness(pVfs, 44, (char*)&wsdPrng.s[4]);
33745 db->iSysErrno = sqlite3OsGetLastError(db->pVfs);
36644 static int kvvfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
36690 sqlite3_vfs *pVfs,
36710 static void *kvvfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
36718 static int kvvfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
36727 static int kvvfsSleep(sqlite3_vfs *pVfs, int nMicro){
36734 static int kvvfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
36742 static int kvvfsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
36991 sqlite3_vfs *pVfs; /* The VFS that created this unixFile */
40897 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
40901 char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname );
40903 unixGetTempname(pFile->pVfs->mxPathname, zTFile);
42536 sqlite3_vfs *pVfs, /* Pointer to vfs object */
42553 pNew->pVfs = pVfs;
42563 if( strcmp(pVfs->zName,"unix-excl")==0 ){
42578 pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
42753 ** pVfs->mxPathname bytes.
42984 sqlite3_vfs *pVfs, /* The VFS for which this is the xOpen method */
43089 rc = unixGetTempname(pVfs->mxPathname, zTmpname);
43219 if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){
43231 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
43251 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
43430 sqlite3_vfs *pVfs, /* Pointer to vfs object */
43444 assert( pVfs->mxPathname==MAX_PATHNAME );
43445 UNUSED_PARAMETER(pVfs);
45338 sqlite3_vfs *pVfs; /* The VFS used to open this file */
47760 winVfsAppData *pAppData = (winVfsAppData*)pFile->pVfs->pAppData;
48639 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
48677 int rc = winGetTempname(pFile->pVfs, &zTFile);
48914 static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){
48943 winDelete(pVfs, p->zFilename, 0);
49053 rc = winOpen(pDbFd->pVfs, pShmNode->zFilename,
49092 winShmPurge(pDbFd->pVfs, 0); /* This call frees pShmNode if required */
49134 winShmPurge(pDbFd->pVfs, deleteFlag);
49817 static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){
49836 nMax = pVfs->mxPathname; nBuf = nMax + 2;
50077 sqlite3_vfs *pVfs, /* Not used on win32 */
50087 sqlite3_vfs *pVfs, /* Used to get maximum path length and AppData */
50177 rc = winGetTempname(pVfs, &zTmpname);
50273 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
50290 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
50310 rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO);
50326 return winOpen(pVfs, zName, id,
50349 pAppData = (winVfsAppData*)pVfs->pAppData;
50374 pFile->pVfs = pVfs;
50410 sqlite3_vfs *pVfs, /* Not used on win32 */
50419 UNUSED_PARAMETER(pVfs);
50518 sqlite3_vfs *pVfs, /* Not used on win32 */
50527 UNUSED_PARAMETER(pVfs);
50651 ** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
50655 sqlite3_vfs *pVfs, /* Pointer to vfs object */
50677 assert( nFull>=pVfs->mxPathname );
50685 char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 );
50691 CCP_RELATIVE, zRelative, zOut, pVfs->mxPathname+1)<0 ){
50701 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
50707 char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 );
50713 zRelative, zOut, pVfs->mxPathname+1)<0 ){
50723 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zUtf8);
50742 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
50745 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zRelative);
50764 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
50825 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut);
50834 sqlite3_vfs *pVfs, /* Pointer to vfs object */
50843 rc = winFullPathnameNoMutex(pVfs, zRelative, nFull, zFull);
50853 static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
50856 int nFull = pVfs->mxPathname+1;
50863 if( winFullPathname(pVfs, zFilename, nFull, zFull)!=SQLITE_OK ){
50872 UNUSED_PARAMETER(pVfs);
50894 static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
50895 UNUSED_PARAMETER(pVfs);
50898 static void (*winDlSym(sqlite3_vfs *pVfs,void *pH,const char *zSym))(void){
50900 UNUSED_PARAMETER(pVfs);
50906 static void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
50907 UNUSED_PARAMETER(pVfs);
50943 static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
50945 UNUSED_PARAMETER(pVfs);
50950 UNUSED_PARAMETER(pVfs);
51000 static int winSleep(sqlite3_vfs *pVfs, int microsec){
51002 UNUSED_PARAMETER(pVfs);
51025 static int winCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){
51059 UNUSED_PARAMETER(pVfs);
51068 static int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){
51071 rc = winCurrentTimeInt64(pVfs, &i);
51099 ** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
51108 static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
51110 UNUSED_PARAMETER(pVfs);
51400 static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void);
51814 sqlite3_vfs *pVfs,
51823 UNUSED_PARAMETER(pVfs);
51899 static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
51911 sqlite3_vfs *pVfs,
51916 UNUSED_PARAMETER(pVfs);
51929 sqlite3_vfs *pVfs,
51934 UNUSED_PARAMETER(pVfs);
51942 static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){
51943 return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
51951 static void memdbDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
51952 ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg);
51958 static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
51959 return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym);
51965 static void memdbDlClose(sqlite3_vfs *pVfs, void *pHandle){
51966 ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle);
51973 static int memdbRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
51974 return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut);
51981 static int memdbSleep(sqlite3_vfs *pVfs, int nMicro){
51982 return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro);
51989 static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
51990 return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut);
51994 static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){
51995 return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b);
51997 static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){
51998 return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p);
56115 sqlite3_vfs *pVfs; /* OS functions to use for IO */
57587 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync);
58048 sqlite3_vfs *pVfs = pPager->pVfs;
58062 pSuper = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2);
58068 rc = sqlite3OsOpen(pVfs, zSuper, pSuper, flags, 0);
58069 pJournal = (sqlite3_file *)(((u8 *)pSuper) + pVfs->szOsFile);
58080 nSuperPtr = pVfs->mxPathname+1;
58097 rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
58111 rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
58132 rc = sqlite3OsDelete(pVfs, zSuper, 0);
58310 sqlite3_vfs *pVfs = pPager->pVfs;
58338 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
58343 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
58345 rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res);
58482 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
58857 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
58866 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
59196 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
60032 rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill);
60244 sqlite3_vfs *pVfs, /* The virtual file system to use */
60275 journalFileSize = ROUND8(sqlite3JournalSize(pVfs));
60298 nPathname = pVfs->mxPathname+1;
60304 rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
60323 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
60325 ** the database being opened will be more than pVfs->mxPathname
60344 ** Database file handle (pVfs->szOsFile bytes)
60385 ROUND8(pVfs->szOsFile) + /* The main db file */
60404 pPager->fd = (sqlite3_file*)pPtr; pPtr += ROUND8(pVfs->szOsFile);
60453 pPager->pVfs = pVfs;
60460 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
60657 sqlite3_vfs * const pVfs = pPager->pVfs;
60672 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
60703 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
60716 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
60849 sqlite3_vfs * const pVfs = pPager->pVfs;
60852 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
60857 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
61340 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
61379 pVfs, pPager->zJournal, pPager->jfd, flags, nSpill
62597 return pPager->pVfs;
62955 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
62968 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
63136 rc = sqlite3WalOpen(pPager->pVfs,
63215 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
63868 sqlite3_vfs *pVfs; /* The VFS used to create pDbFd */
64835 sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */
64896 pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile);
64901 pRet->pVfs = pVfs;
64913 rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
65657 sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);
66116 sqlite3OsSleep(pWal->pVfs, nDelay);
67342 sqlite3OsCurrentTimeInt64(db->pVfs, &g_lastCkptTime);
68537 if( db->pVfs==0 && db->nDb==0 ) return 1;
71071 sqlite3_vfs *pVfs, /* VFS to use for this b-tree */
71100 assert( pVfs!=0 );
71135 int nFullPathname = pVfs->mxPathname+1;
71147 rc = sqlite3OsFullPathname(pVfs, zFilename,
71168 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
71217 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
85406 sqlite3_vfs *pVfs = db->pVfs;
85425 sqlite3OsDelete(pVfs, zSuper, 0);
85439 rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res);
85443 rc = sqlite3OsOpenMalloc(pVfs, zSuper, &pSuperJrnl,
85471 sqlite3OsDelete(pVfs, zSuper, 0);
85485 sqlite3OsDelete(pVfs, zSuper, 0);
85517 rc = sqlite3OsDelete(pVfs, zSuper, 1);
87930 sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
88546 sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
88863 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
94734 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->ub.pBtx,
100849 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
100854 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
100855 if( ALWAYS(pVfs) ) sqlite3OsCurrentTimeInt64(pVfs, &t);
100864 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
100874 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
101088 rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd,
103050 sqlite3_vfs *pVfs; /* The "real" underlying VFS */
103123 rc = sqlite3OsOpen(copy.pVfs, copy.zJournal, pReal, copy.flags, 0);
103326 sqlite3_vfs *pVfs, /* The VFS to use for actual file I/O */
103342 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
103356 p->pVfs = pVfs;
103408 ** pVfs to create the underlying on-disk files.
103410 SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *pVfs){
103411 return MAX(pVfs->szOsFile, (int)sizeof(MemJournal));
116636 sqlite3_vfs *pVfs;
116654 pVfs = sqlite3_vfs_find("memdb");
116655 if( pVfs==0 ) return;
116660 rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
116704 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
116711 assert( pVfs );
116713 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
122674 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
133175 sqlite3_vfs *pVfs = db->pVfs;
133222 handle = sqlite3OsDlOpen(pVfs, zFile);
133227 handle = sqlite3OsDlOpen(pVfs, zAltFile);
133232 xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
133250 sqlite3OsDlClose(pVfs, handle);
133264 xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
133274 sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
133277 sqlite3OsDlClose(pVfs, handle);
133289 sqlite3OsDlClose(pVfs, handle);
133315 sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
133342 sqlite3OsDlClose(db->pVfs, db->aExtension[i]);
135228 rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
135275 rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
175115 sqlite3OsSleep(db->pVfs, delay*1000);
175125 sqlite3OsSleep(db->pVfs, 1000000);
176855 rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
176863 assert( db->pVfs!=0 );
176865 if( sqlite3_stricmp(db->pVfs->zName, "kvvfs")==0 ){
176871 rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
177363 sqlite3_vfs *pVfs;
177365 pVfs = sqlite3_vfs_find(0);
177366 if( pVfs==0 ) return 0;
177371 rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
212642 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
212643 assert( pVfs && p->rc==SQLITE_OK && p->zErrmsg==0 );
212644 pVfs->xDelete(pVfs, zOal, 0);
212664 sqlite3_vfs *pVfs = sqlite3_vfs_find(zRnd);
212665 assert( pVfs );
212666 p->zVfsName = pVfs->zName;
212667 ((rbu_vfs*)pVfs)->pRbu = p;
213834 sqlite3_vfs *pVfs,
213860 rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
213931 static int rbuVfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
213932 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
213941 sqlite3_vfs *pVfs,
213946 rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
213989 sqlite3_vfs *pVfs,
213994 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
214002 static void *rbuVfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
214003 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
214012 static void rbuVfsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
214013 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
214021 sqlite3_vfs *pVfs,
214025 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
214032 static void rbuVfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
214033 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
214042 static int rbuVfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
214043 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
214051 static int rbuVfsSleep(sqlite3_vfs *pVfs, int nMicro){
214052 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
214059 static int rbuVfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
214060 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
214067 static int rbuVfsGetLastError(sqlite3_vfs *pVfs, int a, char *b){
214076 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
214077 if( pVfs && pVfs->xOpen==rbuVfsOpen ){
214078 sqlite3_mutex_free(((rbu_vfs*)pVfs)->mutex);
214079 sqlite3_vfs_unregister(pVfs);
214080 sqlite3_free(pVfs);