[sqlite] Remove obsolete reference version 3.8.7.4.

third_party/sqlite/sqlite-src-3080704/src/test_onefile.c

Index: third_party/sqlite/sqlite-src-3080704/src/test_onefile.c
diff --git a/third_party/sqlite/sqlite-src-3080704/src/test_onefile.c b/third_party/sqlite/sqlite-src-3080704/src/test_onefile.c
deleted file mode 100644
index 69867441b8cc9a621af32413fc63da80993764f4..0000000000000000000000000000000000000000
--- a/third_party/sqlite/sqlite-src-3080704/src/test_onefile.c
+++ /dev/null
@@ -1,830 +0,0 @@
-/*
-** 2007 September 14
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-**
-** OVERVIEW:
-**
-**   This file contains some example code demonstrating how the SQLite 
-**   vfs feature can be used to have SQLite operate directly on an 
-**   embedded media, without using an intermediate file system.
-**
-**   Because this is only a demo designed to run on a workstation, the
-**   underlying media is simulated using a regular file-system file. The
-**   size of the file is fixed when it is first created (default size 10 MB).
-**   From SQLite's point of view, this space is used to store a single
-**   database file and the journal file. 
-**
-**   Any statement journal created is stored in volatile memory obtained 
-**   from sqlite3_malloc(). Any attempt to create a temporary database file 
-**   will fail (SQLITE_IOERR). To prevent SQLite from attempting this,
-**   it should be configured to store all temporary database files in 
-**   main memory (see pragma "temp_store" or the SQLITE_TEMP_STORE compile 
-**   time option).
-**
-** ASSUMPTIONS:
-**
-**   After it has been created, the blob file is accessed using the
-**   following three functions only:
-**
-**       mediaRead();            - Read a 512 byte block from the file.
-**       mediaWrite();           - Write a 512 byte block to the file.
-**       mediaSync();            - Tell the media hardware to sync.
-**
-**   It is assumed that these can be easily implemented by any "real"
-**   media vfs driver adapting this code.
-**
-** FILE FORMAT:
-**
-**   The basic principle is that the "database file" is stored at the
-**   beginning of the 10 MB blob and grows in a forward direction. The 
-**   "journal file" is stored at the end of the 10MB blob and grows
-**   in the reverse direction. If, during a transaction, insufficient
-**   space is available to expand either the journal or database file,
-**   an SQLITE_FULL error is returned. The database file is never allowed
-**   to consume more than 90% of the blob space. If SQLite tries to
-**   create a file larger than this, SQLITE_FULL is returned.
-**
-**   No allowance is made for "wear-leveling", as is required by.
-**   embedded devices in the absence of equivalent hardware features.
-**
-**   The first 512 block byte of the file is reserved for storing the
-**   size of the "database file". It is updated as part of the sync()
-**   operation. On startup, it can only be trusted if no journal file
-**   exists. If a journal-file does exist, then it stores the real size
-**   of the database region. The second and subsequent blocks store the 
-**   actual database content.
-**
-**   The size of the "journal file" is not stored persistently in the 
-**   file. When the system is running, the size of the journal file is
-**   stored in volatile memory. When recovering from a crash, this vfs
-**   reports a very large size for the journal file. The normal journal
-**   header and checksum mechanisms serve to prevent SQLite from 
-**   processing any data that lies past the logical end of the journal.
-**
-**   When SQLite calls OsDelete() to delete the journal file, the final
-**   512 bytes of the blob (the area containing the first journal header)
-**   are zeroed.
-**
-** LOCKING:
-**
-**   File locking is a no-op. Only one connection may be open at any one
-**   time using this demo vfs.
-*/
-
-#include "sqlite3.h"
-#include <assert.h>
-#include <string.h>
-
-/*
-** Maximum pathname length supported by the fs backend.
-*/
-#define BLOCKSIZE 512
-#define BLOBSIZE 10485760
-
-/*
-** Name used to identify this VFS.
-*/
-#define FS_VFS_NAME "fs"
-
-typedef struct fs_real_file fs_real_file;
-struct fs_real_file {
-  sqlite3_file *pFile;
-  const char *zName;
-  int nDatabase;              /* Current size of database region */
-  int nJournal;               /* Current size of journal region */
-  int nBlob;                  /* Total size of allocated blob */
-  int nRef;                   /* Number of pointers to this structure */
-  fs_real_file *pNext;
-  fs_real_file **ppThis;
-};
-
-typedef struct fs_file fs_file;
-struct fs_file {
-  sqlite3_file base;
-  int eType;
-  fs_real_file *pReal;
-};
-
-typedef struct tmp_file tmp_file;
-struct tmp_file {
-  sqlite3_file base;
-  int nSize;
-  int nAlloc;
-  char *zAlloc;
-};
-
-/* Values for fs_file.eType. */
-#define DATABASE_FILE   1
-#define JOURNAL_FILE    2
-
-/*
-** Method declarations for fs_file.
-*/
-static int fsClose(sqlite3_file*);
-static int fsRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
-static int fsWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
-static int fsTruncate(sqlite3_file*, sqlite3_int64 size);
-static int fsSync(sqlite3_file*, int flags);
-static int fsFileSize(sqlite3_file*, sqlite3_int64 *pSize);
-static int fsLock(sqlite3_file*, int);
-static int fsUnlock(sqlite3_file*, int);
-static int fsCheckReservedLock(sqlite3_file*, int *pResOut);
-static int fsFileControl(sqlite3_file*, int op, void *pArg);
-static int fsSectorSize(sqlite3_file*);
-static int fsDeviceCharacteristics(sqlite3_file*);
-
-/*
-** Method declarations for tmp_file.
-*/
-static int tmpClose(sqlite3_file*);
-static int tmpRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
-static int tmpWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
-static int tmpTruncate(sqlite3_file*, sqlite3_int64 size);
-static int tmpSync(sqlite3_file*, int flags);
-static int tmpFileSize(sqlite3_file*, sqlite3_int64 *pSize);
-static int tmpLock(sqlite3_file*, int);
-static int tmpUnlock(sqlite3_file*, int);
-static int tmpCheckReservedLock(sqlite3_file*, int *pResOut);
-static int tmpFileControl(sqlite3_file*, int op, void *pArg);
-static int tmpSectorSize(sqlite3_file*);
-static int tmpDeviceCharacteristics(sqlite3_file*);
-
-/*
-** Method declarations for fs_vfs.
-*/
-static int fsOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
-static int fsDelete(sqlite3_vfs*, const char *zName, int syncDir);
-static int fsAccess(sqlite3_vfs*, const char *zName, int flags, int *);
-static int fsFullPathname(sqlite3_vfs*, const char *zName, int nOut,char *zOut);
-static void *fsDlOpen(sqlite3_vfs*, const char *zFilename);
-static void fsDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
-static void (*fsDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);
-static void fsDlClose(sqlite3_vfs*, void*);
-static int fsRandomness(sqlite3_vfs*, int nByte, char *zOut);
-static int fsSleep(sqlite3_vfs*, int microseconds);
-static int fsCurrentTime(sqlite3_vfs*, double*);
-
-
-typedef struct fs_vfs_t fs_vfs_t;
-struct fs_vfs_t {
-  sqlite3_vfs base;
-  fs_real_file *pFileList;
-  sqlite3_vfs *pParent;
-};
-
-static fs_vfs_t fs_vfs = {
-  {
-    1,                                          /* iVersion */
-    0,                                          /* szOsFile */
-    0,                                          /* mxPathname */
-    0,                                          /* pNext */
-    FS_VFS_NAME,                                /* zName */
-    0,                                          /* pAppData */
-    fsOpen,                                     /* xOpen */
-    fsDelete,                                   /* xDelete */
-    fsAccess,                                   /* xAccess */
-    fsFullPathname,                             /* xFullPathname */
-    fsDlOpen,                                   /* xDlOpen */
-    fsDlError,                                  /* xDlError */
-    fsDlSym,                                    /* xDlSym */
-    fsDlClose,                                  /* xDlClose */
-    fsRandomness,                               /* xRandomness */
-    fsSleep,                                    /* xSleep */
-    fsCurrentTime,                              /* xCurrentTime */
-    0                                           /* xCurrentTimeInt64 */
-  }, 
-  0,                                            /* pFileList */
-  0                                             /* pParent */
-};
-
-static sqlite3_io_methods fs_io_methods = {
-  1,                            /* iVersion */
-  fsClose,                      /* xClose */
-  fsRead,                       /* xRead */
-  fsWrite,                      /* xWrite */
-  fsTruncate,                   /* xTruncate */
-  fsSync,                       /* xSync */
-  fsFileSize,                   /* xFileSize */
-  fsLock,                       /* xLock */
-  fsUnlock,                     /* xUnlock */
-  fsCheckReservedLock,          /* xCheckReservedLock */
-  fsFileControl,                /* xFileControl */
-  fsSectorSize,                 /* xSectorSize */
-  fsDeviceCharacteristics,      /* xDeviceCharacteristics */
-  0,                            /* xShmMap */
-  0,                            /* xShmLock */
-  0,                            /* xShmBarrier */
-  0                             /* xShmUnmap */
-};
-
-
-static sqlite3_io_methods tmp_io_methods = {
-  1,                            /* iVersion */
-  tmpClose,                     /* xClose */
-  tmpRead,                      /* xRead */
-  tmpWrite,                     /* xWrite */
-  tmpTruncate,                  /* xTruncate */
-  tmpSync,                      /* xSync */
-  tmpFileSize,                  /* xFileSize */
-  tmpLock,                      /* xLock */
-  tmpUnlock,                    /* xUnlock */
-  tmpCheckReservedLock,         /* xCheckReservedLock */
-  tmpFileControl,               /* xFileControl */
-  tmpSectorSize,                /* xSectorSize */
-  tmpDeviceCharacteristics,     /* xDeviceCharacteristics */
-  0,                            /* xShmMap */
-  0,                            /* xShmLock */
-  0,                            /* xShmBarrier */
-  0                             /* xShmUnmap */
-};
-
-/* Useful macros used in several places */
-#define MIN(x,y) ((x)<(y)?(x):(y))
-#define MAX(x,y) ((x)>(y)?(x):(y))
-
-
-/*
-** Close a tmp-file.
-*/
-static int tmpClose(sqlite3_file *pFile){
-  tmp_file *pTmp = (tmp_file *)pFile;
-  sqlite3_free(pTmp->zAlloc);
-  return SQLITE_OK;
-}
-
-/*
-** Read data from a tmp-file.
-*/
-static int tmpRead(
-  sqlite3_file *pFile, 
-  void *zBuf, 
-  int iAmt, 
-  sqlite_int64 iOfst
-){
-  tmp_file *pTmp = (tmp_file *)pFile;
-  if( (iAmt+iOfst)>pTmp->nSize ){
-    return SQLITE_IOERR_SHORT_READ;
-  }
-  memcpy(zBuf, &pTmp->zAlloc[iOfst], iAmt);
-  return SQLITE_OK;
-}
-
-/*
-** Write data to a tmp-file.
-*/
-static int tmpWrite(
-  sqlite3_file *pFile, 
-  const void *zBuf, 
-  int iAmt, 
-  sqlite_int64 iOfst
-){
-  tmp_file *pTmp = (tmp_file *)pFile;
-  if( (iAmt+iOfst)>pTmp->nAlloc ){
-    int nNew = (int)(2*(iAmt+iOfst+pTmp->nAlloc));
-    char *zNew = sqlite3_realloc(pTmp->zAlloc, nNew);
-    if( !zNew ){
-      return SQLITE_NOMEM;
-    }
-    pTmp->zAlloc = zNew;
-    pTmp->nAlloc = nNew;
-  }
-  memcpy(&pTmp->zAlloc[iOfst], zBuf, iAmt);
-  pTmp->nSize = (int)MAX(pTmp->nSize, iOfst+iAmt);
-  return SQLITE_OK;
-}
-
-/*
-** Truncate a tmp-file.
-*/
-static int tmpTruncate(sqlite3_file *pFile, sqlite_int64 size){
-  tmp_file *pTmp = (tmp_file *)pFile;
-  pTmp->nSize = (int)MIN(pTmp->nSize, size);
-  return SQLITE_OK;
-}
-
-/*
-** Sync a tmp-file.
-*/
-static int tmpSync(sqlite3_file *pFile, int flags){
-  return SQLITE_OK;
-}
-
-/*
-** Return the current file-size of a tmp-file.
-*/
-static int tmpFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
-  tmp_file *pTmp = (tmp_file *)pFile;
-  *pSize = pTmp->nSize;
-  return SQLITE_OK;
-}
-
-/*
-** Lock a tmp-file.
-*/
-static int tmpLock(sqlite3_file *pFile, int eLock){
-  return SQLITE_OK;
-}
-
-/*
-** Unlock a tmp-file.
-*/
-static int tmpUnlock(sqlite3_file *pFile, int eLock){
-  return SQLITE_OK;
-}
-
-/*
-** Check if another file-handle holds a RESERVED lock on a tmp-file.
-*/
-static int tmpCheckReservedLock(sqlite3_file *pFile, int *pResOut){
-  *pResOut = 0;
-  return SQLITE_OK;
-}
-
-/*
-** File control method. For custom operations on a tmp-file.
-*/
-static int tmpFileControl(sqlite3_file *pFile, int op, void *pArg){
-  return SQLITE_OK;
-}
-
-/*
-** Return the sector-size in bytes for a tmp-file.
-*/
-static int tmpSectorSize(sqlite3_file *pFile){
-  return 0;
-}
-
-/*
-** Return the device characteristic flags supported by a tmp-file.
-*/
-static int tmpDeviceCharacteristics(sqlite3_file *pFile){
-  return 0;
-}
-
-/*
-** Close an fs-file.
-*/
-static int fsClose(sqlite3_file *pFile){
-  int rc = SQLITE_OK;
-  fs_file *p = (fs_file *)pFile;
-  fs_real_file *pReal = p->pReal;
-
-  /* Decrement the real_file ref-count. */
-  pReal->nRef--;
-  assert(pReal->nRef>=0);
-
-  /* When the ref-count reaches 0, destroy the structure */
-  if( pReal->nRef==0 ){
-    *pReal->ppThis = pReal->pNext;
-    if( pReal->pNext ){
-      pReal->pNext->ppThis = pReal->ppThis;
-    }
-    rc = pReal->pFile->pMethods->xClose(pReal->pFile);
-    sqlite3_free(pReal);
-  }
-
-  return rc;
-}
-
-/*
-** Read data from an fs-file.
-*/
-static int fsRead(
-  sqlite3_file *pFile, 
-  void *zBuf, 
-  int iAmt, 
-  sqlite_int64 iOfst
-){
-  int rc = SQLITE_OK;
-  fs_file *p = (fs_file *)pFile;
-  fs_real_file *pReal = p->pReal;
-  sqlite3_file *pF = pReal->pFile;
-
-  if( (p->eType==DATABASE_FILE && (iAmt+iOfst)>pReal->nDatabase)
-   || (p->eType==JOURNAL_FILE && (iAmt+iOfst)>pReal->nJournal)
-  ){
-    rc = SQLITE_IOERR_SHORT_READ;
-  }else if( p->eType==DATABASE_FILE ){
-    rc = pF->pMethods->xRead(pF, zBuf, iAmt, iOfst+BLOCKSIZE);
-  }else{
-    /* Journal file. */
-    int iRem = iAmt;
-    int iBuf = 0;
-    int ii = (int)iOfst;
-    while( iRem>0 && rc==SQLITE_OK ){
-      int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE;
-      int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE));
-
-      rc = pF->pMethods->xRead(pF, &((char *)zBuf)[iBuf], iRealAmt, iRealOff);
-      ii += iRealAmt;
-      iBuf += iRealAmt;
-      iRem -= iRealAmt;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Write data to an fs-file.
-*/
-static int fsWrite(
-  sqlite3_file *pFile, 
-  const void *zBuf, 
-  int iAmt, 
-  sqlite_int64 iOfst
-){
-  int rc = SQLITE_OK;
-  fs_file *p = (fs_file *)pFile;
-  fs_real_file *pReal = p->pReal;
-  sqlite3_file *pF = pReal->pFile;
-
-  if( p->eType==DATABASE_FILE ){
-    if( (iAmt+iOfst+BLOCKSIZE)>(pReal->nBlob-pReal->nJournal) ){
-      rc = SQLITE_FULL;
-    }else{
-      rc = pF->pMethods->xWrite(pF, zBuf, iAmt, iOfst+BLOCKSIZE);
-      if( rc==SQLITE_OK ){
-        pReal->nDatabase = (int)MAX(pReal->nDatabase, iAmt+iOfst);
-      }
-    }
-  }else{
-    /* Journal file. */
-    int iRem = iAmt;
-    int iBuf = 0;
-    int ii = (int)iOfst;
-    while( iRem>0 && rc==SQLITE_OK ){
-      int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE;
-      int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE));
-
-      if( iRealOff<(pReal->nDatabase+BLOCKSIZE) ){
-        rc = SQLITE_FULL;
-      }else{
-        rc = pF->pMethods->xWrite(pF, &((char *)zBuf)[iBuf], iRealAmt,iRealOff);
-        ii += iRealAmt;
-        iBuf += iRealAmt;
-        iRem -= iRealAmt;
-      }
-    }
-    if( rc==SQLITE_OK ){
-      pReal->nJournal = (int)MAX(pReal->nJournal, iAmt+iOfst);
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Truncate an fs-file.
-*/
-static int fsTruncate(sqlite3_file *pFile, sqlite_int64 size){
-  fs_file *p = (fs_file *)pFile;
-  fs_real_file *pReal = p->pReal;
-  if( p->eType==DATABASE_FILE ){
-    pReal->nDatabase = (int)MIN(pReal->nDatabase, size);
-  }else{
-    pReal->nJournal = (int)MIN(pReal->nJournal, size);
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Sync an fs-file.
-*/
-static int fsSync(sqlite3_file *pFile, int flags){
-  fs_file *p = (fs_file *)pFile;
-  fs_real_file *pReal = p->pReal;
-  sqlite3_file *pRealFile = pReal->pFile;
-  int rc = SQLITE_OK;
-
-  if( p->eType==DATABASE_FILE ){
-    unsigned char zSize[4];
-    zSize[0] = (pReal->nDatabase&0xFF000000)>>24;
-    zSize[1] = (pReal->nDatabase&0x00FF0000)>>16;
-    zSize[2] = (pReal->nDatabase&0x0000FF00)>>8;
-    zSize[3] = (pReal->nDatabase&0x000000FF);
-    rc = pRealFile->pMethods->xWrite(pRealFile, zSize, 4, 0);
-  }
-  if( rc==SQLITE_OK ){
-    rc = pRealFile->pMethods->xSync(pRealFile, flags&(~SQLITE_SYNC_DATAONLY));
-  }
-
-  return rc;
-}
-
-/*
-** Return the current file-size of an fs-file.
-*/
-static int fsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
-  fs_file *p = (fs_file *)pFile;
-  fs_real_file *pReal = p->pReal;
-  if( p->eType==DATABASE_FILE ){
-    *pSize = pReal->nDatabase;
-  }else{
-    *pSize = pReal->nJournal;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Lock an fs-file.
-*/
-static int fsLock(sqlite3_file *pFile, int eLock){
-  return SQLITE_OK;
-}
-
-/*
-** Unlock an fs-file.
-*/
-static int fsUnlock(sqlite3_file *pFile, int eLock){
-  return SQLITE_OK;
-}
-
-/*
-** Check if another file-handle holds a RESERVED lock on an fs-file.
-*/
-static int fsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
-  *pResOut = 0;
-  return SQLITE_OK;
-}
-
-/*
-** File control method. For custom operations on an fs-file.
-*/
-static int fsFileControl(sqlite3_file *pFile, int op, void *pArg){
-  return SQLITE_OK;
-}
-
-/*
-** Return the sector-size in bytes for an fs-file.
-*/
-static int fsSectorSize(sqlite3_file *pFile){
-  return BLOCKSIZE;
-}
-
-/*
-** Return the device characteristic flags supported by an fs-file.
-*/
-static int fsDeviceCharacteristics(sqlite3_file *pFile){
-  return 0;
-}
-
-/*
-** Open an fs file handle.
-*/
-static int fsOpen(
-  sqlite3_vfs *pVfs,
-  const char *zName,
-  sqlite3_file *pFile,
-  int flags,
-  int *pOutFlags
-){
-  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
-  fs_file *p = (fs_file *)pFile;
-  fs_real_file *pReal = 0;
-  int eType;
-  int nName;
-  int rc = SQLITE_OK;
-
-  if( 0==(flags&(SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_MAIN_JOURNAL)) ){
-    tmp_file *p = (tmp_file *)pFile;
-    memset(p, 0, sizeof(*p));
-    p->base.pMethods = &tmp_io_methods;
-    return SQLITE_OK;
-  }
-
-  eType = ((flags&(SQLITE_OPEN_MAIN_DB))?DATABASE_FILE:JOURNAL_FILE);
-  p->base.pMethods = &fs_io_methods;
-  p->eType = eType;
-
-  assert(strlen("-journal")==8);
-  nName = (int)strlen(zName)-((eType==JOURNAL_FILE)?8:0);
-  pReal=pFsVfs->pFileList; 
-  for(; pReal && strncmp(pReal->zName, zName, nName); pReal=pReal->pNext);
-
-  if( !pReal ){
-    int real_flags = (flags&~(SQLITE_OPEN_MAIN_DB))|SQLITE_OPEN_TEMP_DB;
-    sqlite3_int64 size;
-    sqlite3_file *pRealFile;
-    sqlite3_vfs *pParent = pFsVfs->pParent;
-    assert(eType==DATABASE_FILE);
-
-    pReal = (fs_real_file *)sqlite3_malloc(sizeof(*pReal)+pParent->szOsFile);
-    if( !pReal ){
-      rc = SQLITE_NOMEM;
-      goto open_out;
-    }
-    memset(pReal, 0, sizeof(*pReal)+pParent->szOsFile);
-    pReal->zName = zName;
-    pReal->pFile = (sqlite3_file *)(&pReal[1]);
-
-    rc = pParent->xOpen(pParent, zName, pReal->pFile, real_flags, pOutFlags);
-    if( rc!=SQLITE_OK ){
-      goto open_out;
-    }
-    pRealFile = pReal->pFile;
-
-    rc = pRealFile->pMethods->xFileSize(pRealFile, &size);
-    if( rc!=SQLITE_OK ){
-      goto open_out;
-    }
-    if( size==0 ){
-      rc = pRealFile->pMethods->xWrite(pRealFile, "\0", 1, BLOBSIZE-1);
-      pReal->nBlob = BLOBSIZE;
-    }else{
-      unsigned char zS[4];
-      pReal->nBlob = (int)size;
-      rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, 0);
-      pReal->nDatabase = (zS[0]<<24)+(zS[1]<<16)+(zS[2]<<8)+zS[3];
-      if( rc==SQLITE_OK ){
-        rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, pReal->nBlob-4);
-        if( zS[0] || zS[1] || zS[2] || zS[3] ){
-          pReal->nJournal = pReal->nBlob;
-        }
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      pReal->pNext = pFsVfs->pFileList;
-      if( pReal->pNext ){
-        pReal->pNext->ppThis = &pReal->pNext;
-      }
-      pReal->ppThis = &pFsVfs->pFileList;
-      pFsVfs->pFileList = pReal;
-    }
-  }
-
-open_out:
-  if( pReal ){
-    if( rc==SQLITE_OK ){
-      p->pReal = pReal;
-      pReal->nRef++;
-    }else{
-      if( pReal->pFile->pMethods ){
-        pReal->pFile->pMethods->xClose(pReal->pFile);
-      }
-      sqlite3_free(pReal);
-    }
-  }
-  return rc;
-}
-
-/*
-** Delete the file located at zPath. If the dirSync argument is true,
-** ensure the file-system modifications are synced to disk before
-** returning.
-*/
-static int fsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
-  int rc = SQLITE_OK;
-  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
-  fs_real_file *pReal;
-  sqlite3_file *pF;
-  int nName = (int)strlen(zPath) - 8;
-
-  assert(strlen("-journal")==8);
-  assert(strcmp("-journal", &zPath[nName])==0);
-
-  pReal = pFsVfs->pFileList; 
-  for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext);
-  if( pReal ){
-    pF = pReal->pFile;
-    rc = pF->pMethods->xWrite(pF, "\0\0\0\0", 4, pReal->nBlob-BLOCKSIZE);
-    if( rc==SQLITE_OK ){
-      pReal->nJournal = 0;
-    }
-  }
-  return rc;
-}
-
-/*
-** Test for access permissions. Return true if the requested permission
-** is available, or false otherwise.
-*/
-static int fsAccess(
-  sqlite3_vfs *pVfs, 
-  const char *zPath, 
-  int flags, 
-  int *pResOut
-){
-  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
-  fs_real_file *pReal;
-  int isJournal = 0;
-  int nName = (int)strlen(zPath);
-
-  if( flags!=SQLITE_ACCESS_EXISTS ){
-    sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-    return pParent->xAccess(pParent, zPath, flags, pResOut);
-  }
-
-  assert(strlen("-journal")==8);
-  if( nName>8 && strcmp("-journal", &zPath[nName-8])==0 ){
-    nName -= 8;
-    isJournal = 1;
-  }
-
-  pReal = pFsVfs->pFileList; 
-  for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext);
-
-  *pResOut = (pReal && (!isJournal || pReal->nJournal>0));
-  return SQLITE_OK;
-}
-
-/*
-** Populate buffer zOut with the full canonical pathname corresponding
-** to the pathname in zPath. zOut is guaranteed to point to a buffer
-** of at least (FS_MAX_PATHNAME+1) bytes.
-*/
-static int fsFullPathname(
-  sqlite3_vfs *pVfs,            /* Pointer to vfs object */
-  const char *zPath,            /* Possibly relative input path */
-  int nOut,                     /* Size of output buffer in bytes */
-  char *zOut                    /* Output buffer */
-){
-  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-  return pParent->xFullPathname(pParent, zPath, nOut, zOut);
-}
-
-/*
-** Open the dynamic library located at zPath and return a handle.
-*/
-static void *fsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
-  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-  return pParent->xDlOpen(pParent, zPath);
-}
-
-/*
-** Populate the buffer zErrMsg (size nByte bytes) with a human readable
-** utf-8 string describing the most recent error encountered associated 
-** with dynamic libraries.
-*/
-static void fsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
-  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-  pParent->xDlError(pParent, nByte, zErrMsg);
-}
-
-/*
-** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
-*/
-static void (*fsDlSym(sqlite3_vfs *pVfs, void *pH, const char *zSym))(void){
-  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-  return pParent->xDlSym(pParent, pH, zSym);
-}
-
-/*
-** Close the dynamic library handle pHandle.
-*/
-static void fsDlClose(sqlite3_vfs *pVfs, void *pHandle){
-  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-  pParent->xDlClose(pParent, pHandle);
-}
-
-/*
-** Populate the buffer pointed to by zBufOut with nByte bytes of 
-** random data.
-*/
-static int fsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
-  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-  return pParent->xRandomness(pParent, nByte, zBufOut);
-}
-
-/*
-** Sleep for nMicro microseconds. Return the number of microseconds 
-** actually slept.
-*/
-static int fsSleep(sqlite3_vfs *pVfs, int nMicro){
-  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-  return pParent->xSleep(pParent, nMicro);
-}
-
-/*
-** Return the current time as a Julian Day number in *pTimeOut.
-*/
-static int fsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
-  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
-  return pParent->xCurrentTime(pParent, pTimeOut);
-}
-
-/*
-** This procedure registers the fs vfs with SQLite. If the argument is
-** true, the fs vfs becomes the new default vfs. It is the only publicly
-** available function in this file.
-*/
-int fs_register(void){
-  if( fs_vfs.pParent ) return SQLITE_OK;
-  fs_vfs.pParent = sqlite3_vfs_find(0);
-  fs_vfs.base.mxPathname = fs_vfs.pParent->mxPathname;
-  fs_vfs.base.szOsFile = MAX(sizeof(tmp_file), sizeof(fs_file));
-  return sqlite3_vfs_register(&fs_vfs.base, 0);
-}
-
-#ifdef SQLITE_TEST
-  int SqlitetestOnefile_Init() {return fs_register();}
-#endif