/*

** 2004 May 22

**

** 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 code that is specific to Windows.

*/

#include "sqliteInt.h"

#if SQLITE_OS_WIN /* This file is used for Windows only */

/*

** Include code that is common to all os_*.c files

*/

#include "os_common.h"

/*

** Include the header file for the Windows VFS.

*/

#include "os_win.h"

/*

** Compiling and using WAL mode requires several APIs that are only

** available in Windows platforms based on the NT kernel.

*/

#if !SQLITE_OS_WINNT && !defined(SQLITE_OMIT_WAL)

# error "WAL mode requires support from the Windows NT kernel, compile\

with SQLITE_OMIT_WAL."

#endif

#if !SQLITE_OS_WINNT && SQLITE_MAX_MMAP_SIZE>0

# error "Memory mapped files require support from the Windows NT kernel,\

compile with SQLITE_MAX_MMAP_SIZE=0."

#endif

/*

** Are most of the Win32 ANSI APIs available (i.e. with certain exceptions

** based on the sub-platform)?

*/

#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(SQLITE_WIN32_NO_ANSI)

# define SQLITE_WIN32_HAS_ANSI

#endif

/*

** Are most of the Win32 Unicode APIs available (i.e. with certain exceptions

** based on the sub-platform)?

*/

#if (SQLITE_OS_WINCE || SQLITE_OS_WINNT || SQLITE_OS_WINRT) && \

!defined(SQLITE_WIN32_NO_WIDE)

# define SQLITE_WIN32_HAS_WIDE

#endif

/*

** Make sure at least one set of Win32 APIs is available.

*/

#if !defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_WIN32_HAS_WIDE)

# error "At least one of SQLITE_WIN32_HAS_ANSI and SQLITE_WIN32_HAS_WIDE\

must be defined."

#endif

/*

** Define the required Windows SDK version constants if they are not

** already available.

*/

#ifndef NTDDI_WIN8

# define NTDDI_WIN8 0x06020000

#endif

#ifndef NTDDI_WINBLUE

# define NTDDI_WINBLUE 0x06030000

#endif

#ifndef NTDDI_WINTHRESHOLD

# define NTDDI_WINTHRESHOLD 0x06040000

#endif

/*

** Check to see if the GetVersionEx[AW] functions are deprecated on the

** target system. GetVersionEx was first deprecated in Win8.1.

*/

#ifndef SQLITE_WIN32_GETVERSIONEX

# if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINBLUE

# define SQLITE_WIN32_GETVERSIONEX 0 /* GetVersionEx() is deprecated */

# else

# define SQLITE_WIN32_GETVERSIONEX 1 /* GetVersionEx() is current */

# endif

#endif

/*

** Check to see if the CreateFileMappingA function is supported on the

** target system. It is unavailable when using "mincore.lib" on Win10.

** When compiling for Windows 10, always assume "mincore.lib" is in use.

*/

#ifndef SQLITE_WIN32_CREATEFILEMAPPINGA

# if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINTHRESHOLD

# define SQLITE_WIN32_CREATEFILEMAPPINGA 0

# else

# define SQLITE_WIN32_CREATEFILEMAPPINGA 1

# endif

#endif

/*

** This constant should already be defined (in the "WinDef.h" SDK file).

*/

#ifndef MAX_PATH

# define MAX_PATH (260)

#endif

/*

** Maximum pathname length (in chars) for Win32. This should normally be

** MAX_PATH.

*/

#ifndef SQLITE_WIN32_MAX_PATH_CHARS

# define SQLITE_WIN32_MAX_PATH_CHARS (MAX_PATH)

#endif

/*

** This constant should already be defined (in the "WinNT.h" SDK file).

*/

#ifndef UNICODE_STRING_MAX_CHARS

# define UNICODE_STRING_MAX_CHARS (32767)

#endif

/*

** Maximum pathname length (in chars) for WinNT. This should normally be

** UNICODE_STRING_MAX_CHARS.

*/

#ifndef SQLITE_WINNT_MAX_PATH_CHARS

# define SQLITE_WINNT_MAX_PATH_CHARS (UNICODE_STRING_MAX_CHARS)

#endif

/*

** Maximum pathname length (in bytes) for Win32. The MAX_PATH macro is in

** characters, so we allocate 4 bytes per character assuming worst-case of

** 4-bytes-per-character for UTF8.

*/

#ifndef SQLITE_WIN32_MAX_PATH_BYTES

