Import SQLite 3.8.7.4.

third_party/sqlite/src/src/test_osinst.c

 /*
 ** 2008 April 10
 **
 ** 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.
 **
@@ skipping 52 matching lines @@
 **         event    TEXT,             // "xOpen", "xRead" etc.
 **         file     TEXT,             // Name of file this call applies to
 **         clicks   INTEGER,          // Time spent in call
 **         rc       INTEGER,          // Return value
 **         size     INTEGER,          // Bytes read or written
 **         offset   INTEGER           // File offset read or written
 **       );
 */
 
 #include "sqlite3.h"
+
+#include "os_setup.h"
+#if SQLITE_OS_WIN
+#  include "os_win.h"
+#endif
+
 #include <string.h>
 #include <assert.h>
 
 
 /*
 ** Maximum pathname length supported by the vfslog backend.
 */
 #define INST_MAX_PATHNAME 512
 
 #define OS_ACCESS            1
@@ skipping 131 matching lines @@
 };
 
 #if SQLITE_OS_UNIX && !defined(NO_GETTOD)
 #include <sys/time.h>
 static sqlite3_uint64 vfslog_time(){
   struct timeval sTime;
   gettimeofday(&sTime, 0);
   return sTime.tv_usec + (sqlite3_uint64)sTime.tv_sec * 1000000;
 }
 #elif SQLITE_OS_WIN
-#include <windows.h>
 #include <time.h>
 static sqlite3_uint64 vfslog_time(){
   FILETIME ft;
   sqlite3_uint64 u64time = 0;
  
   GetSystemTimeAsFileTime(&ft);
 
   u64time |= ft.dwHighDateTime;
   u64time <<= 32;
   u64time |= ft.dwLowDateTime;
 
   /* ft is 100-nanosecond intervals, we want microseconds */
   return u64time /(sqlite3_uint64)10;
 }
 #else
 static sqlite3_uint64 vfslog_time(){
   return 0;
 }
 #endif
 
-static void vfslog_call(sqlite3_vfs *, int, int, int, int, int, int);
+static void vfslog_call(sqlite3_vfs *, int, int, sqlite3_int64, int, int, int);
 static void vfslog_string(sqlite3_vfs *, const char *);
 
 /*
 ** Close an vfslog-file.
 */
 static int vfslogClose(sqlite3_file *pFile){
   sqlite3_uint64 t;
   int rc = SQLITE_OK;
   VfslogFile *p = (VfslogFile *)pFile;
 
@@ skipping 126 matching lines @@
   t = vfslog_time() - t;
   vfslog_call(p->pVfslog, OS_CHECKRESERVEDLOCK, p->iFileId, t, rc, *pResOut, 0);
   return rc;
 }
 
 /*
 ** File control method. For custom operations on an vfslog-file.
 */
 static int vfslogFileControl(sqlite3_file *pFile, int op, void *pArg){
   VfslogFile *p = (VfslogFile *)pFile;
-  return p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
+  int rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
+  if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){
+    *(char**)pArg = sqlite3_mprintf("vfslog/%z", *(char**)pArg);
+  }
+  return rc;
 }
 
 /*
 ** Return the sector-size in bytes for an vfslog-file.
 */
 static int vfslogSectorSize(sqlite3_file *pFile){
   int rc;
   sqlite3_uint64 t;
   VfslogFile *p = (VfslogFile *)pFile;
   t = vfslog_time();
@@ skipping 234 matching lines @@
   p[0] = v>>24;
   p[1] = v>>16;
   p[2] = v>>8;
   p[3] = v;
 }
 
 static void vfslog_call(
   sqlite3_vfs *pVfs,
   int eEvent,
   int iFileid,
-  int nClick,
+  sqlite3_int64 nClick,
   int return_code,
   int size,
   int offset
 ){
   VfslogVfs *p = (VfslogVfs *)pVfs;
   unsigned char *zRec;
   if( (24+p->nBuf)>sizeof(p->aBuf) ){
     vfslog_flush(p);
   }
   zRec = (unsigned char *)&p->aBuf[p->nBuf];
   put32bits(&zRec[0], eEvent);
   put32bits(&zRec[4], iFileid);
-  put32bits(&zRec[8], nClick);
+  put32bits(&zRec[8], (unsigned int)(nClick&0xffff));
   put32bits(&zRec[12], return_code);
   put32bits(&zRec[16], size);
   put32bits(&zRec[20], offset);
   p->nBuf += 24;
 }
 
 static void vfslog_string(sqlite3_vfs *pVfs, const char *zStr){
   VfslogVfs *p = (VfslogVfs *)pVfs;
   unsigned char *zRec;
-  int nStr = zStr ? strlen(zStr) : 0;
+  int nStr = zStr ? (int)strlen(zStr) : 0;
   if( (4+nStr+p->nBuf)>sizeof(p->aBuf) ){
     vfslog_flush(p);
   }
   zRec = (unsigned char *)&p->aBuf[p->nBuf];
   put32bits(&zRec[0], nStr);
   if( zStr ){
     memcpy(&zRec[4], zStr, nStr);
   }
   p->nBuf += (4 + nStr);
 }
@@ skipping 28 matching lines @@
   int flags;
   int rc;
   char *zFile;
   int nVfs;
 
   pParent = sqlite3_vfs_find(zParentVfs);
   if( !pParent ){
     return SQLITE_ERROR;
   }
 
-  nVfs = strlen(zVfs);
+  nVfs = (int)strlen(zVfs);
   nByte = sizeof(VfslogVfs) + pParent->szOsFile + nVfs+1+pParent->mxPathname+1;
   p = (VfslogVfs *)sqlite3_malloc(nByte);
   memset(p, 0, nByte);
 
   p->pVfs = pParent;
   p->pLog = (sqlite3_file *)&p[1];
   memcpy(&p->base, &vfslog_vfs, sizeof(sqlite3_vfs));
   p->base.zName = &((char *)p->pLog)[pParent->szOsFile];
   p->base.szOsFile += pParent->szOsFile;
   memcpy((char *)p->base.zName, zVfs, nVfs);
@@ skipping 302 matching lines @@
   assert( i<7 );
   val = get32bits(&pCsr->aBuf[4*i]);
 
   switch( i ){
     case 0: {
       sqlite3_result_text(ctx, vfslog_eventname(val), -1, SQLITE_STATIC);
       break;
     }
     case 1: {
       char *zStr = pCsr->zTransient;
-      if( val!=0 && val<pCsr->nFile ){
+      if( val!=0 && val<(unsigned)pCsr->nFile ){
         zStr = pCsr->azFile[val];
       }
       sqlite3_result_text(ctx, zStr, -1, SQLITE_TRANSIENT);
       break;
     }
     default:
       sqlite3_result_int(ctx, val);
       break;
   }
 
@@ skipping 149 matching lines @@
 
   return TCL_OK;
 }
 
 int SqlitetestOsinst_Init(Tcl_Interp *interp){
   Tcl_CreateObjCommand(interp, "vfslog", test_vfslog, 0, 0);
   return TCL_OK;
 }
 
 #endif /* SQLITE_TEST */