** Interpret zArg as an integer value, possibly with suffixes.

*/

static sqlite3_int64 integerValue(const char *zArg){

  sqlite3_int64 v = 0;

  static const struct { char *zSuffix; int iMult; } aMult[] = {

    { "KiB", 1024 },

    { "MiB", 1024*1024 },

    { "GiB", 1024*1024*1024 },

    { "KB",  1000 },

    { "MB",  1000000 },

    { "GB",  1000000000 },

    { "K",   1000 },

    { "M",   1000000 },

    { "G",   1000000000 },

  };

  int i;

  int isNeg = 0;

  if( zArg[0]=='-' ){

    isNeg = 1;

    zArg++;

  }else if( zArg[0]=='+' ){

    zArg++;

  }

  while( isdigit(zArg[0]) ){

    v = v*10 + zArg[0] - '0';

    zArg++;

  }

  for(i=0; i<sizeof(aMult)/sizeof(aMult[0]); i++){

    if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){

      v *= aMult[i].iMult;

      break;

    }

  }

  return isNeg? -v : v;

}

/*

          "ORDER BY rowid",

         "ORDER BY rowid",

          fprintf(p->out, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");

        fprintf(p->out, "\n");

            fprintf(p->out, "%d (0x%08x)\n", rc, rc);

            fprintf(p->out, "%d (0x%08x)\n", rc, rc);

            unsigned int opt = (unsigned int)integerValue(azArg[2]);        

            fprintf(p->out, "%d (0x%08x)\n", rc, rc);

            fprintf(p->out, "%d (0x%08x)\n", rc, rc);

            fprintf(p->out, "%d (0x%08x)\n", rc, rc);

    fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,

        fprintf(p->out, "%s\n", zVfsName);

    sqlite3WhereTrace = booleanValue(azArg[1]);

    }else if( zSql && _all_whitespace(zSql) ){

      free(zSql);

      zSql = 0;

      nSql = 0;

  "   -mmap N              default mmap size set to N\n"

      szHeap = integerValue(zSize);

    }else if( strcmp(z,"-mmap")==0 ){

      sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));

      sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);

    }else if( strcmp(z,"-mmap")==0 ){

      i++;

        if( rc && bail_on_error ) return rc==2 ? 0 : rc;

      if( rc==2 ) rc = 0;

** version 3.7.17.  By combining all the individual C code files into this 

# if defined(THREADSAFE)

#   define SQLITE_THREADSAFE THREADSAFE

# else

#   define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */

# endif

#define SQLITE_VERSION        "3.7.17"

#define SQLITE_VERSION_NUMBER 3007017

#define SQLITE_SOURCE_ID      "2013-05-20 00:56:22 118a3b35693b134d56ebd780123b7fd6f1497668"

#define SQLITE_NOTICE      27   /* Notifications from sqlite3_log() */

#define SQLITE_WARNING     28   /* Warnings from sqlite3_log() */

#define SQLITE_IOERR_MMAP              (SQLITE_IOERR | (24<<8))

#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))

#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))

  int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);

  int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p);

  /* Methods above are valid for version 3 */

** ^The [SQLITE_FCNTL_BUSYHANDLER]

** file-control may be invoked by SQLite on the database file handle

** ^Application can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control

** to have SQLite generate a

** <li>[[SQLITE_FCNTL_MMAP_SIZE]]

** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the

** maximum number of bytes that will be used for memory-mapped I/O.

** The argument is a pointer to a value of type sqlite3_int64 that

** is an advisory maximum number of bytes in the file to memory map.  The

** pointer is overwritten with the old value.  The limit is not changed if

** the value originally pointed to is negative, and so the current limit 

** can be queried by passing in a pointer to a negative number.  This

** file-control is used internally to implement [PRAGMA mmap_size].

**

#define SQLITE_FCNTL_MMAP_SIZE              18

** <dd> The SQLITE_CONFIG_LOG option is used to configure the SQLite

** global [error log].