# define SQLITE_WIN32_MAX_PATH_BYTES (SQLITE_WIN32_MAX_PATH_CHARS*4)

#endif

/*

** Maximum pathname length (in bytes) for WinNT. This should normally be

** UNICODE_STRING_MAX_CHARS * sizeof(WCHAR).

*/

#ifndef SQLITE_WINNT_MAX_PATH_BYTES

# define SQLITE_WINNT_MAX_PATH_BYTES \

(sizeof(WCHAR) * SQLITE_WINNT_MAX_PATH_CHARS)

#endif

/*

** Maximum error message length (in chars) for WinRT.

*/

#ifndef SQLITE_WIN32_MAX_ERRMSG_CHARS

# define SQLITE_WIN32_MAX_ERRMSG_CHARS (1024)

#endif

/*

** Returns non-zero if the character should be treated as a directory

** separator.

*/

#ifndef winIsDirSep

# define winIsDirSep(a) (((a) == '/') || ((a) == '\\'))

#endif

/*

** This macro is used when a local variable is set to a value that is

** [sometimes] not used by the code (e.g. via conditional compilation).

*/

#ifndef UNUSED_VARIABLE_VALUE

# define UNUSED_VARIABLE_VALUE(x) (void)(x)

#endif

/*

** Returns the character that should be used as the directory separator.

*/

#ifndef winGetDirSep

# define winGetDirSep() '\\'

#endif

/*

** Do we need to manually define the Win32 file mapping APIs for use with WAL

** mode or memory mapped files (e.g. these APIs are available in the Windows

** CE SDK; however, they are not present in the header file)?

*/

#if SQLITE_WIN32_FILEMAPPING_API && \

(!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)

/*

** Two of the file mapping APIs are different under WinRT. Figure out which

** set we need.

*/

#if SQLITE_OS_WINRT

WINBASEAPI HANDLE WINAPI CreateFileMappingFromApp(HANDLE, \

LPSECURITY_ATTRIBUTES, ULONG, ULONG64, LPCWSTR);

WINBASEAPI LPVOID WINAPI MapViewOfFileFromApp(HANDLE, ULONG, ULONG64, SIZE_T);

#else

#if defined(SQLITE_WIN32_HAS_ANSI)

WINBASEAPI HANDLE WINAPI CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, \

DWORD, DWORD, DWORD, LPCSTR);

#endif /* defined(SQLITE_WIN32_HAS_ANSI) */

#if defined(SQLITE_WIN32_HAS_WIDE)

WINBASEAPI HANDLE WINAPI CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, \

DWORD, DWORD, DWORD, LPCWSTR);

#endif /* defined(SQLITE_WIN32_HAS_WIDE) */

WINBASEAPI LPVOID WINAPI MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T);

#endif /* SQLITE_OS_WINRT */

/*

** These file mapping APIs are common to both Win32 and WinRT.

*/

WINBASEAPI BOOL WINAPI FlushViewOfFile(LPCVOID, SIZE_T);

WINBASEAPI BOOL WINAPI UnmapViewOfFile(LPCVOID);

#endif /* SQLITE_WIN32_FILEMAPPING_API */

/*

** Some Microsoft compilers lack this definition.

*/

#ifndef INVALID_FILE_ATTRIBUTES

# define INVALID_FILE_ATTRIBUTES ((DWORD)-1)

#endif

#ifndef FILE_FLAG_MASK

# define FILE_FLAG_MASK (0xFF3C0000)

#endif

#ifndef FILE_ATTRIBUTE_MASK

# define FILE_ATTRIBUTE_MASK (0x0003FFF7)

#endif

#ifndef SQLITE_OMIT_WAL

/* Forward references to structures used for WAL */

typedef struct winShm winShm; /* A connection to shared-memory */

typedef struct winShmNode winShmNode; /* A region of shared-memory */

#endif

/*

** WinCE lacks native support for file locking so we have to fake it

** with some code of our own.

*/

#if SQLITE_OS_WINCE

typedef struct winceLock {

int nReaders; /* Number of reader locks obtained */

BOOL bPending; /* Indicates a pending lock has been obtained */

BOOL bReserved; /* Indicates a reserved lock has been obtained */

BOOL bExclusive; /* Indicates an exclusive lock has been obtained */

} winceLock;

#endif

/*

** The winFile structure is a subclass of sqlite3_file* specific to the win32

** portability layer.

*/

typedef struct winFile winFile;

