diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/os.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/engine/sqlite/src/os.cpp	Thu Feb 25 14:29:19 2010 +0000
@@ -0,0 +1,305 @@
+ /*
+** 2005 November 29
+**
+** 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.
+**
+******************************************************************************
+**
+** This file contains OS interface code that is common to all
+** architectures.
+*/
+#define _SQLITE_OS_C_ 1
+#include "sqliteInt.h"
+#undef _SQLITE_OS_C_
+
+/*
+** The default SQLite sqlite3_vfs implementations do not allocate
+** memory (actually, os_unix.c allocates a small amount of memory
+** from within OsOpen()), but some third-party implementations may.
+** So we test the effects of a malloc() failing and the sqlite3OsXXX()
+** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
+**
+** The following functions are instrumented for malloc() failure 
+** testing:
+**
+**     sqlite3OsOpen()
+**     sqlite3OsRead()
+**     sqlite3OsWrite()
+**     sqlite3OsSync()
+**     sqlite3OsLock()
+**
+*/
+#ifdef SQLITE_TEST
+  #define DO_OS_MALLOC_TEST if (1) {            \
+    void *pTstAlloc = sqlite3_malloc(10);       \
+    if (!pTstAlloc) return SQLITE_IOERR_NOMEM;  \
+    sqlite3_free(pTstAlloc);                    \
+  }
+#else
+  #define DO_OS_MALLOC_TEST
+#endif
+
+/*
+** The following routines are convenience wrappers around methods
+** of the sqlite3_file object.  This is mostly just syntactic sugar. All
+** of this would be completely automatic if SQLite were coded using
+** C++ instead of plain old C.
+*/
+int sqlite3OsClose(sqlite3_file *pId){
+  int rc = SQLITE_OK;
+/*  if( pId->pMethods ){
+    rc = pId->pMethods->xClose(pId);
+    pId->pMethods = 0;
+  }*/
+  rc = winClose(pId);
+  return rc;
+}
+int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
+  DO_OS_MALLOC_TEST;
+  //return id->pMethods->xRead(id, pBuf, amt, offset);
+  return winRead(id, pBuf, amt, offset);
+}
+int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
+  DO_OS_MALLOC_TEST;
+  //return id->pMethods->xWrite(id, pBuf, amt, offset);
+  return winWrite(id, pBuf, amt, offset);
+}
+int sqlite3OsTruncate(sqlite3_file *id, i64 size){
+  //return id->pMethods->xTruncate(id, size);
+	return winTruncate(id, size);
+}
+int sqlite3OsSync(sqlite3_file *id, int flags){
+  DO_OS_MALLOC_TEST;
+//  return id->pMethods->xSync(id, flags);
+  return winSync(id, flags);
+}
+int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
+//  return id->pMethods->xFileSize(id, pSize);
+	return winFileSize(id, pSize);
+}
+int sqlite3OsLock(sqlite3_file *id, int lockType){
+  DO_OS_MALLOC_TEST;
+  //return id->pMethods->xLock(id, lockType);
+  return winLock(id, lockType);
+}
+int sqlite3OsUnlock(sqlite3_file *id, int lockType){
+  //return id->pMethods->xUnlock(id, lockType);
+	return winUnlock(id, lockType);
+}
+int sqlite3OsCheckReservedLock(sqlite3_file *id){
+  //return id->pMethods->xCheckReservedLock(id);
+	return winCheckReservedLock(id);
+}
+int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
+  //return id->pMethods->xFileControl(id,op,pArg);
+	return winFileControl(id, op, pArg);
+}
+
+#ifdef SQLITE_TEST
+  /* The following two variables are used to override the values returned
+  ** by the xSectorSize() and xDeviceCharacteristics() vfs methods for
+  ** testing purposes. They are usually set by a test command implemented
+  ** in test6.c.
+  */
+  int sqlite3_test_sector_size = 0;
+  int sqlite3_test_device_characteristics = 0;
+  int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
+    int dc = id->pMethods->xDeviceCharacteristics(id);
+    return dc | sqlite3_test_device_characteristics;
+  }
+  int sqlite3OsSectorSize(sqlite3_file *id){
+    if( sqlite3_test_sector_size==0 ){
+      int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
+      return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
+    }
+    return sqlite3_test_sector_size;
+  }
+#else
+  int sqlite3OsSectorSize(sqlite3_file *id){
+    //int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
+    //return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
+	  return winSectorSize(id);
+  }
+  int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
+//    return id->pMethods->xDeviceCharacteristics(id);
+	  return winDeviceCharacteristics(id);
+  }
+#endif
+
+/*
+** The next group of routines are convenience wrappers around the
+** VFS methods.
+*/
+int sqlite3OsOpen(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  sqlite3_file *pFile, 
+  int flags, 
+  int *pFlagsOut
+){
+  //return pVfs->xOpen(pVfs, zPath, pFile, flags, pFlagsOut);
+  return winOpen(pVfs, zPath, pFile, flags, pFlagsOut);
+}
+int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+  //return pVfs->xDelete(pVfs, zPath, dirSync);
+	return winDelete(pVfs, zPath, dirSync);
+}
+int sqlite3OsAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){
+//  return pVfs->xAccess(pVfs, zPath, flags);
+	return winAccess(pVfs, zPath, flags);
+}
+int sqlite3OsGetTempname(sqlite3_vfs *pVfs, int nBufOut, char *zBufOut){
+//  return pVfs->xGetTempname(pVfs, nBufOut, zBufOut);
+	return winGetTempname(pVfs, nBufOut, zBufOut);
+}
+int sqlite3OsFullPathname(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  int nPathOut, 
+  char *zPathOut
+){
+//  return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
+	return winFullPathname(pVfs, zPath, nPathOut, zPathOut);
+}
+void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+//  return pVfs->xDlOpen(pVfs, zPath);
+	return NULL;
+}
+void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+//  pVfs->xDlError(pVfs, nByte, zBufOut);
+
+}
+void *sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+//  return pVfs->xDlSym(pVfs, pHandle, zSymbol);
+	return NULL;
+}
+void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
+//  pVfs->xDlClose(pVfs, pHandle);
+}
+int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+//  return pVfs->xRandomness(pVfs, nByte, zBufOut);
+	return winRandomness(pVfs, nByte, zBufOut);
+}
+int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
+//  return pVfs->xSleep(pVfs, nMicro);
+	return winSleep(pVfs, nMicro);
+}
+int sqlite3OsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
+//  return pVfs->xCurrentTime(pVfs, pTimeOut);
+	return winCurrentTime(pVfs, pTimeOut);
+}
+
+int sqlite3OsOpenMalloc(
+  sqlite3_vfs *pVfs, 
+  const char *zFile, 
+  sqlite3_file **ppFile, 
+  int flags,
+  int *pOutFlags
+){
+  int rc = SQLITE_NOMEM;
+  sqlite3_file *pFile;
+  pFile = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile);
+  if( pFile ){
+    rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
+    if( rc!=SQLITE_OK ){
+      sqlite3_free(pFile);
+    }else{
+      *ppFile = pFile;
+    }
+  }
+  return rc;
+}
+int sqlite3OsCloseFree(sqlite3_file *pFile){
+  int rc = SQLITE_OK;
+  if( pFile ){
+    rc = sqlite3OsClose(pFile);
+    sqlite3_free(pFile);
+  }
+  return rc;
+}
+
+/*
+** The list of all registered VFS implementations.  This list is
+** initialized to the single VFS returned by sqlite3OsDefaultVfs()
+** upon the first call to sqlite3_vfs_find().
+*/
+static sqlite3_vfs *vfsList = 0;
+
+/*
+** Locate a VFS by name.  If no name is given, simply return the
+** first VFS on the list.
+*/
+EXPORT_C sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+  sqlite3_vfs *pVfs = 0;
+  static int isInit = 0;
+  sqlite3_mutex_enter(mutex);
+  if( !isInit ){
+    vfsList = sqlite3OsDefaultVfs();
+    isInit = 1;
+  }
+  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
+    if( zVfs==0 ) break;
+    if( strcmp(zVfs, pVfs->zName)==0 ) break;
+  }
+  sqlite3_mutex_leave(mutex);
+  return pVfs;
+}
+
+/*
+** Unlink a VFS from the linked list
+*/
+static void vfsUnlink(sqlite3_vfs *pVfs){
+  assert( sqlite3_mutex_held(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)) );
+  if( pVfs==0 ){
+    /* No-op */
+  }else if( vfsList==pVfs ){
+    vfsList = pVfs->pNext;
+  }else if( vfsList ){
+    sqlite3_vfs *p = vfsList;
+    while( p->pNext && p->pNext!=pVfs ){
+      p = p->pNext;
+    }
+    if( p->pNext==pVfs ){
+      p->pNext = pVfs->pNext;
+    }
+  }
+}
+
+/*
+** Register a VFS with the system.  It is harmless to register the same
+** VFS multiple times.  The new VFS becomes the default if makeDflt is
+** true.
+*/
+EXPORT_C int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+  sqlite3_vfs_find(0);  /* Make sure we are initialized */
+  sqlite3_mutex_enter(mutex);
+  vfsUnlink(pVfs);
+  if( makeDflt || vfsList==0 ){
+    pVfs->pNext = vfsList;
+    vfsList = pVfs;
+  }else{
+    pVfs->pNext = vfsList->pNext;
+    vfsList->pNext = pVfs;
+  }
+  assert(vfsList);
+  sqlite3_mutex_leave(mutex);
+  return SQLITE_OK;
+}
+
+/*
+** Unregister a VFS so that it is no longer accessible.
+*/
+EXPORT_C int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+  sqlite3_mutex_enter(mutex);
+  vfsUnlink(pVfs);
+  sqlite3_mutex_leave(mutex);
+  return SQLITE_OK;
+}