** (^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a

** </dd>

** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should

** third parameter is passed NULL In this case.  An example of using this

** configuration option can be seen in the "test_sqllog.c" source file in

** the canonical SQLite source tree.</dd>

**

** [[SQLITE_CONFIG_MMAP_SIZE]]

** <dt>SQLITE_CONFIG_MMAP_SIZE

** <dd>SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values

** that are the default mmap size limit (the default setting for

** [PRAGMA mmap_size]) and the maximum allowed mmap size limit.

** The default setting can be overridden by each database connection using

** either the [PRAGMA mmap_size] command, or by using the

** [SQLITE_FCNTL_MMAP_SIZE] file control.  The maximum allowed mmap size

** cannot be changed at run-time.  Nor may the maximum allowed mmap size

** exceed the compile-time maximum mmap size set by the

** [SQLITE_MAX_MMAP_SIZE] compile-time option.  

** If either argument to this option is negative, then that argument is

** changed to its compile-time default.

#define SQLITE_CONFIG_MMAP_SIZE    22  /* sqlite3_int64, sqlite3_int64 */

** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit

** the length of [bound parameter] expansion in the output of sqlite3_trace().

**

** statement and try to run it again. As many as [SQLITE_MAX_SCHEMA_RETRY]

** retries will occur before sqlite3_step() gives up and returns an error.

** ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16()

** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter

** is ignored and the end result is the same as sqlite3_bind_null().

** C++ compilers.

** [SQLite extension] library contained in the file zFile.  If

** the file cannot be loaded directly, attempts are made to load

** with various operating-system specific extensions added.

** So for example, if "samplelib" cannot be loaded, then names like

** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might

** be tried also.

** ^(zProc may be 0, in which case SQLite will try to come up with an

** entry point name on its own.  It first tries "sqlite3_extension_init".

** If that does not work, it constructs a name "sqlite3_X_init" where the

** X is consists of the lower-case equivalent of all ASCII alphabetic

** characters in the filename from the last "/" to the first following

** "." and omitting any initial "lib".)^

** unprepared to deal with [extension loading], and as a means of disabling

** [extension loading] while evaluating user-entered SQL, the following API

** ^Extension loading is off by default.

** xEntryPoint() is the entry point for a statically linked [SQLite extension]

** CAPI3REF: String Globbing

*

** ^The [sqlite3_strglob(P,X)] interface returns zero if string X matches

** the glob pattern P, and it returns non-zero if string X does not match

** the glob pattern P.  ^The definition of glob pattern matching used in

** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the

** SQL dialect used by SQLite.  ^The sqlite3_strglob(P,X) function is case

** sensitive.

**

** Note that this routine returns zero on a match and non-zero if the strings

** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].

*/

SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);

/*

** ^The [sqlite3_log()] interface writes a message into the [error log]

# define SQLITE_TEMP_STORE_xc 1  /* Exclude from ctime.c */

/*

** Disable MMAP on platforms where it is known to not work

*/

#if defined(__OpenBSD__) || defined(__QNXNTO__)

# undef SQLITE_MAX_MMAP_SIZE

# define SQLITE_MAX_MMAP_SIZE 0

#endif

/*

** Default maximum size of memory used by memory-mapped I/O in the VFS

*/

#ifdef __APPLE__

# include <TargetConditionals.h>

# if TARGET_OS_IPHONE

#   undef SQLITE_MAX_MMAP_SIZE

#   define SQLITE_MAX_MMAP_SIZE 0

# endif

#endif

#ifndef SQLITE_MAX_MMAP_SIZE

# if defined(__linux__) \

  || defined(_WIN32) \

  || (defined(__APPLE__) && defined(__MACH__)) \

  || defined(__sun)

#   define SQLITE_MAX_MMAP_SIZE 0x7fff0000  /* 2147418112 */

# else

#   define SQLITE_MAX_MMAP_SIZE 0

# endif

# define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */

#endif