struct winFile {

const sqlite3_io_methods *pMethod; /*** Must be first ***/

sqlite3_vfs *pVfs; /* The VFS used to open this file */

HANDLE h; /* Handle for accessing the file */

u8 locktype; /* Type of lock currently held on this file */

short sharedLockByte; /* Randomly chosen byte used as a shared lock */

u8 ctrlFlags; /* Flags. See WINFILE_* below */

DWORD lastErrno; /* The Windows errno from the last I/O error */

#ifndef SQLITE_OMIT_WAL

winShm *pShm; /* Instance of shared memory on this file */

#endif

const char *zPath; /* Full pathname of this file */

int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */

#if SQLITE_OS_WINCE

LPWSTR zDeleteOnClose; /* Name of file to delete when closing */

HANDLE hMutex; /* Mutex used to control access to shared lock */

HANDLE hShared; /* Shared memory segment used for locking */

winceLock local; /* Locks obtained by this instance of winFile */

winceLock *shared; /* Global shared lock memory for the file */

#endif

#if SQLITE_MAX_MMAP_SIZE>0

int nFetchOut; /* Number of outstanding xFetch references */

HANDLE hMap; /* Handle for accessing memory mapping */

void *pMapRegion; /* Area memory mapped */

sqlite3_int64 mmapSize; /* Size of mapped region */

sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */

#endif

};

/*

** The winVfsAppData structure is used for the pAppData member for all of the

** Win32 VFS variants.

*/

typedef struct winVfsAppData winVfsAppData;

struct winVfsAppData {

const sqlite3_io_methods *pMethod; /* The file I/O methods to use. */

void *pAppData; /* The extra pAppData, if any. */

BOOL bNoLock; /* Non-zero if locking is disabled. */

};

/*

** Allowed values for winFile.ctrlFlags

*/

#define WINFILE_RDONLY 0x02 /* Connection is read only */

#define WINFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */

#define WINFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */

/*

* The size of the buffer used by sqlite3_win32_write_debug().

*/

#ifndef SQLITE_WIN32_DBG_BUF_SIZE

# define SQLITE_WIN32_DBG_BUF_SIZE ((int)(4096-sizeof(DWORD)))

#endif

/*

* If compiled with SQLITE_WIN32_MALLOC on Windows, we will use the

* various Win32 API heap functions instead of our own.

*/

#ifdef SQLITE_WIN32_MALLOC

/*

* If this is non-zero, an isolated heap will be created by the native Win32

* allocator subsystem; otherwise, the default process heap will be used. This

* setting has no effect when compiling for WinRT. By default, this is enabled

* and an isolated heap will be created to store all allocated data.

*

******************************************************************************

* WARNING: It is important to note that when this setting is non-zero and the

* winMemShutdown function is called (e.g. by the sqlite3_shutdown

* function), all data that was allocated using the isolated heap will

* be freed immediately and any attempt to access any of that freed

* data will almost certainly result in an immediate access violation.

******************************************************************************

*/

#ifndef SQLITE_WIN32_HEAP_CREATE

# define SQLITE_WIN32_HEAP_CREATE (TRUE)

#endif

/*

* This is the maximum possible initial size of the Win32-specific heap, in

* bytes.

*/

#ifndef SQLITE_WIN32_HEAP_MAX_INIT_SIZE

# define SQLITE_WIN32_HEAP_MAX_INIT_SIZE (4294967295U)

#endif

/*

* This is the extra space for the initial size of the Win32-specific heap,

* in bytes. This value may be zero.

*/

#ifndef SQLITE_WIN32_HEAP_INIT_EXTRA

# define SQLITE_WIN32_HEAP_INIT_EXTRA (4194304)

#endif

/*

* Calculate the maximum legal cache size, in pages, based on the maximum

* possible initial heap size and the default page size, setting aside the

* needed extra space.

*/

#ifndef SQLITE_WIN32_MAX_CACHE_SIZE

# define SQLITE_WIN32_MAX_CACHE_SIZE (((SQLITE_WIN32_HEAP_MAX_INIT_SIZE) - \

(SQLITE_WIN32_HEAP_INIT_EXTRA)) / \

(SQLITE_DEFAULT_PAGE_SIZE))

#endif

/*

* This is cache size used in the calculation of the initial size of the

* Win32-specific heap. It cannot be negative.

*/

#ifndef SQLITE_WIN32_CACHE_SIZE

# if SQLITE_DEFAULT_CACHE_SIZE>=0

