Sync with trunk r63502.

svn path=/branches/shell-experiments/; revision=63503
2025-07-28 02:11:54 +00:00 · 2014-05-30 17:56:10 +00:00 · 2014-05-30 17:56:10 +00:00 · acd03fd182
commit acd03fd182
parent 7411374268 4dc4711006
159 changed files with 9454 additions and 8144 deletions
--- a/base/applications/cmdutils/help/help.c
+++ b/base/applications/cmdutils/help/help.c
@ -56,7 +56,7 @@ VOID PrintResourceString(INT resID, ...)
    // FIXME: Optimize by using Win32 console functions.
    if (IsConsoleHandle(OutputHandle))
    {
-        _vcwprintf(tmpBuffer, arg_ptr);
+        vfwprintf(stdout, tmpBuffer, arg_ptr);
    }
    else
    {
--- a/base/applications/mscutils/servman/precomp.h
+++ b/base/applications/mscutils/servman/precomp.h
@ -14,6 +14,7 @@
 #include <wincon.h>
 #include <tchar.h>
 #include <shlobj.h>
+#include <strsafe.h>

 #include "resource.h"

--- a/base/applications/mscutils/servman/propsheet_depends.c
+++ b/base/applications/mscutils/servman/propsheet_depends.c
@ -60,7 +60,7 @@ AddItemToTreeView(HWND hTreeView,
                                   dwSize * sizeof(TCHAR));
        if (lpName)
        {
-            _tcscpy_s(lpName, dwSize, lpServiceName);
+            StringCchCopy(lpName, dwSize, lpServiceName);
            tvi.lParam = (LPARAM)lpName;
        }
    }