/*

** The default MMAP_SIZE is zero on all platforms.  Or, even if a larger

** default MMAP_SIZE is specified at compile-time, make sure that it does

** not exceed the maximum mmap size.

*/

#ifndef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE 0

# define SQLITE_DEFAULT_MMAP_SIZE_xc 1  /* Exclude from ctime.c */

#endif

#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE

# undef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE

#endif

SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree*,sqlite3_int64);

#define BTREE_APPLICATION_ID      8

** Flags that make up the mask passed to sqlite3PagerAcquire().

*/

#define PAGER_ACQUIRE_NOCONTENT     0x01  /* Do not load data from disk */

#define PAGER_ACQUIRE_READONLY      0x02  /* Read-only page is acceptable */

/*

SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *, sqlite3_int64);

#define PGHDR_MMAP              0x040  /* This is an mmap page object */

SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64, int, void **);

SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *, i64, void *);

  i64 szMmap;                   /* Default mmap_size setting */

#define NC_AsMaybe   0x10    /* Resolve to AS terms of the result set only

                             ** if no other resolution is available */

  sqlite3_int64 szMmap;             /* mmap() space per open file */

  sqlite3_int64 mxMmap;             /* Maximum value for szMmap */

  u8 bSelectDepthFirst;                     /* Do subqueries first */

#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) || \

    defined(SQLITE_DEBUG_OS_TRACE)

SQLITE_PRIVATE const char *sqlite3ErrName(int);

#endif

   SQLITE_DEFAULT_MMAP_SIZE,  /* szMmap */

   SQLITE_MAX_MMAP_SIZE,      /* mxMmap */

#if defined(SQLITE_DEFAULT_MMAP_SIZE) && !defined(SQLITE_DEFAULT_MMAP_SIZE_xc)

  "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),

#endif

#if defined(SQLITE_MAX_MMAP_SIZE) && !defined(SQLITE_MAX_MMAP_SIZE_xc)

  "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE),

#endif

#if defined(SQLITE_TEMP_STORE) && !defined(SQLITE_TEMP_STORE_xc)

#if defined(SQLITE_THREADSAFE)

    if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0

     && sqlite3CtypeMap[(unsigned char)azCompileOpt[i][n]]==0

    ){

      return 1;

    }

** The maximum number of times that a statement will try to reparse

** itself before giving up and returning SQLITE_SCHEMA.

*/

#ifndef SQLITE_MAX_SCHEMA_RETRY

# define SQLITE_MAX_SCHEMA_RETRY 50

#endif

/*

#if SQLITE_MAX_MMAP_SIZE>0

/* The real implementation of xFetch and xUnfetch */

SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){

  DO_OS_MALLOC_TEST(id);

  return id->pMethods->xFetch(id, iOff, iAmt, pp);

}

SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){

  return id->pMethods->xUnfetch(id, iOff, p);

}

#else

/* No-op stubs to use when memory-mapped I/O is disabled */

SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){

  *pp = 0;

  return SQLITE_OK;

}

SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){

  return SQLITE_OK;

}

#endif

#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0

  int nFetchOut;                      /* Number of outstanding xFetch refs */

  sqlite3_int64 mmapSize;             /* Usable size of mapping at pMapRegion */

  sqlite3_int64 mmapSizeActual;       /* Actual size of mapping at pMapRegion */

  sqlite3_int64 mmapSizeMax;          /* Configured FCNTL_MMAP_SIZE value */

  void *pMapRegion;                   /* Memory mapped region */

#define UNIXFILE_WARNED    0x0100     /* verifyDbFile() warnings have been issued */

** HAVE_MREMAP defaults to true on Linux and false everywhere else.

*/

#if !defined(HAVE_MREMAP)

# if defined(__linux__) && defined(_GNU_SOURCE)

#  define HAVE_MREMAP 1

# else

#  define HAVE_MREMAP 0

# endif

#endif