# define SQLITE_WIN32_CACHE_SIZE (SQLITE_DEFAULT_CACHE_SIZE)

# else

# define SQLITE_WIN32_CACHE_SIZE (-(SQLITE_DEFAULT_CACHE_SIZE))

# endif

#endif

/*

* Make sure that the calculated cache size, in pages, cannot cause the

* initial size of the Win32-specific heap to exceed the maximum amount

* of memory that can be specified in the call to HeapCreate.

*/

#if SQLITE_WIN32_CACHE_SIZE>SQLITE_WIN32_MAX_CACHE_SIZE

# undef SQLITE_WIN32_CACHE_SIZE

# define SQLITE_WIN32_CACHE_SIZE (2000)

#endif

/*

* The initial size of the Win32-specific heap. This value may be zero.

*/

#ifndef SQLITE_WIN32_HEAP_INIT_SIZE

# define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_WIN32_CACHE_SIZE) * \

(SQLITE_DEFAULT_PAGE_SIZE) + \

(SQLITE_WIN32_HEAP_INIT_EXTRA))

#endif

/*

* The maximum size of the Win32-specific heap. This value may be zero.

*/

#ifndef SQLITE_WIN32_HEAP_MAX_SIZE

# define SQLITE_WIN32_HEAP_MAX_SIZE (0)

#endif

/*

* The extra flags to use in calls to the Win32 heap APIs. This value may be

* zero for the default behavior.

*/

#ifndef SQLITE_WIN32_HEAP_FLAGS

# define SQLITE_WIN32_HEAP_FLAGS (0)

#endif

/*

** The winMemData structure stores information required by the Win32-specific

** sqlite3_mem_methods implementation.

*/

typedef struct winMemData winMemData;

struct winMemData {

#ifndef NDEBUG

u32 magic1; /* Magic number to detect structure corruption. */

#endif

HANDLE hHeap; /* The handle to our heap. */

BOOL bOwned; /* Do we own the heap (i.e. destroy it on shutdown)? */

#ifndef NDEBUG

u32 magic2; /* Magic number to detect structure corruption. */

#endif

};

#ifndef NDEBUG

#define WINMEM_MAGIC1 0x42b2830b

#define WINMEM_MAGIC2 0xbd4d7cf4

#endif

static struct winMemData win_mem_data = {

#ifndef NDEBUG

WINMEM_MAGIC1,

#endif

NULL, FALSE

#ifndef NDEBUG

,WINMEM_MAGIC2

#endif

};

#ifndef NDEBUG

#define winMemAssertMagic1() assert( win_mem_data.magic1==WINMEM_MAGIC1 )

#define winMemAssertMagic2() assert( win_mem_data.magic2==WINMEM_MAGIC2 )

#define winMemAssertMagic() winMemAssertMagic1(); winMemAssertMagic2();

#else

#define winMemAssertMagic()

#endif

#define winMemGetDataPtr() &win_mem_data

#define winMemGetHeap() win_mem_data.hHeap

#define winMemGetOwned() win_mem_data.bOwned

static void *winMemMalloc(int nBytes);

static void winMemFree(void *pPrior);

static void *winMemRealloc(void *pPrior, int nBytes);

static int winMemSize(void *p);

static int winMemRoundup(int n);

static int winMemInit(void *pAppData);

static void winMemShutdown(void *pAppData);

const sqlite3_mem_methods *sqlite3MemGetWin32(void);

#endif /* SQLITE_WIN32_MALLOC */

/*

** The following variable is (normally) set once and never changes

** thereafter. It records whether the operating system is Win9x

** or WinNT.

**

** 0: Operating system unknown.

** 1: Operating system is Win9x.

** 2: Operating system is WinNT.

**

** In order to facilitate testing on a WinNT system, the test fixture

** can manually set this value to 1 to emulate Win98 behavior.

*/

#ifdef SQLITE_TEST

LONG SQLITE_WIN32_VOLATILE sqlite3_os_type = 0;

#else

static LONG SQLITE_WIN32_VOLATILE sqlite3_os_type = 0;

#endif

#ifndef SYSCALL

# define SYSCALL sqlite3_syscall_ptr

#endif

/*

** This function is not available on Windows CE or WinRT.

*/

#if SQLITE_OS_WINCE || SQLITE_OS_WINRT

# define osAreFileApisANSI() 1

#endif

/*

** Many system calls are accessed through pointer-to-functions so that

** they may be overridden at runtime to facilitate fault injection during

** testing and sandboxing. The following array holds the names and pointers

** to all overrideable system calls.

*/

