/ Check-in [fb7d8bf6]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Cleanup the Windows syscall table, removing the unused CreateFileMapping entry.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | winrt
Files: files | file ages | folders
SHA1: fb7d8bf6ec5c0ef9a948bc14c28770e34f57db1a
User & Date: mistachkin 2012-03-13 01:30:20
Context
2012-03-13
03:35
Defer creation of the sleep event object until it is needed. Added sqlite3_win32_write_debug and sqlite3_win32_sleep APIs to assist in portability to WinRT. check-in: 7af88ad3 user: mistachkin tags: winrt
01:30
Cleanup the Windows syscall table, removing the unused CreateFileMapping entry. check-in: fb7d8bf6 user: mistachkin tags: winrt
01:16
More changes required to compile for WinRT using VS 11 beta. Also, replace more APIs with their WinRT alternatives. check-in: 6b997d9c user: mistachkin tags: winrt
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to src/os_win.c.

   269    269   #else
   270    270     { "CreateFileW",             (SYSCALL)0,                       0 },
   271    271   #endif
   272    272   
   273    273   #define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \
   274    274           LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent)
   275    275   
   276         -  /* TODO: REMOVE */
   277         -  { "CreateFileMapping",       (SYSCALL)0,                       0 },
   278         -
   279    276   #if defined(SQLITE_WIN32_HAS_WIDE)
   280    277     { "CreateFileMappingW",      (SYSCALL)CreateFileMappingW,      0 },
   281    278   #else
   282    279     { "CreateFileMappingW",      (SYSCALL)0,                       0 },
   283    280   #endif
   284    281   
   285    282   #define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \
   286         -        DWORD,DWORD,DWORD,LPCWSTR))aSyscall[7].pCurrent)
          283  +        DWORD,DWORD,DWORD,LPCWSTR))aSyscall[6].pCurrent)
   287    284   
   288    285   #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)
   289    286     { "CreateMutexW",            (SYSCALL)CreateMutexW,            0 },
   290    287   #else
   291    288     { "CreateMutexW",            (SYSCALL)0,                       0 },
   292    289   #endif
   293    290   
   294    291   #define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \
   295         -        LPCWSTR))aSyscall[8].pCurrent)
          292  +        LPCWSTR))aSyscall[7].pCurrent)
   296    293   
   297    294   #if defined(SQLITE_WIN32_HAS_ANSI)
   298    295     { "DeleteFileA",             (SYSCALL)DeleteFileA,             0 },
   299    296   #else
   300    297     { "DeleteFileA",             (SYSCALL)0,                       0 },
   301    298   #endif
   302    299   
   303         -#define osDeleteFileA ((BOOL(WINAPI*)(LPCSTR))aSyscall[9].pCurrent)
          300  +#define osDeleteFileA ((BOOL(WINAPI*)(LPCSTR))aSyscall[8].pCurrent)
   304    301   
   305    302   #if defined(SQLITE_WIN32_HAS_WIDE)
   306    303     { "DeleteFileW",             (SYSCALL)DeleteFileW,             0 },
   307    304   #else
   308    305     { "DeleteFileW",             (SYSCALL)0,                       0 },
   309    306   #endif
   310    307   
   311         -#define osDeleteFileW ((BOOL(WINAPI*)(LPCWSTR))aSyscall[10].pCurrent)
          308  +#define osDeleteFileW ((BOOL(WINAPI*)(LPCWSTR))aSyscall[9].pCurrent)
   312    309   
   313    310   #if SQLITE_OS_WINCE
   314    311     { "FileTimeToLocalFileTime", (SYSCALL)FileTimeToLocalFileTime, 0 },
   315    312   #else
   316    313     { "FileTimeToLocalFileTime", (SYSCALL)0,                       0 },
   317    314   #endif
   318    315   
   319    316   #define osFileTimeToLocalFileTime ((BOOL(WINAPI*)(CONST FILETIME*, \
   320         -        LPFILETIME))aSyscall[11].pCurrent)
          317  +        LPFILETIME))aSyscall[10].pCurrent)
   321    318   
   322    319   #if SQLITE_OS_WINCE
   323    320     { "FileTimeToSystemTime",    (SYSCALL)FileTimeToSystemTime,    0 },
   324    321   #else
   325    322     { "FileTimeToSystemTime",    (SYSCALL)0,                       0 },
   326    323   #endif
   327    324   
   328    325   #define osFileTimeToSystemTime ((BOOL(WINAPI*)(CONST FILETIME*, \
   329         -        LPSYSTEMTIME))aSyscall[12].pCurrent)
          326  +        LPSYSTEMTIME))aSyscall[11].pCurrent)
   330    327   
   331    328     { "FlushFileBuffers",        (SYSCALL)FlushFileBuffers,        0 },
   332    329   
   333         -#define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[13].pCurrent)
          330  +#define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[12].pCurrent)
   334    331   
   335    332   #if defined(SQLITE_WIN32_HAS_ANSI)
   336    333     { "FormatMessageA",          (SYSCALL)FormatMessageA,          0 },
   337    334   #else
   338    335     { "FormatMessageA",          (SYSCALL)0,                       0 },
   339    336   #endif
   340    337   
   341    338   #define osFormatMessageA ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPSTR, \
   342         -        DWORD,va_list*))aSyscall[14].pCurrent)
          339  +        DWORD,va_list*))aSyscall[13].pCurrent)
   343    340   
   344    341   #if defined(SQLITE_WIN32_HAS_WIDE)
   345    342     { "FormatMessageW",          (SYSCALL)FormatMessageW,          0 },
   346    343   #else
   347    344     { "FormatMessageW",          (SYSCALL)0,                       0 },
   348    345   #endif
   349    346   
   350    347   #define osFormatMessageW ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPWSTR, \
   351         -        DWORD,va_list*))aSyscall[15].pCurrent)
          348  +        DWORD,va_list*))aSyscall[14].pCurrent)
   352    349   
   353    350     { "FreeLibrary",             (SYSCALL)FreeLibrary,             0 },
   354    351   
   355         -#define osFreeLibrary ((BOOL(WINAPI*)(HMODULE))aSyscall[16].pCurrent)
          352  +#define osFreeLibrary ((BOOL(WINAPI*)(HMODULE))aSyscall[15].pCurrent)
   356    353   
   357    354     { "GetCurrentProcessId",     (SYSCALL)GetCurrentProcessId,     0 },
   358    355   
   359         -#define osGetCurrentProcessId ((DWORD(WINAPI*)(VOID))aSyscall[17].pCurrent)
          356  +#define osGetCurrentProcessId ((DWORD(WINAPI*)(VOID))aSyscall[16].pCurrent)
   360    357   
   361    358   #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI)
   362    359     { "GetDiskFreeSpaceA",       (SYSCALL)GetDiskFreeSpaceA,       0 },
   363    360   #else
   364    361     { "GetDiskFreeSpaceA",       (SYSCALL)0,                       0 },
   365    362   #endif
   366    363   
   367    364   #define osGetDiskFreeSpaceA ((BOOL(WINAPI*)(LPCSTR,LPDWORD,LPDWORD,LPDWORD, \
   368         -        LPDWORD))aSyscall[18].pCurrent)
          365  +        LPDWORD))aSyscall[17].pCurrent)
   369    366   
   370    367   #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)
   371    368     { "GetDiskFreeSpaceW",       (SYSCALL)GetDiskFreeSpaceW,       0 },
   372    369   #else
   373    370     { "GetDiskFreeSpaceW",       (SYSCALL)0,                       0 },
   374    371   #endif
   375    372   
   376    373   #define osGetDiskFreeSpaceW ((BOOL(WINAPI*)(LPCWSTR,LPDWORD,LPDWORD,LPDWORD, \
   377         -        LPDWORD))aSyscall[19].pCurrent)
          374  +        LPDWORD))aSyscall[18].pCurrent)
   378    375   
   379    376   #if defined(SQLITE_WIN32_HAS_ANSI)
   380    377     { "GetFileAttributesA",      (SYSCALL)GetFileAttributesA,      0 },
   381    378   #else
   382    379     { "GetFileAttributesA",      (SYSCALL)0,                       0 },
   383    380   #endif
   384    381   
   385         -#define osGetFileAttributesA ((DWORD(WINAPI*)(LPCSTR))aSyscall[20].pCurrent)
          382  +#define osGetFileAttributesA ((DWORD(WINAPI*)(LPCSTR))aSyscall[19].pCurrent)
   386    383   
   387    384   #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)
   388    385     { "GetFileAttributesW",      (SYSCALL)GetFileAttributesW,      0 },
   389    386   #else
   390    387     { "GetFileAttributesW",      (SYSCALL)0,                       0 },
   391    388   #endif
   392    389   
   393         -#define osGetFileAttributesW ((DWORD(WINAPI*)(LPCWSTR))aSyscall[21].pCurrent)
          390  +#define osGetFileAttributesW ((DWORD(WINAPI*)(LPCWSTR))aSyscall[20].pCurrent)
   394    391   
   395    392   #if defined(SQLITE_WIN32_HAS_WIDE)
   396    393     { "GetFileAttributesExW",    (SYSCALL)GetFileAttributesExW,    0 },
   397    394   #else
   398    395     { "GetFileAttributesExW",    (SYSCALL)0,                       0 },
   399    396   #endif
   400    397   
   401    398   #define osGetFileAttributesExW ((BOOL(WINAPI*)(LPCWSTR,GET_FILEEX_INFO_LEVELS, \
   402         -        LPVOID))aSyscall[22].pCurrent)
          399  +        LPVOID))aSyscall[21].pCurrent)
   403    400   
   404    401   #if !SQLITE_OS_WINRT
   405    402     { "GetFileSize",             (SYSCALL)GetFileSize,             0 },
   406    403   #else
   407    404     { "GetFileSize",             (SYSCALL)0,                       0 },
   408    405   #endif
   409    406   
   410         -#define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[23].pCurrent)
          407  +#define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[22].pCurrent)
   411    408   
   412    409   #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI)
   413    410     { "GetFullPathNameA",        (SYSCALL)GetFullPathNameA,        0 },
   414    411   #else
   415    412     { "GetFullPathNameA",        (SYSCALL)0,                       0 },
   416    413   #endif
   417    414   
   418    415   #define osGetFullPathNameA ((DWORD(WINAPI*)(LPCSTR,DWORD,LPSTR, \
   419         -        LPSTR*))aSyscall[24].pCurrent)
          416  +        LPSTR*))aSyscall[23].pCurrent)
   420    417   
   421    418   #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)
   422    419     { "GetFullPathNameW",        (SYSCALL)GetFullPathNameW,        0 },
   423    420   #else
   424    421     { "GetFullPathNameW",        (SYSCALL)0,                       0 },
   425    422   #endif
   426    423   
   427    424   #define osGetFullPathNameW ((DWORD(WINAPI*)(LPCWSTR,DWORD,LPWSTR, \
   428         -        LPWSTR*))aSyscall[25].pCurrent)
          425  +        LPWSTR*))aSyscall[24].pCurrent)
   429    426   
   430    427     { "GetLastError",            (SYSCALL)GetLastError,            0 },
   431    428   
   432         -#define osGetLastError ((DWORD(WINAPI*)(VOID))aSyscall[26].pCurrent)
          429  +#define osGetLastError ((DWORD(WINAPI*)(VOID))aSyscall[25].pCurrent)
   433    430   
   434    431   #if SQLITE_OS_WINCE
   435    432     /* The GetProcAddressA() routine is only available on Windows CE. */
   436    433     { "GetProcAddressA",         (SYSCALL)GetProcAddressA,         0 },
   437    434   #else
   438    435     /* All other Windows platforms expect GetProcAddress() to take
   439    436     ** an ANSI string regardless of the _UNICODE setting */
   440    437     { "GetProcAddressA",         (SYSCALL)GetProcAddress,          0 },
   441    438   #endif
   442    439   
   443    440   #define osGetProcAddressA ((FARPROC(WINAPI*)(HMODULE, \
   444         -        LPCSTR))aSyscall[27].pCurrent)
          441  +        LPCSTR))aSyscall[26].pCurrent)
   445    442   
   446    443   #if !SQLITE_OS_WINRT
   447    444     { "GetSystemInfo",           (SYSCALL)GetSystemInfo,           0 },
   448    445   #else
   449    446     { "GetSystemInfo",           (SYSCALL)0,                       0 },
   450    447   #endif
   451    448   
   452         -#define osGetSystemInfo ((VOID(WINAPI*)(LPSYSTEM_INFO))aSyscall[28].pCurrent)
          449  +#define osGetSystemInfo ((VOID(WINAPI*)(LPSYSTEM_INFO))aSyscall[27].pCurrent)
   453    450   
   454    451     { "GetSystemTime",           (SYSCALL)GetSystemTime,           0 },
   455    452   
   456         -#define osGetSystemTime ((VOID(WINAPI*)(LPSYSTEMTIME))aSyscall[29].pCurrent)
          453  +#define osGetSystemTime ((VOID(WINAPI*)(LPSYSTEMTIME))aSyscall[28].pCurrent)
   457    454   
   458    455   #if !SQLITE_OS_WINCE
   459    456     { "GetSystemTimeAsFileTime", (SYSCALL)GetSystemTimeAsFileTime, 0 },
   460    457   #else
   461    458     { "GetSystemTimeAsFileTime", (SYSCALL)0,                       0 },
   462    459   #endif
   463    460   
   464    461   #define osGetSystemTimeAsFileTime ((VOID(WINAPI*)( \
   465         -        LPFILETIME))aSyscall[30].pCurrent)
          462  +        LPFILETIME))aSyscall[29].pCurrent)
   466    463   
   467    464   #if defined(SQLITE_WIN32_HAS_ANSI)
   468    465     { "GetTempPathA",            (SYSCALL)GetTempPathA,            0 },
   469    466   #else
   470    467     { "GetTempPathA",            (SYSCALL)0,                       0 },
   471    468   #endif
   472    469   
   473         -#define osGetTempPathA ((DWORD(WINAPI*)(DWORD,LPSTR))aSyscall[31].pCurrent)
          470  +#define osGetTempPathA ((DWORD(WINAPI*)(DWORD,LPSTR))aSyscall[30].pCurrent)
   474    471   
   475    472   #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)
   476    473     { "GetTempPathW",            (SYSCALL)GetTempPathW,            0 },
   477    474   #else
   478    475     { "GetTempPathW",            (SYSCALL)0,                       0 },
   479    476   #endif
   480    477   
   481         -#define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[32].pCurrent)
          478  +#define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[31].pCurrent)
   482    479   
   483    480   #if !SQLITE_OS_WINRT
   484    481     { "GetTickCount",            (SYSCALL)GetTickCount,            0 },
   485    482   #else
   486    483     { "GetTickCount",            (SYSCALL)0,                       0 },
   487    484   #endif
   488    485   
   489         -#define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent)
          486  +#define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[32].pCurrent)
   490    487   
   491    488   #if defined(SQLITE_WIN32_HAS_ANSI)
   492    489     { "GetVersionExA",           (SYSCALL)GetVersionExA,           0 },
   493    490   #else
   494    491     { "GetVersionExA",           (SYSCALL)0,                       0 },
   495    492   #endif
   496    493   
   497    494   #define osGetVersionExA ((BOOL(WINAPI*)( \
   498         -        LPOSVERSIONINFOA))aSyscall[34].pCurrent)
          495  +        LPOSVERSIONINFOA))aSyscall[33].pCurrent)
   499    496   
   500    497     { "HeapAlloc",               (SYSCALL)HeapAlloc,               0 },
   501    498   
   502    499   #define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \
   503         -        SIZE_T))aSyscall[35].pCurrent)
          500  +        SIZE_T))aSyscall[34].pCurrent)
   504    501   
   505    502   #if !SQLITE_OS_WINRT
   506    503     { "HeapCreate",              (SYSCALL)HeapCreate,              0 },
   507    504   #else
   508    505     { "HeapCreate",              (SYSCALL)0,                       0 },
   509    506   #endif
   510    507   
   511    508   #define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \
   512         -        SIZE_T))aSyscall[36].pCurrent)
          509  +        SIZE_T))aSyscall[35].pCurrent)
   513    510   
   514    511   #if !SQLITE_OS_WINRT
   515    512     { "HeapDestroy",             (SYSCALL)HeapDestroy,             0 },
   516    513   #else
   517    514     { "HeapDestroy",             (SYSCALL)0,                       0 },
   518    515   #endif
   519    516   
   520         -#define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[37].pCurrent)
          517  +#define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[36].pCurrent)
   521    518   
   522    519     { "HeapFree",                (SYSCALL)HeapFree,                0 },
   523    520   
   524         -#define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[38].pCurrent)
          521  +#define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[37].pCurrent)
   525    522   
   526    523     { "HeapReAlloc",             (SYSCALL)HeapReAlloc,             0 },
   527    524   
   528    525   #define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \
   529         -        SIZE_T))aSyscall[39].pCurrent)
          526  +        SIZE_T))aSyscall[38].pCurrent)
   530    527   
   531    528     { "HeapSize",                (SYSCALL)HeapSize,                0 },
   532    529   
   533    530   #define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \
   534         -        LPCVOID))aSyscall[40].pCurrent)
          531  +        LPCVOID))aSyscall[39].pCurrent)
   535    532   
   536    533   #if !SQLITE_OS_WINRT
   537    534     { "HeapValidate",            (SYSCALL)HeapValidate,            0 },
   538    535   #else
   539    536     { "HeapValidate",            (SYSCALL)0,                       0 },
   540    537   #endif
   541    538   
   542    539   #define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \
   543         -        LPCVOID))aSyscall[41].pCurrent)
          540  +        LPCVOID))aSyscall[40].pCurrent)
   544    541   
   545    542   #if defined(SQLITE_WIN32_HAS_ANSI)
   546    543     { "LoadLibraryA",            (SYSCALL)LoadLibraryA,            0 },
   547    544   #else
   548    545     { "LoadLibraryA",            (SYSCALL)0,                       0 },
   549    546   #endif
   550    547   
   551         -#define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[42].pCurrent)
          548  +#define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[41].pCurrent)
   552    549   
   553    550   #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)
   554    551     { "LoadLibraryW",            (SYSCALL)LoadLibraryW,            0 },
   555    552   #else
   556    553     { "LoadLibraryW",            (SYSCALL)0,                       0 },
   557    554   #endif
   558    555   
   559         -#define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[43].pCurrent)
          556  +#define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[42].pCurrent)
   560    557   
   561    558   #if !SQLITE_OS_WINRT
   562    559     { "LocalFree",               (SYSCALL)LocalFree,               0 },
   563    560   #else
   564    561     { "LocalFree",               (SYSCALL)0,                       0 },
   565    562   #endif
   566    563   
   567         -#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[44].pCurrent)
          564  +#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[43].pCurrent)
   568    565   
   569    566   #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   570    567     { "LockFile",                (SYSCALL)LockFile,                0 },
   571    568   #else
   572    569     { "LockFile",                (SYSCALL)0,                       0 },
   573    570   #endif
   574    571   
   575    572   #define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
   576         -        DWORD))aSyscall[45].pCurrent)
          573  +        DWORD))aSyscall[44].pCurrent)
   577    574   
   578    575   #if !SQLITE_OS_WINCE
   579    576     { "LockFileEx",              (SYSCALL)LockFileEx,              0 },
   580         -
   581         -#define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \
   582         -        LPOVERLAPPED))aSyscall[46].pCurrent)
   583    577   #else
   584    578     { "LockFileEx",              (SYSCALL)0,                       0 },
   585    579   #endif
          580  +
          581  +#define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \
          582  +        LPOVERLAPPED))aSyscall[45].pCurrent)
   586    583   
   587    584   #if !SQLITE_OS_WINRT
   588    585     { "MapViewOfFile",           (SYSCALL)MapViewOfFile,           0 },
   589    586   #else
   590    587     { "MapViewOfFile",           (SYSCALL)0,                       0 },
   591    588   #endif
   592    589   
   593    590   #define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
   594         -        SIZE_T))aSyscall[47].pCurrent)
          591  +        SIZE_T))aSyscall[46].pCurrent)
   595    592   
   596    593     { "MultiByteToWideChar",     (SYSCALL)MultiByteToWideChar,     0 },
   597    594   
   598    595   #define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \
   599         -        int))aSyscall[48].pCurrent)
          596  +        int))aSyscall[47].pCurrent)
   600    597   
   601    598     { "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 },
   602    599   
   603    600   #define osQueryPerformanceCounter ((BOOL(WINAPI*)( \
   604         -        LARGE_INTEGER*))aSyscall[49].pCurrent)
          601  +        LARGE_INTEGER*))aSyscall[48].pCurrent)
   605    602   
   606    603     { "ReadFile",                (SYSCALL)ReadFile,                0 },
   607    604   
   608    605   #define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \
   609         -        LPOVERLAPPED))aSyscall[50].pCurrent)
          606  +        LPOVERLAPPED))aSyscall[49].pCurrent)
   610    607   
   611    608     { "SetEndOfFile",            (SYSCALL)SetEndOfFile,            0 },
   612    609   
   613         -#define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[51].pCurrent)
          610  +#define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[50].pCurrent)
   614    611   
   615    612   #if !SQLITE_OS_WINRT
   616    613     { "SetFilePointer",          (SYSCALL)SetFilePointer,          0 },
   617    614   #else
   618    615     { "SetFilePointer",          (SYSCALL)0,                       0 },
   619    616   #endif
   620    617   
   621    618   #define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \
   622         -        DWORD))aSyscall[52].pCurrent)
          619  +        DWORD))aSyscall[51].pCurrent)
   623    620   
   624    621   #if !SQLITE_OS_WINRT
   625    622     { "Sleep",                   (SYSCALL)Sleep,                   0 },
   626    623   #else
   627    624     { "Sleep",                   (SYSCALL)0,                       0 },
   628    625   #endif
   629    626   
   630         -#define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[53].pCurrent)
          627  +#define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[52].pCurrent)
   631    628   
   632    629     { "SystemTimeToFileTime",    (SYSCALL)SystemTimeToFileTime,    0 },
   633    630   
   634    631   #define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \
   635         -        LPFILETIME))aSyscall[54].pCurrent)
          632  +        LPFILETIME))aSyscall[53].pCurrent)
   636    633   
   637    634   #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   638    635     { "UnlockFile",              (SYSCALL)UnlockFile,              0 },
   639    636   #else
   640    637     { "UnlockFile",              (SYSCALL)0,                       0 },
   641    638   #endif
   642    639   
   643    640   #define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
   644         -        DWORD))aSyscall[55].pCurrent)
          641  +        DWORD))aSyscall[54].pCurrent)
   645    642   
   646    643   #if !SQLITE_OS_WINCE
   647    644     { "UnlockFileEx",            (SYSCALL)UnlockFileEx,            0 },
   648    645   #else
   649    646     { "UnlockFileEx",            (SYSCALL)0,                       0 },
   650    647   #endif
   651    648   
   652    649   #define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
   653         -        LPOVERLAPPED))aSyscall[56].pCurrent)
          650  +        LPOVERLAPPED))aSyscall[55].pCurrent)
   654    651   
   655    652     { "UnmapViewOfFile",         (SYSCALL)UnmapViewOfFile,         0 },
   656    653   
   657         -#define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[57].pCurrent)
          654  +#define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[56].pCurrent)
   658    655   
   659    656     { "WideCharToMultiByte",     (SYSCALL)WideCharToMultiByte,     0 },
   660    657   
   661    658   #define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \
   662         -        LPCSTR,LPBOOL))aSyscall[58].pCurrent)
          659  +        LPCSTR,LPBOOL))aSyscall[57].pCurrent)
   663    660   
   664    661     { "WriteFile",               (SYSCALL)WriteFile,               0 },
   665    662   
   666    663   #define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \
   667         -        LPOVERLAPPED))aSyscall[59].pCurrent)
          664  +        LPOVERLAPPED))aSyscall[58].pCurrent)
   668    665   
   669    666   #if !SQLITE_OS_WINCE
   670    667     { "CreateEventExW",          (SYSCALL)CreateEventExW,          0 },
   671    668   #else
   672    669     { "CreateEventExW",          (SYSCALL)0,                       0 },
   673    670   #endif
   674    671   
   675    672   #define osCreateEventExW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,LPCWSTR, \
   676         -        DWORD,DWORD))aSyscall[60].pCurrent)
          673  +        DWORD,DWORD))aSyscall[59].pCurrent)
   677    674   
   678    675   #if !SQLITE_OS_WINRT
   679    676     { "WaitForSingleObject",     (SYSCALL)WaitForSingleObject,     0 },
   680    677   #else
   681    678     { "WaitForSingleObject",     (SYSCALL)0,                       0 },
   682    679   #endif
   683    680   
   684    681   #define osWaitForSingleObject ((DWORD(WINAPI*)(HANDLE, \
   685         -        DWORD))aSyscall[61].pCurrent)
          682  +        DWORD))aSyscall[60].pCurrent)
   686    683   
   687    684   #if !SQLITE_OS_WINCE
   688    685     { "WaitForSingleObjectEx",   (SYSCALL)WaitForSingleObjectEx,   0 },
   689         -
   690         -#define osWaitForSingleObjectEx ((DWORD(WINAPI*)(HANDLE,DWORD, \
   691         -        BOOL))aSyscall[62].pCurrent)
   692    686   #else
   693    687     { "WaitForSingleObjectEx",   (SYSCALL)0,                       0 },
   694    688   #endif
   695    689   
          690  +#define osWaitForSingleObjectEx ((DWORD(WINAPI*)(HANDLE,DWORD, \
          691  +        BOOL))aSyscall[61].pCurrent)
          692  +
   696    693   #if !SQLITE_OS_WINCE
   697    694     { "SetFilePointerEx",        (SYSCALL)SetFilePointerEx,        0 },
   698         -
   699         -#define osSetFilePointerEx ((BOOL(WINAPI*)(HANDLE,LARGE_INTEGER, \
   700         -        PLARGE_INTEGER,DWORD))aSyscall[63].pCurrent)
   701    695   #else
   702    696     { "SetFilePointerEx",        (SYSCALL)0,                       0 },
   703    697   #endif
   704    698   
          699  +#define osSetFilePointerEx ((BOOL(WINAPI*)(HANDLE,LARGE_INTEGER, \
          700  +        PLARGE_INTEGER,DWORD))aSyscall[62].pCurrent)
          701  +
   705    702   #if !SQLITE_OS_WINCE
   706    703     { "GetFileInformationByHandleEx", (SYSCALL)GetFileInformationByHandleEx, 0 },
   707         -
   708         -#define osGetFileInformationByHandleEx ((BOOL(WINAPI*)(HANDLE, \
   709         -        FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[64].pCurrent)
   710    704   #else
   711    705     { "GetFileInformationByHandleEx", (SYSCALL)0,                  0 },
   712    706   #endif
   713    707   
          708  +#define osGetFileInformationByHandleEx ((BOOL(WINAPI*)(HANDLE, \
          709  +        FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[63].pCurrent)
          710  +
   714    711     { "MapViewOfFileEx",         (SYSCALL)MapViewOfFileEx,         0 },
   715    712   
   716    713   #define osMapViewOfFileEx ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,SIZE_T, \
   717         -        LPVOID))aSyscall[65].pCurrent)
          714  +        LPVOID))aSyscall[64].pCurrent)
   718    715   
   719    716   #if SQLITE_OS_WINRT
   720    717     { "CreateFile2",             (SYSCALL)CreateFile2,             0 },
   721    718   #else
   722    719     { "CreateFile2",             (SYSCALL)0,                       0 },
   723    720   #endif
   724    721   
   725    722   #define osCreateFile2 ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD,DWORD, \
   726         -        LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[66].pCurrent)
          723  +        LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[65].pCurrent)
   727    724   
   728    725   #if SQLITE_OS_WINRT
   729    726     { "LoadPackagedLibrary",     (SYSCALL)LoadPackagedLibrary,     0 },
   730    727   #else
   731    728     { "LoadPackagedLibrary",     (SYSCALL)0,                       0 },
   732    729   #endif
   733    730   
   734    731   #define osLoadPackagedLibrary ((HMODULE(WINAPI*)(LPCWSTR, \
   735         -        DWORD))aSyscall[67].pCurrent)
          732  +        DWORD))aSyscall[66].pCurrent)
   736    733   
   737    734   #if SQLITE_OS_WINRT
   738    735     { "GetTickCount64",          (SYSCALL)GetTickCount64,          0 },
   739    736   #else
   740    737     { "GetTickCount64",          (SYSCALL)0,                       0 },
   741    738   #endif
   742    739   
   743         -#define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[68].pCurrent)
          740  +#define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[67].pCurrent)
   744    741   
   745    742   #if SQLITE_OS_WINRT
   746    743     { "GetNativeSystemInfo",     (SYSCALL)GetNativeSystemInfo,     0 },
   747    744   #else
   748    745     { "GetNativeSystemInfo",     (SYSCALL)0,                       0 },
   749    746   #endif
   750    747   
   751    748   #define osGetNativeSystemInfo ((VOID(WINAPI*)( \
   752         -        LPSYSTEM_INFO))aSyscall[69].pCurrent)
          749  +        LPSYSTEM_INFO))aSyscall[68].pCurrent)
   753    750   
   754    751   }; /* End of the overrideable system calls */
   755    752   
   756    753   /*
   757    754   ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
   758    755   ** "win32" VFSes.  Return SQLITE_OK opon successfully updating the
   759    756   ** system call pointer, or SQLITE_NOTFOUND if there is no configurable