/*

  { "mmap",       (sqlite3_syscall_ptr)mmap,     0 },

#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[21].pCurrent)

  { "munmap",       (sqlite3_syscall_ptr)munmap,          0 },

#define osMunmap ((void*(*)(void*,size_t))aSyscall[22].pCurrent)

#if HAVE_MREMAP

  { "mremap",       (sqlite3_syscall_ptr)mremap,          0 },

#else

  { "mremap",       (sqlite3_syscall_ptr)0,               0 },

#endif

#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[23].pCurrent)

** Check a unixFile that is a database.  Verify the following:

**

** (1) There is exactly one hard link on the file

** (2) The file is not a symbolic link

** (3) The file has not been renamed or unlinked

**

** Issue sqlite3_log(SQLITE_WARNING,...) messages if anything is not right.

*/

static void verifyDbFile(unixFile *pFile){

  struct stat buf;

  int rc;

  if( pFile->ctrlFlags & UNIXFILE_WARNED ){

    /* One or more of the following warnings have already been issued.  Do not

    ** repeat them so as not to clutter the error log */

    return;

  }

  rc = osFstat(pFile->h, &buf);

  if( rc!=0 ){

    sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);

    pFile->ctrlFlags |= UNIXFILE_WARNED;

    return;

  }

  if( buf.st_nlink==0 && (pFile->ctrlFlags & UNIXFILE_DELETE)==0 ){

    sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);

    pFile->ctrlFlags |= UNIXFILE_WARNED;

    return;

  }

  if( buf.st_nlink>1 ){

    sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);

    pFile->ctrlFlags |= UNIXFILE_WARNED;

    return;

  }

  if( pFile->pInode!=0

   && ((rc = osStat(pFile->zPath, &buf))!=0

       || buf.st_ino!=pFile->pInode->fileId.ino)

  ){

    sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);

    pFile->ctrlFlags |= UNIXFILE_WARNED;

    return;

  }

}

/*

  assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 );

static int unixMapfile(unixFile *pFd, i64 nByte);

static void unixUnmapfile(unixFile *pFd);

  unixUnmapfile(pFile);

  verifyDbFile(pFile);

  assert( offset>=0 );

  assert( amt>0 );

#if SQLITE_MAX_MMAP_SIZE>0

  /* Deal with as much of this read request as possible by transfering

  ** data from the memory mapping using memcpy().  */

  if( offset<pFile->mmapSize ){

    if( offset+amt <= pFile->mmapSize ){

      memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);

      return SQLITE_OK;

    }else{

      int nCopy = pFile->mmapSize - offset;

      memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);

      pBuf = &((u8 *)pBuf)[nCopy];

      amt -= nCopy;

      offset += nCopy;

    }

  }

#endif

** Attempt to seek the file-descriptor passed as the first argument to

** absolute offset iOff, then attempt to write nBuf bytes of data from

** pBuf to it. If an error occurs, return -1 and set *piErrno. Otherwise, 

** return the actual number of bytes written (which may be less than

** nBuf).

static int seekAndWriteFd(

  int fd,                         /* File descriptor to write to */

  i64 iOff,                       /* File offset to begin writing at */

  const void *pBuf,               /* Copy data from this buffer to the file */

  int nBuf,                       /* Size of buffer pBuf in bytes */

  int *piErrno                    /* OUT: Error number if error occurs */

){

  int rc = 0;                     /* Value returned by system call */

  assert( nBuf==(nBuf&0x1ffff) );

  nBuf &= 0x1ffff;

  do{ rc = osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR );

  do{ rc = osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR);

    i64 iSeek = lseek(fd, iOff, SEEK_SET);

    SimulateIOError( iSeek-- );

    if( iSeek!=iOff ){

      if( piErrno ) *piErrno = (iSeek==-1 ? errno : 0);

    rc = osWrite(fd, pBuf, nBuf);

  }while( rc<0 && errno==EINTR );

  OSTRACE(("WRITE   %-3d %5d %7lld %llu\n", fd, rc, iOff, TIMER_ELAPSED));

  if( rc<0 && piErrno ) *piErrno = errno;

  return rc;

}