static struct win_syscall {

const char *zName; /* Name of the system call */

sqlite3_syscall_ptr pCurrent; /* Current value of the system call */

sqlite3_syscall_ptr pDefault; /* Default value */

} aSyscall[] = {

#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT

{ "AreFileApisANSI", (SYSCALL)AreFileApisANSI, 0 },

#else

{ "AreFileApisANSI", (SYSCALL)0, 0 },

#endif

#ifndef osAreFileApisANSI

#define osAreFileApisANSI ((BOOL(WINAPI*)(VOID))aSyscall[0].pCurrent)

#endif

#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)

{ "CharLowerW", (SYSCALL)CharLowerW, 0 },

#else

{ "CharLowerW", (SYSCALL)0, 0 },

#endif

#define osCharLowerW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[1].pCurrent)

#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)

{ "CharUpperW", (SYSCALL)CharUpperW, 0 },

#else

{ "CharUpperW", (SYSCALL)0, 0 },

#endif

#define osCharUpperW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[2].pCurrent)

{ "CloseHandle", (SYSCALL)CloseHandle, 0 },

#define osCloseHandle ((BOOL(WINAPI*)(HANDLE))aSyscall[3].pCurrent)

#if defined(SQLITE_WIN32_HAS_ANSI)

{ "CreateFileA", (SYSCALL)CreateFileA, 0 },

#else

{ "CreateFileA", (SYSCALL)0, 0 },

#endif

#define osCreateFileA ((HANDLE(WINAPI*)(LPCSTR,DWORD,DWORD, \

LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[4].pCurrent)

#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)

{ "CreateFileW", (SYSCALL)CreateFileW, 0 },

#else

{ "CreateFileW", (SYSCALL)0, 0 },

#endif

#define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \

LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent)

#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_ANSI) && \

(!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) && \

SQLITE_WIN32_CREATEFILEMAPPINGA

{ "CreateFileMappingA", (SYSCALL)CreateFileMappingA, 0 },

#else

{ "CreateFileMappingA", (SYSCALL)0, 0 },

#endif

#define osCreateFileMappingA ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \

DWORD,DWORD,DWORD,LPCSTR))aSyscall[6].pCurrent)

#if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \

(!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0))

{ "CreateFileMappingW", (SYSCALL)CreateFileMappingW, 0 },

#else

{ "CreateFileMappingW", (SYSCALL)0, 0 },

#endif

#define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \

DWORD,DWORD,DWORD,LPCWSTR))aSyscall[7].pCurrent)

#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)

{ "CreateMutexW", (SYSCALL)CreateMutexW, 0 },

#else

{ "CreateMutexW", (SYSCALL)0, 0 },

#endif

#define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \

LPCWSTR))aSyscall[8].pCurrent)

#if defined(SQLITE_WIN32_HAS_ANSI)

{ "DeleteFileA", (SYSCALL)DeleteFileA, 0 },

#else

{ "DeleteFileA", (SYSCALL)0, 0 },

#endif

#define osDeleteFileA ((BOOL(WINAPI*)(LPCSTR))aSyscall[9].pCurrent)

#if defined(SQLITE_WIN32_HAS_WIDE)

{ "DeleteFileW", (SYSCALL)DeleteFileW, 0 },

#else

{ "DeleteFileW", (SYSCALL)0, 0 },

#endif

#define osDeleteFileW ((BOOL(WINAPI*)(LPCWSTR))aSyscall[10].pCurrent)

#if SQLITE_OS_WINCE

{ "FileTimeToLocalFileTime", (SYSCALL)FileTimeToLocalFileTime, 0 },

#else

{ "FileTimeToLocalFileTime", (SYSCALL)0, 0 },

#endif

#define osFileTimeToLocalFileTime ((BOOL(WINAPI*)(CONST FILETIME*, \

LPFILETIME))aSyscall[11].pCurrent)

#if SQLITE_OS_WINCE

{ "FileTimeToSystemTime", (SYSCALL)FileTimeToSystemTime, 0 },

#else

{ "FileTimeToSystemTime", (SYSCALL)0, 0 },

#endif

#define osFileTimeToSystemTime ((BOOL(WINAPI*)(CONST FILETIME*, \

LPSYSTEMTIME))aSyscall[12].pCurrent)

{ "FlushFileBuffers", (SYSCALL)FlushFileBuffers, 0 },