--- a/base/applications/mscutils/servman/query.c
+++ b/base/applications/mscutils/servman/query.c
@ -183,7 +183,7 @@ GetServiceDescription(LPTSTR lpServiceName)
                                                  dwSize * sizeof(TCHAR));
                        if (lpDescription)
                        {
-                            _tcscpy_s(lpDescription,
+                            StringCchCopy(lpDescription,
                                          dwSize,
                                          pServiceDescription->lpDescription);
                        }
--- a/base/applications/mscutils/servman/stop_dependencies.c
+++ b/base/applications/mscutils/servman/stop_dependencies.c
@ -32,7 +32,7 @@ AddServiceToList(LPWSTR *lpServiceList,
        if (lpNewList)
        {
            /* Copy the service name */
-            wcscpy_s(lpNewList,
+            StringCchCopy(lpNewList,
                          dwToAddSize,
                          lpServiceToAdd);

@ -68,7 +68,7 @@ AddServiceToList(LPWSTR *lpServiceList,
        if (lpNewList)
        {
            /* Copy the service name */
-            wcscpy_s(&lpNewList[dwCurSize - 1],
+            StringCchCopy(&lpNewList[dwCurSize - 1],
                          dwToAddSize,
                          lpServiceToAdd);

--- a/base/applications/mstsc/connectdialog.c
+++ b/base/applications/mstsc/connectdialog.c
@ -647,19 +647,11 @@ OnResolutionChanged(PINFO pInfo, INT position)
                        Pixel,
                        sizeof(Pixel) / sizeof(WCHAR)))
        {
-#ifdef _MSC_VER
-             _swprintf(Buffer,
-                       Pixel,
-                       pInfo->DisplayDeviceList->Resolutions[position].dmPelsWidth,
-                       pInfo->DisplayDeviceList->Resolutions[position].dmPelsHeight,
-                       Pixel);
-#else
            swprintf(Buffer,
                     Pixel,
                     pInfo->DisplayDeviceList->Resolutions[position].dmPelsWidth,
                     pInfo->DisplayDeviceList->Resolutions[position].dmPelsHeight,
                     Pixel);
-#endif
        }
    }

--- a/base/applications/network/net/CMakeLists.txt
+++ b/base/applications/network/net/CMakeLists.txt
@ -3,6 +3,7 @@ add_definitions(-D__USE_W32_SOCKETS)

 list(APPEND SOURCE
    main.c
+    cmdAccounts.c
    cmdStart.c
    cmdStop.c
    cmdHelpMsg.c
@ -13,6 +14,6 @@ list(APPEND SOURCE

 add_executable(net ${SOURCE})
 set_module_type(net win32cui UNICODE)
-add_importlibs(net advapi32 msvcrt kernel32)
+add_importlibs(net advapi32 netapi32 msvcrt kernel32 ntdll)
 add_pch(net net.h SOURCE)
 add_cd_file(TARGET net DESTINATION reactos/system32 FOR all)
--- a/base/applications/network/net/cmdAccounts.c
+++ b/base/applications/network/net/cmdAccounts.c
@ -0,0 +1,192 @@
+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS net command
+ * FILE:
+ * PURPOSE:
+ *
+ * PROGRAMMERS:     Eric Kohl
+ */
+
+#include "net.h"
+
+INT
+cmdAccounts(
+    INT argc,
+    WCHAR **argv)
+{
+    PUSER_MODALS_INFO_0 Info0 = NULL;
+    PUSER_MODALS_INFO_1 Info1 = NULL;
+    PUSER_MODALS_INFO_3 Info3 = NULL;
+    NT_PRODUCT_TYPE ProductType;
+    LPWSTR p, perr;
+    DWORD ParamErr;
+    ULONG value;
+    INT i;
+    BOOL Modified = FALSE;
+//    BOOL Domain = FALSE;
+    NET_API_STATUS Status;
+
+    for (i = 3; i < argc; i++)
+    {
+        if (wcsicmp(argv[i], L"help") == 0)
+        {
+            /* Print short syntax help */
+            puts("NET ACCOUNTS [/FORCELOGOFF:{Minutes|NO}] [/MINPWLEN:Length]");
+            puts("             [/MAXPWAGE:{Days|UNLIMITED}] [/MINPWAGE:Days]");
+            puts("             [/UNIQUEPW:Count] [/DOMAIN]");
+            return 0;
+        }
+
+        if (wcsicmp(argv[i], L"/help") == 0)
+        {
+            /* FIXME: Print long help text*/
+            return 0;
+        }
+
+/*
+        if (wcsicmp(argv[i], L"/domain") == 0)
+        {
+            Domain = TRUE;
+        }
+*/
+    }
+
+    Status = NetUserModalsGet(NULL, 0, (LPBYTE*)&Info0);
+    if (Status != NERR_Success)
+        goto done;
+
+    for (i = 3; i < argc; i++)
+    {
+        if (_wcsnicmp(argv[i], L"/forcelogoff:", 13) == 0)
+        {
+            p = &argv[i][13];
+            if (wcsicmp(p, L"no"))
+            {
+                Info0->usrmod0_force_logoff = TIMEQ_FOREVER;
+                Modified = TRUE;
+            }
+            else
+            {
+                value = wcstoul(p, &perr, 10);
+
+                Info0->usrmod0_force_logoff = value * 60;
+                Modified = TRUE;
+            }
+        }
+        else if (_wcsnicmp(argv[i], L"/minpwlen:", 10) == 0)
+        {
+            p = &argv[i][10];
+            value = wcstoul(p, &perr, 10);
+            Info0->usrmod0_min_passwd_len = value;
+            Modified = TRUE;
+        }
+        else if (_wcsnicmp(argv[i], L"/maxpwage:", 10) == 0)
+        {
+            p = &argv[i][10];
+
+            if (wcsicmp(p, L"unlimited"))
+            {
+                Info0->usrmod0_max_passwd_age = ULONG_MAX;
+                Modified = TRUE;
+            }
+            else
+            {
+                value = wcstoul(p, &perr, 10);
+
+                Info0->usrmod0_max_passwd_age = value * 86400;
+                Modified = TRUE;
+            }
+        }
+        else if (_wcsnicmp(argv[i], L"/minpwage:", 10) == 0)
+        {
+            p = &argv[i][10];
+            value = wcstoul(p, &perr, 10);
+
+            Info0->usrmod0_min_passwd_age = value * 86400;
+            Modified = TRUE;
+        }
+        else if (_wcsnicmp(argv[i], L"/uniquepw:", 10) == 0)
+        {
+            p = &argv[i][10];
+            value = wcstoul(p, &perr, 10);
+
+            Info0->usrmod0_password_hist_len = value;
+            Modified = TRUE;
+        }
+    }
+
+    if (Modified == TRUE)
+    {
+        Status = NetUserModalsSet(NULL, 0, (LPBYTE)Info0, &ParamErr);
+        if (Status != NERR_Success)
+            goto done;
+    }
+    else
+    {
+        Status = NetUserModalsGet(NULL, 1, (LPBYTE*)&Info1);
+        if (Status != NERR_Success)
+            goto done;
+
+        Status = NetUserModalsGet(NULL, 3, (LPBYTE*)&Info3);
+        if (Status != NERR_Success)
+            goto done;
+
+        RtlGetNtProductType(&ProductType);
+
+        printf("Force logoff after: ");
+        if (Info0->usrmod0_force_logoff == TIMEQ_FOREVER)
+            printf("Never\n");
+        else
+            printf("%lu seconds\n", Info0->usrmod0_force_logoff);
+
+        printf("Minimum password age (in days): %lu\n", Info0->usrmod0_min_passwd_age / 86400);
+        printf("Maximum password age (in days): %lu\n", Info0->usrmod0_max_passwd_age / 86400);
+        printf("Minimum password length: %lu\n", Info0->usrmod0_min_passwd_len);
+
+        printf("Password history length: ");
+        if (Info0->usrmod0_password_hist_len == 0)
+            printf("None\n");
+        else
+            printf("%lu\n", Info0->usrmod0_password_hist_len);
+
+        printf("Lockout threshold: %lu\n", Info3->usrmod3_lockout_threshold);
+        printf("Lockout duration (in minutes): %lu\n", Info3->usrmod3_lockout_duration / 60);
+        printf("Lockout observation window (in minutes): %lu\n", Info3->usrmod3_lockout_observation_window / 60);
+
+        printf("Computer role: ");
+
+        if (Info1->usrmod1_role == UAS_ROLE_PRIMARY)
+        {
+            if (ProductType == NtProductLanManNt)
+            {
+                printf("Primary server\n");
+            }
+            else if (ProductType == NtProductServer)
+            {
+                printf("Standalone server\n");
+            }
+            else
+            {
+                printf("Workstation\n");
+            }
+        }
+        else
+        {
+            printf("Backup server\n");
+        }
+    }
+
+done:
+    if (Info3 != NULL)
+        NetApiBufferFree(Info3);
+
+    if (Info1 != NULL)
+        NetApiBufferFree(Info1);
+
+    if (Info0 != NULL)
+        NetApiBufferFree(Info0);
+
+    return 0;
+}
+
+/* EOF */
--- a/base/applications/network/net/main.c
+++ b/base/applications/network/net/main.c
@ -18,7 +18,7 @@ typedef struct _COMMAND

 COMMAND cmds[] =
 {
-    {L"accounts",   unimplemented},
+    {L"accounts",   cmdAccounts},
    {L"computer",   unimplemented},
    {L"config",     unimplemented},
    {L"continue",   cmdContinue},
--- a/base/applications/network/net/net.h
+++ b/base/applications/network/net/net.h
@ -7,16 +7,23 @@
 #ifndef _NET_PCH_
 #define _NET_PCH_

+#define WIN32_NO_STATUS
+
 #include <stdarg.h>

 #include <windef.h>
 #include <winbase.h>
 #include <winsvc.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <lm.h>
+#include <ndk/rtlfuncs.h>

 VOID help(VOID);
 INT unimplemented(INT argc, WCHAR **argv);

+INT cmdAccounts(INT argc, WCHAR **argv);
 INT cmdContinue(INT argc, WCHAR **argv);
 INT cmdHelp(INT argc, WCHAR **argv);
 INT cmdHelpMsg(INT argc, WCHAR **argv);
--- a/base/applications/shutdown/shutdown.c
+++ b/base/applications/shutdown/shutdown.c
@ -22,7 +22,7 @@ VOID PrintResourceString(INT resID, ...)

    va_start(arg_ptr, resID);
    LoadStringW(GetModuleHandle(NULL), resID, tmpBuffer, MAX_BUFFER_SIZE);
-    _vcwprintf(tmpBuffer, arg_ptr);
+    vfwprintf(stdout, tmpBuffer, arg_ptr);
    va_end(arg_ptr);
 }

--- a/base/services/tcpsvcs/discard.c
+++ b/base/services/tcpsvcs/discard.c
@ -24,7 +24,7 @@ ReceiveIncomingPackets(SOCKET sock)
        {
            TCHAR logBuf[256];

-            _swprintf(logBuf, L"Discard: Received %d bytes from client", readBytes);
+            swprintf(logBuf, L"Discard: Received %d bytes from client", readBytes);
            LogEvent(logBuf, 0, 0, LOG_FILE);
        }
        else if (readBytes == SOCKET_ERROR)
--- a/base/services/tcpsvcs/echo.c
+++ b/base/services/tcpsvcs/echo.c
@ -25,7 +25,7 @@ EchoIncomingPackets(SOCKET sock)
        readBytes = recv(sock, readBuffer, RECV_BUF, 0);
        if (readBytes > 0)
        {
-            _swprintf(logBuf, L"Received %d bytes from client", readBytes);
+            swprintf(logBuf, L"Received %d bytes from client", readBytes);
            LogEvent(logBuf, 0, 0, LOG_FILE);

            totalSentBytes = 0;
@ -34,7 +34,7 @@ EchoIncomingPackets(SOCKET sock)
                retVal = send(sock, readBuffer + totalSentBytes, readBytes - totalSentBytes, 0);
                if (retVal > 0)
                {
-                    _swprintf(logBuf, L"Sent %d bytes back to client", retVal);
+                    swprintf(logBuf, L"Sent %d bytes back to client", retVal);
                    LogEvent(logBuf, 0, 0, LOG_FILE);
                    totalSentBytes += retVal;
                }
--- a/base/services/tcpsvcs/skelserver.c
+++ b/base/services/tcpsvcs/skelserver.c
@ -84,14 +84,14 @@ AcceptConnections(SOCKET listeningSocket,
                sock = accept(listeningSocket, (SOCKADDR*)&client, &addrSize);
                if (sock != INVALID_SOCKET)
                {
-                    _swprintf(logBuf,
+                    swprintf(logBuf,
                             L"Accepted connection to %s server from %S:%d",
                             lpName,
                             inet_ntoa(client.sin_addr),
                             ntohs(client.sin_port));
                    LogEvent(logBuf, 0, 0, LOG_FILE);

-                    _swprintf(logBuf, L"Creating worker thread for %s", lpName);
+                    swprintf(logBuf, L"Creating worker thread for %s", lpName);
                    LogEvent(logBuf, 0, 0, LOG_FILE);

                    if (!bShutdown)
@ -103,7 +103,7 @@ AcceptConnections(SOCKET listeningSocket,
                        }
                        else
                        {
-                            _swprintf(logBuf, L"Failed to start worker thread for the %s server",
+                            swprintf(logBuf, L"Failed to start worker thread for the %s server",
                                     lpName);
                            LogEvent(logBuf, 0, 0, LOG_FILE);
                        }
@ -149,7 +149,7 @@ ShutdownConnection(SOCKET sock,
            ret = recv(sock, readBuffer, BUF, 0);
            if (ret >= 0)
            {
-                _swprintf(logBuf, L"FYI, received %d unexpected bytes during shutdown", ret);
+                swprintf(logBuf, L"FYI, received %d unexpected bytes during shutdown", ret);
                LogEvent(logBuf, 0, 0, LOG_FILE);
            }
        } while (ret > 0);
@ -170,7 +170,7 @@ StartServer(LPVOID lpParam)

    pServices = (PSERVICES)lpParam;

-    _swprintf(logBuf, L"Starting %s server", pServices->lpName);
+    swprintf(logBuf, L"Starting %s server", pServices->lpName);
    LogEvent(logBuf, 0, 0, LOG_FILE);

    if (!bShutdown)
@ -178,7 +178,7 @@ StartServer(LPVOID lpParam)
        listeningSocket = SetUpListener(htons(pServices->Port));
        if (!bShutdown && listeningSocket != INVALID_SOCKET)
        {
-            _swprintf(logBuf,
+            swprintf(logBuf,
                     L"%s is waiting for connections on port %d",
                     pServices->lpName,
                     pServices->Port);
@ -192,9 +192,7 @@ StartServer(LPVOID lpParam)
        }
    }

-    _swprintf(logBuf,
-              L"Exiting %s thread",
-              pServices->lpName);
+    swprintf(logBuf, L"Exiting %s thread", pServices->lpName);
    LogEvent(logBuf, 0, 0, LOG_FILE);
    ExitThread(0);
 }
--- a/base/services/tcpsvcs/tcpsvcs.c
+++ b/base/services/tcpsvcs/tcpsvcs.c
@ -72,7 +72,7 @@ CreateServers(PSERVICEINFO pServInfo)

    if ((RetVal = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
    {
-        _swprintf(buf, L"WSAStartup() failed : %lu\n", RetVal);
+        swprintf(buf, L"WSAStartup() failed : %lu\n", RetVal);
        LogEvent(buf, 0, 100, LOG_ALL);
        return FALSE;
    }
@ -84,7 +84,7 @@ CreateServers(PSERVICEINFO pServInfo)
    /* Create worker threads. */
    for (i = 0; i < NUM_SERVICES; i++)
    {
-        _swprintf(buf, L"Creating thread for %s server", Services[i].lpName);
+        swprintf(buf, L"Creating thread for %s server", Services[i].lpName);
        LogEvent(buf, 0, 0, LOG_FILE);

        hThread[i] = CreateThread(NULL,
@ -96,7 +96,7 @@ CreateServers(PSERVICEINFO pServInfo)

        if (hThread[i] == NULL)
        {
-            _swprintf(buf, L"\nError creating %s server thread\n", Services[i].lpName);
+            swprintf(buf, L"\nError creating %s server thread\n", Services[i].lpName);
            LogEvent(buf, GetLastError(), 0, LOG_ALL);
            return FALSE;
        }
--- a/base/services/tcpsvcs/tcpsvcs.h
+++ b/base/services/tcpsvcs/tcpsvcs.h
@ -10,10 +10,6 @@
 #include <winsock2.h>
 #include <tchar.h>

-#ifndef _MSC_VER
-#define _swprintf swprintf
-#endif
-
 #define LOG_FILE 1
 #define LOG_EVENTLOG 2
 #define LOG_ERROR 4
--- a/base/setup/setup/setup.c
+++ b/base/setup/setup/setup.c
@ -36,7 +36,10 @@ typedef DWORD (WINAPI *PINSTALL_REACTOS)(HINSTANCE hInstance);

 /* FUNCTIONS ****************************************************************/

-LPTSTR lstrchr(LPCTSTR s, TCHAR c)
+LPTSTR
+lstrchr(
+    LPCTSTR s,
+    TCHAR c)
 {
    while (*s)
    {
@ -51,8 +54,11 @@ LPTSTR lstrchr(LPCTSTR s, TCHAR c)
    return (LPTSTR)NULL;
 }

-static VOID
-RunNewSetup (HINSTANCE hInstance)
+
+static
+VOID
+RunNewSetup(
+    HINSTANCE hInstance)
 {
    HMODULE hDll;
    PINSTALL_REACTOS InstallReactOS;
@ -66,7 +72,6 @@ RunNewSetup (HINSTANCE hInstance)

    DPRINT("Loaded 'syssetup'!\n");
    InstallReactOS = (PINSTALL_REACTOS)GetProcAddress(hDll, "InstallReactOS");
-
    if (InstallReactOS == NULL)
    {
        DPRINT("Failed to get address for 'InstallReactOS()'!\n");
@ -79,8 +84,11 @@ RunNewSetup (HINSTANCE hInstance)
    FreeLibrary(hDll);
 }

-static VOID
-RunLiveCD (HINSTANCE hInstance)
+
+static
+VOID
+RunLiveCD(
+    HINSTANCE hInstance)
 {
    HMODULE hDll;
    PINSTALL_REACTOS InstallLiveCD;
@ -94,7 +102,6 @@ RunLiveCD (HINSTANCE hInstance)

    DPRINT("Loaded 'syssetup'!\n");
    InstallLiveCD = (PINSTALL_REACTOS)GetProcAddress(hDll, "InstallLiveCD");
-
    if (InstallLiveCD == NULL)
    {
        DPRINT("Failed to get address for 'InstallReactOS()'!\n");
@ -107,8 +114,11 @@ RunLiveCD (HINSTANCE hInstance)
    FreeLibrary(hDll);
 }

-int WINAPI
-_tWinMain (HINSTANCE hInstance,
+
+int
+WINAPI
+_tWinMain(
+    HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPTSTR lpCmdLine,
    int nShowCmd)
--- a/base/system/userinit/CMakeLists.txt
+++ b/base/system/userinit/CMakeLists.txt
@ -2,5 +2,5 @@
 add_executable(userinit userinit.c userinit.rc)
 target_link_libraries(userinit wine)
 set_module_type(userinit win32gui UNICODE)
-add_importlibs(userinit user32 gdi32 advapi32 shell32 shlwapi msvcrt kernel32 ntdll)
+add_importlibs(userinit user32 advapi32 shell32 msvcrt kernel32 ntdll)
 add_cd_file(TARGET userinit DESTINATION reactos/system32 FOR all)
--- a/base/system/userinit/userinit.c
+++ b/base/system/userinit/userinit.c
@ -227,7 +227,7 @@ StartAutoApplications(
    {
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && (findData.nFileSizeHigh || findData.nFileSizeLow))
        {
-            memset(&ExecInfo, 0x0, sizeof(SHELLEXECUTEINFOW));
+            ZeroMemory(&ExecInfo, sizeof(SHELLEXECUTEINFOW));
            ExecInfo.cbSize = sizeof(ExecInfo);
            wcscpy(&szPath[len+1], findData.cFileName);
            ExecInfo.lpVerb = L"open";
@ -430,11 +430,9 @@ COLORREF StrToColorref(

    TRACE("(%s)\n", debugstr_w(lpszCol));

-    rgb[0] = StrToIntW(lpszCol);
-    lpszCol = StrChrW(lpszCol, L' ') + 1;
-    rgb[1] = StrToIntW(lpszCol);
-    lpszCol = StrChrW(lpszCol, L' ') + 1;
-    rgb[2] = StrToIntW(lpszCol);
+    rgb[0] = (BYTE)wcstoul(lpszCol, &lpszCol, 10);
+    rgb[1] = (BYTE)wcstoul(lpszCol, &lpszCol, 10);
+    rgb[2] = (BYTE)wcstoul(lpszCol, &lpszCol, 10);
    return RGB(rgb[0], rgb[1], rgb[2]);
 }

@ -443,7 +441,7 @@ VOID SetUserSysColors(VOID)
 {
    HKEY hKey;
    INT i;
-    WCHAR szColor[20];
+    WCHAR szColor[25];
    DWORD Type, Size;
    COLORREF crColor;
    LONG rc;
--- a/boot/bootdata/CMakeLists.txt
+++ b/boot/bootdata/CMakeLists.txt
@ -2,18 +2,30 @@
 add_subdirectory(packages)

 #common hives
-add_cd_file(FILE ${CMAKE_CURRENT_SOURCE_DIR}/txtsetup.sif DESTINATION reactos NO_CAB FOR bootcd regtest)
-add_cd_file(FILE ${CMAKE_CURRENT_SOURCE_DIR}/hivecls.inf DESTINATION reactos NO_CAB FOR bootcd regtest)
-add_cd_file(FILE ${CMAKE_CURRENT_SOURCE_DIR}/hivedef.inf DESTINATION reactos NO_CAB FOR bootcd regtest)
-add_cd_file(FILE ${CMAKE_CURRENT_SOURCE_DIR}/hivesft.inf DESTINATION reactos NO_CAB FOR bootcd regtest)
-add_cd_file(FILE ${CMAKE_CURRENT_SOURCE_DIR}/hivesys.inf DESTINATION reactos NO_CAB FOR bootcd regtest)

-# livecd hives
-list(APPEND CD_HIVES
+add_cd_file(FILE ${CMAKE_CURRENT_SOURCE_DIR}/txtsetup.sif DESTINATION reactos NO_CAB FOR bootcd regtest)
+
+list(APPEND _common_hives
    ${CMAKE_CURRENT_SOURCE_DIR}/hivecls.inf
    ${CMAKE_CURRENT_SOURCE_DIR}/hivedef.inf
    ${CMAKE_CURRENT_SOURCE_DIR}/hivesft.inf
-    ${CMAKE_CURRENT_SOURCE_DIR}/hivesys.inf
+    ${CMAKE_CURRENT_SOURCE_DIR}/hivesys.inf)
+
+foreach(_hive ${_common_hives})
+    get_filename_component(_hive_name ${_hive} NAME)
+    set(_converted_hive ${CMAKE_CURRENT_BINARY_DIR}/${_hive_name})
+    add_custom_command(OUTPUT ${_converted_hive}
+                       COMMAND native-utf16le ${_hive} ${_converted_hive}
+                       DEPENDS native-utf16le ${_hive})
+    list(APPEND _converted_common_hives ${_converted_hive})
+    add_cd_file(FILE ${_converted_hive} DESTINATION reactos NO_CAB FOR bootcd regtest)
+endforeach()
+
+add_custom_target(converted_hives DEPENDS ${_converted_common_hives})
+
+# livecd hives
+list(APPEND _livecd_hives
+    ${_converted_common_hives}
    ${CMAKE_CURRENT_SOURCE_DIR}/livecd.inf
    ${CMAKE_CURRENT_SOURCE_DIR}/hiveinst.inf)

@ -23,8 +35,8 @@ add_custom_command(
        ${CMAKE_CURRENT_BINARY_DIR}/security
        ${CMAKE_CURRENT_BINARY_DIR}/software
        ${CMAKE_CURRENT_BINARY_DIR}/system
-    COMMAND native-mkhive ${CMAKE_CURRENT_BINARY_DIR} ${CD_HIVES}
-    DEPENDS native-mkhive ${CD_HIVES})
+    COMMAND native-mkhive ${CMAKE_CURRENT_BINARY_DIR} ${_livecd_hives}
+    DEPENDS native-mkhive ${_livecd_hives} ${_converted_common_hives})

 add_custom_target(livecd_hives
    DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/sam
--- a/boot/bootdata/hivecls.inf
+++ b/boot/bootdata/hivecls.inf
@ -1,4 +1,4 @@
-[Version]
+[Version]
 Signature="$ReactOS$"

 [AddReg]
@ -70,10 +70,10 @@ HKCR,"comfile\shell\open\command","",0x00000000,"""%1"" %*"

 ; Control Panel extensions
 HKCR,".cpl","",0x00000000,"cplfile"
-HKCR,"cplfile","",0x00000000,"Control Panel Extension"
+HKCR,"cplfile","",0x00000000,%CPLFILE%
 HKCR,"cplfile","FriendlyTypeName",0x00020000,"@%SystemRoot%\system32\shell32.dll,-161"
 HKCR,"cplfile\DefaultIcon","",0x00020000,"%SystemRoot%\system32\shell32.dll,-154"
-HKCR,"cplfile\shell\cplopen","",0x00000000,"Open with Control Panel"
+HKCR,"cplfile\shell\cplopen","",0x00000000,%CPLFILE_OPENWITH%
 HKCR,"cplfile\shell\cplopen\command","",0x00020000,"%SystemRoot%\system32\rundll32.exe shell32.dll,Control_RunDLL %1,%*"
 HKCR,"cplfile\shell\runas\command","",0x00020000,"%SystemRoot%\system32\rundll32.exe shell32.dll,Control_RunDLLAsUser %1,%*"

@ -466,4 +466,25 @@ HKCR,"MIME\Database\Rfc1766","0434",0x00000000,"xh;Xhosa"
 HKCR,"MIME\Database\Rfc1766","043D",0x00000000,"ji;Yiddish"
 HKCR,"MIME\Database\Rfc1766","0435",0x00000000,"zu;Zulu"

+;-------------------------------- STRINGS -------------------------------
+
+[Strings]
+CPLFILE="Control Panel Extension"
+CPLFILE_OPENWITH="Open with Control Panel"
+
+; LANG_GERMAN SUBLANG_NEUTRAL
+[Strings.0007]
+CPLFILE="Systemsteuerungselement"
+CPLFILE_OPENWITH="Mit der Systemsteuerung öffnen"
+
+; LANG_POLISH SUBLANG_NEUTRAL
+[Strings.0015]
+CPLFILE="Aplet Panelu Sterowania"
+CPLFILE_OPENWITH="Otwórz poprzez Panel Sterowania"
+
+; LANG_FRENCH SUBLANG_NEUTRAL
+[Strings.000C]
+CPLFILE="Extension du Panneau de Contrôle"
+CPLFILE_OPENWITH="Ouvrir avec le Panneau de Contrôle"
+
 ; EOF
--- a/boot/bootdata/hivedef.inf
+++ b/boot/bootdata/hivedef.inf
@ -1,4 +1,4 @@
-[Version]
+[Version]
 Signature="$ReactOS$"

 [AddReg]
--- a/boot/bootdata/hivesft.inf
+++ b/boot/bootdata/hivesft.inf
@ -1,4 +1,4 @@
-[Version]
+[Version]
 Signature="$ReactOS$"

 [AddReg]
--- a/boot/bootdata/hivesys.inf
+++ b/boot/bootdata/hivesys.inf
@ -1,4 +1,4 @@
-[Version]
+[Version]
 Signature = "$ReactOS$"

 [AddReg]
--- a/cmake/CMakeMacros.cmake
+++ b/cmake/CMakeMacros.cmake
@ -239,7 +239,7 @@ function(add_cd_file)
            endforeach()
            if(_CD_TARGET)
                #manage dependency
-                add_dependencies(bootcd ${_CD_TARGET})
+                add_dependencies(bootcd ${_CD_TARGET} converted_hives)
            endif()
        else()
            #add it in reactos.cab
@ -259,7 +259,7 @@ function(add_cd_file)
    if(NOT __cd EQUAL -1)
        #manage dependency
        if(_CD_TARGET)
-            add_dependencies(livecd ${_CD_TARGET})
+            add_dependencies(livecd ${_CD_TARGET} converted_hives)
        endif()
        foreach(item ${_CD_FILE})
            if(_CD_NAME_ON_CD)
@ -289,7 +289,7 @@ function(add_cd_file)
            endforeach()
            if(_CD_TARGET)
                #manage dependency
-                add_dependencies(bootcdregtest ${_CD_TARGET})
+                add_dependencies(bootcdregtest ${_CD_TARGET} converted_hives)
            endif()
        else()
            #add it in reactos.cab
@ -459,7 +459,7 @@ function(set_module_type MODULE TYPE)

    # Handle hotpatchable images.
    # GCC has this as a function attribute so we're handling it using DECLSPEC_HOTPATCH
-    if(__module_HOTPATCHABLE AND MSVC)
+    if(__module_HOTPATCHABLE AND MSVC AND (NOT ARCH STREQUAL "arm"))
        set_property(TARGET ${MODULE} APPEND_STRING PROPERTY COMPILE_FLAGS " /hotpatch")
        if(ARCH STREQUAL "i386")
            set_property(TARGET ${MODULE} APPEND_STRING PROPERTY LINK_FLAGS " /FUNCTIONPADMIN:5")
--- a/cmake/msvc.cmake
+++ b/cmake/msvc.cmake
@ -103,10 +103,16 @@ else()
        set(rc_nologo_flag)
    endif()
    set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> ${rc_nologo_flag} <FLAGS> <DEFINES> ${I18N_DEFS} /fo<OBJECT> <SOURCE>")
+    if(ARCH STREQUAL "arm")
+        set(CMAKE_ASM_COMPILE_OBJECT
+            "cl ${cl_includes_flag} /nologo /X /I${REACTOS_SOURCE_DIR}/include/asm /I${REACTOS_BINARY_DIR}/include/asm <FLAGS> <DEFINES> /D__ASM__ /D_USE_ML /EP /c <SOURCE> > <OBJECT>.tmp"
+            "<CMAKE_ASM_COMPILER> -nologo -o <OBJECT> <OBJECT>.tmp")
+    else()
        set(CMAKE_ASM_COMPILE_OBJECT
            "cl ${cl_includes_flag} /nologo /X /I${REACTOS_SOURCE_DIR}/include/asm /I${REACTOS_BINARY_DIR}/include/asm <FLAGS> <DEFINES> /D__ASM__ /D_USE_ML /EP /c <SOURCE> > <OBJECT>.tmp"
            "<CMAKE_ASM_COMPILER> /nologo /Cp /Fo<OBJECT> /c /Ta <OBJECT>.tmp")
    endif()
+endif()

 if(_VS_ANALYZE_)
    message("VS static analysis enabled!")
@ -222,7 +228,13 @@ endfunction()

 # Define those for having real libraries
 set(CMAKE_IMPLIB_CREATE_STATIC_LIBRARY "LINK /LIB /NOLOGO <LINK_FLAGS> /OUT:<TARGET> <OBJECTS>")
+
+if(ARCH STREQUAL "arm")
+    set(CMAKE_STUB_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> -nologo -o <OBJECT> <SOURCE>")
+else()
    set(CMAKE_STUB_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> /nologo /Cp /Fo<OBJECT> /c /Ta <SOURCE>")
+endif()
+
 function(add_delay_importlibs _module)
    get_target_property(_module_type ${_module} TYPE)
    if(_module_type STREQUAL "STATIC_LIBRARY")
@ -248,9 +260,14 @@ function(generate_import_lib _libname _dllname _spec_file)

    if(MSVC_IDE)
        # Compile the generated asm stub file
+        if(ARCH STREQUAL "arm")
+            set(_asm_stub_command ${CMAKE_ASM_COMPILER} -nologo -o ${_asm_stubs_file}.obj ${_asm_stubs_file})
+        else()
+            set(_asm_stub_command ${CMAKE_ASM_COMPILER} /Cp /Fo${_asm_stubs_file}.obj /c /Ta ${_asm_stubs_file})
+        endif()
        add_custom_command(
            OUTPUT ${_asm_stubs_file}.obj
-            COMMAND ${CMAKE_ASM_COMPILER} /Cp /Fo${_asm_stubs_file}.obj /c /Ta ${_asm_stubs_file}
+            COMMAND ${_asm_stub_command}
            DEPENDS ${_asm_stubs_file})
    else()
        # Be clear about the "language"
@ -274,8 +291,13 @@ function(generate_import_lib _libname _dllname _spec_file)
 endfunction()

 if(ARCH STREQUAL "amd64")
+    # This is NOT a typo.
+    # See https://software.intel.com/en-us/forums/topic/404643
    add_definitions(/D__x86_64)
    set(SPEC2DEF_ARCH x86_64)
+elseif(ARCH STREQUAL "arm")
+    add_definitions(/D__arm__)
+    set(SPEC2DEF_ARCH arm)
 else()
    set(SPEC2DEF_ARCH i386)
 endif()
@ -320,6 +342,8 @@ set(PSEH_LIB "pseh")
 # both the x86 and x64 versions of ml are available.
 if((ARCH STREQUAL "amd64") AND (DEFINED ENV{VCINSTALLDIR}))
    set(CMAKE_ASM16_COMPILER $ENV{VCINSTALLDIR}/bin/ml.exe)
+elseif(ARCH STREQUAL "arm")
+    set(CMAKE_ASM16_COMPILER armasm.exe)
 else()
    set(CMAKE_ASM16_COMPILER ml.exe)
 endif()
@ -333,9 +357,15 @@ function(CreateBootSectorTarget _target_name _asm_file _binary_file _base_addres
        COMMAND ${CMAKE_C_COMPILER} /nologo /X /I${REACTOS_SOURCE_DIR}/include/asm /I${REACTOS_BINARY_DIR}/include/asm /D__ASM__ /D_USE_ML /EP /c ${_asm_file} > ${_temp_file}
        DEPENDS ${_asm_file})

+    if(ARCH STREQUAL "arm")
+        set(_asm16_command ${CMAKE_ASM16_COMPILER} -nologo -o ${_object_file} ${_temp_file})
+    else()
+        set(_asm16_command ${CMAKE_ASM16_COMPILER} /nologo /Cp /Fo${_object_file} /c /Ta ${_temp_file})
+    endif()
+
    add_custom_command(
        OUTPUT ${_object_file}
-        COMMAND ${CMAKE_ASM16_COMPILER} /nologo /Cp /Fo${_object_file} /c /Ta ${_temp_file}
+        COMMAND ${_asm16_command}
        DEPENDS ${_temp_file})

    add_custom_command(
@ -368,9 +398,14 @@ macro(add_asm_files _target)
                    list(APPEND _source_file_defines -D${_define})
                endif()
            endforeach()
+            if(ARCH STREQUAL "arm")
+                set(_pp_asm_compile_command ${CMAKE_ASM_COMPILER} -nologo -o ${_object_file} ${_preprocessed_asm_file})
+            else()
+                set(_pp_asm_compile_command ${CMAKE_ASM_COMPILER} /nologo /Cp /Fo${_object_file} /c /Ta ${_preprocessed_asm_file})
+            endif()
            add_custom_command(
                OUTPUT ${_preprocessed_asm_file} ${_object_file}
-                COMMAND cl /nologo /X /I${REACTOS_SOURCE_DIR}/include/asm /I${REACTOS_BINARY_DIR}/include/asm ${_directory_includes} ${_source_file_defines} ${_directory_defines} /D__ASM__ /D_USE_ML /EP /c ${_source_file_full_path} > ${_preprocessed_asm_file} && ${CMAKE_ASM_COMPILER} /nologo /Cp /Fo${_object_file} /c /Ta ${_preprocessed_asm_file}
+                COMMAND cl /nologo /X /I${REACTOS_SOURCE_DIR}/include/asm /I${REACTOS_BINARY_DIR}/include/asm ${_directory_includes} ${_source_file_defines} ${_directory_defines} /D__ASM__ /D_USE_ML /EP /c ${_source_file_full_path} > ${_preprocessed_asm_file} && ${_pp_asm_compile_command}
                DEPENDS ${_source_file_full_path})
            set_source_files_properties(${_object_file} PROPERTIES EXTERNAL_OBJECT 1)
            list(APPEND ${_target} ${_object_file})
--- a/dll/cpl/appwiz/createlink.c
+++ b/dll/cpl/appwiz/createlink.c
@ -226,11 +226,7 @@ WelcomeDlgProc(HWND hwndDlg,
                        LoadStringW(hApplet, IDS_ERROR_NOT_FOUND, szPath, MAX_PATH) < MAX_PATH)
                    {
                        WCHAR szError[MAX_PATH + 100];
-#ifdef _MSC_VER
-                        _swprintf(szError, szPath, pContext->szTarget);
-#else
                        swprintf(szError, szPath, pContext->szTarget);
-#endif
                        MessageBoxW(hwndDlg, szError, szDesc, MB_ICONERROR);
                    }
                    SendDlgItemMessage(hwndDlg, IDC_SHORTCUT_LOCATION, EM_SETSEL, 0, -1);
--- a/dll/ntdll/def/ntdll.spec
+++ b/dll/ntdll/def/ntdll.spec
@ -1,4 +1,15 @@
-
+;@ stdcall PropertyLengthAsVariant(ptr long long long)
+;@ stdcall RtlConvertPropertyToVariant(ptr long ptr ptr)
+;@ stdcall RtlConvertVariantToProperty(ptr long ptr ptr ptr long ptr)
+@ fastcall RtlActivateActivationContextUnsafeFast(ptr ptr)
+@ fastcall RtlDeactivateActivationContextUnsafeFast(ptr)
+@ stdcall RtlInterlockedPushListSList(ptr ptr ptr long)
+@ fastcall -arch=i386 RtlUlongByteSwap(long)
+@ fastcall -ret64 RtlUlonglongByteSwap(double)
+@ fastcall -arch=i386 RtlUshortByteSwap(long)
+@ stdcall -arch=i386,x86_64 ExpInterlockedPopEntrySListEnd()
+@ stdcall -arch=i386,x86_64 ExpInterlockedPopEntrySListFault()
+@ stdcall -arch=i386,x86_64 ExpInterlockedPopEntrySListResume()
@ stdcall CsrAllocateCaptureBuffer(long long)
@ stdcall CsrAllocateMessagePointer(ptr long ptr)
@ stdcall CsrCaptureMessageBuffer(ptr ptr long ptr)
@ -32,12 +43,42 @@
@ stdcall DbgUiStopDebugging(ptr)
@ stdcall DbgUiWaitStateChange(ptr ptr)
@ stdcall DbgUserBreakPoint()
+# EtwControlTraceA
+# EtwControlTraceW
+# EtwCreateTraceInstanceId
+# EtwEnableTrace
+# EtwEnumerateTraceGuids
+# EtwFlushTraceA
+# EtwFlushTraceW
+# EtwGetTraceEnableFlags
+# EtwGetTraceEnableLevel
+# EtwGetTraceLoggerHandle
+# EtwNotificationRegistrationA
+# EtwNotificationRegistrationW
+# EtwQueryAllTracesA
+# EtwQueryAllTracesW
+# EtwQueryTraceA
+# EtwQueryTraceW
+# EtwReceiveNotificationsA
+# EtwReceiveNotificationsW
+# EtwRegisterTraceGuidsA
+# EtwRegisterTraceGuidsW
+# EtwStartTraceA
+# EtwStartTraceW
+# EtwStopTraceA
+# EtwStopTraceW
+# EtwTraceEvent
+# EtwTraceEventInstance
+# EtwTraceMessage
+# EtwTraceMessageVa
+# EtwUnregisterTraceGuids
+# EtwUpdateTraceA
+# EtwUpdateTraceW
+# EtwpGetTraceBuffer
+# EtwpSetHWConfigFunction
@ stdcall -arch=i386 KiFastSystemCall()
@ stdcall -arch=i386 KiFastSystemCallRet()
@ stdcall -arch=i386 KiIntSystemCall()
-@ stdcall -arch=i386,x86_64 ExpInterlockedPopEntrySListEnd()
-@ stdcall -arch=i386,x86_64 ExpInterlockedPopEntrySListFault()
-@ stdcall -arch=i386,x86_64 ExpInterlockedPopEntrySListResume()
@ stdcall KiRaiseUserExceptionDispatcher()
@ stdcall KiUserApcDispatcher(ptr ptr ptr ptr)
@ stdcall KiUserCallbackDispatcher(ptr ptr long) ; CHECKME
@ -69,6 +110,7 @@
@ stdcall LdrOpenImageFileOptionsKey(ptr long ptr) ; 5.2 SP1 and higher
@ stdcall LdrProcessRelocationBlock(ptr long ptr long)
@ stdcall LdrQueryImageFileExecutionOptions(ptr str long ptr long ptr)
+;@ stdcall LdrQueryImageFileExecutionOptionsEx(ptr ptr long ptr long ptr long)
@ stdcall LdrQueryImageFileKeyOption(ptr ptr long ptr long ptr)
@ stdcall LdrQueryProcessModuleInformation(ptr long ptr)
 ;@ stdcall LdrSetAppCompatDllRedirectionCallback
@ -148,6 +190,7 @@
@ stdcall NtDelayExecution(long ptr)
@ stdcall NtDeleteAtom(long)
@ stdcall NtDeleteBootEntry(long)
+# NtDeleteDriverEntry
@ stdcall NtDeleteFile(ptr)
@ stdcall NtDeleteKey(long)
@ stdcall NtDeleteObjectAuditAlarm(ptr ptr long)
@ -157,6 +200,7 @@
@ stdcall NtDuplicateObject(long long long ptr long long long)
@ stdcall NtDuplicateToken(long long long long long long)
@ stdcall NtEnumerateBootEntries(ptr ptr)
+;@ stdcall NtEnumerateDriverEntries(ptr ptr)
@ stdcall NtEnumerateKey (long long long long long long)
@ stdcall NtEnumerateSystemEnvironmentValuesEx(long ptr long)
@ stdcall NtEnumerateValueKey(long long long long long long)
@ -188,6 +232,7 @@
@ stdcall NtLoadDriver(ptr)
@ stdcall NtLoadKey2(ptr ptr long)
@ stdcall NtLoadKey(ptr ptr)
+;@ stdcall NtLoadKeyEx(ptr ptr long ptr)
@ stdcall NtLockFile(long long ptr ptr ptr ptr ptr ptr long long)
@ stdcall NtLockProductActivationKeys(ptr ptr)
@ stdcall NtLockRegistryKey(ptr)
@ -198,6 +243,7 @@
@ stdcall NtMapUserPhysicalPagesScatter(ptr ptr ptr)
@ stdcall NtMapViewOfSection(long long ptr long long ptr ptr long long long)
@ stdcall NtModifyBootEntry(ptr)
+# NtModifyDriverEntry
@ stdcall NtNotifyChangeDirectoryFile(long long ptr ptr ptr ptr long long long)
@ stdcall NtNotifyChangeKey(long long ptr ptr ptr long long ptr long long)
@ stdcall NtNotifyChangeMultipleKeys(ptr long ptr ptr ptr ptr ptr long long ptr long long)
@ -236,6 +282,7 @@
@ stdcall NtQueryDefaultUILanguage(ptr)
@ stdcall NtQueryDirectoryFile(long long ptr ptr ptr ptr long long long ptr long)
@ stdcall NtQueryDirectoryObject(long ptr long long long ptr ptr)
+;@ stdcall NtQueryDriverEntryOrder(ptr ptr)
@ stdcall NtQueryEaFile(long ptr ptr long long ptr long ptr long)
@ stdcall NtQueryEvent(long long ptr long ptr)
@ stdcall NtQueryFullAttributesFile(ptr ptr)
@ -254,6 +301,7 @@
@ stdcall NtQueryMutant(long long ptr long ptr)
@ stdcall NtQueryObject(long long long long long)
@ stdcall NtQueryOpenSubKeys(ptr ptr)
+;@ stdcall NtQueryOpenSubKeysEx(ptr long ptr ptr)
@ stdcall NtQueryPerformanceCounter(ptr ptr)
@ stdcall NtQueryPortInformationProcess()
@ stdcall NtQueryQuotaInformationFile(ptr ptr ptr long long ptr long ptr long)
@ -309,6 +357,7 @@
@ stdcall NtSetDefaultHardErrorPort(ptr)
@ stdcall NtSetDefaultLocale(long long)
@ stdcall NtSetDefaultUILanguage(long)
+;@ stdcall NtSetDriverEntryOrder(ptr ptr)
@ stdcall NtSetEaFile(long ptr ptr long)
@ stdcall NtSetEvent(long long)
@ stdcall NtSetEventBoostPriority(ptr)
@ -354,6 +403,7 @@
@ stdcall NtTraceEvent(long long long ptr)
@ stdcall NtTranslateFilePath(ptr long ptr long)
@ stdcall NtUnloadDriver(ptr)
+;@ stdcall NtUnloadKey2(ptr long)
@ stdcall NtUnloadKey(long)
@ stdcall NtUnloadKeyEx(ptr ptr)
@ stdcall NtUnlockFile(long ptr ptr ptr ptr)
@ -362,6 +412,7 @@
@ stdcall NtVdmControl(long ptr)
@ stdcall NtWaitForDebugEvent(ptr long ptr ptr)
@ stdcall NtWaitForKeyedEvent(ptr ptr long ptr)
+;@ stdcall NtWaitForMultipleObjects32(long ptr long long ptr)
@ stdcall NtWaitForMultipleObjects(long ptr long long ptr)
@ stdcall NtWaitForSingleObject(long long long)
@ stdcall NtWaitHighEventPair(ptr)
@ -375,18 +426,14 @@
 ;@ stdcall PfxInitialize
 ;@ stdcall PfxInsertPrefix
 ;@ stdcall PfxRemovePrefix
-;@ stdcall PropertyLengthAsVariant
@ stdcall RtlAbortRXact(ptr)
@ stdcall RtlAbsoluteToSelfRelativeSD(ptr ptr ptr)
@ stdcall RtlAcquirePebLock()
@ stdcall RtlAcquirePrivilege(ptr long long ptr)
@ stdcall RtlAcquireResourceExclusive(ptr long)
@ stdcall RtlAcquireResourceShared(ptr long)
-@ stdcall RtlAcquireSRWLockExclusive(ptr)
-@ stdcall RtlAcquireSRWLockShared(ptr)
@ stdcall RtlActivateActivationContext(long ptr ptr)
@ stdcall RtlActivateActivationContextEx(long ptr ptr ptr)
-@ fastcall RtlActivateActivationContextUnsafeFast(ptr ptr)
@ stdcall RtlAddAccessAllowedAce(ptr long long ptr)
@ stdcall RtlAddAccessAllowedAceEx(ptr long long long ptr)
@ stdcall RtlAddAccessAllowedObjectAce(ptr long long long ptr ptr ptr)
@ -401,9 +448,7 @@
@ stdcall RtlAddAuditAccessAceEx(ptr long long long ptr long long)
@ stdcall RtlAddAuditAccessObjectAce(ptr long long long ptr ptr ptr long long)
 ;@ stdcall RtlAddCompoundAce
-;@ stdcall RtlAddRange ; 5.0 and 5.1 only
@ stdcall -arch=x86_64 RtlAddFunctionTable(ptr long long)
-;@ stdcall RtlAddMandatoryAce(ptr long long long long ptr)
@ stdcall RtlAddRefActivationContext(ptr)
@ stdcall RtlAddRefMemoryStream(ptr)
@ stdcall RtlAddVectoredContinueHandler(long ptr)
@ -454,19 +499,16 @@
@ stdcall RtlConsoleMultiByteToUnicodeN(ptr long ptr ptr long ptr)
@ stdcall RtlConvertExclusiveToShared(ptr)
@ stdcall -arch=win32 -ret64 RtlConvertLongToLargeInteger(long)
-;@ stdcall RtlConvertPropertyToVariant
@ stdcall RtlConvertSharedToExclusive(ptr)
@ stdcall RtlConvertSidToUnicodeString(ptr ptr long)
@ stdcall RtlConvertToAutoInheritSecurityObject(ptr ptr ptr ptr long ptr)
 ;@ stdcall RtlConvertUiListToApiList
@ stdcall -arch=win32 -ret64 RtlConvertUlongToLargeInteger(long)
-;@ stdcall RtlConvertVariantToProperty
@ stdcall RtlCopyLuid(ptr ptr)
@ stdcall RtlCopyLuidAndAttributesArray(long ptr ptr)
 ;@ stdcall RtlCopyMappedMemory
@ stdcall RtlCopyMemoryStreamTo(ptr ptr int64 ptr ptr)
@ stdcall RtlCopyOutOfProcessMemoryStreamTo(ptr ptr int64 ptr ptr) RtlCopyMemoryStreamTo
-;@ stdcall RtlCopyRangeList ; 5.0 and 5.1 only
@ stdcall RtlCopySecurityDescriptor(ptr ptr)
@ stdcall RtlCopySid(long ptr ptr)
@ stdcall RtlCopySidAndAttributesArray(long ptr long ptr ptr ptr ptr)
@ -496,7 +538,7 @@
@ stdcall RtlCutoverTimeToSystemTime(ptr ptr ptr long)
@ stdcall RtlDeNormalizeProcessParams(ptr)
@ stdcall RtlDeactivateActivationContext(long long)
-@ fastcall RtlDeactivateActivationContextUnsafeFast(ptr)
+# RtlDebugPrintTimes
@ stdcall RtlDecodePointer(ptr)
@ stdcall RtlDecodeSystemPointer(ptr) RtlEncodeSystemPointer
@ stdcall RtlDecompressBuffer(long ptr long ptr long ptr)
@ -510,8 +552,6 @@
@ stdcall RtlDeleteElementGenericTableAvl(ptr ptr)
@ cdecl -arch=x86_64 RtlDeleteFunctionTable(ptr)
@ stdcall RtlDeleteNoSplay(ptr ptr)
-@ stdcall RtlDeleteOwnersRanges(ptr ptr)
-@ stdcall RtlDeleteRange(ptr long long long long ptr)
@ stdcall RtlDeleteRegistryValue(long ptr ptr)
@ stdcall RtlDeleteResource(ptr)
@ stdcall RtlDeleteSecurityObject(ptr)
@ -579,18 +619,13 @@
@ stdcall RtlFindClearBitsAndSet(ptr long long)
@ stdcall RtlFindClearRuns(ptr ptr long long)
@ stdcall RtlFindLastBackwardRunClear(ptr long ptr)
-;@ stdcall RtlFindLastBackwardRunSet(ptr long ptr)
@ stdcall RtlFindLeastSignificantBit(double)
@ stdcall RtlFindLongestRunClear(ptr long)
-@ stdcall RtlFindLongestRunSet(ptr long)
@ stdcall RtlFindMessage(long long long long ptr)
@ stdcall RtlFindMostSignificantBit(double)
@ stdcall RtlFindNextForwardRunClear(ptr long ptr)
-;@ stdcall RtlFindNextForwardRunSet(ptr long ptr)
-@ stdcall RtlFindRange(ptr long long long long long long long long ptr ptr ptr)
@ stdcall RtlFindSetBits(ptr long long)
@ stdcall RtlFindSetBitsAndClear(ptr long long)
-;@ stdcall RtlFindSetRuns(ptr ptr long long)
@ stdcall RtlFirstEntrySList(ptr)
@ stdcall RtlFirstFreeAce(ptr ptr)
@ stdcall RtlFlushSecureMemoryCache(ptr ptr)
@ -602,7 +637,6 @@
@ stdcall RtlFreeHandle(ptr ptr)
@ stdcall RtlFreeHeap(long long long)
@ stdcall RtlFreeOemString(ptr)
-@ stdcall RtlFreeRangeList(ptr)
@ stdcall RtlFreeSid(long)
@ stdcall RtlFreeThreadActivationContextStack()
@ stdcall RtlFreeUnicodeString(ptr)
@ -621,7 +655,6 @@
@ stdcall RtlGetDaclSecurityDescriptor(ptr ptr ptr ptr)
@ stdcall RtlGetElementGenericTable(ptr long)
@ stdcall RtlGetElementGenericTableAvl(ptr long)
-@ stdcall RtlGetFirstRange(ptr ptr ptr)
 ;@ stdcall RtlGetFrame
@ stdcall RtlGetFullPathName_U(wstr long ptr ptr)
@ stdcall RtlGetFullPathName_UstrEx(ptr ptr ptr ptr ptr ptr ptr ptr)
@ -633,12 +666,10 @@
@ stdcall RtlGetLengthWithoutTrailingPathSeperators(long ptr ptr) RtlGetLengthWithoutTrailingPathSeparators
@ stdcall RtlGetLongestNtPathLength()
@ stdcall RtlGetNativeSystemInformation(long long long long) NtQuerySystemInformation
-@ stdcall RtlGetNextRange(ptr ptr long)
@ stdcall RtlGetNtGlobalFlags()
@ stdcall RtlGetNtProductType(ptr)
@ stdcall RtlGetNtVersionNumbers(ptr ptr ptr)
@ stdcall RtlGetOwnerSecurityDescriptor(ptr ptr ptr)
-;@ stdcall RtlGetProductInfo(long long long long ptr)
@ stdcall RtlGetProcessHeaps(long ptr)
@ stdcall RtlGetSaclSecurityDescriptor(ptr ptr ptr ptr)
@ stdcall RtlGetSecurityDescriptorRMControl(ptr ptr)
@ -669,19 +700,17 @@
@ stdcall RtlInitializeContext(ptr ptr ptr ptr ptr)
@ stdcall RtlInitializeCriticalSection(ptr)
@ stdcall RtlInitializeCriticalSectionAndSpinCount(ptr long)
-;@ stdcall RtlInitializeCriticalSectionEx(ptr long long)
@ stdcall RtlInitializeGenericTable(ptr ptr ptr ptr ptr)
@ stdcall RtlInitializeGenericTableAvl(ptr ptr ptr ptr ptr)
@ stdcall RtlInitializeHandleTable(long long ptr)
@ stdcall RtlInitializeRXact(ptr long ptr)
-@ stdcall RtlInitializeRangeList(ptr)
@ stdcall RtlInitializeResource(ptr)
@ stdcall RtlInitializeSListHead(ptr)
@ stdcall RtlInitializeSid(ptr ptr long)
-@ stdcall RtlInitializeSRWLock(ptr)
-;@ stdcall RtlInitializeStackTraceDataBase ; 5.1 SP2 and SP3, and 5.2 only
@ stdcall RtlInsertElementGenericTable(ptr ptr long ptr)
@ stdcall RtlInsertElementGenericTableAvl(ptr ptr long ptr)
+# RtlInsertElementGenericTableFull
+;@ stdcall RtlInsertElementGenericTableFullAvl(ptr ptr long ptr ptr long)
@ stdcall -arch=x86_64 RtlInstallFunctionTableCallback(double double long ptr ptr ptr)
@ stdcall RtlInt64ToUnicodeString(double long ptr)
@ stdcall RtlIntegerToChar(long long long ptr)
@ -690,8 +719,6 @@
@ stdcall -arch=i386,x86_64 RtlInterlockedFlushSList(ptr)
@ stdcall -arch=i386,x86_64 RtlInterlockedPopEntrySList(ptr)
@ stdcall -arch=i386,x86_64 RtlInterlockedPushEntrySList(ptr ptr)
-@ stdcall RtlInterlockedPushListSList(ptr ptr ptr long)
-@ stdcall RtlInvertRangeList(ptr ptr)
@ stdcall RtlIpv4AddressToStringA(ptr ptr)
@ stdcall RtlIpv4AddressToStringExA(ptr long ptr ptr)
@ stdcall RtlIpv4AddressToStringExW(ptr long ptr ptr)
@ -715,7 +742,6 @@
@ stdcall RtlIsGenericTableEmpty(ptr)
@ stdcall RtlIsGenericTableEmptyAvl(ptr)
@ stdcall RtlIsNameLegalDOS8Dot3(ptr ptr ptr)
-@ stdcall RtlIsRangeAvailable(ptr long long long long long long ptr ptr ptr)
@ stdcall RtlIsTextUnicode(ptr long ptr)
@ stdcall RtlIsThreadWithinLoaderCallout()
@ stdcall RtlIsValidHandle(ptr ptr)
@ -740,15 +766,18 @@
@ stdcall RtlLookupAtomInAtomTable(ptr wstr ptr)
@ stdcall RtlLookupElementGenericTable(ptr ptr)
@ stdcall RtlLookupElementGenericTableAvl(ptr ptr)
+# RtlLookupElementGenericTableFull
+# RtlLookupElementGenericTableFullAvl
@ stdcall -arch=x86_64 RtlLookupFunctionEntry(long ptr ptr)
@ stdcall RtlMakeSelfRelativeSD(ptr ptr ptr)
@ stdcall RtlMapGenericMask(long ptr)
 ;@ stdcall RtlMapSecurityErrorToNtStatus
-@ stdcall RtlMergeRangeLists(ptr ptr ptr long)
@ stdcall RtlMoveMemory(ptr ptr long)
@ stdcall RtlMultiAppendUnicodeStringBuffer(ptr long ptr)
@ stdcall RtlMultiByteToUnicodeN(ptr long ptr ptr long)
@ stdcall RtlMultiByteToUnicodeSize(ptr str long)
+# RtlMultipleAllocateHeap
+# RtlMultipleFreeHeap
@ stdcall RtlNewInstanceSecurityObject(long long ptr ptr ptr ptr ptr long ptr ptr)
@ stdcall RtlNewSecurityGrantedAccess(long ptr ptr ptr ptr ptr)
@ stdcall RtlNewSecurityObject(ptr ptr ptr long ptr ptr)
@ -771,7 +800,6 @@
 ;@ stdcall RtlPopFrame
@ stdcall RtlPrefixString(ptr ptr long)
@ stdcall RtlPrefixUnicodeString(ptr ptr long)
-;@ stdcall RtlPropertySetNameToGuid ; 4.0 only
@ stdcall RtlProtectHeap(ptr long)
 ;@ stdcall RtlPushFrame
@ stdcall RtlQueryAtomInAtomTable(ptr long ptr ptr ptr ptr)
@ -786,9 +814,6 @@
@ stdcall RtlQueryProcessDebugInformation(long long ptr)
 ;@ stdcall RtlQueryProcessHeapInformation
 ;@ stdcall RtlQueryProcessLockInformation
-;@ stdcall RtlQueryProperties ; 4.0 only
-;@ stdcall RtlQueryPropertyNames ; 4.0 only
-;@ stdcall RtlQueryPropertySet ; 4.0 only
@ stdcall RtlQueryRegistryValues(long ptr ptr ptr ptr)
@ stdcall RtlQuerySecurityObject(ptr long ptr long ptr)
@ stdcall RtlQueryTagHeap(ptr long long long ptr)
@ -812,8 +837,6 @@
@ stdcall RtlReleasePrivilege(ptr)
@ stdcall RtlReleaseRelativeName(ptr)
@ stdcall RtlReleaseResource(ptr)
-@ stdcall RtlReleaseSRWLockExclusive(ptr)
-@ stdcall RtlReleaseSRWLockShared(ptr)
@ stdcall RtlRemoteCall(ptr ptr ptr long ptr long long)
@ stdcall RtlRemoveVectoredContinueHandler(ptr)
@ stdcall RtlRemoveVectoredExceptionHandler(ptr)
@ -847,10 +870,6 @@
@ stdcall RtlSetMemoryStreamSize(ptr int64)
@ stdcall RtlSetOwnerSecurityDescriptor(ptr ptr long)
@ cdecl RtlSetProcessIsCritical(long ptr long)
-;@ stdcall RtlSetProperties ; RtlSetProperties
-;@ stdcall RtlSetPropertyClassId ; 4.0 only
-;@ stdcall RtlSetPropertyNames ; 4.0 only
-;@ stdcall RtlSetPropertySetClassId ; 4.0 only
@ stdcall RtlSetSaclSecurityDescriptor(ptr long ptr long)
@ stdcall RtlSetSecurityDescriptorRMControl(ptr ptr)
@ stdcall RtlSetSecurityObject(long ptr ptr ptr ptr)
@ -865,8 +884,6 @@
@ stdcall RtlSetUserFlagsHeap(ptr long ptr long long)
@ stdcall RtlSetUserValueHeap(ptr long ptr ptr)
@ stdcall RtlSizeHeap(long long ptr)
-@ stdcall RtlSleepConditionVariableCS(ptr ptr ptr)
-@ stdcall RtlSleepConditionVariableSRW(ptr ptr ptr long)
@ stdcall RtlSplay(ptr)
@ stdcall RtlStartRXact(ptr)
@ stdcall RtlStatMemoryStream(ptr ptr long)
@ -890,8 +907,6 @@
 ;@ stdcall RtlTraceDatabaseUnlock
 ;@ stdcall RtlTraceDatabaseValidate
@ stdcall RtlTryEnterCriticalSection(ptr)
-@ fastcall -arch=i386 RtlUlongByteSwap(long)
-@ fastcall -ret64 RtlUlonglongByteSwap(double)
 ;@ stdcall RtlUnhandledExceptionFilter2
@ stdcall RtlUnhandledExceptionFilter(ptr)
 ;@ stdcall RtlUnicodeStringToAnsiSize(ptr)
@ -922,7 +937,6 @@
@ stdcall RtlUpperChar(long)
@ stdcall RtlUpperString(ptr ptr)
@ stdcall RtlUsageHeap(ptr long ptr)
-@ fastcall -arch=i386 RtlUshortByteSwap(long)
@ stdcall RtlValidAcl(ptr)
@ stdcall RtlValidRelativeSecurityDescriptor(ptr long long)
@ stdcall RtlValidSecurityDescriptor(ptr)
@ -936,8 +950,6 @@
@ stdcall RtlWalkHeap(long ptr)
@ stdcall RtlWow64EnableFsRedirection(long)
@ stdcall RtlWow64EnableFsRedirectionEx(long ptr)
-@ stdcall RtlWakeAllConditionVariable(ptr)
-@ stdcall RtlWakeConditionVariable(ptr)
@ stdcall RtlWriteMemoryStream(ptr ptr long ptr)
@ stdcall RtlWriteRegistryValue(long ptr ptr long ptr long)
@ stdcall RtlZeroHeap(ptr long)
@ -969,6 +981,7 @@
@ stdcall ZwAccessCheckByTypeResultListAndAuditAlarmByHandle(ptr ptr ptr ptr ptr ptr ptr long long long ptr long ptr long ptr ptr ptr) NtAccessCheckByTypeResultListAndAuditAlarmByHandle
@ stdcall ZwAddAtom(ptr long ptr) NtAddAtom
@ stdcall ZwAddBootEntry(ptr long)
+# ZwAddDriverEntry
@ stdcall ZwAdjustGroupsToken(long long long long long long) NtAdjustGroupsToken
@ stdcall ZwAdjustPrivilegesToken(long long long long long long) NtAdjustPrivilegesToken
@ stdcall ZwAlertResumeThread(long ptr) NtAlertResumeThread
@ -977,12 +990,12 @@
@ stdcall ZwAllocateUserPhysicalPages(ptr ptr ptr)
@ stdcall ZwAllocateUuids(ptr ptr ptr ptr) NtAllocateUuids
@ stdcall ZwAllocateVirtualMemory(long ptr ptr ptr long long) NtAllocateVirtualMemory
+# ZwApphelpCacheControl
@ stdcall ZwAreMappedFilesTheSame(ptr ptr) NtAreMappedFilesTheSame
@ stdcall ZwAssignProcessToJobObject(long long) NtAssignProcessToJobObject
@ stdcall ZwCallbackReturn(ptr long long)
@ stdcall ZwCancelDeviceWakeupRequest(ptr)
@ stdcall ZwCancelIoFile(long ptr) NtCancelIoFile
-;@ stdcall ZwCancelIoFileEx(long ptr ptr) NtCancelIoFileEx
@ stdcall ZwCancelTimer(long ptr) NtCancelTimer
@ stdcall ZwClearEvent(long) NtClearEvent
@ stdcall ZwClose(long) NtClose
@ -1023,6 +1036,7 @@
@ stdcall ZwDelayExecution(long ptr) NtDelayExecution
@ stdcall ZwDeleteAtom(long) NtDeleteAtom
@ stdcall ZwDeleteBootEntry(long) NtDeleteBootEntry
+# ZwDeleteDriverEntry
@ stdcall ZwDeleteFile(ptr) NtDeleteFile
@ stdcall ZwDeleteKey(long) NtDeleteKey
@ stdcall ZwDeleteObjectAuditAlarm(ptr ptr long)
@ -1032,7 +1046,7 @@
@ stdcall ZwDuplicateObject(long long long ptr long long long) NtDuplicateObject
@ stdcall ZwDuplicateToken(long long long long long long) NtDuplicateToken
@ stdcall ZwEnumerateBootEntries(ptr ptr)
-;@ stdcall ZwEnumerateBus ; 3.51 only
+# ZwEnumerateDriverEntries
@ stdcall ZwEnumerateKey(long long long ptr long ptr) NtEnumerateKey
@ stdcall ZwEnumerateSystemEnvironmentValuesEx(long ptr long) NtEnumerateSystemEnvironmentValuesEx
@ stdcall ZwEnumerateValueKey(long long long ptr long ptr) NtEnumerateValueKey
@ -1051,7 +1065,6 @@
@ stdcall ZwGetCurrentProcessorNumber()
@ stdcall ZwGetDevicePowerState(ptr ptr)
@ stdcall ZwGetPlugPlayEvent(long long ptr long)
-@ stdcall ZwGetTickCount() RtlGetTickCount
@ stdcall ZwGetWriteWatch(long long ptr long ptr ptr ptr) NtGetWriteWatch
@ stdcall ZwImpersonateAnonymousToken(ptr)
@ stdcall ZwImpersonateClientOfPort(ptr ptr) NtImpersonateClientOfPort
@ -1064,6 +1077,7 @@
@ stdcall ZwLoadDriver(ptr) NtLoadDriver
@ stdcall ZwLoadKey2(ptr ptr long) NtLoadKey2
@ stdcall ZwLoadKey(ptr ptr) NtLoadKey
+# ZwLoadKeyEx
@ stdcall ZwLockFile(long long ptr ptr ptr ptr ptr ptr long long) NtLockFile
@ stdcall ZwLockProductActivationKeys(ptr ptr) NtLockProductActivationKeys
@ stdcall ZwLockRegistryKey(ptr) NtLockRegistryKey
@ -1074,6 +1088,7 @@
@ stdcall ZwMapUserPhysicalPagesScatter(ptr ptr ptr)
@ stdcall ZwMapViewOfSection(long long ptr long long ptr ptr long long long) NtMapViewOfSection
@ stdcall ZwModifyBootEntry(ptr) NtModifyBootEntry
+# ZwModifyDriverEntry
@ stdcall ZwNotifyChangeDirectoryFile(long long ptr ptr ptr ptr long long long) NtNotifyChangeDirectoryFile
@ stdcall ZwNotifyChangeKey(long long ptr ptr ptr long long ptr long long) NtNotifyChangeKey
@ stdcall ZwNotifyChangeMultipleKeys(ptr long ptr ptr ptr ptr ptr long long ptr long long) NtNotifyChangeMultipleKeys
@ -1112,6 +1127,7 @@
@ stdcall ZwQueryDefaultUILanguage(ptr) NtQueryDefaultUILanguage
@ stdcall ZwQueryDirectoryFile(long long ptr ptr ptr ptr long long long ptr long) NtQueryDirectoryFile
@ stdcall ZwQueryDirectoryObject(long ptr long long long ptr ptr) NtQueryDirectoryObject
+# ZwQueryDriverEntryOrder
@ stdcall ZwQueryEaFile(long ptr ptr long long ptr long ptr long) NtQueryEaFile
@ stdcall ZwQueryEvent(long long ptr long ptr) NtQueryEvent
@ stdcall ZwQueryFullAttributesFile(ptr ptr) NtQueryFullAttributesFile
@ -1130,6 +1146,7 @@
@ stdcall ZwQueryMutant(long long ptr long ptr) NtQueryMutant
@ stdcall ZwQueryObject(long long long long long) NtQueryObject
@ stdcall ZwQueryOpenSubKeys(ptr ptr) NtQueryOpenSubKeys
+# ZwQueryOpenSubKeysEx
@ stdcall ZwQueryPerformanceCounter (long long) NtQueryPerformanceCounter
@ stdcall ZwQueryPortInformationProcess() NtQueryPortInformationProcess
@ stdcall ZwQueryQuotaInformationFile(ptr ptr ptr long long ptr long ptr long) NtQueryQuotaInformationFile
@ -1153,11 +1170,9 @@
@ stdcall ZwReadFileScatter(long long ptr ptr ptr ptr long ptr ptr) NtReadFileScatter
@ stdcall ZwReadRequestData(ptr ptr long ptr long ptr) NtReadRequestData
@ stdcall ZwReadVirtualMemory(long ptr ptr long ptr) NtReadVirtualMemory
-;@ stdcall ZwRegisterNewDevice ; 3.51 only
@ stdcall ZwRegisterThreadTerminatePort(ptr) NtRegisterThreadTerminatePort
@ stdcall ZwReleaseKeyedEvent(ptr ptr long ptr) NtReleaseKeyedEvent
@ stdcall ZwReleaseMutant(long ptr) NtReleaseMutant
-;@ stdcall ZwReleaseProcessMutant ; 3.51 only
@ stdcall ZwReleaseSemaphore(long long ptr) NtReleaseSemaphore
@ stdcall ZwRemoveIoCompletion(ptr ptr ptr ptr ptr) NtRemoveIoCompletion
@ stdcall ZwRemoveProcessDebug(ptr ptr) NtRemoveProcessDebug
@ -1187,12 +1202,12 @@
@ stdcall ZwSetDefaultHardErrorPort(ptr)
@ stdcall ZwSetDefaultLocale(long long)
@ stdcall ZwSetDefaultUILanguage(long)
+# ZwSetDriverEntryOrder
@ stdcall ZwSetEaFile(long ptr ptr long)
@ stdcall ZwSetEvent(long long)
@ stdcall ZwSetEventBoostPriority(ptr)
@ stdcall ZwSetHighEventPair(ptr)
@ stdcall ZwSetHighWaitLowEventPair(ptr)
-;@ stdcall ZwSetHighWaitLowThread ; 3.51 and 4.0 only
@ stdcall ZwSetInformationDebugObject(ptr long ptr long ptr)
@ stdcall ZwSetInformationFile(long long long long long)
@ stdcall ZwSetInformationJobObject(long long ptr long)
@ -1206,7 +1221,6 @@
@ stdcall ZwSetLdtEntries(long double long double) ; CHECKME
@ stdcall ZwSetLowEventPair(ptr)
@ stdcall ZwSetLowWaitHighEventPair(ptr)
-;@ stdcall ZwSetLowWaitHighThread ; 3.51 and 4.0 only
@ stdcall ZwSetQuotaInformationFile(ptr ptr ptr long)
@ stdcall ZwSetSecurityObject(long long ptr)
@ stdcall ZwSetSystemEnvironmentValue(ptr ptr)
@ -1234,17 +1248,17 @@
@ stdcall ZwTraceEvent(long long long ptr)
@ stdcall ZwTranslateFilePath(ptr long ptr long)
@ stdcall ZwUnloadDriver(ptr)
+# ZwUnloadKey2
@ stdcall ZwUnloadKey(long)
@ stdcall ZwUnloadKeyEx(ptr ptr)
@ stdcall ZwUnlockFile(long ptr ptr ptr ptr)
@ stdcall ZwUnlockVirtualMemory(long ptr ptr long)
@ stdcall ZwUnmapViewOfSection(long ptr)
@ stdcall ZwVdmControl(long ptr)
-;@ stdcall ZwW32Call(long ptr long ptr ptr)
@ stdcall ZwWaitForDebugEvent(ptr long ptr ptr)
@ stdcall ZwWaitForKeyedEvent(ptr ptr long ptr)
+# ZwWaitForMultipleObjects32
@ stdcall ZwWaitForMultipleObjects(long ptr long long ptr)
-;@ stdcall ZwWaitForProcessMutant ; 3.51 only
@ stdcall ZwWaitForSingleObject(long long long)
@ stdcall ZwWaitHighEventPair(ptr)
@ stdcall ZwWaitLowEventPair(ptr)
@ -1310,6 +1324,7 @@
@ cdecl _wcsicmp(wstr wstr)
@ cdecl _wcslwr(wstr)
@ cdecl _wcsnicmp(wstr wstr long)
+# _wcstoui64
@ cdecl _wcsupr(wstr)
@ cdecl _wtoi(wstr)
@ cdecl _wtoi64(wstr)
@ -1392,7 +1407,6 @@
@ cdecl wcsrchr(wstr long)
@ cdecl wcsspn(wstr wstr)
@ cdecl wcsstr(wstr wstr)
-;@ cdecl wcstok(wstr wstr)
@ cdecl wcstol(wstr ptr long)
@ cdecl wcstombs(ptr ptr long)
@ cdecl wcstoul(wstr ptr long)
--- a/dll/win32/advapi32/misc/logon.c
+++ b/dll/win32/advapi32/misc/logon.c
@ -463,7 +463,7 @@ LogonUserW(LPWSTR lpszUsername,
                                        SE_GROUP_ENABLED_BY_DEFAULT;

    /* Set the token source */
-    strcpy(TokenSource.SourceName, "LogonUser");
+    strncpy(TokenSource.SourceName, "Advapi  ", sizeof(TokenSource.SourceName));
    AllocateLocallyUniqueId(&TokenSource.SourceIdentifier);

    Status = LsaLogonUser(LsaHandle,
--- a/dll/win32/browseui/internettoolbar.cpp
+++ b/dll/win32/browseui/internettoolbar.cpp
@ -29,7 +29,7 @@ toolbar, and address band for an explorer window
 #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
 #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))

-#define USE_CUSTOM_MENUBAND 1
+#define USE_CUSTOM_MENUBAND 0

 // navigation controls and menubar just send a message to parent window
 /*
--- a/dll/win32/browseui/shellbrowser.cpp
+++ b/dll/win32/browseui/shellbrowser.cpp
@ -957,6 +957,11 @@ HRESULT CShellBrowser::BrowseToPath(IShellFolder *newShellFolder,
        // what to do with error? Do we want to halt browse because state save failed?
    }

+    if (fCurrentShellView)
+    {
+        fCurrentShellView->UIActivate(SVUIA_DEACTIVATE);
+    }
+
    // create view object
    hResult = newShellFolder->CreateViewObject(m_hWnd, IID_PPV_ARG(IShellView, &newShellView));
    if (FAILED(hResult))
--- a/dll/win32/kernel32/client/file/copy.c
+++ b/dll/win32/kernel32/client/file/copy.c
@ -351,18 +351,33 @@ CopyFileExA(IN LPCSTR lpExistingFileName,
 */
 BOOL
 WINAPI
-CopyFileA (
-    LPCSTR	lpExistingFileName,
-    LPCSTR	lpNewFileName,
-    BOOL	bFailIfExists
-)
+CopyFileA(IN LPCSTR lpExistingFileName,
+          IN LPCSTR lpNewFileName,
+          IN BOOL bFailIfExists)
 {
-    return CopyFileExA (lpExistingFileName,
-                        lpNewFileName,
+    BOOL Result = FALSE;
+    UNICODE_STRING lpNewFileNameW;
+    PUNICODE_STRING lpExistingFileNameW;
+
+    lpExistingFileNameW = Basep8BitStringToStaticUnicodeString(lpExistingFileName);
+    if (!lpExistingFileNameW)
+    {
+        return FALSE;
+    }
+
+    if (Basep8BitStringToDynamicUnicodeString(&lpNewFileNameW, lpNewFileName))
+    {
+        Result = CopyFileExW(lpExistingFileNameW->Buffer,
+                             lpNewFileNameW.Buffer,
                             NULL,
                             NULL,
                             NULL,
-                        bFailIfExists);
+                             (bFailIfExists ? COPY_FILE_FAIL_IF_EXISTS : 0));
+
+        RtlFreeUnicodeString(&lpNewFileNameW);
+    }
+
+    return Result;
 }


@ -371,18 +386,16 @@ CopyFileA (
 */
 BOOL
 WINAPI
-CopyFileW (
-    LPCWSTR	lpExistingFileName,
-    LPCWSTR	lpNewFileName,
-    BOOL	bFailIfExists
-)
+CopyFileW(IN LPCWSTR lpExistingFileName,
+          IN LPCWSTR lpNewFileName,
+          IN BOOL bFailIfExists)
 {
    return CopyFileExW(lpExistingFileName,
                       lpNewFileName,
                       NULL,
                       NULL,
                       NULL,
-                        bFailIfExists);
+                       (bFailIfExists ? COPY_FILE_FAIL_IF_EXISTS : 0));
 }


--- a/dll/win32/lsasrv/authpackage.c
+++ b/dll/win32/lsasrv/authpackage.c
@ -1308,8 +1308,9 @@ LsapSetPrivileges(
                                     TokenInfo1->Groups->Groups[i].Sid,
                                     ACCOUNT_VIEW,
                                     &AccountHandle);
-            if (NT_SUCCESS(Status))
-            {
+            if (!NT_SUCCESS(Status))
+                continue;
+
            Status = LsarEnumeratePrivilegesAccount(AccountHandle,
                                                    &Privileges);
            if (NT_SUCCESS(Status))
@ -1319,13 +1320,19 @@ LsapSetPrivileges(
                    Status = LsapAddPrivilegeToTokenPrivileges(&TokenInfo1->Privileges,
                                                               &(Privileges->Privilege[j]));
                    if (!NT_SUCCESS(Status))
+                    {
+                        /* We failed, clean everything and return */
+                        LsaIFree_LSAPR_PRIVILEGE_SET(Privileges);
+                        LsarClose(&AccountHandle);
+                        LsarClose(&PolicyHandle);
+
                        return Status;
                    }
+                }

                LsaIFree_LSAPR_PRIVILEGE_SET(Privileges);
                Privileges = NULL;
            }
-            }

            LsarClose(&AccountHandle);
        }
--- a/dll/win32/msgina/lsa.c
+++ b/dll/win32/msgina/lsa.c
@ -192,7 +192,7 @@ MyLogonUser(
                                        SE_GROUP_ENABLED_BY_DEFAULT;

    /* Set the token source */
-    strcpy(TokenSource.SourceName, "LogonUser");
+    strncpy(TokenSource.SourceName, "User32  ", sizeof(TokenSource.SourceName));
    AllocateLocallyUniqueId(&TokenSource.SourceIdentifier);

    Status = LsaLogonUser(LsaHandle,
--- a/dll/win32/msvcrt/msvcrt.spec
+++ b/dll/win32/msvcrt/msvcrt.spec
--- a/dll/win32/powrprof/powrprof.c
+++ b/dll/win32/powrprof/powrprof.c
@ -64,7 +64,7 @@ CallNtPowerInformation(POWER_INFORMATION_LEVEL InformationLevel,
 {
    BOOLEAN old;

-	//Lohnegrim: In order to get the right results, we have to ajust our Privilegs
+	//Lohnegrim: In order to get the right results, we have to adjust our Privileges
    RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE, TRUE, FALSE, &old);
    RtlAdjustPrivilege(SE_CREATE_PAGEFILE_PRIVILEGE, TRUE, FALSE, &old);

@ -332,7 +332,7 @@ GetCurrentPowerPolicies(PGLOBAL_POWER_POLICY pGlobalPowerPolicy,
    return FALSE;
    */
 /*
-   Lohnegrim: I dont know why this Function shoud call NtPowerInformation, becouse as far as i know,
+   Lohnegrim: I don't know why this Function should call NtPowerInformation, because as far as I know,
      it simply returns the GlobalPowerPolicy and the AktivPowerScheme!
 */
    UINT uiID;
@ -794,7 +794,7 @@ CheckPowerActionPolicy(PPOWER_ACTION_POLICY pPAP, SYSTEM_POWER_CAPABILITIES Powe
 {
 /*
   Lohnegrim: this is an Helper function, it checks if the POWERACTIONPOLICY is valid
-   Also, if the System dosn't support Hipernation, then change the PowerAction
+   Also, if the System doesn't support Hibernation, then change the PowerAction
 */
    switch (pPAP->Action)
    {
@ -829,7 +829,7 @@ CheckPowerActionPolicy(PPOWER_ACTION_POLICY pPAP, SYSTEM_POWER_CAPABILITIES Powe
 static VOID
 FixSystemPowerState(PSYSTEM_POWER_STATE Psps, SYSTEM_POWER_CAPABILITIES PowerCaps)
 {
-	//Lohnegrim: If the System dosn't support the Powerstates, then we have to change them
+	//Lohnegrim: If the System doesn't support the Powerstates, then we have to change them
    if (!PowerCaps.SystemS1 && *Psps == PowerSystemSleeping1)
        *Psps = PowerSystemSleeping2;
    if (!PowerCaps.SystemS2 && *Psps == PowerSystemSleeping2)
@ -923,7 +923,7 @@ ValidatePowerPolicies(PGLOBAL_POWER_POLICY pGPP, PPOWER_POLICY pPP)
        if (pGPP->mach.BroadcastCapacityResolution > 100)
            pGPP->mach.BroadcastCapacityResolution = 100;

-		//Lohnegrim: I have no idear, if they are realy needed, or if they are spezific for my System, or what they mean, so i removed them
+		//Lohnegrim: I have no idea, if they are really needed, or if they are specific for my System, or what they mean, so I removed them
        //pGPP->user.DischargePolicy[1].PowerPolicy.EventCode = pGPP->user.DischargePolicy[1].PowerPolicy.EventCode | 0x010000;
        //pGPP->user.DischargePolicy[2].PowerPolicy.EventCode = pGPP->user.DischargePolicy[2].PowerPolicy.EventCode | 0x020000;
        //pGPP->user.DischargePolicy[3].PowerPolicy.EventCode = pGPP->user.DischargePolicy[3].PowerPolicy.EventCode | 0x030000;
@ -1053,7 +1053,7 @@ ValidatePowerPolicies(PGLOBAL_POWER_POLICY pGPP, PPOWER_POLICY pPP)
            pPP->user.MaxSleepAc=PowerSystemSleeping1;
            pPP->user.MaxSleepDc=PowerSystemSleeping1;
        }
-		//Lohnegrim: I dont know where to get this info from, so i removed it
+		//Lohnegrim: I don't know where to get this info from, so I removed it
        //pPP->user.OptimizeForPowerAc=TRUE;
        //pPP->user.OptimizeForPowerDc=TRUE;

--- a/dll/win32/setupapi/CMakeLists.txt
+++ b/dll/win32/setupapi/CMakeLists.txt
@ -40,7 +40,7 @@ add_library(setupapi SHARED

 set_module_type(setupapi win32dll UNICODE)
 target_link_libraries(setupapi uuid wine ${PSEH_LIB})
-add_delay_importlibs(setupapi shell32 wintrust)
+add_delay_importlibs(setupapi shell32 winspool wintrust)

 add_importlibs(setupapi
    msvcrt
--- a/dll/win32/setupapi/dirid.c
+++ b/dll/win32/setupapi/dirid.c
@ -70,6 +70,7 @@ static const WCHAR *create_system_dirid( int dirid )

    WCHAR buffer[MAX_PATH+32], *str;
    int len;
+    DWORD needed;

    switch(dirid)
    {
@ -122,8 +123,14 @@ static const WCHAR *create_system_dirid( int dirid )
        return get_csidl_dir(CSIDL_PROFILE);
    case DIRID_LOADER:
        return C_Root;  /* FIXME */
+    case DIRID_PRINTPROCESSOR:
+        if (!GetPrintProcessorDirectoryW(NULL, NULL, 1, (LPBYTE)buffer, sizeof(buffer), &needed))
+        {
+            WARN( "cannot retrieve print processor directory\n" );
+            return get_unknown_dirid();
+        }
+        break;
    case DIRID_COLOR:  /* FIXME */
-    case DIRID_PRINTPROCESSOR:  /* FIXME */
    default:
        FIXME( "unknown dirid %d\n", dirid );
        return get_unknown_dirid();
--- a/dll/win32/setupapi/setupapi_private.h
+++ b/dll/win32/setupapi/setupapi_private.h
@ -31,6 +31,8 @@
 #include <windef.h>
 #include <winbase.h>
 #include <winreg.h>
+#include <wingdi.h>
+#include <winspool.h>
 #include <wincon.h>
 #include <objbase.h>
 #include <cfgmgr32.h>
--- a/include/asm/CMakeLists.txt
+++ b/include/asm/CMakeLists.txt
@ -11,17 +11,19 @@ else()
 endif()

 if(ARCH STREQUAL "i386")
-    set(_filename ks386)
+    set(_filename ks386.inc)
 elseif(ARCH STREQUAL "amd64")
-    set(_filename ksamd64)
+    set(_filename ksamd64.inc)
+elseif(ARCH STREQUAL "arm")
+    set(_filename ksarm.h)
 endif()

 get_target_property(genincdata_dll genincdata LOCATION)

 add_custom_command(
-    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_filename}.inc
-    COMMAND native-geninc ${genincdata_dll} ${CMAKE_CURRENT_BINARY_DIR}/${_filename}.inc ${OPT_MS}
+    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_filename}
+    COMMAND native-geninc ${genincdata_dll} ${CMAKE_CURRENT_BINARY_DIR}/${_filename} ${OPT_MS}
    DEPENDS genincdata native-geninc)

 add_custom_target(asm
-    DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_filename}.inc)
+    DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_filename})
--- a/include/asm/genincdata.c
+++ b/include/asm/genincdata.c
@ -74,15 +74,18 @@ __attribute__ ((section(".asmdef")))

 ASMGENDATA Table[] =
 {
-
+#if defined (_M_IX86) || defined (M_AMD64)
 /* PORTABLE CONSTANTS ********************************************************/
 #include "ksx.template.h"
+#endif

 /* ARCHITECTURE SPECIFIC CONTSTANTS ******************************************/
 #ifdef _M_IX86
 #include "ks386.template.h"
 #elif defined(_M_AMD64)
 #include "ksamd64.template.h"
+#elif defined(_M_ARM)
+#include "ksarm.template.h"
 #endif

    /* End of list */
--- a/include/asm/ksarm.template.h
+++ b/include/asm/ksarm.template.h
@ -0,0 +1,105 @@
+
+RAW(""),
+RAW("#include <kxarm.h>"),
+RAW(""),
+
+HEADER("CPSR Values"),
+CONSTANT(CPSR_THUMB_ENABLE),
+CONSTANT(CPSR_FIQ_DISABLE),
+CONSTANT(CPSR_IRQ_DISABLE),
+CONSTANT(CPSR_USER_MODE),
+CONSTANT(CPSR_FIQ_MODE),
+CONSTANT(CPSR_IRQ_MODE),
+CONSTANT(CPSR_SVC_MODE),
+CONSTANT(CPSR_ABORT_MODE),
+CONSTANT(CPSR_UND_MODE),
+CONSTANT(CPSR_MODES),
+
+HEADER("C1 Register Values"),
+CONSTANT(C1_MMU_CONTROL),
+CONSTANT(C1_ALIGNMENT_CONTROL),
+CONSTANT(C1_DCACHE_CONTROL),
+CONSTANT(C1_ICACHE_CONTROL),
+CONSTANT(C1_VECTOR_CONTROL),
+
+HEADER("Loader Parameter Block Offsets"),
+OFFSET(LpbKernelStack, LOADER_PARAMETER_BLOCK, KernelStack),
+OFFSET(LpbPanicStack, LOADER_PARAMETER_BLOCK, u.Arm.PanicStack),
+OFFSET(LpbInterruptStack, LOADER_PARAMETER_BLOCK, u.Arm.InterruptStack),
+
+HEADER("Trap Frame offsets"),
+OFFSET(TrDbgArgMark, KTRAP_FRAME, DbgArgMark),
+OFFSET(TrR0, KTRAP_FRAME, R0),
+OFFSET(TrR1, KTRAP_FRAME, R1),
+OFFSET(TrR2, KTRAP_FRAME, R2),
+OFFSET(TrR3, KTRAP_FRAME, R3),
+OFFSET(TrR4, KTRAP_FRAME, R4),
+OFFSET(TrR5, KTRAP_FRAME, R5),
+OFFSET(TrR6, KTRAP_FRAME, R6),
+OFFSET(TrR7, KTRAP_FRAME, R7),
+OFFSET(TrR8, KTRAP_FRAME, R8),
+OFFSET(TrR9, KTRAP_FRAME, R9),
+OFFSET(TrR10, KTRAP_FRAME, R10),
+OFFSET(TrR11, KTRAP_FRAME, R11),
+OFFSET(TrR12, KTRAP_FRAME, R12),
+OFFSET(TrUserSp, KTRAP_FRAME, UserSp),
+OFFSET(TrUserLr, KTRAP_FRAME, UserLr),
+OFFSET(TrSvcSp, KTRAP_FRAME, SvcSp),
+OFFSET(TrSvcLr, KTRAP_FRAME, SvcLr),
+OFFSET(TrPc, KTRAP_FRAME, Pc),
+OFFSET(TrSpsr, KTRAP_FRAME, Spsr),
+SIZE(TrapFrameLength, KTRAP_FRAME),
+
+HEADER("Exception Frame offsets"),
+OFFSET(ExR4, KEXCEPTION_FRAME, R4),
+OFFSET(ExR5, KEXCEPTION_FRAME, R5),
+OFFSET(ExR6, KEXCEPTION_FRAME, R6),
+OFFSET(ExR7, KEXCEPTION_FRAME, R7),
+OFFSET(ExR8, KEXCEPTION_FRAME, R8),
+OFFSET(ExR9, KEXCEPTION_FRAME, R9),
+OFFSET(ExR10, KEXCEPTION_FRAME, R10),
+OFFSET(ExR11, KEXCEPTION_FRAME, R11),
+OFFSET(ExLr, KEXCEPTION_FRAME, Lr),
+OFFSET(ExSpsr, KEXCEPTION_FRAME, Psr), // name?
+SIZE(ExceptionFrameLength, KEXCEPTION_FRAME),
+
+HEADER("PCR"),
+CONSTANTX(KiPcr, 0xFFFFF000),
+
+HEADER("PCR Offsets"),
+//OFFSET(PcCurrentIrql, KPCR, CurrentIrql),
+
+HEADER("KTHREAD Offsets"),
+OFFSET(ThKernelStack, KTHREAD, KernelStack),
+
+HEADER("CONTEXT Offsets"),
+OFFSET(CsContextFlags, CONTEXT, ContextFlags),
+OFFSET(CsR0, CONTEXT, R0),
+OFFSET(CsR1, CONTEXT, R1),
+OFFSET(CsR2, CONTEXT, R2),
+OFFSET(CsR3, CONTEXT, R3),
+OFFSET(CsR4, CONTEXT, R4),
+OFFSET(CsR5, CONTEXT, R5),
+OFFSET(CsR6, CONTEXT, R6),
+OFFSET(CsR7, CONTEXT, R7),
+OFFSET(CsR8, CONTEXT, R8),
+OFFSET(CsR9, CONTEXT, R9),
+OFFSET(CsR10, CONTEXT, R10),
+OFFSET(CsR11, CONTEXT, R11),
+OFFSET(CsR12, CONTEXT, R12),
+OFFSET(CsSp, CONTEXT, Sp),
+OFFSET(CsLr, CONTEXT, Lr),
+OFFSET(CsPc, CONTEXT, Pc),
+OFFSET(CsPsr, CONTEXT, Psr),
+
+CONSTANT(CONTEXT_FULL),
+
+HEADER("DebugService Control Types"),
+CONSTANT(BREAKPOINT_BREAK),
+CONSTANT(BREAKPOINT_PRINT),
+CONSTANT(BREAKPOINT_PROMPT),
+CONSTANT(BREAKPOINT_LOAD_SYMBOLS),
+CONSTANT(BREAKPOINT_UNLOAD_SYMBOLS),
+CONSTANT(BREAKPOINT_COMMAND_STRING),
+
+
--- a/ntoskrnl/include/internal/arm/kxarm.h
+++ b/ntoskrnl/include/internal/arm/kxarm.h
@ -1,22 +1,103 @@

+
+#ifdef _MSC_VER
+
+    /* Globals */
+    GBLS    AreaName
+    GBLS    FuncName
+    GBLS    PrologName
+    GBLS    FuncEndName
+AreaName    SETS    "|.text|"
+
+    MACRO
+    TEXTAREA
+    AREA |.text|,ALIGN=2,CODE,READONLY
+AreaName    SETS    "|.text|"
+    MEND
+
+    MACRO
+    NESTED_ENTRY    $Name
+FuncName    SETS    "$Name"
+PrologName  SETS    "$Name":CC:"_Prolog"
+FuncEndName SETS    "$Name":CC:"_end"
+    AREA |.pdata|,ALIGN=2,PDATA
+    ALIGN 2
+    EXPORT $FuncName [FUNC]
+$FuncName
+    ROUT
+    MEND
+
+    MACRO
+    PROLOG_END
+$PrologName
+    MEND
+
+    MACRO
+    ENTRY_END $Name
+$FuncEndName
+    MEND
+
+	MACRO
+	LEAF_ENTRY $Name
+FuncName    SETS    "$Name"
+PrologName  SETS	"Invalid Prolog"
+FuncEndName SETS    "$Name":CC:"_end"
+	ALIGN 2
+	EXPORT $FuncName [FUNC]
+$FuncName
+	ROUT
+	MEND
+
+    MACRO
+    LEAF_END $Name
+$FuncEndName
+    MEND
+
+    MACRO
+    TRAP_PROLOG $Abort
+        fixme
+    MEND
+
+    MACRO
+    SYSCALL_PROLOG $Abort
+        fixme
+    MEND
+
+    MACRO
+    TRAP_EPILOG $SystemCall
+        fixme
+    MEND
+
+#else
+
+/* Compatibility define */
+#define EQU .equ
+
+.macro IMPORT Name
+    /* Ignore */
+.endm
+
 .macro TEXTAREA
    .section .text, "rx"
    .align 2
 .endm

 .macro NESTED_ENTRY Name
-    .global &Name
+FuncName    .equ    &Name
+PrologName  .equ    &Name&_Prolog
+FuncEndName .equ    &Name&_end
+    .global &FuncName
    .align 2
-    .func &Name
-    &Name:
+    .func &FuncName
+    &FuncName:
 .endm

-.macro PROLOG_END Name
-    prolog_&Name:
+.macro PROLOG_END
+    \PrologName:
 .endm

 .macro ENTRY_END Name
-    end_&Name:
+    &FuncEndName:
   .endfunc
 .endm

@ -30,57 +111,39 @@
    sub lr, lr, #4
 .endif

-    //
    // Save the bottom 4 registers
-    //
    stmdb sp, {r0-r3}

-    //
    // Save the abort lr, sp, spsr, cpsr
-    //
    mov r0, lr
    mov r1, sp
    mrs r2, cpsr
    mrs r3, spsr

-    //
    // Switch to SVC mode
-    //
    bic r2, r2, #CPSR_MODES
    orr r2, r2, #CPSR_SVC_MODE
    msr cpsr_c, r2

-    //
    // Save the SVC sp before we modify it
-    //
    mov r2, sp

-    //
    // Make space for the trap frame
-    //
    sub sp, sp, #TrapFrameLength

-    //
    // Save abt32 state
-    //
    str r0, [sp, #TrPc]
    str lr, [sp, #TrSvcLr]
    str r2, [sp, #TrSvcSp]

-    //
    // Restore the saved SPSR
-    //
    msr spsr_all, r3

-    //
    // Restore our 4 registers
-    //
    ldmdb r1, {r0-r3}

-    //
    // Build trap frame
    // FIXME: Change to stmdb later
-    //
    str r0, [sp, #TrR0]
    str r1, [sp, #TrR1]
    str r2, [sp, #TrR2]
@ -104,15 +167,11 @@
 .endm

 .macro SYSCALL_PROLOG
-    //
    // Make space for the trap frame
-    //
    sub sp, sp, #TrapFrameLength

-    //
    // Build trap frame
    // FIXME: Change to stmdb later
-    //
    str r0, [sp, #TrR0]
    str r1, [sp, #TrR1]
    str r2, [sp, #TrR2]
@ -138,24 +197,18 @@
 .endm

 .macro TRAP_EPILOG SystemCall
-    //
    // ASSERT(TrapFrame->DbgArgMark == 0xBADB0D00)
-    //
    ldr r0, [sp, #TrDbgArgMark]
    ldr r1, =0xBADB0D00
    cmp r0, r1
    bne 1f

-    //
    // Get the SPSR and restore it
-    //
    ldr r0, [sp, #TrSpsr]
    msr spsr_all, r0

-    //
    // Restore the registers
    // FIXME: Use LDMIA later
-    //
    mov r0, sp
    add r0, r0, #TrUserSp
    ldm r0, {sp, lr}^
@ -173,9 +226,7 @@
    ldr r11, [sp, #TrR11]
    ldr r12, [sp, #TrR12]

-    //
    // Restore program execution state
-    //
 .if \SystemCall
    ldr lr, [sp, #TrPc]
    add sp, sp, #TrapFrameLength
@ -187,3 +238,7 @@
 1:
    b .
 .endm
+
+#endif
+
+
--- a/include/crt/conio.h
+++ b/include/crt/conio.h
@ -416,10 +416,10 @@ extern "C" {
    int _Ch);

 #if (defined(_X86_) && !defined(__x86_64))
-  _CRT_NONSTDC_DEPRECATE(_inp) _CRTIMP int __cdecl inp(unsigned short);
-  _CRT_NONSTDC_DEPRECATE(_inpw) _CRTIMP unsigned short __cdecl inpw(unsigned short);
-  _CRT_NONSTDC_DEPRECATE(_outp) _CRTIMP int __cdecl outp(unsigned short,int);
-  _CRT_NONSTDC_DEPRECATE(_outpw) _CRTIMP unsigned short __cdecl outpw(unsigned short,unsigned short);
+  _CRT_NONSTDC_DEPRECATE(_inp) int __cdecl inp(unsigned short);
+  _CRT_NONSTDC_DEPRECATE(_inpw) unsigned short __cdecl inpw(unsigned short);
+  _CRT_NONSTDC_DEPRECATE(_outp) int __cdecl outp(unsigned short,int);
+  _CRT_NONSTDC_DEPRECATE(_outpw) unsigned short __cdecl outpw(unsigned short,unsigned short);
 #endif

 #endif /* !NO_OLDNAMES */
--- a/include/crt/crtdefs.h
+++ b/include/crt/crtdefs.h
@ -237,9 +237,11 @@
 #define _TRUNCATE ((size_t)-1)
 #endif

+#ifndef __REACTOS__
 #define __STDC_SECURE_LIB__ 200411L
 #define __GOT_SECURE_LIB__ __STDC_SECURE_LIB__
 #define _SECURECRT_FILL_BUFFER_PATTERN 0xFD
+#endif


 /** Type definitions *********************************************************/
--- a/include/crt/msc/intrin.h
+++ b/include/crt/msc/intrin.h
@ -29,52 +29,84 @@ void _mm_lfence(void);
 #pragma intrinsic(_mm_lfence)
 void _mm_sfence(void);
 #pragma intrinsic(_mm_sfence)
+void __nvreg_restore_fence(void);
+void __nvreg_save_fence(void);
 #endif
-#ifdef _M_AMD64
+#if defined(_M_AMD64)
 void __faststorefence(void);
 #pragma intrinsic(__faststorefence)
+#elif defined(_M_ARM)
+__int16 __iso_volatile_load16(const volatile __int16 *);
+#pragma intrinsic(__iso_volatile_load16)
+__int32 __iso_volatile_load32(const volatile __int32 *);
+#pragma intrinsic(__iso_volatile_load32)
+__int64 __iso_volatile_load64(const volatile __int64 *);
+#pragma intrinsic(__iso_volatile_load64)
+__int8 __iso_volatile_load8(const volatile __int8 *);
+#pragma intrinsic(__iso_volatile_load8)
+void __iso_volatile_store16(volatile __int16 *, __int16);
+#pragma intrinsic(__iso_volatile_store16)
+void __iso_volatile_store32(volatile __int32 *, __int32);
+#pragma intrinsic(__iso_volatile_store32)
+void __iso_volatile_store64(volatile __int64 *, __int64);
+#pragma intrinsic(__iso_volatile_store64)
+void __iso_volatile_store8(volatile __int8 *, __int8);
+#pragma intrinsic(__iso_volatile_store8)
 #endif

 /*** Atomic operations ***/
-long _InterlockedCompareExchange(volatile long * Destination, long Exchange, long Comperand);
+long _InterlockedCompareExchange(_Interlocked_operand_ volatile long * Destination, long Exchange, long Comperand);
 #pragma intrinsic(_InterlockedCompareExchange)
-long _InterlockedExchange(volatile long * Target, long Value);
+char _InterlockedCompareExchange8(_Interlocked_operand_ char volatile * Destination, char Exchange, char Comparand);
+#pragma intrinsic(_InterlockedCompareExchange8)
+short _InterlockedCompareExchange16(_Interlocked_operand_ short volatile * Destination, short Exchange, short Comparand);
+#pragma intrinsic(_InterlockedCompareExchange16)
+__int64 _InterlockedCompareExchange64(_Interlocked_operand_ volatile __int64 * Destination, __int64 Exchange, __int64 Comperand);
+#pragma intrinsic(_InterlockedCompareExchange64)
+long _InterlockedExchange(_Interlocked_operand_ volatile long * Target, long Value);
 #pragma intrinsic(_InterlockedExchange)
-long _InterlockedExchangeAdd(volatile long * Addend, long Value);
+char _InterlockedExchange8(_Interlocked_operand_ char volatile * Target, char Value);
+#pragma intrinsic(_InterlockedExchange8)
+short _InterlockedExchange16(_Interlocked_operand_ short volatile * Target, short Value);
+#pragma intrinsic(_InterlockedExchange16)
+long _InterlockedExchangeAdd(_Interlocked_operand_ volatile long * Addend, long Value);
 #pragma intrinsic(_InterlockedExchangeAdd)
-char _InterlockedAnd8(volatile char * value, char mask);
+char _InterlockedExchangeAdd8(_Interlocked_operand_ char volatile * Addend, char Value);
+#pragma intrinsic(_InterlockedExchangeAdd8)
+short _InterlockedExchangeAdd16(_Interlocked_operand_ short volatile * Addend, short Value);
+#pragma intrinsic(_InterlockedExchangeAdd16)
+char _InterlockedAnd8(_Interlocked_operand_ volatile char * value, char mask);
 #pragma intrinsic(_InterlockedAnd8)
-short _InterlockedAnd16(volatile short * value, short mask);
+short _InterlockedAnd16(_Interlocked_operand_ volatile short * value, short mask);
 #pragma intrinsic(_InterlockedAnd16)
-long _InterlockedAnd(volatile long * value, long mask);
+long _InterlockedAnd(_Interlocked_operand_ volatile long * value, long mask);
 #pragma intrinsic(_InterlockedAnd)
-char _InterlockedOr8(volatile char * value, char mask);
+char _InterlockedOr8(_Interlocked_operand_ volatile char * value, char mask);
 #pragma intrinsic(_InterlockedOr8)
-short _InterlockedOr16(volatile short * value, short mask);
+short _InterlockedOr16(_Interlocked_operand_ volatile short * value, short mask);
 #pragma intrinsic(_InterlockedOr16)
-long _InterlockedOr(volatile long * value, long mask);
+long _InterlockedOr(_Interlocked_operand_ volatile long * value, long mask);
 #pragma intrinsic(_InterlockedOr)
-char _InterlockedXor8(volatile char * value, char mask);
+char _InterlockedXor8(_Interlocked_operand_ volatile char * value, char mask);
 #pragma intrinsic(_InterlockedXor8)
-short _InterlockedXor16(volatile short * value, short mask);
+short _InterlockedXor16(_Interlocked_operand_ volatile short * value, short mask);
 #pragma intrinsic(_InterlockedXor16)
-long _InterlockedXor(volatile long * value, long mask);
+long _InterlockedXor(_Interlocked_operand_ volatile long * value, long mask);
 #pragma intrinsic(_InterlockedXor)
-long _InterlockedDecrement(volatile long * lpAddend);
+long _InterlockedDecrement(_Interlocked_operand_ volatile long * lpAddend);
 #pragma intrinsic(_InterlockedDecrement)
-long _InterlockedIncrement(volatile long * lpAddend);
+long _InterlockedIncrement(_Interlocked_operand_ volatile long * lpAddend);
 #pragma intrinsic(_InterlockedIncrement)
-short _InterlockedDecrement16(volatile short * lpAddend);
+short _InterlockedDecrement16(_Interlocked_operand_ volatile short * lpAddend);
 #pragma intrinsic(_InterlockedDecrement16)
-short _InterlockedIncrement16(volatile short * lpAddend);
+short _InterlockedIncrement16(_Interlocked_operand_ volatile short * lpAddend);
 #pragma intrinsic(_InterlockedIncrement16)
 unsigned char _interlockedbittestandreset(volatile long * a, long b);
 #pragma intrinsic(_interlockedbittestandreset)
 unsigned char _interlockedbittestandset(volatile long * a, long b);
 #pragma intrinsic(_interlockedbittestandset)
-
 #if defined(_M_IX86)
-long _InterlockedAddLargeStatistic(volatile __int64 * Addend, long Value);
+long _InterlockedAddLargeStatistic(_Interlocked_operand_ volatile __int64 * Addend, long Value);
 #pragma intrinsic(_InterlockedAddLargeStatistic)
 #elif defined(_M_AMD64)
 __int64 _InterlockedExchange64(volatile __int64 * Target, __int64 Value);
@ -85,12 +117,12 @@ void * _InterlockedCompareExchangePointer(void * volatile * Destination, void *
 #pragma intrinsic(_InterlockedCompareExchangePointer)
 void * _InterlockedExchangePointer(void * volatile * Target, void * Value);
 #pragma intrinsic(_InterlockedExchangePointer)
+unsigned char _InterlockedCompareExchange128(_Interlocked_operand_ volatile __int64 * Destination, __int64 ExchangeHigh, __int64 ExchangeLow, __int64 * ComparandResult);
+#pragma intrinsic(_InterlockedCompareExchange128)
 __int64 _InterlockedAnd64(volatile __int64 * value, __int64 mask);
 #pragma intrinsic(_InterlockedAnd64)
 __int64 _InterlockedOr64(volatile __int64 * value, __int64 mask);
 #pragma intrinsic(_InterlockedOr64)
-__int64 _InterlockedCompareExchange64(volatile __int64 * Destination, __int64 Exchange, __int64 Comperand);
-#pragma intrinsic(_InterlockedCompareExchange64)
 __int64 _InterlockedDecrement64(volatile __int64 * lpAddend);
 #pragma intrinsic(_InterlockedDecrement64)
 __int64 _InterlockedIncrement64(volatile __int64 * lpAddend);
@ -99,10 +131,161 @@ unsigned char _interlockedbittestandreset64(volatile __int64 * a, __int64 b);
 #pragma intrinsic(_interlockedbittestandreset64)
 unsigned char _interlockedbittestandset64(volatile __int64 * a, __int64 b);
 #pragma intrinsic(_interlockedbittestandset64)
+long _InterlockedAnd_np(volatile long * Value, long Mask);
+#pragma intrinsic(_InterlockedAnd_np)
+char _InterlockedAnd8_np(volatile char * Value, char Mask);
+#pragma intrinsic(_InterlockedAnd8_np)
+short _InterlockedAnd16_np(volatile short * Value, short Mask);
+#pragma intrinsic(_InterlockedAnd16_np)
+__int64 _InterlockedAnd64_np(volatile __int64 * Value, __int64 Mask);
+#pragma intrinsic(_InterlockedAnd64_np)
+short _InterlockedCompareExchange16_np(volatile short * Destination, short Exchange, short Comparand);
+#pragma intrinsic(_InterlockedCompareExchange16_np)
+__int64 _InterlockedCompareExchange64_np(volatile __int64 * Destination, __int64 Exchange, __int64 Comparand);
+#pragma intrinsic(_InterlockedCompareExchange64_np)
+unsigned char _InterlockedCompareExchange128_np(volatile __int64 * Destination, __int64 ExchangeHigh, __int64 ExchangeLow, __int64 * ComparandResult);
+#pragma intrinsic(_InterlockedCompareExchange128_np)
+void * _InterlockedCompareExchangePointer_np(void * volatile * Destination, void * Exchange, void * Comparand);
+#pragma intrinsic(_InterlockedCompareExchangePointer_np)
+long _InterlockedCompareExchange_np(volatile long * Destination, long Exchange, long Comparand);
+#pragma intrinsic(_InterlockedCompareExchange_np)
+short _InterlockedOr16_np(volatile short * Value, short Mask);
+#pragma intrinsic(_InterlockedOr16_np)
+char _InterlockedOr8_np(volatile char * Value, char Mask);
+#pragma intrinsic(_InterlockedOr8_np)
+long _InterlockedOr_np(volatile long * Value, long Mask);
+#pragma intrinsic(_InterlockedOr_np)
+short _InterlockedXor16_np(volatile short * Value, short Mask);
+#pragma intrinsic(_InterlockedXor16_np)
+__int64 _InterlockedXor64_np(volatile __int64 * Value, __int64 Mask);
+#pragma intrinsic(_InterlockedXor64_np)
+char _InterlockedXor8_np(volatile char * Value, char Mask);
+#pragma intrinsic(_InterlockedXor8_np)
+long _InterlockedXor_np(volatile long * Value, long Mask);
+#pragma intrinsic(_InterlockedXor_np)
+__int64 _InterlockedOr64_np(volatile __int64 * Value, __int64 Mask);
+#pragma intrinsic(_InterlockedOr64_np)
+#elif defined(_M_ARM)
+long _InterlockedAdd(_Interlocked_operand_ long volatile * Addend, long Value);
+__int64 _InterlockedAdd64(_Interlocked_operand_ __int64 volatile * Addend, __int64 Value);
+__int64 _InterlockedAdd64_acq(__int64 volatile * Addend, __int64 Value);
+__int64 _InterlockedAdd64_nf(__int64 volatile * Addend, __int64 Value);
+__int64 _InterlockedAdd64_rel(__int64 volatile * Addend, __int64 Value);
+long _InterlockedAdd_acq(long volatile * Addend, long Value);
+long _InterlockedAdd_nf(long volatile * Addend, long Value);
+long _InterlockedAdd_rel(long volatile * Addend, long Value);
+short _InterlockedAnd16_acq(short volatile * Value, short Mask);
+short _InterlockedAnd16_nf(short volatile * Value, short Mask);
+short _InterlockedAnd16_rel(short volatile * Value, short Mask);
+__int64 _InterlockedAnd64_acq(__int64 volatile * Value, __int64 Mask);
+__int64 _InterlockedAnd64_nf(__int64 volatile * Value, __int64 Mask);
+__int64 _InterlockedAnd64_rel(__int64 volatile * Value, __int64 Mask);
+char _InterlockedAnd8_acq(char volatile * Value, char Mask);
+char _InterlockedAnd8_nf(char volatile * Value, char Mask);
+char _InterlockedAnd8_rel(char volatile * Value, char Mask);
+long _InterlockedAnd_acq(long volatile * Value, long Mask);
+long _InterlockedAnd_nf(long volatile * Value, long Mask);
+long _InterlockedAnd_rel(long volatile * Value, long Mask);
+short _InterlockedCompareExchange16_acq(short volatile * Destination, short Exchange, short Comparand);
+short _InterlockedCompareExchange16_nf(short volatile * Destination, short Exchange, short Comparand);
+short _InterlockedCompareExchange16_rel(short volatile * Destination, short Exchange, short Comparand);
+__int64 _InterlockedCompareExchange64_acq(__int64 volatile * Destination, __int64 Exchange, __int64 Comparand);
+__int64 _InterlockedCompareExchange64_nf(__int64 volatile * Destination, __int64 Exchange, __int64 Comparand);
+__int64 _InterlockedCompareExchange64_rel(__int64 volatile * Destination, __int64 Exchange, __int64 Comparand);
+char _InterlockedCompareExchange8_acq(char volatile * Destination, char Exchange, char Comparand);
+char _InterlockedCompareExchange8_nf(char volatile * Destination, char Exchange, char Comparand);
+char _InterlockedCompareExchange8_rel(char volatile * Destination, char Exchange, char Comparand);
+void * _InterlockedCompareExchangePointer_acq(void * volatile * Destination, void * Exchange, void * Comparand);
+void * _InterlockedCompareExchangePointer_nf(void * volatile * Destination, void * Exchange, void * Comparand);
+void * _InterlockedCompareExchangePointer_rel(void * volatile * Destination, void * Exchange, void * Comparand);
+long _InterlockedCompareExchange_acq(long volatile * Destination, long Exchange, long Comparand);
+long _InterlockedCompareExchange_nf(long volatile * Destination, long Exchange, long Comparand);
+long _InterlockedCompareExchange_rel(long volatile * Destination, long Exchange, long Comparand);
+short _InterlockedDecrement16_acq(short volatile * Addend);
+short _InterlockedDecrement16_nf(short volatile * Addend);
+short _InterlockedDecrement16_rel(short volatile * Addend);
+__int64 _InterlockedDecrement64_acq(__int64 volatile * Addend);
+__int64 _InterlockedDecrement64_nf(__int64 volatile * Addend);
+__int64 _InterlockedDecrement64_rel(__int64 volatile * Addend);
+long _InterlockedDecrement_acq(long volatile * Addend);
+long _InterlockedDecrement_nf(long volatile * Addend);
+long _InterlockedDecrement_rel(long volatile * Addend);
+short _InterlockedExchange16_acq(short volatile * Target, short Value);
+short _InterlockedExchange16_nf(short volatile * Target, short Value);
+__int64 _InterlockedExchange64_acq(__int64 volatile * Target, __int64 Value);
+__int64 _InterlockedExchange64_nf(__int64 volatile * Target, __int64 Value);
+char _InterlockedExchange8_acq(char volatile * Target, char Value);
+char _InterlockedExchange8_nf(char volatile * Target, char Value);
+short _InterlockedExchangeAdd16_acq(short volatile * Addend, short Value);
+short _InterlockedExchangeAdd16_nf(short volatile * Addend, short Value);
+short _InterlockedExchangeAdd16_rel(short volatile * Addend, short Value);
+__int64 _InterlockedExchangeAdd64_acq(__int64 volatile * Addend, __int64 Value);
+__int64 _InterlockedExchangeAdd64_nf(__int64 volatile * Addend, __int64 Value);
+__int64 _InterlockedExchangeAdd64_rel(__int64 volatile * Addend, __int64 Value);
+char _InterlockedExchangeAdd8_acq(char volatile * Addend, char Value);
+char _InterlockedExchangeAdd8_nf(char volatile * Addend, char Value);
+char _InterlockedExchangeAdd8_rel(char volatile * Addend, char Value);
+long _InterlockedExchangeAdd_acq(long volatile * Addend, long Value);
+long _InterlockedExchangeAdd_nf(long volatile * Addend, long Value);
+long _InterlockedExchangeAdd_rel(long volatile * Addend, long Value);
+void * _InterlockedExchangePointer_acq(void * volatile * Target, void * Value);
+void * _InterlockedExchangePointer_nf(void * volatile * Target, void * Value);
+long _InterlockedExchange_acq(long volatile * Target, long Value);
+long _InterlockedExchange_nf(long volatile * Target, long Value);
+short _InterlockedIncrement16_acq(short volatile * Addend);
+short _InterlockedIncrement16_nf(short volatile * Addend);
+short _InterlockedIncrement16_rel(short volatile * Addend);
+__int64 _InterlockedIncrement64_acq(__int64 volatile * Addend);
+__int64 _InterlockedIncrement64_nf(__int64 volatile * Addend);
+__int64 _InterlockedIncrement64_rel(__int64 volatile * Addend);
+long _InterlockedIncrement_acq(long volatile * Addend);
+long _InterlockedIncrement_nf(long volatile * Addend);
+long _InterlockedIncrement_rel(long volatile * Addend);
+short _InterlockedOr16_acq(short volatile * Value, short Mask);
+short _InterlockedOr16_nf(short volatile * Value, short Mask);
+short _InterlockedOr16_rel(short volatile * Value, short Mask);
+__int64 _InterlockedOr64_acq(__int64 volatile * Value, __int64 Mask);
+__int64 _InterlockedOr64_nf(__int64 volatile * Value, __int64 Mask);
+__int64 _InterlockedOr64_rel(__int64 volatile * Value, __int64 Mask);
+char _InterlockedOr8_acq(char volatile * Value, char Mask);
+char _InterlockedOr8_nf(char volatile * Value, char Mask);
+char _InterlockedOr8_rel(char volatile * Value, char Mask);
+long _InterlockedOr_acq(long volatile * Value, long Mask);
+long _InterlockedOr_nf(long volatile * Value, long Mask);
+long _InterlockedOr_rel(long volatile * Value, long Mask);
+short _InterlockedXor16_acq(short volatile * Value, short Mask);
+short _InterlockedXor16_nf(short volatile * Value, short Mask);
+short _InterlockedXor16_rel(short volatile * Value, short Mask);
+__int64 _InterlockedXor64_acq(__int64 volatile * Value, __int64 Mask);
+__int64 _InterlockedXor64_nf(__int64 volatile * Value, __int64 Mask);
+__int64 _InterlockedXor64_rel(_Interlocked_operand_ __int64 volatile * Value, __int64 Mask);
+char _InterlockedXor8_acq(char volatile * Value, char Mask);
+char _InterlockedXor8_nf(char volatile * Value, char Mask);
+char _InterlockedXor8_rel(char volatile * Value, char Mask);
+long _InterlockedXor_acq(long volatile * Value, long Mask);
+long _InterlockedXor_nf(long volatile * Value, long Mask);
+long _InterlockedXor_rel(long volatile * Value, long Mask);
+unsigned char _interlockedbittestandreset_acq(long volatile *, long);
+unsigned char _interlockedbittestandreset_nf(long volatile *, long);
+unsigned char _interlockedbittestandreset_rel(long volatile *, long);
+unsigned char _interlockedbittestandset_acq(long volatile *, long);
+unsigned char _interlockedbittestandset_nf(long volatile *, long);
+unsigned char _interlockedbittestandset_rel(long volatile *, long);
+#endif
+#if defined(_M_AMD64) || defined(_M_ARM)
+__int64 _InterlockedAnd64(_Interlocked_operand_ __int64 volatile * Value, __int64 Mask);
+void * _InterlockedCompareExchangePointer(_Interlocked_operand_ void * volatile * Destination, void * Exchange, void * Comparand);
+__int64 _InterlockedDecrement64(_Interlocked_operand_ __int64 volatile * Addend);
+__int64 _InterlockedExchange64(_Interlocked_operand_ __int64 volatile * Target, __int64 Value);
+__int64 _InterlockedExchangeAdd64(_Interlocked_operand_ __int64 volatile * Addend, __int64 Value);
+void * _InterlockedExchangePointer(_Interlocked_operand_ void * volatile * Target, void * Value);
+__int64 _InterlockedIncrement64(_Interlocked_operand_ __int64 volatile * Addend);
+__int64 _InterlockedOr64(_Interlocked_operand_ __int64 volatile * Value, __int64 Mask);
+__int64 _InterlockedXor64(_Interlocked_operand_ __int64 volatile * Value, __int64 Mask);
 #endif

-#if defined(_M_IX86) || defined(_M_AMD64)
 /*** String operations ***/
+#if defined(_M_IX86) || defined(_M_AMD64)
 void __stosb(unsigned char * Dest, unsigned char Data, size_t Count);
 #pragma intrinsic(__stosb)
 void __stosw(unsigned short * Dest, unsigned short Data, size_t Count);
@ -123,8 +306,8 @@ void __movsq(unsigned __int64 * Destination, unsigned __int64 const * Source, si
 #pragma intrinsic(__movsq)
 #endif

-#if defined(_M_AMD64)
 /*** GS segment addressing ***/
+#if defined(_M_AMD64)
 void __writegsbyte(unsigned long Offset, unsigned char Data);
 #pragma intrinsic(__writegsbyte)
 void __writegsword(unsigned long Offset, unsigned short Data);
@ -147,24 +330,28 @@ void __incgsword(unsigned long Offset);
 #pragma intrinsic(__incgsword)
 void __incgsdword(unsigned long Offset);
 #pragma intrinsic(__incgsdword)
+void __incgsqword(unsigned long);
+#pragma intrinsic(__incgsqword)
 void __addgsbyte(unsigned long Offset, unsigned char Data);
 #pragma intrinsic(__addgsbyte)
 void __addgsword(unsigned long Offset, unsigned short Data);
 #pragma intrinsic(__addgsword)
-void __addgsdword(unsigned long Offset, unsigned int Data);
+void __addgsdword(unsigned long Offset, unsigned long Data);
 #pragma intrinsic(__addgsdword)
 void __addgsqword(unsigned long Offset, unsigned __int64 Data);
 #pragma intrinsic(__addgsqword)
 #endif

-#if defined(_M_IX86)
 /*** FS segment addressing ***/
+#if defined(_M_IX86)
 void __writefsbyte(unsigned long Offset, unsigned char Data);
 #pragma intrinsic(__writefsbyte)
 void __writefsword(unsigned long Offset, unsigned short Data);
 #pragma intrinsic(__writefsword)
 void __writefsdword(unsigned long Offset, unsigned long Data);
 #pragma intrinsic(__writefsdword)
+void __writefsqword(unsigned long Offset, unsigned __int64 Data);
+#pragma intrinsic(__writefsdword)
 unsigned char __readfsbyte(unsigned long Offset);
 #pragma intrinsic(__readfsbyte)
 unsigned short __readfsword(unsigned long Offset);
@ -181,11 +368,10 @@ void __addfsbyte(unsigned long Offset, unsigned char Data);
 #pragma intrinsic(__addfsbyte)
 void __addfsword(unsigned long Offset, unsigned short Data);
 #pragma intrinsic(__addfsword)
-void __addfsdword(unsigned long Offset, unsigned int Data);
+void __addfsdword(unsigned long Offset, unsigned long Data);
 #pragma intrinsic(__addfsdword)
 #endif

-
 /*** Bit manipulation ***/
 unsigned char _BitScanForward(unsigned long * Index, unsigned long Mask);
 #pragma intrinsic(_BitScanForward)
@ -209,14 +395,22 @@ unsigned char _rotl8(unsigned char value, unsigned char shift);
 #pragma intrinsic(_rotl8)
 unsigned short _rotl16(unsigned short value, unsigned char shift);
 #pragma intrinsic(_rotl16)
-unsigned int _rotl(unsigned int value, int shift);
+_Check_return_ unsigned int _rotl(unsigned int value, int shift);
 #pragma intrinsic(_rotl)
-unsigned int _rotr(unsigned int value, int shift);
-#pragma intrinsic(_rotr)
+_Check_return_ unsigned __int64 __cdecl _rotl64(_In_ unsigned __int64 Value, _In_ int Shift);
+#pragma intrinsic(_rotl64)
+_Check_return_ unsigned long __cdecl _lrotl(_In_ unsigned long, _In_ int);
+#pragma intrinsic(_lrotl)
 unsigned char _rotr8(unsigned char value, unsigned char shift);
 #pragma intrinsic(_rotr8)
 unsigned short _rotr16(unsigned short value, unsigned char shift);
 #pragma intrinsic(_rotr16)
+_Check_return_ unsigned int _rotr(unsigned int value, int shift);
+#pragma intrinsic(_rotr)
+_Check_return_ unsigned __int64 __cdecl _rotr64(_In_ unsigned __int64 Value, _In_ int Shift);
+#pragma intrinsic(_rotr64)
+_Check_return_ unsigned long __cdecl _lrotr(_In_ unsigned long, _In_ int);
+#pragma intrinsic(_lrotr)
 unsigned short _byteswap_ushort(unsigned short value);
 #pragma intrinsic(_byteswap_ushort)
 unsigned long _byteswap_ulong(unsigned long value);
@ -230,26 +424,86 @@ __int64 __ll_rshift(__int64 Mask, int Bit);
 #pragma intrinsic(__ll_rshift)
 unsigned __int64 __ull_rshift(unsigned __int64 Mask, int Bit);
 #pragma intrinsic(__ull_rshift)
+unsigned int __lzcnt(unsigned int Value);
+#pragma intrinsic(__lzcnt)
+unsigned short __lzcnt16(unsigned short Value);
+#pragma intrinsic(__lzcnt16)
+unsigned int __popcnt(unsigned int Value);
+#pragma intrinsic(__popcnt)
+unsigned short __popcnt16(unsigned short Value);
+#pragma intrinsic(__popcnt16)
 #endif
 #ifdef _M_AMD64
+unsigned __int64 __shiftleft128(unsigned __int64 LowPart, unsigned __int64 HighPart, unsigned char Shift);
+#pragma intrinsic(__shiftleft128)
+unsigned __int64 __shiftright128(unsigned __int64 LowPart, unsigned __int64 HighPart, unsigned char Shift);
+#pragma intrinsic(__shiftright128)
 unsigned char _bittest64(__int64 const *a, __int64 b);
 #pragma intrinsic(_bittest64)
+unsigned char _bittestandcomplement64(__int64 *a, __int64 b);
+#pragma intrinsic(_bittestandcomplement64)
+unsigned char _bittestandreset64(__int64 *a, __int64 b);
+#pragma intrinsic(_bittestandreset64)
+unsigned char _bittestandset64(__int64 *a, __int64 b);
+#pragma intrinsic(_bittestandset64)
+unsigned __int64 __lzcnt64(unsigned __int64 Value);
+#pragma intrinsic(__lzcnt64)
+unsigned __int64 __popcnt64(unsigned __int64 Value);
+#pragma intrinsic(__popcnt64)
+#elif defined(_M_ARM)
+unsigned int _CountLeadingOnes(unsigned long Value);
+unsigned int _CountLeadingOnes64(unsigned __int64 Value);
+unsigned int _CountLeadingSigns(long Value);
+unsigned int _CountLeadingSigns64(__int64 Value);
+unsigned int _CountLeadingZeros(unsigned long Value);
+unsigned int _CountLeadingZeros64(unsigned __int64 Value);
+unsigned int _CountOneBits(unsigned long Value);
+unsigned int _CountOneBits64(unsigned __int64 Value);
 #endif

+/*** 64/128-bit math ***/
+__int64 __cdecl _abs64(__int64);
+#pragma intrinsic(_abs64)
 #if defined(_M_IX86) || defined(_M_AMD64)
-/*** 64-bit math ***/
 __int64 __emul(int a, int b);
 #pragma intrinsic(__emul)
 unsigned __int64 __emulu(unsigned int a, unsigned int b);
 #pragma intrinsic(__emulu)
 #endif
 #ifdef _M_AMD64
+__int64 __mulh(__int64 a, __int64 b);
+#pragma intrinsic(__mulh)
 unsigned __int64 __umulh(unsigned __int64 a, unsigned __int64 b);
 #pragma intrinsic(__umulh)
+__int64 _mul128(__int64 Multiplier, __int64 Multiplicand, __int64 * HighProduct);
+#pragma intrinsic(_mul128)
+unsigned __int64 _umul128(unsigned __int64 Multiplier, unsigned __int64 Multiplicand, unsigned __int64 * HighProduct);
+#pragma intrinsic(_umul128)
+#elif defined(_M_ARM)
+long _MulHigh(long Multiplier, long Multiplicand);
+#pragma intrinsic(_MulHigh)
+unsigned long _MulUnsignedHigh(unsigned long Multiplier, unsigned long Multiplicand);
+#pragma intrinsic(_MulUnsignedHigh)
+#endif
+
+/** Floating point stuff **/
+#if defined(_M_ARM)
+int _isunordered(double arg1, double arg2);
+#pragma intrinsic(_isunordered)
+int _isunorderedf(float arg1, float arg2);
+#pragma intrinsic(_isunorderedf)
+double _CopyDoubleFromInt64(__int64);
+#pragma intrinsic(_CopyDoubleFromInt64)
+float _CopyFloatFromInt32(__int32);
+#pragma intrinsic(_CopyFloatFromInt32)
+__int32 _CopyInt32FromFloat(float);
+#pragma intrinsic(_CopyInt32FromFloat)
+__int64 _CopyInt64FromDouble(double);
+#pragma intrinsic(_CopyInt64FromDouble)
 #endif

-#if defined(_M_IX86) || defined(_M_AMD64)
 /*** Port I/O ***/
+#if defined(_M_IX86) || defined(_M_AMD64)
 unsigned char __inbyte(unsigned short Port);
 #pragma intrinsic(__inbyte)
 unsigned short __inword(unsigned short Port);
@ -274,21 +528,49 @@ void __outwordstring(unsigned short Port, unsigned short * Buffer, unsigned long
 #pragma intrinsic(__outwordstring)
 void __outdwordstring(unsigned short Port, unsigned long * Buffer, unsigned long Count);
 #pragma intrinsic(__outdwordstring)
+int __cdecl _inp(unsigned short Port);
+#pragma intrinsic(_inp)
+unsigned long __cdecl _inpd(unsigned short Port);
+#pragma intrinsic(_inpd)
+unsigned short __cdecl _inpw(unsigned short Port);
+#pragma intrinsic(_inpw)
+int __cdecl inp(unsigned short Port);
+#pragma intrinsic(inp)
+unsigned long __cdecl inpd(unsigned short Port);
+#pragma intrinsic(inpd)
+unsigned short __cdecl inpw(unsigned short Port);
+#pragma intrinsic(inpw)
+int __cdecl _outp(unsigned short Port, int Value);
+#pragma intrinsic(_outp)
+unsigned long __cdecl _outpd(unsigned short Port, unsigned long Value);
+#pragma intrinsic(_outpd)
+unsigned short __cdecl _outpw(unsigned short Port, unsigned short Value);
+#pragma intrinsic(_outpw)
+int __cdecl outp(unsigned short Port, int Value);
+#pragma intrinsic(outp)
+unsigned long __cdecl outpd(unsigned short Port, unsigned long Value);
+#pragma intrinsic(outpd)
+unsigned short __cdecl outpw(unsigned short Port, unsigned short Value);
+#pragma intrinsic(outpw)
 #endif

-#if defined(_M_IX86) || defined(_M_AMD64)
 /*** System information ***/
-void __cpuid(int CPUInfo[], int InfoType);
+#if defined(_M_IX86) || defined(_M_AMD64)
+void __cpuid(int CPUInfo[4], int InfoType);
 #pragma intrinsic(__cpuid)
+void __cpuidex(int CPUInfo[4], int InfoType, int ECXValue);
+#pragma intrinsic(__cpuidex)
 unsigned __int64 __rdtsc(void);
 #pragma intrinsic(__rdtsc)
+unsigned __int64 __rdtscp(unsigned int *);
+#pragma intrinsic(__rdtscp)
 void __writeeflags(uintptr_t Value);
 #pragma intrinsic(__writeeflags)
 uintptr_t __readeflags(void);
 #pragma intrinsic(__readeflags)
 #endif

-/*** Interrupts ***/
+/*** Interrupts and traps ***/
 void __debugbreak(void);
 #pragma intrinsic(__debugbreak)
 void _disable(void);
@ -300,49 +582,46 @@ void __int2c(void);
 #pragma intrinsic(__int2c)
 void __halt(void);
 #pragma intrinsic(__halt)
+void __ud2(void);
+#pragma intrinsic(__ud2)
+#if (_MSC_VER >= 1700)
+__declspec(noreturn) void __fastfail(unsigned int Code);
+#pragma intrinsic(__fastfail)
+#endif
+#endif
+#if defined(_M_ARM)
+int __trap(int Arg1, ...);
 #endif

 /*** Protected memory management ***/
 #if defined(_M_IX86) || defined(_M_AMD64)
-void __writecr0(unsigned __int64 Data);
+void __writecr0(uintptr_t Data);
 #pragma intrinsic(__writecr0)
-void __writecr3(unsigned __int64 Data);
+void __writecr3(uintptr_t Data);
 #pragma intrinsic(__writecr3)
-void __writecr4(unsigned __int64 Data);
+void __writecr4(uintptr_t Data);
 #pragma intrinsic(__writecr4)
-#endif
-#ifdef _M_AMD64
-void __writecr8(unsigned __int64 Data);
+void __writecr8(uintptr_t Data);
 #pragma intrinsic(__writecr8)
-unsigned __int64 __readcr0(void);
-#pragma intrinsic(__readcr0)
-unsigned __int64 __readcr2(void);
-#pragma intrinsic(__readcr2)
-unsigned __int64 __readcr3(void);
-#pragma intrinsic(__readcr3)
-unsigned __int64 __readcr4(void);
-#pragma intrinsic(__readcr4)
-unsigned __int64 __readcr8(void);
-#pragma intrinsic(__readcr8)
-unsigned __int64 __readdr(unsigned int reg);
-#pragma intrinsic(__readdr)
-void __writedr(unsigned reg, unsigned __int64 value);
-#pragma intrinsic(__writedr)
-#elif defined(_M_IX86)
+#endif
+#if defined(_M_IX86)
 unsigned long __readcr0(void);
+#pragma intrinsic(__readcr0)
 unsigned long __readcr2(void);
+#pragma intrinsic(__readcr2)
 unsigned long __readcr3(void);
+#pragma intrinsic(__readcr3)
 //unsigned long __readcr4(void);
 //#pragma intrinsic(__readcr4)
 // HACK: MSVC is broken
 unsigned long  ___readcr4(void);
 #define __readcr4 ___readcr4
-
+unsigned long __readcr8(void);
+#pragma intrinsic(__readcr8)
 unsigned int __readdr(unsigned int reg);
+#pragma intrinsic(__readdr)
 void __writedr(unsigned reg, unsigned int value);
-#endif
-
-#ifdef _M_IX86
+#pragma intrinsic(__writedr)
 // This intrinsic is broken and generates wrong opcodes,
 // when optimization is enabled!
 #pragma warning(push)
@ -362,15 +641,33 @@ void  __forceinline __invlpg_fixed(void * Address)
 #elif defined(_M_AMD64)
 void __invlpg(void * Address);
 #pragma intrinsic(__invlpg)
+#elif defined(_M_AMD64)
+unsigned __int64 __readcr0(void);
+#pragma intrinsic(__readcr0)
+unsigned __int64 __readcr2(void);
+#pragma intrinsic(__readcr2)
+unsigned __int64 __readcr3(void);
+#pragma intrinsic(__readcr3)
+unsigned __int64 __readcr4(void);
+#pragma intrinsic(__readcr4)
+unsigned __int64 __readcr8(void);
+#pragma intrinsic(__readcr8)
+unsigned __int64 __readdr(unsigned int reg);
+#pragma intrinsic(__readdr)
+void __writedr(unsigned reg, unsigned __int64 value);
+#pragma intrinsic(__writedr)
+#elif defined(_M_ARM)
+void __cdecl __prefetch(const void *);
+#pragma intrinsic(__prefetch)
 #endif

 /*** System operations ***/
 #if defined(_M_IX86) || defined(_M_AMD64)
-unsigned __int64 __readmsr(int reg);
+unsigned __int64 __readmsr(unsigned long reg);
 #pragma intrinsic(__readmsr)
 void __writemsr(unsigned long Register, unsigned __int64 Value);
 #pragma intrinsic(__writemsr)
-unsigned __int64 __readpmc(int counter);
+unsigned __int64 __readpmc(unsigned long counter);
 #pragma intrinsic(__readpmc)
 unsigned long __segmentlimit(unsigned long a);
 #pragma intrinsic(__segmentlimit)
@ -383,6 +680,95 @@ void __sidt(void *Destination);
 void _mm_pause(void);
 #pragma intrinsic(_mm_pause)
 #endif
+#if defined(_M_ARM)
+unsigned int _MoveFromCoprocessor(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int);
+#pragma intrinsic(_MoveFromCoprocessor)
+unsigned int _MoveFromCoprocessor2(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int);
+#pragma intrinsic(_MoveFromCoprocessor2)
+unsigned __int64 _MoveFromCoprocessor64(unsigned int, unsigned int, unsigned int);
+#pragma intrinsic(_MoveFromCoprocessor64)
+void _MoveToCoprocessor(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int);
+#pragma intrinsic(_MoveToCoprocessor)
+void _MoveToCoprocessor2(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int);
+#pragma intrinsic(_MoveToCoprocessor2)
+void _MoveToCoprocessor64(unsigned __int64, unsigned int, unsigned int, unsigned int);
+#pragma intrinsic(_MoveToCoprocessor64)
+int _ReadStatusReg(int);
+#pragma intrinsic(_ReadStatusReg)
+void _WriteStatusReg(int, int, int);
+#pragma intrinsic(_WriteStatusReg)
+void __yield(void);
+#pragma intrinsic(__yield)
+void __wfe(void);
+#pragma intrinsic(__wfe)
+void __wfi(void);
+#pragma intrinsic(__wfi)
+unsigned int __swi(unsigned int, ...);
+#pragma intrinsic(__swi)
+unsigned int __hvc(unsigned int, ...);
+#pragma intrinsic(__hvc)
+__int64 __ldrexd(__int64 volatile *);
+#pragma intrinsic(__ldrexd)
+unsigned __int64 __rdpmccntr64(void);
+#pragma intrinsic(__rdpmccntr64)
+void __sev(void);
+#pragma intrinsic(__sev)
+#endif
+
+/** Secure virtual machine **/
+#if defined(_M_IX86) || defined(_M_AMD64)
+void __svm_clgi(void);
+#pragma intrinsic(__svm_clgi)
+void __svm_invlpga(void * Va, int Asid);
+#pragma intrinsic(__svm_invlpga)
+void __svm_skinit(int Slb);
+#pragma intrinsic(__svm_skinit)
+void __svm_stgi(void);
+#pragma intrinsic(__svm_stgi)
+void __svm_vmload(uintptr_t VmcbPhysicalAddress);
+#pragma intrinsic(__svm_vmload)
+void __svm_vmrun(uintptr_t VmcbPhysicalAddress);
+#pragma intrinsic(__svm_vmrun)
+void __svm_vmsave(uintptr_t VmcbPhysicalAddress);
+#pragma intrinsic(__svm_vmsave)
+#endif
+
+/** Virtual machine extension **/
+#if defined(_M_IX86) || defined(_M_AMD64)
+void __vmx_off(void);
+void __vmx_vmptrst(unsigned __int64 * VmcsPhysicalAddress );
+#endif
+#if defined(_M_AMD64)
+unsigned char __vmx_on(unsigned __int64 * VmsSupportPhysicalAddress);
+unsigned char __vmx_vmclear(unsigned __int64 * VmcsPhysicalAddress);
+unsigned char __vmx_vmlaunch(void);
+unsigned char __vmx_vmptrld(unsigned __int64 *VmcsPhysicalAddress );
+unsigned char __vmx_vmread(size_t Field, size_t *FieldValue);
+unsigned char __vmx_vmresume(void);
+unsigned char __vmx_vmwrite(size_t Field, size_t FieldValue);
+#endif
+
+/** Misc **/
+void __nop(void);
+#pragma intrinsic(__nop)
+#if (_MSC_VER >= 1700)
+void __code_seg(const char *);
+#pragma intrinsic(__code_seg)
+#endif
+#ifdef _M_ARM
+int _AddSatInt(int, int);
+#pragma intrinsic(_AddSatInt)
+int _DAddSatInt(int, int);
+#pragma intrinsic(_DAddSatInt)
+int _DSubSatInt(int, int);
+#pragma intrinsic(_DSubSatInt)
+int _SubSatInt(int, int);
+#pragma intrinsic(_SubSatInt)
+void __emit(unsigned __int32);
+#pragma intrinsic(__emit)
+void __static_assert(int, const char *);
+#pragma intrinsic(__static_assert)
+#endif

 #ifdef __cplusplus
 }
--- a/include/ndk/arm/ketypes.h
+++ b/include/ndk/arm/ketypes.h
@ -27,6 +27,29 @@ extern "C" {
 // Dependencies
 //

+//
+// CPSR Values
+//
+#define CPSR_THUMB_ENABLE    0x20
+#define CPSR_FIQ_DISABLE     0x40
+#define CPSR_IRQ_DISABLE     0x80
+#define CPSR_USER_MODE       0x10
+#define CPSR_FIQ_MODE        0x11
+#define CPSR_IRQ_MODE        0x12
+#define CPSR_SVC_MODE        0x13
+#define CPSR_ABORT_MODE      0x17
+#define CPSR_UND_MODE        0x1B
+#define CPSR_MODES           0x1F
+
+//
+// C1 Register Values
+//
+#define C1_MMU_CONTROL       0x01
+#define C1_ALIGNMENT_CONTROL 0x02
+#define C1_DCACHE_CONTROL    0x04
+#define C1_ICACHE_CONTROL    0x1000
+#define C1_VECTOR_CONTROL    0x2000
+
 //
 // IPI Types
 //
--- a/include/psdk/basetsd.h
+++ b/include/psdk/basetsd.h
@ -1,5 +1,8 @@
-#ifndef _BASETSD_H
-#define _BASETSD_H
+#ifndef _BASETSD_H_
+#define _BASETSD_H_
+#pragma once
+
+#include <msvctarget.h>

 #ifndef _M_AMD64
 #if !defined(__ROS_LONG64__)
@ -23,30 +26,7 @@
 #error Not supported.
 #endif

-#if !defined(_X86_) && !defined(_AMD64_) && !defined(_IA64_) && !defined(_ALPHA_) && \
-    !defined(_ARM_) && !defined(_PPC_) && !defined(_MIPS_) && !defined(_68K_)
-
-#if defined(_M_AMD64) || defined(__x86_64__)
-#define _AMD64_
-#elif defined(_M_IX86) || defined(__i386__)
-#define _X86_
-#elif defined(_M_IA64) || defined(__ia64__)
-#define _IA64_
-#elif defined(_M_ALPHA) || defined(__alpha__)
-#define _ALPHA_
-#elif defined(_M_ARM) || defined(__arm__)
-#define _ARM_
-#elif defined(_M_PPC) || defined(__powerpc__)
-#define _PPC_
-#elif defined(_M_MRX000) || defined(__mips__)
-#define _MIPS_
-#elif defined(_M_M68K) || defined(__68k__)
-#define _68K_
-#endif
-
-#endif
-
-#if !defined(MIDL_PASS) && !defined(RC_INVOKED)
+#if defined(_MSC_VER) && !defined(MIDL_PASS) && !defined(RC_INVOKED)
 #define POINTER_64 __ptr64
 #if defined(_WIN64)
  #define POINTER_32 __ptr32
@ -56,7 +36,7 @@
 #else
 #define POINTER_64
 #define POINTER_32
-#endif /* !defined(MIDL_PASS) && !defined(RC_INVOKED) */
+#endif /* defined(_MSC_VER) && !defined(MIDL_PASS) && !defined(RC_INVOKED) */

 #if defined(_M_MRX000) || defined(_M_AMD64) || defined(_M_IA64)
 typedef unsigned __int64 POINTER_64_INT;
@ -64,6 +44,12 @@
 typedef unsigned long POINTER_64_INT;
 #endif

+#if defined(_IA64_) || defined(_AMD64_)
+ #define FIRMWARE_PTR
+#else
+ #define FIRMWARE_PTR POINTER_32
+#endif
+
 #if 0 /* Not supported yet */
 #define POINTER_SIGNED __sptr
 #define POINTER_UNSIGNED __uptr
@ -214,4 +200,4 @@ typedef KAFFINITY *PKAFFINITY;
 #endif
 #endif /* !RC_INVOKED */

-#endif /* _BASETSD_H */
+#endif /* _BASETSD_H_ */
--- a/include/psdk/ntdef.h
+++ b/include/psdk/ntdef.h
@ -20,25 +20,23 @@

 #ifndef _NTDEF_
 #define _NTDEF_
+#pragma once

 /* Dependencies */
 #include <ctype.h>
 #include <basetsd.h>
+#include <guiddef.h>
 #include <excpt.h>
 #include <sdkddkver.h>
 #include <specstrings.h>
+#include <kernelspecs.h>

 // FIXME: Shouldn't be included!
 #include <stdarg.h>
 #include <string.h>

-/* Helper macro to enable gcc's extension.  */
-#ifndef __GNU_EXTENSION
-#ifdef __GNUC__
-#define __GNU_EXTENSION __extension__
-#else
-#define __GNU_EXTENSION
-#endif
+#ifdef __cplusplus
+extern "C" {
 #endif

 /* Pseudo Modifiers for Input Parameters */
@ -63,16 +61,11 @@
 #define CRITICAL
 #endif

+// FIXME: deprecated
 #ifndef FAR
 #define FAR
 #endif

-
-/* Defines the "size" of an any-size array */
-#ifndef ANYSIZE_ARRAY
-#define ANYSIZE_ARRAY 1
-#endif
-
 /* Constant modifier */
 #ifndef CONST
 #define CONST const
@ -93,26 +86,22 @@
 #endif
 #endif /* NULL */

+/* Defines the "size" of an any-size array */
+#ifndef ANYSIZE_ARRAY
+#define ANYSIZE_ARRAY 1
+#endif

-//
-// FIXME
-// We should use the -fms-extensions compiler flag for gcc,
-// and clean up the mess.
-//
-#ifndef __ANONYMOUS_DEFINED
-#define __ANONYMOUS_DEFINED
-
-#ifndef NONAMELESSUNION
+/* Helper macro to enable gcc's extension.  */
+#ifndef __GNU_EXTENSION
 #ifdef __GNUC__
-#define _ANONYMOUS_UNION __GNU_EXTENSION
-#define _ANONYMOUS_STRUCT __GNU_EXTENSION
-#elif defined(__WATCOMC__) || defined(_MSC_VER)
-#define _ANONYMOUS_UNION
-#define _ANONYMOUS_STRUCT
-#endif /* __GNUC__/__WATCOMC__ */
-#endif /* NONAMELESSUNION */
+#define __GNU_EXTENSION __extension__
+#else
+#define __GNU_EXTENSION
+#endif
+#endif

-#ifndef _ANONYMOUS_UNION
+#ifndef DUMMYUNIONNAME
+#if defined(NONAMELESSUNION)// || !defined(_MSC_EXTENSIONS)
 #define _ANONYMOUS_UNION
 #define _UNION_NAME(x) x
 #define DUMMYUNIONNAME  u
@ -124,7 +113,9 @@
 #define DUMMYUNIONNAME6 u6
 #define DUMMYUNIONNAME7 u7
 #define DUMMYUNIONNAME8 u8
+#define DUMMYUNIONNAME9  u9
 #else
+#define _ANONYMOUS_UNION __GNU_EXTENSION
 #define _UNION_NAME(x)
 #define DUMMYUNIONNAME
 #define DUMMYUNIONNAME1
@ -135,9 +126,12 @@
 #define DUMMYUNIONNAME6
 #define DUMMYUNIONNAME7
 #define DUMMYUNIONNAME8
-#endif
+#define DUMMYUNIONNAME9
+#endif /* NONAMELESSUNION */
+#endif /* !DUMMYUNIONNAME */

-#ifndef _ANONYMOUS_STRUCT
+#ifndef DUMMYSTRUCTNAME
+#if defined(NONAMELESSUNION)// || !defined(_MSC_EXTENSIONS)
 #define _ANONYMOUS_STRUCT
 #define _STRUCT_NAME(x) x
 #define DUMMYSTRUCTNAME s
@ -147,6 +141,7 @@
 #define DUMMYSTRUCTNAME4 s4
 #define DUMMYSTRUCTNAME5 s5
 #else
+#define _ANONYMOUS_STRUCT __GNU_EXTENSION
 #define _STRUCT_NAME(x)
 #define DUMMYSTRUCTNAME
 #define DUMMYSTRUCTNAME1
@ -154,11 +149,14 @@
 #define DUMMYSTRUCTNAME3
 #define DUMMYSTRUCTNAME4
 #define DUMMYSTRUCTNAME5
+#endif /* NONAMELESSUNION */
+#endif /* DUMMYSTRUCTNAME */
+
+#if defined(STRICT_GS_ENABLED)
+#pragma strict_gs_check(push, on)
 #endif

-#endif /* __ANONYMOUS_DEFINED */
-
-#if defined(_M_MRX000) || defined(_M_ALPHA) || defined(_M_PPC) || defined(_M_IA64) || defined(_M_AMD64)
+#if defined(_M_MRX000) || defined(_M_ALPHA) || defined(_M_PPC) || defined(_M_IA64) || defined(_M_AMD64) || defined(_M_ARM)
 #define ALIGNMENT_MACHINE
 #define UNALIGNED __unaligned
 #if defined(_WIN64)
@ -203,7 +201,7 @@
 #endif

 /* Returns the type's alignment */
-#if defined(_MSC_VER) && (_MSC_VER >= 1300)
+#if defined(_MSC_VER)
 #define TYPE_ALIGNMENT(t) __alignof(t)
 #else
 #define TYPE_ALIGNMENT(t) FIELD_OFFSET(struct { char x; t test; }, test)
@ -217,8 +215,14 @@
 #error "unknown architecture"
 #endif

+#if defined(_WIN64)
+#define PROBE_ALIGNMENT32(_s) TYPE_ALIGNMENT(ULONG)
+#endif
+
 /* Calling Conventions */
-#if defined(_M_IX86)
+#if defined(_MANAGED)
+#define FASTCALL __stdcall
+#elif defined(_M_IX86)
 #define FASTCALL __fastcall
 #else
 #define FASTCALL
@ -234,15 +238,23 @@
 #define DECLSPEC_NORETURN __declspec(noreturn)

 #ifndef DECLSPEC_ADDRSAFE
-#if (_MSC_VER >= 1200) && (defined(_M_ALPHA) || defined(_M_AXP64))
+#if defined(_MSC_VER) && (defined(_M_ALPHA) || defined(_M_AXP64))
 #define DECLSPEC_ADDRSAFE  __declspec(address_safe)
 #else
 #define DECLSPEC_ADDRSAFE
 #endif
 #endif /* DECLSPEC_ADDRSAFE */

+#ifndef DECLSPEC_NOTHROW
+#if !defined(MIDL_PASS)
+#define DECLSPEC_NOTHROW __declspec(nothrow)
+#else
+#define DECLSPEC_NOTHROW
+#endif
+#endif
+
 #ifndef NOP_FUNCTION
-#if (_MSC_VER >= 1210)
+#if defined(_MSC_VER)
 #define NOP_FUNCTION __noop
 #else
 #define NOP_FUNCTION (void)0
@ -263,17 +275,13 @@

 /* Inlines */
 #ifndef FORCEINLINE
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
 #define FORCEINLINE __forceinline
-#elif defined(_MSC_VER)
-#define FORCEINLINE __inline
-#else /* __GNUC__ */
-# if ( __MINGW_GNUC_PREREQ(4, 3)  &&  __STDC_VERSION__ >= 199901L)
+#elif ( __MINGW_GNUC_PREREQ(4, 3)  &&  __STDC_VERSION__ >= 199901L)
 # define FORCEINLINE extern inline __attribute__((__always_inline__,__gnu_inline__))
 #else
 # define FORCEINLINE extern __inline__ __attribute__((__always_inline__))
 #endif
-#endif
 #endif /* FORCEINLINE */

 #ifndef DECLSPEC_NOINLINE
@ -294,7 +302,7 @@

 /* Use to specify structure alignment */
 #ifndef DECLSPEC_ALIGN
-#if defined(_MSC_VER) && (_MSC_VER >= 1300) && !defined(MIDL_PASS)
+#if defined(_MSC_VER) && !defined(MIDL_PASS)
 #define DECLSPEC_ALIGN(x) __declspec(align(x))
 #elif defined(__GNUC__)
 #define DECLSPEC_ALIGN(x) __attribute__ ((__aligned__(x)))
@ -315,14 +323,55 @@
 #define DECLSPEC_CACHEALIGN DECLSPEC_ALIGN(SYSTEM_CACHE_ALIGNMENT_SIZE)
 #endif

+#ifndef DECLSPEC_UUID
+#if defined(_MSC_VER) && defined(__cplusplus)
+#define DECLSPEC_UUID(x) __declspec(uuid(x))
+#else
+#define DECLSPEC_UUID(x)
+#endif
+#endif
+
+#ifndef DECLSPEC_NOVTABLE
+#if defined(_MSC_VER) && defined(__cplusplus)
+#define DECLSPEC_NOVTABLE __declspec(novtable)
+#else
+#define DECLSPEC_NOVTABLE
+#endif
+#endif
+
 #ifndef DECLSPEC_SELECTANY
-#if (_MSC_VER >= 1100) || defined(__GNUC__)
+#if defined(_MSC_VER) || defined(__GNUC__)
 #define DECLSPEC_SELECTANY __declspec(selectany)
 #else
 #define DECLSPEC_SELECTANY
 #endif
 #endif

+#ifndef DECLSPEC_DEPRECATED
+#if (defined(_MSC_VER) || defined(__GNUC__)) && !defined(MIDL_PASS)
+#define DECLSPEC_DEPRECATED __declspec(deprecated)
+#define DEPRECATE_SUPPORTED
+#else
+#define DECLSPEC_DEPRECATED
+#undef  DEPRECATE_SUPPORTED
+#endif
+#endif
+
+#ifdef DEPRECATE_DDK_FUNCTIONS
+#ifdef _NTDDK_
+#define DECLSPEC_DEPRECATED_DDK DECLSPEC_DEPRECATED
+#ifdef DEPRECATE_SUPPORTED
+#define PRAGMA_DEPRECATED_DDK 1
+#endif
+#else
+#define DECLSPEC_DEPRECATED_DDK
+#define PRAGMA_DEPRECATED_DDK 1
+#endif
+#else
+#define DECLSPEC_DEPRECATED_DDK
+#define PRAGMA_DEPRECATED_DDK 0
+#endif
+
 /* Use to silence unused variable warnings when it is intentional */
 #define UNREFERENCED_PARAMETER(P) {(P)=(P);}
 #define UNREFERENCED_LOCAL_VARIABLE(L) ((void)(L))
@ -347,18 +396,15 @@

 /* Void Pointers */
 typedef void *PVOID;
-//typedef void * POINTER_64 PVOID64;
-typedef PVOID PVOID64; // FIXME!
+typedef void * POINTER_64 PVOID64;

 /* Handle Type */
+typedef void *HANDLE, **PHANDLE;;
 #ifdef STRICT
-typedef void *HANDLE;
-#define DECLARE_HANDLE(n) typedef struct n##__{int i;}*n
+#define DECLARE_HANDLE(n) typedef struct n##__{int unused;} *n
 #else
-typedef PVOID HANDLE;
 #define DECLARE_HANDLE(n) typedef HANDLE n
 #endif
-typedef HANDLE *PHANDLE;

 /* Upper-Case Versions of Some Standard C Types */
 #ifndef VOID
@ -891,4 +937,8 @@ typedef struct _GROUP_AFFINITY {
 #define LANG_YORUBA                               0x6a
 #define LANG_ZULU                                 0x35

+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif /* _NTDEF_ */
--- a/include/psdk/ras.h
+++ b/include/psdk/ras.h
@ -13,7 +13,7 @@ extern "C"
 /* TODO
 include <basetsd.h> from winnt.h so that this typedef is not necessary
 */
-#ifndef _BASETSD_H
+#ifndef _BASETSD_H_
 typedef unsigned long ULONG_PTR, *PULONG_PTR;
 #endif

--- a/include/psdk/wingdi.h
+++ b/include/psdk/wingdi.h
@ -2894,11 +2894,17 @@ typedef UINT (CALLBACK *LPFNDEVMODE)(HWND,HMODULE,LPDEVMODEA,LPSTR,LPSTR,LPDEVMO
 typedef DWORD (CALLBACK *LPFNDEVCAPS)(LPSTR,LPSTR,UINT,LPSTR,LPDEVMODEA);


-#define RGB(r,g,b)	((DWORD)(((BYTE)(r)|((WORD)(g)<<8))|(((DWORD)(BYTE)(b))<<16)))
+#define GetRValue(rgb) ((BYTE)(rgb))
+#define GetGValue(rgb) ((BYTE)(((WORD)(rgb)) >> 8))
+#define GetBValue(rgb) ((BYTE)((rgb)>>16))
+
+#define RGB(r,g,b)          ((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(b))<<16)))
+#define PALETTERGB(r,g,b)   (0x02000000 | RGB(r,g,b))
+#define PALETTEINDEX(i)     ((COLORREF)(0x01000000 | (DWORD)(WORD)(i)))
+
 #define MAKEPOINTS(l) (*((POINTS*)&(l)))
 #define MAKEROP4(f,b) (DWORD)((((b)<<8)&0xFF000000)|(f))
-#define PALETTEINDEX(i)	((0x01000000|(COLORREF)(WORD)(i)))
-#define PALETTERGB(r,g,b)	(0x02000000|RGB(r,g,b))
+
 int WINAPI AbortDoc(_In_ HDC);
 BOOL WINAPI AbortPath(_In_ HDC);
 int WINAPI AddFontResourceA(LPCSTR);
@ -3197,14 +3203,13 @@ GdiGradientFill(

 BOOL WINAPI GdiTransparentBlt(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT);
 BOOL WINAPI GdiIsMetaFileDC(HDC);
-#define GetCValue(cmyk) ((BYTE)(cmyk))
-#define GetMValue(cmyk) ((BYTE)((cmyk)>> 8))
-#define GetYValue(cmyk) ((BYTE)((cmyk)>>16))
-#define GetKValue(cmyk) ((BYTE)((cmyk)>>24))
-#define CMYK(c,m,y,k) ((COLORREF)((((BYTE)(c)|((WORD)((BYTE)(m))<<8))|(((DWORD)(BYTE)(y))<<16))|(((DWORD)(BYTE)(k))<<24)))
-#define GetRValue(c) ((BYTE)(c))
-#define GetGValue(c) ((BYTE)(((WORD)(c))>>8))
-#define GetBValue(c) ((BYTE)((c)>>16))
+
+#define GetKValue(cmyk) ((BYTE)(cmyk))
+#define GetYValue(cmyk) ((BYTE)((cmyk)>> 8))
+#define GetMValue(cmyk) ((BYTE)((cmyk)>>16))
+#define GetCValue(cmyk) ((BYTE)((cmyk)>>24))
+#define CMYK(c,m,y,k) ((COLORREF)((((BYTE)(k)|((WORD)((BYTE)(y))<<8))|(((DWORD)(BYTE)(m))<<16))|(((DWORD)(BYTE)(c))<<24)))
+
 int WINAPI GetArcDirection(_In_ HDC);
 BOOL WINAPI GetAspectRatioFilterEx(_In_ HDC, _Out_ LPSIZE);

--- a/include/psdk/winnls.h
+++ b/include/psdk/winnls.h
@ -473,7 +473,7 @@ static const WCHAR LOCALE_NAME_SYSTEM_DEFAULT[] = {'!','s','y','s','-','d','e','
 #define VS_ALLOW_LATIN 0x1
 #define GSS_ALLOW_INHERITED_COMMON 0x1
 #endif
-#ifndef  _BASETSD_H
+#ifndef  _BASETSD_H_
 typedef long LONG_PTR;
 #endif

--- a/include/psdk/winnt.h
+++ b/include/psdk/winnt.h
@ -3310,7 +3310,7 @@ typedef struct _CONTEXT {
 	DWORD Fill[2];

 } CONTEXT;
-#elif defined(ARM)
+#elif defined(_ARM_)

 #ifndef PAGE_SIZE
 #define PAGE_SIZE                         0x1000 // FIXME: This should probably go elsewhere
--- a/include/reactos/arm/armddk.h
+++ b/include/reactos/arm/armddk.h
@ -228,6 +228,7 @@ extern volatile struct _KSYSTEM_TIME KeTickCount;
 #define RESULT_NEGATIVE 1
 #define RESULT_POSITIVE 2

+#if 0
 DECLSPEC_IMPORT
 VOID
 __fastcall
@ -240,6 +241,7 @@ KIRQL
 __fastcall
 KfAcquireSpinLock(
  IN OUT ULONG_PTR* SpinLock);
+#endif

 #ifndef _WINNT_
 //
--- a/include/reactos/idl/ms-dtyp.idl
+++ b/include/reactos/idl/ms-dtyp.idl
@ -7,7 +7,7 @@ typedef int BOOL, *PBOOL, *LPBOOL;
 typedef unsigned char BYTE, *PBYTE, *LPBYTE;
 typedef unsigned long DWORD, *PDWORD, *LPDWORD;
 cpp_quote("#endif")
-cpp_quote("#ifndef _BASETSD_H")
+cpp_quote("#ifndef _BASETSD_H_")
 typedef unsigned int DWORD32;
 typedef unsigned __int64 DWORD64;
 cpp_quote("#endif")
@ -15,13 +15,13 @@ cpp_quote("#endif")
 cpp_quote("#ifndef _WINDEF_H")
 typedef int INT, *LPINT;
 cpp_quote("#endif")
-cpp_quote("#ifndef _BASETSD_H")
+cpp_quote("#ifndef _BASETSD_H_")
 typedef signed char INT8;
 typedef signed short INT16;
 typedef signed int INT32;
 typedef signed __int64 INT64;
 cpp_quote("#endif")
-cpp_quote("#ifndef _BASETSD_H")
+cpp_quote("#ifndef _BASETSD_H_")
 typedef signed int LONG32;
 typedef signed __int64 LONG64;
 cpp_quote("#endif")
@ -37,7 +37,7 @@ cpp_quote("#endif")
 cpp_quote("#ifndef _WINDEF_H")
 typedef unsigned int UINT;
 cpp_quote("#endif")
-cpp_quote("#ifndef _BASETSD_H")
+cpp_quote("#ifndef _BASETSD_H_")
 typedef unsigned char UINT8;
 typedef unsigned short UINT16;
 typedef unsigned int UINT32;
@ -46,7 +46,7 @@ cpp_quote("#endif")
 cpp_quote("#ifndef _WINNT_")
 typedef unsigned long ULONG, *PULONG;
 cpp_quote("#endif")
-cpp_quote("#ifndef _BASETSD_H")
+cpp_quote("#ifndef _BASETSD_H_")
 typedef unsigned int ULONG32;
 typedef unsigned __int64 ULONG64;
 cpp_quote("#endif")
@ -77,7 +77,7 @@ cpp_quote("#endif")
 cpp_quote("#ifndef _WINNT_")
 typedef BYTE BOOLEAN, *PBOOLEAN;
 cpp_quote("#endif")
-cpp_quote("#ifndef _BASETSD_H")
+cpp_quote("#ifndef _BASETSD_H_")
 #ifdef _WIN64
 typedef __int64 LONG_PTR;
 typedef unsigned __int64 ULONG_PTR;
--- a/include/reactos/libs/fast486/fast486.h
+++ b/include/reactos/libs/fast486/fast486.h
@ -251,6 +251,7 @@ typedef struct _FAST486_SEG_REG
    ULONG DirConf       : 1;
    ULONG Executable    : 1;
    ULONG SystemType    : 1;
+    ULONG Rpl           : 2;
    ULONG Dpl           : 2;
    ULONG Present       : 1;
    ULONG Size          : 1;
--- a/include/reactos/msvctarget.h
+++ b/include/reactos/msvctarget.h
@ -1,19 +1,52 @@
-#ifndef _MSC_VER
-#ifndef __GNUC__
-#error Unsupported compiler
-#endif
+
+#pragma once

 /* translate GCC target defines to MS equivalents. */
-#if defined(__i686__) && !defined(_M_IX86)
-#define _M_IX86 600
-#undef __i686__
-#elif defined(__i586__) && !defined(_M_IX86)
-#define _M_IX86 500
-#undef __i586__
-#elif defined(__i486__) && !defined(_M_IX86)
-#define _M_IX86 400
-#undef __i486__
-#elif defined(__i386__) && !defined(_M_IX86)
-#define _M_IX86 300
+#if defined(__i386__)
+ #if !defined(_X86_)
+  #define _X86_ 1
 #endif
+ #if !defined(_M_IX86)
+  #define _M_IX86 1
+ #endif
+#elif defined(__x86_64__) || defined(__x86_64)
+ #if !defined(_AMD64_)
+  #define _AMD64_ 1
+ #endif
+ #if !defined(_M_AMD64)
+  #define _M_AMD64 1
+ #endif
+ #if !defined(_M_X64)
+  #define _M_X64 1
+ #endif
+#elif defined(__arm__)
+ #if !defined(_ARM_)
+  #define _ARM_ 1
+ #endif
+ #if !defined(_M_ARM)
+  #define _M_ARM 1
+ #endif
+#elif defined(__ia64__)
+ #if !defined(_IA64_)
+  #define _IA64_ 1
+ #endif
+ #if !defined(_M_IA64)
+  #define _M_IA64 1
+ #endif
+#elif defined(__alpha__)
+ #if !defined(_ALPHA_)
+  #define _ALPHA_ 1
+ #endif
+ #if !defined(_M_ALPHA)
+  #define _M_ALPHA 1
+ #endif
+#elif defined(__powerpc__)
+ #if !defined(_PPC_)
+  #define _PPC_ 1
+ #endif
+ #if !defined(_M_PPC)
+  #define _M_PPC 1
+ #endif
+#else
+#error Unknown architecture
 #endif
--- a/lib/3rdparty/stlport/src/stdio_streambuf.cpp
+++ b/lib/3rdparty/stlport/src/stdio_streambuf.cpp
@ -34,7 +34,7 @@ _STLP_MOVE_TO_PRIV_NAMESPACE

 #if defined (_STLP_USE_DEFAULT_FILE_OFFSET) || \
    (!defined(_LARGEFILE_SOURCE) && !defined(_LARGEFILE64_SOURCE))
-#  if !defined (_STLP_MSVC) || (_STLP_MSVC < 1400) || defined(_STLP_WCE)
+#  if !defined (_STLP_MSVC) || (_STLP_MSVC < 1400) || defined(_STLP_WCE) || defined(__REACTOS__)
 #    define FSEEK fseek
 #  else
 #    define FSEEK _fseeki64
--- a/lib/atl/statreg.h
+++ b/lib/atl/statreg.h
@ -272,7 +272,7 @@ private:
 			{
 				len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0) + 1;
 				regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR)));
-				if (regstra == NULL)
+				if (regstrw == NULL)
 				{
 					HeapFree(GetProcessHeap(), 0, regstra);
 					return E_OUTOFMEMORY;
--- a/lib/fast486/common.c
+++ b/lib/fast486/common.c
@ -65,7 +65,7 @@ Fast486ReadMemory(PFAST486_STATE State,
            return FALSE;
        }

-        if ((!InstFetch && (GET_SEGMENT_RPL(CachedDescriptor->Selector) > CachedDescriptor->Dpl))
+        if ((!InstFetch && (CachedDescriptor->Rpl > CachedDescriptor->Dpl))
            || (Fast486GetCurrentPrivLevel(State) > CachedDescriptor->Dpl))
        {
            Fast486Exception(State, FAST486_EXCEPTION_GP);
@ -132,7 +132,7 @@ Fast486WriteMemory(PFAST486_STATE State,
            return FALSE;
        }

-        if ((GET_SEGMENT_RPL(CachedDescriptor->Selector) > CachedDescriptor->Dpl)
+        if ((CachedDescriptor->Rpl > CachedDescriptor->Dpl)
            || (Fast486GetCurrentPrivLevel(State) > CachedDescriptor->Dpl))
        {
            Fast486Exception(State, FAST486_EXCEPTION_GP);
@ -164,8 +164,11 @@ BOOLEAN
 Fast486InterruptInternal(PFAST486_STATE State,
                         USHORT SegmentSelector,
                         ULONG Offset,
-                         BOOLEAN InterruptGate)
+                         ULONG GateType)
 {
+    BOOLEAN GateSize = (GateType == FAST486_IDT_INT_GATE_32)
+                       || (GateType == FAST486_IDT_TRAP_GATE_32);
+
    /* Check for protected mode */
    if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE)
    {
@ -173,6 +176,15 @@ Fast486InterruptInternal(PFAST486_STATE State,
        USHORT OldSs = State->SegmentRegs[FAST486_REG_SS].Selector;
        ULONG OldEsp = State->GeneralRegs[FAST486_REG_ESP].Long;
        
+        if (GateSize != (State->SegmentRegs[FAST486_REG_CS].Size))
+        {
+            /*
+             * The gate size doesn't match the current operand size, so toggle
+             * the OPSIZE flag.
+             */
+            State->PrefixFlags ^= FAST486_PREFIX_OPSIZE;
+        }
+
        /* Check if the interrupt handler is more privileged */
        if (Fast486GetCurrentPrivLevel(State) > GET_SEGMENT_RPL(SegmentSelector))
        {
@ -257,7 +269,7 @@ Fast486InterruptInternal(PFAST486_STATE State,
    /* Push the instruction pointer */
    if (!Fast486StackPush(State, State->InstPtr.Long)) return FALSE;

-    if (InterruptGate)
+    if ((GateType == FAST486_IDT_INT_GATE) || (GateType == FAST486_IDT_INT_GATE_32))
    {
        /* Disable interrupts after a jump to an interrupt gate handler */
        State->Flags.If = FALSE;
@ -270,7 +282,7 @@ Fast486InterruptInternal(PFAST486_STATE State,
        return FALSE;
    }

-    if (State->SegmentRegs[FAST486_REG_CS].Size)
+    if (GateSize)
    {
        /* 32-bit code segment, use EIP */
        State->InstPtr.Long = Offset;
--- a/lib/fast486/common.h
+++ b/lib/fast486/common.h
@ -159,7 +159,7 @@ Fast486InterruptInternal
    PFAST486_STATE State,
    USHORT SegmentSelector,
    ULONG Offset,
-    BOOLEAN InterruptGate
+    ULONG GateType
 );

 VOID
--- a/lib/fast486/common.inl
+++ b/lib/fast486/common.inl
@ -542,6 +542,8 @@ Fast486LoadSegment(PFAST486_STATE State,
        {
            /* Loading a data segment */

+            if (GET_SEGMENT_INDEX(Selector) != 0)
+            {
                if (!GdtEntry.SystemType)
                {
                    /* This is a special descriptor */
@ -562,6 +564,12 @@ Fast486LoadSegment(PFAST486_STATE State,
                    return FALSE;
                }
            }
+            else
+            {
+                /* This is a NULL selector */
+                RtlZeroMemory(&GdtEntry, sizeof(GdtEntry));
+            }
+        }

        /* Update the cache entry */
        CachedDescriptor->Selector = Selector;
@ -572,6 +580,7 @@ Fast486LoadSegment(PFAST486_STATE State,
        CachedDescriptor->DirConf = GdtEntry.DirConf;
        CachedDescriptor->Executable = GdtEntry.Executable;
        CachedDescriptor->SystemType = GdtEntry.SystemType;
+        CachedDescriptor->Rpl = GET_SEGMENT_RPL(Selector);
        CachedDescriptor->Dpl = GdtEntry.Dpl;
        CachedDescriptor->Present = GdtEntry.Present;
        CachedDescriptor->Size = GdtEntry.Size;
--- a/lib/fast486/opcodes.c
+++ b/lib/fast486/opcodes.c
@ -3702,9 +3702,9 @@ FAST486_OPCODE_HANDLER(Fast486OpcodePushImm)
    }
    else
    {
-        USHORT Data;
+        SHORT Data;

-        if (!Fast486FetchWord(State, &Data))
+        if (!Fast486FetchWord(State, (PUSHORT)&Data))
        {
            /* Exception occurred */
            return FALSE;
@ -3837,12 +3837,12 @@ FAST486_OPCODE_HANDLER(Fast486OpcodeImulModrmImm)

 FAST486_OPCODE_HANDLER(Fast486OpcodePushByteImm)
 {
-    UCHAR Data;
+    CHAR Data;

    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x6A);

-    if (!Fast486FetchByte(State, &Data))
+    if (!Fast486FetchByte(State, (PUCHAR)&Data))
    {
        /* Exception occurred */
        return FALSE;
--- a/lib/fast486/opgroups.c
+++ b/lib/fast486/opgroups.c
@ -2018,10 +2018,13 @@ FAST486_OPCODE_HANDLER(Fast486OpcodeGroup0F01)
 {
    UCHAR TableReg[6];
    FAST486_MOD_REG_RM ModRegRm;
-    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
+    BOOLEAN OperandSize, AddressSize;
    FAST486_SEG_REGS Segment = FAST486_REG_DS;

+    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
+
    NO_LOCK_PREFIX();
+    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);

    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
@ -2117,6 +2120,9 @@ FAST486_OPCODE_HANDLER(Fast486OpcodeGroup0F01)
            State->Gdtr.Size = *((PUSHORT)TableReg);
            State->Gdtr.Address = *((PULONG)&TableReg[sizeof(USHORT)]);

+            /* In 16-bit mode the highest byte is masked out */
+            if (!OperandSize) State->Gdtr.Address &= 0x00FFFFFF;
+
            return TRUE;
        }

@ -2153,6 +2159,9 @@ FAST486_OPCODE_HANDLER(Fast486OpcodeGroup0F01)
            State->Idtr.Size = *((PUSHORT)TableReg);
            State->Idtr.Address = *((PULONG)&TableReg[sizeof(USHORT)]);

+            /* In 16-bit mode the highest byte is masked out */
+            if (!OperandSize) State->Idtr.Address &= 0x00FFFFFF;
+
            return TRUE;
        }

--- a/lib/pseh/CMakeLists.txt
+++ b/lib/pseh/CMakeLists.txt
@ -29,14 +29,13 @@ else()
        list(APPEND ASM_SOURCE
            i386/seh.s
            i386/seh_prolog.s)
-        list(APPEND SOURCE dummy.c)
    elseif(ARCH STREQUAL "amd64")
        list(APPEND ASM_SOURCE
            amd64/seh.s
            amd64/seh_prolog.s)
-        list(APPEND SOURCE dummy.c)
    endif()

+    list(APPEND SOURCE dummy.c)
    add_asm_files(pseh_asm ${ASM_SOURCE})
    add_library(pseh ${SOURCE} ${pseh_asm})
    add_dependencies(pseh asm)
--- a/lib/rtl/bitmap.c
+++ b/lib/rtl/bitmap.c
@ -30,6 +30,9 @@ typedef ULONG64 BITMAP_BUFFER, *PBITMAP_BUFFER;
 #undef BitScanForward
 #define BitScanForward(Index, Mask) \
    do { unsigned long tmp; BitScanForward64(&tmp, Mask); *Index = tmp; } while (0)
+#undef BitScanReverse
+#define BitScanReverse(Index, Mask) \
+    do { unsigned long tmp; BitScanReverse64(&tmp, Mask); *Index = tmp; } while (0)
 #define RtlFillMemoryUlong RtlFillMemoryUlonglong

 #define RtlInitializeBitMap RtlInitializeBitMap64
@ -734,7 +737,7 @@ RtlFindFirstRunClear(
    return RtlFindNextForwardRunClear(BitMapHeader, 0, StartingIndex);
 }

-ULONG
+BITMAP_INDEX
 NTAPI
 RtlFindLastBackwardRunClear(
    _In_ PRTL_BITMAP BitMapHeader,
@ -771,7 +774,7 @@ RtlFindLastBackwardRunClear(
    BitScanReverse(&BitPos, InvValue);

    /* Calculate last bit position */
-    FromIndex = (Buffer + 1 - BitMapHeader->Buffer) * _BITCOUNT + BitPos;
+    FromIndex = (BITMAP_INDEX)((Buffer + 1 - BitMapHeader->Buffer) * _BITCOUNT + BitPos);

    Value = ~InvValue << ((_BITCOUNT - 1) - BitPos) >> ((_BITCOUNT - 1) - BitPos);

@ -787,7 +790,7 @@ RtlFindLastBackwardRunClear(
        BitScanReverse(&BitPos, Value);

        /* Calculate Starting Index */
-        *StartingRunIndex = (Buffer + 1 - BitMapHeader->Buffer) * _BITCOUNT + BitPos + 1;
+        *StartingRunIndex = (BITMAP_INDEX)((Buffer + 1 - BitMapHeader->Buffer) * _BITCOUNT + BitPos + 1);
    }
    else
    {
@ -796,7 +799,7 @@ RtlFindLastBackwardRunClear(
    }

    /* Return length of the run */
-    return FromIndex - *StartingRunIndex;
+    return (FromIndex - *StartingRunIndex);
 }


--- a/lib/sdk/crt/crt.cmake
+++ b/lib/sdk/crt/crt.cmake
@ -306,6 +306,7 @@ list(APPEND CRT_SOURCE
    string/wtoi.c
    string/wtoi64.c
    string/wtol.c
+    string/winesup.c
    sys_stat/systime.c
    time/asctime.c
    time/clock.c
--- a/lib/sdk/crt/include/internal/locale.h
+++ b/lib/sdk/crt/include/internal/locale.h
@ -18,7 +18,7 @@ typedef struct MSVCRT_threadlocaleinfostruct {
    int *lconv_intl_refcount;
    int *lconv_num_refcount;
    int *lconv_mon_refcount;
-    struct MSVCRT_lconv *lconv;
+    struct lconv *lconv;
    int *ctype1_refcount;
    unsigned short *ctype1;
    const unsigned short *pctype;
@ -37,26 +37,7 @@ typedef struct MSVCRT_threadmbcinfostruct {
    char mbcasemap[256];
 } MSVCRT_threadmbcinfo;

-struct MSVCRT_lconv {
-    char* decimal_point;
-    char* thousands_sep;
-    char* grouping;
-    char* int_curr_symbol;
-    char* currency_symbol;
-    char* mon_decimal_point;
-    char* mon_thousands_sep;
-    char* mon_grouping;
-    char* positive_sign;
-    char* negative_sign;
-    char int_frac_digits;
-    char frac_digits;
-    char p_cs_precedes;
-    char p_sep_by_space;
-    char n_cs_precedes;
-    char n_sep_by_space;
-    char p_sign_posn;
-    char n_sign_posn;
-};
+#define MSVCRT_lconv lconv

 typedef struct MSVCRT_threadlocaleinfostruct *MSVCRT_pthreadlocinfo;
 typedef struct MSVCRT_threadmbcinfostruct *MSVCRT_pthreadmbcinfo;
--- a/lib/sdk/crt/libcntpr.cmake
+++ b/lib/sdk/crt/libcntpr.cmake
@ -59,6 +59,7 @@ list(APPEND LIBCNTPR_SOURCE
    string/wtoi64.c
    string/wtoi.c
    string/wtol.c
+    string/winesup.c
    wstring/wcsicmp.c
    wstring/wcslwr.c
    wstring/wcsnicmp.c
--- a/lib/sdk/crt/string/scanf.c
+++ b/lib/sdk/crt/string/scanf.c
@ -23,13 +23,15 @@
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

-#include <precomp.h>
-#include <ctype.h>
+#include <stdarg.h>
+#include <limits.h>

-// HACK for LIBCNT
-#ifndef debugstr_a
-#define debugstr_a
-#endif
+#include <winternl.h>
+#include <wine/debug.h>
+
+#include "winesup.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);

 //extern FILE _iob[];

@ -56,78 +58,83 @@ static int wchar2digit(wchar_t c, int base) {
 }

 #ifndef _LIBCNT_
-/* vfscanf */
+/* vfscanf_l */
 #undef WIDE_SCANF
 #undef CONSOLE
 #undef STRING
+#undef SECURE
 #include "scanf.h"

-/* vfwscanf */
+/* vfwscanf_l */
 #define WIDE_SCANF 1
 #undef CONSOLE
 #undef STRING
+#undef SECURE
 #include "scanf.h"
-#endif
+#endif /* !_LIBCNT_ */

-/* vsscanf */
+/* vsscanf_l */
 #undef WIDE_SCANF
 #undef CONSOLE
 #define STRING 1
+#undef SECURE
 #include "scanf.h"

-/* vswscanf */
+/* vswscanf_l */
 #define WIDE_SCANF 1
 #undef CONSOLE
 #define STRING 1
+#undef SECURE
 #include "scanf.h"

 #ifndef _LIBCNT_
-/* vcscanf */
+/* vcscanf_l */
 #undef WIDE_SCANF
 #define CONSOLE 1
 #undef STRING
+#undef SECURE
 #include "scanf.h"


 /*********************************************************************
 *		fscanf (MSVCRT.@)
 */
-int fscanf(FILE *file, const char *format, ...)
+int CDECL fscanf(FILE *file, const char *format, ...)
 {
-    va_list valist;
+    __ms_va_list valist;
    int res;

-    va_start(valist, format);
-    res = vfscanf(file, format, valist);
-    va_end(valist);
+    __ms_va_start(valist, format);
+    res = vfscanf_l(file, format, NULL, valist);
+    __ms_va_end(valist);
    return res;
 }

 /*********************************************************************
 *		scanf (MSVCRT.@)
 */
-int scanf(const char *format, ...)
+int CDECL scanf(const char *format, ...)
 {
-    va_list valist;
+    __ms_va_list valist;
    int res;

-    va_start(valist, format);
-    res = vfscanf(stdin, format, valist);
-    va_end(valist);
+    __ms_va_start(valist, format);
+    res = vfscanf_l(stdin, format, NULL, valist);
+    __ms_va_end(valist);
    return res;
 }

 /*********************************************************************
 *		fwscanf (MSVCRT.@)
 */
-int fwscanf(FILE *file, const wchar_t *format, ...)
+int CDECL fwscanf(FILE *file, const wchar_t *format, ...)
 {
-    va_list valist;
+    __ms_va_list valist;
    int res;

-    va_start(valist, format);
-    res = vfwscanf(file, format, valist);
-    va_end(valist);
+    __ms_va_start(valist, format);
+    res = vfwscanf_l(file, format, NULL, valist);
+    __ms_va_end(valist);
    return res;
 }

@ -135,30 +142,30 @@ int fwscanf(FILE *file, const wchar_t *format, ...)
 /*********************************************************************
 *		wscanf (MSVCRT.@)
 */
-int wscanf(const wchar_t *format, ...)
+int CDECL wscanf(const wchar_t *format, ...)
 {
-    va_list valist;
+    __ms_va_list valist;
    int res;

-    va_start(valist, format);
-    res = vfwscanf(stdin, format, valist);
-    va_end(valist);
+    __ms_va_start(valist, format);
+    res = vfwscanf_l(stdin, format, NULL, valist);
+    __ms_va_end(valist);
    return res;
 }
-#endif
+#endif /* !_LIBCNT_ */


 /*********************************************************************
 *		sscanf (MSVCRT.@)
 */
-int sscanf(const char *str, const char *format, ...)
+int CDECL sscanf(const char *str, const char *format, ...)
 {
-    va_list valist;
+    __ms_va_list valist;
    int res;

-    va_start(valist, format);
-    res = vsscanf(str, format, valist);
-    va_end(valist);
+    __ms_va_start(valist, format);
+    res = vsscanf_l(str, format, NULL, valist);
+    __ms_va_end(valist);
    return res;
 }

@ -168,12 +175,12 @@ int sscanf(const char *str, const char *format, ...)
 */
 int CDECL swscanf(const wchar_t *str, const wchar_t *format, ...)
 {
-    va_list valist;
+    __ms_va_list valist;
    int res;

-    va_start(valist, format);
-    res = vswscanf(str, format, valist);
-    va_end(valist);
+    __ms_va_start(valist, format);
+    res = vswscanf_l(str, format, NULL, valist);
+    __ms_va_end(valist);
    return res;
 }

@ -183,12 +190,12 @@ int CDECL swscanf(const wchar_t *str, const wchar_t *format, ...)
 */
 int CDECL _cscanf(const char *format, ...)
 {
-    va_list valist;
+    __ms_va_list valist;
    int res;

-    va_start(valist, format);
-    res = vcscanf(format, valist);
-    va_end(valist);
+    __ms_va_start(valist, format);
+    res = vcscanf_l(format, NULL, valist);
+    __ms_va_end(valist);
    return res;
 }
 #endif
--- a/lib/sdk/crt/string/scanf.h
+++ b/lib/sdk/crt/string/scanf.h
@ -48,7 +48,11 @@
 #ifdef CONSOLE
 #define _GETC_(file) (consumed++, _getch())
 #define _UNGETC_(nch, file) do { _ungetch(nch); consumed--; } while(0)
-#define _FUNCTION_ int vcscanf(const char *format, va_list ap)
+#ifdef SECURE
+#define _FUNCTION_ static int vcscanf_s_l(const char *format, _locale_t locale, __ms_va_list ap)
+#else  /* SECURE */
+#define _FUNCTION_ static int vcscanf_l(const char *format, _locale_t locale, __ms_va_list ap)
+#endif /* SECURE */
 #else
 #ifdef STRING
 #undef _EOF_
@ -56,24 +60,41 @@
 #define _GETC_(file) (consumed++, *file++)
 #define _UNGETC_(nch, file) do { file--; consumed--; } while(0)
 #ifdef WIDE_SCANF
-#define _FUNCTION_ int vswscanf(const wchar_t *file, const wchar_t *format, va_list ap)
+#ifdef SECURE
+#define _FUNCTION_ static int vswscanf_s_l(const wchar_t *file, const wchar_t *format, _locale_t locale, __ms_va_list ap)
+#else  /* SECURE */
+#define _FUNCTION_ static int vswscanf_l(const wchar_t *file, const wchar_t *format, _locale_t locale, __ms_va_list ap)
+#endif /* SECURE */
 #else /* WIDE_SCANF */
-#define _FUNCTION_ int vsscanf(const char *file, const char *format, va_list ap)
+#ifdef SECURE
+#define _FUNCTION_ static int vsscanf_s_l(const char *file, const char *format, _locale_t locale, __ms_va_list ap)
+#else  /* SECURE */
+#define _FUNCTION_ static int vsscanf_l(const char *file, const char *format, _locale_t locale, __ms_va_list ap)
+#endif /* SECURE */
 #endif /* WIDE_SCANF */
 #else /* STRING */
 #ifdef WIDE_SCANF
 #define _GETC_(file) (consumed++, fgetwc(file))
 #define _UNGETC_(nch, file) do { ungetwc(nch, file); consumed--; } while(0)
-#define _FUNCTION_ int vfwscanf(FILE* file, const wchar_t *format, va_list ap)
+#ifdef SECURE
+#define _FUNCTION_ static int vfwscanf_s_l(FILE* file, const wchar_t *format, _locale_t locale, __ms_va_list ap)
+#else  /* SECURE */
+#define _FUNCTION_ static int vfwscanf_l(FILE* file, const wchar_t *format, _locale_t locale, __ms_va_list ap)
+#endif /* SECURE */
 #else /* WIDE_SCANF */
 #define _GETC_(file) (consumed++, fgetc(file))
 #define _UNGETC_(nch, file) do { ungetc(nch, file); consumed--; } while(0)
-#define _FUNCTION_ int vfscanf(FILE* file, const char *format, va_list ap)
+#ifdef SECURE
+#define _FUNCTION_ static int vfscanf_s_l(FILE* file, const char *format, _locale_t locale, __ms_va_list ap)
+#else  /* SECURE */
+#define _FUNCTION_ static int vfscanf_l(FILE* file, const char *format, _locale_t locale, __ms_va_list ap)
+#endif /* SECURE */
 #endif /* WIDE_SCANF */
 #endif /* STRING */
 #endif /* CONSOLE */

 _FUNCTION_ {
+    pthreadlocinfo locinfo;
    int rd = 0, consumed = 0;
    int nch;
    if (!*format) return 0;
@ -94,6 +115,11 @@ _FUNCTION_ {
        return _EOF_RET;
    }

+    if(!locale)
+        locinfo = get_locinfo();
+    else
+        locinfo = locale->locinfo;
+
    while (*format) {
 	/* a whitespace character in the format string causes scanf to read,
 	 * but not store, all consecutive white-space characters in the input
@ -246,8 +272,12 @@ _FUNCTION_ {
            case 'f':
            case 'g':
            case 'G': { /* read a float */
-                    long double cur = 0;
-		    int negative = 0;
+                    //long double cur = 1, expcnt = 10;
+                    ULONGLONG d, hlp;
+                    int exp = 0, negative = 0;
+                    //unsigned fpcontrol;
+                    //BOOL negexp;
+
                    /* skip initial whitespace */
                    while ((nch!=_EOF_) && _ISSPACE_(nch))
                        nch = _GETC_(file);
@ -259,69 +289,112 @@ _FUNCTION_ {
                        if (width==0) break;
                        nch = _GETC_(file);
                    }
+
                    /* get first digit. */
-		    if ('.' != nch) {
+                    if (*locinfo->lconv->decimal_point != nch) {
                        if (!_ISDIGIT_(nch)) break;
-		      cur = (nch - '0');
+                        d = nch - '0';
                        nch = _GETC_(file);
                        if (width>0) width--;
                        /* read until no more digits */
                        while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
-                        cur = cur*10 + (nch - '0');
+                            hlp = d*10 + nch - '0';
+                            nch = _GETC_(file);
+                            if (width>0) width--;
+                            if(d > (ULONGLONG)-1/10 || hlp<d) {
+                                exp++;
+                                break;
+                            }
+                            else
+                                d = hlp;
+                        }
+                        while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
+                            exp++;
                            nch = _GETC_(file);
                            if (width>0) width--;
                        }
                    } else {
-		      cur = 0; /* MaxPayneDemo Fix: .8 -> 0.8 */
+                        d = 0; /* Fix: .8 -> 0.8 */
                    }
+
                    /* handle decimals */
-                    if (width!=0 && nch == '.') {
-                        long double dec = 1;
+                    if (width!=0 && nch == *locinfo->lconv->decimal_point) {
                        nch = _GETC_(file);
                        if (width>0) width--;
+
+                        while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
+                            hlp = d*10 + nch - '0';
+                            nch = _GETC_(file);
+                            if (width>0) width--;
+                            if(d > (ULONGLONG)-1/10 || hlp<d)
+                                break;
+
+                            d = hlp;
+                            exp--;
+                        }
                        while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
-                            dec /= 10;
-                            cur += dec * (nch - '0');
                            nch = _GETC_(file);
                            if (width>0) width--;
                        }
                    }
+
                    /* handle exponent */
                    if (width!=0 && (nch == 'e' || nch == 'E')) {
-			int exponent = 0, negexp = 0;
-			double expcnt, shift;
+                        int sign = 1, e = 0;
+
                        nch = _GETC_(file);
                        if (width>0) width--;
-			/* possible sign on the exponent */
                        if (width!=0 && (nch=='+' || nch=='-')) {
-			    negexp = (nch=='-');
+                            if(nch == '-')
+                                sign = -1;
                            nch = _GETC_(file);
                            if (width>0) width--;
                        }
+
                        /* exponent digits */
                        while (width!=0 && (nch!=_EOF_) && _ISDIGIT_(nch)) {
-			    exponent *= 10;
-			    exponent += (nch - '0');
+                            if(e > INT_MAX/10 || (e = e*10 + nch - '0')<0)
+                                e = INT_MAX;
                            nch = _GETC_(file);
                            if (width>0) width--;
                        }
+                        e *= sign;
+
+                        if(exp<0 && e<0 && e+exp>0) exp = INT_MIN;
+                        else if(exp>0 && e>0 && e+exp<0) exp = INT_MAX;
+                        else exp += e;
+                    }
+
+#ifdef __REACTOS__
+                    /* ReactOS: don't inline float processing (kernel/freeldr don't like that! */
+                    _internal_handle_float(negative, exp, suppress, d, l_prefix || L_prefix, &ap);
+                    st = 1;
+#else
+                    fpcontrol = _control87(0, 0);
+                    _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE
+                            |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);
+
+                    negexp = (exp < 0);
+                    if(negexp)
+                        exp = -exp;
                    /* update 'cur' with this exponent. */
-			expcnt = 10;
-			shift = 1.0;
-			while (exponent!=0) {
-			    if (exponent&1)
-				shift *= expcnt;
-			    exponent/=2;
+                    while(exp) {
+                        if(exp & 1)
+                            cur *= expcnt;
+                        exp /= 2;
                        expcnt = expcnt*expcnt;
                    }
-			cur = (negexp ? cur / shift : cur * shift);
-		    }
+                    cur = (negexp ? d/cur : d*cur);
+
+                    _control87(fpcontrol, 0xffffffff);
+
                    st = 1;
                    if (!suppress) {
-			if (L_prefix) _SET_NUMBER_(long double);
+                        if (L_prefix) _SET_NUMBER_(double);
                        else if (l_prefix) _SET_NUMBER_(double);
                        else _SET_NUMBER_(float);
                    }
+#endif /* __REACTOS__ */
                }
                break;
 		/* According to msdn,
@ -448,11 +521,7 @@ _FUNCTION_ {
 		    int invert = 0; /* Set if we are NOT to find the chars */

            /* Init our bitmap */
-#ifdef _LIBCNT_
-            Mask = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, _BITMAPSIZE_/8);
-#else
            Mask = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, _BITMAPSIZE_/8);
-#endif
            RtlInitializeBitMap(&bitMask, Mask, _BITMAPSIZE_);

 		    /* Read the format */
@ -497,11 +566,7 @@ _FUNCTION_ {
                    }
                    /* terminate */
                    if (!suppress) *sptr = 0;
-#ifdef _LIBCNT_
-                    RtlFreeHeap(RtlGetProcessHeap(), 0, Mask);
-#else
                    HeapFree(GetProcessHeap(), 0, Mask);
-#endif
                }
                break;
            default:
--- a/lib/sdk/crt/string/winesup.c
+++ b/lib/sdk/crt/string/winesup.c
@ -0,0 +1,102 @@
+
+#include "precomp.h"
+#include "winesup.h"
+
+#ifdef _LIBCNT_
+
+static struct lconv _LIBCNT_lconv =
+{
+    ".", // char* decimal_point;
+    ",", // char* thousands_sep;
+    " ", // char* grouping;
+    "$", // char* int_curr_symbol;
+    "$", // char* currency_symbol;
+    ".", // char* mon_decimal_point;
+    "?", // char* mon_thousands_sep;
+    "/", // char* mon_grouping;
+    "+", // char* positive_sign;
+    "-", // char* negative_sign;
+    4, // char int_frac_digits;
+    4, // char frac_digits;
+    4, // char p_cs_precedes;
+    1, // char p_sep_by_space;
+    0, // char n_cs_precedes;
+    1, // char n_sep_by_space;
+    1, // char p_sign_posn;
+    1, // char n_sign_posn;
+};
+
+threadlocinfo _LIBCNT_locinfo =
+{
+    2, // LONG refcount;
+    0, // CP_ACP, // unsigned int lc_codepage;
+    0, // unsigned int lc_collate_cp;
+    {0}, // unsigned long lc_handle[6];
+    {{0}}, // LC_ID lc_id[6];
+
+    // struct {
+    // char *locale;
+    // wchar_t *wlocale;
+    // int *refcount;
+    // int *wrefcount;
+    // } lc_category[6];
+    {{0}},
+
+    0, // int lc_clike;
+    2, // int mb_cur_max;
+    0, // int *lconv_intl_refcount;
+    0, // int *lconv_num_refcount;
+    0, // int *lconv_mon_refcount;
+    &_LIBCNT_lconv, // struct MSVCRT_lconv *lconv;
+    0, // int *ctype1_refcount;
+    0, // unsigned short *ctype1;
+    0, // const unsigned short *pctype;
+    0, // unsigned char *pclmap;
+    0, // unsigned char *pcumap;
+    0, // struct __lc_time_data *lc_time_curr;
+};
+
+#define get_locinfo() (&_LIBCNT_locinfo)
+
+#endif
+
+#define _SET_NUMBER_(type) *va_arg((*ap), type*) = negative ? -cur : cur
+
+void
+__declspec(noinline)
+_internal_handle_float(
+    int negative,
+    int exp,
+    int suppress,
+    ULONGLONG d,
+    int l_or_L_prefix,
+    va_list *ap)
+{
+    long double cur = 1, expcnt = 10;
+    unsigned fpcontrol;
+    BOOL negexp;
+
+    fpcontrol = _control87(0, 0);
+    _control87(_EM_DENORMAL|_EM_INVALID|_EM_ZERODIVIDE
+            |_EM_OVERFLOW|_EM_UNDERFLOW|_EM_INEXACT, 0xffffffff);
+
+    negexp = (exp < 0);
+    if(negexp)
+        exp = -exp;
+    /* update 'cur' with this exponent. */
+    while(exp) {
+        if(exp & 1)
+            cur *= expcnt;
+        exp /= 2;
+        expcnt = expcnt*expcnt;
+    }
+    cur = (negexp ? d/cur : d*cur);
+
+    _control87(fpcontrol, 0xffffffff);
+
+    if (!suppress) {
+        if (l_or_L_prefix) _SET_NUMBER_(double);
+        else _SET_NUMBER_(float);
+    }
+}
+#undef _SET_NUMBER_
--- a/lib/sdk/crt/string/winesup.h
+++ b/lib/sdk/crt/string/winesup.h
@ -0,0 +1,45 @@
+#pragma once
+
+#include <stdio.h>
+#include <conio.h>
+#include <float.h>
+#include <locale.h>
+#include <internal/locale.h>
+
+#undef NtCurrentPeb
+#define NtCurrentPeb() (NtCurrentTeb()->Peb)
+#define GetProcessHeap() (NtCurrentPeb()->ProcessHeap)
+
+#define HeapAlloc(_Heap, _Flags, _Size) RtlAllocateHeap(_Heap, _Flags, _Size)
+#define HeapFree(_Heap, _Flags, _Ptr) RtlFreeHeap(_Heap, _Flags, _Ptr)
+
+#ifdef _LIBCNT_
+static inline unsigned int __control87(unsigned int new, unsigned int mask)
+{
+    return 0;
+}
+#define _control87 __control87
+extern threadlocinfo _LIBCNT_locinfo;
+#define get_locinfo() (&_LIBCNT_locinfo)
+#else
+#define get_locinfo() ((pthreadlocinfo)get_locinfo())
+#endif
+
+void
+__declspec(noinline)
+_internal_handle_float(
+    int negative,
+    int exp,
+    int suppress,
+    ULONGLONG d,
+    int l_or_L_prefix,
+    va_list *ap);
+
+//#include <debug.h>
+
+#define __WINE_DEBUG_H
+#undef WINE_DEFAULT_DEBUG_CHANNEL
+#define WINE_DEFAULT_DEBUG_CHANNEL(_Ch)
+#undef TRACE
+#define TRACE(...) /* DPRINT(__VA_ARGS__) */
+#define debugstr_a(format) format
--- a/media/doc/3rd
+++ b/media/doc/3rd
@ -10,6 +10,14 @@ Title: DejaVu Fonts
 Used Version: 2.34
 Website: http://dejavu.sourceforge.net

+Title: Ubuntu Fonts
+Used Version: 0.80
+Website: http://font.ubuntu.com
+
+Title: Open Sans Fonts
+Used Version: 1.10
+Website: http://www.google.com/fonts/specimen/Open+Sans
+
 Title: DXTN OpenGL Compression Libs
 Used Version: 1.1
 Website: http://www.geocities.com/dborca/opengl/tc.html
--- a/media/fonts/CMakeLists.txt
+++ b/media/fonts/CMakeLists.txt
@ -47,9 +47,35 @@ list(APPEND FONT_FILES
    LiberationSerif-Italic.ttf
    LiberationSerif-Regular.ttf
    Marlett.ttf
+    OpenSans-Bold.ttf
+    OpenSans-BoldItalic.ttf
+    OpenSans-CondBold.ttf
+    OpenSans-CondLight.ttf
+    OpenSans-CondLightItalic.ttf
+    OpenSans-ExtraBold.ttf
+    OpenSans-ExtraBoldItalic.ttf
+    OpenSans-Italic.ttf
+    OpenSans-Light.ttf
+    OpenSans-LightItalic.ttf
+    OpenSans-Regular.ttf
+    OpenSans-Semibold.ttf
+    OpenSans-SemiboldItalic.ttf
    symbol.ttf
    tahoma.ttf
    tahomabd.ttf
+    Ubuntu-B.ttf
+    Ubuntu-BI.ttf
+    Ubuntu-C.ttf
+    Ubuntu-L.ttf
+    Ubuntu-LI.ttf
+    Ubuntu-M.ttf
+    Ubuntu-MI.ttf
+    UbuntuMono-B.ttf
+    UbuntuMono-BI.ttf
+    UbuntuMono-R.ttf
+    UbuntuMono-RI.ttf
+    Ubuntu-R.ttf
+    Ubuntu-RI.ttf
    UniVGA16.ttf
 )

--- a/media/fonts/OpenSans-Bold.ttf
+++ b/media/fonts/OpenSans-Bold.ttf
--- a/media/fonts/OpenSans-BoldItalic.ttf
+++ b/media/fonts/OpenSans-BoldItalic.ttf
--- a/media/fonts/OpenSans-CondBold.ttf
+++ b/media/fonts/OpenSans-CondBold.ttf
--- a/media/fonts/OpenSans-CondLight.ttf
+++ b/media/fonts/OpenSans-CondLight.ttf
--- a/media/fonts/OpenSans-CondLightItalic.ttf
+++ b/media/fonts/OpenSans-CondLightItalic.ttf
--- a/media/fonts/OpenSans-ExtraBold.ttf
+++ b/media/fonts/OpenSans-ExtraBold.ttf
--- a/media/fonts/OpenSans-ExtraBoldItalic.ttf
+++ b/media/fonts/OpenSans-ExtraBoldItalic.ttf
--- a/media/fonts/OpenSans-Italic.ttf
+++ b/media/fonts/OpenSans-Italic.ttf
--- a/media/fonts/OpenSans-Light.ttf
+++ b/media/fonts/OpenSans-Light.ttf
--- a/media/fonts/OpenSans-LightItalic.ttf
+++ b/media/fonts/OpenSans-LightItalic.ttf
--- a/media/fonts/OpenSans-Regular.ttf
+++ b/media/fonts/OpenSans-Regular.ttf
--- a/media/fonts/OpenSans-Semibold.ttf
+++ b/media/fonts/OpenSans-Semibold.ttf
--- a/media/fonts/OpenSans-SemiboldItalic.ttf
+++ b/media/fonts/OpenSans-SemiboldItalic.ttf
--- a/media/fonts/Ubuntu-B.ttf
+++ b/media/fonts/Ubuntu-B.ttf
--- a/media/fonts/Ubuntu-BI.ttf
+++ b/media/fonts/Ubuntu-BI.ttf
--- a/media/fonts/Ubuntu-C.ttf
+++ b/media/fonts/Ubuntu-C.ttf
--- a/media/fonts/Ubuntu-L.ttf
+++ b/media/fonts/Ubuntu-L.ttf
--- a/media/fonts/Ubuntu-LI.ttf
+++ b/media/fonts/Ubuntu-LI.ttf
--- a/media/fonts/Ubuntu-M.ttf
+++ b/media/fonts/Ubuntu-M.ttf
--- a/media/fonts/Ubuntu-MI.ttf
+++ b/media/fonts/Ubuntu-MI.ttf
--- a/media/fonts/Ubuntu-R.ttf
+++ b/media/fonts/Ubuntu-R.ttf
--- a/media/fonts/Ubuntu-RI.ttf
+++ b/media/fonts/Ubuntu-RI.ttf
--- a/media/fonts/UbuntuMono-B.ttf
+++ b/media/fonts/UbuntuMono-B.ttf
--- a/media/fonts/UbuntuMono-BI.ttf
+++ b/media/fonts/UbuntuMono-BI.ttf
--- a/media/fonts/UbuntuMono-R.ttf
+++ b/media/fonts/UbuntuMono-R.ttf
--- a/Show more
+++ b/Show more