/*

** Seek to the offset in id->offset then read cnt bytes into pBuf.

** Return the number of bytes actually read.  Update the offset.

**

** To avoid stomping the errno value on a failed write the lastErrno value

** is set before returning.

*/

static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){

  return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno);

#if SQLITE_MAX_MMAP_SIZE>0

  /* Deal with as much of this write request as possible by transfering

  ** data from the memory mapping using memcpy().  */

  if( offset<pFile->mmapSize ){

    if( offset+amt <= pFile->mmapSize ){

      memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);

      return SQLITE_OK;

    }else{

      int nCopy = pFile->mmapSize - offset;

      memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);

      pBuf = &((u8 *)pBuf)[nCopy];

      amt -= nCopy;

      offset += nCopy;

    }

  }

#endif

    /* If the file was just truncated to a size smaller than the currently

    ** mapped region, reduce the effective mapping size as well. SQLite will

    ** use read() and write() to access data beyond this point from now on.  

    */

    if( nByte<pFile->mmapSize ){

      pFile->mmapSize = nByte;

    }

  if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){

    int rc;

    if( pFile->szChunk<=0 ){

      if( robust_ftruncate(pFile->h, nByte) ){

        pFile->lastErrno = errno;

        return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);

      }

    }

    rc = unixMapfile(pFile, nByte);

    return rc;

  }

    case SQLITE_FCNTL_MMAP_SIZE: {

      i64 newLimit = *(i64*)pArg;

      if( newLimit>sqlite3GlobalConfig.mxMmap ){

        newLimit = sqlite3GlobalConfig.mxMmap;

      }

      *(i64*)pArg = pFile->mmapSizeMax;

      if( newLimit>=0 ){

        pFile->mmapSizeMax = newLimit;

        if( newLimit<pFile->mmapSize ) pFile->mmapSize = newLimit;

      }

      return SQLITE_OK;

    }

        osMunmap(p->apRegion[i], p->szRegion);

        if( !bExtend ){

        /* Alternatively, if bExtend is true, extend the file. Do this by

        ** writing a single byte to the end of each (OS) page being

        ** allocated or extended. Technically, we need only write to the

        ** last page in order to extend the file. But writing to all new

        ** pages forces the OS to allocate them immediately, which reduces

        ** the chances of SIGBUS while accessing the mapped region later on.

        */

        else{

          static const int pgsz = 4096;

          int iPg;

          /* Write to the last byte of each newly allocated or extended page */

          assert( (nByte % pgsz)==0 );

          for(iPg=(sStat.st_size/pgsz); iPg<(nByte/pgsz); iPg++){

            if( seekAndWriteFd(pShmNode->h, iPg*pgsz + pgsz-1, "", 1, 0)!=1 ){

              const char *zFile = pShmNode->zFilename;

              rc = unixLogError(SQLITE_IOERR_SHMSIZE, "write", zFile);

              goto shmpage_out;

            }

          }

        pMem = osMmap(0, szRegion,

** If it is currently memory mapped, unmap file pFd.

*/

static void unixUnmapfile(unixFile *pFd){

  assert( pFd->nFetchOut==0 );

#if SQLITE_MAX_MMAP_SIZE>0

  if( pFd->pMapRegion ){

    osMunmap(pFd->pMapRegion, pFd->mmapSizeActual);

    pFd->pMapRegion = 0;

    pFd->mmapSize = 0;

    pFd->mmapSizeActual = 0;

  }

#endif

}

#if SQLITE_MAX_MMAP_SIZE>0

/*

** Return the system page size.

*/

static int unixGetPagesize(void){

#if HAVE_MREMAP

  return 512;

#elif defined(_BSD_SOURCE)

  return getpagesize();

#else

  return (int)sysconf(_SC_PAGESIZE);

#endif

}

#endif /* SQLITE_MAX_MMAP_SIZE>0 */

#if SQLITE_MAX_MMAP_SIZE>0

/*

** Attempt to set the size of the memory mapping maintained by file 

** descriptor pFd to nNew bytes. Any existing mapping is discarded.

**

** If successful, this function sets the following variables:

**

**       unixFile.pMapRegion

**       unixFile.mmapSize

**       unixFile.mmapSizeActual

**

** If unsuccessful, an error message is logged via sqlite3_log() and

** the three variables above are zeroed. In this case SQLite should

** continue accessing the database using the xRead() and xWrite()

** methods.

*/

static void unixRemapfile(

  unixFile *pFd,                  /* File descriptor object */

  i64 nNew                        /* Required mapping size */

){

  const char *zErr = "mmap";

  int h = pFd->h;                      /* File descriptor open on db file */

  u8 *pOrig = (u8 *)pFd->pMapRegion;   /* Pointer to current file mapping */

  i64 nOrig = pFd->mmapSizeActual;     /* Size of pOrig region in bytes */

  u8 *pNew = 0;                        /* Location of new mapping */

  int flags = PROT_READ;               /* Flags to pass to mmap() */

  assert( pFd->nFetchOut==0 );

  assert( nNew>pFd->mmapSize );

  assert( nNew<=pFd->mmapSizeMax );

  assert( nNew>0 );

  assert( pFd->mmapSizeActual>=pFd->mmapSize );

  assert( MAP_FAILED!=0 );

  if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE;

  if( pOrig ){

    const int szSyspage = unixGetPagesize();

    i64 nReuse = (pFd->mmapSize & ~(szSyspage-1));

    u8 *pReq = &pOrig[nReuse];

    /* Unmap any pages of the existing mapping that cannot be reused. */

    if( nReuse!=nOrig ){

      osMunmap(pReq, nOrig-nReuse);

    }

#if HAVE_MREMAP

    pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE);

    zErr = "mremap";

#else

    pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);

    if( pNew!=MAP_FAILED ){

      if( pNew!=pReq ){

        osMunmap(pNew, nNew - nReuse);

        pNew = 0;

      }else{

        pNew = pOrig;

      }

    }

#endif

    /* The attempt to extend the existing mapping failed. Free it. */

    if( pNew==MAP_FAILED || pNew==0 ){

      osMunmap(pOrig, nReuse);

    }

  }

  /* If pNew is still NULL, try to create an entirely new mapping. */

  if( pNew==0 ){

    pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);

  }

  if( pNew==MAP_FAILED ){

    pNew = 0;

    nNew = 0;

    unixLogError(SQLITE_OK, zErr, pFd->zPath);

    /* If the mmap() above failed, assume that all subsequent mmap() calls

    ** will probably fail too. Fall back to using xRead/xWrite exclusively

    ** in this case.  */

    pFd->mmapSizeMax = 0;

  }

  pFd->pMapRegion = (void *)pNew;

  pFd->mmapSize = pFd->mmapSizeActual = nNew;

}

