/ Check-in [d5fc3f1d]
Login
SQLite training in Houston TX on 2019-11-05 (details)
Part of the 2019 Tcl Conference

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

Overview
Comment:Fix Windows SDK compiler warning.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: d5fc3f1dabc7227230dcabdd808357f63432357b
User & Date: mistachkin 2013-09-13 23:27:39
Context
2013-09-16
12:57
The date and time functions use the exact same notion of "now" for every invocation within the same call to sqlite3_step(). check-in: daf6ba41 user: drh tags: trunk
2013-09-13
23:27
Fix Windows SDK compiler warning. check-in: d5fc3f1d user: mistachkin tags: trunk
23:26
Fix test issues for Windows portability. check-in: 650b3282 user: mistachkin tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to src/os_win.c.

   678    678   #else
   679    679     { "GetVersionExA",           (SYSCALL)0,                       0 },
   680    680   #endif
   681    681   
   682    682   #define osGetVersionExA ((BOOL(WINAPI*)( \
   683    683           LPOSVERSIONINFOA))aSyscall[34].pCurrent)
   684    684   
          685  +#if defined(SQLITE_WIN32_HAS_WIDE)
          686  +  { "GetVersionExW",           (SYSCALL)GetVersionExW,           0 },
          687  +#else
          688  +  { "GetVersionExW",           (SYSCALL)0,                       0 },
          689  +#endif
          690  +
          691  +#define osGetVersionExW ((BOOL(WINAPI*)( \
          692  +        LPOSVERSIONINFOW))aSyscall[35].pCurrent)
          693  +
   685    694     { "HeapAlloc",               (SYSCALL)HeapAlloc,               0 },
   686    695   
   687    696   #define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \
   688         -        SIZE_T))aSyscall[35].pCurrent)
          697  +        SIZE_T))aSyscall[36].pCurrent)
   689    698   
   690    699   #if !SQLITE_OS_WINRT
   691    700     { "HeapCreate",              (SYSCALL)HeapCreate,              0 },
   692    701   #else
   693    702     { "HeapCreate",              (SYSCALL)0,                       0 },
   694    703   #endif
   695    704   
   696    705   #define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \
   697         -        SIZE_T))aSyscall[36].pCurrent)
          706  +        SIZE_T))aSyscall[37].pCurrent)
   698    707   
   699    708   #if !SQLITE_OS_WINRT
   700    709     { "HeapDestroy",             (SYSCALL)HeapDestroy,             0 },
   701    710   #else
   702    711     { "HeapDestroy",             (SYSCALL)0,                       0 },
   703    712   #endif
   704    713   
   705         -#define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[37].pCurrent)
          714  +#define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[38].pCurrent)
   706    715   
   707    716     { "HeapFree",                (SYSCALL)HeapFree,                0 },
   708    717   
   709         -#define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[38].pCurrent)
          718  +#define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[39].pCurrent)
   710    719   
   711    720     { "HeapReAlloc",             (SYSCALL)HeapReAlloc,             0 },
   712    721   
   713    722   #define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \
   714         -        SIZE_T))aSyscall[39].pCurrent)
          723  +        SIZE_T))aSyscall[40].pCurrent)
   715    724   
   716    725     { "HeapSize",                (SYSCALL)HeapSize,                0 },
   717    726   
   718    727   #define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \
   719         -        LPCVOID))aSyscall[40].pCurrent)
          728  +        LPCVOID))aSyscall[41].pCurrent)
   720    729   
   721    730   #if !SQLITE_OS_WINRT
   722    731     { "HeapValidate",            (SYSCALL)HeapValidate,            0 },
   723    732   #else
   724    733     { "HeapValidate",            (SYSCALL)0,                       0 },
   725    734   #endif
   726    735   
   727    736   #define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \
   728         -        LPCVOID))aSyscall[41].pCurrent)
          737  +        LPCVOID))aSyscall[42].pCurrent)
   729    738   
   730    739   #if defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
   731    740     { "LoadLibraryA",            (SYSCALL)LoadLibraryA,            0 },
   732    741   #else
   733    742     { "LoadLibraryA",            (SYSCALL)0,                       0 },
   734    743   #endif
   735    744   
   736         -#define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[42].pCurrent)
          745  +#define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[43].pCurrent)
   737    746   
   738    747   #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \
   739    748           !defined(SQLITE_OMIT_LOAD_EXTENSION)
   740    749     { "LoadLibraryW",            (SYSCALL)LoadLibraryW,            0 },
   741    750   #else
   742    751     { "LoadLibraryW",            (SYSCALL)0,                       0 },
   743    752   #endif
   744    753   
   745         -#define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[43].pCurrent)
          754  +#define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[44].pCurrent)
   746    755   
   747    756   #if !SQLITE_OS_WINRT
   748    757     { "LocalFree",               (SYSCALL)LocalFree,               0 },
   749    758   #else
   750    759     { "LocalFree",               (SYSCALL)0,                       0 },
   751    760   #endif
   752    761   
   753         -#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[44].pCurrent)
          762  +#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[45].pCurrent)
   754    763   
   755    764   #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   756    765     { "LockFile",                (SYSCALL)LockFile,                0 },
   757    766   #else
   758    767     { "LockFile",                (SYSCALL)0,                       0 },
   759    768   #endif
   760    769   
   761    770   #ifndef osLockFile
   762    771   #define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
   763         -        DWORD))aSyscall[45].pCurrent)
          772  +        DWORD))aSyscall[46].pCurrent)
   764    773   #endif
   765    774   
   766    775   #if !SQLITE_OS_WINCE
   767    776     { "LockFileEx",              (SYSCALL)LockFileEx,              0 },
   768    777   #else
   769    778     { "LockFileEx",              (SYSCALL)0,                       0 },
   770    779   #endif
   771    780   
   772    781   #ifndef osLockFileEx
   773    782   #define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \
   774         -        LPOVERLAPPED))aSyscall[46].pCurrent)
          783  +        LPOVERLAPPED))aSyscall[47].pCurrent)
   775    784   #endif
   776    785   
   777    786   #if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && !defined(SQLITE_OMIT_WAL))
   778    787     { "MapViewOfFile",           (SYSCALL)MapViewOfFile,           0 },
   779    788   #else
   780    789     { "MapViewOfFile",           (SYSCALL)0,                       0 },
   781    790   #endif
   782    791   
   783    792   #define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
   784         -        SIZE_T))aSyscall[47].pCurrent)
          793  +        SIZE_T))aSyscall[48].pCurrent)
   785    794   
   786    795     { "MultiByteToWideChar",     (SYSCALL)MultiByteToWideChar,     0 },
   787    796   
   788    797   #define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \
   789         -        int))aSyscall[48].pCurrent)
          798  +        int))aSyscall[49].pCurrent)
   790    799   
   791    800     { "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 },
   792    801   
   793    802   #define osQueryPerformanceCounter ((BOOL(WINAPI*)( \
   794         -        LARGE_INTEGER*))aSyscall[49].pCurrent)
          803  +        LARGE_INTEGER*))aSyscall[50].pCurrent)
   795    804   
   796    805     { "ReadFile",                (SYSCALL)ReadFile,                0 },
   797    806   
   798    807   #define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \
   799         -        LPOVERLAPPED))aSyscall[50].pCurrent)
          808  +        LPOVERLAPPED))aSyscall[51].pCurrent)
   800    809   
   801    810     { "SetEndOfFile",            (SYSCALL)SetEndOfFile,            0 },
   802    811   
   803         -#define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[51].pCurrent)
          812  +#define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[52].pCurrent)
   804    813   
   805    814   #if !SQLITE_OS_WINRT
   806    815     { "SetFilePointer",          (SYSCALL)SetFilePointer,          0 },
   807    816   #else
   808    817     { "SetFilePointer",          (SYSCALL)0,                       0 },
   809    818   #endif
   810    819   
   811    820   #define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \
   812         -        DWORD))aSyscall[52].pCurrent)
          821  +        DWORD))aSyscall[53].pCurrent)
   813    822   
   814    823   #if !SQLITE_OS_WINRT
   815    824     { "Sleep",                   (SYSCALL)Sleep,                   0 },
   816    825   #else
   817    826     { "Sleep",                   (SYSCALL)0,                       0 },
   818    827   #endif
   819    828   
   820         -#define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[53].pCurrent)
          829  +#define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[54].pCurrent)
   821    830   
   822    831     { "SystemTimeToFileTime",    (SYSCALL)SystemTimeToFileTime,    0 },
   823    832   
   824    833   #define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \
   825         -        LPFILETIME))aSyscall[54].pCurrent)
          834  +        LPFILETIME))aSyscall[55].pCurrent)
   826    835   
   827    836   #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   828    837     { "UnlockFile",              (SYSCALL)UnlockFile,              0 },
   829    838   #else
   830    839     { "UnlockFile",              (SYSCALL)0,                       0 },
   831    840   #endif
   832    841   
   833    842   #ifndef osUnlockFile
   834    843   #define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
   835         -        DWORD))aSyscall[55].pCurrent)
          844  +        DWORD))aSyscall[56].pCurrent)
   836    845   #endif
   837    846   
   838    847   #if !SQLITE_OS_WINCE
   839    848     { "UnlockFileEx",            (SYSCALL)UnlockFileEx,            0 },
   840    849   #else
   841    850     { "UnlockFileEx",            (SYSCALL)0,                       0 },
   842    851   #endif
   843    852   
   844    853   #define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
   845         -        LPOVERLAPPED))aSyscall[56].pCurrent)
          854  +        LPOVERLAPPED))aSyscall[57].pCurrent)
   846    855   
   847    856   #if SQLITE_OS_WINCE || !defined(SQLITE_OMIT_WAL)
   848    857     { "UnmapViewOfFile",         (SYSCALL)UnmapViewOfFile,         0 },
   849    858   #else
   850    859     { "UnmapViewOfFile",         (SYSCALL)0,                       0 },
   851    860   #endif
   852    861   
   853         -#define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[57].pCurrent)
          862  +#define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[58].pCurrent)
   854    863   
   855    864     { "WideCharToMultiByte",     (SYSCALL)WideCharToMultiByte,     0 },
   856    865   
   857    866   #define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \
   858         -        LPCSTR,LPBOOL))aSyscall[58].pCurrent)
          867  +        LPCSTR,LPBOOL))aSyscall[59].pCurrent)
   859    868   
   860    869     { "WriteFile",               (SYSCALL)WriteFile,               0 },
   861    870   
   862    871   #define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \
   863         -        LPOVERLAPPED))aSyscall[59].pCurrent)
          872  +        LPOVERLAPPED))aSyscall[60].pCurrent)
   864    873   
   865    874   #if SQLITE_OS_WINRT
   866    875     { "CreateEventExW",          (SYSCALL)CreateEventExW,          0 },
   867    876   #else
   868    877     { "CreateEventExW",          (SYSCALL)0,                       0 },
   869    878   #endif
   870    879   
   871    880   #define osCreateEventExW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,LPCWSTR, \
   872         -        DWORD,DWORD))aSyscall[60].pCurrent)
          881  +        DWORD,DWORD))aSyscall[61].pCurrent)
   873    882   
   874    883   #if !SQLITE_OS_WINRT
   875    884     { "WaitForSingleObject",     (SYSCALL)WaitForSingleObject,     0 },
   876    885   #else
   877    886     { "WaitForSingleObject",     (SYSCALL)0,                       0 },
   878    887   #endif
   879    888   
   880    889   #define osWaitForSingleObject ((DWORD(WINAPI*)(HANDLE, \
   881         -        DWORD))aSyscall[61].pCurrent)
          890  +        DWORD))aSyscall[62].pCurrent)
   882    891   
   883    892   #if SQLITE_OS_WINRT
   884    893     { "WaitForSingleObjectEx",   (SYSCALL)WaitForSingleObjectEx,   0 },
   885    894   #else
   886    895     { "WaitForSingleObjectEx",   (SYSCALL)0,                       0 },
   887    896   #endif
   888    897   
   889    898   #define osWaitForSingleObjectEx ((DWORD(WINAPI*)(HANDLE,DWORD, \
   890         -        BOOL))aSyscall[62].pCurrent)
          899  +        BOOL))aSyscall[63].pCurrent)
   891    900   
   892    901   #if SQLITE_OS_WINRT
   893    902     { "SetFilePointerEx",        (SYSCALL)SetFilePointerEx,        0 },
   894    903   #else
   895    904     { "SetFilePointerEx",        (SYSCALL)0,                       0 },
   896    905   #endif
   897    906   
   898    907   #define osSetFilePointerEx ((BOOL(WINAPI*)(HANDLE,LARGE_INTEGER, \
   899         -        PLARGE_INTEGER,DWORD))aSyscall[63].pCurrent)
          908  +        PLARGE_INTEGER,DWORD))aSyscall[64].pCurrent)
   900    909   
   901    910   #if SQLITE_OS_WINRT
   902    911     { "GetFileInformationByHandleEx", (SYSCALL)GetFileInformationByHandleEx, 0 },
   903    912   #else
   904    913     { "GetFileInformationByHandleEx", (SYSCALL)0,                  0 },
   905    914   #endif
   906    915   
   907    916   #define osGetFileInformationByHandleEx ((BOOL(WINAPI*)(HANDLE, \
   908         -        FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[64].pCurrent)
          917  +        FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[65].pCurrent)
   909    918   
   910    919   #if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_WAL)
   911    920     { "MapViewOfFileFromApp",    (SYSCALL)MapViewOfFileFromApp,    0 },
   912    921   #else
   913    922     { "MapViewOfFileFromApp",    (SYSCALL)0,                       0 },
   914    923   #endif
   915    924   
   916    925   #define osMapViewOfFileFromApp ((LPVOID(WINAPI*)(HANDLE,ULONG,ULONG64, \
   917         -        SIZE_T))aSyscall[65].pCurrent)
          926  +        SIZE_T))aSyscall[66].pCurrent)
   918    927   
   919    928   #if SQLITE_OS_WINRT
   920    929     { "CreateFile2",             (SYSCALL)CreateFile2,             0 },
   921    930   #else
   922    931     { "CreateFile2",             (SYSCALL)0,                       0 },
   923    932   #endif
   924    933   
   925    934   #define osCreateFile2 ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD,DWORD, \
   926         -        LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[66].pCurrent)
          935  +        LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[67].pCurrent)
   927    936   
   928    937   #if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_LOAD_EXTENSION)
   929    938     { "LoadPackagedLibrary",     (SYSCALL)LoadPackagedLibrary,     0 },
   930    939   #else
   931    940     { "LoadPackagedLibrary",     (SYSCALL)0,                       0 },
   932    941   #endif
   933    942   
   934    943   #define osLoadPackagedLibrary ((HMODULE(WINAPI*)(LPCWSTR, \
   935         -        DWORD))aSyscall[67].pCurrent)
          944  +        DWORD))aSyscall[68].pCurrent)
   936    945   
   937    946   #if SQLITE_OS_WINRT
   938    947     { "GetTickCount64",          (SYSCALL)GetTickCount64,          0 },
   939    948   #else
   940    949     { "GetTickCount64",          (SYSCALL)0,                       0 },
   941    950   #endif
   942    951   
   943         -#define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[68].pCurrent)
          952  +#define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[69].pCurrent)
   944    953   
   945    954   #if SQLITE_OS_WINRT
   946    955     { "GetNativeSystemInfo",     (SYSCALL)GetNativeSystemInfo,     0 },
   947    956   #else
   948    957     { "GetNativeSystemInfo",     (SYSCALL)0,                       0 },
   949    958   #endif
   950    959   
   951    960   #define osGetNativeSystemInfo ((VOID(WINAPI*)( \
   952         -        LPSYSTEM_INFO))aSyscall[69].pCurrent)
          961  +        LPSYSTEM_INFO))aSyscall[70].pCurrent)
   953    962   
   954    963   #if defined(SQLITE_WIN32_HAS_ANSI)
   955    964     { "OutputDebugStringA",      (SYSCALL)OutputDebugStringA,      0 },
   956    965   #else
   957    966     { "OutputDebugStringA",      (SYSCALL)0,                       0 },
   958    967   #endif
   959    968   
   960         -#define osOutputDebugStringA ((VOID(WINAPI*)(LPCSTR))aSyscall[70].pCurrent)
          969  +#define osOutputDebugStringA ((VOID(WINAPI*)(LPCSTR))aSyscall[71].pCurrent)
   961    970   
   962    971   #if defined(SQLITE_WIN32_HAS_WIDE)
   963    972     { "OutputDebugStringW",      (SYSCALL)OutputDebugStringW,      0 },
   964    973   #else
   965    974     { "OutputDebugStringW",      (SYSCALL)0,                       0 },
   966    975   #endif
   967    976   
   968         -#define osOutputDebugStringW ((VOID(WINAPI*)(LPCWSTR))aSyscall[71].pCurrent)
          977  +#define osOutputDebugStringW ((VOID(WINAPI*)(LPCWSTR))aSyscall[72].pCurrent)
   969    978   
   970    979     { "GetProcessHeap",          (SYSCALL)GetProcessHeap,          0 },
   971    980   
   972         -#define osGetProcessHeap ((HANDLE(WINAPI*)(VOID))aSyscall[72].pCurrent)
          981  +#define osGetProcessHeap ((HANDLE(WINAPI*)(VOID))aSyscall[73].pCurrent)
   973    982   
   974    983   #if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_WAL)
   975    984     { "CreateFileMappingFromApp", (SYSCALL)CreateFileMappingFromApp, 0 },
   976    985   #else
   977    986     { "CreateFileMappingFromApp", (SYSCALL)0,                      0 },
   978    987   #endif
   979    988   
   980    989   #define osCreateFileMappingFromApp ((HANDLE(WINAPI*)(HANDLE, \
   981         -        LPSECURITY_ATTRIBUTES,ULONG,ULONG64,LPCWSTR))aSyscall[73].pCurrent)
          990  +        LPSECURITY_ATTRIBUTES,ULONG,ULONG64,LPCWSTR))aSyscall[74].pCurrent)
   982    991   
   983    992   }; /* End of the overrideable system calls */
   984    993   
   985    994   /*
   986    995   ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
   987    996   ** "win32" VFSes.  Return SQLITE_OK opon successfully updating the
   988    997   ** system call pointer, or SQLITE_NOTFOUND if there is no configurable
................................................................................
  1130   1139   ** Here is an interesting observation:  Win95, Win98, and WinME lack
  1131   1140   ** the LockFileEx() API.  But we can still statically link against that
  1132   1141   ** API as long as we don't call it when running Win95/98/ME.  A call to
  1133   1142   ** this routine is used to determine if the host is Win95/98/ME or
  1134   1143   ** WinNT/2K/XP so that we will know whether or not we can safely call
  1135   1144   ** the LockFileEx() API.
  1136   1145   */
         1146  +#ifndef NTDDI_WIN8
         1147  +#  define NTDDI_WIN8                        0x06020000
         1148  +#endif
         1149  +
  1137   1150   #if SQLITE_OS_WINCE || SQLITE_OS_WINRT || !defined(SQLITE_WIN32_HAS_ANSI)
  1138   1151   # define osIsNT()  (1)
  1139   1152   #elif !defined(SQLITE_WIN32_HAS_WIDE)
  1140   1153   # define osIsNT()  (0)
  1141   1154   #else
  1142   1155     static int osIsNT(void){
  1143   1156       if( sqlite3_os_type==0 ){
         1157  +#if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WIN8
         1158  +      OSVERSIONINFOW sInfo;
         1159  +      sInfo.dwOSVersionInfoSize = sizeof(sInfo);
         1160  +      osGetVersionExW(&sInfo);
         1161  +#else
  1144   1162         OSVERSIONINFOA sInfo;
  1145   1163         sInfo.dwOSVersionInfoSize = sizeof(sInfo);
  1146   1164         osGetVersionExA(&sInfo);
         1165  +#endif
  1147   1166         sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
  1148   1167       }
  1149   1168       return sqlite3_os_type==2;
  1150   1169     }
  1151   1170   #endif
  1152   1171   
  1153   1172   #ifdef SQLITE_WIN32_MALLOC
................................................................................
  5162   5181       winGetSystemCall,    /* xGetSystemCall */
  5163   5182       winNextSystemCall,   /* xNextSystemCall */
  5164   5183     };
  5165   5184   #endif
  5166   5185   
  5167   5186     /* Double-check that the aSyscall[] array has been constructed
  5168   5187     ** correctly.  See ticket [bb3a86e890c8e96ab] */
  5169         -  assert( ArraySize(aSyscall)==74 );
         5188  +  assert( ArraySize(aSyscall)==75 );
  5170   5189   
  5171   5190     /* get memory map allocation granularity */
  5172   5191     memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));
  5173   5192   #if SQLITE_OS_WINRT
  5174   5193     osGetNativeSystemInfo(&winSysInfo);
  5175   5194   #else
  5176   5195     osGetSystemInfo(&winSysInfo);