#define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[13].pCurrent)

#if defined(SQLITE_WIN32_HAS_ANSI)

{ "FormatMessageA", (SYSCALL)FormatMessageA, 0 },

#else

{ "FormatMessageA", (SYSCALL)0, 0 },

#endif

#define osFormatMessageA ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPSTR, \

DWORD,va_list*))aSyscall[14].pCurrent)

#if defined(SQLITE_WIN32_HAS_WIDE)

{ "FormatMessageW", (SYSCALL)FormatMessageW, 0 },

#else

{ "FormatMessageW", (SYSCALL)0, 0 },

#endif

#define osFormatMessageW ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPWSTR, \

DWORD,va_list*))aSyscall[15].pCurrent)

#if !defined(SQLITE_OMIT_LOAD_EXTENSION)

{ "FreeLibrary", (SYSCALL)FreeLibrary, 0 },

#else

{ "FreeLibrary", (SYSCALL)0, 0 },

#endif

#define osFreeLibrary ((BOOL(WINAPI*)(HMODULE))aSyscall[16].pCurrent)

{ "GetCurrentProcessId", (SYSCALL)GetCurrentProcessId, 0 },

#define osGetCurrentProcessId ((DWORD(WINAPI*)(VOID))aSyscall[17].pCurrent)

#if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI)

{ "GetDiskFreeSpaceA", (SYSCALL)GetDiskFreeSpaceA, 0 },

#else

{ "GetDiskFreeSpaceA", (SYSCALL)0, 0 },

#endif

#define osGetDiskFreeSpaceA ((BOOL(WINAPI*)(LPCSTR,LPDWORD,LPDWORD,LPDWORD, \

LPDWORD))aSyscall[18].pCurrent)

#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)

{ "GetDiskFreeSpaceW", (SYSCALL)GetDiskFreeSpaceW, 0 },

#else

{ "GetDiskFreeSpaceW", (SYSCALL)0, 0 },

#endif

#define osGetDiskFreeSpaceW ((BOOL(WINAPI*)(LPCWSTR,LPDWORD,LPDWORD,LPDWORD, \

LPDWORD))aSyscall[19].pCurrent)

#if defined(SQLITE_WIN32_HAS_ANSI)

{ "GetFileAttributesA", (SYSCALL)GetFileAttributesA, 0 },

#else

{ "GetFileAttributesA", (SYSCALL)0, 0 },

#endif

#define osGetFileAttributesA ((DWORD(WINAPI*)(LPCSTR))aSyscall[20].pCurrent)

#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)

{ "GetFileAttributesW", (SYSCALL)GetFileAttributesW, 0 },

#else

{ "GetFileAttributesW", (SYSCALL)0, 0 },

#endif

#define osGetFileAttributesW ((DWORD(WINAPI*)(LPCWSTR))aSyscall[21].pCurrent)

#if defined(SQLITE_WIN32_HAS_WIDE)

{ "GetFileAttributesExW", (SYSCALL)GetFileAttributesExW, 0 },

#else

{ "GetFileAttributesExW", (SYSCALL)0, 0 },

#endif

#define osGetFileAttributesExW ((BOOL(WINAPI*)(LPCWSTR,GET_FILEEX_INFO_LEVELS, \

LPVOID))aSyscall[22].pCurrent)

#if !SQLITE_OS_WINRT

{ "GetFileSize", (SYSCALL)GetFileSize, 0 },

#else

{ "GetFileSize", (SYSCALL)0, 0 },

#endif

#define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[23].pCurrent)

#if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI)

{ "GetFullPathNameA", (SYSCALL)GetFullPathNameA, 0 },

#else

{ "GetFullPathNameA", (SYSCALL)0, 0 },

#endif

#define osGetFullPathNameA ((DWORD(WINAPI*)(LPCSTR,DWORD,LPSTR, \

LPSTR*))aSyscall[24].pCurrent)

#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)

{ "GetFullPathNameW", (SYSCALL)GetFullPathNameW, 0 },

#else

{ "GetFullPathNameW", (SYSCALL)0, 0 },

#endif

#define osGetFullPathNameW ((DWORD(WINAPI*)(LPCWSTR,DWORD,LPWSTR, \

LPWSTR*))aSyscall[25].pCurrent)

{ "GetLastError", (SYSCALL)GetLastError, 0 },

#define osGetLastError ((DWORD(WINAPI*)(VOID))aSyscall[26].pCurrent)