#endif

/*

** Memory map or remap the file opened by file-descriptor pFd (if the file

** is already mapped, the existing mapping is replaced by the new). Or, if 

** there already exists a mapping for this file, and there are still 

** outstanding xFetch() references to it, this function is a no-op.

**

** If parameter nByte is non-negative, then it is the requested size of 

** the mapping to create. Otherwise, if nByte is less than zero, then the 

** requested size is the size of the file on disk. The actual size of the

** created mapping is either the requested size or the value configured 

** using SQLITE_FCNTL_MMAP_LIMIT, whichever is smaller.

**

** SQLITE_OK is returned if no error occurs (even if the mapping is not

** recreated as a result of outstanding references) or an SQLite error

** code otherwise.

*/

static int unixMapfile(unixFile *pFd, i64 nByte){

#if SQLITE_MAX_MMAP_SIZE>0

  i64 nMap = nByte;

  int rc;

  assert( nMap>=0 || pFd->nFetchOut==0 );

  if( pFd->nFetchOut>0 ) return SQLITE_OK;

  if( nMap<0 ){

    struct stat statbuf;          /* Low-level file information */

    rc = osFstat(pFd->h, &statbuf);

    if( rc!=SQLITE_OK ){

      return SQLITE_IOERR_FSTAT;

    }

    nMap = statbuf.st_size;

  }

  if( nMap>pFd->mmapSizeMax ){

    nMap = pFd->mmapSizeMax;

  }

  if( nMap!=pFd->mmapSize ){

    if( nMap>0 ){

      unixRemapfile(pFd, nMap);

    }else{

      unixUnmapfile(pFd);

    }

  }

#endif

  return SQLITE_OK;

}

