Sync with trunk r63192.
authorHermès Bélusca-Maïto <hermes.belusca-maito@reactos.org>
Thu, 8 May 2014 14:40:52 +0000 (14:40 +0000)
committerHermès Bélusca-Maïto <hermes.belusca-maito@reactos.org>
Thu, 8 May 2014 14:40:52 +0000 (14:40 +0000)
svn path=/branches/condrv_restructure/; revision=63193

179 files changed:
1  2 
base/applications/cmdutils/comp/comp.c
base/applications/mscutils/devmgmt/mainwnd.c
base/applications/network/ftp/cmds.c
base/applications/network/ipconfig/ipconfig.c
base/applications/network/telnet/src/ansiprsr.cpp
base/setup/usetup/partlist.c
base/setup/usetup/partlist.h
base/shell/cmd/cmd.c
boot/bootdata/hivedef.inf
cmake/gcc.cmake
cmake/msvc.cmake
configure.sh
dll/directx/wine/msdmo/dmoreg.c
dll/ntdll/CMakeLists.txt
dll/ntdll/csr/capture.c
dll/ntdll/def/ntdll.spec
dll/ntdll/ldr/ldrapi.c
dll/win32/beepmidi/beepmidi.c
dll/win32/kernel32/client/proc.c
dll/win32/kernel32/client/vdm.c
dll/win32/kernel32/include/vdm.h
dll/win32/kernel32/k32.h
dll/win32/kernel32/wine/actctx.c
dll/win32/msafd/msafd.h
dll/win32/netapi32/nbcmdqueue.h
dll/win32/netapi32/nbnamecache.h
dll/win32/netapi32/nbt.c
dll/win32/netapi32/netapi32.c
dll/win32/netapi32/netapi32.h
dll/win32/netapi32/netapi32.spec
dll/win32/netapi32/netbios.c
dll/win32/netapi32/netbios.h
dll/win32/netapi32/wksta.c
dll/win32/shlwapi/path.c
dll/win32/uxtheme/ncscrollbar.c
dll/win32/ws2help/context.c
drivers/base/bootvid/i386/vga.c
drivers/base/nmidebug/nmidebug.c
drivers/filesystems/npfs/npfs.h
drivers/input/i8042prt/i8042prt.c
drivers/input/i8042prt/mouse.c
drivers/input/i8042prt/pnp.c
hal/halx86/apic/apic.c
hal/halx86/apic/apic.h
hal/halx86/apic/rtctimer.c
hal/halx86/up/pic.c
include/ddk/isvbop.h
include/ddk/isvbop.inc
include/ddk/nt_vdd.h
include/ddk/vddsvc.h
include/ndk/rtlfuncs.h
include/reactos/kdros.h
include/reactos/libs/fast486/fast486.h
include/reactos/libs/pseh/pseh3.h
include/reactos/subsys/win/conmsg.h
include/reactos/subsys/win/vdm.h
include/reactos/wine/port.h
lib/CMakeLists.txt
lib/fast486/CMakeLists.txt
lib/fast486/COPYING
lib/fast486/common.c
lib/fast486/common.h
lib/fast486/common.inl
lib/fast486/extraops.c
lib/fast486/extraops.h
lib/fast486/fast486.c
lib/fast486/fpu.c
lib/fast486/fpu.h
lib/fast486/opcodes.c
lib/fast486/opcodes.h
lib/fast486/opgroups.c
lib/fast486/opgroups.h
lib/rtl/actctx.c
lib/sdk/crt/include/internal/tls.h
lib/sdk/crt/signal/xcptinfo.c
media/doc/README.WINE
ntoskrnl/include/internal/i386/trap_x.h
ntoskrnl/mm/section.c
subsystems/CMakeLists.txt
subsystems/ntvdm/CMakeLists.txt
subsystems/ntvdm/bios/bios.c
subsystems/ntvdm/bios/bios.h
subsystems/ntvdm/bios/bios32/bios32.c
subsystems/ntvdm/bios/bios32/bios32.h
subsystems/ntvdm/bios/bios32/bios32p.h
subsystems/ntvdm/bios/bios32/kbdbios32.c
subsystems/ntvdm/bios/bios32/kbdbios32.h
subsystems/ntvdm/bios/bios32/vidbios32.c
subsystems/ntvdm/bios/bios32/vidbios32.h
subsystems/ntvdm/bios/kbdbios.c
subsystems/ntvdm/bios/kbdbios.h
subsystems/ntvdm/bios/rom.c
subsystems/ntvdm/bios/rom.h
subsystems/ntvdm/bios/vidbios.c
subsystems/ntvdm/bios/vidbios.h
subsystems/ntvdm/bop.c
subsystems/ntvdm/bop.h
subsystems/ntvdm/callback.c
subsystems/ntvdm/callback.h
subsystems/ntvdm/clock.c
subsystems/ntvdm/clock.h
subsystems/ntvdm/dos/dem.c
subsystems/ntvdm/dos/dem.h
subsystems/ntvdm/dos/dos32krnl/bios.c
subsystems/ntvdm/dos/dos32krnl/dos.c
subsystems/ntvdm/dos/dos32krnl/dos.h
subsystems/ntvdm/emulator.c
subsystems/ntvdm/emulator.h
subsystems/ntvdm/hardware/cmos.c
subsystems/ntvdm/hardware/cmos.h
subsystems/ntvdm/hardware/pic.c
subsystems/ntvdm/hardware/pic.h
subsystems/ntvdm/hardware/ps2.c
subsystems/ntvdm/hardware/ps2.h
subsystems/ntvdm/hardware/speaker.c
subsystems/ntvdm/hardware/speaker.h
subsystems/ntvdm/hardware/timer.c
subsystems/ntvdm/hardware/timer.h
subsystems/ntvdm/hardware/vga.c
subsystems/ntvdm/hardware/vga.h
subsystems/ntvdm/int32.c
subsystems/ntvdm/int32.h
subsystems/ntvdm/io.c
subsystems/ntvdm/io.h
subsystems/ntvdm/lang/cs-CZ.rc
subsystems/ntvdm/lang/de-DE.rc
subsystems/ntvdm/lang/en-US.rc
subsystems/ntvdm/lang/es-ES.rc
subsystems/ntvdm/lang/fr-FR.rc
subsystems/ntvdm/lang/it-IT.rc
subsystems/ntvdm/lang/pl-PL.rc
subsystems/ntvdm/ntvdm.c
subsystems/ntvdm/ntvdm.h
subsystems/ntvdm/ntvdm.rc
subsystems/ntvdm/ntvdm.spec
subsystems/ntvdm/registers.c
subsystems/ntvdm/registers.h
subsystems/ntvdm/res/ntvdm.ico
subsystems/ntvdm/resource.h
subsystems/ntvdm/utils.c
subsystems/ntvdm/utils.h
subsystems/ntvdm/vddsup.c
subsystems/ntvdm/vddsup.h
subsystems/win/basesrv/basesrv.h
subsystems/win/basesrv/init.c
subsystems/win/basesrv/proc.c
subsystems/win/basesrv/vdm.c
subsystems/win/basesrv/vdm.h
subsystems/win32/csrsrv/procsup.c
win32ss/drivers/font/bmfd/glyph.c
win32ss/gdi/eng/pdevobj.c
win32ss/gdi/eng/surface.h
win32ss/gdi/eng/xlateobj.h
win32ss/gdi/gdi32/gdi32.spec
win32ss/gdi/ntgdi/brush.h
win32ss/gdi/ntgdi/coord.h
win32ss/gdi/ntgdi/dc.h
win32ss/gdi/ntgdi/freetype.c
win32ss/gdi/ntgdi/palette.h
win32ss/gdi/ntgdi/rect.h
win32ss/gdi/ntgdi/text.h
win32ss/include/ntuser.h
win32ss/user/ntuser/accelerator.c
win32ss/user/ntuser/clipboard.c
win32ss/user/ntuser/menu.c
win32ss/user/ntuser/menu.h
win32ss/user/ntuser/ntstubs.c
win32ss/user/ntuser/userfuncs.h
win32ss/user/ntuser/window.c
win32ss/user/user32/CMakeLists.txt
win32ss/user/user32/controls/listbox.c
win32ss/user/user32/misc/stubs.c
win32ss/user/user32/user32.spec
win32ss/user/user32/windows/clipboard.c
win32ss/user/user32/windows/mdi.c
win32ss/user/user32/windows/menu.c
win32ss/user/user32/windows/window.c
win32ss/w32ksvc.db
win32ss/w32ksvc.h

Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc cmake/gcc.cmake
Simple merge
Simple merge
diff --cc configure.sh
Simple merge
index 48968b3,0000000..84c1ed9
mode 100644,000000..100644
--- /dev/null
@@@ -1,830 -1,0 +1,830 @@@
-             Names[count] = HeapAlloc(GetProcessHeap(), 0, strlenW(szValue) + 1);
 +/*
 + * Copyright (C) 2003 Michael Günnewig
 + * Copyright (C) 2003 CodeWeavers Inc. (Ulrich Czekalla)
 + *
 + * This library is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * This library is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with this library; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 + */
 +
 +#include "precomp.h"
 +
 +#include <winuser.h>
 +#include <winreg.h>
 +#include <wine/unicode.h>
 +#include <dmo.h>
 +
 +#define MSDMO_MAJOR_VERSION 6
 +
 +static const WCHAR szDMORootKey[] = 
 +{
 +    'D','i','r','e','c','t','S','h','o','w','\\',
 +    'M','e','d','i','a','O','b','j','e','c','t','s',0
 +}; 
 +
 +static const WCHAR szDMOInputType[] =
 +{
 +    'I','n','p','u','t','T','y','p','e','s',0
 +};
 +
 +static const WCHAR szDMOOutputType[] =
 +{
 +    'O','u','t','p','u','t','T','y','p','e','s',0
 +};
 +
 +static const WCHAR szDMOKeyed[] =
 +{
 +    'K','e','y','e','d',0
 +};
 +
 +static const WCHAR szDMOCategories[] =
 +{
 +    'C','a','t','e','g','o','r','i','e','s',0
 +};
 +
 +static const WCHAR szGUIDFmt[] =
 +{
 +    '%','0','8','X','-','%','0','4','X','-','%','0','4','X','-','%','0',
 +    '2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2',
 +    'X','%','0','2','X','%','0','2','X','%','0','2','X',0
 +};
 +
 +static const WCHAR szCat3Fmt[] =
 +{
 +    '%','s','\\','%','s','\\','%','s',0
 +};
 +
 +static const WCHAR szCat2Fmt[] =
 +{
 +    '%','s','\\','%','s',0
 +};
 +
 +static const WCHAR szToGuidFmt[] =
 +{
 +    '{','%','s','}',0
 +};
 +
 +
 +typedef struct
 +{
 +    IEnumDMO                    IEnumDMO_iface;
 +    LONG                      ref;
 +    DWORD                     index;
 +    const GUID*                 guidCategory;
 +    DWORD                       dwFlags;
 +    DWORD                       cInTypes;
 +    DMO_PARTIAL_MEDIATYPE       *pInTypes;
 +    DWORD                       cOutTypes;
 +    DMO_PARTIAL_MEDIATYPE       *pOutTypes;
 +    HKEY                        hkey;
 +} IEnumDMOImpl;
 +
 +static inline IEnumDMOImpl *impl_from_IEnumDMO(IEnumDMO *iface)
 +{
 +    return CONTAINING_RECORD(iface, IEnumDMOImpl, IEnumDMO_iface);
 +}
 +
 +static HRESULT read_types(HKEY root, LPCWSTR key, ULONG *supplied, ULONG requested, DMO_PARTIAL_MEDIATYPE* types);
 +
 +static const IEnumDMOVtbl edmovt;
 +
 +static LPWSTR GUIDToString(LPWSTR lpwstr, REFGUID lpcguid)
 +{
 +    wsprintfW(lpwstr, szGUIDFmt, lpcguid->Data1, lpcguid->Data2,
 +        lpcguid->Data3, lpcguid->Data4[0], lpcguid->Data4[1],
 +        lpcguid->Data4[2], lpcguid->Data4[3], lpcguid->Data4[4],
 +        lpcguid->Data4[5], lpcguid->Data4[6], lpcguid->Data4[7]);
 +
 +    return lpwstr;
 +}
 +
 +static BOOL IsMediaTypeEqual(const DMO_PARTIAL_MEDIATYPE* mt1, const DMO_PARTIAL_MEDIATYPE* mt2)
 +{
 +
 +    return (IsEqualCLSID(&mt1->type, &mt2->type) ||
 +            IsEqualCLSID(&mt2->type, &GUID_NULL) ||
 +            IsEqualCLSID(&mt1->type, &GUID_NULL)) &&
 +            (IsEqualCLSID(&mt1->subtype, &mt2->subtype) ||
 +            IsEqualCLSID(&mt2->subtype, &GUID_NULL) ||
 +            IsEqualCLSID(&mt1->subtype, &GUID_NULL));
 +}
 +
 +static HRESULT write_types(HKEY hkey, LPCWSTR name, const DMO_PARTIAL_MEDIATYPE* types, DWORD count)
 +{
 +    HRESULT hres = S_OK;
 +    if (MSDMO_MAJOR_VERSION > 5)
 +    {
 +        hres = RegSetValueExW(hkey, name, 0, REG_BINARY, (const BYTE*) types,
 +                          count* sizeof(DMO_PARTIAL_MEDIATYPE));
 +    }
 +    else
 +    {
 +        HKEY skey1,skey2,skey3;
 +        DWORD index = 0;
 +        WCHAR szGuidKey[64];
 +
 +        hres = RegCreateKeyExW(hkey, name, 0, NULL, REG_OPTION_NON_VOLATILE,
 +                               KEY_WRITE, NULL, &skey1, NULL);
 +        while (index < count)
 +        {
 +            GUIDToString(szGuidKey,&types[index].type);
 +            hres = RegCreateKeyExW(skey1, szGuidKey, 0, NULL,
 +                        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey2, NULL);
 +            GUIDToString(szGuidKey,&types[index].subtype);
 +            hres = RegCreateKeyExW(skey2, szGuidKey, 0, NULL,
 +                        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey3, NULL);
 +            RegCloseKey(skey3);
 +            RegCloseKey(skey2);
 +            index ++;
 +        }
 +        RegCloseKey(skey1);
 +    }
 +
 +    return hres;
 +}
 +
 +/***************************************************************
 + * DMORegister (MSDMO.@)
 + *
 + * Register a DirectX Media Object.
 + */
 +HRESULT WINAPI DMORegister(
 +   LPCWSTR szName,
 +   REFCLSID clsidDMO,
 +   REFGUID guidCategory,
 +   DWORD dwFlags,
 +   DWORD cInTypes,
 +   const DMO_PARTIAL_MEDIATYPE *pInTypes,
 +   DWORD cOutTypes,
 +   const DMO_PARTIAL_MEDIATYPE *pOutTypes
 +)
 +{
 +    WCHAR szguid[64];
 +    HRESULT hres;
 +    HKEY hrkey = 0;
 +    HKEY hkey = 0;
 +    HKEY hckey = 0;
 +    HKEY hclskey = 0;
 +
 +    TRACE("%s\n", debugstr_w(szName));
 +
 +    hres = RegCreateKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, NULL,
 +        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hrkey, NULL);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +    /* Create clsidDMO key under MediaObjects */ 
 +    hres = RegCreateKeyExW(hrkey, GUIDToString(szguid, clsidDMO), 0, NULL,
 +        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +    /* Set default Name value */
 +    hres = RegSetValueExW(hkey, NULL, 0, REG_SZ, (const BYTE*) szName, 
 +        (strlenW(szName) + 1) * sizeof(WCHAR));
 +
 +    /* Set InputTypes */
 +    hres = write_types(hkey, szDMOInputType, pInTypes, cInTypes);
 +
 +    /* Set OutputTypes */
 +    hres = write_types(hkey, szDMOOutputType, pOutTypes, cOutTypes);
 +
 +    if (dwFlags & DMO_REGISTERF_IS_KEYED)
 +    {
 +        /* Create Keyed key */ 
 +        hres = RegCreateKeyExW(hkey, szDMOKeyed, 0, NULL,
 +            REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
 +        if (ERROR_SUCCESS != hres)
 +            goto lend;
 +        RegCloseKey(hckey);
 +    }
 +
 +    /* Register the category */
 +    hres = RegCreateKeyExW(hrkey, szDMOCategories, 0, NULL,
 +            REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +    RegCloseKey(hkey);
 +
 +    hres = RegCreateKeyExW(hckey, GUIDToString(szguid, guidCategory), 0, NULL,
 +            REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +    hres = RegCreateKeyExW(hkey, GUIDToString(szguid, clsidDMO), 0, NULL,
 +        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hclskey, NULL);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +lend:
 +    if (hkey)
 +        RegCloseKey(hkey);
 +    if (hckey)
 +        RegCloseKey(hckey);
 +    if (hclskey)
 +        RegCloseKey(hclskey);
 +    if (hrkey)
 +        RegCloseKey(hrkey);
 +
 +    TRACE(" hresult=0x%08x\n", hres);
 +    return hres;
 +}
 +
 +
 +/***************************************************************
 + * DMOUnregister (MSDMO.@)
 + *
 + * Unregister a DirectX Media Object.
 + */
 +HRESULT WINAPI DMOUnregister(REFCLSID clsidDMO, REFGUID guidCategory)
 +{
 +    HRESULT hres;
 +    WCHAR szguid[64];
 +    HKEY hrkey = 0;
 +    HKEY hckey = 0;
 +
 +    GUIDToString(szguid, clsidDMO);
 +
 +    TRACE("%s %p\n", debugstr_w(szguid), guidCategory);
 +
 +    hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_WRITE, &hrkey);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +    hres = RegDeleteKeyW(hrkey, szguid);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +    hres = RegOpenKeyExW(hrkey, szDMOCategories, 0, KEY_WRITE, &hckey);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +    hres = RegDeleteKeyW(hckey, szguid);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +lend:
 +    if (hckey)
 +        RegCloseKey(hckey);
 +    if (hrkey)
 +        RegCloseKey(hrkey);
 +
 +    return hres;
 +}
 +
 +
 +/***************************************************************
 + * DMOGetName (MSDMO.@)
 + *
 + * Get DMP Name from the registry
 + */
 +HRESULT WINAPI DMOGetName(REFCLSID clsidDMO, WCHAR szName[])
 +{
 +    WCHAR szguid[64];
 +    HRESULT hres;
 +    HKEY hrkey = 0;
 +    HKEY hkey = 0;
 +    static const INT max_name_len = 80;
 +    DWORD count;
 +
 +    TRACE("%s\n", debugstr_guid(clsidDMO));
 +
 +    hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 
 +        0, KEY_READ, &hrkey);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +    hres = RegOpenKeyExW(hrkey, GUIDToString(szguid, clsidDMO),
 +        0, KEY_READ, &hkey);
 +    if (ERROR_SUCCESS != hres)
 +        goto lend;
 +
 +    count = max_name_len * sizeof(WCHAR);
 +    hres = RegQueryValueExW(hkey, NULL, NULL, NULL, 
 +        (LPBYTE) szName, &count); 
 +
 +    TRACE(" szName=%s\n", debugstr_w(szName));
 +lend:
 +    if (hkey)
 +        RegCloseKey(hrkey);
 +    if (hkey)
 +        RegCloseKey(hkey);
 +
 +    return hres;
 +}
 +
 +
 +/**************************************************************************
 +*   IEnumDMOImpl_Destructor
 +*/
 +static BOOL IEnumDMOImpl_Destructor(IEnumDMOImpl* This)
 +{
 +    TRACE("%p\n", This);
 +
 +    if (This->hkey)
 +        RegCloseKey(This->hkey);
 +
 +    HeapFree(GetProcessHeap(), 0, This->pInTypes);
 +    HeapFree(GetProcessHeap(), 0, This->pOutTypes);
 +
 +    return TRUE;
 +}
 +
 +
 +/**************************************************************************
 + *  IEnumDMO_Constructor
 + */
 +static IEnumDMO * IEnumDMO_Constructor(
 +    REFGUID guidCategory,
 +    DWORD dwFlags,
 +    DWORD cInTypes,
 +    const DMO_PARTIAL_MEDIATYPE *pInTypes,
 +    DWORD cOutTypes,
 +    const DMO_PARTIAL_MEDIATYPE *pOutTypes)
 +{
 +    UINT size;
 +    IEnumDMOImpl* lpedmo;
 +    BOOL ret = FALSE;
 +
 +    lpedmo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumDMOImpl));
 +
 +    if (lpedmo)
 +    {
 +        lpedmo->ref = 1;
 +        lpedmo->IEnumDMO_iface.lpVtbl = &edmovt;
 +        lpedmo->index = -1;
 +      lpedmo->guidCategory = guidCategory;
 +      lpedmo->dwFlags = dwFlags;
 +
 +        if (cInTypes > 0)
 +        {
 +            size = cInTypes * sizeof(DMO_PARTIAL_MEDIATYPE);
 +            lpedmo->pInTypes = HeapAlloc(GetProcessHeap(), 0, size);
 +            if (!lpedmo->pInTypes)
 +                goto lerr;
 +            memcpy(lpedmo->pInTypes, pInTypes, size);
 +            lpedmo->cInTypes = cInTypes;
 +        }
 +
 +        if (cOutTypes > 0)
 +        {
 +            size = cOutTypes * sizeof(DMO_PARTIAL_MEDIATYPE);
 +            lpedmo->pOutTypes = HeapAlloc(GetProcessHeap(), 0, size);
 +            if (!lpedmo->pOutTypes)
 +                goto lerr;
 +            memcpy(lpedmo->pOutTypes, pOutTypes, size);
 +            lpedmo->cOutTypes = cOutTypes;
 +        }
 +
 +        /* If not filtering by category enum from media objects root */
 +        if (IsEqualGUID(guidCategory, &GUID_NULL))
 +        {
 +            if (ERROR_SUCCESS == RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 
 +                0, KEY_READ, &lpedmo->hkey))
 +                ret = TRUE;
 +        }
 +        else
 +        {
 +            WCHAR szguid[64];
 +            WCHAR szKey[MAX_PATH];
 +
 +            wsprintfW(szKey, szCat3Fmt, szDMORootKey, szDMOCategories, 
 +                GUIDToString(szguid, guidCategory));
 +            if (ERROR_SUCCESS == RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 
 +                0, KEY_READ, &lpedmo->hkey))
 +                ret = TRUE;
 +        }
 +
 +lerr:
 +        if(!ret)
 +        {
 +            IEnumDMOImpl_Destructor(lpedmo);
 +            HeapFree(GetProcessHeap(),0,lpedmo);
 +            lpedmo = NULL;
 +        }
 +    }
 +
 +    TRACE("returning %p\n", lpedmo);
 +
 +    return (IEnumDMO*)lpedmo;
 +}
 +
 +
 +/******************************************************************************
 + * IEnumDMO_fnAddRef
 + */
 +static ULONG WINAPI IEnumDMO_fnAddRef(IEnumDMO * iface)
 +{
 +    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 +    return InterlockedIncrement(&This->ref);
 +}
 +
 +
 +/**************************************************************************
 + *  EnumDMO_QueryInterface
 + */
 +static HRESULT WINAPI IEnumDMO_fnQueryInterface(
 +    IEnumDMO* iface,
 +    REFIID riid,
 +    LPVOID *ppvObj)
 +{
 +    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 +
 +    *ppvObj = NULL;
 +
 +    if(IsEqualIID(riid, &IID_IUnknown))
 +        *ppvObj = This;
 +    else if(IsEqualIID(riid, &IID_IEnumDMO))
 +        *ppvObj = This;
 +
 +    if(*ppvObj)
 +    {
 +        IEnumDMO_fnAddRef(*ppvObj);
 +        return S_OK;
 +    }
 +
 +    return E_NOINTERFACE;
 +}
 +
 +
 +/******************************************************************************
 + * IEnumDMO_fnRelease
 + */
 +static ULONG WINAPI IEnumDMO_fnRelease(IEnumDMO * iface)
 +{
 +    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 +    ULONG refCount = InterlockedDecrement(&This->ref);
 +
 +    if (!refCount)
 +    {
 +        IEnumDMOImpl_Destructor(This);
 +        HeapFree(GetProcessHeap(),0,This);
 +    }
 +    return refCount;
 +}
 +
 +
 +/******************************************************************************
 + * IEnumDMO_fnNext
 + */
 +static HRESULT WINAPI IEnumDMO_fnNext(
 +    IEnumDMO * iface, 
 +    DWORD cItemsToFetch,
 +    CLSID * pCLSID,
 +    WCHAR ** Names,
 +    DWORD * pcItemsFetched)
 +{
 +    FILETIME ft;
 +    HKEY hkey;
 +    WCHAR szNextKey[MAX_PATH];
 +    WCHAR szGuidKey[64];
 +    WCHAR szKey[MAX_PATH];
 +    WCHAR szValue[MAX_PATH];
 +    DWORD len;
 +    UINT count = 0;
 +    HRESULT hres = S_OK;
 +
 +    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 +
 +    TRACE("--> (%p) %d %p %p %p\n", iface, cItemsToFetch, pCLSID, Names, pcItemsFetched);
 +
 +    if (!pCLSID || !Names || !pcItemsFetched)
 +        return E_POINTER;
 +
 +    while (count < cItemsToFetch)
 +    {
 +        This->index++;
 +
 +        len = MAX_PATH;
 +        hres = RegEnumKeyExW(This->hkey, This->index, szNextKey, &len, NULL, NULL, NULL, &ft);
 +        if (hres != ERROR_SUCCESS)
 +            break;
 +
 +        TRACE("found %s\n", debugstr_w(szNextKey));
 +
 +        if (!(This->dwFlags & DMO_ENUMF_INCLUDE_KEYED))
 +        {
 +            wsprintfW(szKey, szCat3Fmt, szDMORootKey, szNextKey, szDMOKeyed);
 +            hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
 +            if (ERROR_SUCCESS == hres)
 +            {
 +                RegCloseKey(hkey);
 +                /* Skip Keyed entries */
 +                continue;
 +            }
 +        }
 +
 +        wsprintfW(szKey, szCat2Fmt, szDMORootKey, szNextKey);
 +        hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
 +
 +        if (This->pInTypes)
 +        {
 +            UINT i, j;
 +            DWORD cInTypes;
 +            DMO_PARTIAL_MEDIATYPE* pInTypes;
 +
 +            hres = read_types(hkey, szDMOInputType, &cInTypes,
 +                    sizeof(szValue)/sizeof(DMO_PARTIAL_MEDIATYPE),
 +                    (DMO_PARTIAL_MEDIATYPE*)szValue);
 +
 +            if (ERROR_SUCCESS != hres)
 +            {
 +                RegCloseKey(hkey);
 +                continue;
 +            }
 +
 +          pInTypes = (DMO_PARTIAL_MEDIATYPE*) szValue;
 +
 +            for (i = 0; i < This->cInTypes; i++)
 +            {
 +                for (j = 0; j < cInTypes; j++) 
 +                {
 +                    if (IsMediaTypeEqual(&pInTypes[j], &This->pInTypes[i]))
 +                      break;
 +                }
 +
 +              if (j >= cInTypes)
 +                    break;
 +            }
 +
 +            if (i < This->cInTypes)
 +            {
 +                RegCloseKey(hkey);
 +                continue;
 +            }
 +        }
 +
 +        if (This->pOutTypes)
 +        {
 +            UINT i, j;
 +            DWORD cOutTypes;
 +            DMO_PARTIAL_MEDIATYPE* pOutTypes;
 +
 +            hres = read_types(hkey, szDMOOutputType, &cOutTypes,
 +                    sizeof(szValue)/sizeof(DMO_PARTIAL_MEDIATYPE),
 +                    (DMO_PARTIAL_MEDIATYPE*)szValue);
 +
 +          if (ERROR_SUCCESS != hres)
 +            {
 +                RegCloseKey(hkey);
 +                continue;
 +            }
 +
 +          pOutTypes = (DMO_PARTIAL_MEDIATYPE*) szValue;
 +
 +            for (i = 0; i < This->cOutTypes; i++)
 +            {
 +                for (j = 0; j < cOutTypes; j++) 
 +                {
 +                    if (IsMediaTypeEqual(&pOutTypes[j], &This->pOutTypes[i]))
 +                      break;
 +                }
 +
 +              if (j >= cOutTypes)
 +                    break;
 +            }
 +
 +            if (i < This->cOutTypes)
 +            {
 +                RegCloseKey(hkey);
 +                continue;
 +            }
 +        }
 +
 +      /* Media object wasn't filtered so add it to return list */
 +        Names[count] = NULL;
 +      len = MAX_PATH * sizeof(WCHAR);
 +        hres = RegQueryValueExW(hkey, NULL, NULL, NULL, (LPBYTE) szValue, &len); 
 +        if (ERROR_SUCCESS == hres)
 +      {
-                 strcmpW(Names[count], szValue);
++            Names[count] = HeapAlloc(GetProcessHeap(), 0, (strlenW(szValue) + 1) * sizeof(WCHAR));
 +          if (Names[count])
++                strcpyW(Names[count], szValue);
 +      }
 +        wsprintfW(szGuidKey,szToGuidFmt,szNextKey);
 +        CLSIDFromString(szGuidKey, &pCLSID[count]);
 +
 +        TRACE("found match %s %s\n", debugstr_w(szValue), debugstr_w(szNextKey));
 +        RegCloseKey(hkey);
 +      count++;
 +    }
 +
 +    *pcItemsFetched = count;
 +    if (*pcItemsFetched < cItemsToFetch)
 +        hres = S_FALSE;
 +
 +    TRACE("<-- %i found\n",count);
 +    return hres;
 +}
 + 
 +
 +/******************************************************************************
 + * IEnumDMO_fnSkip
 + */
 +static HRESULT WINAPI IEnumDMO_fnSkip(IEnumDMO * iface, DWORD cItemsToSkip)
 +{
 +    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 +
 +    This->index += cItemsToSkip;
 +
 +    return S_OK;
 +}
 +
 +
 +/******************************************************************************
 + * IEnumDMO_fnReset
 + */
 +static HRESULT WINAPI IEnumDMO_fnReset(IEnumDMO * iface)
 +{
 +    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 +
 +    This->index = -1;
 +
 +    return S_OK;
 +}
 + 
 +
 +/******************************************************************************
 + * IEnumDMO_fnClone
 + */
 +static HRESULT WINAPI IEnumDMO_fnClone(IEnumDMO * iface, IEnumDMO **ppEnum)
 +{
 +    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 +
 +    FIXME("(%p)->() to (%p)->() E_NOTIMPL\n", This, ppEnum);
 +
 +  return E_NOTIMPL;
 +}
 +
 +
 +/***************************************************************
 + * DMOEnum (MSDMO.@)
 + *
 + * Enumerate DirectX Media Objects in the registry.
 + */
 +HRESULT WINAPI DMOEnum(
 +    REFGUID guidCategory,
 +    DWORD dwFlags,
 +    DWORD cInTypes,
 +    const DMO_PARTIAL_MEDIATYPE *pInTypes,
 +    DWORD cOutTypes,
 +    const DMO_PARTIAL_MEDIATYPE *pOutTypes,
 +    IEnumDMO **ppEnum)
 +{
 +    HRESULT hres = E_FAIL;
 +
 +    TRACE("guidCategory=%p dwFlags=0x%08x cInTypes=%d cOutTypes=%d\n",
 +        guidCategory, dwFlags, cInTypes, cOutTypes);
 +
 +    *ppEnum = IEnumDMO_Constructor(guidCategory, dwFlags, cInTypes,
 +        pInTypes, cOutTypes, pOutTypes);
 +    if (*ppEnum)
 +        hres = S_OK;
 +
 +    return hres;
 +}
 +
 +
 +static const IEnumDMOVtbl edmovt =
 +{
 +      IEnumDMO_fnQueryInterface,
 +      IEnumDMO_fnAddRef,
 +      IEnumDMO_fnRelease,
 +      IEnumDMO_fnNext,
 +      IEnumDMO_fnSkip,
 +      IEnumDMO_fnReset,
 +      IEnumDMO_fnClone,
 +};
 +
 +
 +HRESULT read_types(HKEY root, LPCWSTR key, ULONG *supplied, ULONG requested, DMO_PARTIAL_MEDIATYPE* types )
 +{
 +    HRESULT ret = S_OK;
 +    if (MSDMO_MAJOR_VERSION > 5)
 +    {
 +        DWORD len;
 +        len = requested * sizeof(DMO_PARTIAL_MEDIATYPE);
 +        ret = RegQueryValueExW(root, key, NULL, NULL, (LPBYTE) types, &len);
 +        *supplied = len / sizeof(DMO_PARTIAL_MEDIATYPE);
 +    }
 +    else
 +    {
 +        HKEY hkey;
 +        WCHAR szGuidKey[64];
 +
 +        *supplied = 0;
 +        if (ERROR_SUCCESS == RegOpenKeyExW(root, key, 0, KEY_READ, &hkey))
 +        {
 +          int index = 0;
 +          WCHAR szNextKey[MAX_PATH];
 +          DWORD len;
 +          LONG rc = ERROR_SUCCESS;
 +
 +          while (rc == ERROR_SUCCESS)
 +          {
 +            len = MAX_PATH;
 +            rc = RegEnumKeyExW(hkey, index, szNextKey, &len, NULL, NULL, NULL, NULL);
 +            if (rc == ERROR_SUCCESS)
 +            {
 +              HKEY subk;
 +              int sub_index = 0;
 +              LONG rcs = ERROR_SUCCESS;
 +              WCHAR szSubKey[MAX_PATH];
 +
 +              RegOpenKeyExW(hkey, szNextKey, 0, KEY_READ, &subk);
 +              while (rcs == ERROR_SUCCESS)
 +              {
 +                len = MAX_PATH;
 +                rcs = RegEnumKeyExW(subk, sub_index, szSubKey, &len, NULL, NULL, NULL, NULL);
 +                if (rcs == ERROR_SUCCESS)
 +                {
 +                  if (*supplied >= requested)
 +                  {
 +                    /* Bailing */
 +                    ret = S_FALSE;
 +                    rc = ERROR_MORE_DATA;
 +                    rcs = ERROR_MORE_DATA;
 +                    break;
 +                  }
 +
 +                  wsprintfW(szGuidKey,szToGuidFmt,szNextKey);
 +                  CLSIDFromString(szGuidKey, &types[*supplied].type);
 +                  wsprintfW(szGuidKey,szToGuidFmt,szSubKey);
 +                  CLSIDFromString(szGuidKey, &types[*supplied].subtype);
 +                  TRACE("Adding type %s subtype %s at index %i\n",
 +                    debugstr_guid(&types[*supplied].type),
 +                    debugstr_guid(&types[*supplied].subtype),
 +                    *supplied);
 +                  (*supplied)++;
 +                }
 +                sub_index++;
 +              }
 +              index++;
 +            }
 +          }
 +          RegCloseKey(hkey);
 +        }
 +    }
 +    return ret;
 +}
 +
 +/***************************************************************
 + * DMOGetTypes (MSDMO.@)
 + */
 +HRESULT WINAPI DMOGetTypes(REFCLSID clsidDMO,
 +               ULONG ulInputTypesRequested,
 +               ULONG* pulInputTypesSupplied,
 +               DMO_PARTIAL_MEDIATYPE* pInputTypes,
 +               ULONG ulOutputTypesRequested,
 +               ULONG* pulOutputTypesSupplied,
 +               DMO_PARTIAL_MEDIATYPE* pOutputTypes)
 +{
 +  HKEY root,hkey;
 +  HRESULT ret = S_OK;
 +  WCHAR szguid[64];
 +
 +  TRACE ("(%s,%u,%p,%p,%u,%p,%p)\n", debugstr_guid(clsidDMO), ulInputTypesRequested,
 +        pulInputTypesSupplied, pInputTypes, ulOutputTypesRequested, pulOutputTypesSupplied,
 +        pOutputTypes);
 +
 +  if (ERROR_SUCCESS != RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0,
 +                                     KEY_READ, &root))
 +    return E_FAIL;
 +
 +  if (ERROR_SUCCESS != RegOpenKeyExW(root,GUIDToString(szguid,clsidDMO) , 0,
 +                                     KEY_READ, &hkey))
 +  {
 +    RegCloseKey(root);
 +    return E_FAIL;
 +  }
 +
 +  if (ulInputTypesRequested > 0)
 +  {
 +    ret = read_types(hkey, szDMOInputType, pulInputTypesSupplied, ulInputTypesRequested, pInputTypes );
 +  }
 +  else
 +    *pulInputTypesSupplied = 0;
 +
 +  if (ulOutputTypesRequested > 0)
 +  {
 +    HRESULT ret2;
 +    ret2 = read_types(hkey, szDMOOutputType, pulOutputTypesSupplied, ulOutputTypesRequested, pOutputTypes );
 +
 +    if (ret == S_OK)
 +        ret = ret2;
 +  }
 +  else
 +    *pulOutputTypesSupplied = 0;
 +
 +  return ret;
 +}
index afa15fd,0000000..d990093
mode 100644,000000..100644
--- /dev/null
@@@ -1,66 -1,0 +1,67 @@@
 +
 +spec2def(ntdll.dll def/ntdll.spec ADD_IMPORTLIB)
 +
 +add_definitions(
 +    -D__NTDLL__
 +    -D_NTOSKRNL_
 +    -DCRTDLL)
 +
 +include_directories(
 +    BEFORE include
 +    ${REACTOS_SOURCE_DIR}/include/reactos/subsys
 +    ${REACTOS_SOURCE_DIR}/win32ss/include)
 +
 +list(APPEND SOURCE
 +    csr/api.c
 +    csr/capture.c
 +    csr/connect.c
 +    dbg/dbgui.c
 +    ldr/ldrapi.c
 +    ldr/ldrinit.c
 +    ldr/ldrpe.c
 +    ldr/ldrutils.c
 +    rtl/libsupp.c
 +    rtl/version.c
 +    include/ntdll.h)
 +
 +if(ARCH STREQUAL "i386")
 +    list(APPEND ASM_SOURCE dispatch/i386/dispatch.S)
 +elseif(ARCH STREQUAL "amd64")
 +    list(APPEND ASM_SOURCE dispatch/amd64/dispatch.S)
 +elseif(ARCH STREQUAL "arm")
 +    list(APPEND ASM_SOURCE dispatch/arm/stubs_asm.s)
 +else()
 +    list(APPEND SOURCE dispatch/dispatch.c)
 +endif()
 +
 +add_asm_files(ntdll_asm ${ASM_SOURCE})
 +
 +add_library(ntdll SHARED
 +    ${SOURCE}
 +    ${ntdll_asm}
 +    def/ntdll.rc
++    ${CMAKE_CURRENT_BINARY_DIR}/ntdll_stubs.c
 +    ${CMAKE_CURRENT_BINARY_DIR}/ntdll.def)
 +
 +set_module_type(ntdll win32dll HOTPATCHABLE ENTRYPOINT 0)
 +#############################################
 +## HACK FOR MSVC COMPILATION WITH win32dll ##
 +set_subsystem(ntdll console)
 +################# END  HACK #################
 +
 +if(MSVC)
 +    add_target_link_flags(ntdll "/RELEASE")
 +endif()
 +
 +target_link_libraries(ntdll
 +                      rtl
 +                      ntdllsys
 +                      libcntpr
 +                      uuid
 +                      ${PSEH_LIB})
 +
 +add_pch(ntdll include/ntdll.h SOURCE)
 +add_dependencies(ntdll ntstatus asm)
 +
 +add_cd_file(TARGET ntdll DESTINATION reactos/system32 NO_CAB FOR all)
 +
index 5c8d09e,0000000..0718a3b
mode 100644,000000..100644
--- /dev/null
@@@ -1,324 -1,0 +1,327 @@@
 +/*
 + * COPYRIGHT:       See COPYING in the top level directory
 + * PROJECT:         ReactOS kernel
 + * FILE:            dll/ntdll/csr/capture.c
 + * PURPOSE:         Routines for probing and capturing CSR API Messages
 + * PROGRAMMER:      Alex Ionescu (alex@relsoft.net)
 + */
 +
 +/* INCLUDES *******************************************************************/
 +
 +#include <ntdll.h>
 +
 +#define NDEBUG
 +#include <debug.h>
 +
 +/* GLOBALS ********************************************************************/
 +
 +extern HANDLE CsrPortHeap;
 +
 +/* FUNCTIONS ******************************************************************/
 +
 +/*
 + * @implemented
 + */
 +VOID
 +NTAPI
 +CsrProbeForRead(IN PVOID Address,
 +                IN ULONG Length,
 +                IN ULONG Alignment)
 +{
 +    volatile UCHAR *Pointer;
 +    UCHAR Data;
 +
 +    /* Validate length */
 +    if (Length == 0) return;
 +
 +    /* Validate alignment */
 +    if ((ULONG_PTR)Address & (Alignment - 1))
 +    {
 +        /* Raise exception if it doesn't match */
 +        RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
 +    }
 +
 +    /* Probe first byte */
 +    Pointer = Address;
 +    Data = *Pointer;
 +
 +    /* Probe last byte */
 +    Pointer = (PUCHAR)Address + Length - 1;
 +    Data = *Pointer;
 +    (void)Data;
 +}
 +
 +/*
 + * @implemented
 + */
 +VOID
 +NTAPI
 +CsrProbeForWrite(IN PVOID Address,
 +                 IN ULONG Length,
 +                 IN ULONG Alignment)
 +{
 +    volatile UCHAR *Pointer;
 +
 +    /* Validate length */
 +    if (Length == 0) return;
 +
 +    /* Validate alignment */
 +    if ((ULONG_PTR)Address & (Alignment - 1))
 +    {
 +        /* Raise exception if it doesn't match */
 +        RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
 +    }
 +
 +    /* Probe first byte */
 +    Pointer = Address;
 +    *Pointer = *Pointer;
 +
 +    /* Probe last byte */
 +    Pointer = (PUCHAR)Address + Length - 1;
 +    *Pointer = *Pointer;
 +}
 +
 +/*
 + * @implemented
 + */
 +PCSR_CAPTURE_BUFFER
 +NTAPI
 +CsrAllocateCaptureBuffer(IN ULONG ArgumentCount,
 +                         IN ULONG BufferSize)
 +{
 +    PCSR_CAPTURE_BUFFER CaptureBuffer;
 +
 +    /* Validate size */
 +    if (BufferSize >= MAXLONG) return NULL;
 +
 +    /* Add the size of the header and for each offset to the pointers */
 +    BufferSize += FIELD_OFFSET(CSR_CAPTURE_BUFFER, PointerOffsetsArray) +
 +                    (ArgumentCount * sizeof(ULONG_PTR));
 +
 +    /* Align it to a 4-byte boundary */
 +    BufferSize = (BufferSize + 3) & ~3;
 +
++    /* Add the size of the alignment padding for each argument */
++    BufferSize += ArgumentCount * 3;
++
 +    /* Allocate memory from the port heap */
 +    CaptureBuffer = RtlAllocateHeap(CsrPortHeap, HEAP_ZERO_MEMORY, BufferSize);
 +    if (CaptureBuffer == NULL) return NULL;
 +
 +    /* Initialize the header */
 +    CaptureBuffer->Size = BufferSize;
 +    CaptureBuffer->PointerCount = 0;
 +
 +    /* Initialize all the offsets */
 +    RtlZeroMemory(CaptureBuffer->PointerOffsetsArray,
 +                  ArgumentCount * sizeof(ULONG_PTR));
 +
 +    /* Point to the start of the free buffer */
 +    CaptureBuffer->BufferEnd = (PVOID)((ULONG_PTR)CaptureBuffer->PointerOffsetsArray +
 +                                       ArgumentCount * sizeof(ULONG_PTR));
 +
 +    /* Return the address of the buffer */
 +    return CaptureBuffer;
 +}
 +
 +/*
 + * @implemented
 + */
 +ULONG
 +NTAPI
 +CsrAllocateMessagePointer(IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer,
 +                          IN ULONG MessageLength,
 +                          OUT PVOID* CapturedData)
 +{
 +    if (MessageLength == 0)
 +    {
 +        *CapturedData = NULL;
 +        CapturedData = NULL;
 +    }
 +    else
 +    {
 +        /* Set the capture data at our current available buffer */
 +        *CapturedData = CaptureBuffer->BufferEnd;
 +
 +        /* Validate the size */
 +        if (MessageLength >= MAXLONG) return 0;
 +
 +        /* Align it to a 4-byte boundary */
 +        MessageLength = (MessageLength + 3) & ~3;
 +
 +        /* Move our available buffer beyond this space */
 +        CaptureBuffer->BufferEnd = (PVOID)((ULONG_PTR)CaptureBuffer->BufferEnd + MessageLength);
 +    }
 +
 +    /* Write down this pointer in the array and increase the count */
 +    CaptureBuffer->PointerOffsetsArray[CaptureBuffer->PointerCount++] = (ULONG_PTR)CapturedData;
 +
 +    /* Return the aligned length */
 +    return MessageLength;
 +}
 +
 +/*
 + * @implemented
 + */
 +VOID
 +NTAPI
 +CsrCaptureMessageBuffer(IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer,
 +                        IN PVOID MessageBuffer OPTIONAL,
 +                        IN ULONG MessageLength,
 +                        OUT PVOID* CapturedData)
 +{
 +    /* Simply allocate a message pointer in the buffer */
 +    CsrAllocateMessagePointer(CaptureBuffer, MessageLength, CapturedData);
 +
 +    /* Check if there was any data */
 +    if (!MessageBuffer || !MessageLength) return;
 +
 +    /* Copy the data into the buffer */
 +    RtlMoveMemory(*CapturedData, MessageBuffer, MessageLength);
 +}
 +
 +/*
 + * @implemented
 + */
 +VOID
 +NTAPI
 +CsrFreeCaptureBuffer(IN PCSR_CAPTURE_BUFFER CaptureBuffer)
 +{
 +    /* Free it from the heap */
 +    RtlFreeHeap(CsrPortHeap, 0, CaptureBuffer);
 +}
 +
 +/*
 + * @implemented
 + */
 +VOID
 +NTAPI
 +CsrCaptureMessageString(IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer,
 +                        IN PCSTR String OPTIONAL,
 +                        IN ULONG StringLength,
 +                        IN ULONG MaximumLength,
 +                        OUT PSTRING CapturedString)
 +{
 +    ASSERT(CapturedString != NULL);
 +
 +    /*
 +     * If we don't have a string, initialize an empty one,
 +     * otherwise capture the given string.
 +     */
 +    if (!String)
 +    {
 +        CapturedString->Length = 0;
 +        CapturedString->MaximumLength = (USHORT)MaximumLength;
 +
 +        /* Allocate a pointer for it */
 +        CsrAllocateMessagePointer(CaptureBuffer,
 +                                  MaximumLength,
 +                                  (PVOID*)&CapturedString->Buffer);
 +    }
 +    else
 +    {
 +        /* Cut-off the string length if needed */
 +        if (StringLength > MaximumLength)
 +            StringLength = MaximumLength;
 +
 +        CapturedString->Length = (USHORT)StringLength;
 +
 +        /* Allocate a buffer and get its size */
 +        CapturedString->MaximumLength =
 +            (USHORT)CsrAllocateMessagePointer(CaptureBuffer,
 +                                              MaximumLength,
 +                                              (PVOID*)&CapturedString->Buffer);
 +
 +        /* If the string has data, copy it into the buffer */
 +        if (StringLength)
 +            RtlMoveMemory(CapturedString->Buffer, String, StringLength);
 +    }
 +
 +    /* Null-terminate the string if we don't take up the whole space */
 +    if (CapturedString->Length < CapturedString->MaximumLength)
 +        CapturedString->Buffer[CapturedString->Length] = '\0';
 +}
 +
 +static VOID
 +CsrCaptureMessageUnicodeStringInPlace(IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer,
 +                                      IN PUNICODE_STRING String)
 +{
 +    ASSERT(String != NULL);
 +
 +    /* This is a way to capture the UNICODE string, since (Maximum)Length are also in bytes */
 +    CsrCaptureMessageString(CaptureBuffer,
 +                            (PCSTR)String->Buffer,
 +                            String->Length,
 +                            String->MaximumLength,
 +                            (PSTRING)String);
 +
 +    /* Null-terminate the string */
 +    if (String->MaximumLength >= String->Length + sizeof(WCHAR))
 +    {
 +        String->Buffer[String->Length / sizeof(WCHAR)] = L'\0';
 +    }
 +}
 +
 +/*
 + * @implemented
 + */
 +NTSTATUS
 +NTAPI
 +CsrCaptureMessageMultiUnicodeStringsInPlace(OUT PCSR_CAPTURE_BUFFER* CaptureBuffer,
 +                                            IN ULONG StringsCount,
 +                                            IN PUNICODE_STRING* MessageStrings)
 +{
 +    ULONG Count;
 +
 +    if (!CaptureBuffer) return STATUS_INVALID_PARAMETER;
 +
 +    /* Allocate a new capture buffer if we don't have one already */
 +    if (!*CaptureBuffer)
 +    {
 +        /* Compute the required size for the capture buffer */
 +        ULONG Size = 0;
 +
 +        Count = 0;
 +        while (Count < StringsCount)
 +        {
 +            if (MessageStrings[Count])
 +                Size += MessageStrings[Count]->MaximumLength;
 +
 +            ++Count;
 +        }
 +
 +        /* Allocate the capture buffer */
 +        *CaptureBuffer = CsrAllocateCaptureBuffer(StringsCount, Size);
 +        if (!*CaptureBuffer) return STATUS_NO_MEMORY;
 +    }
 +
 +    /* Now capture each UNICODE string */
 +    Count = 0;
 +    while (Count < StringsCount)
 +    {
 +        if (MessageStrings[Count])
 +            CsrCaptureMessageUnicodeStringInPlace(*CaptureBuffer, MessageStrings[Count]);
 +
 +        ++Count;
 +    }
 +
 +    return STATUS_SUCCESS;
 +}
 +
 +/*
 + * @implemented
 + */
 +PLARGE_INTEGER
 +NTAPI
 +CsrCaptureTimeout(IN ULONG Milliseconds,
 +                  OUT PLARGE_INTEGER Timeout)
 +{
 +    /* Validate the time */
 +    if (Milliseconds == -1) return NULL;
 +
 +    /* Convert to relative ticks */
 +    Timeout->QuadPart = Int32x32To64(Milliseconds, -10000);
 +    return Timeout;
 +}
 +
 +/* EOF */
index 4ed630d,0000000..e6f8799
mode 100644,000000..100644
--- /dev/null
@@@ -1,1398 -1,0 +1,1398 @@@
- ;@ stdcall NtGetTickCount()
 +
 +@ stdcall CsrAllocateCaptureBuffer(long long)
 +@ stdcall CsrAllocateMessagePointer(ptr long ptr)
 +@ stdcall CsrCaptureMessageBuffer(ptr ptr long ptr)
 +@ stdcall CsrCaptureMessageMultiUnicodeStringsInPlace(ptr long ptr)
 +@ stdcall CsrCaptureMessageString(ptr str long long ptr)
 +@ stdcall CsrCaptureTimeout(long ptr)
 +@ stdcall CsrClientCallServer(ptr ptr long long)
 +@ stdcall CsrClientConnectToServer(str long ptr ptr ptr)
 +@ stdcall CsrFreeCaptureBuffer(ptr)
 +@ stdcall CsrGetProcessId()
 +@ stdcall CsrIdentifyAlertableThread()
 +@ stdcall CsrNewThread()
 +@ stdcall CsrProbeForRead(ptr long long)
 +@ stdcall CsrProbeForWrite(ptr long long)
 +@ stdcall CsrSetPriorityClass(ptr ptr)
 +@ stdcall DbgBreakPoint()
 +@ varargs DbgPrint(str)
 +@ varargs DbgPrintEx(long long str)
 +@ varargs DbgPrintReturnControlC(str)
 +@ stdcall DbgPrompt(ptr ptr long)
 +@ stdcall DbgQueryDebugFilterState(long long)
 +@ stdcall DbgSetDebugFilterState(long long long)
 +@ stdcall DbgUiConnectToDbg()
 +@ stdcall DbgUiContinue(ptr long)
 +@ stdcall DbgUiConvertStateChangeStructure(ptr ptr)
 +@ stdcall DbgUiDebugActiveProcess(ptr)
 +@ stdcall DbgUiGetThreadDebugObject()
 +@ stdcall DbgUiIssueRemoteBreakin(ptr)
 +@ stdcall DbgUiRemoteBreakin()
 +@ stdcall DbgUiSetThreadDebugObject(ptr)
 +@ stdcall DbgUiStopDebugging(ptr)
 +@ stdcall DbgUiWaitStateChange(ptr ptr)
 +@ stdcall DbgUserBreakPoint()
 +@ 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
 +@ stdcall KiUserExceptionDispatcher(ptr ptr)
 +@ stdcall LdrAccessOutOfProcessResource(ptr ptr ptr ptr ptr)
 +@ stdcall LdrAccessResource(long ptr ptr ptr)
 +@ stdcall LdrAddRefDll(long ptr)
 +;@ stdcall LdrAlternateResourcesEnabled
 +@ stdcall LdrCreateOutOfProcessImage(long ptr ptr ptr)
 +@ stdcall LdrDestroyOutOfProcessImage(ptr)
 +@ stdcall LdrDisableThreadCalloutsForDll(long)
 +@ stdcall LdrEnumResources(ptr ptr long ptr ptr)
 +@ stdcall LdrEnumerateLoadedModules(long ptr long)
 +@ stdcall LdrFindCreateProcessManifest(long ptr ptr long ptr) ; 5.1 and 5.2 only
 +@ stdcall LdrFindEntryForAddress(ptr ptr)
 +@ stdcall LdrFindResourceDirectory_U(long ptr long ptr)
 +;@ stdcall LdrFindResourceEx_U ; 5.1 and higher
 +@ stdcall LdrFindResource_U(long ptr long ptr)
 +@ stdcall LdrFlushAlternateResourceModules()
 +@ stdcall LdrGetDllHandle(wstr long ptr ptr)
 +@ stdcall LdrGetDllHandleEx(long wstr long ptr ptr)
 +@ stdcall LdrGetProcedureAddress(ptr ptr long ptr)
 +;@ stdcall LdrHotPatchRoutine
 +;@ stdcall LdrInitShimEngineDynamic
 +@ stdcall LdrInitializeThunk(long long long long)
 +@ stdcall LdrLoadAlternateResourceModule(ptr ptr)
 +@ stdcall LdrLoadDll(wstr long ptr ptr)
 +@ stdcall LdrLockLoaderLock(long ptr ptr)
 +@ 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 LdrQueryImageFileKeyOption(ptr ptr long ptr long ptr)
 +@ stdcall LdrQueryProcessModuleInformation(ptr long ptr)
 +;@ stdcall LdrSetAppCompatDllRedirectionCallback
 +@ stdcall LdrSetDllManifestProber(ptr)
 +@ stdcall LdrShutdownProcess()
 +@ stdcall LdrShutdownThread()
 +@ stdcall LdrUnloadAlternateResourceModule(ptr)
 +@ stdcall LdrUnloadDll(ptr)
 +@ stdcall LdrUnlockLoaderLock(long long)
 +@ stdcall LdrVerifyImageMatchesChecksum(ptr long long long)
 +@ extern NlsAnsiCodePage
 +@ extern NlsMbCodePageTag
 +@ extern NlsMbOemCodePageTag
 +@ stdcall NtAcceptConnectPort(ptr long ptr long long ptr)
 +@ stdcall NtAccessCheck(ptr long long ptr ptr ptr ptr ptr)
 +@ stdcall NtAccessCheckAndAuditAlarm(ptr long ptr ptr ptr long ptr long ptr ptr ptr)
 +@ stdcall NtAccessCheckByType(ptr ptr ptr long ptr long ptr ptr long ptr ptr)
 +@ stdcall NtAccessCheckByTypeAndAuditAlarm(ptr ptr ptr ptr ptr ptr long long long ptr long ptr long ptr ptr ptr)
 +@ stdcall NtAccessCheckByTypeResultList(ptr ptr ptr long ptr long ptr ptr long ptr ptr)
 +@ stdcall NtAccessCheckByTypeResultListAndAuditAlarm(ptr ptr ptr ptr ptr ptr long long long ptr long ptr long ptr ptr ptr)
 +@ stdcall NtAccessCheckByTypeResultListAndAuditAlarmByHandle(ptr ptr ptr ptr ptr ptr ptr long long long ptr long ptr long ptr ptr ptr)
 +@ stdcall NtAddAtom(ptr long ptr)
 +@ stdcall NtAddBootEntry(ptr long)
 +@ stdcall NtAddDriverEntry(ptr long) ; 5.2 and higher
 +@ stdcall NtAdjustGroupsToken(long long ptr long ptr ptr)
 +@ stdcall NtAdjustPrivilegesToken(long long long long long long)
 +@ stdcall NtAlertResumeThread(long ptr)
 +@ stdcall NtAlertThread(long)
 +@ stdcall NtAllocateLocallyUniqueId(ptr)
 +@ stdcall NtAllocateUserPhysicalPages(ptr ptr ptr)
 +@ stdcall NtAllocateUuids(ptr ptr ptr ptr)
 +@ stdcall NtAllocateVirtualMemory(long ptr ptr ptr long long)
 +@ stdcall NtApphelpCacheControl(long ptr)
 +@ stdcall NtAreMappedFilesTheSame(ptr ptr)
 +@ stdcall NtAssignProcessToJobObject(long long)
 +@ stdcall NtCallbackReturn(ptr long long)
 +@ stdcall NtCancelDeviceWakeupRequest(ptr)
 +@ stdcall NtCancelIoFile(long ptr)
 +@ stdcall NtCancelTimer(long ptr)
 +@ stdcall NtClearEvent(long)
 +@ stdcall NtClose(long)
 +@ stdcall NtCloseObjectAuditAlarm(ptr ptr long)
 +@ stdcall NtCompactKeys(long ptr)
 +@ stdcall NtCompareTokens(ptr ptr ptr)
 +@ stdcall NtCompleteConnectPort(ptr)
 +@ stdcall NtCompressKey(ptr)
 +@ stdcall NtConnectPort(ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall NtContinue(ptr long)
 +@ stdcall NtCreateDebugObject(ptr long ptr long)
 +@ stdcall NtCreateDirectoryObject(long long long)
 +@ stdcall NtCreateEvent(long long long long long)
 +@ stdcall NtCreateEventPair(ptr long ptr)
 +@ stdcall NtCreateFile(ptr long ptr ptr long long long ptr long long ptr)
 +@ stdcall NtCreateIoCompletion(ptr long ptr long)
 +@ stdcall NtCreateJobObject(ptr long ptr)
 +@ stdcall NtCreateJobSet(long ptr long)
 +@ stdcall NtCreateKey(ptr long ptr long ptr long long)
 +@ stdcall NtCreateKeyedEvent(ptr long ptr long)
 +@ stdcall NtCreateMailslotFile(long long long long long long long long)
 +@ stdcall NtCreateMutant(ptr long ptr long)
 +@ stdcall NtCreateNamedPipeFile(ptr long ptr ptr long long long long long long long long long ptr)
 +@ stdcall NtCreatePagingFile(long long long long)
 +@ stdcall NtCreatePort(ptr ptr long long ptr)
 +@ stdcall NtCreateProcess(ptr long ptr ptr long ptr ptr ptr)
 +@ stdcall NtCreateProcessEx(ptr long ptr ptr long ptr ptr ptr long)
 +@ stdcall NtCreateProfile(ptr ptr ptr long long ptr long long long) ; CHECKME
 +@ stdcall NtCreateSection(ptr long ptr ptr long long long)
 +@ stdcall NtCreateSemaphore(ptr long ptr long long)
 +@ stdcall NtCreateSymbolicLinkObject(ptr long ptr ptr)
 +@ stdcall NtCreateThread(ptr long ptr ptr ptr ptr ptr long)
 +@ stdcall NtCreateTimer(ptr long ptr long)
 +@ stdcall NtCreateToken(ptr long ptr long ptr ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall NtCreateWaitablePort(ptr ptr long long long)
 +@ stdcall -arch=win32 NtCurrentTeb() _NtCurrentTeb
 +@ stdcall NtDebugActiveProcess(ptr ptr)
 +@ stdcall NtDebugContinue(ptr ptr long)
 +@ stdcall NtDelayExecution(long ptr)
 +@ stdcall NtDeleteAtom(long)
 +@ stdcall NtDeleteBootEntry(long)
 +@ stdcall NtDeleteFile(ptr)
 +@ stdcall NtDeleteKey(long)
 +@ stdcall NtDeleteObjectAuditAlarm(ptr ptr long)
 +@ stdcall NtDeleteValueKey(long ptr)
 +@ stdcall NtDeviceIoControlFile(long long long long long long long long long long)
 +@ stdcall NtDisplayString(ptr)
 +@ stdcall NtDuplicateObject(long long long ptr long long long)
 +@ stdcall NtDuplicateToken(long long long long long long)
 +@ stdcall NtEnumerateBootEntries(ptr ptr)
 +@ stdcall NtEnumerateKey (long long long long long long)
 +@ stdcall NtEnumerateSystemEnvironmentValuesEx(long ptr long)
 +@ stdcall NtEnumerateValueKey(long long long long long long)
 +@ stdcall NtExtendSection(ptr ptr)
 +@ stdcall NtFilterToken(ptr long ptr ptr ptr ptr)
 +@ stdcall NtFindAtom(ptr long ptr)
 +@ stdcall NtFlushBuffersFile(long ptr)
 +@ stdcall NtFlushInstructionCache(long ptr long)
 +@ stdcall NtFlushKey(long)
 +@ stdcall NtFlushVirtualMemory(long ptr ptr long)
 +@ stdcall NtFlushWriteBuffer()
 +@ stdcall NtFreeUserPhysicalPages(ptr ptr ptr)
 +@ stdcall NtFreeVirtualMemory(long ptr ptr long)
 +@ stdcall NtFsControlFile(long long long long long long long long long long)
 +@ stdcall NtGetContextThread(long ptr)
 +@ stdcall NtGetCurrentProcessorNumber() ; 5.2 and higher
 +@ stdcall NtGetDevicePowerState(ptr ptr)
 +@ stdcall NtGetPlugPlayEvent(long long ptr long)
++@ stdcall -stub NtGetTickCount()
 +@ stdcall NtGetWriteWatch(long long ptr long ptr ptr ptr)
 +@ stdcall NtImpersonateAnonymousToken(ptr)
 +@ stdcall NtImpersonateClientOfPort(ptr ptr)
 +@ stdcall NtImpersonateThread(ptr ptr ptr)
 +@ stdcall NtInitializeRegistry(long)
 +@ stdcall NtInitiatePowerAction (long long long long)
 +@ stdcall NtIsProcessInJob(long long)
 +@ stdcall NtIsSystemResumeAutomatic()
 +@ stdcall NtListenPort(ptr ptr)
 +@ stdcall NtLoadDriver(ptr)
 +@ stdcall NtLoadKey2(ptr ptr long)
 +@ stdcall NtLoadKey(ptr ptr)
 +@ stdcall NtLockFile(long long ptr ptr ptr ptr ptr ptr long long)
 +@ stdcall NtLockProductActivationKeys(ptr ptr)
 +@ stdcall NtLockRegistryKey(ptr)
 +@ stdcall NtLockVirtualMemory(long ptr ptr long)
 +@ stdcall NtMakePermanentObject(ptr)
 +@ stdcall NtMakeTemporaryObject(long)
 +@ stdcall NtMapUserPhysicalPages(ptr ptr ptr)
 +@ stdcall NtMapUserPhysicalPagesScatter(ptr ptr ptr)
 +@ stdcall NtMapViewOfSection(long long ptr long long ptr ptr long long long)
 +@ stdcall NtModifyBootEntry(ptr)
 +@ 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)
 +@ stdcall NtOpenDirectoryObject(long long long)
 +@ stdcall NtOpenEvent(long long long)
 +@ stdcall NtOpenEventPair(ptr long ptr)
 +@ stdcall NtOpenFile(ptr long ptr ptr long long)
 +@ stdcall NtOpenIoCompletion(ptr long ptr)
 +@ stdcall NtOpenJobObject(ptr long ptr)
 +@ stdcall NtOpenKey(ptr long ptr)
 +@ stdcall NtOpenKeyedEvent(ptr long ptr)
 +@ stdcall NtOpenMutant(ptr long ptr)
 +@ stdcall NtOpenObjectAuditAlarm(ptr ptr ptr ptr ptr ptr long long ptr long long ptr)
 +@ stdcall NtOpenProcess(ptr long ptr ptr)
 +@ stdcall NtOpenProcessToken(long long ptr)
 +@ stdcall NtOpenProcessTokenEx(long long long ptr)
 +@ stdcall NtOpenSection(ptr long ptr)
 +@ stdcall NtOpenSemaphore(long long ptr)
 +@ stdcall NtOpenSymbolicLinkObject (ptr long ptr)
 +@ stdcall NtOpenThread(ptr long ptr ptr)
 +@ stdcall NtOpenThreadToken(long long long ptr)
 +@ stdcall NtOpenThreadTokenEx(long long long long ptr)
 +@ stdcall NtOpenTimer(ptr long ptr)
 +@ stdcall NtPlugPlayControl(ptr ptr long)
 +@ stdcall NtPowerInformation(long ptr long ptr long)
 +@ stdcall NtPrivilegeCheck(ptr ptr ptr)
 +@ stdcall NtPrivilegeObjectAuditAlarm(ptr ptr ptr long ptr long)
 +@ stdcall NtPrivilegedServiceAuditAlarm(ptr ptr ptr ptr long)
 +@ stdcall NtProtectVirtualMemory(long ptr ptr long ptr)
 +@ stdcall NtPulseEvent(long ptr)
 +@ stdcall NtQueryAttributesFile(ptr ptr)
 +@ stdcall NtQueryBootEntryOrder(ptr ptr)
 +@ stdcall NtQueryBootOptions(ptr ptr)
 +@ stdcall NtQueryDebugFilterState(long long)
 +@ stdcall NtQueryDefaultLocale(long ptr)
 +@ 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 NtQueryEaFile(long ptr ptr long long ptr long ptr long)
 +@ stdcall NtQueryEvent(long long ptr long ptr)
 +@ stdcall NtQueryFullAttributesFile(ptr ptr)
 +@ stdcall NtQueryInformationAtom(long long ptr long ptr)
 +@ stdcall NtQueryInformationFile(long ptr ptr long long)
 +@ stdcall NtQueryInformationJobObject(long long ptr long ptr)
 +@ stdcall NtQueryInformationPort(ptr long ptr long ptr)
 +@ stdcall NtQueryInformationProcess(long long ptr long ptr)
 +@ stdcall NtQueryInformationThread(long long ptr long ptr)
 +@ stdcall NtQueryInformationToken(long long ptr long ptr)
 +@ stdcall NtQueryInstallUILanguage(ptr)
 +@ stdcall NtQueryIntervalProfile(long ptr)
 +@ stdcall NtQueryIoCompletion(long long ptr long ptr)
 +@ stdcall NtQueryKey (long long ptr long ptr)
 +@ stdcall NtQueryMultipleValueKey(long ptr long ptr long ptr)
 +@ stdcall NtQueryMutant(long long ptr long ptr)
 +@ stdcall NtQueryObject(long long long long long)
 +@ stdcall NtQueryOpenSubKeys(ptr ptr)
 +@ stdcall NtQueryPerformanceCounter(ptr ptr)
 +@ stdcall NtQueryPortInformationProcess()
 +@ stdcall NtQueryQuotaInformationFile(ptr ptr ptr long long ptr long ptr long)
 +@ stdcall NtQuerySection (long long long long long)
 +@ stdcall NtQuerySecurityObject (long long long long long)
 +@ stdcall NtQuerySemaphore (long long ptr long ptr)
 +@ stdcall NtQuerySymbolicLinkObject(long ptr ptr)
 +@ stdcall NtQuerySystemEnvironmentValue(ptr ptr long ptr)
 +@ stdcall NtQuerySystemEnvironmentValueEx(ptr ptr ptr ptr ptr)
 +@ stdcall NtQuerySystemInformation(long long long long)
 +@ stdcall NtQuerySystemTime(ptr)
 +@ stdcall NtQueryTimer(ptr long ptr long ptr)
 +@ stdcall NtQueryTimerResolution(long long long)
 +@ stdcall NtQueryValueKey(long long long long long long)
 +@ stdcall NtQueryVirtualMemory(long ptr long ptr long ptr)
 +@ stdcall NtQueryVolumeInformationFile(long ptr ptr long long)
 +@ stdcall NtQueueApcThread(long ptr long long long)
 +@ stdcall NtRaiseException(ptr ptr long)
 +@ stdcall NtRaiseHardError(long long long ptr long ptr)
 +@ stdcall NtReadFile(long long ptr ptr ptr ptr long ptr ptr)
 +@ stdcall NtReadFileScatter(long long ptr ptr ptr ptr long ptr ptr)
 +@ stdcall NtReadRequestData(ptr ptr long ptr long ptr)
 +@ stdcall NtReadVirtualMemory(long ptr ptr long ptr)
 +@ stdcall NtRegisterThreadTerminatePort(ptr)
 +@ stdcall NtReleaseKeyedEvent(ptr ptr long ptr)
 +@ stdcall NtReleaseMutant(long ptr)
 +@ stdcall NtReleaseSemaphore(long long ptr)
 +@ stdcall NtRemoveIoCompletion(ptr ptr ptr ptr ptr)
 +@ stdcall NtRemoveProcessDebug(ptr ptr)
 +@ stdcall NtRenameKey(ptr ptr)
 +@ stdcall NtReplaceKey(ptr long ptr)
 +@ stdcall NtReplyPort(ptr ptr)
 +@ stdcall NtReplyWaitReceivePort(ptr ptr ptr ptr)
 +@ stdcall NtReplyWaitReceivePortEx(ptr ptr ptr ptr ptr)
 +@ stdcall NtReplyWaitReplyPort(ptr ptr)
 +@ stdcall NtRequestDeviceWakeup(ptr)
 +@ stdcall NtRequestPort(ptr ptr)
 +@ stdcall NtRequestWaitReplyPort(ptr ptr ptr)
 +@ stdcall NtRequestWakeupLatency(long)
 +@ stdcall NtResetEvent(long ptr)
 +@ stdcall NtResetWriteWatch(long ptr long)
 +@ stdcall NtRestoreKey(long long long)
 +@ stdcall NtResumeProcess(ptr)
 +@ stdcall NtResumeThread(long long)
 +@ stdcall NtSaveKey(long long)
 +@ stdcall NtSaveKeyEx(ptr ptr long)
 +@ stdcall NtSaveMergedKeys(ptr ptr ptr)
 +@ stdcall NtSecureConnectPort(ptr ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall NtSetBootEntryOrder(ptr ptr)
 +@ stdcall NtSetBootOptions(ptr long)
 +@ stdcall NtSetContextThread(long ptr)
 +@ stdcall NtSetDebugFilterState(long long long)
 +@ stdcall NtSetDefaultHardErrorPort(ptr)
 +@ stdcall NtSetDefaultLocale(long long)
 +@ stdcall NtSetDefaultUILanguage(long)
 +@ stdcall NtSetEaFile(long ptr ptr long)
 +@ stdcall NtSetEvent(long long)
 +@ stdcall NtSetEventBoostPriority(ptr)
 +@ stdcall NtSetHighEventPair(ptr)
 +@ stdcall NtSetHighWaitLowEventPair(ptr)
 +@ stdcall NtSetInformationDebugObject(ptr long ptr long ptr)
 +@ stdcall NtSetInformationFile(long long long long long)
 +@ stdcall NtSetInformationJobObject(long long ptr long)
 +@ stdcall NtSetInformationKey(long long ptr long)
 +@ stdcall NtSetInformationObject(long long ptr long)
 +@ stdcall NtSetInformationProcess(long long long long)
 +@ stdcall NtSetInformationThread(long long ptr long)
 +@ stdcall NtSetInformationToken(long long ptr long)
 +@ stdcall NtSetIntervalProfile(long long)
 +@ stdcall NtSetIoCompletion(ptr long ptr long long)
 +@ stdcall NtSetLdtEntries(long double long double) ; CHECKME
 +@ stdcall NtSetLowEventPair(ptr)
 +@ stdcall NtSetLowWaitHighEventPair(ptr)
 +@ stdcall NtSetQuotaInformationFile(ptr ptr ptr long)
 +@ stdcall NtSetSecurityObject(long long ptr)
 +@ stdcall NtSetSystemEnvironmentValue(ptr ptr)
 +@ stdcall NtSetSystemEnvironmentValueEx(ptr ptr)
 +@ stdcall NtSetSystemInformation(long ptr long)
 +@ stdcall NtSetSystemPowerState(long long long)
 +@ stdcall NtSetSystemTime(ptr ptr)
 +@ stdcall NtSetThreadExecutionState(long ptr)
 +@ stdcall NtSetTimer(long ptr ptr ptr long long ptr)
 +@ stdcall NtSetTimerResolution(long long ptr)
 +@ stdcall NtSetUuidSeed(ptr)
 +@ stdcall NtSetValueKey(long long long long long long)
 +@ stdcall NtSetVolumeInformationFile(long ptr ptr long long)
 +@ stdcall NtShutdownSystem(long)
 +@ stdcall NtSignalAndWaitForSingleObject(long long long ptr)
 +@ stdcall NtStartProfile(ptr)
 +@ stdcall NtStopProfile(ptr)
 +@ stdcall NtSuspendProcess(ptr)
 +@ stdcall NtSuspendThread(long ptr)
 +@ stdcall NtSystemDebugControl(long ptr long ptr long ptr)
 +@ stdcall NtTerminateJobObject(long long)
 +@ stdcall NtTerminateProcess(long long)
 +@ stdcall NtTerminateThread(long long)
 +@ stdcall NtTestAlert()
 +@ stdcall NtTraceEvent(long long long ptr)
 +@ stdcall NtTranslateFilePath(ptr long ptr long)
 +@ stdcall NtUnloadDriver(ptr)
 +@ stdcall NtUnloadKey(long)
 +@ stdcall NtUnloadKeyEx(ptr ptr)
 +@ stdcall NtUnlockFile(long ptr ptr ptr ptr)
 +@ stdcall NtUnlockVirtualMemory(long ptr ptr long)
 +@ stdcall NtUnmapViewOfSection(long ptr)
 +@ stdcall NtVdmControl(long ptr)
 +@ stdcall NtWaitForDebugEvent(ptr long ptr ptr)
 +@ stdcall NtWaitForKeyedEvent(ptr ptr long ptr)
 +@ stdcall NtWaitForMultipleObjects(long ptr long long ptr)
 +@ stdcall NtWaitForSingleObject(long long long)
 +@ stdcall NtWaitHighEventPair(ptr)
 +@ stdcall NtWaitLowEventPair(ptr)
 +@ stdcall NtWriteFile(long long ptr ptr ptr ptr long ptr ptr)
 +@ stdcall NtWriteFileGather(long long ptr ptr ptr ptr long ptr ptr)
 +@ stdcall NtWriteRequestData(ptr ptr long ptr long ptr)
 +@ stdcall NtWriteVirtualMemory(long ptr ptr long ptr)
 +@ stdcall NtYieldExecution()
 +;@ stdcall PfxFindPrefix
 +;@ 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)
 +@ stdcall RtlAddAccessDeniedAce(ptr long long ptr)
 +@ stdcall RtlAddAccessDeniedAceEx(ptr long long long ptr)
 +@ stdcall RtlAddAccessDeniedObjectAce(ptr long long long ptr ptr ptr)
 +@ stdcall RtlAddAce(ptr long long ptr long)
 +@ stdcall RtlAddActionToRXact(ptr long ptr long ptr long)
 +@ stdcall RtlAddAtomToAtomTable(ptr wstr ptr)
 +@ stdcall RtlAddAttributeActionToRXact(ptr long ptr ptr ptr long ptr long)
 +@ stdcall RtlAddAuditAccessAce(ptr long long ptr long long)
 +@ 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)
 +@ stdcall RtlAddVectoredExceptionHandler(long ptr)
 +;@ stdcall RtlAddressInSectionTable
 +@ stdcall RtlAdjustPrivilege(long long long ptr)
 +@ stdcall RtlAllocateActivationContextStack(ptr) ; CHECKME
 +@ stdcall RtlAllocateAndInitializeSid(ptr long long long long long long long long long ptr)
 +@ stdcall RtlAllocateHandle(ptr ptr)
 +@ stdcall RtlAllocateHeap(ptr long ptr)
 +@ stdcall RtlAnsiCharToUnicodeChar(ptr)
 +@ stdcall RtlAnsiStringToUnicodeSize(ptr) RtlxAnsiStringToUnicodeSize
 +@ stdcall RtlAnsiStringToUnicodeString(ptr ptr long)
 +@ stdcall RtlAppendAsciizToString(ptr str)
 +;@ stdcall RtlAppendPathElement
 +@ stdcall RtlAppendStringToString(ptr ptr)
 +@ stdcall RtlAppendUnicodeStringToString(ptr ptr)
 +@ stdcall RtlAppendUnicodeToString(ptr wstr)
 +;@ stdcall RtlApplicationVerifierStop
 +@ stdcall RtlApplyRXact(ptr)
 +@ stdcall RtlApplyRXactNoFlush(ptr)
 +@ stdcall RtlAreAllAccessesGranted(long long)
 +@ stdcall RtlAreAnyAccessesGranted(long long)
 +@ stdcall RtlAreBitsClear(ptr long long)
 +@ stdcall RtlAreBitsSet(ptr long long)
 +@ stdcall RtlAssert(ptr ptr long ptr)
 +;@ stdcall RtlCancelTimer
 +@ stdcall -register RtlCaptureContext(ptr)
 +@ stdcall RtlCaptureStackBackTrace(long long ptr ptr)
 +;@ stdcall RtlCaptureStackContext
 +@ stdcall RtlCharToInteger(ptr long ptr)
 +@ stdcall RtlCheckForOrphanedCriticalSections(ptr)
 +;@ stdcall RtlCheckProcessParameters
 +@ stdcall RtlCheckRegistryKey(long ptr)
 +@ stdcall RtlClearAllBits(ptr)
 +@ stdcall RtlClearBits(ptr long long)
 +@ stdcall RtlCloneMemoryStream(ptr ptr)
 +@ stdcall RtlCommitMemoryStream(ptr long)
 +@ stdcall RtlCompactHeap(long long)
 +@ stdcall RtlCompareMemory(ptr ptr long)
 +@ stdcall RtlCompareMemoryUlong(ptr long long)
 +@ stdcall RtlCompareString(ptr ptr long)
 +@ stdcall RtlCompareUnicodeString (ptr ptr long)
 +@ stdcall RtlCompressBuffer(long ptr long ptr long long ptr ptr)
 +@ stdcall RtlComputeCrc32(long ptr long)
 +@ stdcall RtlComputeImportTableHash(ptr ptr long)
 +@ stdcall RtlComputePrivatizedDllName_U(ptr ptr ptr)
 +@ 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)
 +@ stdcall RtlCopyString(ptr ptr)
 +@ stdcall RtlCopyUnicodeString(ptr ptr)
 +@ stdcall RtlCreateAcl(ptr long long)
 +@ stdcall RtlCreateActivationContext(long ptr long ptr ptr ptr)
 +@ stdcall RtlCreateAndSetSD(ptr long ptr ptr ptr)
 +@ stdcall RtlCreateAtomTable(long ptr)
 +@ stdcall RtlCreateBootStatusDataFile()
 +@ stdcall RtlCreateEnvironment(long ptr)
 +@ stdcall RtlCreateHeap(long ptr long long ptr ptr)
 +@ stdcall RtlCreateProcessParameters(ptr ptr ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall RtlCreateQueryDebugBuffer(long long)
 +@ stdcall RtlCreateRegistryKey(long wstr)
 +@ stdcall RtlCreateSecurityDescriptor(ptr long)
 +@ stdcall RtlCreateSystemVolumeInformationFolder(ptr)
 +@ stdcall RtlCreateTagHeap(ptr long str str)
 +@ stdcall RtlCreateTimer(ptr ptr ptr ptr long long long)
 +@ stdcall RtlCreateTimerQueue(ptr)
 +@ stdcall RtlCreateUnicodeString(ptr wstr)
 +@ stdcall RtlCreateUnicodeStringFromAsciiz(ptr str)
 +@ stdcall RtlCreateUserProcess(ptr long ptr ptr ptr ptr long ptr ptr ptr)
 +@ stdcall RtlCreateUserSecurityObject(ptr long ptr ptr long ptr ptr)
 +@ stdcall RtlCreateUserThread(long ptr long ptr long long ptr ptr ptr ptr)
 +@ stdcall RtlCustomCPToUnicodeN(ptr wstr long ptr str long)
 +@ stdcall RtlCutoverTimeToSystemTime(ptr ptr ptr long)
 +@ stdcall RtlDeNormalizeProcessParams(ptr)
 +@ stdcall RtlDeactivateActivationContext(long long)
 +@ fastcall RtlDeactivateActivationContextUnsafeFast(ptr)
 +@ stdcall RtlDecodePointer(ptr)
 +@ stdcall RtlDecodeSystemPointer(ptr) RtlEncodeSystemPointer
 +@ stdcall RtlDecompressBuffer(long ptr long ptr long ptr)
 +@ stdcall RtlDecompressFragment(long ptr long ptr long long ptr ptr)
 +@ stdcall RtlDefaultNpAcl(ptr)
 +@ stdcall RtlDelete(ptr)
 +@ stdcall RtlDeleteAce(ptr long)
 +@ stdcall RtlDeleteAtomFromAtomTable(ptr long)
 +@ stdcall RtlDeleteCriticalSection(ptr)
 +@ stdcall RtlDeleteElementGenericTable(ptr ptr)
 +@ 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)
 +@ stdcall RtlDeleteTimer(ptr ptr ptr)
 +@ stdcall RtlDeleteTimerQueue(ptr)
 +@ stdcall RtlDeleteTimerQueueEx(ptr ptr)
 +@ stdcall RtlDeregisterWait(ptr)
 +@ stdcall RtlDeregisterWaitEx(ptr ptr)
 +@ stdcall RtlDestroyAtomTable(ptr)
 +@ stdcall RtlDestroyEnvironment(ptr)
 +@ stdcall RtlDestroyHandleTable(ptr)
 +@ stdcall RtlDestroyHeap(long)
 +@ stdcall RtlDestroyProcessParameters(ptr)
 +@ stdcall RtlDestroyQueryDebugBuffer(ptr)
 +@ stdcall RtlDetermineDosPathNameType_U(wstr)
 +@ stdcall RtlDllShutdownInProgress()
 +@ stdcall RtlDnsHostNameToComputerName(ptr ptr long)
 +@ stdcall RtlDoesFileExists_U(wstr)
 +@ stdcall RtlDosApplyFileIsolationRedirection_Ustr(long ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall RtlDosPathNameToNtPathName_U(wstr ptr ptr ptr)
 +@ stdcall RtlDosPathNameToNtPathName_U_WithStatus(wstr ptr ptr ptr) ; 5.2 SP1, and higher
 +@ stdcall RtlDosPathNameToRelativeNtPathName_U(ptr ptr ptr ptr)
 +@ stdcall RtlDosPathNameToRelativeNtPathName_U_WithStatus(wstr ptr ptr ptr)
 +@ stdcall RtlDosSearchPath_U(wstr wstr wstr long ptr ptr)
 +@ stdcall RtlDosSearchPath_Ustr(long ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall RtlDowncaseUnicodeChar(long)
 +@ stdcall RtlDowncaseUnicodeString(ptr ptr long)
 +@ stdcall RtlDumpResource(ptr)
 +@ stdcall RtlDuplicateUnicodeString(long ptr ptr)
 +@ stdcall RtlEmptyAtomTable(ptr long)
 +;@ stdcall RtlEnableEarlyCriticalSectionEventCreation
 +@ stdcall RtlEncodePointer(ptr)
 +@ stdcall RtlEncodeSystemPointer(ptr)
 +@ stdcall -arch=win32 -ret64 RtlEnlargedIntegerMultiply(long long)
 +@ stdcall -arch=win32 RtlEnlargedUnsignedDivide(double long ptr)
 +@ stdcall -arch=win32 -ret64 RtlEnlargedUnsignedMultiply(long long)
 +@ stdcall RtlEnterCriticalSection(ptr)
 +@ stdcall RtlEnumProcessHeaps(ptr ptr)
 +@ stdcall RtlEnumerateGenericTable(ptr long)
 +@ stdcall RtlEnumerateGenericTableAvl(ptr long)
 +@ stdcall RtlEnumerateGenericTableLikeADirectory(ptr ptr ptr long ptr ptr ptr)
 +@ stdcall RtlEnumerateGenericTableWithoutSplaying(ptr ptr)
 +@ stdcall RtlEnumerateGenericTableWithoutSplayingAvl(ptr ptr)
 +@ stdcall RtlEqualComputerName(ptr ptr)
 +@ stdcall RtlEqualDomainName(ptr ptr)
 +@ stdcall RtlEqualLuid(ptr ptr)
 +@ stdcall RtlEqualPrefixSid(ptr ptr)
 +@ stdcall RtlEqualSid(long long)
 +@ stdcall RtlEqualString(ptr ptr long)
 +@ stdcall RtlEqualUnicodeString(ptr ptr long)
 +@ stdcall RtlEraseUnicodeString(ptr)
 +@ stdcall RtlExitUserThread(long)
 +@ stdcall RtlExpandEnvironmentStrings_U(ptr ptr ptr ptr)
 +@ stdcall RtlExtendHeap(ptr long ptr ptr)
 +@ stdcall -arch=win32 -ret64 RtlExtendedIntegerMultiply(double long)
 +@ stdcall -arch=win32 -ret64 RtlExtendedLargeIntegerDivide(double long ptr)
 +@ stdcall -arch=win32 -ret64 RtlExtendedMagicDivide(double double long)
 +@ stdcall RtlFillMemory(ptr long long)
 +@ stdcall RtlFillMemoryUlong(ptr long long)
 +@ stdcall RtlFinalReleaseOutOfProcessMemoryStream(ptr)
 +@ stdcall RtlFindActivationContextSectionGuid(long ptr long ptr ptr)
 +@ stdcall RtlFindActivationContextSectionString(long ptr long ptr ptr)
 +@ stdcall RtlFindCharInUnicodeString(long ptr ptr ptr)
 +@ stdcall RtlFindClearBits(ptr long long)
 +@ 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)
 +@ stdcall RtlFormatCurrentUserKeyPath(ptr)
 +@ stdcall RtlFormatMessage(ptr long long long long ptr ptr long)
 +@ stdcall RtlFormatMessageEx(ptr long long long long ptr ptr long long)
 +@ stdcall RtlFreeActivationContextStack(ptr)
 +@ stdcall RtlFreeAnsiString(long)
 +@ stdcall RtlFreeHandle(ptr ptr)
 +@ stdcall RtlFreeHeap(long long long)
 +@ stdcall RtlFreeOemString(ptr)
 +@ stdcall RtlFreeRangeList(ptr)
 +@ stdcall RtlFreeSid(long)
 +@ stdcall RtlFreeThreadActivationContextStack()
 +@ stdcall RtlFreeUnicodeString(ptr)
 +@ stdcall RtlFreeUserThreadStack(ptr ptr) ; 4.0 to 5.2 only
 +@ stdcall RtlGUIDFromString(ptr ptr)
 +@ stdcall RtlGenerate8dot3Name(ptr ptr long ptr)
 +@ stdcall RtlGetAce(ptr long ptr)
 +@ stdcall RtlGetActiveActivationContext(ptr)
 +@ stdcall RtlGetCallersAddress(ptr ptr)
 +@ stdcall RtlGetCompressionWorkSpaceSize(long ptr ptr)
 +@ stdcall RtlGetControlSecurityDescriptor(ptr ptr ptr)
 +@ stdcall RtlGetCriticalSectionRecursionCount(ptr)
 +@ stdcall RtlGetCurrentDirectory_U(long ptr)
 +@ stdcall RtlGetCurrentPeb()
 +@ stdcall RtlGetCurrentProcessorNumber() ; 5.2 SP1 and higher
 +@ 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)
 +@ stdcall RtlGetGroupSecurityDescriptor(ptr ptr ptr)
 +@ stdcall RtlGetLastNtStatus()
 +@ stdcall RtlGetLastWin32Error()
 +@ stdcall RtlGetLengthWithoutLastFullDosOrNtPathElement(long ptr ptr)
 +; Yes, Microsoft really misspelled this one!
 +@ 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)
 +@ stdcall RtlGetSetBootStatusData(ptr long long ptr long long)
 +@ stdcall RtlGetThreadErrorMode()
 +;@ stdcall RtlGetUnloadEventTrace
 +@ stdcall RtlGetUserInfoHeap(ptr long ptr ptr ptr)
 +@ stdcall RtlGetVersion(ptr)
 +@ stdcall RtlHashUnicodeString(ptr long long ptr)
 +@ stdcall RtlIdentifierAuthoritySid(ptr)
 +@ stdcall RtlImageDirectoryEntryToData(long long long ptr)
 +@ stdcall RtlImageNtHeader(long)
 +@ stdcall RtlImageNtHeaderEx(long ptr double ptr)
 +@ stdcall RtlImageRvaToSection(ptr long long)
 +@ stdcall RtlImageRvaToVa(ptr long long ptr)
 +@ stdcall RtlImpersonateSelf(long)
 +@ stdcall RtlInitAnsiString(ptr str)
 +@ stdcall RtlInitAnsiStringEx(ptr str)
 +@ stdcall RtlInitCodePageTable(ptr ptr)
 +@ stdcall RtlInitMemoryStream(ptr)
 +@ stdcall RtlInitNlsTables(ptr ptr ptr ptr)
 +@ stdcall RtlInitOutOfProcessMemoryStream(ptr)
 +@ stdcall RtlInitString(ptr str)
 +@ stdcall RtlInitUnicodeString(ptr wstr)
 +@ stdcall RtlInitUnicodeStringEx(ptr wstr)
 +;@ stdcall RtlInitializeAtomPackage
 +@ stdcall RtlInitializeBitMap(ptr long long)
 +@ 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)
 +@ stdcall -arch=x86_64 RtlInstallFunctionTableCallback(double double long ptr ptr ptr)
 +@ stdcall RtlInt64ToUnicodeString(double long ptr)
 +@ stdcall RtlIntegerToChar(long long long ptr)
 +@ stdcall RtlIntegerToUnicodeString(long long ptr)
 +@ stdcall -arch=win32 -ret64 RtlInterlockedCompareExchange64(ptr double double)
 +@ 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)
 +@ stdcall RtlIpv4AddressToStringW(ptr ptr)
 +@ stdcall RtlIpv4StringToAddressA(str long ptr ptr)
 +@ stdcall RtlIpv4StringToAddressExA(str long ptr ptr)
 +@ stdcall RtlIpv4StringToAddressExW(wstr long ptr ptr)
 +@ stdcall RtlIpv4StringToAddressW(wstr long ptr ptr)
 +@ stdcall RtlIpv6AddressToStringA(ptr ptr)
 +@ stdcall RtlIpv6AddressToStringExA(ptr long long ptr ptr)
 +@ stdcall RtlIpv6AddressToStringExW(ptr long long ptr ptr)
 +@ stdcall RtlIpv6AddressToStringW(ptr ptr)
 +@ stdcall RtlIpv6StringToAddressA(str ptr ptr)
 +@ stdcall RtlIpv6StringToAddressExA(str ptr ptr ptr)
 +@ stdcall RtlIpv6StringToAddressExW(wstr ptr ptr ptr)
 +@ stdcall RtlIpv6StringToAddressW(wstr ptr ptr)
 +@ stdcall RtlIsActivationContextActive(ptr)
 +;@ stdcall RtlIsCriticalSectionLocked
 +;@ stdcall RtlIsCriticalSectionLockedByThread
 +@ stdcall RtlIsDosDeviceName_U(wstr)
 +@ 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)
 +@ stdcall RtlIsValidIndexHandle(ptr long ptr)
 +@ stdcall -arch=win32 -ret64 RtlLargeIntegerAdd(double double)
 +@ stdcall -arch=win32 -ret64 RtlLargeIntegerArithmeticShift(double long)
 +@ stdcall -arch=win32 -ret64 RtlLargeIntegerDivide(double double ptr)
 +@ stdcall -arch=win32 -ret64 RtlLargeIntegerNegate(double)
 +@ stdcall -arch=win32 -ret64 RtlLargeIntegerShiftLeft(double long)
 +@ stdcall -arch=win32 -ret64 RtlLargeIntegerShiftRight(double long)
 +@ stdcall -arch=win32 -ret64 RtlLargeIntegerSubtract(double double)
 +@ stdcall RtlLargeIntegerToChar(ptr long long ptr)
 +@ stdcall RtlLeaveCriticalSection(ptr)
 +@ stdcall RtlLengthRequiredSid(long)
 +@ stdcall RtlLengthSecurityDescriptor(ptr)
 +@ stdcall RtlLengthSid(ptr)
 +@ stdcall RtlLocalTimeToSystemTime(ptr ptr)
 +@ stdcall RtlLockBootStatusData(ptr)
 +@ stdcall RtlLockHeap(long)
 +@ stdcall RtlLockMemoryStreamRegion(ptr int64 int64 long)
 +;@ stdcall RtlLogStackBackTrace
 +@ stdcall RtlLookupAtomInAtomTable(ptr wstr ptr)
 +@ stdcall RtlLookupElementGenericTable(ptr ptr)
 +@ stdcall RtlLookupElementGenericTableAvl(ptr ptr)
 +@ 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)
 +@ 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)
 +@ stdcall RtlNewSecurityObjectEx(ptr ptr ptr ptr long long ptr ptr)
 +@ stdcall RtlNewSecurityObjectWithMultipleInheritance(ptr ptr ptr ptr long long long ptr ptr)
 +@ stdcall RtlNormalizeProcessParams(ptr)
 +@ stdcall RtlNtPathNameToDosPathName(ptr ptr ptr ptr) ; CHECKME
 +@ stdcall RtlNtStatusToDosError(long)
 +@ stdcall RtlNtStatusToDosErrorNoTeb(long)
 +@ stdcall RtlNumberGenericTableElements(ptr)
 +@ stdcall RtlNumberGenericTableElementsAvl(ptr)
 +@ stdcall RtlNumberOfClearBits(ptr)
 +@ stdcall RtlNumberOfSetBits(ptr)
 +;@ stdcall RtlOemStringToUnicodeSize(ptr)
 +@ stdcall RtlOemStringToUnicodeString(ptr ptr long)
 +@ stdcall RtlOemToUnicodeN(ptr long ptr ptr long)
 +@ stdcall RtlOpenCurrentUser(long ptr)
 +@ stdcall RtlPcToFileHeader(ptr ptr)
 +@ stdcall RtlPinAtomInAtomTable(ptr long)
 +;@ 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)
 +@ stdcall RtlQueryDepthSList(ptr)
 +@ stdcall RtlQueryEnvironmentVariable_U(ptr ptr ptr)
 +@ stdcall RtlQueryHeapInformation(long long ptr long ptr)
 +@ stdcall RtlQueryInformationAcl(ptr ptr long long)
 +@ stdcall RtlQueryInformationActivationContext(long long ptr long ptr long ptr)
 +@ stdcall RtlQueryInformationActiveActivationContext(long ptr long ptr)
 +@ stdcall RtlQueryInterfaceMemoryStream(ptr ptr ptr)
 +;@ stdcall RtlQueryProcessBackTraceInformation
 +@ 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)
 +@ stdcall RtlQueryTimeZoneInformation(ptr)
 +;@ stdcall RtlQueueApcWow64Thread
 +@ stdcall RtlQueueWorkItem(ptr ptr long)
 +@ stdcall -register RtlRaiseException(ptr)
 +@ stdcall RtlRaiseStatus(long)
 +@ stdcall RtlRandom(ptr)
 +@ stdcall RtlRandomEx(ptr)
 +@ stdcall RtlReAllocateHeap(long long ptr long)
 +@ stdcall RtlReadMemoryStream(ptr ptr long ptr)
 +@ stdcall RtlReadOutOfProcessMemoryStream(ptr ptr long ptr)
 +@ stdcall RtlRealPredecessor(ptr)
 +@ stdcall RtlRealSuccessor(ptr)
 +@ stdcall RtlRegisterSecureMemoryCacheCallback(ptr)
 +@ stdcall RtlRegisterWait(ptr ptr ptr ptr long long)
 +@ stdcall RtlReleaseActivationContext(ptr)
 +@ stdcall RtlReleaseMemoryStream(ptr)
 +@ stdcall RtlReleasePebLock()
 +@ 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)
 +@ stdcall RtlResetRtlTranslations(ptr)
 +@ stdcall -arch=x86_64 RtlRestoreContext(ptr ptr)
 +@ stdcall RtlRestoreLastWin32Error(long) RtlSetLastWin32Error
 +@ stdcall RtlRevertMemoryStream(ptr)
 +@ stdcall RtlRunDecodeUnicodeString(long ptr)
 +@ stdcall RtlRunEncodeUnicodeString(long ptr)
 +@ stdcall RtlSecondsSince1970ToTime(long ptr)
 +@ stdcall RtlSecondsSince1980ToTime(long ptr)
 +@ stdcall RtlSeekMemoryStream(ptr int64 long ptr)
 +@ stdcall RtlSelfRelativeToAbsoluteSD2(ptr ptr)
 +@ stdcall RtlSelfRelativeToAbsoluteSD(ptr ptr ptr ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall RtlSetAllBits(ptr)
 +@ stdcall RtlSetAttributesSecurityDescriptor(ptr long ptr)
 +@ stdcall RtlSetBits(ptr long long)
 +@ stdcall RtlSetControlSecurityDescriptor(ptr long long)
 +@ stdcall RtlSetCriticalSectionSpinCount(ptr long)
 +@ stdcall RtlSetCurrentDirectory_U(ptr)
 +@ stdcall RtlSetCurrentEnvironment(wstr ptr)
 +@ stdcall RtlSetDaclSecurityDescriptor(ptr long ptr long)
 +@ stdcall RtlSetEnvironmentStrings(wstr long)
 +@ stdcall RtlSetEnvironmentVariable(ptr ptr ptr)
 +@ stdcall RtlSetGroupSecurityDescriptor(ptr ptr long)
 +@ stdcall RtlSetHeapInformation(ptr long ptr ptr)
 +@ stdcall RtlSetInformationAcl(ptr ptr long long)
 +@ stdcall RtlSetIoCompletionCallback(long ptr long)
 +@ stdcall RtlSetLastWin32Error(long)
 +@ stdcall RtlSetLastWin32ErrorAndNtStatusFromNtStatus(long)
 +@ 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)
 +@ stdcall RtlSetSecurityObjectEx(long ptr ptr long ptr ptr)
 +@ stdcall RtlSetThreadErrorMode(long ptr)
 +@ cdecl RtlSetThreadIsCritical(long ptr long)
 +@ stdcall RtlSetThreadPoolStartFunc(ptr ptr)
 +@ stdcall RtlSetTimeZoneInformation(ptr)
 +;@ stdcall RtlSetTimer
 +@ stdcall RtlSetUnhandledExceptionFilter(ptr)
 +;@ stdcall RtlSetUnicodeCallouts
 +@ 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)
 +@ stdcall RtlStringFromGUID(ptr ptr)
 +@ stdcall RtlSubAuthorityCountSid(ptr)
 +@ stdcall RtlSubAuthoritySid(ptr long)
 +@ stdcall RtlSubtreePredecessor(ptr)
 +@ stdcall RtlSubtreeSuccessor(ptr)
 +@ stdcall RtlSystemTimeToLocalTime(ptr ptr)
 +@ stdcall RtlTimeFieldsToTime(ptr ptr)
 +@ stdcall RtlTimeToElapsedTimeFields(long long)
 +@ stdcall RtlTimeToSecondsSince1970(ptr ptr)
 +@ stdcall RtlTimeToSecondsSince1980(ptr ptr)
 +@ stdcall RtlTimeToTimeFields (long long)
 +;@ stdcall RtlTraceDatabaseAdd
 +;@ stdcall RtlTraceDatabaseCreate
 +;@ stdcall RtlTraceDatabaseDestroy
 +;@ stdcall RtlTraceDatabaseEnumerate
 +;@ stdcall RtlTraceDatabaseFind
 +;@ stdcall RtlTraceDatabaseLock
 +;@ stdcall RtlTraceDatabaseUnlock
 +;@ stdcall RtlTraceDatabaseValidate
 +@ stdcall RtlTryEnterCriticalSection(ptr)
 +@ fastcall -arch=i386 RtlUlongByteSwap(long)
 +@ fastcall -ret64 RtlUlonglongByteSwap(double)
 +;@ stdcall RtlUnhandledExceptionFilter2
 +@ stdcall RtlUnhandledExceptionFilter(ptr)
 +;@ stdcall RtlUnicodeStringToAnsiSize(ptr)
 +@ stdcall RtlUnicodeStringToAnsiString(ptr ptr long)
 +@ stdcall RtlUnicodeStringToCountedOemString(ptr ptr long)
 +@ stdcall RtlUnicodeStringToInteger(ptr long ptr)
 +;@ stdcall RtlUnicodeStringToOemSize(ptr)
 +@ stdcall RtlUnicodeStringToOemString(ptr ptr long)
 +@ stdcall RtlUnicodeToCustomCPN(ptr ptr long ptr wstr long)
 +@ stdcall RtlUnicodeToMultiByteN(ptr long ptr ptr long)
 +@ stdcall RtlUnicodeToMultiByteSize(ptr ptr long)
 +@ stdcall RtlUnicodeToOemN(ptr long ptr ptr long)
 +@ stdcall RtlUniform(ptr)
 +@ stdcall RtlUnlockBootStatusData(ptr)
 +@ stdcall RtlUnlockHeap(long)
 +@ stdcall RtlUnlockMemoryStreamRegion(ptr int64 int64 long)
 +@ stdcall -register RtlUnwind(ptr ptr ptr ptr)
 +@ stdcall -arch=x86_64 RtlUnwindEx(long long ptr long ptr)
 +@ stdcall RtlUpcaseUnicodeChar(long)
 +@ stdcall RtlUpcaseUnicodeString(ptr ptr long)
 +@ stdcall RtlUpcaseUnicodeStringToAnsiString(ptr ptr long)
 +@ stdcall RtlUpcaseUnicodeStringToCountedOemString(ptr ptr long)
 +@ stdcall RtlUpcaseUnicodeStringToOemString(ptr ptr long)
 +@ stdcall RtlUpcaseUnicodeToCustomCPN(ptr ptr long ptr wstr long)
 +@ stdcall RtlUpcaseUnicodeToMultiByteN(ptr long ptr ptr long)
 +@ stdcall RtlUpcaseUnicodeToOemN(ptr long ptr ptr long)
 +@ stdcall RtlUpdateTimer(ptr ptr long long)
 +@ 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)
 +@ stdcall RtlValidSid(ptr)
 +@ stdcall RtlValidateHeap(long long ptr)
 +@ stdcall RtlValidateProcessHeaps()
 +@ stdcall RtlValidateUnicodeString(long ptr)
 +@ stdcall RtlVerifyVersionInfo(ptr long double)
 +@ stdcall -arch=x86_64 RtlVirtualUnwind(long long long ptr ptr ptr ptr ptr)
 +@ stdcall RtlWalkFrameChain(ptr long long)
 +@ 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)
 +@ stdcall RtlZeroMemory(ptr long)
 +@ stdcall RtlZombifyActivationContext(ptr)
 +@ stdcall RtlpApplyLengthFunction(long long ptr ptr)
 +@ stdcall RtlpEnsureBufferSize(ptr ptr ptr) ; CHECKME
 +;@ stdcall RtlpNotOwnerCriticalSection
 +@ stdcall RtlpNtCreateKey(ptr long ptr long ptr ptr)
 +@ stdcall RtlpNtEnumerateSubKey(ptr ptr long long)
 +@ stdcall RtlpNtMakeTemporaryKey(ptr)
 +@ stdcall RtlpNtOpenKey(ptr long ptr long)
 +@ stdcall RtlpNtQueryValueKey(ptr ptr ptr ptr long)
 +@ stdcall RtlpNtSetValueKey(ptr long ptr long)
 +@ stdcall RtlpUnWaitCriticalSection(ptr)
 +@ stdcall RtlpWaitForCriticalSection(ptr)
 +@ stdcall RtlxAnsiStringToUnicodeSize(ptr)
 +@ stdcall RtlxOemStringToUnicodeSize(ptr)
 +@ stdcall RtlxUnicodeStringToAnsiSize(ptr)
 +@ stdcall RtlxUnicodeStringToOemSize(ptr) ; RtlUnicodeStringToOemSize
 +@ stdcall -ret64 VerSetConditionMask(double long long)
 +@ stdcall ZwAcceptConnectPort(ptr long ptr long long ptr) NtAcceptConnectPort
 +@ stdcall ZwAccessCheck(ptr long long ptr ptr ptr ptr ptr) NtAccessCheck
 +@ stdcall ZwAccessCheckAndAuditAlarm(ptr long ptr ptr ptr long ptr long ptr ptr ptr) NtAccessCheckAndAuditAlarm
 +@ stdcall ZwAccessCheckByType(ptr ptr ptr long ptr long ptr ptr long ptr ptr) NtAccessCheckByType
 +@ stdcall ZwAccessCheckByTypeAndAuditAlarm(ptr ptr ptr ptr ptr ptr long long long ptr long ptr long ptr ptr ptr) NtAccessCheckByTypeAndAuditAlarm
 +@ stdcall ZwAccessCheckByTypeResultList(ptr ptr ptr long ptr long ptr ptr long ptr ptr) NtAccessCheckByTypeResultList
 +@ stdcall ZwAccessCheckByTypeResultListAndAuditAlarm(ptr ptr ptr ptr ptr ptr long long long ptr long ptr long ptr ptr ptr) NtAccessCheckByTypeResultListAndAuditAlarm
 +@ 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)
 +@ stdcall ZwAdjustGroupsToken(long long long long long long) NtAdjustGroupsToken
 +@ stdcall ZwAdjustPrivilegesToken(long long long long long long) NtAdjustPrivilegesToken
 +@ stdcall ZwAlertResumeThread(long ptr) NtAlertResumeThread
 +@ stdcall ZwAlertThread(long) NtAlertThread
 +@ stdcall ZwAllocateLocallyUniqueId(ptr) NtAllocateLocallyUniqueId
 +@ stdcall ZwAllocateUserPhysicalPages(ptr ptr ptr)
 +@ stdcall ZwAllocateUuids(ptr ptr ptr ptr) NtAllocateUuids
 +@ stdcall ZwAllocateVirtualMemory(long ptr ptr ptr long long) NtAllocateVirtualMemory
 +@ 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
 +@ stdcall ZwCloseObjectAuditAlarm(ptr ptr long)
 +@ stdcall ZwCompactKeys(long ptr) NtCompactKeys
 +@ stdcall ZwCompareTokens(ptr ptr ptr) NtCompareTokens
 +@ stdcall ZwCompleteConnectPort(ptr) NtCompleteConnectPort
 +@ stdcall ZwCompressKey(ptr) NtCompressKey
 +@ stdcall ZwConnectPort(ptr ptr ptr ptr ptr ptr ptr ptr) NtConnectPort
 +@ stdcall ZwContinue(ptr long) NtContinue
 +@ stdcall ZwCreateDebugObject(ptr long ptr long) NtCreateDebugObject
 +@ stdcall ZwCreateDirectoryObject(long long long) NtCreateDirectoryObject
 +@ stdcall ZwCreateEvent(long long long long long) NtCreateEvent
 +@ stdcall ZwCreateEventPair(ptr long ptr) NtCreateEventPair
 +@ stdcall ZwCreateFile(ptr long ptr ptr long long long ptr long long ptr) NtCreateFile
 +@ stdcall ZwCreateIoCompletion(ptr long ptr long) NtCreateIoCompletion
 +@ stdcall ZwCreateJobObject(ptr long ptr) NtCreateJobObject
 +@ stdcall ZwCreateJobSet(long ptr long) NtCreateJobSet
 +@ stdcall ZwCreateKey(ptr long ptr long ptr long long) NtCreateKey
 +@ stdcall ZwCreateKeyedEvent(ptr long ptr long) NtCreateKeyedEvent
 +@ stdcall ZwCreateMailslotFile(long long long long long long long long) NtCreateMailslotFile
 +@ stdcall ZwCreateMutant(ptr long ptr long) NtCreateMutant
 +@ stdcall ZwCreateNamedPipeFile(ptr long ptr ptr long long long long long long long long long ptr) NtCreateNamedPipeFile
 +@ stdcall ZwCreatePagingFile(long long long long) NtCreatePagingFile
 +@ stdcall ZwCreatePort(ptr ptr long long long) NtCreatePort
 +@ stdcall ZwCreateProcess(ptr long ptr ptr long ptr ptr ptr)
 +@ stdcall ZwCreateProcessEx(ptr long ptr ptr long ptr ptr ptr long) NtCreateProcessEx
 +@ stdcall ZwCreateProfile(ptr ptr ptr long long ptr long long long) NtCreateProfile ; CHECKME
 +@ stdcall ZwCreateSection(ptr long ptr ptr long long long) NtCreateSection
 +@ stdcall ZwCreateSemaphore(ptr long ptr long long) NtCreateSemaphore
 +@ stdcall ZwCreateSymbolicLinkObject(ptr long ptr ptr) NtCreateSymbolicLinkObject
 +@ stdcall ZwCreateThread(ptr long ptr ptr ptr ptr ptr long)
 +@ stdcall ZwCreateTimer(ptr long ptr long) NtCreateTimer
 +@ stdcall ZwCreateToken(ptr long ptr long ptr ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall ZwCreateWaitablePort(ptr ptr long long long) NtCreateWaitablePort
 +@ stdcall ZwDebugActiveProcess(ptr ptr) NtDebugActiveProcess
 +@ stdcall ZwDebugContinue(ptr ptr long) NtDebugContinue
 +@ stdcall ZwDelayExecution(long ptr) NtDelayExecution
 +@ stdcall ZwDeleteAtom(long) NtDeleteAtom
 +@ stdcall ZwDeleteBootEntry(long) NtDeleteBootEntry
 +@ stdcall ZwDeleteFile(ptr) NtDeleteFile
 +@ stdcall ZwDeleteKey(long) NtDeleteKey
 +@ stdcall ZwDeleteObjectAuditAlarm(ptr ptr long)
 +@ stdcall ZwDeleteValueKey(long ptr) NtDeleteValueKey
 +@ stdcall ZwDeviceIoControlFile(long long long long long long long long long long) NtDeviceIoControlFile
 +@ stdcall ZwDisplayString(ptr) NtDisplayString
 +@ 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
 +@ stdcall ZwEnumerateKey(long long long ptr long ptr) NtEnumerateKey
 +@ stdcall ZwEnumerateSystemEnvironmentValuesEx(long ptr long) NtEnumerateSystemEnvironmentValuesEx
 +@ stdcall ZwEnumerateValueKey(long long long ptr long ptr) NtEnumerateValueKey
 +@ stdcall ZwExtendSection(ptr ptr) NtExtendSection
 +@ stdcall ZwFilterToken(ptr long ptr ptr ptr ptr) NtFilterToken
 +@ stdcall ZwFindAtom(ptr long ptr) NtFindAtom
 +@ stdcall ZwFlushBuffersFile(long ptr) NtFlushBuffersFile
 +@ stdcall ZwFlushInstructionCache(long ptr long) NtFlushInstructionCache
 +@ stdcall ZwFlushKey(long) NtFlushKey
 +@ stdcall ZwFlushVirtualMemory(long ptr ptr long) NtFlushVirtualMemory
 +@ stdcall ZwFlushWriteBuffer()
 +@ stdcall ZwFreeUserPhysicalPages(ptr ptr ptr)
 +@ stdcall ZwFreeVirtualMemory(long ptr ptr long) NtFreeVirtualMemory
 +@ stdcall ZwFsControlFile(long long long long long long long long long long) NtFsControlFile
 +@ stdcall ZwGetContextThread(long ptr) NtGetContextThread
 +@ stdcall ZwGetCurrentProcessorNumber()
 +@ stdcall ZwGetDevicePowerState(ptr ptr)
 +@ stdcall ZwGetPlugPlayEvent(long long ptr long)
 +;@ stdcall ZwGetTickCount() NtGetTickCount
 +@ stdcall ZwGetWriteWatch(long long ptr long ptr ptr ptr) NtGetWriteWatch
 +@ stdcall ZwImpersonateAnonymousToken(ptr)
 +@ stdcall ZwImpersonateClientOfPort(ptr ptr) NtImpersonateClientOfPort
 +@ stdcall ZwImpersonateThread(ptr ptr ptr) NtImpersonateThread
 +@ stdcall ZwInitializeRegistry(long)
 +@ stdcall ZwInitiatePowerAction(long long long long) NtInitiatePowerAction
 +@ stdcall ZwIsProcessInJob(long long) NtIsProcessInJob
 +@ stdcall ZwIsSystemResumeAutomatic()
 +@ stdcall ZwListenPort(ptr ptr) NtListenPort
 +@ stdcall ZwLoadDriver(ptr) NtLoadDriver
 +@ stdcall ZwLoadKey2(ptr ptr long) NtLoadKey2
 +@ stdcall ZwLoadKey(ptr ptr) NtLoadKey
 +@ stdcall ZwLockFile(long long ptr ptr ptr ptr ptr ptr long long) NtLockFile
 +@ stdcall ZwLockProductActivationKeys(ptr ptr) NtLockProductActivationKeys
 +@ stdcall ZwLockRegistryKey(ptr) NtLockRegistryKey
 +@ stdcall ZwLockVirtualMemory(long ptr ptr long) NtLockVirtualMemory
 +@ stdcall ZwMakePermanentObject(ptr) NtMakePermanentObject
 +@ stdcall ZwMakeTemporaryObject(long) NtMakeTemporaryObject
 +@ stdcall ZwMapUserPhysicalPages(ptr ptr ptr)
 +@ stdcall ZwMapUserPhysicalPagesScatter(ptr ptr ptr)
 +@ stdcall ZwMapViewOfSection(long long ptr long long ptr ptr long long long) NtMapViewOfSection
 +@ stdcall ZwModifyBootEntry(ptr) NtModifyBootEntry
 +@ 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
 +@ stdcall ZwOpenDirectoryObject(long long long) NtOpenDirectoryObject
 +@ stdcall ZwOpenEvent(long long long) NtOpenEvent
 +@ stdcall ZwOpenEventPair(ptr long ptr) NtOpenEventPair
 +@ stdcall ZwOpenFile(ptr long ptr ptr long long) NtOpenFile
 +@ stdcall ZwOpenIoCompletion(ptr long ptr) NtOpenIoCompletion
 +@ stdcall ZwOpenJobObject(ptr long ptr) NtOpenJobObject
 +@ stdcall ZwOpenKey(ptr long ptr) NtOpenKey
 +@ stdcall ZwOpenKeyedEvent(ptr long ptr) NtOpenKeyedEvent
 +@ stdcall ZwOpenMutant(ptr long ptr) NtOpenMutant
 +@ stdcall ZwOpenObjectAuditAlarm(ptr ptr ptr ptr ptr ptr long long ptr long long ptr)
 +@ stdcall ZwOpenProcess(ptr long ptr ptr) NtOpenProcess
 +@ stdcall ZwOpenProcessToken(long long ptr) NtOpenProcessToken
 +@ stdcall ZwOpenProcessTokenEx(long long long ptr) NtOpenProcessTokenEx
 +@ stdcall ZwOpenSection(ptr long ptr) NtOpenSection
 +@ stdcall ZwOpenSemaphore(long long ptr) NtOpenSemaphore
 +@ stdcall ZwOpenSymbolicLinkObject (ptr long ptr) NtOpenSymbolicLinkObject
 +@ stdcall ZwOpenThread(ptr long ptr ptr) NtOpenThread
 +@ stdcall ZwOpenThreadToken(long long long ptr) NtOpenThreadToken
 +@ stdcall ZwOpenThreadTokenEx(long long long long ptr) NtOpenThreadTokenEx
 +@ stdcall ZwOpenTimer(ptr long ptr) NtOpenTimer
 +@ stdcall ZwPlugPlayControl(ptr ptr long)
 +@ stdcall ZwPowerInformation(long ptr long ptr long) NtPowerInformation
 +@ stdcall ZwPrivilegeCheck(ptr ptr ptr) NtPrivilegeCheck
 +@ stdcall ZwPrivilegeObjectAuditAlarm(ptr ptr ptr long ptr long)
 +@ stdcall ZwPrivilegedServiceAuditAlarm(ptr ptr ptr ptr long)
 +@ stdcall ZwProtectVirtualMemory(long ptr ptr long ptr) NtProtectVirtualMemory
 +@ stdcall ZwPulseEvent(long ptr) NtPulseEvent
 +@ stdcall ZwQueryAttributesFile(ptr ptr) NtQueryAttributesFile
 +@ stdcall ZwQueryBootEntryOrder(ptr ptr) NtQueryBootEntryOrder
 +@ stdcall ZwQueryBootOptions(ptr ptr) NtQueryBootOptions
 +@ stdcall ZwQueryDebugFilterState(long long) NtQueryDebugFilterState
 +@ stdcall ZwQueryDefaultLocale(long ptr) NtQueryDefaultLocale
 +@ 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
 +@ 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
 +@ stdcall ZwQueryInformationAtom(long long ptr long ptr) NtQueryInformationAtom
 +@ stdcall ZwQueryInformationFile(long ptr ptr long long) NtQueryInformationFile
 +@ stdcall ZwQueryInformationJobObject(long long ptr long ptr) NtQueryInformationJobObject
 +@ stdcall ZwQueryInformationPort(ptr long ptr long ptr) NtQueryInformationPort
 +@ stdcall ZwQueryInformationProcess(long long ptr long ptr) NtQueryInformationProcess
 +@ stdcall ZwQueryInformationThread(long long ptr long ptr) NtQueryInformationThread
 +@ stdcall ZwQueryInformationToken(long long ptr long ptr) NtQueryInformationToken
 +@ stdcall ZwQueryInstallUILanguage(ptr) NtQueryInstallUILanguage
 +@ stdcall ZwQueryIntervalProfile(long ptr) NtQueryIntervalProfile
 +@ stdcall ZwQueryIoCompletion(long long ptr long ptr) NtQueryIoCompletion
 +@ stdcall ZwQueryKey(long long ptr long ptr) NtQueryKey
 +@ stdcall ZwQueryMultipleValueKey(long ptr long ptr long ptr) NtQueryMultipleValueKey
 +@ stdcall ZwQueryMutant(long long ptr long ptr) NtQueryMutant
 +@ stdcall ZwQueryObject(long long long long long) NtQueryObject
 +@ stdcall ZwQueryOpenSubKeys(ptr ptr) NtQueryOpenSubKeys
 +@ stdcall ZwQueryPerformanceCounter (long long) NtQueryPerformanceCounter
 +@ stdcall ZwQueryPortInformationProcess() NtQueryPortInformationProcess
 +@ stdcall ZwQueryQuotaInformationFile(ptr ptr ptr long long ptr long ptr long) NtQueryQuotaInformationFile
 +@ stdcall ZwQuerySection (long long long long long) NtQuerySection
 +@ stdcall ZwQuerySecurityObject (long long long long long) NtQuerySecurityObject
 +@ stdcall ZwQuerySemaphore (long long long long long) NtQuerySemaphore
 +@ stdcall ZwQuerySymbolicLinkObject(long ptr ptr) NtQuerySymbolicLinkObject
 +@ stdcall ZwQuerySystemEnvironmentValue(ptr ptr long ptr) NtQuerySystemEnvironmentValue
 +@ stdcall ZwQuerySystemEnvironmentValueEx(ptr ptr ptr ptr ptr) NtQuerySystemEnvironmentValueEx
 +@ stdcall ZwQuerySystemInformation(long long long long) NtQuerySystemInformation
 +@ stdcall ZwQuerySystemTime(ptr) NtQuerySystemTime
 +@ stdcall ZwQueryTimer(ptr long ptr long ptr) NtQueryTimer
 +@ stdcall ZwQueryTimerResolution(long long long) NtQueryTimerResolution
 +@ stdcall ZwQueryValueKey(long ptr long ptr long ptr) NtQueryValueKey
 +@ stdcall ZwQueryVirtualMemory(long ptr long ptr long ptr) NtQueryVirtualMemory
 +@ stdcall ZwQueryVolumeInformationFile(long ptr ptr long long) NtQueryVolumeInformationFile
 +@ stdcall ZwQueueApcThread(long ptr long long long) NtQueueApcThread
 +@ stdcall ZwRaiseException(ptr ptr long) NtRaiseException
 +@ stdcall ZwRaiseHardError(long long long ptr long ptr) NtRaiseHardError
 +@ stdcall ZwReadFile(long long ptr ptr ptr ptr long ptr ptr) NtReadFile
 +@ 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
 +@ stdcall ZwRenameKey(ptr ptr) NtRenameKey
 +@ stdcall ZwReplaceKey(ptr long ptr) NtReplaceKey
 +@ stdcall ZwReplyPort(ptr ptr) NtReplyPort
 +@ stdcall ZwReplyWaitReceivePort(ptr ptr ptr ptr) NtReplyWaitReceivePort
 +@ stdcall ZwReplyWaitReceivePortEx(ptr ptr ptr ptr ptr)
 +@ stdcall ZwReplyWaitReplyPort(ptr ptr)
 +@ stdcall ZwRequestDeviceWakeup(ptr)
 +@ stdcall ZwRequestPort(ptr ptr)
 +@ stdcall ZwRequestWaitReplyPort(ptr ptr ptr)
 +@ stdcall ZwRequestWakeupLatency(long)
 +@ stdcall ZwResetEvent(long ptr)
 +@ stdcall ZwResetWriteWatch(long ptr long)
 +@ stdcall ZwRestoreKey(long long long)
 +@ stdcall ZwResumeProcess(ptr)
 +@ stdcall ZwResumeThread(long long)
 +@ stdcall ZwSaveKey(long long)
 +@ stdcall ZwSaveKeyEx(ptr ptr long)
 +@ stdcall ZwSaveMergedKeys(ptr ptr ptr)
 +@ stdcall ZwSecureConnectPort(ptr ptr ptr ptr ptr ptr ptr ptr ptr)
 +@ stdcall ZwSetBootEntryOrder(ptr ptr)
 +@ stdcall ZwSetBootOptions(ptr long)
 +@ stdcall ZwSetContextThread(long ptr)
 +@ stdcall ZwSetDebugFilterState(long long long)
 +@ stdcall ZwSetDefaultHardErrorPort(ptr)
 +@ stdcall ZwSetDefaultLocale(long long)
 +@ stdcall ZwSetDefaultUILanguage(long)
 +@ 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)
 +@ stdcall ZwSetInformationKey(long long ptr long)
 +@ stdcall ZwSetInformationObject(long long ptr long)
 +@ stdcall ZwSetInformationProcess(long long long long)
 +@ stdcall ZwSetInformationThread(long long ptr long)
 +@ stdcall ZwSetInformationToken(long long ptr long)
 +@ stdcall ZwSetIntervalProfile(long long)
 +@ stdcall ZwSetIoCompletion(ptr long ptr long long)
 +@ 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)
 +@ stdcall ZwSetSystemEnvironmentValueEx(ptr ptr)
 +@ stdcall ZwSetSystemInformation(long ptr long)
 +@ stdcall ZwSetSystemPowerState(long long long)
 +@ stdcall ZwSetSystemTime(ptr ptr)
 +@ stdcall ZwSetThreadExecutionState(long ptr)
 +@ stdcall ZwSetTimer(long ptr ptr ptr long long ptr)
 +@ stdcall ZwSetTimerResolution(long long ptr)
 +@ stdcall ZwSetUuidSeed(ptr)
 +@ stdcall ZwSetValueKey(long long long long long long)
 +@ stdcall ZwSetVolumeInformationFile(long ptr ptr long long)
 +@ stdcall ZwShutdownSystem(long)
 +@ stdcall ZwSignalAndWaitForSingleObject(long long long ptr)
 +@ stdcall ZwStartProfile(ptr)
 +@ stdcall ZwStopProfile(ptr)
 +@ stdcall ZwSuspendProcess(ptr)
 +@ stdcall ZwSuspendThread(long ptr)
 +@ stdcall ZwSystemDebugControl(long ptr long ptr long ptr)
 +@ stdcall ZwTerminateJobObject(long long)
 +@ stdcall ZwTerminateProcess(long long)
 +@ stdcall ZwTerminateThread(long long)
 +@ stdcall ZwTestAlert()
 +@ stdcall ZwTraceEvent(long long long ptr)
 +@ stdcall ZwTranslateFilePath(ptr long ptr long)
 +@ stdcall ZwUnloadDriver(ptr)
 +@ 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)
 +@ stdcall ZwWaitForMultipleObjects(long ptr long long ptr)
 +;@ stdcall ZwWaitForProcessMutant ; 3.51 only
 +@ stdcall ZwWaitForSingleObject(long long long)
 +@ stdcall ZwWaitHighEventPair(ptr)
 +@ stdcall ZwWaitLowEventPair(ptr)
 +@ stdcall ZwWriteFile(long long ptr ptr ptr ptr long ptr ptr)
 +@ stdcall ZwWriteFileGather(long long ptr ptr ptr ptr long ptr ptr)
 +@ stdcall ZwWriteRequestData(ptr ptr long ptr long ptr)
 +@ stdcall ZwWriteVirtualMemory(long ptr ptr long ptr)
 +@ stdcall ZwYieldExecution()
 +@ cdecl -arch=i386 _CIcos()
 +@ cdecl -arch=i386 _CIlog()
 +@ cdecl -arch=i386 _CIpow()
 +@ cdecl -arch=i386 _CIsin()
 +@ cdecl -arch=i386 _CIsqrt()
 +@ cdecl -arch=x86_64 __C_specific_handler(ptr long ptr ptr)
 +@ cdecl __isascii(long)
 +@ cdecl __iscsym(long)
 +@ cdecl __iscsymf(long)
 +@ cdecl __toascii(long)
 +@ cdecl -arch=i386 -ret64 _alldiv(double double)
 +@ cdecl -arch=i386 _alldvrm()
 +@ cdecl -arch=i386 -ret64 _allmul(double double)
 +@ cdecl -arch=i386 -norelay _alloca_probe()
 +@ cdecl -arch=i386 -ret64 _allrem(double double)
 +@ cdecl -arch=i386 _allshl()
 +@ cdecl -arch=i386 _allshr()
 +@ cdecl -ret64 _atoi64(str)
 +@ cdecl -arch=i386 -ret64 _aulldiv(double double)
 +@ cdecl -arch=i386 _aulldvrm()
 +@ cdecl -arch=i386 -ret64 _aullrem(double double)
 +@ cdecl -arch=i386 _aullshr()
 +@ extern -arch=i386 _chkstk
 +@ cdecl -arch=i386,x86_64 _fltused()
 +@ cdecl -arch=i386 -ret64 _ftol()
 +@ cdecl _i64toa(double ptr long)
 +@ cdecl _i64tow(double ptr long)
 +@ cdecl _itoa(long ptr long)
 +@ cdecl _itow(long ptr long)
 +@ cdecl _lfind(ptr ptr ptr long ptr)
 +@ cdecl -arch=x86_64 _local_unwind()
 +@ cdecl _ltoa(long ptr long)
 +@ cdecl _ltow(long ptr long)
 +@ cdecl _memccpy(ptr ptr long long)
 +@ cdecl _memicmp(str str long)
 +@ cdecl -arch=x86_64 _setjmp(ptr ptr)
 +@ cdecl -arch=x86_64 _setjmpex(ptr ptr)
 +@ varargs _snprintf(ptr long str)
 +@ varargs _snwprintf(ptr long wstr)
 +@ cdecl _splitpath(str ptr ptr ptr ptr)
 +@ cdecl _strcmpi(str str) _stricmp
 +@ cdecl _stricmp(str str)
 +@ cdecl _strlwr(str)
 +@ cdecl _strnicmp(str str long)
 +@ cdecl _strupr(str)
 +@ cdecl _tolower(long)
 +@ cdecl _toupper(long)
 +@ cdecl _ui64toa(double ptr long)
 +@ cdecl _ui64tow(double ptr long)
 +@ cdecl _ultoa(long ptr long)
 +@ cdecl _ultow(long ptr long)
 +@ cdecl _vscwprintf(wstr ptr)
 +@ cdecl _vsnprintf(ptr long str ptr)
 +@ cdecl _vsnwprintf(ptr long wstr ptr)
 +@ cdecl _wcsicmp(wstr wstr)
 +@ cdecl _wcslwr(wstr)
 +@ cdecl _wcsnicmp(wstr wstr long)
 +@ cdecl _wcsupr(wstr)
 +@ cdecl _wtoi(wstr)
 +@ cdecl _wtoi64(wstr)
 +@ cdecl _wtol(wstr)
 +@ cdecl abs(long)
 +@ cdecl -arch=i386,x86_64 atan(double)
 +@ cdecl atoi(str)
 +@ cdecl atol(str)
 +@ cdecl bsearch(ptr ptr long long ptr)
 +@ cdecl -arch=i386,x86_64 ceil(double)
 +@ cdecl -arch=i386,x86_64 cos(double)
 +@ cdecl -arch=i386,x86_64 fabs(double)
 +@ cdecl -arch=i386,x86_64 floor(double)
 +@ cdecl isalnum(long)
 +@ cdecl isalpha(long)
 +@ cdecl iscntrl(long)
 +@ cdecl isdigit(long)
 +@ cdecl isgraph(long)
 +@ cdecl islower(long)
 +@ cdecl isprint(long)
 +@ cdecl ispunct(long)
 +@ cdecl isspace(long)
 +@ cdecl isupper(long)
 +@ cdecl iswalpha(long)
 +@ cdecl iswctype(long long)
 +@ cdecl iswdigit(long)
 +@ cdecl iswlower(long)
 +@ cdecl iswspace(long)
 +@ cdecl iswxdigit(long)
 +@ cdecl isxdigit(long)
 +@ cdecl labs(long)
 +@ cdecl -arch=i386,x86_64 log(double)
 +@ cdecl -arch=x86_64 longjmp(ptr)
 +@ cdecl mbstowcs(ptr str long)
 +@ cdecl memchr(ptr long long)
 +@ cdecl memcmp(ptr ptr long)
 +@ cdecl memcpy(ptr ptr long) memmove
 +@ cdecl memmove(ptr ptr long)
 +@ cdecl memset(ptr long long)
 +@ cdecl -arch=i386,x86_64 pow(double double)
 +@ cdecl qsort(ptr long long ptr)
 +@ cdecl -arch=i386,x86_64 sin(double)
 +@ varargs sprintf(ptr str)
 +@ cdecl -arch=i386,x86_64 sqrt(double)
 +@ varargs sscanf(str str)
 +@ cdecl strcat(str str)
 +@ cdecl strchr(str long)
 +@ cdecl strcmp(str str)
 +@ cdecl strcpy(ptr str)
 +@ cdecl strcspn(str str)
 +@ cdecl strlen(str)
 +@ cdecl strncat(str str long)
 +@ cdecl strncmp(str str long)
 +@ cdecl strncpy(ptr str long)
 +@ cdecl strpbrk(str str)
 +@ cdecl strrchr(str long)
 +@ cdecl strspn(str str)
 +@ cdecl strstr(str str)
 +@ cdecl strtol(str ptr long)
 +@ cdecl strtoul(str ptr long)
 +@ varargs swprintf(ptr wstr)
 +@ cdecl -arch=i386,x86_64 tan(double)
 +@ cdecl tolower(long)
 +@ cdecl toupper(long)
 +@ cdecl towlower(long)
 +@ cdecl towupper(long)
 +@ stdcall vDbgPrintEx(long long str ptr)
 +@ stdcall vDbgPrintExWithPrefix(str long long str ptr)
 +@ cdecl vsprintf(ptr str ptr)
 +@ cdecl wcscat(wstr wstr)
 +@ cdecl wcschr(wstr long)
 +@ cdecl wcscmp(wstr wstr)
 +@ cdecl wcscpy(ptr wstr)
 +@ cdecl wcscspn(wstr wstr)
 +@ cdecl wcslen(wstr)
 +@ cdecl wcsncat(wstr wstr long)
 +@ cdecl wcsncmp(wstr wstr long)
 +@ cdecl wcsncpy(ptr wstr long)
 +@ cdecl wcspbrk(wstr wstr)
 +@ 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)
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 7eb91a9,0000000..c1a73d1
mode 100644,000000..100644
--- /dev/null
@@@ -1,188 -1,0 +1,192 @@@
- /* synched with wine 1.1.26 */
 +/*
 + * COPYRIGHT:       See COPYING in the top level directory
 + * PROJECT:         ReactOS system libraries
 + * FILE:            dll/win32/kernel32/wine/actctx.c
 + * PURPOSE:         Activation contexts
 + * PROGRAMMERS:     Jacek Caban for CodeWeavers
 + *                  Eric Pouech
 + *                  Jon Griffiths
 + *                  Dmitry Chapyshev (dmitry@reactos.org)
 + *                  Samuel Serapión 
 + */
 +
-   FIXME("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
-        ulId, debugstr_guid(lpSearchGuid), pInfo);
-   SetLastError( ERROR_CALL_NOT_IMPLEMENTED);
-   return FALSE;
- }
++/* Partly synched with Wine 1.7.17 */
 +
 +#include <k32.h>
 +
 +#define NDEBUG
 +#include <debug.h>
 +DEBUG_CHANNEL(actctx);
 +
 +#define ACTCTX_FAKE_HANDLE ((HANDLE) 0xf00baa)
 +
 +/***********************************************************************
 + * CreateActCtxA (KERNEL32.@)
 + *
 + * Create an activation context.
 + */
 +HANDLE WINAPI CreateActCtxA(PCACTCTXA pActCtx)
 +{
 +    ACTCTXW     actw;
 +    SIZE_T      len;
 +    HANDLE      ret = INVALID_HANDLE_VALUE;
 +    LPWSTR      src = NULL, assdir = NULL, resname = NULL, appname = NULL;
 +
 +    TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
 +
 +    if (!pActCtx || pActCtx->cbSize != sizeof(*pActCtx))
 +    {
 +        SetLastError(ERROR_INVALID_PARAMETER);
 +        return INVALID_HANDLE_VALUE;
 +    }
 +
 +    actw.cbSize = sizeof(actw);
 +    actw.dwFlags = pActCtx->dwFlags;
 +    if (pActCtx->lpSource)
 +    {
 +        len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpSource, -1, NULL, 0);
 +        src = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 +        if (!src) return INVALID_HANDLE_VALUE;
 +        MultiByteToWideChar(CP_ACP, 0, pActCtx->lpSource, -1, src, len);
 +    }
 +    actw.lpSource = src;
 +
 +    if (actw.dwFlags & ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID)
 +        actw.wProcessorArchitecture = pActCtx->wProcessorArchitecture;
 +    if (actw.dwFlags & ACTCTX_FLAG_LANGID_VALID)
 +        actw.wLangId = pActCtx->wLangId;
 +    if (actw.dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID)
 +    {
 +        len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpAssemblyDirectory, -1, NULL, 0);
 +        assdir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 +        if (!assdir) goto done;
 +        MultiByteToWideChar(CP_ACP, 0, pActCtx->lpAssemblyDirectory, -1, assdir, len);
 +        actw.lpAssemblyDirectory = assdir;
 +    }
 +    if (actw.dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
 +    {
 +        if ((ULONG_PTR)pActCtx->lpResourceName >> 16)
 +        {
 +            len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpResourceName, -1, NULL, 0);
 +            resname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 +            if (!resname) goto done;
 +            MultiByteToWideChar(CP_ACP, 0, pActCtx->lpResourceName, -1, resname, len);
 +            actw.lpResourceName = resname;
 +        }
 +        else actw.lpResourceName = (LPCWSTR)pActCtx->lpResourceName;
 +    }
 +    if (actw.dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
 +    {
 +        len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpApplicationName, -1, NULL, 0);
 +        appname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 +        if (!appname) goto done;
 +        MultiByteToWideChar(CP_ACP, 0, pActCtx->lpApplicationName, -1, appname, len);
 +        actw.lpApplicationName = appname;
 +    }
 +    if (actw.dwFlags & ACTCTX_FLAG_HMODULE_VALID)
 +        actw.hModule = pActCtx->hModule;
 +
 +    ret = CreateActCtxW(&actw);
 +
 +done:
 +    HeapFree(GetProcessHeap(), 0, src);
 +    HeapFree(GetProcessHeap(), 0, assdir);
 +    HeapFree(GetProcessHeap(), 0, resname);
 +    HeapFree(GetProcessHeap(), 0, appname);
 +    return ret;
 +}
 +
 +/***********************************************************************
 + * CreateActCtxW (KERNEL32.@)
 + *
 + * Create an activation context.
 + */
 +HANDLE WINAPI CreateActCtxW(PCACTCTXW pActCtx)
 +{
 +    NTSTATUS    status;
 +    HANDLE      hActCtx;
 +
 +    TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
 +
 +    if ((status = RtlCreateActivationContext(0, (PVOID)pActCtx, 0, NULL, NULL, &hActCtx)))
 +    {
 +        SetLastError(RtlNtStatusToDosError(status));
 +        return INVALID_HANDLE_VALUE;
 +    }
 +    return hActCtx;
 +}
 +
 +/***********************************************************************
 + * FindActCtxSectionStringA (KERNEL32.@)
 + *
 + * Find information about a string in an activation context.
 + */
 +BOOL WINAPI FindActCtxSectionStringA(DWORD dwFlags, const GUID* lpExtGuid,
 +                                    ULONG ulId, LPCSTR lpSearchStr,
 +                                    PACTCTX_SECTION_KEYED_DATA pInfo)
 +{
 +    LPWSTR  search_str;
 +    DWORD   len;
 +    BOOL    ret;
 +
 +    TRACE("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
 +          ulId, debugstr_a(lpSearchStr), pInfo);
 +
 +    if (!lpSearchStr)
 +    {
 +        SetLastError(ERROR_INVALID_PARAMETER);
 +        return FALSE;
 +    }
 +
 +    len = MultiByteToWideChar(CP_ACP, 0, lpSearchStr, -1, NULL, 0);
 +    search_str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 +    MultiByteToWideChar(CP_ACP, 0, lpSearchStr, -1, search_str, len);
 +
 +    ret = FindActCtxSectionStringW(dwFlags, lpExtGuid, ulId, search_str, pInfo);
 +
 +    HeapFree(GetProcessHeap(), 0, search_str);
 +    return ret;
 +}
 +
 +/***********************************************************************
 + * FindActCtxSectionStringW (KERNEL32.@)
 + *
 + * Find information about a string in an activation context.
 + */
 +BOOL WINAPI FindActCtxSectionStringW(DWORD dwFlags, const GUID* lpExtGuid,
 +                                    ULONG ulId, LPCWSTR lpSearchStr,
 +                                    PACTCTX_SECTION_KEYED_DATA pInfo)
 +{
 +    UNICODE_STRING us;
 +    NTSTATUS status;
 +
 +    RtlInitUnicodeString(&us, lpSearchStr);
 +    if ((status = RtlFindActivationContextSectionString(dwFlags, lpExtGuid, ulId, &us, pInfo)))
 +    {
 +        SetLastError(RtlNtStatusToDosError(status));
 +        return FALSE;
 +    }
 +    return TRUE;
 +}
 +
 +/***********************************************************************
 + * FindActCtxSectionGuid (KERNEL32.@)
 + *
 + * Find information about a GUID in an activation context.
 + */
 +BOOL WINAPI FindActCtxSectionGuid(DWORD dwFlags, const GUID* lpExtGuid,
 +                                  ULONG ulId, const GUID* lpSearchGuid,
 +                                  PACTCTX_SECTION_KEYED_DATA pInfo)
 +{
++    NTSTATUS status;
 +
++    if ((status = RtlFindActivationContextSectionGuid(dwFlags, lpExtGuid, ulId, lpSearchGuid, pInfo)))
++    {
++        SetLastError(RtlNtStatusToDosError(status));
++        return FALSE;
++    }
++
++    return TRUE;
++}
 +
 +/* EOF */
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 46eb8d9,0000000..c0589ac
mode 100644,000000..100644
--- /dev/null
@@@ -1,4333 -1,0 +1,4333 @@@
-   if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
 +/*
 + * Path Functions
 + *
 + * Copyright 1999, 2000 Juergen Schmied
 + * Copyright 2001, 2002 Jon Griffiths
 + *
 + * This library is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * This library is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with this library; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 + */
 +
 +#include "precomp.h"
 +
 +/* Get a function pointer from a DLL handle */
 +#define GET_FUNC(func, module, name, fail) \
 +  do { \
 +    if (!func) { \
 +      if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
 +      func = (fn##func)GetProcAddress(SHLWAPI_h##module, name); \
 +      if (!func) return fail; \
 +    } \
 +  } while (0)
 +
 +/* DLL handles for late bound calls */
 +static HMODULE SHLWAPI_hshell32;
 +
 +/* Function pointers for GET_FUNC macro; these need to be global because of gcc bug */
 +typedef BOOL (WINAPI *fnpIsNetDrive)(int);
 +static  fnpIsNetDrive pIsNetDrive;
 +
 +HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR,LPWSTR,DWORD);
 +
 +static inline WCHAR* heap_strdupAtoW(LPCSTR str)
 +{
 +    WCHAR *ret = NULL;
 +
 +    if (str)
 +    {
 +        DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 +        ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 +        if (ret)
 +            MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 +    }
 +
 +    return ret;
 +}
 +
 +/*************************************************************************
 + * PathAppendA    [SHLWAPI.@]
 + *
 + * Append one path to another.
 + *
 + * PARAMS
 + *  lpszPath   [I/O] Initial part of path, and destination for output
 + *  lpszAppend [I]   Path to append
 + *
 + * RETURNS
 + *  Success: TRUE. lpszPath contains the newly created path.
 + *  Failure: FALSE, if either path is NULL, or PathCombineA() fails.
 + *
 + * NOTES
 + *  lpszAppend must contain at least one backslash ('\') if not NULL.
 + *  Because PathCombineA() is used to join the paths, the resulting
 + *  path is also canonicalized.
 + */
 +BOOL WINAPI PathAppendA (LPSTR lpszPath, LPCSTR lpszAppend)
 +{
 +  TRACE("(%s,%s)\n",debugstr_a(lpszPath), debugstr_a(lpszAppend));
 +
 +  if (lpszPath && lpszAppend)
 +  {
 +    if (!PathIsUNCA(lpszAppend))
 +      while (*lpszAppend == '\\')
 +        lpszAppend++;
 +    if (PathCombineA(lpszPath, lpszPath, lpszAppend))
 +      return TRUE;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathAppendW    [SHLWAPI.@]
 + *
 + * See PathAppendA.
 + */
 +BOOL WINAPI PathAppendW(LPWSTR lpszPath, LPCWSTR lpszAppend)
 +{
 +  TRACE("(%s,%s)\n",debugstr_w(lpszPath), debugstr_w(lpszAppend));
 +
 +  if (lpszPath && lpszAppend)
 +  {
 +    if (!PathIsUNCW(lpszAppend))
 +      while (*lpszAppend == '\\')
 +        lpszAppend++;
 +    if (PathCombineW(lpszPath, lpszPath, lpszAppend))
 +      return TRUE;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathCombineA               [SHLWAPI.@]
 + *
 + * Combine two paths together.
 + *
 + * PARAMS
 + *  lpszDest [O] Destination for combined path
 + *  lpszDir  [I] Directory path
 + *  lpszFile [I] File path
 + *
 + * RETURNS
 + *  Success: The output path
 + *  Failure: NULL, if inputs are invalid.
 + *
 + * NOTES
 + *  lpszDest should be at least MAX_PATH in size, and may point to the same
 + *  memory location as lpszDir. The combined path is canonicalised.
 + */
 +LPSTR WINAPI PathCombineA(LPSTR lpszDest, LPCSTR lpszDir, LPCSTR lpszFile)
 +{
 +  WCHAR szDest[MAX_PATH];
 +  WCHAR szDir[MAX_PATH];
 +  WCHAR szFile[MAX_PATH];
 +  TRACE("(%p,%s,%s)\n", lpszDest, debugstr_a(lpszDir), debugstr_a(lpszFile));
 +
 +  /* Invalid parameters */
 +  if (!lpszDest)
 +    return NULL;
 +  if (!lpszDir && !lpszFile)
 +  {
 +    lpszDest[0] = 0;
 +    return NULL;
 +  }
 +
 +  if (lpszDir)
 +    MultiByteToWideChar(CP_ACP,0,lpszDir,-1,szDir,MAX_PATH);
 +  if (lpszFile)
 +    MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
 +
 +  if (PathCombineW(szDest, lpszDir ? szDir : NULL, lpszFile ? szFile : NULL))
 +    if (WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0))
 +      return lpszDest;
 +
 +  lpszDest[0] = 0;
 +  return NULL;
 +}
 +
 +/*************************************************************************
 + * PathCombineW                [SHLWAPI.@]
 + *
 + * See PathCombineA.
 + */
 +LPWSTR WINAPI PathCombineW(LPWSTR lpszDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
 +{
 +  WCHAR szTemp[MAX_PATH];
 +  BOOL bUseBoth = FALSE, bStrip = FALSE;
 +
 +  TRACE("(%p,%s,%s)\n", lpszDest, debugstr_w(lpszDir), debugstr_w(lpszFile));
 +
 +  /* Invalid parameters */
 +  if (!lpszDest)
 +    return NULL;
 +  if (!lpszDir && !lpszFile)
 +  {
 +    lpszDest[0] = 0;
 +    return NULL;
 +  }
 +
 +  if ((!lpszFile || !*lpszFile) && lpszDir)
 +  {
 +    /* Use dir only */
 +    lstrcpynW(szTemp, lpszDir, MAX_PATH);
 +  }
 +  else if (!lpszDir || !*lpszDir || !PathIsRelativeW(lpszFile))
 +  {
 +    if (!lpszDir || !*lpszDir || *lpszFile != '\\' || PathIsUNCW(lpszFile))
 +    {
 +      /* Use file only */
 +      lstrcpynW(szTemp, lpszFile, MAX_PATH);
 +    }
 +    else
 +    {
 +      bUseBoth = TRUE;
 +      bStrip = TRUE;
 +    }
 +  }
 +  else
 +    bUseBoth = TRUE;
 +
 +  if (bUseBoth)
 +  {
 +    lstrcpynW(szTemp, lpszDir, MAX_PATH);
 +    if (bStrip)
 +    {
 +      PathStripToRootW(szTemp);
 +      lpszFile++; /* Skip '\' */
 +    }
 +    if (!PathAddBackslashW(szTemp) || strlenW(szTemp) + strlenW(lpszFile) >= MAX_PATH)
 +    {
 +      lpszDest[0] = 0;
 +      return NULL;
 +    }
 +    strcatW(szTemp, lpszFile);
 +  }
 +
 +  PathCanonicalizeW(lpszDest, szTemp);
 +  return lpszDest;
 +}
 +
 +/*************************************************************************
 + * PathAddBackslashA  [SHLWAPI.@]
 + *
 + * Append a backslash ('\') to a path if one doesn't exist.
 + *
 + * PARAMS
 + *  lpszPath [I/O] The path to append a backslash to.
 + *
 + * RETURNS
 + *  Success: The position of the last backslash in the path.
 + *  Failure: NULL, if lpszPath is NULL or the path is too large.
 + */
 +LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
 +{
 +  size_t iLen;
 +  LPSTR prev = lpszPath;
 +
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (!lpszPath || (iLen = strlen(lpszPath)) >= MAX_PATH)
 +    return NULL;
 +
 +  if (iLen)
 +  {
 +    do {
 +      lpszPath = CharNextA(prev);
 +      if (*lpszPath)
 +        prev = lpszPath;
 +    } while (*lpszPath);
 +    if (*prev != '\\')
 +    {
 +      *lpszPath++ = '\\';
 +      *lpszPath = '\0';
 +    }
 +  }
 +  return lpszPath;
 +}
 +
 +/*************************************************************************
 + * PathAddBackslashW  [SHLWAPI.@]
 + *
 + * See PathAddBackslashA.
 + */
 +LPWSTR WINAPI PathAddBackslashW( LPWSTR lpszPath )
 +{
 +  size_t iLen;
 +
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (!lpszPath || (iLen = strlenW(lpszPath)) >= MAX_PATH)
 +    return NULL;
 +
 +  if (iLen)
 +  {
 +    lpszPath += iLen;
 +    if (lpszPath[-1] != '\\')
 +    {
 +      *lpszPath++ = '\\';
 +      *lpszPath = '\0';
 +    }
 +  }
 +  return lpszPath;
 +}
 +
 +/*************************************************************************
 + * PathBuildRootA    [SHLWAPI.@]
 + *
 + * Create a root drive string (e.g. "A:\") from a drive number.
 + *
 + * PARAMS
 + *  lpszPath [O] Destination for the drive string
 + *
 + * RETURNS
 + *  lpszPath
 + *
 + * NOTES
 + *  If lpszPath is NULL or drive is invalid, nothing is written to lpszPath.
 + */
 +LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
 +{
 +  TRACE("(%p,%d)\n", lpszPath, drive);
 +
 +  if (lpszPath && drive >= 0 && drive < 26)
 +  {
 +    lpszPath[0] = 'A' + drive;
 +    lpszPath[1] = ':';
 +    lpszPath[2] = '\\';
 +    lpszPath[3] = '\0';
 +  }
 +  return lpszPath;
 +}
 +
 +/*************************************************************************
 + * PathBuildRootW    [SHLWAPI.@]
 + *
 + * See PathBuildRootA.
 + */
 +LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
 +{
 +  TRACE("(%p,%d)\n", lpszPath, drive);
 +
 +  if (lpszPath && drive >= 0 && drive < 26)
 +  {
 +    lpszPath[0] = 'A' + drive;
 +    lpszPath[1] = ':';
 +    lpszPath[2] = '\\';
 +    lpszPath[3] = '\0';
 +  }
 +  return lpszPath;
 +}
 +
 +/*************************************************************************
 + * PathFindFileNameA  [SHLWAPI.@]
 + *
 + * Locate the start of the file name in a path
 + *
 + * PARAMS
 + *  lpszPath [I] Path to search
 + *
 + * RETURNS
 + *  A pointer to the first character of the file name
 + */
 +LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
 +{
 +  LPCSTR lastSlash = lpszPath;
 +
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  while (lpszPath && *lpszPath)
 +  {
 +    if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
 +        lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
 +      lastSlash = lpszPath + 1;
 +    lpszPath = CharNextA(lpszPath);
 +  }
 +  return (LPSTR)lastSlash;
 +}
 +
 +/*************************************************************************
 + * PathFindFileNameW  [SHLWAPI.@]
 + *
 + * See PathFindFileNameA.
 + */
 +LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
 +{
 +  LPCWSTR lastSlash = lpszPath;
 +
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  while (lpszPath && *lpszPath)
 +  {
 +    if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
 +        lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
 +      lastSlash = lpszPath + 1;
 +    lpszPath++;
 +  }
 +  return (LPWSTR)lastSlash;
 +}
 +
 +/*************************************************************************
 + * PathFindExtensionA  [SHLWAPI.@]
 + *
 + * Locate the start of the file extension in a path
 + *
 + * PARAMS
 + *  lpszPath [I] The path to search
 + *
 + * RETURNS
 + *  A pointer to the first character of the extension, the end of
 + *  the string if the path has no extension, or NULL If lpszPath is NULL
 + */
 +LPSTR WINAPI PathFindExtensionA( LPCSTR lpszPath )
 +{
 +  LPCSTR lastpoint = NULL;
 +
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    while (*lpszPath)
 +    {
 +      if (*lpszPath == '\\' || *lpszPath==' ')
 +        lastpoint = NULL;
 +      else if (*lpszPath == '.')
 +        lastpoint = lpszPath;
 +      lpszPath = CharNextA(lpszPath);
 +    }
 +  }
 +  return (LPSTR)(lastpoint ? lastpoint : lpszPath);
 +}
 +
 +/*************************************************************************
 + * PathFindExtensionW  [SHLWAPI.@]
 + *
 + * See PathFindExtensionA.
 + */
 +LPWSTR WINAPI PathFindExtensionW( LPCWSTR lpszPath )
 +{
 +  LPCWSTR lastpoint = NULL;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    while (*lpszPath)
 +    {
 +      if (*lpszPath == '\\' || *lpszPath==' ')
 +        lastpoint = NULL;
 +      else if (*lpszPath == '.')
 +        lastpoint = lpszPath;
 +      lpszPath++;
 +    }
 +  }
 +  return (LPWSTR)(lastpoint ? lastpoint : lpszPath);
 +}
 +
 +/*************************************************************************
 + * PathGetArgsA    [SHLWAPI.@]
 + *
 + * Find the next argument in a string delimited by spaces.
 + *
 + * PARAMS
 + *  lpszPath [I] The string to search for arguments in
 + *
 + * RETURNS
 + *  The start of the next argument in lpszPath, or NULL if lpszPath is NULL
 + *
 + * NOTES
 + *  Spaces in quoted strings are ignored as delimiters.
 + */
 +LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
 +{
 +  BOOL bSeenQuote = FALSE;
 +
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    while (*lpszPath)
 +    {
 +      if ((*lpszPath==' ') && !bSeenQuote)
 +        return (LPSTR)lpszPath + 1;
 +      if (*lpszPath == '"')
 +        bSeenQuote = !bSeenQuote;
 +      lpszPath = CharNextA(lpszPath);
 +    }
 +  }
 +  return (LPSTR)lpszPath;
 +}
 +
 +/*************************************************************************
 + * PathGetArgsW    [SHLWAPI.@]
 + *
 + * See PathGetArgsA.
 + */
 +LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
 +{
 +  BOOL bSeenQuote = FALSE;
 +
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    while (*lpszPath)
 +    {
 +      if ((*lpszPath==' ') && !bSeenQuote)
 +        return (LPWSTR)lpszPath + 1;
 +      if (*lpszPath == '"')
 +        bSeenQuote = !bSeenQuote;
 +      lpszPath++;
 +    }
 +  }
 +  return (LPWSTR)lpszPath;
 +}
 +
 +/*************************************************************************
 + * PathGetDriveNumberA        [SHLWAPI.@]
 + *
 + * Return the drive number from a path
 + *
 + * PARAMS
 + *  lpszPath [I] Path to get the drive number from
 + *
 + * RETURNS
 + *  Success: The drive number corresponding to the drive in the path
 + *  Failure: -1, if lpszPath contains no valid drive
 + */
 +int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
 +{
 +  TRACE ("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (lpszPath && !IsDBCSLeadByte(*lpszPath) && lpszPath[1] == ':' &&
 +      tolower(*lpszPath) >= 'a' && tolower(*lpszPath) <= 'z')
 +    return tolower(*lpszPath) - 'a';
 +  return -1;
 +}
 +
 +/*************************************************************************
 + * PathGetDriveNumberW        [SHLWAPI.@]
 + *
 + * See PathGetDriveNumberA.
 + */
 +int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
 +{
 +  TRACE ("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +      WCHAR tl = tolowerW(lpszPath[0]);
 +      if (tl >= 'a' && tl <= 'z' && lpszPath[1] == ':')
 +          return tl - 'a';
 +  }
 +  return -1;
 +}
 +
 +/*************************************************************************
 + * PathRemoveFileSpecA        [SHLWAPI.@]
 + *
 + * Remove the file specification from a path.
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to remove the file spec from
 + *
 + * RETURNS
 + *  TRUE  If the path was valid and modified
 + *  FALSE Otherwise
 + */
 +BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
 +{
 +  LPSTR lpszFileSpec = lpszPath;
 +  BOOL bModified = FALSE;
 +
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if(lpszPath)
 +  {
 +    /* Skip directory or UNC path */
 +    if (*lpszPath == '\\')
 +      lpszFileSpec = ++lpszPath;
 +    if (*lpszPath == '\\')
 +      lpszFileSpec = ++lpszPath;
 +
 +    while (*lpszPath)
 +    {
 +      if(*lpszPath == '\\')
 +        lpszFileSpec = lpszPath; /* Skip dir */
 +      else if(*lpszPath == ':')
 +      {
 +        lpszFileSpec = ++lpszPath; /* Skip drive */
 +        if (*lpszPath == '\\')
 +          lpszFileSpec++;
 +      }
 +      if (!(lpszPath = CharNextA(lpszPath)))
 +        break;
 +    }
 +
 +    if (*lpszFileSpec)
 +    {
 +      *lpszFileSpec = '\0';
 +      bModified = TRUE;
 +    }
 +  }
 +  return bModified;
 +}
 +
 +/*************************************************************************
 + * PathRemoveFileSpecW        [SHLWAPI.@]
 + *
 + * See PathRemoveFileSpecA.
 + */
 +BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
 +{
 +  LPWSTR lpszFileSpec = lpszPath;
 +  BOOL bModified = FALSE;
 +
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if(lpszPath)
 +  {
 +    /* Skip directory or UNC path */
 +    if (*lpszPath == '\\')
 +      lpszFileSpec = ++lpszPath;
 +    if (*lpszPath == '\\')
 +      lpszFileSpec = ++lpszPath;
 +
 +    while (*lpszPath)
 +    {
 +      if(*lpszPath == '\\')
 +        lpszFileSpec = lpszPath; /* Skip dir */
 +      else if(*lpszPath == ':')
 +      {
 +        lpszFileSpec = ++lpszPath; /* Skip drive */
 +        if (*lpszPath == '\\')
 +          lpszFileSpec++;
 +      }
 +      lpszPath++;
 +    }
 +
 +    if (*lpszFileSpec)
 +    {
 +      *lpszFileSpec = '\0';
 +      bModified = TRUE;
 +    }
 +  }
 +  return bModified;
 +}
 +
 +/*************************************************************************
 + * PathStripPathA     [SHLWAPI.@]
 + *
 + * Remove the initial path from the beginning of a filename
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to remove the initial path from
 + *
 + * RETURNS
 + *  Nothing.
 + */
 +void WINAPI PathStripPathA(LPSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    LPSTR lpszFileName = PathFindFileNameA(lpszPath);
 +    if(lpszFileName)
 +      RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
 +  }
 +}
 +
 +/*************************************************************************
 + * PathStripPathW     [SHLWAPI.@]
 + *
 + * See PathStripPathA.
 + */
 +void WINAPI PathStripPathW(LPWSTR lpszPath)
 +{
 +  LPWSTR lpszFileName;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +  lpszFileName = PathFindFileNameW(lpszPath);
 +  if(lpszFileName)
 +    RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
 +}
 +
 +/*************************************************************************
 + * PathStripToRootA   [SHLWAPI.@]
 + *
 + * Reduce a path to its root.
 + *
 + * PARAMS
 + *  lpszPath [I/O] the path to reduce
 + *
 + * RETURNS
 + *  Success: TRUE if the stripped path is a root path
 + *  Failure: FALSE if the path cannot be stripped or is NULL
 + */
 +BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +  while(!PathIsRootA(lpszPath))
 +    if (!PathRemoveFileSpecA(lpszPath))
 +      return FALSE;
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathStripToRootW   [SHLWAPI.@]
 + *
 + * See PathStripToRootA.
 + */
 +BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +  while(!PathIsRootW(lpszPath))
 +    if (!PathRemoveFileSpecW(lpszPath))
 +      return FALSE;
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathRemoveArgsA    [SHLWAPI.@]
 + *
 + * Strip space separated arguments from a path.
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to remove arguments from
 + *
 + * RETURNS
 + *  Nothing.
 + */
 +void WINAPI PathRemoveArgsA(LPSTR lpszPath)
 +{
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if(lpszPath)
 +  {
 +    LPSTR lpszArgs = PathGetArgsA(lpszPath);
 +    if (*lpszArgs)
 +      lpszArgs[-1] = '\0';
 +    else
 +    {
 +      LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
 +      if(*lpszLastChar == ' ')
 +        *lpszLastChar = '\0';
 +    }
 +  }
 +}
 +
 +/*************************************************************************
 + * PathRemoveArgsW    [SHLWAPI.@]
 + *
 + * See PathRemoveArgsA.
 + */
 +void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
 +{
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if(lpszPath)
 +  {
 +    LPWSTR lpszArgs = PathGetArgsW(lpszPath);
 +    if (*lpszArgs || (lpszArgs > lpszPath && lpszArgs[-1] == ' '))
 +      lpszArgs[-1] = '\0';
 +  }
 +}
 +
 +/*************************************************************************
 + * PathRemoveExtensionA               [SHLWAPI.@]
 + *
 + * Remove the file extension from a path
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to remove the extension from
 + *
 + * NOTES
 + *  The NUL terminator must be written only if extension exists
 + *  and if the pointed character is not already NUL.
 + *
 + * RETURNS
 + *  Nothing.
 + */
 +void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    lpszPath = PathFindExtensionA(lpszPath);
 +    if (lpszPath && *lpszPath != '\0')
 +      *lpszPath = '\0';
 +  }
 +}
 +
 +/*************************************************************************
 + * PathRemoveExtensionW               [SHLWAPI.@]
 + *
 + * See PathRemoveExtensionA.
 +*/
 +void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    lpszPath = PathFindExtensionW(lpszPath);
 +    if (lpszPath && *lpszPath != '\0')
 +      *lpszPath = '\0';
 +  }
 +}
 +
 +/*************************************************************************
 + * PathRemoveBackslashA       [SHLWAPI.@]
 + *
 + * Remove a trailing backslash from a path.
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to remove backslash from
 + *
 + * RETURNS
 + *  Success: A pointer to the end of the path
 + *  Failure: NULL, if lpszPath is NULL
 + */
 +LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
 +{
 +  LPSTR szTemp = NULL;
 +
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if(lpszPath)
 +  {
 +    szTemp = CharPrevA(lpszPath, lpszPath + strlen(lpszPath));
 +    if (!PathIsRootA(lpszPath) && *szTemp == '\\')
 +      *szTemp = '\0';
 +  }
 +  return szTemp;
 +}
 +
 +/*************************************************************************
 + * PathRemoveBackslashW       [SHLWAPI.@]
 + *
 + * See PathRemoveBackslashA.
 + */
 +LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
 +{
 +  LPWSTR szTemp = NULL;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if(lpszPath)
 +  {
 +    szTemp = lpszPath + strlenW(lpszPath);
 +    if (szTemp > lpszPath) szTemp--;
 +    if (!PathIsRootW(lpszPath) && *szTemp == '\\')
 +      *szTemp = '\0';
 +  }
 +  return szTemp;
 +}
 +
 +/*************************************************************************
 + * PathRemoveBlanksA [SHLWAPI.@]
 + *
 + * Remove Spaces from the start and end of a path.
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to strip blanks from
 + *
 + * RETURNS
 + *  Nothing.
 + */
 +VOID WINAPI PathRemoveBlanksA(LPSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if(lpszPath && *lpszPath)
 +  {
 +    LPSTR start = lpszPath;
 +
 +    while (*lpszPath == ' ')
 +      lpszPath = CharNextA(lpszPath);
 +
 +    while(*lpszPath)
 +      *start++ = *lpszPath++;
 +
 +    if (start != lpszPath)
 +      while (start[-1] == ' ')
 +        start--;
 +    *start = '\0';
 +  }
 +}
 +
 +/*************************************************************************
 + * PathRemoveBlanksW [SHLWAPI.@]
 + *
 + * See PathRemoveBlanksA.
 + */
 +VOID WINAPI PathRemoveBlanksW(LPWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if(lpszPath && *lpszPath)
 +  {
 +    LPWSTR start = lpszPath;
 +
 +    while (*lpszPath == ' ')
 +      lpszPath++;
 +
 +    while(*lpszPath)
 +      *start++ = *lpszPath++;
 +
 +    if (start != lpszPath)
 +      while (start[-1] == ' ')
 +        start--;
 +    *start = '\0';
 +  }
 +}
 +
 +/*************************************************************************
 + * PathQuoteSpacesA [SHLWAPI.@]
 + *
 + * Surround a path containing spaces in quotes.
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to quote
 + *
 + * RETURNS
 + *  Nothing.
 + *
 + * NOTES
 + *  The path is not changed if it is invalid or has no spaces.
 + */
 +VOID WINAPI PathQuoteSpacesA(LPSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if(lpszPath && StrChrA(lpszPath,' '))
 +  {
 +    size_t iLen = strlen(lpszPath) + 1;
 +
 +    if (iLen + 2 < MAX_PATH)
 +    {
 +      memmove(lpszPath + 1, lpszPath, iLen);
 +      lpszPath[0] = '"';
 +      lpszPath[iLen] = '"';
 +      lpszPath[iLen + 1] = '\0';
 +    }
 +  }
 +}
 +
 +/*************************************************************************
 + * PathQuoteSpacesW [SHLWAPI.@]
 + *
 + * See PathQuoteSpacesA.
 + */
 +VOID WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if(lpszPath && StrChrW(lpszPath,' '))
 +  {
 +    int iLen = strlenW(lpszPath) + 1;
 +
 +    if (iLen + 2 < MAX_PATH)
 +    {
 +      memmove(lpszPath + 1, lpszPath, iLen * sizeof(WCHAR));
 +      lpszPath[0] = '"';
 +      lpszPath[iLen] = '"';
 +      lpszPath[iLen + 1] = '\0';
 +    }
 +  }
 +}
 +
 +/*************************************************************************
 + * PathUnquoteSpacesA [SHLWAPI.@]
 + *
 + * Remove quotes ("") from around a path, if present.
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to strip quotes from
 + *
 + * RETURNS
 + *  Nothing
 + *
 + * NOTES
 + *  If the path contains a single quote only, an empty string will result.
 + *  Otherwise quotes are only removed if they appear at the start and end
 + *  of the path.
 + */
 +VOID WINAPI PathUnquoteSpacesA(LPSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath && *lpszPath == '"')
 +  {
 +    DWORD dwLen = strlen(lpszPath) - 1;
 +
 +    if (lpszPath[dwLen] == '"')
 +    {
 +      lpszPath[dwLen] = '\0';
 +      for (; *lpszPath; lpszPath++)
 +        *lpszPath = lpszPath[1];
 +    }
 +  }
 +}
 +
 +/*************************************************************************
 + * PathUnquoteSpacesW [SHLWAPI.@]
 + *
 + * See PathUnquoteSpacesA.
 + */
 +VOID WINAPI PathUnquoteSpacesW(LPWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (lpszPath && *lpszPath == '"')
 +  {
 +    DWORD dwLen = strlenW(lpszPath) - 1;
 +
 +    if (lpszPath[dwLen] == '"')
 +    {
 +      lpszPath[dwLen] = '\0';
 +      for (; *lpszPath; lpszPath++)
 +        *lpszPath = lpszPath[1];
 +    }
 +  }
 +}
 +
 +/*************************************************************************
 + * PathParseIconLocationA  [SHLWAPI.@]
 + *
 + * Parse the location of an icon from a path.
 + *
 + * PARAMS
 + *  lpszPath [I/O] The path to parse the icon location from.
 + *
 + * RETURNS
 + *  Success: The number of the icon
 + *  Failure: 0 if the path does not contain an icon location or is NULL
 + *
 + * NOTES
 + *  The path has surrounding quotes and spaces removed regardless
 + *  of whether the call succeeds or not.
 + */
 +int WINAPI PathParseIconLocationA(LPSTR lpszPath)
 +{
 +  int iRet = 0;
 +  LPSTR lpszComma;
 +
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    if ((lpszComma = strchr(lpszPath, ',')))
 +    {
 +      *lpszComma++ = '\0';
 +      iRet = StrToIntA(lpszComma);
 +    }
 +    PathUnquoteSpacesA(lpszPath);
 +    PathRemoveBlanksA(lpszPath);
 +  }
 +  return iRet;
 +}
 +
 +/*************************************************************************
 + * PathParseIconLocationW  [SHLWAPI.@]
 + *
 + * See PathParseIconLocationA.
 + */
 +int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
 +{
 +  int iRet = 0;
 +  LPWSTR lpszComma;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    if ((lpszComma = StrChrW(lpszPath, ',')))
 +    {
 +      *lpszComma++ = '\0';
 +      iRet = StrToIntW(lpszComma);
 +    }
 +    PathUnquoteSpacesW(lpszPath);
 +    PathRemoveBlanksW(lpszPath);
 +  }
 +  return iRet;
 +}
 +
 +/*************************************************************************
 + * @  [SHLWAPI.4]
 + *
 + * Unicode version of PathFileExistsDefExtA.
 + */
 +BOOL WINAPI PathFileExistsDefExtW(LPWSTR lpszPath,DWORD dwWhich)
 +{
 +  static const WCHAR pszExts[][5]  = { { '.', 'p', 'i', 'f', 0},
 +                                       { '.', 'c', 'o', 'm', 0},
 +                                       { '.', 'e', 'x', 'e', 0},
 +                                       { '.', 'b', 'a', 't', 0},
 +                                       { '.', 'l', 'n', 'k', 0},
 +                                       { '.', 'c', 'm', 'd', 0},
 +                                       { 0, 0, 0, 0, 0} };
 +
 +  TRACE("(%s,%d)\n", debugstr_w(lpszPath), dwWhich);
 +
 +  if (!lpszPath || PathIsUNCServerW(lpszPath) || PathIsUNCServerShareW(lpszPath))
 +    return FALSE;
 +
 +  if (dwWhich)
 +  {
 +    LPCWSTR szExt = PathFindExtensionW(lpszPath);
 +    if (!*szExt || dwWhich & 0x40)
 +    {
 +      size_t iChoose = 0;
 +      int iLen = lstrlenW(lpszPath);
 +      if (iLen > (MAX_PATH - 5))
 +        return FALSE;
 +      while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
 +      {
 +        lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
 +        if (PathFileExistsW(lpszPath))
 +          return TRUE;
 +        iChoose++;
 +        dwWhich >>= 1;
 +      }
 +      *(lpszPath + iLen) = (WCHAR)'\0';
 +      return FALSE;
 +    }
 +  }
 +  return PathFileExistsW(lpszPath);
 +}
 +
 +/*************************************************************************
 + * @  [SHLWAPI.3]
 + *
 + * Determine if a file exists locally and is of an executable type.
 + *
 + * PARAMS
 + *  lpszPath       [I/O] File to search for
 + *  dwWhich        [I]   Type of executable to search for
 + *
 + * RETURNS
 + *  TRUE  If the file was found. lpszPath contains the file name.
 + *  FALSE Otherwise.
 + *
 + * NOTES
 + *  lpszPath is modified in place and must be at least MAX_PATH in length.
 + *  If the function returns FALSE, the path is modified to its original state.
 + *  If the given path contains an extension or dwWhich is 0, executable
 + *  extensions are not checked.
 + *
 + *  Ordinals 3-6 are a classic case of MS exposing limited functionality to
 + *  users (here through PathFindOnPathA()) and keeping advanced functionality for
 + *  their own developers exclusive use. Monopoly, anyone?
 + */
 +BOOL WINAPI PathFileExistsDefExtA(LPSTR lpszPath,DWORD dwWhich)
 +{
 +  BOOL bRet = FALSE;
 +
 +  TRACE("(%s,%d)\n", debugstr_a(lpszPath), dwWhich);
 +
 +  if (lpszPath)
 +  {
 +    WCHAR szPath[MAX_PATH];
 +    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
 +    bRet = PathFileExistsDefExtW(szPath, dwWhich);
 +    if (bRet)
 +      WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
 +  }
 +  return bRet;
 +}
 +
 +/*************************************************************************
 + * SHLWAPI_PathFindInOtherDirs
 + *
 + * Internal helper for SHLWAPI_PathFindOnPathExA/W.
 + */
 +static BOOL SHLWAPI_PathFindInOtherDirs(LPWSTR lpszFile, DWORD dwWhich)
 +{
 +  static const WCHAR szSystem[] = { 'S','y','s','t','e','m','\0'};
 +  static const WCHAR szPath[] = { 'P','A','T','H','\0'};
 +  DWORD dwLenPATH;
 +  LPCWSTR lpszCurr;
 +  WCHAR *lpszPATH;
 +  WCHAR buff[MAX_PATH];
 +
 +  TRACE("(%s,%08x)\n", debugstr_w(lpszFile), dwWhich);
 +
 +  /* Try system directories */
 +  GetSystemDirectoryW(buff, MAX_PATH);
 +  if (!PathAppendW(buff, lpszFile))
 +     return FALSE;
 +  if (PathFileExistsDefExtW(buff, dwWhich))
 +  {
 +    strcpyW(lpszFile, buff);
 +    return TRUE;
 +  }
 +  GetWindowsDirectoryW(buff, MAX_PATH);
 +  if (!PathAppendW(buff, szSystem ) || !PathAppendW(buff, lpszFile))
 +    return FALSE;
 +  if (PathFileExistsDefExtW(buff, dwWhich))
 +  {
 +    strcpyW(lpszFile, buff);
 +    return TRUE;
 +  }
 +  GetWindowsDirectoryW(buff, MAX_PATH);
 +  if (!PathAppendW(buff, lpszFile))
 +    return FALSE;
 +  if (PathFileExistsDefExtW(buff, dwWhich))
 +  {
 +    strcpyW(lpszFile, buff);
 +    return TRUE;
 +  }
 +  /* Try dirs listed in %PATH% */
 +  dwLenPATH = GetEnvironmentVariableW(szPath, buff, MAX_PATH);
 +
 +  if (!dwLenPATH || !(lpszPATH = HeapAlloc(GetProcessHeap(), 0, (dwLenPATH + 1) * sizeof (WCHAR))))
 +    return FALSE;
 +
 +  GetEnvironmentVariableW(szPath, lpszPATH, dwLenPATH + 1);
 +  lpszCurr = lpszPATH;
 +  while (lpszCurr)
 +  {
 +    LPCWSTR lpszEnd = lpszCurr;
 +    LPWSTR pBuff = buff;
 +
 +    while (*lpszEnd == ' ')
 +      lpszEnd++;
 +    while (*lpszEnd && *lpszEnd != ';')
 +      *pBuff++ = *lpszEnd++;
 +    *pBuff = '\0';
 +
 +    if (*lpszEnd)
 +      lpszCurr = lpszEnd + 1;
 +    else
 +      lpszCurr = NULL; /* Last Path, terminate after this */
 +
 +    if (!PathAppendW(buff, lpszFile))
 +    {
 +      HeapFree(GetProcessHeap(), 0, lpszPATH);
 +      return FALSE;
 +    }
 +    if (PathFileExistsDefExtW(buff, dwWhich))
 +    {
 +      strcpyW(lpszFile, buff);
 +      HeapFree(GetProcessHeap(), 0, lpszPATH);
 +      return TRUE;
 +    }
 +  }
 +  HeapFree(GetProcessHeap(), 0, lpszPATH);
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * @  [SHLWAPI.5]
 + *
 + * Search a range of paths for a specific type of executable.
 + *
 + * PARAMS
 + *  lpszFile       [I/O] File to search for
 + *  lppszOtherDirs [I]   Other directories to look in
 + *  dwWhich        [I]   Type of executable to search for
 + *
 + * RETURNS
 + *  Success: TRUE. The path to the executable is stored in lpszFile.
 + *  Failure: FALSE. The path to the executable is unchanged.
 + */
 +BOOL WINAPI PathFindOnPathExA(LPSTR lpszFile,LPCSTR *lppszOtherDirs,DWORD dwWhich)
 +{
 +  WCHAR szFile[MAX_PATH];
 +  WCHAR buff[MAX_PATH];
 +
 +  TRACE("(%s,%p,%08x)\n", debugstr_a(lpszFile), lppszOtherDirs, dwWhich);
 +
 +  if (!lpszFile || !PathIsFileSpecA(lpszFile))
 +    return FALSE;
 +
 +  MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
 +
 +  /* Search provided directories first */
 +  if (lppszOtherDirs && *lppszOtherDirs)
 +  {
 +    WCHAR szOther[MAX_PATH];
 +    LPCSTR *lpszOtherPath = lppszOtherDirs;
 +
 +    while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
 +    {
 +      MultiByteToWideChar(CP_ACP,0,*lpszOtherPath,-1,szOther,MAX_PATH);
 +      PathCombineW(buff, szOther, szFile);
 +      if (PathFileExistsDefExtW(buff, dwWhich))
 +      {
 +        WideCharToMultiByte(CP_ACP,0,buff,-1,lpszFile,MAX_PATH,0,0);
 +        return TRUE;
 +      }
 +      lpszOtherPath++;
 +    }
 +  }
 +  /* Not found, try system and path dirs */
 +  if (SHLWAPI_PathFindInOtherDirs(szFile, dwWhich))
 +  {
 +    WideCharToMultiByte(CP_ACP,0,szFile,-1,lpszFile,MAX_PATH,0,0);
 +    return TRUE;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * @  [SHLWAPI.6]
 + *
 + * Unicode version of PathFindOnPathExA.
 + */
 +BOOL WINAPI PathFindOnPathExW(LPWSTR lpszFile,LPCWSTR *lppszOtherDirs,DWORD dwWhich)
 +{
 +  WCHAR buff[MAX_PATH];
 +
 +  TRACE("(%s,%p,%08x)\n", debugstr_w(lpszFile), lppszOtherDirs, dwWhich);
 +
 +  if (!lpszFile || !PathIsFileSpecW(lpszFile))
 +    return FALSE;
 +
 +  /* Search provided directories first */
 +  if (lppszOtherDirs && *lppszOtherDirs)
 +  {
 +    LPCWSTR *lpszOtherPath = lppszOtherDirs;
 +    while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
 +    {
 +      PathCombineW(buff, *lpszOtherPath, lpszFile);
 +      if (PathFileExistsDefExtW(buff, dwWhich))
 +      {
 +        strcpyW(lpszFile, buff);
 +        return TRUE;
 +      }
 +      lpszOtherPath++;
 +    }
 +  }
 +  /* Not found, try system and path dirs */
 +  return SHLWAPI_PathFindInOtherDirs(lpszFile, dwWhich);
 +}
 +
 +/*************************************************************************
 + * PathFindOnPathA    [SHLWAPI.@]
 + *
 + * Search a range of paths for an executable.
 + *
 + * PARAMS
 + *  lpszFile       [I/O] File to search for
 + *  lppszOtherDirs [I]   Other directories to look in
 + *
 + * RETURNS
 + *  Success: TRUE. The path to the executable is stored in lpszFile.
 + *  Failure: FALSE. The path to the executable is unchanged.
 + */
 +BOOL WINAPI PathFindOnPathA(LPSTR lpszFile, LPCSTR *lppszOtherDirs)
 +{
 +  TRACE("(%s,%p)\n", debugstr_a(lpszFile), lppszOtherDirs);
 +  return PathFindOnPathExA(lpszFile, lppszOtherDirs, 0);
 + }
 +
 +/*************************************************************************
 + * PathFindOnPathW      [SHLWAPI.@]
 + *
 + * See PathFindOnPathA.
 + */
 +BOOL WINAPI PathFindOnPathW(LPWSTR lpszFile, LPCWSTR *lppszOtherDirs)
 +{
 +  TRACE("(%s,%p)\n", debugstr_w(lpszFile), lppszOtherDirs);
 +  return PathFindOnPathExW(lpszFile,lppszOtherDirs, 0);
 +}
 +
 +/*************************************************************************
 + * PathCompactPathExA   [SHLWAPI.@]
 + *
 + * Compact a path into a given number of characters.
 + *
 + * PARAMS
 + *  lpszDest [O] Destination for compacted path
 + *  lpszPath [I] Source path
 + *  cchMax   [I] Maximum size of compacted path
 + *  dwFlags  [I] Reserved
 + *
 + * RETURNS
 + *  Success: TRUE. The compacted path is written to lpszDest.
 + *  Failure: FALSE. lpszPath is undefined.
 + *
 + * NOTES
 + *  If cchMax is given as 0, lpszDest will still be NUL terminated.
 + *
 + *  The Win32 version of this function contains a bug: When cchMax == 7,
 + *  8 bytes will be written to lpszDest. This bug is fixed in the Wine
 + *  implementation.
 + *
 + *  Some relative paths will be different when cchMax == 5 or 6. This occurs
 + *  because Win32 will insert a "\" in lpszDest, even if one is
 + *  not present in the original path.
 + */
 +BOOL WINAPI PathCompactPathExA(LPSTR lpszDest, LPCSTR lpszPath,
 +                               UINT cchMax, DWORD dwFlags)
 +{
 +  BOOL bRet = FALSE;
 +
 +  TRACE("(%p,%s,%d,0x%08x)\n", lpszDest, debugstr_a(lpszPath), cchMax, dwFlags);
 +
 +  if (lpszPath && lpszDest)
 +  {
 +    WCHAR szPath[MAX_PATH];
 +    WCHAR szDest[MAX_PATH];
 +
 +    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
 +    szDest[0] = '\0';
 +    bRet = PathCompactPathExW(szDest, szPath, cchMax, dwFlags);
 +    WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0);
 +  }
 +  return bRet;
 +}
 +
 +/*************************************************************************
 + * PathCompactPathExW   [SHLWAPI.@]
 + *
 + * See PathCompactPathExA.
 + */
 +BOOL WINAPI PathCompactPathExW(LPWSTR lpszDest, LPCWSTR lpszPath,
 +                               UINT cchMax, DWORD dwFlags)
 +{
 +  static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
 +  LPCWSTR lpszFile;
 +  DWORD dwLen, dwFileLen = 0;
 +
 +  TRACE("(%p,%s,%d,0x%08x)\n", lpszDest, debugstr_w(lpszPath), cchMax, dwFlags);
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  if (!lpszDest)
 +  {
 +    WARN("Invalid lpszDest would crash under Win32!\n");
 +    return FALSE;
 +  }
 +
 +  *lpszDest = '\0';
 +
 +  if (cchMax < 2)
 +    return TRUE;
 +
 +  dwLen = strlenW(lpszPath) + 1;
 +
 +  if (dwLen < cchMax)
 +  {
 +    /* Don't need to compact */
 +    memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
 +    return TRUE;
 +  }
 +
 +  /* Path must be compacted to fit into lpszDest */
 +  lpszFile = PathFindFileNameW(lpszPath);
 +  dwFileLen = lpszPath + dwLen - lpszFile;
 +
 +  if (dwFileLen == dwLen)
 +  {
 +    /* No root in psth */
 +    if (cchMax <= 4)
 +    {
 +      while (--cchMax > 0) /* No room left for anything but ellipses */
 +        *lpszDest++ = '.';
 +      *lpszDest = '\0';
 +      return TRUE;
 +    }
 +    /* Compact the file name with ellipses at the end */
 +    cchMax -= 4;
 +    memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
 +    strcpyW(lpszDest + cchMax, szEllipses);
 +    return TRUE;
 +  }
 +  /* We have a root in the path */
 +  lpszFile--; /* Start compacted filename with the path separator */
 +  dwFileLen++;
 +
 +  if (dwFileLen + 3 > cchMax)
 +  {
 +    /* Compact the file name */
 +    if (cchMax <= 4)
 +    {
 +      while (--cchMax > 0) /* No room left for anything but ellipses */
 +        *lpszDest++ = '.';
 +      *lpszDest = '\0';
 +      return TRUE;
 +    }
 +    strcpyW(lpszDest, szEllipses);
 +    lpszDest += 3;
 +    cchMax -= 4;
 +    *lpszDest++ = *lpszFile++;
 +    if (cchMax <= 4)
 +    {
 +      while (--cchMax > 0) /* No room left for anything but ellipses */
 +        *lpszDest++ = '.';
 +      *lpszDest = '\0';
 +      return TRUE;
 +    }
 +    cchMax -= 4;
 +    memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
 +    strcpyW(lpszDest + cchMax, szEllipses);
 +    return TRUE;
 +  }
 +
 +  /* Only the root needs to be Compacted */
 +  dwLen = cchMax - dwFileLen - 3;
 +  memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
 +  strcpyW(lpszDest + dwLen, szEllipses);
 +  strcpyW(lpszDest + dwLen + 3, lpszFile);
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathIsRelativeA    [SHLWAPI.@]
 + *
 + * Determine if a path is a relative path.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *
 + * RETURNS
 + *  TRUE:  The path is relative, or is invalid.
 + *  FALSE: The path is not relative.
 + */
 +BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
 +{
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (!lpszPath || !*lpszPath || IsDBCSLeadByte(*lpszPath))
 +    return TRUE;
 +  if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
 +    return FALSE;
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + *  PathIsRelativeW   [SHLWAPI.@]
 + *
 + * See PathIsRelativeA.
 + */
 +BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
 +{
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (!lpszPath || !*lpszPath)
 +    return TRUE;
 +  if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
 +    return FALSE;
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathIsRootA                [SHLWAPI.@]
 + *
 + * Determine if a path is a root path.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *
 + * RETURNS
 + *  TRUE  If lpszPath is valid and a root path,
 + *  FALSE Otherwise
 + */
 +BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath && *lpszPath)
 +  {
 +    if (*lpszPath == '\\')
 +    {
 +      if (!lpszPath[1])
 +        return TRUE; /* \ */
 +      else if (lpszPath[1]=='\\')
 +      {
 +        BOOL bSeenSlash = FALSE;
 +        lpszPath += 2;
 +
 +        /* Check for UNC root path */
 +        while (*lpszPath)
 +        {
 +          if (*lpszPath == '\\')
 +          {
 +            if (bSeenSlash)
 +              return FALSE;
 +            bSeenSlash = TRUE;
 +          }
 +          lpszPath = CharNextA(lpszPath);
 +        }
 +        return TRUE;
 +      }
 +    }
 +    else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
 +      return TRUE; /* X:\ */
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsRootW                [SHLWAPI.@]
 + *
 + * See PathIsRootA.
 + */
 +BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (lpszPath && *lpszPath)
 +  {
 +    if (*lpszPath == '\\')
 +    {
 +      if (!lpszPath[1])
 +        return TRUE; /* \ */
 +      else if (lpszPath[1]=='\\')
 +      {
 +        BOOL bSeenSlash = FALSE;
 +        lpszPath += 2;
 +
 +        /* Check for UNC root path */
 +        while (*lpszPath)
 +        {
 +          if (*lpszPath == '\\')
 +          {
 +            if (bSeenSlash)
 +              return FALSE;
 +            bSeenSlash = TRUE;
 +          }
 +          lpszPath++;
 +        }
 +        return TRUE;
 +      }
 +    }
 +    else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
 +      return TRUE; /* X:\ */
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsDirectoryA   [SHLWAPI.@]
 + *
 + * Determine if a path is a valid directory
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check.
 + *
 + * RETURNS
 + *  FILE_ATTRIBUTE_DIRECTORY if lpszPath exists and can be read (See Notes)
 + *  FALSE if lpszPath is invalid or not a directory.
 + *
 + * NOTES
 + *  Although this function is prototyped as returning a BOOL, it returns
 + *  FILE_ATTRIBUTE_DIRECTORY for success. This means that code such as:
 + *
 + *|  if (PathIsDirectoryA("c:\\windows\\") == TRUE)
 + *|    ...
 + *
 + *  will always fail.
 + */
 +BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
 +{
 +  DWORD dwAttr;
 +
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (!lpszPath || PathIsUNCServerA(lpszPath))
 +    return FALSE;
 +
 +  if (PathIsUNCServerShareA(lpszPath))
 +  {
 +    FIXME("UNC Server Share not yet supported - FAILING\n");
 +    return FALSE;
 +  }
 +
 +  if ((dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES)
 +    return FALSE;
 +  return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
 +}
 +
 +/*************************************************************************
 + * PathIsDirectoryW   [SHLWAPI.@]
 + *
 + * See PathIsDirectoryA.
 + */
 +BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
 +{
 +  DWORD dwAttr;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (!lpszPath || PathIsUNCServerW(lpszPath))
 +    return FALSE;
 +
 +  if (PathIsUNCServerShareW(lpszPath))
 +  {
 +    FIXME("UNC Server Share not yet supported - FAILING\n");
 +    return FALSE;
 +  }
 +
 +  if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
 +    return FALSE;
 +  return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
 +}
 +
 +/*************************************************************************
 + * PathFileExistsA    [SHLWAPI.@]
 + *
 + * Determine if a file exists.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *
 + * RETURNS
 + *  TRUE  If the file exists and is readable
 + *  FALSE Otherwise
 + */
 +BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
 +{
 +  UINT iPrevErrMode;
 +  DWORD dwAttr;
 +
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  /* Prevent a dialog box if path is on a disk that has been ejected. */
 +  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
 +  dwAttr = GetFileAttributesA(lpszPath);
 +  SetErrorMode(iPrevErrMode);
 +  return dwAttr != INVALID_FILE_ATTRIBUTES;
 +}
 +
 +/*************************************************************************
 + * PathFileExistsW    [SHLWAPI.@]
 + *
 + * See PathFileExistsA.
 + */
 +BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
 +{
 +  UINT iPrevErrMode;
 +  DWORD dwAttr;
 +
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
 +  dwAttr = GetFileAttributesW(lpszPath);
 +  SetErrorMode(iPrevErrMode);
 +  return dwAttr != INVALID_FILE_ATTRIBUTES;
 +}
 +
 +/*************************************************************************
 + * PathFileExistsAndAttributesA       [SHLWAPI.445]
 + *
 + * Determine if a file exists.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *  dwAttr   [O] attributes of file
 + *
 + * RETURNS
 + *  TRUE  If the file exists and is readable
 + *  FALSE Otherwise
 + */
 +BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR lpszPath, DWORD *dwAttr)
 +{
 +  UINT iPrevErrMode;
 +  DWORD dwVal = 0;
 +
 +  TRACE("(%s %p)\n", debugstr_a(lpszPath), dwAttr);
 +
 +  if (dwAttr)
 +    *dwAttr = INVALID_FILE_ATTRIBUTES;
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
 +  dwVal = GetFileAttributesA(lpszPath);
 +  SetErrorMode(iPrevErrMode);
 +  if (dwAttr)
 +    *dwAttr = dwVal;
 +  return (dwVal != INVALID_FILE_ATTRIBUTES);
 +}
 +
 +/*************************************************************************
 + * PathFileExistsAndAttributesW       [SHLWAPI.446]
 + *
 + * See PathFileExistsA.
 + */
 +BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR lpszPath, DWORD *dwAttr)
 +{
 +  UINT iPrevErrMode;
 +  DWORD dwVal;
 +
 +  TRACE("(%s %p)\n", debugstr_w(lpszPath), dwAttr);
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
 +  dwVal = GetFileAttributesW(lpszPath);
 +  SetErrorMode(iPrevErrMode);
 +  if (dwAttr)
 +    *dwAttr = dwVal;
 +  return (dwVal != INVALID_FILE_ATTRIBUTES);
 +}
 +
 +/*************************************************************************
 + * PathMatchSingleMaskA       [internal]
 + */
 +static BOOL PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
 +{
 +  while (*name && *mask && *mask!=';')
 +  {
 +    if (*mask == '*')
 +    {
 +      do
 +      {
 +        if (PathMatchSingleMaskA(name,mask+1))
 +          return TRUE;  /* try substrings */
 +      } while (*name++);
 +      return FALSE;
 +    }
 +
 +    if (toupper(*mask) != toupper(*name) && *mask != '?')
 +      return FALSE;
 +
 +    name = CharNextA(name);
 +    mask = CharNextA(mask);
 +  }
 +
 +  if (!*name)
 +  {
 +    while (*mask == '*')
 +      mask++;
 +    if (!*mask || *mask == ';')
 +      return TRUE;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathMatchSingleMaskW       [internal]
 + */
 +static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
 +{
 +  while (*name && *mask && *mask != ';')
 +  {
 +    if (*mask == '*')
 +    {
 +      do
 +      {
 +        if (PathMatchSingleMaskW(name,mask+1))
 +          return TRUE;  /* try substrings */
 +      } while (*name++);
 +      return FALSE;
 +    }
 +
 +    if (toupperW(*mask) != toupperW(*name) && *mask != '?')
 +      return FALSE;
 +
 +    name++;
 +    mask++;
 +  }
 +  if (!*name)
 +  {
 +    while (*mask == '*')
 +      mask++;
 +    if (!*mask || *mask == ';')
 +      return TRUE;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathMatchSpecA     [SHLWAPI.@]
 + *
 + * Determine if a path matches one or more search masks.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *  lpszMask [I] Search mask(s)
 + *
 + * RETURNS
 + *  TRUE  If lpszPath is valid and is matched
 + *  FALSE Otherwise
 + *
 + * NOTES
 + *  Multiple search masks may be given if they are separated by ";". The
 + *  pattern "*.*" is treated specially in that it matches all paths (for
 + *  backwards compatibility with DOS).
 + */
 +BOOL WINAPI PathMatchSpecA(LPCSTR lpszPath, LPCSTR lpszMask)
 +{
 +  TRACE("(%s,%s)\n", lpszPath, lpszMask);
 +
 +  if (!lstrcmpA(lpszMask, "*.*"))
 +    return TRUE; /* Matches every path */
 +
 +  while (*lpszMask)
 +  {
 +    while (*lpszMask == ' ')
 +      lpszMask++; /* Eat leading spaces */
 +
 +    if (PathMatchSingleMaskA(lpszPath, lpszMask))
 +      return TRUE; /* Matches the current mask */
 +
 +    while (*lpszMask && *lpszMask != ';')
 +      lpszMask = CharNextA(lpszMask); /* masks separated by ';' */
 +
 +    if (*lpszMask == ';')
 +      lpszMask++;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathMatchSpecW     [SHLWAPI.@]
 + *
 + * See PathMatchSpecA.
 + */
 +BOOL WINAPI PathMatchSpecW(LPCWSTR lpszPath, LPCWSTR lpszMask)
 +{
 +  static const WCHAR szStarDotStar[] = { '*', '.', '*', '\0' };
 +
 +  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszMask));
 +
 +  if (!lstrcmpW(lpszMask, szStarDotStar))
 +    return TRUE; /* Matches every path */
 +
 +  while (*lpszMask)
 +  {
 +    while (*lpszMask == ' ')
 +      lpszMask++; /* Eat leading spaces */
 +
 +    if (PathMatchSingleMaskW(lpszPath, lpszMask))
 +      return TRUE; /* Matches the current path */
 +
 +    while (*lpszMask && *lpszMask != ';')
 +      lpszMask++; /* masks separated by ';' */
 +
 +    if (*lpszMask == ';')
 +      lpszMask++;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsSameRootA    [SHLWAPI.@]
 + *
 + * Determine if two paths share the same root.
 + *
 + * PARAMS
 + *  lpszPath1 [I] Source path
 + *  lpszPath2 [I] Path to compare with
 + *
 + * RETURNS
 + *  TRUE  If both paths are valid and share the same root.
 + *  FALSE If either path is invalid or the paths do not share the same root.
 + */
 +BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
 +{
 +  LPCSTR lpszStart;
 +  int dwLen;
 +
 +  TRACE("(%s,%s)\n", debugstr_a(lpszPath1), debugstr_a(lpszPath2));
 +
 +  if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootA(lpszPath1)))
 +    return FALSE;
 +
 +  dwLen = PathCommonPrefixA(lpszPath1, lpszPath2, NULL) + 1;
 +  if (lpszStart - lpszPath1 > dwLen)
 +    return FALSE; /* Paths not common up to length of the root */
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathIsSameRootW    [SHLWAPI.@]
 + *
 + * See PathIsSameRootA.
 + */
 +BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
 +{
 +  LPCWSTR lpszStart;
 +  int dwLen;
 +
 +  TRACE("(%s,%s)\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
 +
 +  if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootW(lpszPath1)))
 +    return FALSE;
 +
 +  dwLen = PathCommonPrefixW(lpszPath1, lpszPath2, NULL) + 1;
 +  if (lpszStart - lpszPath1 > dwLen)
 +    return FALSE; /* Paths not common up to length of the root */
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathIsContentTypeA   [SHLWAPI.@]
 + *
 + * Determine if a file is of a given registered content type.
 + *
 + * PARAMS
 + *  lpszPath        [I] File to check
 + *  lpszContentType [I] Content type to check for
 + *
 + * RETURNS
 + *  TRUE  If lpszPath is a given registered content type,
 + *  FALSE Otherwise.
 + *
 + * NOTES
 + *  This function looks up the registered content type for lpszPath. If
 + *  a content type is registered, it is compared (case insensitively) to
 + *  lpszContentType. Only if this matches does the function succeed.
 + */
 +BOOL WINAPI PathIsContentTypeA(LPCSTR lpszPath, LPCSTR lpszContentType)
 +{
 +  LPCSTR szExt;
 +  DWORD dwDummy;
 +  char szBuff[MAX_PATH];
 +
 +  TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszContentType));
 +
 +  if (lpszPath && (szExt = PathFindExtensionA(lpszPath)) && *szExt &&
 +      !SHGetValueA(HKEY_CLASSES_ROOT, szExt, "Content Type",
 +                   REG_NONE, szBuff, &dwDummy) &&
 +      !strcasecmp(lpszContentType, szBuff))
 +  {
 +    return TRUE;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsContentTypeW   [SHLWAPI.@]
 + *
 + * See PathIsContentTypeA.
 + */
 +BOOL WINAPI PathIsContentTypeW(LPCWSTR lpszPath, LPCWSTR lpszContentType)
 +{
 +  static const WCHAR szContentType[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0' };
 +  LPCWSTR szExt;
 +  DWORD dwDummy;
 +  WCHAR szBuff[MAX_PATH];
 +
 +  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszContentType));
 +
 +  if (lpszPath && (szExt = PathFindExtensionW(lpszPath)) && *szExt &&
 +      !SHGetValueW(HKEY_CLASSES_ROOT, szExt, szContentType,
 +                   REG_NONE, szBuff, &dwDummy) &&
 +      !strcmpiW(lpszContentType, szBuff))
 +  {
 +    return TRUE;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsFileSpecA   [SHLWAPI.@]
 + *
 + * Determine if a path is a file specification.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *
 + * RETURNS
 + *  TRUE  If lpszPath is a file specification (i.e. Contains no directories).
 + *  FALSE Otherwise.
 + */
 +BOOL WINAPI PathIsFileSpecA(LPCSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  while (*lpszPath)
 +  {
 +    if (*lpszPath == '\\' || *lpszPath == ':')
 +      return FALSE;
 +    lpszPath = CharNextA(lpszPath);
 +  }
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathIsFileSpecW   [SHLWAPI.@]
 + *
 + * See PathIsFileSpecA.
 + */
 +BOOL WINAPI PathIsFileSpecW(LPCWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  while (*lpszPath)
 +  {
 +    if (*lpszPath == '\\' || *lpszPath == ':')
 +      return FALSE;
 +    lpszPath++;
 +  }
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathIsPrefixA   [SHLWAPI.@]
 + *
 + * Determine if a path is a prefix of another.
 + *
 + * PARAMS
 + *  lpszPrefix [I] Prefix
 + *  lpszPath   [I] Path to check
 + *
 + * RETURNS
 + *  TRUE  If lpszPath has lpszPrefix as its prefix,
 + *  FALSE If either path is NULL or lpszPrefix is not a prefix
 + */
 +BOOL WINAPI PathIsPrefixA (LPCSTR lpszPrefix, LPCSTR lpszPath)
 +{
 +  TRACE("(%s,%s)\n", debugstr_a(lpszPrefix), debugstr_a(lpszPath));
 +
 +  if (lpszPrefix && lpszPath &&
 +      PathCommonPrefixA(lpszPath, lpszPrefix, NULL) == (int)strlen(lpszPrefix))
 +    return TRUE;
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + *  PathIsPrefixW   [SHLWAPI.@]
 + *
 + *  See PathIsPrefixA.
 + */
 +BOOL WINAPI PathIsPrefixW(LPCWSTR lpszPrefix, LPCWSTR lpszPath)
 +{
 +  TRACE("(%s,%s)\n", debugstr_w(lpszPrefix), debugstr_w(lpszPath));
 +
 +  if (lpszPrefix && lpszPath &&
 +      PathCommonPrefixW(lpszPath, lpszPrefix, NULL) == (int)strlenW(lpszPrefix))
 +    return TRUE;
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsSystemFolderA   [SHLWAPI.@]
 + *
 + * Determine if a path or file attributes are a system folder.
 + *
 + * PARAMS
 + *  lpszPath  [I] Path to check.
 + *  dwAttrib  [I] Attributes to check, if lpszPath is NULL.
 + *
 + * RETURNS
 + *  TRUE   If lpszPath or dwAttrib are a system folder.
 + *  FALSE  If GetFileAttributesA() fails or neither parameter is a system folder.
 + */
 +BOOL WINAPI PathIsSystemFolderA(LPCSTR lpszPath, DWORD dwAttrib)
 +{
 +  TRACE("(%s,0x%08x)\n", debugstr_a(lpszPath), dwAttrib);
 +
 +  if (lpszPath && *lpszPath)
 +    dwAttrib = GetFileAttributesA(lpszPath);
 +
 +  if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
 +      !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
 +    return FALSE;
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathIsSystemFolderW   [SHLWAPI.@]
 + *
 + * See PathIsSystemFolderA.
 + */
 +BOOL WINAPI PathIsSystemFolderW(LPCWSTR lpszPath, DWORD dwAttrib)
 +{
 +  TRACE("(%s,0x%08x)\n", debugstr_w(lpszPath), dwAttrib);
 +
 +  if (lpszPath && *lpszPath)
 +    dwAttrib = GetFileAttributesW(lpszPath);
 +
 +  if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
 +      !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
 +    return FALSE;
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathIsUNCA         [SHLWAPI.@]
 + *
 + * Determine if a path is in UNC format.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *
 + * RETURNS
 + *  TRUE: The path is UNC.
 + *  FALSE: The path is not UNC or is NULL.
 + */
 +BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
 +{
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?'))
 +    return TRUE;
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsUNCW         [SHLWAPI.@]
 + *
 + * See PathIsUNCA.
 + */
 +BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
 +{
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?'))
 +    return TRUE;
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsUNCServerA   [SHLWAPI.@]
 + *
 + * Determine if a path is a UNC server name ("\\SHARENAME").
 + *
 + * PARAMS
 + *  lpszPath  [I] Path to check.
 + *
 + * RETURNS
 + *  TRUE   If lpszPath is a valid UNC server name.
 + *  FALSE  Otherwise.
 + *
 + * NOTES
 + *  This routine is bug compatible with Win32: Server names with a
 + *  trailing backslash (e.g. "\\FOO\"), return FALSE incorrectly.
 + *  Fixing this bug may break other shlwapi functions!
 + */
 +BOOL WINAPI PathIsUNCServerA(LPCSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
 +  {
 +    while (*lpszPath)
 +    {
 +      if (*lpszPath == '\\')
 +        return FALSE;
 +      lpszPath = CharNextA(lpszPath);
 +    }
 +    return TRUE;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsUNCServerW   [SHLWAPI.@]
 + *
 + * See PathIsUNCServerA.
 + */
 +BOOL WINAPI PathIsUNCServerW(LPCWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (lpszPath && lpszPath[0] == '\\' && lpszPath[1] == '\\')
 +  {
 +      return !strchrW( lpszPath + 2, '\\' );
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsUNCServerShareA   [SHLWAPI.@]
 + *
 + * Determine if a path is a UNC server share ("\\SHARENAME\SHARE").
 + *
 + * PARAMS
 + *  lpszPath  [I] Path to check.
 + *
 + * RETURNS
 + *  TRUE   If lpszPath is a valid UNC server share.
 + *  FALSE  Otherwise.
 + *
 + * NOTES
 + *  This routine is bug compatible with Win32: Server shares with a
 + *  trailing backslash (e.g. "\\FOO\BAR\"), return FALSE incorrectly.
 + *  Fixing this bug may break other shlwapi functions!
 + */
 +BOOL WINAPI PathIsUNCServerShareA(LPCSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
 +  {
 +    BOOL bSeenSlash = FALSE;
 +    while (*lpszPath)
 +    {
 +      if (*lpszPath == '\\')
 +      {
 +        if (bSeenSlash)
 +          return FALSE;
 +        bSeenSlash = TRUE;
 +      }
 +      lpszPath = CharNextA(lpszPath);
 +    }
 +    return bSeenSlash;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathIsUNCServerShareW   [SHLWAPI.@]
 + *
 + * See PathIsUNCServerShareA.
 + */
 +BOOL WINAPI PathIsUNCServerShareW(LPCWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
 +  {
 +    BOOL bSeenSlash = FALSE;
 +    while (*lpszPath)
 +    {
 +      if (*lpszPath == '\\')
 +      {
 +        if (bSeenSlash)
 +          return FALSE;
 +        bSeenSlash = TRUE;
 +      }
 +      lpszPath++;
 +    }
 +    return bSeenSlash;
 +  }
 +  return FALSE;
 +}
 +
 +/*************************************************************************
 + * PathCanonicalizeA   [SHLWAPI.@]
 + *
 + * Convert a path to its canonical form.
 + *
 + * PARAMS
 + *  lpszBuf  [O] Output path
 + *  lpszPath [I] Path to canonicalize
 + *
 + * RETURNS
 + *  Success: TRUE.  lpszBuf contains the output path,
 + *  Failure: FALSE, If input path is invalid. lpszBuf is undefined
 + */
 +BOOL WINAPI PathCanonicalizeA(LPSTR lpszBuf, LPCSTR lpszPath)
 +{
 +  BOOL bRet = FALSE;
 +
 +  TRACE("(%p,%s)\n", lpszBuf, debugstr_a(lpszPath));
 +
 +  if (lpszBuf)
 +    *lpszBuf = '\0';
 +
 +  if (!lpszBuf || !lpszPath)
 +    SetLastError(ERROR_INVALID_PARAMETER);
 +  else
 +  {
 +    WCHAR szPath[MAX_PATH];
 +    WCHAR szBuff[MAX_PATH];
 +    int ret = MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
 +
 +    if (!ret) {
 +      WARN("Failed to convert string to widechar (too long?), LE %d.\n", GetLastError());
 +      return FALSE;
 +    }
 +    bRet = PathCanonicalizeW(szBuff, szPath);
 +    WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszBuf,MAX_PATH,0,0);
 +  }
 +  return bRet;
 +}
 +
 +
 +/*************************************************************************
 + * PathCanonicalizeW   [SHLWAPI.@]
 + *
 + * See PathCanonicalizeA.
 + */
 +BOOL WINAPI PathCanonicalizeW(LPWSTR lpszBuf, LPCWSTR lpszPath)
 +{
 +  LPWSTR lpszDst = lpszBuf;
 +  LPCWSTR lpszSrc = lpszPath;
 +
 +  TRACE("(%p,%s)\n", lpszBuf, debugstr_w(lpszPath));
 +
 +  if (lpszBuf)
 +    *lpszDst = '\0';
 +
 +  if (!lpszBuf || !lpszPath)
 +  {
 +    SetLastError(ERROR_INVALID_PARAMETER);
 +    return FALSE;
 +  }
 +
 +  if (!*lpszPath)
 +  {
 +    *lpszBuf++ = '\\';
 +    *lpszBuf = '\0';
 +    return TRUE;
 +  }
 +
 +  /* Copy path root */
 +  if (*lpszSrc == '\\')
 +  {
 +    *lpszDst++ = *lpszSrc++;
 +  }
 +  else if (*lpszSrc && lpszSrc[1] == ':')
 +  {
 +    /* X:\ */
 +    *lpszDst++ = *lpszSrc++;
 +    *lpszDst++ = *lpszSrc++;
 +    if (*lpszSrc == '\\')
 +      *lpszDst++ = *lpszSrc++;
 +  }
 +
 +  /* Canonicalize the rest of the path */
 +  while (*lpszSrc)
 +  {
 +    if (*lpszSrc == '.')
 +    {
 +      if (lpszSrc[1] == '\\' && (lpszSrc == lpszPath || lpszSrc[-1] == '\\' || lpszSrc[-1] == ':'))
 +      {
 +        lpszSrc += 2; /* Skip .\ */
 +      }
 +      else if (lpszSrc[1] == '.' && (lpszDst == lpszBuf || lpszDst[-1] == '\\'))
 +      {
 +        /* \.. backs up a directory, over the root if it has no \ following X:.
 +         * .. is ignored if it would remove a UNC server name or initial \\
 +         */
 +        if (lpszDst != lpszBuf)
 +        {
 +          *lpszDst = '\0'; /* Allow PathIsUNCServerShareA test on lpszBuf */
 +          if (lpszDst > lpszBuf+1 && lpszDst[-1] == '\\' &&
 +             (lpszDst[-2] != '\\' || lpszDst > lpszBuf+2))
 +          {
 +            if (lpszDst[-2] == ':' && (lpszDst > lpszBuf+3 || lpszDst[-3] == ':'))
 +            {
 +              lpszDst -= 2;
 +              while (lpszDst > lpszBuf && *lpszDst != '\\')
 +                lpszDst--;
 +              if (*lpszDst == '\\')
 +                lpszDst++; /* Reset to last '\' */
 +              else
 +                lpszDst = lpszBuf; /* Start path again from new root */
 +            }
 +            else if (lpszDst[-2] != ':' && !PathIsUNCServerShareW(lpszBuf))
 +              lpszDst -= 2;
 +          }
 +          while (lpszDst > lpszBuf && *lpszDst != '\\')
 +            lpszDst--;
 +          if (lpszDst == lpszBuf)
 +          {
 +            *lpszDst++ = '\\';
 +            lpszSrc++;
 +          }
 +        }
 +        lpszSrc += 2; /* Skip .. in src path */
 +      }
 +      else
 +        *lpszDst++ = *lpszSrc++;
 +    }
 +    else
 +      *lpszDst++ = *lpszSrc++;
 +  }
 +  /* Append \ to naked drive specs */
 +  if (lpszDst - lpszBuf == 2 && lpszDst[-1] == ':')
 +    *lpszDst++ = '\\';
 +  *lpszDst++ = '\0';
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathFindNextComponentA   [SHLWAPI.@]
 + *
 + * Find the next component in a path.
 + *
 + * PARAMS
 + *   lpszPath [I] Path to find next component in
 + *
 + * RETURNS
 + *  Success: A pointer to the next component, or the end of the string.
 + *  Failure: NULL, If lpszPath is invalid
 + *
 + * NOTES
 + *  A 'component' is either a backslash character (\) or UNC marker (\\).
 + *  Because of this, relative paths (e.g "c:foo") are regarded as having
 + *  only one component.
 + */
 +LPSTR WINAPI PathFindNextComponentA(LPCSTR lpszPath)
 +{
 +  LPSTR lpszSlash;
 +
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if(!lpszPath || !*lpszPath)
 +    return NULL;
 +
 +  if ((lpszSlash = StrChrA(lpszPath, '\\')))
 +  {
 +    if (lpszSlash[1] == '\\')
 +      lpszSlash++;
 +    return lpszSlash + 1;
 +  }
 +  return (LPSTR)lpszPath + strlen(lpszPath);
 +}
 +
 +/*************************************************************************
 + * PathFindNextComponentW   [SHLWAPI.@]
 + *
 + * See PathFindNextComponentA.
 + */
 +LPWSTR WINAPI PathFindNextComponentW(LPCWSTR lpszPath)
 +{
 +  LPWSTR lpszSlash;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if(!lpszPath || !*lpszPath)
 +    return NULL;
 +
 +  if ((lpszSlash = StrChrW(lpszPath, '\\')))
 +  {
 +    if (lpszSlash[1] == '\\')
 +      lpszSlash++;
 +    return lpszSlash + 1;
 +  }
 +  return (LPWSTR)lpszPath + strlenW(lpszPath);
 +}
 +
 +/*************************************************************************
 + * PathAddExtensionA   [SHLWAPI.@]
 + *
 + * Add a file extension to a path
 + *
 + * PARAMS
 + *  lpszPath      [I/O] Path to add extension to
 + *  lpszExtension [I]   Extension to add to lpszPath
 + *
 + * RETURNS
 + *  TRUE  If the path was modified,
 + *  FALSE If lpszPath or lpszExtension are invalid, lpszPath has an
 + *        extension already, or the new path length is too big.
 + *
 + * FIXME
 + *  What version of shlwapi.dll adds "exe" if lpszExtension is NULL? Win2k
 + *  does not do this, so the behaviour was removed.
 + */
 +BOOL WINAPI PathAddExtensionA(LPSTR lpszPath, LPCSTR lpszExtension)
 +{
 +  size_t dwLen;
 +
 +  TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExtension));
 +
 +  if (!lpszPath || !lpszExtension || *(PathFindExtensionA(lpszPath)))
 +    return FALSE;
 +
 +  dwLen = strlen(lpszPath);
 +
 +  if (dwLen + strlen(lpszExtension) >= MAX_PATH)
 +    return FALSE;
 +
 +  strcpy(lpszPath + dwLen, lpszExtension);
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathAddExtensionW   [SHLWAPI.@]
 + *
 + * See PathAddExtensionA.
 + */
 +BOOL WINAPI PathAddExtensionW(LPWSTR lpszPath, LPCWSTR lpszExtension)
 +{
 +  size_t dwLen;
 +
 +  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExtension));
 +
 +  if (!lpszPath || !lpszExtension || *(PathFindExtensionW(lpszPath)))
 +    return FALSE;
 +
 +  dwLen = strlenW(lpszPath);
 +
 +  if (dwLen + strlenW(lpszExtension) >= MAX_PATH)
 +    return FALSE;
 +
 +  strcpyW(lpszPath + dwLen, lpszExtension);
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathMakePrettyA   [SHLWAPI.@]
 + *
 + * Convert an uppercase DOS filename into lowercase.
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to convert.
 + *
 + * RETURNS
 + *  TRUE  If the path was an uppercase DOS path and was converted,
 + *  FALSE Otherwise.
 + */
 +BOOL WINAPI PathMakePrettyA(LPSTR lpszPath)
 +{
 +  LPSTR pszIter = lpszPath;
 +
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (!pszIter)
 +    return FALSE;
 +
 +  if (*pszIter)
 +  {
 +    do
 +    {
 +      if (islower(*pszIter) || IsDBCSLeadByte(*pszIter))
 +        return FALSE; /* Not DOS path */
 +      pszIter++;
 +    } while (*pszIter);
 +    pszIter = lpszPath + 1;
 +    while (*pszIter)
 +    {
 +      *pszIter = tolower(*pszIter);
 +      pszIter++;
 +    }
 +  }
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathMakePrettyW   [SHLWAPI.@]
 + *
 + * See PathMakePrettyA.
 + */
 +BOOL WINAPI PathMakePrettyW(LPWSTR lpszPath)
 +{
 +  LPWSTR pszIter = lpszPath;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (!pszIter)
 +    return FALSE;
 +
 +  if (*pszIter)
 +  {
 +    do
 +    {
 +      if (islowerW(*pszIter))
 +        return FALSE; /* Not DOS path */
 +      pszIter++;
 +    } while (*pszIter);
 +    pszIter = lpszPath + 1;
 +    while (*pszIter)
 +    {
 +      *pszIter = tolowerW(*pszIter);
 +      pszIter++;
 +    }
 +  }
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathCommonPrefixA   [SHLWAPI.@]
 + *
 + * Determine the length of the common prefix between two paths.
 + *
 + * PARAMS
 + *  lpszFile1 [I] First path for comparison
 + *  lpszFile2 [I] Second path for comparison
 + *  achPath   [O] Destination for common prefix string
 + *
 + * RETURNS
 + *  The length of the common prefix. This is 0 if there is no common
 + *  prefix between the paths or if any parameters are invalid. If the prefix
 + *  is non-zero and achPath is not NULL, achPath is filled with the common
 + *  part of the prefix and NUL terminated.
 + *
 + * NOTES
 + *  A common prefix of 2 is always returned as 3. It is thus possible for
 + *  the length returned to be invalid (i.e. Longer than one or both of the
 + *  strings given as parameters). This Win32 behaviour has been implemented
 + *  here, and cannot be changed (fixed?) without breaking other SHLWAPI calls.
 + *  To work around this when using this function, always check that the byte
 + *  at [common_prefix_len-1] is not a NUL. If it is, deduct 1 from the prefix.
 + */
 +int WINAPI PathCommonPrefixA(LPCSTR lpszFile1, LPCSTR lpszFile2, LPSTR achPath)
 +{
 +  size_t iLen = 0;
 +  LPCSTR lpszIter1 = lpszFile1;
 +  LPCSTR lpszIter2 = lpszFile2;
 +
 +  TRACE("(%s,%s,%p)\n", debugstr_a(lpszFile1), debugstr_a(lpszFile2), achPath);
 +
 +  if (achPath)
 +    *achPath = '\0';
 +
 +  if (!lpszFile1 || !lpszFile2)
 +    return 0;
 +
 +  /* Handle roots first */
 +  if (PathIsUNCA(lpszFile1))
 +  {
 +    if (!PathIsUNCA(lpszFile2))
 +      return 0;
 +    lpszIter1 += 2;
 +    lpszIter2 += 2;
 +  }
 +  else if (PathIsUNCA(lpszFile2))
 +      return 0; /* Know already lpszFile1 is not UNC */
 +
 +  do
 +  {
 +    /* Update len */
 +    if ((!*lpszIter1 || *lpszIter1 == '\\') &&
 +        (!*lpszIter2 || *lpszIter2 == '\\'))
 +      iLen = lpszIter1 - lpszFile1; /* Common to this point */
 +
 +    if (!*lpszIter1 || (tolower(*lpszIter1) != tolower(*lpszIter2)))
 +      break; /* Strings differ at this point */
 +
 +    lpszIter1++;
 +    lpszIter2++;
 +  } while (1);
 +
 +  if (iLen == 2)
 +    iLen++; /* Feature/Bug compatible with Win32 */
 +
 +  if (iLen && achPath)
 +  {
 +    memcpy(achPath,lpszFile1,iLen);
 +    achPath[iLen] = '\0';
 +  }
 +  return iLen;
 +}
 +
 +/*************************************************************************
 + * PathCommonPrefixW   [SHLWAPI.@]
 + *
 + * See PathCommonPrefixA.
 + */
 +int WINAPI PathCommonPrefixW(LPCWSTR lpszFile1, LPCWSTR lpszFile2, LPWSTR achPath)
 +{
 +  size_t iLen = 0;
 +  LPCWSTR lpszIter1 = lpszFile1;
 +  LPCWSTR lpszIter2 = lpszFile2;
 +
 +  TRACE("(%s,%s,%p)\n", debugstr_w(lpszFile1), debugstr_w(lpszFile2), achPath);
 +
 +  if (achPath)
 +    *achPath = '\0';
 +
 +  if (!lpszFile1 || !lpszFile2)
 +    return 0;
 +
 +  /* Handle roots first */
 +  if (PathIsUNCW(lpszFile1))
 +  {
 +    if (!PathIsUNCW(lpszFile2))
 +      return 0;
 +    lpszIter1 += 2;
 +    lpszIter2 += 2;
 +  }
 +  else if (PathIsUNCW(lpszFile2))
 +      return 0; /* Know already lpszFile1 is not UNC */
 +
 +  do
 +  {
 +    /* Update len */
 +    if ((!*lpszIter1 || *lpszIter1 == '\\') &&
 +        (!*lpszIter2 || *lpszIter2 == '\\'))
 +      iLen = lpszIter1 - lpszFile1; /* Common to this point */
 +
 +    if (!*lpszIter1 || (tolowerW(*lpszIter1) != tolowerW(*lpszIter2)))
 +      break; /* Strings differ at this point */
 +
 +    lpszIter1++;
 +    lpszIter2++;
 +  } while (1);
 +
 +  if (iLen == 2)
 +    iLen++; /* Feature/Bug compatible with Win32 */
 +
 +  if (iLen && achPath)
 +  {
 +    memcpy(achPath,lpszFile1,iLen * sizeof(WCHAR));
 +    achPath[iLen] = '\0';
 +  }
 +  return iLen;
 +}
 +
 +/*************************************************************************
 + * PathCompactPathA   [SHLWAPI.@]
 + *
 + * Make a path fit into a given width when printed to a DC.
 + *
 + * PARAMS
 + *  hDc      [I]   Destination DC
 + *  lpszPath [I/O] Path to be printed to hDc
 + *  dx       [I]   Desired width
 + *
 + * RETURNS
 + *  TRUE  If the path was modified/went well.
 + *  FALSE Otherwise.
 + */
 +BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR lpszPath, UINT dx)
 +{
 +  BOOL bRet = FALSE;
 +
 +  TRACE("(%p,%s,%d)\n", hDC, debugstr_a(lpszPath), dx);
 +
 +  if (lpszPath)
 +  {
 +    WCHAR szPath[MAX_PATH];
 +    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
 +    bRet = PathCompactPathW(hDC, szPath, dx);
 +    WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
 +  }
 +  return bRet;
 +}
 +
 +/*************************************************************************
 + * PathCompactPathW   [SHLWAPI.@]
 + *
 + * See PathCompactPathA.
 + */
 +BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR lpszPath, UINT dx)
 +{
 +  static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
 +  BOOL bRet = TRUE;
 +  HDC hdc = 0;
 +  WCHAR buff[MAX_PATH];
 +  SIZE size;
 +  DWORD dwLen;
 +
 +  TRACE("(%p,%s,%d)\n", hDC, debugstr_w(lpszPath), dx);
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  if (!hDC)
 +    hdc = hDC = GetDC(0);
 +
 +  /* Get the length of the whole path */
 +  dwLen = strlenW(lpszPath);
 +  GetTextExtentPointW(hDC, lpszPath, dwLen, &size);
 +
 +  if ((UINT)size.cx > dx)
 +  {
 +    /* Path too big, must reduce it */
 +    LPWSTR sFile;
 +    DWORD dwEllipsesLen = 0, dwPathLen = 0;
 +
 +    sFile = PathFindFileNameW(lpszPath);
 +    if (sFile != lpszPath) sFile--;
 +
 +    /* Get the size of ellipses */
 +    GetTextExtentPointW(hDC, szEllipses, 3, &size);
 +    dwEllipsesLen = size.cx;
 +    /* Get the size of the file name */
 +    GetTextExtentPointW(hDC, sFile, strlenW(sFile), &size);
 +    dwPathLen = size.cx;
 +
 +    if (sFile != lpszPath)
 +    {
 +      LPWSTR sPath = sFile;
 +      BOOL bEllipses = FALSE;
 +
 +      /* The path includes a file name. Include as much of the path prior to
 +       * the file name as possible, allowing for the ellipses, e.g:
 +       * c:\some very long path\filename ==> c:\some v...\filename
 +       */
 +      lstrcpynW(buff, sFile, MAX_PATH);
 +
 +      do
 +      {
 +        DWORD dwTotalLen = bEllipses? dwPathLen + dwEllipsesLen : dwPathLen;
 +
 +        GetTextExtentPointW(hDC, lpszPath, sPath - lpszPath, &size);
 +        dwTotalLen += size.cx;
 +        if (dwTotalLen <= dx)
 +          break;
 +        sPath--;
 +        if (!bEllipses)
 +        {
 +          bEllipses = TRUE;
 +          sPath -= 2;
 +        }
 +      } while (sPath > lpszPath);
 +
 +      if (sPath > lpszPath)
 +      {
 +        if (bEllipses)
 +        {
 +          strcpyW(sPath, szEllipses);
 +          strcpyW(sPath+3, buff);
 +        }
 +        bRet = TRUE;
 +        goto end;
 +      }
 +      strcpyW(lpszPath, szEllipses);
 +      strcpyW(lpszPath+3, buff);
 +      bRet = FALSE;
 +      goto end;
 +    }
 +
 +    /* Trim the path by adding ellipses to the end, e.g:
 +     * A very long file name.txt ==> A very...
 +     */
 +    dwLen = strlenW(lpszPath);
 +
 +    if (dwLen > MAX_PATH - 3)
 +      dwLen =  MAX_PATH - 3;
 +    lstrcpynW(buff, sFile, dwLen);
 +
 +    do {
 +      dwLen--;
 +      GetTextExtentPointW(hDC, buff, dwLen, &size);
 +    } while (dwLen && size.cx + dwEllipsesLen > dx);
 +
 +   if (!dwLen)
 +   {
 +     DWORD dwWritten = 0;
 +
 +     dwEllipsesLen /= 3; /* Size of a single '.' */
 +
 +     /* Write as much of the Ellipses string as possible */
 +     while (dwWritten + dwEllipsesLen < dx && dwLen < 3)
 +     {
 +       *lpszPath++ = '.';
 +       dwWritten += dwEllipsesLen;
 +       dwLen++;
 +     }
 +     *lpszPath = '\0';
 +     bRet = FALSE;
 +   }
 +   else
 +   {
 +     strcpyW(buff + dwLen, szEllipses);
 +     strcpyW(lpszPath, buff);
 +    }
 +  }
 +
 +end:
 +  if (hdc)
 +    ReleaseDC(0, hdc);
 +
 +  return bRet;
 +}
 +
 +/*************************************************************************
 + * PathGetCharTypeA   [SHLWAPI.@]
 + *
 + * Categorise a character from a file path.
 + *
 + * PARAMS
 + *  ch [I] Character to get the type of
 + *
 + * RETURNS
 + *  A set of GCT_ bit flags (from "shlwapi.h") indicating the character type.
 + */
 +UINT WINAPI PathGetCharTypeA(UCHAR ch)
 +{
 +  return PathGetCharTypeW(ch);
 +}
 +
 +/*************************************************************************
 + * PathGetCharTypeW   [SHLWAPI.@]
 + *
 + * See PathGetCharTypeA.
 + */
 +UINT WINAPI PathGetCharTypeW(WCHAR ch)
 +{
 +  UINT flags = 0;
 +
 +  TRACE("(%d)\n", ch);
 +
 +  if (!ch || ch < ' ' || ch == '<' || ch == '>' ||
 +      ch == '"' || ch == '|' || ch == '/')
 +    flags = GCT_INVALID; /* Invalid */
 +  else if (ch == '*' || ch=='?')
 +    flags = GCT_WILD; /* Wildchars */
 +  else if ((ch == '\\') || (ch == ':'))
 +    return GCT_SEPARATOR; /* Path separators */
 +  else
 +  {
 +     if (ch < 126)
 +     {
 +         if (((ch & 0x1) && ch != ';') || !ch || isalnum(ch) || ch == '$' || ch == '&' || ch == '(' ||
 +            ch == '.' || ch == '@' || ch == '^' ||
 +            ch == '\'' || ch == 130 || ch == '`')
 +         flags |= GCT_SHORTCHAR; /* All these are valid for DOS */
 +     }
 +     else
 +       flags |= GCT_SHORTCHAR; /* Bug compatible with win32 */
 +     flags |= GCT_LFNCHAR; /* Valid for long file names */
 +  }
 +  return flags;
 +}
 +
 +/*************************************************************************
 + * SHLWAPI_UseSystemForSystemFolders
 + *
 + * Internal helper for PathMakeSystemFolderW.
 + */
 +static BOOL SHLWAPI_UseSystemForSystemFolders(void)
 +{
 +  static BOOL bCheckedReg = FALSE;
 +  static BOOL bUseSystemForSystemFolders = FALSE;
 +
 +  if (!bCheckedReg)
 +  {
 +    bCheckedReg = TRUE;
 +
 +    /* Key tells Win what file attributes to use on system folders */
 +    if (SHGetValueA(HKEY_LOCAL_MACHINE,
 +        "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
 +        "UseSystemForSystemFolders", 0, 0, 0))
 +      bUseSystemForSystemFolders = TRUE;
 +  }
 +  return bUseSystemForSystemFolders;
 +}
 +
 +/*************************************************************************
 + * PathMakeSystemFolderA   [SHLWAPI.@]
 + *
 + * Set system folder attribute for a path.
 + *
 + * PARAMS
 + *  lpszPath [I] The path to turn into a system folder
 + *
 + * RETURNS
 + *  TRUE  If the path was changed to/already was a system folder
 + *  FALSE If the path is invalid or SetFileAttributesA() fails
 + */
 +BOOL WINAPI PathMakeSystemFolderA(LPCSTR lpszPath)
 +{
 +  BOOL bRet = FALSE;
 +
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (lpszPath && *lpszPath)
 +  {
 +    WCHAR szPath[MAX_PATH];
 +    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
 +    bRet = PathMakeSystemFolderW(szPath);
 +  }
 +  return bRet;
 +}
 +
 +/*************************************************************************
 + * PathMakeSystemFolderW   [SHLWAPI.@]
 + *
 + * See PathMakeSystemFolderA.
 + */
 +BOOL WINAPI PathMakeSystemFolderW(LPCWSTR lpszPath)
 +{
 +  DWORD dwDefaultAttr = FILE_ATTRIBUTE_READONLY, dwAttr;
 +  WCHAR buff[MAX_PATH];
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (!lpszPath || !*lpszPath)
 +    return FALSE;
 +
 +  /* If the directory is already a system directory, don't do anything */
 +  GetSystemDirectoryW(buff, MAX_PATH);
 +  if (!strcmpW(buff, lpszPath))
 +    return TRUE;
 +
 +  GetWindowsDirectoryW(buff, MAX_PATH);
 +  if (!strcmpW(buff, lpszPath))
 +    return TRUE;
 +
 +  /* "UseSystemForSystemFolders" Tells Win what attributes to use */
 +  if (SHLWAPI_UseSystemForSystemFolders())
 +    dwDefaultAttr = FILE_ATTRIBUTE_SYSTEM;
 +
 +  if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
 +    return FALSE;
 +
 +  /* Change file attributes to system attributes */
 +  dwAttr &= ~(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_READONLY);
 +  return SetFileAttributesW(lpszPath, dwAttr | dwDefaultAttr);
 +}
 +
 +/*************************************************************************
 + * PathRenameExtensionA   [SHLWAPI.@]
 + *
 + * Swap the file extension in a path with another extension.
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to swap the extension in
 + *  lpszExt  [I]   The new extension
 + *
 + * RETURNS
 + *  TRUE  if lpszPath was modified,
 + *  FALSE if lpszPath or lpszExt is NULL, or the new path is too long
 + */
 +BOOL WINAPI PathRenameExtensionA(LPSTR lpszPath, LPCSTR lpszExt)
 +{
 +  LPSTR lpszExtension;
 +
 +  TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExt));
 +
 +  lpszExtension = PathFindExtensionA(lpszPath);
 +
 +  if (!lpszExtension || (lpszExtension - lpszPath + strlen(lpszExt) >= MAX_PATH))
 +    return FALSE;
 +
 +  strcpy(lpszExtension, lpszExt);
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathRenameExtensionW   [SHLWAPI.@]
 + *
 + * See PathRenameExtensionA.
 + */
 +BOOL WINAPI PathRenameExtensionW(LPWSTR lpszPath, LPCWSTR lpszExt)
 +{
 +  LPWSTR lpszExtension;
 +
 +  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExt));
 +
 +  lpszExtension = PathFindExtensionW(lpszPath);
 +
 +  if (!lpszExtension || (lpszExtension - lpszPath + strlenW(lpszExt) >= MAX_PATH))
 +    return FALSE;
 +
 +  strcpyW(lpszExtension, lpszExt);
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathSearchAndQualifyA   [SHLWAPI.@]
 + *
 + * Determine if a given path is correct and fully qualified.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *  lpszBuf  [O] Output for correct path
 + *  cchBuf   [I] Size of lpszBuf
 + *
 + * RETURNS
 + *  Unknown.
 + */
 +BOOL WINAPI PathSearchAndQualifyA(LPCSTR lpszPath, LPSTR lpszBuf, UINT cchBuf)
 +{
 +    TRACE("(%s,%p,0x%08x)\n", debugstr_a(lpszPath), lpszBuf, cchBuf);
 +
 +    if(SearchPathA(NULL, lpszPath, NULL, cchBuf, lpszBuf, NULL))
 +        return TRUE;
 +    return !!GetFullPathNameA(lpszPath, cchBuf, lpszBuf, NULL);
 +}
 +
 +/*************************************************************************
 + * PathSearchAndQualifyW   [SHLWAPI.@]
 + *
 + * See PathSearchAndQualifyA.
 + */
 +BOOL WINAPI PathSearchAndQualifyW(LPCWSTR lpszPath, LPWSTR lpszBuf, UINT cchBuf)
 +{
 +    TRACE("(%s,%p,0x%08x)\n", debugstr_w(lpszPath), lpszBuf, cchBuf);
 +
 +    if(SearchPathW(NULL, lpszPath, NULL, cchBuf, lpszBuf, NULL))
 +        return TRUE;
 +    return !!GetFullPathNameW(lpszPath, cchBuf, lpszBuf, NULL);
 +}
 +
 +/*************************************************************************
 + * PathSkipRootA   [SHLWAPI.@]
 + *
 + * Return the portion of a path following the drive letter or mount point.
 + *
 + * PARAMS
 + *  lpszPath [I] The path to skip on
 + *
 + * RETURNS
 + *  Success: A pointer to the next character after the root.
 + *  Failure: NULL, if lpszPath is invalid, has no root or is a multibyte string.
 + */
 +LPSTR WINAPI PathSkipRootA(LPCSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (!lpszPath || !*lpszPath)
 +    return NULL;
 +
 +  if (*lpszPath == '\\' && lpszPath[1] == '\\')
 +  {
 +    /* Network share: skip share server and mount point */
 +    lpszPath += 2;
 +    if ((lpszPath = StrChrA(lpszPath, '\\')) &&
 +        (lpszPath = StrChrA(lpszPath + 1, '\\')))
 +      lpszPath++;
 +    return (LPSTR)lpszPath;
 +  }
 +
 +  if (IsDBCSLeadByte(*lpszPath))
 +    return NULL;
 +
 +  /* Check x:\ */
 +  if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
 +    return (LPSTR)lpszPath + 3;
 +  return NULL;
 +}
 +
 +/*************************************************************************
 + * PathSkipRootW   [SHLWAPI.@]
 + *
 + * See PathSkipRootA.
 + */
 +LPWSTR WINAPI PathSkipRootW(LPCWSTR lpszPath)
 +{
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (!lpszPath || !*lpszPath)
 +    return NULL;
 +
 +  if (*lpszPath == '\\' && lpszPath[1] == '\\')
 +  {
 +    /* Network share: skip share server and mount point */
 +    lpszPath += 2;
 +    if ((lpszPath = StrChrW(lpszPath, '\\')) &&
 +        (lpszPath = StrChrW(lpszPath + 1, '\\')))
 +     lpszPath++;
 +    return (LPWSTR)lpszPath;
 +  }
 +
 +  /* Check x:\ */
 +  if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
 +    return (LPWSTR)lpszPath + 3;
 +  return NULL;
 +}
 +
 +/*************************************************************************
 + * PathCreateFromUrlA   [SHLWAPI.@]
 + *
 + * See PathCreateFromUrlW
 + */
 +HRESULT WINAPI PathCreateFromUrlA(LPCSTR pszUrl, LPSTR pszPath,
 +                                  LPDWORD pcchPath, DWORD dwReserved)
 +{
 +    WCHAR bufW[MAX_PATH];
 +    WCHAR *pathW = bufW;
 +    UNICODE_STRING urlW;
 +    HRESULT ret;
 +    DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
 +
 +    if (!pszUrl || !pszPath || !pcchPath || !*pcchPath)
 +        return E_INVALIDARG;
 +
 +    if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl))
 +        return E_INVALIDARG;
 +    if((ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved)) == E_POINTER) {
 +        pathW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
 +        ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved);
 +    }
 +    if(ret == S_OK) {
 +        RtlUnicodeToMultiByteSize(&lenA, pathW, lenW * sizeof(WCHAR));
 +        if(*pcchPath > lenA) {
 +            RtlUnicodeToMultiByteN(pszPath, *pcchPath - 1, &lenA, pathW, lenW * sizeof(WCHAR));
 +            pszPath[lenA] = 0;
 +            *pcchPath = lenA;
 +        } else {
 +            *pcchPath = lenA + 1;
 +            ret = E_POINTER;
 +        }
 +    }
 +    if(pathW != bufW) HeapFree(GetProcessHeap(), 0, pathW);
 +    RtlFreeUnicodeString(&urlW);
 +    return ret;
 +}
 +
 +/*************************************************************************
 + * PathCreateFromUrlW   [SHLWAPI.@]
 + *
 + * Create a path from a URL
 + *
 + * PARAMS
 + *  lpszUrl  [I] URL to convert into a path
 + *  lpszPath [O] Output buffer for the resulting Path
 + *  pcchPath [I] Length of lpszPath
 + *  dwFlags  [I] Flags controlling the conversion
 + *
 + * RETURNS
 + *  Success: S_OK. lpszPath contains the URL in path format,
 + *  Failure: An HRESULT error code such as E_INVALIDARG.
 + */
 +HRESULT WINAPI PathCreateFromUrlW(LPCWSTR pszUrl, LPWSTR pszPath,
 +                                  LPDWORD pcchPath, DWORD dwReserved)
 +{
 +    static const WCHAR file_colon[] = { 'f','i','l','e',':',0 };
 +    static const WCHAR localhost[] = { 'l','o','c','a','l','h','o','s','t',0 };
 +    DWORD nslashes, unescape, len;
 +    const WCHAR *src;
 +    WCHAR *tpath, *dst;
 +    HRESULT ret;
 +
 +    TRACE("(%s,%p,%p,0x%08x)\n", debugstr_w(pszUrl), pszPath, pcchPath, dwReserved);
 +
 +    if (!pszUrl || !pszPath || !pcchPath || !*pcchPath)
 +        return E_INVALIDARG;
 +
 +    if (CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, pszUrl, 5,
 +                       file_colon, 5) != CSTR_EQUAL)
 +        return E_INVALIDARG;
 +    pszUrl += 5;
 +    ret = S_OK;
 +
 +    src = pszUrl;
 +    nslashes = 0;
 +    while (*src == '/' || *src == '\\') {
 +        nslashes++;
 +        src++;
 +    }
 +
 +    /* We need a temporary buffer so we can compute what size to ask for.
 +     * We know that the final string won't be longer than the current pszUrl
 +     * plus at most two backslashes. All the other transformations make it
 +     * shorter.
 +     */
 +    len = 2 + lstrlenW(pszUrl) + 1;
 +    if (*pcchPath < len)
 +        tpath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 +    else
 +        tpath = pszPath;
 +
 +    len = 0;
 +    dst = tpath;
 +    unescape = 1;
 +    switch (nslashes)
 +    {
 +    case 0:
 +        /* 'file:' + escaped DOS path */
 +        break;
 +    case 1:
 +        /* 'file:/' + escaped DOS path */
 +        /* fall through */
 +    case 3:
 +        /* 'file:///' (implied localhost) + escaped DOS path */
 +        if (!isalphaW(*src) || (src[1] != ':' && src[1] != '|'))
 +            src -= 1;
 +        break;
 +    case 2:
 +        if (CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, src, 9,
 +                           localhost, 9) == CSTR_EQUAL &&
 +            (src[9] == '/' || src[9] == '\\'))
 +        {
 +            /* 'file://localhost/' + escaped DOS path */
 +            src += 10;
 +        }
 +        else if (isalphaW(*src) && (src[1] == ':' || src[1] == '|'))
 +        {
 +            /* 'file://' + unescaped DOS path */
 +            unescape = 0;
 +        }
 +        else
 +        {
 +            /*    'file://hostname:port/path' (where path is escaped)
 +             * or 'file:' + escaped UNC path (\\server\share\path)
 +             * The second form is clearly specific to Windows and it might
 +             * even be doing a network lookup to try to figure it out.
 +             */
 +            while (*src && *src != '/' && *src != '\\')
 +                src++;
 +            len = src - pszUrl;
 +            StrCpyNW(dst, pszUrl, len + 1);
 +            dst += len;
 +            if (isalphaW(src[1]) && (src[2] == ':' || src[2] == '|'))
 +            {
 +                /* 'Forget' to add a trailing '/', just like Windows */
 +                src++;
 +            }
 +        }
 +        break;
 +    case 4:
 +        /* 'file://' + unescaped UNC path (\\server\share\path) */
 +        unescape = 0;
 +        if (isalphaW(*src) && (src[1] == ':' || src[1] == '|'))
 +            break;
 +        /* fall through */
 +    default:
 +        /* 'file:/...' + escaped UNC path (\\server\share\path) */
 +        src -= 2;
 +    }
 +
 +    /* Copy the remainder of the path */
 +    len += lstrlenW(src);
 +    StrCpyW(dst, src);
 +
 +     /* First do the Windows-specific path conversions */
 +    for (dst = tpath; *dst; dst++)
 +        if (*dst == '/') *dst = '\\';
 +    if (isalphaW(*tpath) && tpath[1] == '|')
 +        tpath[1] = ':'; /* c| -> c: */
 +
 +    /* And only then unescape the path (i.e. escaped slashes are left as is) */
 +    if (unescape)
 +    {
 +        ret = UrlUnescapeW(tpath, NULL, &len, URL_UNESCAPE_INPLACE);
 +        if (ret == S_OK)
 +        {
 +            /* When working in-place UrlUnescapeW() does not set len */
 +            len = lstrlenW(tpath);
 +        }
 +    }
 +
 +    if (*pcchPath < len + 1)
 +    {
 +        ret = E_POINTER;
 +        *pcchPath = len + 1;
 +    }
 +    else
 +    {
 +        *pcchPath = len;
 +        if (tpath != pszPath)
 +            StrCpyW(pszPath, tpath);
 +    }
 +    if (tpath != pszPath)
 +      HeapFree(GetProcessHeap(), 0, tpath);
 +
 +    TRACE("Returning (%u) %s\n", *pcchPath, debugstr_w(pszPath));
 +    return ret;
 +}
 +
 +/*************************************************************************
 + * PathCreateFromUrlAlloc   [SHLWAPI.@]
 + */
 +HRESULT WINAPI PathCreateFromUrlAlloc(LPCWSTR pszUrl, LPWSTR *pszPath,
 +                                      DWORD dwReserved)
 +{
 +    WCHAR pathW[MAX_PATH];
 +    DWORD size;
 +    HRESULT hr;
 +
 +    size = MAX_PATH;
 +    hr = PathCreateFromUrlW(pszUrl, pathW, &size, dwReserved);
 +    if (SUCCEEDED(hr))
 +    {
 +        /* Yes, this is supposed to crash if pszPath is NULL */
 +        *pszPath = StrDupW(pathW);
 +    }
 +    return hr;
 +}
 +
 +/*************************************************************************
 + * PathRelativePathToA   [SHLWAPI.@]
 + *
 + * Create a relative path from one path to another.
 + *
 + * PARAMS
 + *  lpszPath   [O] Destination for relative path
 + *  lpszFrom   [I] Source path
 + *  dwAttrFrom [I] File attribute of source path
 + *  lpszTo     [I] Destination path
 + *  dwAttrTo   [I] File attributes of destination path
 + *
 + * RETURNS
 + *  TRUE  If a relative path can be formed. lpszPath contains the new path
 + *  FALSE If the paths are not relative or any parameters are invalid
 + *
 + * NOTES
 + *  lpszTo should be at least MAX_PATH in length.
 + *
 + *  Calling this function with relative paths for lpszFrom or lpszTo may
 + *  give erroneous results.
 + *
 + *  The Win32 version of this function contains a bug where the lpszTo string
 + *  may be referenced 1 byte beyond the end of the string. As a result random
 + *  garbage may be written to the output path, depending on what lies beyond
 + *  the last byte of the string. This bug occurs because of the behaviour of
 + *  PathCommonPrefix() (see notes for that function), and no workaround seems
 + *  possible with Win32.
 + *
 + *  This bug has been fixed here, so for example the relative path from "\\"
 + *  to "\\" is correctly determined as "." in this implementation.
 + */
 +BOOL WINAPI PathRelativePathToA(LPSTR lpszPath, LPCSTR lpszFrom, DWORD dwAttrFrom,
 +                                LPCSTR lpszTo, DWORD dwAttrTo)
 +{
 +  BOOL bRet = FALSE;
 +
 +  TRACE("(%p,%s,0x%08x,%s,0x%08x)\n", lpszPath, debugstr_a(lpszFrom),
 +        dwAttrFrom, debugstr_a(lpszTo), dwAttrTo);
 +
 +  if(lpszPath && lpszFrom && lpszTo)
 +  {
 +    WCHAR szPath[MAX_PATH];
 +    WCHAR szFrom[MAX_PATH];
 +    WCHAR szTo[MAX_PATH];
 +    MultiByteToWideChar(CP_ACP,0,lpszFrom,-1,szFrom,MAX_PATH);
 +    MultiByteToWideChar(CP_ACP,0,lpszTo,-1,szTo,MAX_PATH);
 +    bRet = PathRelativePathToW(szPath,szFrom,dwAttrFrom,szTo,dwAttrTo);
 +    WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
 +  }
 +  return bRet;
 +}
 +
 +/*************************************************************************
 + * PathRelativePathToW   [SHLWAPI.@]
 + *
 + * See PathRelativePathToA.
 + */
 +BOOL WINAPI PathRelativePathToW(LPWSTR lpszPath, LPCWSTR lpszFrom, DWORD dwAttrFrom,
 +                                LPCWSTR lpszTo, DWORD dwAttrTo)
 +{
 +  static const WCHAR szPrevDirSlash[] = { '.', '.', '\\', '\0' };
 +  static const WCHAR szPrevDir[] = { '.', '.', '\0' };
 +  WCHAR szFrom[MAX_PATH];
 +  WCHAR szTo[MAX_PATH];
 +  DWORD dwLen;
 +
 +  TRACE("(%p,%s,0x%08x,%s,0x%08x)\n", lpszPath, debugstr_w(lpszFrom),
 +        dwAttrFrom, debugstr_w(lpszTo), dwAttrTo);
 +
 +  if(!lpszPath || !lpszFrom || !lpszTo)
 +    return FALSE;
 +
 +  *lpszPath = '\0';
 +  lstrcpynW(szFrom, lpszFrom, MAX_PATH);
 +  lstrcpynW(szTo, lpszTo, MAX_PATH);
 +
 +  if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
 +    PathRemoveFileSpecW(szFrom);
++  if(!(dwAttrTo & FILE_ATTRIBUTE_DIRECTORY))
 +    PathRemoveFileSpecW(szTo);
 +
 +  /* Paths can only be relative if they have a common root */
 +  if(!(dwLen = PathCommonPrefixW(szFrom, szTo, 0)))
 +    return FALSE;
 +
 +  /* Strip off lpszFrom components to the root, by adding "..\" */
 +  lpszFrom = szFrom + dwLen;
 +  if (!*lpszFrom)
 +  {
 +    lpszPath[0] = '.';
 +    lpszPath[1] = '\0';
 +  }
 +  if (*lpszFrom == '\\')
 +    lpszFrom++;
 +
 +  while (*lpszFrom)
 +  {
 +    lpszFrom = PathFindNextComponentW(lpszFrom);
 +    strcatW(lpszPath, *lpszFrom ? szPrevDirSlash : szPrevDir);
 +  }
 +
 +  /* From the root add the components of lpszTo */
 +  lpszTo += dwLen;
 +  /* We check lpszTo[-1] to avoid skipping end of string. See the notes for
 +   * this function.
 +   */
 +  if (*lpszTo && lpszTo[-1])
 +  {
 +    if (*lpszTo != '\\')
 +      lpszTo--;
 +    dwLen = strlenW(lpszPath);
 +    if (dwLen + strlenW(lpszTo) >= MAX_PATH)
 +    {
 +      *lpszPath = '\0';
 +      return FALSE;
 +    }
 +    strcpyW(lpszPath + dwLen, lpszTo);
 +  }
 +  return TRUE;
 +}
 +
 +/*************************************************************************
 + * PathUnmakeSystemFolderA   [SHLWAPI.@]
 + *
 + * Remove the system folder attributes from a path.
 + *
 + * PARAMS
 + *  lpszPath [I] The path to remove attributes from
 + *
 + * RETURNS
 + *  Success: TRUE.
 + *  Failure: FALSE, if lpszPath is NULL, empty, not a directory, or calling
 + *           SetFileAttributesA() fails.
 + */
 +BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR lpszPath)
 +{
 +  DWORD dwAttr;
 +
 +  TRACE("(%s)\n", debugstr_a(lpszPath));
 +
 +  if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
 +      !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
 +    return FALSE;
 +
 +  dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
 +  return SetFileAttributesA(lpszPath, dwAttr);
 +}
 +
 +/*************************************************************************
 + * PathUnmakeSystemFolderW   [SHLWAPI.@]
 + *
 + * See PathUnmakeSystemFolderA.
 + */
 +BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR lpszPath)
 +{
 +  DWORD dwAttr;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
 +    !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
 +    return FALSE;
 +
 +  dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
 +  return SetFileAttributesW(lpszPath, dwAttr);
 +}
 +
 +
 +/*************************************************************************
 + * PathSetDlgItemPathA   [SHLWAPI.@]
 + *
 + * Set the text of a dialog item to a path, shrinking the path to fit
 + * if it is too big for the item.
 + *
 + * PARAMS
 + *  hDlg     [I] Dialog handle
 + *  id       [I] ID of item in the dialog
 + *  lpszPath [I] Path to set as the items text
 + *
 + * RETURNS
 + *  Nothing.
 + *
 + * NOTES
 + *  If lpszPath is NULL, a blank string ("") is set (i.e. The previous
 + *  window text is erased).
 + */
 +VOID WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR lpszPath)
 +{
 +  WCHAR szPath[MAX_PATH];
 +
 +  TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_a(lpszPath));
 +
 +  if (lpszPath)
 +    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
 +  else
 +    szPath[0] = '\0';
 +  PathSetDlgItemPathW(hDlg, id, szPath);
 +}
 +
 +/*************************************************************************
 + * PathSetDlgItemPathW   [SHLWAPI.@]
 + *
 + * See PathSetDlgItemPathA.
 + */
 +VOID WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR lpszPath)
 +{
 +  WCHAR path[MAX_PATH + 1];
 +  HWND hwItem;
 +  RECT rect;
 +  HDC hdc;
 +  HGDIOBJ hPrevObj;
 +
 +  TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_w(lpszPath));
 +
 +  if (!(hwItem = GetDlgItem(hDlg, id)))
 +    return;
 +
 +  if (lpszPath)
 +    lstrcpynW(path, lpszPath, sizeof(path) / sizeof(WCHAR));
 +  else
 +    path[0] = '\0';
 +
 +  GetClientRect(hwItem, &rect);
 +  hdc = GetDC(hDlg);
 +  hPrevObj = SelectObject(hdc, (HGDIOBJ)SendMessageW(hwItem,WM_GETFONT,0,0));
 +
 +  if (hPrevObj)
 +  {
 +    PathCompactPathW(hdc, path, rect.right);
 +    SelectObject(hdc, hPrevObj);
 +  }
 +
 +  ReleaseDC(hDlg, hdc);
 +  SetWindowTextW(hwItem, path);
 +}
 +
 +/*************************************************************************
 + * PathIsNetworkPathA [SHLWAPI.@]
 + *
 + * Determine if the given path is a network path.
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *
 + * RETURNS
 + *  TRUE  If lpszPath is a UNC share or mapped network drive, or
 + *  FALSE If lpszPath is a local drive or cannot be determined
 + */
 +BOOL WINAPI PathIsNetworkPathA(LPCSTR lpszPath)
 +{
 +  int dwDriveNum;
 +
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +  if (*lpszPath == '\\' && lpszPath[1] == '\\')
 +    return TRUE;
 +  dwDriveNum = PathGetDriveNumberA(lpszPath);
 +  if (dwDriveNum == -1)
 +    return FALSE;
 +  GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
 +  return pIsNetDrive(dwDriveNum);
 +}
 +
 +/*************************************************************************
 + * PathIsNetworkPathW [SHLWAPI.@]
 + *
 + * See PathIsNetworkPathA.
 + */
 +BOOL WINAPI PathIsNetworkPathW(LPCWSTR lpszPath)
 +{
 +  int dwDriveNum;
 +
 +  TRACE("(%s)\n", debugstr_w(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +  if (*lpszPath == '\\' && lpszPath[1] == '\\')
 +    return TRUE;
 +  dwDriveNum = PathGetDriveNumberW(lpszPath);
 +  if (dwDriveNum == -1)
 +    return FALSE;
 +  GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
 +  return pIsNetDrive(dwDriveNum);
 +}
 +
 +/*************************************************************************
 + * PathIsLFNFileSpecA [SHLWAPI.@]
 + *
 + * Determine if the given path is a long file name
 + *
 + * PARAMS
 + *  lpszPath [I] Path to check
 + *
 + * RETURNS
 + *  TRUE  If path is a long file name,
 + *  FALSE If path is a valid DOS short file name
 + */
 +BOOL WINAPI PathIsLFNFileSpecA(LPCSTR lpszPath)
 +{
 +  DWORD dwNameLen = 0, dwExtLen = 0;
 +
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  while (*lpszPath)
 +  {
 +    if (*lpszPath == ' ')
 +      return TRUE; /* DOS names cannot have spaces */
 +    if (*lpszPath == '.')
 +    {
 +      if (dwExtLen)
 +        return TRUE; /* DOS names have only one dot */
 +      dwExtLen = 1;
 +    }
 +    else if (dwExtLen)
 +    {
 +      dwExtLen++;
 +      if (dwExtLen > 4)
 +        return TRUE; /* DOS extensions are <= 3 chars*/
 +    }
 +    else
 +    {
 +      dwNameLen++;
 +      if (dwNameLen > 8)
 +        return TRUE; /* DOS names are <= 8 chars */
 +    }
 +    lpszPath += IsDBCSLeadByte(*lpszPath) ? 2 : 1;
 +  }
 +  return FALSE; /* Valid DOS path */
 +}
 +
 +/*************************************************************************
 + * PathIsLFNFileSpecW [SHLWAPI.@]
 + *
 + * See PathIsLFNFileSpecA.
 + */
 +BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR lpszPath)
 +{
 +  DWORD dwNameLen = 0, dwExtLen = 0;
 +
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (!lpszPath)
 +    return FALSE;
 +
 +  while (*lpszPath)
 +  {
 +    if (*lpszPath == ' ')
 +      return TRUE; /* DOS names cannot have spaces */
 +    if (*lpszPath == '.')
 +    {
 +      if (dwExtLen)
 +        return TRUE; /* DOS names have only one dot */
 +      dwExtLen = 1;
 +    }
 +    else if (dwExtLen)
 +    {
 +      dwExtLen++;
 +      if (dwExtLen > 4)
 +        return TRUE; /* DOS extensions are <= 3 chars*/
 +    }
 +    else
 +    {
 +      dwNameLen++;
 +      if (dwNameLen > 8)
 +        return TRUE; /* DOS names are <= 8 chars */
 +    }
 +    lpszPath++;
 +  }
 +  return FALSE; /* Valid DOS path */
 +}
 +
 +/*************************************************************************
 + * PathIsDirectoryEmptyA [SHLWAPI.@]
 + *
 + * Determine if a given directory is empty.
 + *
 + * PARAMS
 + *  lpszPath [I] Directory to check
 + *
 + * RETURNS
 + *  TRUE  If the directory exists and contains no files,
 + *  FALSE Otherwise
 + */
 +BOOL WINAPI PathIsDirectoryEmptyA(LPCSTR lpszPath)
 +{
 +  BOOL bRet = FALSE;
 +
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    WCHAR szPath[MAX_PATH];
 +    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
 +    bRet = PathIsDirectoryEmptyW(szPath);
 +  }
 +  return bRet;
 +}
 +
 +/*************************************************************************
 + * PathIsDirectoryEmptyW [SHLWAPI.@]
 + *
 + * See PathIsDirectoryEmptyA.
 + */
 +BOOL WINAPI PathIsDirectoryEmptyW(LPCWSTR lpszPath)
 +{
 +  static const WCHAR szAllFiles[] = { '*', '.', '*', '\0' };
 +  WCHAR szSearch[MAX_PATH];
 +  DWORD dwLen;
 +  HANDLE hfind;
 +  BOOL retVal = FALSE;
 +  WIN32_FIND_DATAW find_data;
 +
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (!lpszPath || !PathIsDirectoryW(lpszPath))
 +      return FALSE;
 +
 +  lstrcpynW(szSearch, lpszPath, MAX_PATH);
 +  PathAddBackslashW(szSearch);
 +  dwLen = strlenW(szSearch);
 +  if (dwLen > MAX_PATH - 4)
 +    return FALSE;
 +
 +  strcpyW(szSearch + dwLen, szAllFiles);
 +  hfind = FindFirstFileW(szSearch, &find_data);
 +  if (hfind != INVALID_HANDLE_VALUE)
 +  {
 +    if (find_data.cFileName[0] == '.' && find_data.cFileName[1] == '.')
 +      /* The only directory entry should be the parent */
 +      retVal = !FindNextFileW(hfind, &find_data);
 +    FindClose(hfind);
 +  }
 +
 +  return retVal;
 +}
 +
 +
 +/*************************************************************************
 + * PathFindSuffixArrayA [SHLWAPI.@]
 + *
 + * Find a suffix string in an array of suffix strings
 + *
 + * PARAMS
 + *  lpszSuffix [I] Suffix string to search for
 + *  lppszArray [I] Array of suffix strings to search
 + *  dwCount    [I] Number of elements in lppszArray
 + *
 + * RETURNS
 + *  Success: The index of the position of lpszSuffix in lppszArray
 + *  Failure: 0, if any parameters are invalid or lpszSuffix is not found
 + *
 + * NOTES
 + *  The search is case sensitive.
 + *  The match is made against the end of the suffix string, so for example:
 + *  lpszSuffix="fooBAR" matches "BAR", but lpszSuffix="fooBARfoo" does not.
 + */
 +LPCSTR WINAPI PathFindSuffixArrayA(LPCSTR lpszSuffix, LPCSTR *lppszArray, int dwCount)
 +{
 +  size_t dwLen;
 +  int dwRet = 0;
 +
 +  TRACE("(%s,%p,%d)\n",debugstr_a(lpszSuffix), lppszArray, dwCount);
 +
 +  if (lpszSuffix && lppszArray && dwCount > 0)
 +  {
 +    dwLen = strlen(lpszSuffix);
 +
 +    while (dwRet < dwCount)
 +    {
 +      size_t dwCompareLen = strlen(*lppszArray);
 +      if (dwCompareLen < dwLen)
 +      {
 +        if (!strcmp(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
 +          return *lppszArray; /* Found */
 +      }
 +      dwRet++;
 +      lppszArray++;
 +    }
 +  }
 +  return NULL;
 +}
 +
 +/*************************************************************************
 + * PathFindSuffixArrayW [SHLWAPI.@]
 + *
 + * See PathFindSuffixArrayA.
 + */
 +LPCWSTR WINAPI PathFindSuffixArrayW(LPCWSTR lpszSuffix, LPCWSTR *lppszArray, int dwCount)
 +{
 +  size_t dwLen;
 +  int dwRet = 0;
 +
 +  TRACE("(%s,%p,%d)\n",debugstr_w(lpszSuffix), lppszArray, dwCount);
 +
 +  if (lpszSuffix && lppszArray && dwCount > 0)
 +  {
 +    dwLen = strlenW(lpszSuffix);
 +
 +    while (dwRet < dwCount)
 +    {
 +      size_t dwCompareLen = strlenW(*lppszArray);
 +      if (dwCompareLen < dwLen)
 +      {
 +        if (!strcmpW(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
 +          return *lppszArray; /* Found */
 +      }
 +      dwRet++;
 +      lppszArray++;
 +    }
 +  }
 +  return NULL;
 +}
 +
 +/*************************************************************************
 + * PathUndecorateA [SHLWAPI.@]
 + *
 + * Undecorate a file path
 + *
 + * PARAMS
 + *  lpszPath [I/O] Path to remove any decoration from
 + *
 + * RETURNS
 + *  Nothing
 + *
 + * NOTES
 + *  A decorations form is "path[n].ext" where "n" is an optional decimal number.
 + */
 +VOID WINAPI PathUndecorateA(LPSTR lpszPath)
 +{
 +  TRACE("(%s)\n",debugstr_a(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    LPSTR lpszExt = PathFindExtensionA(lpszPath);
 +    if (lpszExt > lpszPath && lpszExt[-1] == ']')
 +    {
 +      LPSTR lpszSkip = lpszExt - 2;
 +      if (*lpszSkip == '[')
 +        lpszSkip++;  /* [] (no number) */
 +      else
 +        while (lpszSkip > lpszPath && isdigit(lpszSkip[-1]))
 +          lpszSkip--;
 +      if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
 +      {
 +        /* remove the [n] */
 +        lpszSkip--;
 +        while (*lpszExt)
 +          *lpszSkip++ = *lpszExt++;
 +        *lpszSkip = '\0';
 +      }
 +    }
 +  }
 +}
 +
 +/*************************************************************************
 + * PathUndecorateW [SHLWAPI.@]
 + *
 + * See PathUndecorateA.
 + */
 +VOID WINAPI PathUndecorateW(LPWSTR lpszPath)
 +{
 +  TRACE("(%s)\n",debugstr_w(lpszPath));
 +
 +  if (lpszPath)
 +  {
 +    LPWSTR lpszExt = PathFindExtensionW(lpszPath);
 +    if (lpszExt > lpszPath && lpszExt[-1] == ']')
 +    {
 +      LPWSTR lpszSkip = lpszExt - 2;
 +      if (*lpszSkip == '[')
 +        lpszSkip++; /* [] (no number) */
 +      else
 +        while (lpszSkip > lpszPath && isdigitW(lpszSkip[-1]))
 +          lpszSkip--;
 +      if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
 +      {
 +        /* remove the [n] */
 +        lpszSkip--;
 +        while (*lpszExt)
 +          *lpszSkip++ = *lpszExt++;
 +        *lpszSkip = '\0';
 +      }
 +    }
 +  }
 +}
 +
 +/*************************************************************************
 + * PathUnExpandEnvStringsA [SHLWAPI.@]
 + *
 + * Substitute folder names in a path with their corresponding environment
 + * strings.
 + *
 + * PARAMS
 + *  path    [I] Buffer containing the path to unexpand.
 + *  buffer  [O] Buffer to receive the unexpanded path.
 + *  buf_len [I] Size of pszBuf in characters.
 + *
 + * RETURNS
 + *  Success: TRUE
 + *  Failure: FALSE
 + */
 +BOOL WINAPI PathUnExpandEnvStringsA(LPCSTR path, LPSTR buffer, UINT buf_len)
 +{
 +    WCHAR bufferW[MAX_PATH], *pathW;
 +    DWORD len;
 +    BOOL ret;
 +
 +    TRACE("(%s, %p, %d)\n", debugstr_a(path), buffer, buf_len);
 +
 +    pathW = heap_strdupAtoW(path);
 +    if (!pathW) return FALSE;
 +
 +    ret = PathUnExpandEnvStringsW(pathW, bufferW, MAX_PATH);
 +    HeapFree(GetProcessHeap(), 0, pathW);
 +    if (!ret) return FALSE;
 +
 +    len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
 +    if (buf_len < len + 1) return FALSE;
 +
 +    WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, buf_len, NULL, NULL);
 +    return TRUE;
 +}
 +
 +static const WCHAR allusersprofileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%',0};
 +static const WCHAR appdataW[] = {'%','A','P','P','D','A','T','A','%',0};
 +static const WCHAR computernameW[] = {'%','C','O','M','P','U','T','E','R','N','A','M','E','%',0};
 +static const WCHAR programfilesW[] = {'%','P','r','o','g','r','a','m','F','i','l','e','s','%',0};
 +static const WCHAR systemrootW[] = {'%','S','y','s','t','e','m','R','o','o','t','%',0};
 +static const WCHAR systemdriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%',0};
 +static const WCHAR userprofileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%',0};
 +
 +struct envvars_map
 +{
 +    const WCHAR *var;
 +    UINT  varlen;
 +    WCHAR path[MAX_PATH];
 +    DWORD len;
 +};
 +
 +static void init_envvars_map(struct envvars_map *map)
 +{
 +    while (map->var)
 +    {
 +        map->len = ExpandEnvironmentStringsW(map->var, map->path, sizeof(map->path)/sizeof(WCHAR));
 +        /* exclude null from length */
 +        if (map->len) map->len--;
 +        map++;
 +    }
 +}
 +
 +/*************************************************************************
 + * PathUnExpandEnvStringsW [SHLWAPI.@]
 + *
 + * Unicode version of PathUnExpandEnvStringsA.
 + */
 +BOOL WINAPI PathUnExpandEnvStringsW(LPCWSTR path, LPWSTR buffer, UINT buf_len)
 +{
 +    static struct envvars_map null_var = {NULL, 0, {0}, 0};
 +    struct envvars_map *match = &null_var, *cur;
 +    struct envvars_map envvars[] = {
 +        { allusersprofileW, sizeof(allusersprofileW)/sizeof(WCHAR) },
 +        { appdataW,         sizeof(appdataW)/sizeof(WCHAR)         },
 +        { computernameW,    sizeof(computernameW)/sizeof(WCHAR)    },
 +        { programfilesW,    sizeof(programfilesW)/sizeof(WCHAR)    },
 +        { systemrootW,      sizeof(systemrootW)/sizeof(WCHAR)      },
 +        { systemdriveW,     sizeof(systemdriveW)/sizeof(WCHAR)     },
 +        { userprofileW,     sizeof(userprofileW)/sizeof(WCHAR)     },
 +        { NULL }
 +    };
 +    DWORD pathlen;
 +    UINT  needed;
 +
 +    TRACE("(%s, %p, %d)\n", debugstr_w(path), buffer, buf_len);
 +
 +    pathlen = strlenW(path);
 +    init_envvars_map(envvars);
 +    cur = envvars;
 +    while (cur->var)
 +    {
 +        /* path can't contain expanded value or value wasn't retrieved */
 +        if (cur->len == 0 || cur->len > pathlen || strncmpiW(cur->path, path, cur->len))
 +        {
 +            cur++;
 +            continue;
 +        }
 +
 +        if (cur->len > match->len)
 +            match = cur;
 +        cur++;
 +    }
 +
 +    /* 'varlen' includes NULL termination char */
 +    needed = match->varlen + pathlen - match->len;
 +    if (match->len == 0 || needed > buf_len) return FALSE;
 +
 +    strcpyW(buffer, match->var);
 +    strcatW(buffer, &path[match->len]);
 +    TRACE("ret %s\n", debugstr_w(buffer));
 +
 +    return TRUE;
 +}
 +
 +/*************************************************************************
 + * @     [SHLWAPI.440]
 + *
 + * Find localised or default web content in "%WINDOWS%\web\".
 + *
 + * PARAMS
 + *  lpszFile  [I] File name containing content to look for
 + *  lpszPath  [O] Buffer to contain the full path to the file
 + *  dwPathLen [I] Length of lpszPath
 + *
 + * RETURNS
 + *  Success: S_OK. lpszPath contains the full path to the content.
 + *  Failure: E_FAIL. The content does not exist or lpszPath is too short.
 + */
 +HRESULT WINAPI SHGetWebFolderFilePathA(LPCSTR lpszFile, LPSTR lpszPath, DWORD dwPathLen)
 +{
 +  WCHAR szFile[MAX_PATH], szPath[MAX_PATH];
 +  HRESULT hRet;
 +
 +  TRACE("(%s,%p,%d)\n", lpszFile, lpszPath, dwPathLen);
 +
 +  MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, szFile, MAX_PATH);
 +  szPath[0] = '\0';
 +  hRet = SHGetWebFolderFilePathW(szFile, szPath, dwPathLen);
 +  WideCharToMultiByte(CP_ACP, 0, szPath, -1, lpszPath, dwPathLen, 0, 0);
 +  return hRet;
 +}
 +
 +/*************************************************************************
 + * @     [SHLWAPI.441]
 + *
 + * Unicode version of SHGetWebFolderFilePathA.
 + */
 +HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR lpszFile, LPWSTR lpszPath, DWORD dwPathLen)
 +{
 +  static const WCHAR szWeb[] = {'\\','W','e','b','\\','\0'};
 +  static const WCHAR szWebMui[] = {'m','u','i','\\','%','0','4','x','\\','\0'};
 +#define szWebLen (sizeof(szWeb)/sizeof(WCHAR))
 +#define szWebMuiLen ((sizeof(szWebMui)+1)/sizeof(WCHAR))
 +  DWORD dwLen, dwFileLen;
 +  LANGID lidSystem, lidUser;
 +
 +  TRACE("(%s,%p,%d)\n", debugstr_w(lpszFile), lpszPath, dwPathLen);
 +
 +  /* Get base directory for web content */
 +  dwLen = GetSystemWindowsDirectoryW(lpszPath, dwPathLen);
 +  if (dwLen > 0 && lpszPath[dwLen-1] == '\\')
 +    dwLen--;
 +
 +  dwFileLen = strlenW(lpszFile);
 +
 +  if (dwLen + dwFileLen + szWebLen >= dwPathLen)
 +    return E_FAIL; /* lpszPath too short */
 +
 +  strcpyW(lpszPath+dwLen, szWeb);
 +  dwLen += szWebLen;
 +  dwPathLen = dwPathLen - dwLen; /* Remaining space */
 +
 +  lidSystem = GetSystemDefaultUILanguage();
 +  lidUser = GetUserDefaultUILanguage();
 +
 +  if (lidSystem != lidUser)
 +  {
 +    if (dwFileLen + szWebMuiLen < dwPathLen)
 +    {
 +      /* Use localised content in the users UI language if present */
 +      wsprintfW(lpszPath + dwLen, szWebMui, lidUser);
 +      strcpyW(lpszPath + dwLen + szWebMuiLen, lpszFile);
 +      if (PathFileExistsW(lpszPath))
 +        return S_OK;
 +    }
 +  }
 +
 +  /* Fall back to OS default installed content */
 +  strcpyW(lpszPath + dwLen, lpszFile);
 +  if (PathFileExistsW(lpszPath))
 +    return S_OK;
 +  return E_FAIL;
 +}
 +
 +#define PATH_CHAR_CLASS_LETTER      0x00000001
 +#define PATH_CHAR_CLASS_ASTERIX     0x00000002
 +#define PATH_CHAR_CLASS_DOT         0x00000004
 +#define PATH_CHAR_CLASS_BACKSLASH   0x00000008
 +#define PATH_CHAR_CLASS_COLON       0x00000010
 +#define PATH_CHAR_CLASS_SEMICOLON   0x00000020
 +#define PATH_CHAR_CLASS_COMMA       0x00000040
 +#define PATH_CHAR_CLASS_SPACE       0x00000080
 +#define PATH_CHAR_CLASS_OTHER_VALID 0x00000100
 +#define PATH_CHAR_CLASS_DOUBLEQUOTE 0x00000200
 +
 +#define PATH_CHAR_CLASS_INVALID     0x00000000
 +#define PATH_CHAR_CLASS_ANY         0xffffffff
 +
 +static const DWORD SHELL_charclass[] =
 +{
 +    /* 0x00 */  PATH_CHAR_CLASS_INVALID,      /* 0x01 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x02 */  PATH_CHAR_CLASS_INVALID,      /* 0x03 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x04 */  PATH_CHAR_CLASS_INVALID,      /* 0x05 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x06 */  PATH_CHAR_CLASS_INVALID,      /* 0x07 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x08 */  PATH_CHAR_CLASS_INVALID,      /* 0x09 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x0a */  PATH_CHAR_CLASS_INVALID,      /* 0x0b */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x0c */  PATH_CHAR_CLASS_INVALID,      /* 0x0d */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x0e */  PATH_CHAR_CLASS_INVALID,      /* 0x0f */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x10 */  PATH_CHAR_CLASS_INVALID,      /* 0x11 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x12 */  PATH_CHAR_CLASS_INVALID,      /* 0x13 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x14 */  PATH_CHAR_CLASS_INVALID,      /* 0x15 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x16 */  PATH_CHAR_CLASS_INVALID,      /* 0x17 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x18 */  PATH_CHAR_CLASS_INVALID,      /* 0x19 */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x1a */  PATH_CHAR_CLASS_INVALID,      /* 0x1b */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x1c */  PATH_CHAR_CLASS_INVALID,      /* 0x1d */  PATH_CHAR_CLASS_INVALID,
 +    /* 0x1e */  PATH_CHAR_CLASS_INVALID,      /* 0x1f */  PATH_CHAR_CLASS_INVALID,
 +    /* ' '  */  PATH_CHAR_CLASS_SPACE,        /* '!'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '"'  */  PATH_CHAR_CLASS_DOUBLEQUOTE,  /* '#'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '$'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '%'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '&'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '\'' */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '('  */  PATH_CHAR_CLASS_OTHER_VALID,  /* ')'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '*'  */  PATH_CHAR_CLASS_ASTERIX,      /* '+'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* ','  */  PATH_CHAR_CLASS_COMMA,        /* '-'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '.'  */  PATH_CHAR_CLASS_DOT,          /* '/'  */  PATH_CHAR_CLASS_INVALID,
 +    /* '0'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '1'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '2'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '3'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '4'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '5'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '6'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '7'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '8'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '9'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* ':'  */  PATH_CHAR_CLASS_COLON,        /* ';'  */  PATH_CHAR_CLASS_SEMICOLON,
 +    /* '<'  */  PATH_CHAR_CLASS_INVALID,      /* '='  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '>'  */  PATH_CHAR_CLASS_INVALID,      /* '?'  */  PATH_CHAR_CLASS_LETTER,
 +    /* '@'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* 'A'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'B'  */  PATH_CHAR_CLASS_ANY,          /* 'C'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'D'  */  PATH_CHAR_CLASS_ANY,          /* 'E'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'F'  */  PATH_CHAR_CLASS_ANY,          /* 'G'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'H'  */  PATH_CHAR_CLASS_ANY,          /* 'I'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'J'  */  PATH_CHAR_CLASS_ANY,          /* 'K'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'L'  */  PATH_CHAR_CLASS_ANY,          /* 'M'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'N'  */  PATH_CHAR_CLASS_ANY,          /* 'O'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'P'  */  PATH_CHAR_CLASS_ANY,          /* 'Q'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'R'  */  PATH_CHAR_CLASS_ANY,          /* 'S'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'T'  */  PATH_CHAR_CLASS_ANY,          /* 'U'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'V'  */  PATH_CHAR_CLASS_ANY,          /* 'W'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'X'  */  PATH_CHAR_CLASS_ANY,          /* 'Y'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'Z'  */  PATH_CHAR_CLASS_ANY,          /* '['  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '\\' */  PATH_CHAR_CLASS_BACKSLASH,    /* ']'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '^'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '_'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '`'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* 'a'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'b'  */  PATH_CHAR_CLASS_ANY,          /* 'c'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'd'  */  PATH_CHAR_CLASS_ANY,          /* 'e'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'f'  */  PATH_CHAR_CLASS_ANY,          /* 'g'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'h'  */  PATH_CHAR_CLASS_ANY,          /* 'i'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'j'  */  PATH_CHAR_CLASS_ANY,          /* 'k'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'l'  */  PATH_CHAR_CLASS_ANY,          /* 'm'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'n'  */  PATH_CHAR_CLASS_ANY,          /* 'o'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'p'  */  PATH_CHAR_CLASS_ANY,          /* 'q'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'r'  */  PATH_CHAR_CLASS_ANY,          /* 's'  */  PATH_CHAR_CLASS_ANY,
 +    /* 't'  */  PATH_CHAR_CLASS_ANY,          /* 'u'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'v'  */  PATH_CHAR_CLASS_ANY,          /* 'w'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'x'  */  PATH_CHAR_CLASS_ANY,          /* 'y'  */  PATH_CHAR_CLASS_ANY,
 +    /* 'z'  */  PATH_CHAR_CLASS_ANY,          /* '{'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '|'  */  PATH_CHAR_CLASS_INVALID,      /* '}'  */  PATH_CHAR_CLASS_OTHER_VALID,
 +    /* '~'  */  PATH_CHAR_CLASS_OTHER_VALID
 +};
 +
 +/*************************************************************************
 + * @     [SHLWAPI.455]
 + *
 + * Check if an ASCII char is of a certain class
 + */
 +BOOL WINAPI PathIsValidCharA( char c, DWORD class )
 +{
 +    if ((unsigned)c > 0x7e)
 +        return class & PATH_CHAR_CLASS_OTHER_VALID;
 +
 +    return class & SHELL_charclass[(unsigned)c];
 +}
 +
 +/*************************************************************************
 + * @     [SHLWAPI.456]
 + *
 + * Check if a Unicode char is of a certain class
 + */
 +BOOL WINAPI PathIsValidCharW( WCHAR c, DWORD class )
 +{
 +    if (c > 0x7e)
 +        return class & PATH_CHAR_CLASS_OTHER_VALID;
 +
 +    return class & SHELL_charclass[c];
 +}
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 0000000,088e9e6..088e9e6
mode 000000,100644..100644
--- /dev/null
index 0000000,7a13b4b..7a13b4b
mode 000000,100644..100644
--- /dev/null
index 0000000,b4b6c7d..b4b6c7d
mode 000000,100644..100644
--- /dev/null
index 0000000,eb80822..eb80822
mode 000000,100644..100644
--- /dev/null
index c0a205c,0000000..b38a982
mode 100644,000000..100644
--- /dev/null
@@@ -1,4426 -1,0 +1,4437 @@@
-     _In_ PUNICODE_STRING SectionName,
 +/*++ NDK Version: 0098
 +
 +Copyright (c) Alex Ionescu.  All rights reserved.
 +
 +Header Name:
 +
 +    rtlfuncs.h
 +
 +Abstract:
 +
 +    Function definitions for the Run-Time Library
 +
 +Author:
 +
 +    Alex Ionescu (alexi@tinykrnl.org) - Updated - 27-Feb-2006
 +
 +--*/
 +
 +#ifndef _RTLFUNCS_H
 +#define _RTLFUNCS_H
 +
 +//
 +// Dependencies
 +//
 +#include <umtypes.h>
 +#include <ntnls.h>
 +#include <rtltypes.h>
 +#include <pstypes.h>
 +#include <extypes.h>
 +#include "in6addr.h"
 +#include "inaddr.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +#ifdef NTOS_MODE_USER
 +
 +//
 +// List Functions
 +//
 +FORCEINLINE
 +VOID
 +InitializeListHead(
 +    _Out_ PLIST_ENTRY ListHead
 +)
 +{
 +    ListHead->Flink = ListHead->Blink = ListHead;
 +}
 +
 +FORCEINLINE
 +VOID
 +InsertHeadList(
 +    _Inout_ PLIST_ENTRY ListHead,
 +    _Inout_ PLIST_ENTRY Entry
 +)
 +{
 +    PLIST_ENTRY OldFlink;
 +    OldFlink = ListHead->Flink;
 +    Entry->Flink = OldFlink;
 +    Entry->Blink = ListHead;
 +    OldFlink->Blink = Entry;
 +    ListHead->Flink = Entry;
 +}
 +
 +FORCEINLINE
 +VOID
 +InsertTailList(
 +    _Inout_ PLIST_ENTRY ListHead,
 +    _Inout_ PLIST_ENTRY Entry
 +)
 +{
 +    PLIST_ENTRY OldBlink;
 +    OldBlink = ListHead->Blink;
 +    Entry->Flink = ListHead;
 +    Entry->Blink = OldBlink;
 +    OldBlink->Flink = Entry;
 +    ListHead->Blink = Entry;
 +}
 +
 +_Must_inspect_result_
 +FORCEINLINE
 +BOOLEAN
 +IsListEmpty(
 +    _In_ const LIST_ENTRY * ListHead
 +)
 +{
 +    return (BOOLEAN)(ListHead->Flink == ListHead);
 +}
 +
 +FORCEINLINE
 +PSINGLE_LIST_ENTRY
 +PopEntryList(
 +    _Inout_ PSINGLE_LIST_ENTRY ListHead
 +)
 +{
 +    PSINGLE_LIST_ENTRY FirstEntry;
 +    FirstEntry = ListHead->Next;
 +    if (FirstEntry != NULL) {
 +        ListHead->Next = FirstEntry->Next;
 +    }
 +
 +    return FirstEntry;
 +}
 +
 +FORCEINLINE
 +VOID
 +PushEntryList(
 +    _Inout_ PSINGLE_LIST_ENTRY ListHead,
 +    _Inout_ PSINGLE_LIST_ENTRY Entry
 +)
 +{
 +    Entry->Next = ListHead->Next;
 +    ListHead->Next = Entry;
 +}
 +
 +FORCEINLINE
 +BOOLEAN
 +RemoveEntryList(
 +    _In_ PLIST_ENTRY Entry)
 +{
 +    PLIST_ENTRY OldFlink;
 +    PLIST_ENTRY OldBlink;
 +
 +    OldFlink = Entry->Flink;
 +    OldBlink = Entry->Blink;
 +    OldFlink->Blink = OldBlink;
 +    OldBlink->Flink = OldFlink;
 +    return (BOOLEAN)(OldFlink == OldBlink);
 +}
 +
 +FORCEINLINE
 +PLIST_ENTRY
 +RemoveHeadList(
 +    _Inout_ PLIST_ENTRY ListHead)
 +{
 +    PLIST_ENTRY Flink;
 +    PLIST_ENTRY Entry;
 +
 +    Entry = ListHead->Flink;
 +    Flink = Entry->Flink;
 +    ListHead->Flink = Flink;
 +    Flink->Blink = ListHead;
 +    return Entry;
 +}
 +
 +FORCEINLINE
 +PLIST_ENTRY
 +RemoveTailList(
 +    _Inout_ PLIST_ENTRY ListHead)
 +{
 +    PLIST_ENTRY Blink;
 +    PLIST_ENTRY Entry;
 +
 +    Entry = ListHead->Blink;
 +    Blink = Entry->Blink;
 +    ListHead->Blink = Blink;
 +    Blink->Flink = ListHead;
 +    return Entry;
 +}
 +
 +//
 +// Unicode string macros
 +//
 +_At_(UnicodeString->Buffer, _Post_equal_to_(Buffer))
 +_At_(UnicodeString->Length, _Post_equal_to_(0))
 +_At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize))
 +FORCEINLINE
 +VOID
 +RtlInitEmptyUnicodeString(
 +    _Out_ PUNICODE_STRING UnicodeString,
 +    _When_(BufferSize != 0, _Notnull_) _Writable_bytes_(BufferSize) __drv_aliasesMem PWCHAR Buffer,
 +    _In_ USHORT BufferSize)
 +{
 +    UnicodeString->Length = 0;
 +    UnicodeString->MaximumLength = BufferSize;
 +    UnicodeString->Buffer = Buffer;
 +}
 +
 +_At_(AnsiString->Buffer, _Post_equal_to_(Buffer))
 +_At_(AnsiString->Length, _Post_equal_to_(0))
 +_At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize))
 +FORCEINLINE
 +VOID
 +RtlInitEmptyAnsiString(
 +    _Out_ PANSI_STRING AnsiString,
 +    _When_(BufferSize != 0, _Notnull_) _Writable_bytes_(BufferSize) __drv_aliasesMem PCHAR Buffer,
 +    _In_ USHORT BufferSize)
 +{
 +    AnsiString->Length = 0;
 +    AnsiString->MaximumLength = BufferSize;
 +    AnsiString->Buffer = Buffer;
 +}
 +
 +//
 +// LUID Macros
 +//
 +#define RtlEqualLuid(L1, L2) (((L1)->HighPart == (L2)->HighPart) && \
 +                              ((L1)->LowPart  == (L2)->LowPart))
 +FORCEINLINE
 +LUID
 +NTAPI_INLINE
 +RtlConvertUlongToLuid(
 +    _In_ ULONG Ulong)
 +{
 +    LUID TempLuid;
 +
 +    TempLuid.LowPart = Ulong;
 +    TempLuid.HighPart = 0;
 +    return TempLuid;
 +}
 +
 +//
 +// ASSERT Macros
 +//
 +#ifndef ASSERT
 +#if DBG
 +
 +#define ASSERT( exp ) \
 +    ((void)((!(exp)) ? \
 +        (RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ),FALSE) : \
 +        TRUE))
 +
 +#define ASSERTMSG( msg, exp ) \
 +    ((void)((!(exp)) ? \
 +        (RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ),FALSE) : \
 +        TRUE))
 +
 +#else
 +
 +#define ASSERT( exp )         ((void) 0)
 +#define ASSERTMSG( msg, exp ) ((void) 0)
 +
 +#endif
 +#endif
 +
 +#ifdef NTOS_KERNEL_RUNTIME
 +
 +//
 +// Executing RTL functions at DISPATCH_LEVEL or higher will result in a
 +// bugcheck.
 +//
 +#define RTL_PAGED_CODE PAGED_CODE
 +
 +#else
 +
 +//
 +// This macro does nothing in user mode
 +//
 +#define RTL_PAGED_CODE NOP_FUNCTION
 +
 +#endif
 +
 +//
 +// RTL Splay Tree Functions
 +//
 +#ifndef RTL_USE_AVL_TABLES
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlInitializeGenericTable(
 +    _Out_ PRTL_GENERIC_TABLE Table,
 +    _In_ PRTL_GENERIC_COMPARE_ROUTINE CompareRoutine,
 +    _In_opt_ PRTL_GENERIC_ALLOCATE_ROUTINE AllocateRoutine,
 +    _In_opt_ PRTL_GENERIC_FREE_ROUTINE FreeRoutine,
 +    _In_opt_ PVOID TableContext
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlInsertElementGenericTable(
 +    _In_ PRTL_GENERIC_TABLE Table,
 +    _In_reads_bytes_(BufferSize) PVOID Buffer,
 +    _In_ CLONG BufferSize,
 +    _Out_opt_ PBOOLEAN NewElement
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlInsertElementGenericTableFull(
 +    _In_ PRTL_GENERIC_TABLE Table,
 +    _In_reads_bytes_(BufferSize) PVOID Buffer,
 +    _In_ CLONG BufferSize,
 +    _Out_opt_ PBOOLEAN NewElement,
 +    _In_ PVOID NodeOrParent,
 +    _In_ TABLE_SEARCH_RESULT SearchResult
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlDeleteElementGenericTable(
 +    _In_ PRTL_GENERIC_TABLE Table,
 +    _In_ PVOID Buffer
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlLookupElementGenericTable(
 +    _In_ PRTL_GENERIC_TABLE Table,
 +    _In_ PVOID Buffer
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlLookupElementGenericTableFull(
 +    _In_ PRTL_GENERIC_TABLE Table,
 +    _In_ PVOID Buffer,
 +    _Out_ PVOID *NodeOrParent,
 +    _Out_ TABLE_SEARCH_RESULT *SearchResult
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlEnumerateGenericTable(
 +    _In_ PRTL_GENERIC_TABLE Table,
 +    _In_ BOOLEAN Restart
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlEnumerateGenericTableWithoutSplaying(
 +    _In_ PRTL_GENERIC_TABLE Table,
 +    _Inout_ PVOID *RestartKey
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlGetElementGenericTable(
 +    _In_ PRTL_GENERIC_TABLE Table,
 +    _In_ ULONG I
 +);
 +
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlNumberGenericTableElements(
 +    _In_ PRTL_GENERIC_TABLE Table
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlIsGenericTableEmpty(
 +    _In_ PRTL_GENERIC_TABLE Table
 +);
 +
 +#endif /* !RTL_USE_AVL_TABLES */
 +
 +NTSYSAPI
 +PRTL_SPLAY_LINKS
 +NTAPI
 +RtlSplay(
 +    _Inout_ PRTL_SPLAY_LINKS Links
 +);
 +
 +NTSYSAPI
 +PRTL_SPLAY_LINKS
 +NTAPI
 +RtlDelete(
 +    _In_ PRTL_SPLAY_LINKS Links
 +);
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlDeleteNoSplay(
 +    _In_ PRTL_SPLAY_LINKS Links,
 +    _Inout_ PRTL_SPLAY_LINKS *Root
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PRTL_SPLAY_LINKS
 +NTAPI
 +RtlSubtreeSuccessor(
 +    _In_ PRTL_SPLAY_LINKS Links
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PRTL_SPLAY_LINKS
 +NTAPI
 +RtlSubtreePredecessor(
 +    _In_ PRTL_SPLAY_LINKS Links
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PRTL_SPLAY_LINKS
 +NTAPI
 +RtlRealSuccessor(
 +    _In_ PRTL_SPLAY_LINKS Links
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PRTL_SPLAY_LINKS
 +NTAPI
 +RtlRealPredecessor(
 +    _In_ PRTL_SPLAY_LINKS Links
 +);
 +
 +#define RtlIsLeftChild(Links) \
 +    (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
 +
 +#define RtlIsRightChild(Links) \
 +    (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
 +
 +#define RtlRightChild(Links) \
 +    ((PRTL_SPLAY_LINKS)(Links))->RightChild
 +
 +#define RtlIsRoot(Links) \
 +    (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))
 +
 +#define RtlLeftChild(Links) \
 +    ((PRTL_SPLAY_LINKS)(Links))->LeftChild
 +
 +#define RtlParent(Links) \
 +    ((PRTL_SPLAY_LINKS)(Links))->Parent
 +
 +// FIXME: use inline function
 +
 +#define RtlInitializeSplayLinks(Links)                  \
 +    {                                                   \
 +        PRTL_SPLAY_LINKS _SplayLinks;                   \
 +        _SplayLinks = (PRTL_SPLAY_LINKS)(Links);        \
 +        _SplayLinks->Parent = _SplayLinks;              \
 +        _SplayLinks->LeftChild = NULL;                  \
 +        _SplayLinks->RightChild = NULL;                 \
 +    }
 +
 +#define RtlInsertAsLeftChild(ParentLinks,ChildLinks)    \
 +    {                                                   \
 +        PRTL_SPLAY_LINKS _SplayParent;                  \
 +        PRTL_SPLAY_LINKS _SplayChild;                   \
 +        _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
 +        _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
 +        _SplayParent->LeftChild = _SplayChild;          \
 +        _SplayChild->Parent = _SplayParent;             \
 +    }
 +
 +#define RtlInsertAsRightChild(ParentLinks,ChildLinks)   \
 +    {                                                   \
 +        PRTL_SPLAY_LINKS _SplayParent;                  \
 +        PRTL_SPLAY_LINKS _SplayChild;                   \
 +        _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
 +        _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
 +        _SplayParent->RightChild = _SplayChild;         \
 +        _SplayChild->Parent = _SplayParent;             \
 +    }
 +
 +//
 +// RTL AVL Tree Functions
 +//
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlInitializeGenericTableAvl(
 +    _Out_ PRTL_AVL_TABLE Table,
 +    _In_ PRTL_AVL_COMPARE_ROUTINE CompareRoutine,
 +    _In_opt_ PRTL_AVL_ALLOCATE_ROUTINE AllocateRoutine,
 +    _In_opt_ PRTL_AVL_FREE_ROUTINE FreeRoutine,
 +    _In_opt_ PVOID TableContext
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlInsertElementGenericTableAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_reads_bytes_(BufferSize) PVOID Buffer,
 +    _In_ CLONG BufferSize,
 +    _Out_opt_ PBOOLEAN NewElement
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlInsertElementGenericTableFullAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_reads_bytes_(BufferSize) PVOID Buffer,
 +    _In_ CLONG BufferSize,
 +    _Out_opt_ PBOOLEAN NewElement,
 +    _In_ PVOID NodeOrParent,
 +    _In_ TABLE_SEARCH_RESULT SearchResult
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlDeleteElementGenericTableAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_ PVOID Buffer
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlLookupElementGenericTableAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_ PVOID Buffer
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlLookupElementGenericTableFullAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_ PVOID Buffer,
 +    _Out_ PVOID *NodeOrParent,
 +    _Out_ TABLE_SEARCH_RESULT *SearchResult
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlEnumerateGenericTableAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_ BOOLEAN Restart
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlEnumerateGenericTableWithoutSplayingAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _Inout_ PVOID *RestartKey
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlLookupFirstMatchingElementGenericTableAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_ PVOID Buffer,
 +    _Out_ PVOID *RestartKey
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlEnumerateGenericTableLikeADirectory(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_opt_ PRTL_AVL_MATCH_FUNCTION MatchFunction,
 +    _In_opt_ PVOID MatchData,
 +    _In_ ULONG NextFlag,
 +    _Inout_ PVOID *RestartKey,
 +    _Inout_ PULONG DeleteCount,
 +    _In_ PVOID Buffer
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlGetElementGenericTableAvl(
 +    _In_ PRTL_AVL_TABLE Table,
 +    _In_ ULONG I
 +);
 +
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlNumberGenericTableElementsAvl(
 +    _In_ PRTL_AVL_TABLE Table
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlIsGenericTableEmptyAvl(
 +    _In_ PRTL_AVL_TABLE Table
 +);
 +
 +#ifdef RTL_USE_AVL_TABLES
 +
 +#define RtlInitializeGenericTable               RtlInitializeGenericTableAvl
 +#define RtlInsertElementGenericTable            RtlInsertElementGenericTableAvl
 +#define RtlInsertElementGenericTableFull        RtlInsertElementGenericTableFullAvl
 +#define RtlDeleteElementGenericTable            RtlDeleteElementGenericTableAvl
 +#define RtlLookupElementGenericTable            RtlLookupElementGenericTableAvl
 +#define RtlLookupElementGenericTableFull        RtlLookupElementGenericTableFullAvl
 +#define RtlEnumerateGenericTable                RtlEnumerateGenericTableAvl
 +#define RtlEnumerateGenericTableWithoutSplaying RtlEnumerateGenericTableWithoutSplayingAvl
 +#define RtlGetElementGenericTable               RtlGetElementGenericTableAvl
 +#define RtlNumberGenericTableElements           RtlNumberGenericTableElementsAvl
 +#define RtlIsGenericTableEmpty                  RtlIsGenericTableEmptyAvl
 +
 +#endif /* RTL_USE_AVL_TABLES */
 +
 +//
 +// Error and Exception Functions
 +//
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlAddVectoredExceptionHandler(
 +    _In_ ULONG FirstHandler,
 +    _In_ PVECTORED_EXCEPTION_HANDLER VectoredHandler
 +);
 +
 +__analysis_noreturn
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlAssert(
 +    _In_ PVOID FailedAssertion,
 +    _In_ PVOID FileName,
 +    _In_ ULONG LineNumber,
 +    _In_opt_z_ PCHAR Message
 +);
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlSetUnhandledExceptionFilter(
 +    _In_ PRTLP_UNHANDLED_EXCEPTION_FILTER TopLevelExceptionFilter
 +);
 +
 +#endif /* NTOS_MODE_USER */
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlCaptureContext(
 +    _Out_ PCONTEXT ContextRecord
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlEncodePointer(
 +    _In_ PVOID Pointer
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlDecodePointer(
 +    _In_ PVOID Pointer
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlEncodeSystemPointer(
 +    _In_ PVOID Pointer
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlDecodeSystemPointer(
 +    _In_ PVOID Pointer
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlDispatchException(
 +    _In_ PEXCEPTION_RECORD ExceptionRecord,
 +    _In_ PCONTEXT Context
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +_When_(Status < 0, _Out_range_(>, 0))
 +_When_(Status >= 0, _Out_range_(==, 0))
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlNtStatusToDosError(
 +    _In_ NTSTATUS Status
 +);
 +
 +_When_(Status < 0, _Out_range_(>, 0))
 +_When_(Status >= 0, _Out_range_(==, 0))
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlNtStatusToDosErrorNoTeb(
 +    _In_ NTSTATUS Status
 +);
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlSetLastWin32ErrorAndNtStatusFromNtStatus(
 +    _In_ NTSTATUS Status
 +);
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlRaiseException(
 +    _In_ PEXCEPTION_RECORD ExceptionRecord
 +);
 +
 +DECLSPEC_NORETURN
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlRaiseStatus(
 +    _In_ NTSTATUS Status
 +);
 +
 +NTSYSAPI
 +LONG
 +NTAPI
 +RtlUnhandledExceptionFilter(
 +    _In_ struct _EXCEPTION_POINTERS* ExceptionInfo
 +);
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlUnwind(
 +    _In_opt_ PVOID TargetFrame,
 +    _In_opt_ PVOID TargetIp,
 +    _In_opt_ PEXCEPTION_RECORD ExceptionRecord,
 +    _In_ PVOID ReturnValue
 +);
 +
 +#define RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT 8
 +
 +//
 +// Tracing Functions
 +//
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlWalkFrameChain(
 +    _Out_writes_(Count - (Flags >> RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT)) PVOID *Callers,
 +    _In_ ULONG Count,
 +    _In_ ULONG Flags
 +);
 +
 +NTSYSAPI
 +USHORT
 +NTAPI
 +RtlLogStackBackTrace(
 +    VOID
 +);
 +
 +#ifdef NTOS_MODE_USER
 +//
 +// Heap Functions
 +//
 +_Must_inspect_result_
 +_Ret_maybenull_
 +_Post_writable_byte_size_(Size)
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlAllocateHeap(
 +    _In_ PVOID HeapHandle,
 +    _In_opt_ ULONG Flags,
 +    _In_ SIZE_T Size
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlCreateHeap(
 +    _In_ ULONG Flags,
 +    _In_opt_ PVOID BaseAddress,
 +    _In_opt_ SIZE_T SizeToReserve,
 +    _In_opt_ SIZE_T SizeToCommit,
 +    _In_opt_ PVOID Lock,
 +    _In_opt_ PRTL_HEAP_PARAMETERS Parameters
 +);
 +
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlCreateTagHeap(
 +    _In_ HANDLE HeapHandle,
 +    _In_ ULONG Flags,
 +    _In_ PWSTR TagName,
 +    _In_ PWSTR TagSubName
 +);
 +
 +ULONG
 +NTAPI
 +RtlCompactHeap(
 +    _In_ HANDLE Heap,
 +    _In_ ULONG Flags
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlDebugCreateHeap(
 +    _In_ ULONG Flags,
 +    _In_opt_ PVOID BaseAddress,
 +    _In_opt_ SIZE_T SizeToReserve,
 +    _In_opt_ SIZE_T SizeToCommit,
 +    _In_opt_ PVOID Lock,
 +    _In_opt_ PRTL_HEAP_PARAMETERS Parameters
 +);
 +
 +NTSYSAPI
 +HANDLE
 +NTAPI
 +RtlDestroyHeap(
 +    _In_ _Post_invalid_ HANDLE Heap
 +);
 +
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlExtendHeap(
 +    _In_ HANDLE Heap,
 +    _In_ ULONG Flags,
 +    _In_ PVOID P,
 +    _In_ SIZE_T Size
 +);
 +
 +_Success_(return != 0)
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlFreeHeap(
 +    _In_ HANDLE HeapHandle,
 +    _In_opt_ ULONG Flags,
 +    _In_ _Post_invalid_ PVOID P
 +);
 +
 +ULONG
 +NTAPI
 +RtlGetProcessHeaps(
 +    _In_ ULONG HeapCount,
 +    _Out_cap_(HeapCount) HANDLE *HeapArray
 +);
 +
 +_Success_(return != 0)
 +BOOLEAN
 +NTAPI
 +RtlGetUserInfoHeap(
 +    _In_ PVOID HeapHandle,
 +    _In_ ULONG Flags,
 +    _In_ PVOID BaseAddress,
 +    _Inout_opt_ PVOID *UserValue,
 +    _Out_opt_ PULONG UserFlags
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlProtectHeap(
 +    _In_ PVOID HeapHandle,
 +    _In_ BOOLEAN Protect
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlQueryHeapInformation(
 +    _In_ PVOID HeapHandle,
 +    _In_ HEAP_INFORMATION_CLASS HeapInformationClass,
 +    _Out_ PVOID HeapInformation,
 +    _In_ SIZE_T HeapInformationLength,
 +    _When_(HeapInformationClass==HeapCompatibilityInformation, _On_failure_(_Out_opt_))
 +        _Out_opt_ PSIZE_T ReturnLength
 +);
 +
 +_Ret_opt_z_
 +NTSYSAPI
 +PWSTR
 +NTAPI
 +RtlQueryTagHeap(
 +    _In_ PVOID HeapHandle,
 +    _In_ ULONG Flags,
 +    _In_ USHORT TagIndex,
 +    _In_ BOOLEAN ResetCounters,
 +    _Out_ PRTL_HEAP_TAG_INFO HeapTagInfo
 +);
 +
 +_Must_inspect_result_
 +_Ret_maybenull_
 +_Post_writable_byte_size_(Size)
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlReAllocateHeap(
 +    _In_ HANDLE Heap,
 +    _In_opt_ ULONG Flags,
 +    _In_ _Post_invalid_ PVOID Ptr,
 +    _In_ SIZE_T Size
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetHeapInformation(
 +    _In_ PVOID HeapHandle,
 +    _In_ HEAP_INFORMATION_CLASS HeapInformationClass,
 +    _When_(HeapInformationClass==HeapCompatibilityInformation,_In_) PVOID HeapInformation,
 +    _In_ SIZE_T HeapInformationLength
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlLockHeap(
 +    _In_ HANDLE Heap
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlMultipleAllocateHeap (
 +    _In_ HANDLE HeapHandle,
 +    _In_ ULONG Flags,
 +    _In_ SIZE_T Size,
 +    _In_ ULONG Count,
 +    _Out_cap_(Count) _Deref_post_bytecap_(Size) PVOID * Array
 +    );
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlMultipleFreeHeap (
 +    _In_ HANDLE HeapHandle,
 +    _In_ ULONG Flags,
 +    _In_ ULONG Count,
 +    _In_count_(Count) /* _Deref_ _Post_invalid_ */ PVOID * Array
 +    );
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUsageHeap(
 +    _In_ HANDLE Heap,
 +    _In_ ULONG Flags,
 +    _Out_ PRTL_HEAP_USAGE Usage
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlUnlockHeap(
 +    _In_ HANDLE Heap
 +);
 +
 +BOOLEAN
 +NTAPI
 +RtlSetUserValueHeap(
 +    _In_ PVOID HeapHandle,
 +    _In_ ULONG Flags,
 +    _In_ PVOID BaseAddress,
 +    _In_ PVOID UserValue
 +);
 +
 +BOOLEAN
 +NTAPI
 +RtlSetUserFlagsHeap(
 +    _In_ PVOID HeapHandle,
 +    _In_ ULONG Flags,
 +    _In_ PVOID BaseAddress,
 +    _In_ ULONG UserFlagsReset,
 +    _In_ ULONG UserFlagsSet
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlValidateHeap(
 +    _In_ HANDLE Heap,
 +    _In_ ULONG Flags,
 +    _In_opt_ PVOID P
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlWalkHeap(
 +    _In_ HANDLE HeapHandle,
 +    _In_ PVOID HeapEntry
 +);
 +
 +#define RtlGetProcessHeap() (NtCurrentPeb()->ProcessHeap)
 +
 +#endif // NTOS_MODE_USER
 +
 +NTSYSAPI
 +SIZE_T
 +NTAPI
 +RtlSizeHeap(
 +    _In_ PVOID HeapHandle,
 +    _In_ ULONG Flags,
 +    _In_ PVOID MemoryPointer
 +);
 +
 +
 +//
 +// Security Functions
 +//
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAbsoluteToSelfRelativeSD(
 +    _In_ PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor,
 +    _Out_writes_bytes_to_opt_(*BufferLength, *BufferLength) PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor,
 +    _Inout_ PULONG BufferLength
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAccessAllowedAce(
 +    _Inout_ PACL Acl,
 +    _In_ ULONG Revision,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_ PSID Sid
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAccessAllowedAceEx(
 +    _Inout_ PACL pAcl,
 +    _In_ ULONG dwAceRevision,
 +    _In_ ULONG AceFlags,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_ PSID pSid
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAccessAllowedObjectAce(
 +    _Inout_ PACL pAcl,
 +    _In_ ULONG dwAceRevision,
 +    _In_ ULONG AceFlags,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_opt_ GUID *ObjectTypeGuid,
 +    _In_opt_ GUID *InheritedObjectTypeGuid,
 +    _In_ PSID pSid
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAccessDeniedAce(
 +    _Inout_ PACL Acl,
 +    _In_ ULONG Revision,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_ PSID Sid
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAccessDeniedAceEx(
 +    _Inout_ PACL Acl,
 +    _In_ ULONG Revision,
 +    _In_ ULONG Flags,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_ PSID Sid
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAccessDeniedObjectAce(
 +    _Inout_ PACL pAcl,
 +    _In_ ULONG dwAceRevision,
 +    _In_ ULONG AceFlags,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_opt_ GUID *ObjectTypeGuid,
 +    _In_opt_ GUID *InheritedObjectTypeGuid,
 +    _In_ PSID pSid
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAce(
 +    _Inout_ PACL Acl,
 +    _In_ ULONG AceRevision,
 +    _In_ ULONG StartingAceIndex,
 +    _In_reads_bytes_(AceListLength) PVOID AceList,
 +    _In_ ULONG AceListLength
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAuditAccessAce(
 +    _Inout_ PACL Acl,
 +    _In_ ULONG Revision,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_ PSID Sid,
 +    _In_ BOOLEAN Success,
 +    _In_ BOOLEAN Failure
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAcquirePrivilege(
 +    _In_ PULONG Privilege,
 +    _In_ ULONG NumPriv,
 +    _In_ ULONG Flags,
 +    _Out_ PVOID *ReturnedState
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAuditAccessAceEx(
 +    _Inout_ PACL Acl,
 +    _In_ ULONG Revision,
 +    _In_ ULONG Flags,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_ PSID Sid,
 +    _In_ BOOLEAN Success,
 +    _In_ BOOLEAN Failure
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddAuditAccessObjectAce(
 +    _Inout_ PACL Acl,
 +    _In_ ULONG Revision,
 +    _In_ ULONG Flags,
 +    _In_ ACCESS_MASK AccessMask,
 +    _In_opt_ GUID *ObjectTypeGuid,
 +    _In_opt_ GUID *InheritedObjectTypeGuid,
 +    _In_ PSID Sid,
 +    _In_ BOOLEAN Success,
 +    _In_ BOOLEAN Failure
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAddMandatoryAce(
 +    _Inout_ PACL Acl,
 +    _In_ ULONG Revision,
 +    _In_ ULONG Flags,
 +    _In_ ULONG MandatoryFlags,
 +    _In_ UCHAR AceType,
 +    _In_ PSID LabelSid);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAdjustPrivilege(
 +    _In_ ULONG Privilege,
 +    _In_ BOOLEAN NewValue,
 +    _In_ BOOLEAN ForThread,
 +    _Out_ PBOOLEAN OldValue
 +);
 +
 +_Must_inspect_result_
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAllocateAndInitializeSid(
 +    _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
 +    _In_ UCHAR SubAuthorityCount,
 +    _In_ ULONG SubAuthority0,
 +    _In_ ULONG SubAuthority1,
 +    _In_ ULONG SubAuthority2,
 +    _In_ ULONG SubAuthority3,
 +    _In_ ULONG SubAuthority4,
 +    _In_ ULONG SubAuthority5,
 +    _In_ ULONG SubAuthority6,
 +    _In_ ULONG SubAuthority7,
 +    _Outptr_ PSID *Sid
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlAreAllAccessesGranted(
 +    ACCESS_MASK GrantedAccess,
 +    ACCESS_MASK DesiredAccess
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlAreAnyAccessesGranted(
 +    ACCESS_MASK GrantedAccess,
 +    ACCESS_MASK DesiredAccess
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlCopyLuid (
 +    _Out_ PLUID DestinationLuid,
 +    _In_ PLUID SourceLuid
 +    );
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlCopyLuidAndAttributesArray(
 +    ULONG Count,
 +    PLUID_AND_ATTRIBUTES Src,
 +    PLUID_AND_ATTRIBUTES Dest
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlCopySidAndAttributesArray(
 +    ULONG Count,
 +    PSID_AND_ATTRIBUTES Src,
 +    ULONG SidAreaSize,
 +    PSID_AND_ATTRIBUTES Dest,
 +    PVOID SidArea,
 +    PVOID* RemainingSidArea,
 +    PULONG RemainingSidAreaSize
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlConvertSidToUnicodeString(
 +    _Inout_ PUNICODE_STRING UnicodeString,
 +    _In_ PSID Sid,
 +    _In_ BOOLEAN AllocateDestinationString
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlCopySid(
 +    _In_ ULONG DestinationSidLength,
 +    _Out_writes_bytes_(DestinationSidLength) PSID DestinationSid,
 +    _In_ PSID SourceSid
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlCreateAcl(
 +    PACL Acl,
 +    ULONG AclSize,
 +    ULONG AclRevision
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlCreateSecurityDescriptor(
 +    _Out_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _In_ ULONG Revision
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlCreateSecurityDescriptorRelative(
 +    _Out_ PISECURITY_DESCRIPTOR_RELATIVE SecurityDescriptor,
 +    _In_ ULONG Revision
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlCopySecurityDescriptor(
 +    _In_ PSECURITY_DESCRIPTOR pSourceSecurityDescriptor,
 +    _Out_ PSECURITY_DESCRIPTOR *pDestinationSecurityDescriptor
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlDeleteAce(
 +    PACL Acl,
 +    ULONG AceIndex
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlEqualPrefixSid(
 +    PSID Sid1,
 +    PSID Sid2
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlEqualSid (
 +    _In_ PSID Sid1,
 +    _In_ PSID Sid2
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlFirstFreeAce(
 +    PACL Acl,
 +    PACE* Ace
 +);
 +
 +NTSYSAPI
 +PVOID
 +NTAPI
 +RtlFreeSid(
 +    _In_ _Post_invalid_ PSID Sid
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlGetAce(
 +    PACL Acl,
 +    ULONG AceIndex,
 +    PVOID *Ace
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlGetControlSecurityDescriptor(
 +    _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _Out_ PSECURITY_DESCRIPTOR_CONTROL Control,
 +    _Out_ PULONG Revision
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlGetDaclSecurityDescriptor(
 +    _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _Out_ PBOOLEAN DaclPresent,
 +    _Out_ PACL *Dacl,
 +    _Out_ PBOOLEAN DaclDefaulted
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlGetSaclSecurityDescriptor(
 +    _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _Out_ PBOOLEAN SaclPresent,
 +    _Out_ PACL* Sacl,
 +    _Out_ PBOOLEAN SaclDefaulted
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlGetGroupSecurityDescriptor(
 +    _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _Out_ PSID *Group,
 +    _Out_ PBOOLEAN GroupDefaulted
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlGetOwnerSecurityDescriptor(
 +    _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _Out_ PSID *Owner,
 +    _Out_ PBOOLEAN OwnerDefaulted
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlGetSecurityDescriptorRMControl(
 +    _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _Out_ PUCHAR RMControl
 +);
 +
 +NTSYSAPI
 +PSID_IDENTIFIER_AUTHORITY
 +NTAPI
 +RtlIdentifierAuthoritySid(PSID Sid);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlImpersonateSelf(IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlInitializeSid(
 +    _Out_ PSID Sid,
 +    _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
 +    _In_ UCHAR SubAuthorityCount
 +);
 +
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlLengthRequiredSid(IN ULONG SubAuthorityCount);
 +
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlLengthSid(IN PSID Sid);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlMakeSelfRelativeSD(
 +    _In_ PSECURITY_DESCRIPTOR AbsoluteSD,
 +    _Out_ PSECURITY_DESCRIPTOR SelfRelativeSD,
 +    _Inout_ PULONG BufferLength);
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlMapGenericMask(
 +    PACCESS_MASK AccessMask,
 +    PGENERIC_MAPPING GenericMapping
 +);
 +
 +#ifdef NTOS_MODE_USER
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlQueryInformationAcl(
 +    PACL Acl,
 +    PVOID Information,
 +    ULONG InformationLength,
 +    ACL_INFORMATION_CLASS InformationClass
 +);
 +
 +#endif
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlReleasePrivilege(
 +    _In_ PVOID ReturnedState
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSelfRelativeToAbsoluteSD(
 +    _In_ PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor,
 +    _Out_writes_bytes_to_opt_(*AbsoluteSecurityDescriptorSize, *AbsoluteSecurityDescriptorSize) PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor,
 +    _Inout_ PULONG AbsoluteSecurityDescriptorSize,
 +    _Out_writes_bytes_to_opt_(*DaclSize, *DaclSize) PACL Dacl,
 +    _Inout_ PULONG DaclSize,
 +    _Out_writes_bytes_to_opt_(*SaclSize, *SaclSize) PACL Sacl,
 +    _Inout_ PULONG SaclSize,
 +    _Out_writes_bytes_to_opt_(*OwnerSize, *OwnerSize) PSID Owner,
 +    _Inout_ PULONG OwnerSize,
 +    _Out_writes_bytes_to_opt_(*PrimaryGroupSize, *PrimaryGroupSize) PSID PrimaryGroup,
 +    _Inout_ PULONG PrimaryGroupSize
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSelfRelativeToAbsoluteSD2(
 +    _Inout_ PSECURITY_DESCRIPTOR SelfRelativeSD,
 +    _Out_ PULONG BufferSize
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetAttributesSecurityDescriptor(
 +    _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _In_ SECURITY_DESCRIPTOR_CONTROL Control,
 +    _Out_ PULONG Revision
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetControlSecurityDescriptor(
 +    _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _In_ SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,
 +    _In_ SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetDaclSecurityDescriptor(
 +    _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _In_ BOOLEAN DaclPresent,
 +    _In_opt_ PACL Dacl,
 +    _In_opt_ BOOLEAN DaclDefaulted
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetGroupSecurityDescriptor(
 +    _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _In_opt_ PSID Group,
 +    _In_opt_ BOOLEAN GroupDefaulted
 +);
 +
 +#ifdef NTOS_MODE_USER
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetInformationAcl(
 +    PACL Acl,
 +    PVOID Information,
 +    ULONG InformationLength,
 +    ACL_INFORMATION_CLASS InformationClass
 +);
 +
 +#endif
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetOwnerSecurityDescriptor(
 +    _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _In_opt_ PSID Owner,
 +    _In_opt_ BOOLEAN OwnerDefaulted
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetSaclSecurityDescriptor(
 +    _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _In_ BOOLEAN SaclPresent,
 +    _In_ PACL Sacl,
 +    _In_ BOOLEAN SaclDefaulted
 +);
 +
 +NTSYSAPI
 +VOID
 +NTAPI
 +RtlSetSecurityDescriptorRMControl(
 +    _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
 +    _In_ PUCHAR RMControl
 +);
 +
 +NTSYSAPI
 +PUCHAR
 +NTAPI
 +RtlSubAuthorityCountSid(
 +    _In_ PSID Sid
 +);
 +
 +NTSYSAPI
 +PULONG
 +NTAPI
 +RtlSubAuthoritySid(
 +    _In_ PSID Sid,
 +    _In_ ULONG SubAuthority
 +);
 +
 +_IRQL_requires_max_(APC_LEVEL)
 +_Must_inspect_result_
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlValidRelativeSecurityDescriptor(
 +    _In_reads_bytes_(SecurityDescriptorLength) PSECURITY_DESCRIPTOR SecurityDescriptorInput,
 +    _In_ ULONG SecurityDescriptorLength,
 +    _In_ SECURITY_INFORMATION RequiredInformation
 +);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlValidSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlValidSid(IN PSID Sid);
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlValidAcl(PACL Acl);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlDeleteSecurityObject(
 +    _In_ PSECURITY_DESCRIPTOR *ObjectDescriptor
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlNewSecurityObject(
 +    _In_ PSECURITY_DESCRIPTOR ParentDescriptor,
 +    _In_ PSECURITY_DESCRIPTOR CreatorDescriptor,
 +    _Out_ PSECURITY_DESCRIPTOR *NewDescriptor,
 +    _In_ BOOLEAN IsDirectoryObject,
 +    _In_ HANDLE Token,
 +    _In_ PGENERIC_MAPPING GenericMapping
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlQuerySecurityObject(
 +    _In_ PSECURITY_DESCRIPTOR ObjectDescriptor,
 +    _In_ SECURITY_INFORMATION SecurityInformation,
 +    _Out_ PSECURITY_DESCRIPTOR ResultantDescriptor,
 +    _In_ ULONG DescriptorLength,
 +    _Out_ PULONG ReturnLength
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlSetSecurityObject(
 +    _In_ SECURITY_INFORMATION SecurityInformation,
 +    _In_ PSECURITY_DESCRIPTOR ModificationDescriptor,
 +    _Out_ PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
 +    _In_ PGENERIC_MAPPING GenericMapping,
 +    _In_ HANDLE Token
 +);
 +
 +//
 +// Single-Character Functions
 +//
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlLargeIntegerToChar(
 +    _In_ PLARGE_INTEGER Value,
 +    _In_ ULONG Base,
 +    _In_ ULONG Length,
 +    _Out_ PCHAR String
 +);
 +
 +NTSYSAPI
 +CHAR
 +NTAPI
 +RtlUpperChar(CHAR Source);
 +
 +NTSYSAPI
 +WCHAR
 +NTAPI
 +RtlUpcaseUnicodeChar(WCHAR Source);
 +
 +NTSYSAPI
 +WCHAR
 +NTAPI
 +RtlDowncaseUnicodeChar(IN WCHAR Source);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlIntegerToChar(
 +    _In_ ULONG Value,
 +    _In_ ULONG Base,
 +    _In_ ULONG Length,
 +    _Out_ PCHAR String
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlIntegerToUnicode(
 +    _In_ ULONG Value,
 +    _In_opt_ ULONG Base,
 +    _In_opt_ ULONG Length,
 +    _Inout_ LPWSTR String
 +);
 +
 +_IRQL_requires_max_(PASSIVE_LEVEL)
 +_At_(String->MaximumLength, _Const_)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlIntegerToUnicodeString(
 +    _In_ ULONG Value,
 +    _In_opt_ ULONG Base,
 +    _Inout_ PUNICODE_STRING String
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlCharToInteger(
 +    PCSZ String,
 +    ULONG Base,
 +    PULONG Value
 +);
 +
 +//
 +// Byte Swap Functions
 +//
 +#ifdef NTOS_MODE_USER
 +
 +#if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037)) || \
 +    ((defined(_M_AMD64) || \
 +     defined(_M_IA64)) && (_MSC_FULL_VER > 13009175))
 +
 +unsigned short __cdecl _byteswap_ushort(unsigned short);
 +unsigned long  __cdecl _byteswap_ulong (unsigned long);
 +unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64);
 +#pragma intrinsic(_byteswap_ushort)
 +#pragma intrinsic(_byteswap_ulong)
 +#pragma intrinsic(_byteswap_uint64)
 +#define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
 +#define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
 +#define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
 +
 +#elif defined (__GNUC__)
 +
 +#define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
 +#define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
 +#define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
 +
 +#else
 +
 +#if (NTDDI_VERSION >= NTDDI_WIN2K)
 +NTSYSAPI
 +USHORT
 +FASTCALL
 +RtlUshortByteSwap(IN USHORT Source);
 +
 +NTSYSAPI
 +ULONG
 +FASTCALL
 +RtlUlongByteSwap(IN ULONG Source);
 +
 +NTSYSAPI
 +ULONGLONG
 +FASTCALL
 +RtlUlonglongByteSwap(IN ULONGLONG Source);
 +#endif
 +
 +#endif
 +#endif // NTOS_MODE_USER
 +
 +//
 +// Unicode->Ansi String Functions
 +//
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlxUnicodeStringToAnsiSize(IN PCUNICODE_STRING UnicodeString);
 +
 +#ifdef NTOS_MODE_USER
 +
 +#define RtlUnicodeStringToAnsiSize(STRING) (                  \
 +    NLS_MB_CODE_PAGE_TAG ?                                    \
 +    RtlxUnicodeStringToAnsiSize(STRING) :                     \
 +    ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
 +)
 +
 +#endif
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUnicodeStringToAnsiString(
 +    PANSI_STRING DestinationString,
 +    PCUNICODE_STRING SourceString,
 +    BOOLEAN AllocateDestinationString
 +);
 +
 +//
 +// Unicode->OEM String Functions
 +//
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUpcaseUnicodeStringToOemString(
 +    POEM_STRING DestinationString,
 +    PCUNICODE_STRING SourceString,
 +    BOOLEAN AllocateDestinationString
 +);
 +
 +_IRQL_requires_max_(PASSIVE_LEVEL)
 +_Must_inspect_result_
 +//_At_(DestinationString->Buffer, _Post_bytecount_(DestinationString->Length))
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUpcaseUnicodeStringToCountedOemString(
 +    _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
 +    _When_(!AllocateDestinationString, _Inout_)
 +        POEM_STRING DestinationString,
 +    _In_ PCUNICODE_STRING SourceString,
 +    _In_ BOOLEAN AllocateDestinationString
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUnicodeStringToOemString(
 +    POEM_STRING DestinationString,
 +    PCUNICODE_STRING SourceString,
 +    BOOLEAN AllocateDestinationString
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUpcaseUnicodeToOemN(
 +    PCHAR OemString,
 +    ULONG OemSize,
 +    PULONG ResultSize,
 +    PCWCH UnicodeString,
 +    ULONG UnicodeSize
 +);
 +
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlxUnicodeStringToOemSize(IN PCUNICODE_STRING UnicodeString);
 +
 +#ifdef NTOS_MODE_USER
 +
 +#define RtlUnicodeStringToOemSize(STRING) (                             \
 +    NLS_MB_OEM_CODE_PAGE_TAG ?                                          \
 +    RtlxUnicodeStringToOemSize(STRING) :                                \
 +    ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR)           \
 +)
 +
 +#define RtlUnicodeStringToCountedOemSize(STRING) (                      \
 +    (ULONG)(RtlUnicodeStringToOemSize(STRING) - sizeof(ANSI_NULL))      \
 +)
 +
 +#endif
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUnicodeToOemN(
 +    PCHAR OemString,
 +    ULONG OemSize,
 +    PULONG ResultSize,
 +    PCWCH UnicodeString,
 +    ULONG UnicodeSize
 +);
 +
 +//
 +// Unicode->MultiByte String Functions
 +//
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUnicodeToMultiByteN(
 +    PCHAR MbString,
 +    ULONG MbSize,
 +    PULONG ResultSize,
 +    PCWCH UnicodeString,
 +    ULONG UnicodeSize
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUpcaseUnicodeToMultiByteN(
 +    PCHAR MbString,
 +    ULONG MbSize,
 +    PULONG ResultSize,
 +    PCWCH UnicodeString,
 +    ULONG UnicodeSize
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlUnicodeToMultiByteSize(
 +    PULONG MbSize,
 +    PCWCH UnicodeString,
 +    ULONG UnicodeSize
 +);
 +
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlxOemStringToUnicodeSize(IN PCOEM_STRING OemString);
 +
 +//
 +// OEM to Unicode Functions
 +//
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlOemStringToUnicodeString(
 +    PUNICODE_STRING DestinationString,
 +    PCOEM_STRING SourceString,
 +    BOOLEAN AllocateDestinationString
 +);
 +
 +_IRQL_requires_max_(PASSIVE_LEVEL)
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlOemToUnicodeN(
 +    _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWCH UnicodeString,
 +    _In_ ULONG MaxBytesInUnicodeString,
 +    _Out_opt_ PULONG BytesInUnicodeString,
 +    _In_reads_bytes_(BytesInOemString) PCCH OemString,
 +    _In_ ULONG BytesInOemString
 +);
 +
 +#ifdef NTOS_MODE_USER
 +
 +#define RtlOemStringToUnicodeSize(STRING) (                             \
 +    NLS_MB_OEM_CODE_PAGE_TAG ?                                          \
 +    RtlxOemStringToUnicodeSize(STRING) :                                \
 +    ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)              \
 +)
 +
 +#define RtlOemStringToCountedUnicodeSize(STRING) (                      \
 +    (ULONG)(RtlOemStringToUnicodeSize(STRING) - sizeof(UNICODE_NULL))   \
 +)
 +
 +#endif
 +
 +//
 +// Ansi->Unicode String Functions
 +//
 +NTSYSAPI
 +ULONG
 +NTAPI
 +RtlxAnsiStringToUnicodeSize(
 +    PCANSI_STRING AnsiString
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAnsiStringToUnicodeString(
 +    PUNICODE_STRING DestinationString,
 +    PCANSI_STRING SourceString,
 +    BOOLEAN AllocateDestinationString
 +);
 +
 +#ifdef NTOS_MODE_USER
 +
 +#define RtlAnsiStringToUnicodeSize(STRING) (                        \
 +    NLS_MB_CODE_PAGE_TAG ?                                          \
 +    RtlxAnsiStringToUnicodeSize(STRING) :                           \
 +    ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)          \
 +)
 +
 +#endif
 +
 +NTSYSAPI
 +BOOLEAN
 +NTAPI
 +RtlCreateUnicodeStringFromAsciiz(
 +    _Out_ PUNICODE_STRING Destination,
 +    _In_ PCSZ Source
 +);
 +
 +//
 +// Unicode String Functions
 +//
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAppendUnicodeToString(
 +    PUNICODE_STRING Destination,
 +    PCWSTR Source
 +);
 +
 +NTSYSAPI
 +NTSTATUS
 +NTAPI
 +RtlAppendUnicodeStringToString(
 +    PUNICODE_STRING Destination,
 +    PCUNICODE_STRING Source
 +);
 +
 +NTSYSAPI
 +LONG
 +NTAP