[sql] Import reference version of SQLite 3.8.7.4.

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

 /*
 ** 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.
 **
@@ skipping 270 matching lines @@
 ** 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 = 2*(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 = MAX(pTmp->nSize, iOfst+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 = MIN(pTmp->nSize, size);
+  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;
 }
 
@@ skipping 91 matching lines @@
   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 = iOfst;
+    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;
     }
   }
@@ skipping 14 matching lines @@
   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 = MAX(pReal->nDatabase, iAmt+iOfst);
+        pReal->nDatabase = (int)MAX(pReal->nDatabase, iAmt+iOfst);
       }
     }
   }else{
     /* Journal file. */
     int iRem = iAmt;
     int iBuf = 0;
-    int ii = iOfst;
+    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 = MAX(pReal->nJournal, iAmt+iOfst);
+      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 = MIN(pReal->nDatabase, size);
+    pReal->nDatabase = (int)MIN(pReal->nDatabase, size);
   }else{
-    pReal->nJournal = MIN(pReal->nJournal, size);
+    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;
@@ skipping 94 matching lines @@
     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 = strlen(zName)-((eType==JOURNAL_FILE)?8:0);
+  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);
 
@@ skipping 14 matching lines @@
 
     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 = size;
+      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;
         }
       }
     }
 
@@ skipping 25 matching lines @@
 /*
 ** 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 = strlen(zPath) - 8;
+  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 = strlen(zPath);
+  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;
@@ skipping 90 matching lines @@
   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