/*

** If possible, return a pointer to a mapping of file fd starting at offset

** iOff. The mapping must be valid for at least nAmt bytes.

**

** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.

** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.

** Finally, if an error does occur, return an SQLite error code. The final

** value of *pp is undefined in this case.

**

** If this function does return a pointer, the caller must eventually 

** release the reference by calling unixUnfetch().

*/

static int unixFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){

#if SQLITE_MAX_MMAP_SIZE>0

  unixFile *pFd = (unixFile *)fd;   /* The underlying database file */

#endif

  *pp = 0;

#if SQLITE_MAX_MMAP_SIZE>0

  if( pFd->mmapSizeMax>0 ){

    if( pFd->pMapRegion==0 ){

      int rc = unixMapfile(pFd, -1);

      if( rc!=SQLITE_OK ) return rc;

    }

    if( pFd->mmapSize >= iOff+nAmt ){

      *pp = &((u8 *)pFd->pMapRegion)[iOff];

      pFd->nFetchOut++;

    }

  }

#endif

  return SQLITE_OK;

}

/*

** If the third argument is non-NULL, then this function releases a 

** reference obtained by an earlier call to unixFetch(). The second

** argument passed to this function must be the same as the corresponding

** argument that was passed to the unixFetch() invocation. 

**

** Or, if the third argument is NULL, then this function is being called 

** to inform the VFS layer that, according to POSIX, any existing mapping 

** may now be invalid and should be unmapped.

*/

static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){

  unixFile *pFd = (unixFile *)fd;   /* The underlying database file */

  UNUSED_PARAMETER(iOff);

  /* If p==0 (unmap the entire file) then there must be no outstanding 

  ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference),

  ** then there must be at least one outstanding.  */

  assert( (p==0)==(pFd->nFetchOut==0) );

  /* If p!=0, it must match the iOff value. */

  assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );

  if( p ){

    pFd->nFetchOut--;

  }else{

    unixUnmapfile(pFd);

  }

  assert( pFd->nFetchOut>=0 );

  return SQLITE_OK;

}

/*

   unixShmUnmap,               /* xShmUnmap */                               \

   unixFetch,                  /* xFetch */                                  \

   unixUnfetch,                /* xUnfetch */                                \

  3,                        /* shared memory and mmap are enabled */

  pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap;

    pNew->ctrlFlags |= UNIXFILE_DELETE;

    verifyDbFile(pNew);

  assert( ArraySize(aSyscall)==24 );

#if SQLITE_MAX_MMAP_SIZE>0

  int nFetchOut;                /* Number of outstanding xFetch references */

  HANDLE hMap;                  /* Handle for accessing memory mapping */

  void *pMapRegion;             /* Area memory mapped */

  sqlite3_int64 mmapSize;       /* Usable size of mapped region */

  sqlite3_int64 mmapSizeActual; /* Actual size of mapped region */

  sqlite3_int64 mmapSizeMax;    /* Configured FCNTL_MMAP_SIZE value */

#endif

#define WINFILE_RDONLY          0x02   /* Connection is read only */

    sqlite3_snprintf(nBuf, zBuf, "OsError 0x%lx (%lu)", lastErrno, lastErrno);

      "os_win.c:%d: (%lu) %s(%s) - %s",

  OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));

    OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));

  OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));

    OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));