#if !defined(SQLITE_OMIT_LOAD_EXTENSION)

#if SQLITE_OS_WINCE

/* The GetProcAddressA() routine is only available on Windows CE. */

{ "GetProcAddressA", (SYSCALL)GetProcAddressA, 0 },

#else

/* All other Windows platforms expect GetProcAddress() to take

** an ANSI string regardless of the _UNICODE setting */

{ "GetProcAddressA", (SYSCALL)GetProcAddress, 0 },

#endif

#else

{ "GetProcAddressA", (SYSCALL)0, 0 },

#endif

#define osGetProcAddressA ((FARPROC(WINAPI*)(HMODULE, \

LPCSTR))aSyscall[27].pCurrent)

#if !SQLITE_OS_WINRT

{ "GetSystemInfo", (SYSCALL)GetSystemInfo, 0 },

#else

{ "GetSystemInfo", (SYSCALL)0, 0 },

#endif

#define osGetSystemInfo ((VOID(WINAPI*)(LPSYSTEM_INFO))aSyscall[28].pCurrent)

{ "GetSystemTime", (SYSCALL)GetSystemTime, 0 },

#define osGetSystemTime ((VOID(WINAPI*)(LPSYSTEMTIME))aSyscall[29].pCurrent)

#if !SQLITE_OS_WINCE

{ "GetSystemTimeAsFileTime", (SYSCALL)GetSystemTimeAsFileTime, 0 },

#else

{ "GetSystemTimeAsFileTime", (SYSCALL)0, 0 },

#endif

#define osGetSystemTimeAsFileTime ((VOID(WINAPI*)( \

LPFILETIME))aSyscall[30].pCurrent)

#if defined(SQLITE_WIN32_HAS_ANSI)

{ "GetTempPathA", (SYSCALL)GetTempPathA, 0 },

#else

{ "GetTempPathA", (SYSCALL)0, 0 },

#endif

#define osGetTempPathA ((DWORD(WINAPI*)(DWORD,LPSTR))aSyscall[31].pCurrent)

#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)

{ "GetTempPathW", (SYSCALL)GetTempPathW, 0 },

#else

{ "GetTempPathW", (SYSCALL)0, 0 },

#endif

#define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[32].pCurrent)

#if !SQLITE_OS_WINRT

{ "GetTickCount", (SYSCALL)GetTickCount, 0 },

#else

{ "GetTickCount", (SYSCALL)0, 0 },

#endif

#define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent)

#if defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_GETVERSIONEX

{ "GetVersionExA", (SYSCALL)GetVersionExA, 0 },

#else

{ "GetVersionExA", (SYSCALL)0, 0 },

#endif

#define osGetVersionExA ((BOOL(WINAPI*)( \

LPOSVERSIONINFOA))aSyscall[34].pCurrent)

#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \

SQLITE_WIN32_GETVERSIONEX

{ "GetVersionExW", (SYSCALL)GetVersionExW, 0 },

#else

{ "GetVersionExW", (SYSCALL)0, 0 },

#endif

#define osGetVersionExW ((BOOL(WINAPI*)( \

LPOSVERSIONINFOW))aSyscall[35].pCurrent)

{ "HeapAlloc", (SYSCALL)HeapAlloc, 0 },

#define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \

SIZE_T))aSyscall[36].pCurrent)

#if !SQLITE_OS_WINRT

{ "HeapCreate", (SYSCALL)HeapCreate, 0 },

#else

{ "HeapCreate", (SYSCALL)0, 0 },

#endif

#define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \

SIZE_T))aSyscall[37].pCurrent)

#if !SQLITE_OS_WINRT

{ "HeapDestroy", (SYSCALL)HeapDestroy, 0 },

#else

{ "HeapDestroy", (SYSCALL)0, 0 },

#endif

#define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[38].pCurrent)

{ "HeapFree", (SYSCALL)HeapFree, 0 },

#define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[39].pCurrent)

{ "HeapReAlloc", (SYSCALL)HeapReAlloc, 0 },

#define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \

SIZE_T))aSyscall[40].pCurrent)

{ "HeapSize", (SYSCALL)HeapSize, 0 },

#define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \

LPCVOID))aSyscall[41].pCurrent)

#if !SQLITE_OS_WINRT

{ "HeapValidate", (SYSCALL)HeapValidate, 0 },

#else

{ "HeapValidate", (SYSCALL)0, 0 },

#endif

#define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \

LPCVOID))aSyscall[42].pCurrent)

#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT

{ "HeapCompact", (SYSCALL)HeapCompact, 0 },

#else

{ "HeapCompact", (SYSCALL)0, 0 },

#endif

#define osHeapCompact ((UINT(WINAPI*)(HANDLE,DWORD))aSyscall[43].pCurrent)

#if defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_OMIT_LOAD_EXTENSION)

{ "LoadLibraryA", (SYSCALL)LoadLibraryA, 0 },

#else

{ "LoadLibraryA", (SYSCALL)0, 0 },

#endif

#define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[44].pCurrent)

#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \

!defined(SQLITE_OMIT_LOAD_EXTENSION)

{ "LoadLibraryW", (SYSCALL)LoadLibraryW, 0 },

#else

{ "LoadLibraryW", (SYSCALL)0, 0 },

#endif

#define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[45].pCurrent)

#if !SQLITE_OS_WINRT

{ "LocalFree", (SYSCALL)LocalFree, 0 },

#else

{ "LocalFree", (SYSCALL)0, 0 },

#endif

#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[46].pCurrent)

#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT

{ "LockFile", (SYSCALL)LockFile, 0 },

#else

{ "LockFile", (SYSCALL)0, 0 },

#endif

#ifndef osLockFile

#define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \

DWORD))aSyscall[47].pCurrent)

#endif

#if !SQLITE_OS_WINCE

{ "LockFileEx", (SYSCALL)LockFileEx, 0 },

#else

{ "LockFileEx", (SYSCALL)0, 0 },

#endif

#ifndef osLockFileEx

#define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \

LPOVERLAPPED))aSyscall[48].pCurrent)

#endif

#if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && \

(!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0))

{ "MapViewOfFile", (SYSCALL)MapViewOfFile, 0 },

#else

{ "MapViewOfFile", (SYSCALL)0, 0 },

#endif

#define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \

SIZE_T))aSyscall[49].pCurrent)

{ "MultiByteToWideChar", (SYSCALL)MultiByteToWideChar, 0 },

#define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \

int))aSyscall[50].pCurrent)

{ "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 },

#define osQueryPerformanceCounter ((BOOL(WINAPI*)( \

LARGE_INTEGER*))aSyscall[51].pCurrent)

{ "ReadFile", (SYSCALL)ReadFile, 0 },

#define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \

LPOVERLAPPED))aSyscall[52].pCurrent)

{ "SetEndOfFile", (SYSCALL)SetEndOfFile, 0 },

#define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[53].pCurrent)

#if !SQLITE_OS_WINRT

{ "SetFilePointer", (SYSCALL)SetFilePointer, 0 },

#else

{ "SetFilePointer", (SYSCALL)0, 0 },

#endif

#define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \

DWORD))aSyscall[54].pCurrent)

#if !SQLITE_OS_WINRT

{ "Sleep", (SYSCALL)Sleep, 0 },

#else

{ "Sleep", (SYSCALL)0, 0 },

#endif

#define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[55].pCurrent)

{ "SystemTimeToFileTime", (SYSCALL)SystemTimeToFileTime, 0 },

#define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \

LPFILETIME))aSyscall[56].pCurrent)

#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT

{ "UnlockFile", (SYSCALL)UnlockFile, 0 },

#else

{ "UnlockFile", (SYSCALL)0, 0 },

#endif

#ifndef osUnlockFile

#define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \

DWORD))aSyscall[57].pCurrent)

#endif

#if !SQLITE_OS_WINCE

{ "UnlockFileEx", (SYSCALL)UnlockFileEx, 0 },

#else

{ "UnlockFileEx", (SYSCALL)0, 0 },

#endif

#define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \

LPOVERLAPPED))aSyscall[58].pCurrent)

#if SQLITE_OS_WINCE || !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0

{ "UnmapViewOfFile", (SYSCALL)UnmapViewOfFile, 0 },

#else

{ "UnmapViewOfFile", (SYSCALL)0, 0 },

#endif

#define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[59].pCurrent)

{ "WideCharToMultiByte", (SYSCALL)WideCharToMultiByte, 0 },

#define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \

LPCSTR,LPBOOL))aSyscall[60].pCurrent)

{ "WriteFile", (SYSCALL)WriteFile, 0 },

#define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \

LPOVERLAPPED))aSyscall[61].pCurrent)

#if SQLITE_OS_WINRT

{ "CreateEventExW", (SYSCALL)CreateEventExW, 0 },

#else