nls.c File Reference

#include <k32.h>
#include <debug.h>

Include dependency graph for nls.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static NTSTATUS	CreateNlsDirectorySecurity (_Out_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ SIZE_T DescriptorSize)
	Creates a security descriptor for the NLS object directory.
GetNlsSectionName
Construct a name of NLS section. Parameters CodePage Code page number. Base Integer base used for converting to string. Usually set to 10. Unknown As the name suggests the meaning of this parameter is unknown. The native version of Kernel32 passes it as the third parameter to NlsConvertIntegerToString function, which is used for the actual conversion of the code page number. BaseName Base name of the section. (ex. "\\Nls\\NlsSectionCP") Result Buffer that will hold the constructed name. ResultSize Size of the buffer for the result. Returns TRUE if the buffer was large enough and was filled with the requested information, FALSE otherwise. @implemented
BOOL WINAPI	GetNlsSectionName (UINT CodePage, UINT Base, ULONG Unknown, LPSTR BaseName, LPSTR Result, ULONG ResultSize)
GetCPFileNameFromRegistry
Get file name of code page definition file. Parameters CodePage Code page number to get file name of. FileName Buffer that is filled with file name of successful return. Can be set to NULL. FileNameSize Size of the buffer to hold file name in WCHARs. Returns TRUE if the file name was retrieved, FALSE otherwise. @implemented
BOOL WINAPI	GetCPFileNameFromRegistry (UINT CodePage, LPWSTR FileName, ULONG FileNameSize)
IsDBCSLeadByteEx
Determine if passed byte is lead byte in current ANSI code page. @implemented
NTSTATUS WINAPI	CreateNlsSecurityDescriptor (_Out_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ SIZE_T DescriptorSize, _In_ ULONG AccessMask)
	Creates a security descriptor for each NLS section. Typically used by BASESRV to give Everyone (World SID) read access to the sections.
BOOL WINAPI	IsDBCSLeadByteEx (UINT CodePage, BYTE TestByte)
BOOL WINAPI	IsDBCSLeadByte (BYTE TestByte)
BOOL WINAPI	IsValidUILanguage (LANGID langid)
VOID WINAPI	NlsConvertIntegerToString (ULONG Value, ULONG Base, ULONG strsize, LPWSTR str, ULONG strsize2)
UINT WINAPI	SetCPGlobal (UINT CodePage)
BOOL WINAPI	ValidateLCType (int a1, unsigned int a2, int a3, int a4)
BOOL WINAPI	NlsResetProcessLocale (VOID)
VOID WINAPI	GetDefaultSortkeySize (LPVOID lpUnknown)
VOID WINAPI	GetLinguistLangSize (LPVOID lpUnknown)
BOOL WINAPI	ValidateLocale (IN ULONG LocaleId)
ULONG WINAPI	NlsGetCacheUpdateCount (VOID)
BOOL WINAPI	IsNLSDefinedString (IN NLS_FUNCTION Function, IN DWORD dwFlags, IN LPNLSVERSIONINFO lpVersionInformation, IN LPCWSTR lpString, IN INT cchStr)
BOOL WINAPI	GetNLSVersion (IN NLS_FUNCTION Function, IN LCID Locale, IN OUT LPNLSVERSIONINFO lpVersionInformation)
BOOL WINAPI	GetNLSVersionEx (IN NLS_FUNCTION function, IN LPCWSTR lpLocaleName, IN OUT LPNLSVERSIONINFOEX lpVersionInformation)
NlsInit
Internal NLS related stuff initialization.
BOOL FASTCALL	NlsInit (VOID)
NlsUninit
Internal NLS related stuff uninitialization.
VOID FASTCALL	NlsUninit (VOID)
IntGetLoadedCodePageEntry
Internal function to get structure containing a code page information of code page that is already loaded. Parameters CodePage Number of the code page. Special values like CP_OEMCP, CP_ACP or CP_UTF8 aren't allowed. Returns Code page entry or NULL if the specified code page hasn't been loaded yet.
PCODEPAGE_ENTRY FASTCALL	IntGetLoadedCodePageEntry (UINT CodePage)
IntGetCodePageEntry
Internal function to get structure containing a code page information. Parameters CodePage Number of the code page. Special values like CP_OEMCP, CP_ACP or CP_THREAD_ACP are allowed, but CP_UTF[7/8] isn't. Returns Code page entry.
PCODEPAGE_ENTRY FASTCALL	IntGetCodePageEntry (UINT CodePage)
IntMultiByteToWideCharUTF8
Internal version of MultiByteToWideChar for UTF8. Note We use Win10's behaviour due to security reason. See also MultiByteToWideChar
static INT WINAPI	IntMultiByteToWideCharUTF8 (DWORD Flags, LPCSTR MultiByteString, INT MultiByteCount, LPWSTR WideCharString, INT WideCharCount)
IntMultiByteToWideCharCP
Internal version of MultiByteToWideChar for code page tables. See also MultiByteToWideChar Todo: Handle MB_PRECOMPOSED, MB_COMPOSITE, MB_USEGLYPHCHARS and DBCS codepages.
static INT WINAPI	IntMultiByteToWideCharCP (UINT CodePage, DWORD Flags, LPCSTR MultiByteString, INT MultiByteCount, LPWSTR WideCharString, INT WideCharCount)
IntMultiByteToWideCharSYMBOL
Internal version of MultiByteToWideChar for SYMBOL. See also MultiByteToWideChar
static INT WINAPI	IntMultiByteToWideCharSYMBOL (DWORD Flags, LPCSTR MultiByteString, INT MultiByteCount, LPWSTR WideCharString, INT WideCharCount)
IntWideCharToMultiByteSYMBOL
Internal version of WideCharToMultiByte for SYMBOL. See also WideCharToMultiByte
static INT WINAPI	IntWideCharToMultiByteSYMBOL (DWORD Flags, LPCWSTR WideCharString, INT WideCharCount, LPSTR MultiByteString, INT MultiByteCount)
IntWideCharToMultiByteUTF8
Internal version of WideCharToMultiByte for UTF8. See also WideCharToMultiByte
static INT WINAPI	IntWideCharToMultiByteUTF8 (UINT CodePage, DWORD Flags, LPCWSTR WideCharString, INT WideCharCount, LPSTR MultiByteString, INT MultiByteCount, LPCSTR DefaultChar, LPBOOL UsedDefaultChar)
IsValidSBCSMapping
Checks if ch (single-byte character) is a valid mapping for wch See also IntWideCharToMultiByteCP
static BOOL	IntIsValidSBCSMapping (PCPTABLEINFO CodePageTable, DWORD Flags, WCHAR wch, UCHAR ch)
IsValidDBCSMapping
Checks if ch (double-byte character) is a valid mapping for wch See also IntWideCharToMultiByteCP
static BOOL	IntIsValidDBCSMapping (PCPTABLEINFO CodePageTable, DWORD Flags, WCHAR wch, USHORT ch)
IntWideCharToMultiByteCP
Internal version of WideCharToMultiByte for code page tables. See also WideCharToMultiByte Todo: Handle WC_COMPOSITECHECK
static INT WINAPI	IntWideCharToMultiByteCP (UINT CodePage, DWORD Flags, LPCWSTR WideCharString, INT WideCharCount, LPSTR MultiByteString, INT MultiByteCount, LPCSTR DefaultChar, LPBOOL UsedDefaultChar)
IntIsLeadByte
Internal function to detect if byte is lead byte in specific character table.
static BOOL WINAPI	IntIsLeadByte (PCPTABLEINFO TableInfo, BYTE Byte)
IsValidCodePage
Detect if specified code page is valid and present in the system. Parameters CodePage Code page number to query. Returns TRUE if code page is present.
BOOL WINAPI	IsValidCodePage (UINT CodePage)
static BOOL	utf7_write_w (WCHAR *dst, int dstlen, int *index, WCHAR character)
static INT	Utf7ToWideChar (const char *src, int srclen, WCHAR *dst, int dstlen)
MultiByteToWideChar
Convert a multi-byte string to wide-charater equivalent. Parameters CodePage Code page to be used to perform the conversion. It can be also one of the special values (CP_ACP for ANSI code page, CP_MACCP for Macintosh code page, CP_OEMCP for OEM code page, CP_THREAD_ACP for thread active code page, CP_UTF7 or CP_UTF8). Flags Additional conversion flags (MB_PRECOMPOSED, MB_COMPOSITE, MB_ERR_INVALID_CHARS, MB_USEGLYPHCHARS). MultiByteString Input buffer. MultiByteCount Size of MultiByteString, or -1 if MultiByteString is NULL terminated. WideCharString Output buffer. WideCharCount Size in WCHARs of WideCharString, or 0 if the caller just wants to know how large WideCharString should be for a successful conversion. Returns Zero on error, otherwise the number of WCHARs written in the WideCharString buffer. @implemented
INT WINAPI	MultiByteToWideChar (UINT CodePage, DWORD Flags, LPCSTR MultiByteString, INT MultiByteCount, LPWSTR WideCharString, INT WideCharCount)
static BOOL	utf7_can_directly_encode (WCHAR codepoint)
static BOOL	utf7_write_c (char *dst, int dstlen, int *index, char character)
static INT	WideCharToUtf7 (const WCHAR *src, int srclen, char *dst, int dstlen)
UINT	GetLocalisedText (IN UINT uID, IN LPWSTR lpszDest, IN UINT cchDest, IN LANGID lang)
BOOL WINAPI	GetCPInfo (UINT CodePage, LPCPINFO CodePageInfo)
BOOL WINAPI	GetCPInfoExW (UINT CodePage, DWORD dwFlags, LPCPINFOEXW lpCPInfoEx)
BOOL WINAPI	GetCPInfoExA (UINT CodePage, DWORD dwFlags, LPCPINFOEXA lpCPInfoEx)
WideCharToMultiByte
Convert a wide-charater string to closest multi-byte equivalent. Parameters CodePage Code page to be used to perform the conversion. It can be also one of the special values (CP_ACP for ANSI code page, CP_MACCP for Macintosh code page, CP_OEMCP for OEM code page, CP_THREAD_ACP for thread active code page, CP_UTF7 or CP_UTF8). Flags Additional conversion flags (WC_NO_BEST_FIT_CHARS, WC_COMPOSITECHECK, WC_DISCARDNS, WC_SEPCHARS, WC_DEFAULTCHAR). WideCharString Points to the wide-character string to be converted. WideCharCount Size in WCHARs of WideCharStr, or 0 if the caller just wants to know how large WideCharString should be for a successful conversion. MultiByteString Points to the buffer to receive the translated string. MultiByteCount Specifies the size in bytes of the buffer pointed to by the MultiByteString parameter. If this value is zero, the function returns the number of bytes required for the buffer. DefaultChar Points to the character used if a wide character cannot be represented in the specified code page. If this parameter is NULL, a system default value is used. UsedDefaultChar Points to a flag that indicates whether a default character was used. This parameter can be NULL. Returns Zero on error, otherwise the number of bytes written in the MultiByteString buffer. Or the number of bytes needed for the MultiByteString buffer if MultiByteCount is zero. @implemented
INT WINAPI	WideCharToMultiByte (UINT CodePage, DWORD Flags, LPCWSTR WideCharString, INT WideCharCount, LPSTR MultiByteString, INT MultiByteCount, LPCSTR DefaultChar, LPBOOL UsedDefaultChar)
GetACP
Get active ANSI code page number. @implemented
UINT WINAPI	GetACP (VOID)
GetOEMCP
Get active OEM code page number. @implemented
UINT WINAPI	GetOEMCP (VOID)

Variables
static const char	UTF8Length [128]
static const unsigned char	UTF8Mask [6] = {0x7f, 0x1f, 0x0f, 0x07, 0x03, 0x01}
static const unsigned long	UTF8LBound []
static LIST_ENTRY	CodePageListHead
static CODEPAGE_ENTRY	AnsiCodePage
static CODEPAGE_ENTRY	OemCodePage
static RTL_CRITICAL_SECTION	CodePageListLock

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 19 of file nls.c.

Function Documentation

CreateNlsDirectorySecurity()

static NTSTATUS CreateNlsDirectorySecurity ( _Out_ PSECURITY_DESCRIPTOR  SecurityDescriptor, _In_ SIZE_T  DescriptorSize  )

static

Creates a security descriptor for the NLS object directory.

Parameters

[out]	SecurityDescriptor
[in]	DescriptorSize	Same parameters as for CreateNlsSecurityDescriptor().

Remarks

Everyone (World SID) is given read access to the NLS directory, whereas Admins are given full access.

Definition at line 81 of file nls.c.

{
    static SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
    NTSTATUS Status;
    PSID AdminsSid;
    PACL Dacl;
    BOOLEAN DaclPresent, DaclDefaulted;
 
    /* Give everyone basic directory access */
    Status = CreateNlsSecurityDescriptor(SecurityDescriptor,
                                         DescriptorSize,
                                         DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create basic NLS SD (Status 0x%08x)\n", Status);
        return Status;
    }
 
    /* Create the Admins SID */
    // NOTE: Win <= 2k3 uses SYSTEM instead (SECURITY_LOCAL_SYSTEM_RID with one SubAuthority)
    Status = RtlAllocateAndInitializeSid(&NtAuthority,
                                         2,
                                         SECURITY_BUILTIN_DOMAIN_RID,
                                         DOMAIN_ALIAS_RID_ADMINS,
                                         0, 0, 0, 0, 0, 0,
                                         &AdminsSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create Admins SID (Status 0x%08x)\n", Status);
        goto Quit;
    }
 
    /* Retrieve the DACL from the descriptor */
    Status = RtlGetDaclSecurityDescriptor(SecurityDescriptor,
                                          &DaclPresent,
                                          &Dacl,
                                          &DaclDefaulted);
    if (!NT_SUCCESS(Status) || !DaclPresent || !Dacl)
    {
        DPRINT1("Failed to get DACL from descriptor (Status 0x%08x)\n", Status);
        goto Quit;
    }
 
    /* Add an allowed access ACE to the Admins SID with full access.
     * The function verifies the DACL is large enough to accommodate it. */
    Status = RtlAddAccessAllowedAce(Dacl,
                                    ACL_REVISION,
                                    DIRECTORY_ALL_ACCESS,
                                    AdminsSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to add allowed access ACE for Admins SID (Status 0x%08x)\n", Status);
        goto Quit;
    }
 
Quit:
    RtlFreeSid(AdminsSid);
    return Status;
}

Referenced by NlsInit().

CreateNlsSecurityDescriptor()

NTSTATUS WINAPI CreateNlsSecurityDescriptor	(	_Out_ PSECURITY_DESCRIPTOR	SecurityDescriptor,
		_In_ SIZE_T	DescriptorSize,
		_In_ ULONG	AccessMask
	)

Creates a security descriptor for each NLS section. Typically used by BASESRV to give Everyone (World SID) read access to the sections.

Parameters

[out]	SecurityDescriptor	A pointer to a correctly sized user-allocated buffer, that receives a security descriptor containing one ACL with one World SID. Its size should be at least equal to NLS_SECTION_SECURITY_DESCRIPTOR_SIZE.
[in]	DescriptorSize	Size (in bytes) of the user-provided SecurityDescriptor buffer.
[in]	AccessMask	An access mask that grants Everyone an access specific to that mask.

Returns

STATUS_SUCCESS is returned if the function has successfully created a security descriptor for a NLS section name. Otherwise a NTSTATUS failure code is returned.

Remarks

This implementation has to be made compatible with NT <= 5.2 in order to inter-operate with BASESRV. In particular, the security descriptor is a user-provided buffer correctly sized. The caller is responsible to submit the exact size of the descriptor.

Definition at line 2395 of file nls.c.

{
    static SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
    NTSTATUS Status;
    PSID WorldSid;
    PACL Dacl;
    ULONG DaclSize;
 
    if (DescriptorSize < NLS_SECTION_SECURITY_DESCRIPTOR_SIZE)
    {
        DPRINT1("Security descriptor size too small\n");
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* Create the World SID */
    Status = RtlAllocateAndInitializeSid(&WorldAuthority,
                                         1,
                                         SECURITY_WORLD_RID,
                                         0, 0, 0, 0, 0, 0, 0,
                                         &WorldSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create World SID (Status 0x%08x)\n", Status);
        return Status;
    }
 
    /* Initialize the security descriptor */
    Status = RtlCreateSecurityDescriptor(SecurityDescriptor,
                                         SECURITY_DESCRIPTOR_REVISION);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create security descriptor (Status 0x%08x)\n", Status);
        goto Quit;
    }
 
    /* The DACL follows the security descriptor, and includes the World SID */
    Dacl = (PACL)((ULONG_PTR)SecurityDescriptor + sizeof(SECURITY_DESCRIPTOR));
    DaclSize = DescriptorSize - sizeof(SECURITY_DESCRIPTOR);
 
    /* Create the DACL */
    Status = RtlCreateAcl(Dacl, DaclSize, ACL_REVISION);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create DACL (Status 0x%08x)\n", Status);
        goto Quit;
    }
 
    /* Add an allowed access ACE to the World SID */
    Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, AccessMask, WorldSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to add allowed access ACE for World SID (Status 0x%08x)\n", Status);
        goto Quit;
    }
 
    /* Set the DACL to the descriptor */
    Status = RtlSetDaclSecurityDescriptor(SecurityDescriptor, TRUE, Dacl, FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to set DACL into descriptor (Status 0x%08x)\n", Status);
        goto Quit;
    }
 
Quit:
    RtlFreeSid(WorldSid);
    return Status;
}

Referenced by CreateNlsDirectorySecurity(), and IntGetCodePageEntry().

GetACP()

UINT WINAPI GetACP

(

VOID

)

Definition at line 2309 of file nls.c.

{
    return AnsiCodePage.CodePageTable.CodePage;
}

GetCPFileNameFromRegistry()

BOOL WINAPI GetCPFileNameFromRegistry	(	UINT	CodePage,
		LPWSTR	FileName,
		ULONG	FileNameSize
	)

Definition at line 1528 of file nls.c.

{
    WCHAR ValueNameBuffer[11];
    UNICODE_STRING KeyName, ValueName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    HANDLE KeyHandle;
    PKEY_VALUE_PARTIAL_INFORMATION Kvpi;
    DWORD KvpiSize;
    BOOL bRetValue;
 
    bRetValue = FALSE;
 
    /* Convert the codepage number to string. */
    ValueName.Buffer = ValueNameBuffer;
    ValueName.MaximumLength = sizeof(ValueNameBuffer);
 
    if (!NT_SUCCESS(RtlIntegerToUnicodeString(CodePage, 10, &ValueName)))
        return bRetValue;
 
    /* Open the registry key containing file name mappings. */
    RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\System\\"
                         L"CurrentControlSet\\Control\\Nls\\CodePage");
    InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE,
                               NULL, NULL);
    Status = NtOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        return bRetValue;
    }
 
    /* Allocate buffer that will be used to query the value data. */
    KvpiSize = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + (MAX_PATH * sizeof(WCHAR));
    Kvpi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, KvpiSize);
    if (Kvpi == NULL)
    {
        NtClose(KeyHandle);
        return bRetValue;
    }
 
    /* Query the file name for our code page. */
    Status = NtQueryValueKey(KeyHandle, &ValueName, KeyValuePartialInformation,
                             Kvpi, KvpiSize, &KvpiSize);
 
    NtClose(KeyHandle);
 
    /* Check if we succeded and the value is non-empty string. */
    if (NT_SUCCESS(Status) && Kvpi->Type == REG_SZ &&
        Kvpi->DataLength > sizeof(WCHAR))
    {
        bRetValue = TRUE;
        if (FileName != NULL)
        {
            lstrcpynW(FileName, (WCHAR*)Kvpi->Data,
                      min(Kvpi->DataLength / sizeof(WCHAR), FileNameSize));
        }
    }
 
    /* free temporary buffer */
    HeapFree(GetProcessHeap(),0,Kvpi);
    return bRetValue;
}

Referenced by IntGetCodePageEntry(), and IsValidCodePage().

GetCPInfo()

BOOL WINAPI GetCPInfo	(	UINT	CodePage,
		LPCPINFO	CodePageInfo
	)

Definition at line 2039 of file nls.c.

{
    PCODEPAGE_ENTRY CodePageEntry;
 
    if (!CodePageInfo)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    CodePageEntry = IntGetCodePageEntry(CodePage);
    if (CodePageEntry == NULL)
    {
        switch(CodePage)
        {
            case CP_UTF7:
            case CP_UTF8:
                RtlZeroMemory(CodePageInfo, sizeof(*CodePageInfo));
                CodePageInfo->DefaultChar[0] = 0x3f;
                CodePageInfo->DefaultChar[1] = 0;
                CodePageInfo->LeadByte[0] = CodePageInfo->LeadByte[1] = 0;
                CodePageInfo->MaxCharSize = (CodePage == CP_UTF7) ? 5 : 4;
                return TRUE;
        }
 
        DPRINT1("Invalid CP!: %lx\n", CodePage);
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
 
    RtlZeroMemory(CodePageInfo, sizeof(*CodePageInfo));
    if (CodePageEntry->CodePageTable.DefaultChar & 0xff00)
    {
        CodePageInfo->DefaultChar[0] = (CodePageEntry->CodePageTable.DefaultChar & 0xff00) >> 8;
        CodePageInfo->DefaultChar[1] = CodePageEntry->CodePageTable.DefaultChar & 0x00ff;
    }
    else
    {
        CodePageInfo->DefaultChar[0] = CodePageEntry->CodePageTable.DefaultChar & 0xff;
        CodePageInfo->DefaultChar[1] = 0;
    }
 
    if ((CodePageInfo->MaxCharSize = CodePageEntry->CodePageTable.MaximumCharacterSize) == 2)
        memcpy(CodePageInfo->LeadByte, CodePageEntry->CodePageTable.LeadByte, sizeof(CodePageInfo->LeadByte));
    else
        CodePageInfo->LeadByte[0] = CodePageInfo->LeadByte[1] = 0;
 
    return TRUE;
}

Referenced by GetCPInfoExW().

GetCPInfoExA()

BOOL WINAPI GetCPInfoExA	(	UINT	CodePage,
		DWORD	dwFlags,
		LPCPINFOEXA	lpCPInfoEx
	)

Definition at line 2154 of file nls.c.

{
    CPINFOEXW CPInfo;
 
    if (!GetCPInfoExW(CodePage, dwFlags, &CPInfo))
        return FALSE;
 
    /* the layout is the same except for CodePageName */
    memcpy(lpCPInfoEx, &CPInfo, sizeof(CPINFOEXA));
 
    WideCharToMultiByte(CP_ACP,
                        0,
                        CPInfo.CodePageName,
                        -1,
                        lpCPInfoEx->CodePageName,
                        sizeof(lpCPInfoEx->CodePageName),
                        NULL,
                        NULL);
    return TRUE;
}

GetCPInfoExW()

BOOL WINAPI GetCPInfoExW	(	UINT	CodePage,
		DWORD	dwFlags,
		LPCPINFOEXW	lpCPInfoEx
	)

Definition at line 2095 of file nls.c.

{
    if (!GetCPInfo(CodePage, (LPCPINFO)lpCPInfoEx))
        return FALSE;
 
    switch(CodePage)
    {
        case CP_UTF7:
        {
            lpCPInfoEx->CodePage = CP_UTF7;
            lpCPInfoEx->UnicodeDefaultChar = 0x3f;
            return GetLocalisedText(lpCPInfoEx->CodePage,
                                    lpCPInfoEx->CodePageName,
                                    ARRAYSIZE(lpCPInfoEx->CodePageName),
                                    GetThreadLocale()) != 0;
        }
        break;
 
        case CP_UTF8:
        {
            lpCPInfoEx->CodePage = CP_UTF8;
            lpCPInfoEx->UnicodeDefaultChar = 0x3f;
            return GetLocalisedText(lpCPInfoEx->CodePage,
                                    lpCPInfoEx->CodePageName,
                                    ARRAYSIZE(lpCPInfoEx->CodePageName),
                                    GetThreadLocale()) != 0;
        }
 
        default:
        {
            PCODEPAGE_ENTRY CodePageEntry;
 
            CodePageEntry = IntGetCodePageEntry(CodePage);
            if (CodePageEntry == NULL)
            {
                DPRINT1("Could not get CodePage Entry! CodePageEntry = NULL\n");
                SetLastError(ERROR_INVALID_PARAMETER);
                return FALSE;
            }
 
            lpCPInfoEx->CodePage = CodePageEntry->CodePageTable.CodePage;
            lpCPInfoEx->UnicodeDefaultChar = CodePageEntry->CodePageTable.UniDefaultChar;
            return GetLocalisedText(lpCPInfoEx->CodePage,
                                    lpCPInfoEx->CodePageName,
                                    ARRAYSIZE(lpCPInfoEx->CodePageName),
                                    GetThreadLocale()) != 0;
        }
        break;
    }
}

Referenced by GetCPInfoExA().

GetDefaultSortkeySize()

VOID WINAPI GetDefaultSortkeySize

(

LPVOID

lpUnknown

)

Definition at line 2519 of file nls.c.

{
    STUB;
    lpUnknown = NULL;
}

GetLinguistLangSize()

VOID WINAPI GetLinguistLangSize

(

LPVOID

lpUnknown

)

Definition at line 2530 of file nls.c.

{
    STUB;
    lpUnknown = NULL;
}

GetLocalisedText()

UINT GetLocalisedText	(	IN UINT	uID,
		IN LPWSTR	lpszDest,
		IN UINT	cchDest,
		IN LANGID	lang
	)

Definition at line 1952 of file nls.c.

{
    HRSRC hrsrc;
    HGLOBAL hmem;
    LCID lcid;
    LANGID langId;
    const WCHAR *p;
    UINT i;
 
    /* See HACK in winnls/lang/xx-XX.rc files */
    if (uID == 37)
        uID = uID * 100;
 
    lcid = ConvertDefaultLocale(lang);
 
    langId = LANGIDFROMLCID(lcid);
 
    if (PRIMARYLANGID(langId) == LANG_NEUTRAL)
        langId = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
 
    hrsrc = FindResourceExW(hCurrentModule,
                            (LPWSTR)RT_STRING,
                            MAKEINTRESOURCEW((uID >> 4) + 1),
                            langId);
 
    /* English fallback */
    if (!hrsrc)
    {
        hrsrc = FindResourceExW(hCurrentModule,
                                (LPWSTR)RT_STRING,
                                MAKEINTRESOURCEW((uID >> 4) + 1),
                                MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
    }
 
    if (!hrsrc)
        goto NotFound;
 
    hmem = LoadResource(hCurrentModule, hrsrc);
    if (!hmem)
        goto NotFound;
 
    p = LockResource(hmem);
 
    for (i = 0; i < (uID & 0x0F); i++)
        p += *p + 1;
 
    /* Needed for GetGeoInfo(): return the needed string size including the NULL terminator */
    if (cchDest == 0)
        return *p + 1;
    /* Needed for GetGeoInfo(): bail out if the user buffer is not large enough */
    if (*p + 1 > cchDest)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return 0;
    }
 
    i = *p;
    if (i > 0)
    {
        memcpy(lpszDest, p + 1, i * sizeof(WCHAR));
        lpszDest[i] = L'\0';
        return i;
    }
#if 0
    else
    {
        if (cchDest >= 1)
            lpszDest[0] = L'\0';
        /* Fall-back */
    }
#endif
 
NotFound:
    DPRINT1("Resource not found: uID = %lu\n", uID);
    SetLastError(ERROR_INVALID_PARAMETER);
    return 0;
}

Referenced by GetCPInfoExW().

GetNlsSectionName()

BOOL WINAPI GetNlsSectionName	(	UINT	CodePage,
		UINT	Base,
		ULONG	Unknown,
		LPSTR	BaseName,
		LPSTR	Result,
		ULONG	ResultSize
	)

Definition at line 1483 of file nls.c.

{
    CHAR Integer[11];
 
    if (!NT_SUCCESS(RtlIntegerToChar(CodePage, Base, sizeof(Integer), Integer)))
        return FALSE;
 
    /*
     * If the name including the terminating NULL character doesn't
     * fit in the output buffer then fail.
     */
    if (strlen(Integer) + strlen(BaseName) >= ResultSize)
        return FALSE;
 
    lstrcpyA(Result, BaseName);
    lstrcatA(Result, Integer);
 
    return TRUE;
}

Referenced by IntGetCodePageEntry().

GetNLSVersion()

BOOL WINAPI GetNLSVersion	(	IN NLS_FUNCTION	Function,
		IN LCID	Locale,
		IN OUT LPNLSVERSIONINFO	lpVersionInformation
	)

Definition at line 2578 of file nls.c.

{
    STUB;
    return TRUE;
}

GetNLSVersionEx()

BOOL WINAPI GetNLSVersionEx	(	IN NLS_FUNCTION	function,
		IN LPCWSTR	lpLocaleName,
		IN OUT LPNLSVERSIONINFOEX	lpVersionInformation
	)

Definition at line 2591 of file nls.c.

{
    STUB;
    return TRUE;
}

GetOEMCP()

UINT WINAPI GetOEMCP

(

VOID

)

Definition at line 2324 of file nls.c.

{
    return OemCodePage.CodePageTable.CodePage;
}

IntGetCodePageEntry()

PCODEPAGE_ENTRY FASTCALL IntGetCodePageEntry

(

UINT

CodePage

)

Definition at line 293 of file nls.c.

{
    NTSTATUS Status;
    CHAR SectionName[40];
    HANDLE SectionHandle = INVALID_HANDLE_VALUE, FileHandle;
    PBYTE SectionMapping;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UCHAR SecurityDescriptor[NLS_SECTION_SECURITY_DESCRIPTOR_SIZE];
    ANSI_STRING AnsiName;
    UNICODE_STRING UnicodeName;
    WCHAR FileName[MAX_PATH + 1];
    UINT FileNamePos;
    PCODEPAGE_ENTRY CodePageEntry;
 
    if (CodePage == CP_ACP)
    {
        return &AnsiCodePage;
    }
    else if (CodePage == CP_OEMCP)
    {
        return &OemCodePage;
    }
    else if (CodePage == CP_THREAD_ACP)
    {
        if (!GetLocaleInfoW(GetThreadLocale(),
                            LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
                            (WCHAR *)&CodePage,
                            sizeof(CodePage) / sizeof(WCHAR)))
        {
            /* Last error is set by GetLocaleInfoW. */
            return NULL;
        }
        if (CodePage == 0)
            return &AnsiCodePage;
    }
    else if (CodePage == CP_MACCP)
    {
        if (!GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT,
                            LOCALE_IDEFAULTMACCODEPAGE | LOCALE_RETURN_NUMBER,
                            (WCHAR *)&CodePage,
                            sizeof(CodePage) / sizeof(WCHAR)))
        {
            /* Last error is set by GetLocaleInfoW. */
            return NULL;
        }
    }
 
    /* Try searching for loaded page first. */
    CodePageEntry = IntGetLoadedCodePageEntry(CodePage);
    if (CodePageEntry != NULL)
    {
        return CodePageEntry;
    }
 
    /*
     * Yes, we really want to lock here. Otherwise it can happen that
     * two parallel requests will try to get the entry for the same
     * code page and we would load it twice.
     */
    RtlEnterCriticalSection(&CodePageListLock);
 
    /* Generate the section name. */
    if (!GetNlsSectionName(CodePage,
                           10,
                           0,
                           "\\Nls\\NlsSectionCP",
                           SectionName,
                           sizeof(SectionName)))
    {
        RtlLeaveCriticalSection(&CodePageListLock);
        return NULL;
    }
 
    RtlInitAnsiString(&AnsiName, SectionName);
    RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE);
 
    /*
     * FIXME: IntGetCodePageEntry should not create any security
     * descriptor here but instead this responsibility should be
     * assigned to Base Server API (aka basesrv.dll). That is,
     * kernel32 must instruct basesrv.dll on creating NLS section
     * names that do not exist through API message communication.
     * However since we do not do that, let the kernel32 do the job
     * by assigning security to NLS section names for the time being...
     */
    Status = CreateNlsSecurityDescriptor(&SecurityDescriptor,
                                         sizeof(SecurityDescriptor),
                                         SECTION_MAP_READ);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsSecurityDescriptor FAILED! (Status 0x%08x)\n", Status);
        RtlLeaveCriticalSection(&CodePageListLock);
        return NULL;
    }
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &UnicodeName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               SecurityDescriptor);
 
    /* Try to open the section first */
    Status = NtOpenSection(&SectionHandle,
                           SECTION_MAP_READ,
                           &ObjectAttributes);
 
    /* If the section doesn't exist, try to create it. */
    if (Status == STATUS_UNSUCCESSFUL ||
        Status == STATUS_OBJECT_NAME_NOT_FOUND ||
        Status == STATUS_OBJECT_PATH_NOT_FOUND)
    {
        FileNamePos = GetSystemDirectoryW(FileName, MAX_PATH);
        if (GetCPFileNameFromRegistry(CodePage,
                                      FileName + FileNamePos + 1,
                                      MAX_PATH - FileNamePos - 1))
        {
            FileName[FileNamePos] = L'\\';
            FileName[MAX_PATH] = 0;
            FileHandle = CreateFileW(FileName,
                                     FILE_GENERIC_READ,
                                     FILE_SHARE_READ,
                                     NULL,
                                     OPEN_EXISTING,
                                     0,
                                     NULL);
 
            Status = NtCreateSection(&SectionHandle,
                                     SECTION_MAP_READ,
                                     &ObjectAttributes,
                                     NULL,
                                     PAGE_READONLY,
                                     SEC_COMMIT,
                                     FileHandle);
 
            /* HACK: Check if another process was faster
             * and already created this section. See bug 3626 for details */
            if (Status == STATUS_OBJECT_NAME_COLLISION)
            {
                /* Close the file then */
                NtClose(FileHandle);
 
                /* And open the section */
                Status = NtOpenSection(&SectionHandle,
                                       SECTION_MAP_READ,
                                       &ObjectAttributes);
            }
        }
    }
    RtlFreeUnicodeString(&UnicodeName);
 
    if (!NT_SUCCESS(Status))
    {
        RtlLeaveCriticalSection(&CodePageListLock);
        return NULL;
    }
 
    SectionMapping = MapViewOfFile(SectionHandle, FILE_MAP_READ, 0, 0, 0);
    if (SectionMapping == NULL)
    {
        NtClose(SectionHandle);
        RtlLeaveCriticalSection(&CodePageListLock);
        return NULL;
    }
 
    CodePageEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(CODEPAGE_ENTRY));
    if (CodePageEntry == NULL)
    {
        NtClose(SectionHandle);
        RtlLeaveCriticalSection(&CodePageListLock);
        return NULL;
    }
 
    CodePageEntry->CodePage = CodePage;
    CodePageEntry->SectionHandle = SectionHandle;
    CodePageEntry->SectionMapping = SectionMapping;
 
    RtlInitCodePageTable((PUSHORT)SectionMapping, &CodePageEntry->CodePageTable);
 
    /* Insert the new entry to list and unlock. Uff. */
    InsertTailList(&CodePageListHead, &CodePageEntry->Entry);
    RtlLeaveCriticalSection(&CodePageListLock);
 
    return CodePageEntry;
}

Referenced by GetCPInfo(), GetCPInfoExW(), IntMultiByteToWideCharCP(), IntWideCharToMultiByteCP(), and IsDBCSLeadByteEx().

IntGetLoadedCodePageEntry()

PCODEPAGE_ENTRY FASTCALL IntGetLoadedCodePageEntry

(

UINT

CodePage

)

Definition at line 257 of file nls.c.

{
    LIST_ENTRY *CurrentEntry;
    PCODEPAGE_ENTRY Current;
 
    RtlEnterCriticalSection(&CodePageListLock);
    for (CurrentEntry = CodePageListHead.Flink;
         CurrentEntry != &CodePageListHead;
         CurrentEntry = CurrentEntry->Flink)
    {
        Current = CONTAINING_RECORD(CurrentEntry, CODEPAGE_ENTRY, Entry);
        if (Current->CodePage == CodePage)
        {
            RtlLeaveCriticalSection(&CodePageListLock);
            return Current;
        }
    }
    RtlLeaveCriticalSection(&CodePageListLock);
 
    return NULL;
}

Referenced by IntGetCodePageEntry(), and IsValidCodePage().

IntIsLeadByte()

static BOOL WINAPI IntIsLeadByte ( PCPTABLEINFO  TableInfo, BYTE  Byte  )

static

Definition at line 1436 of file nls.c.

{
    UINT i;
 
    if (TableInfo->MaximumCharacterSize == 2)
    {
        for (i = 0; i < MAXIMUM_LEADBYTES && TableInfo->LeadByte[i]; i += 2)
        {
            if (Byte >= TableInfo->LeadByte[i] && Byte <= TableInfo->LeadByte[i+1])
                return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by IsDBCSLeadByte(), and IsDBCSLeadByteEx().

IntIsValidDBCSMapping()

static BOOL IntIsValidDBCSMapping ( PCPTABLEINFO  CodePageTable, DWORD  Flags, WCHAR  wch, USHORT  ch  )

inlinestatic

Definition at line 1125 of file nls.c.

{
    /* If ch is the default character, but the wch is not, it can't be a valid mapping */
    if (ch == CodePageTable->TransDefaultChar && wch != CodePageTable->TransUniDefaultChar)
        return FALSE;
 
    /* If the WC_NO_BEST_FIT_CHARS flag has been specified, the characters need to match exactly. */
    if (Flags & WC_NO_BEST_FIT_CHARS)
    {
        if(ch & 0xff00)
        {
            USHORT uOffset = CodePageTable->DBCSOffsets[ch >> 8];
            /* if (!uOffset) return (CodePageTable->MultiByteTable[ch] == wch); */
            return (CodePageTable->DBCSOffsets[uOffset + (ch & 0xff)] == wch);
        }
 
        return (CodePageTable->MultiByteTable[ch] == wch);
    }
 
    /* If we're still here, we have a valid mapping */
    return TRUE;
}

Referenced by IntWideCharToMultiByteCP().

IntIsValidSBCSMapping()

static BOOL IntIsValidSBCSMapping ( PCPTABLEINFO  CodePageTable, DWORD  Flags, WCHAR  wch, UCHAR  ch  )

inlinestatic

Definition at line 1102 of file nls.c.

{
    /* If the WC_NO_BEST_FIT_CHARS flag has been specified, the characters need to match exactly. */
    if (Flags & WC_NO_BEST_FIT_CHARS)
        return (CodePageTable->MultiByteTable[ch] == wch);
 
    /* By default, all characters except TransDefaultChar apply as a valid mapping
       for ch (so also "nearest" characters) */
    if (ch != CodePageTable->TransDefaultChar)
        return TRUE;
 
    /* The only possible left valid mapping is the default character itself */
    return (wch == CodePageTable->TransUniDefaultChar);
}

Referenced by IntWideCharToMultiByteCP().

IntMultiByteToWideCharCP()

static INT WINAPI IntMultiByteToWideCharCP ( UINT  CodePage, DWORD  Flags, LPCSTR  MultiByteString, INT  MultiByteCount, LPWSTR  WideCharString, INT  WideCharCount  )

static

Definition at line 662 of file nls.c.

{
    PCODEPAGE_ENTRY CodePageEntry;
    PCPTABLEINFO CodePageTable;
    PUSHORT MultiByteTable;
    LPCSTR TempString;
    INT TempLength;
    USHORT WideChar;
 
    /* Get code page table. */
    CodePageEntry = IntGetCodePageEntry(CodePage);
    if (CodePageEntry == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    CodePageTable = &CodePageEntry->CodePageTable;
 
    /* If MB_USEGLYPHCHARS flag present and glyph table present */
    if ((Flags & MB_USEGLYPHCHARS) && CodePageTable->MultiByteTable[256])
    {
        /* Use glyph table */
        MultiByteTable = CodePageTable->MultiByteTable + 256 + 1;
    }
    else
    {
        MultiByteTable = CodePageTable->MultiByteTable;
    }
 
    /* Different handling for DBCS code pages. */
    if (CodePageTable->DBCSCodePage)
    {
        UCHAR Char;
        USHORT DBCSOffset;
        LPCSTR MbsEnd = MultiByteString + MultiByteCount;
        INT Count;
 
        if (Flags & MB_ERR_INVALID_CHARS)
        {
            TempString = MultiByteString;
 
            while (TempString < MbsEnd)
            {
                DBCSOffset = CodePageTable->DBCSOffsets[(UCHAR)*TempString];
 
                if (DBCSOffset)
                {
                    /* If lead byte is presented, but behind it there is no symbol */
                    if (((TempString + 1) == MbsEnd) || (*(TempString + 1) == 0))
                    {
                        SetLastError(ERROR_NO_UNICODE_TRANSLATION);
                        return 0;
                    }
 
                    WideChar = CodePageTable->DBCSOffsets[DBCSOffset + *(TempString + 1)];
 
                    if (WideChar == CodePageTable->UniDefaultChar &&
                        MAKEWORD(*(TempString + 1), *TempString) != CodePageTable->TransUniDefaultChar)
                    {
                        SetLastError(ERROR_NO_UNICODE_TRANSLATION);
                        return 0;
                    }
 
                    TempString++;
                }
                else
                {
                    WideChar = MultiByteTable[(UCHAR)*TempString];
 
                    if ((WideChar == CodePageTable->UniDefaultChar &&
                        *TempString != CodePageTable->TransUniDefaultChar) ||
                        /* "Private Use" characters */
                        (WideChar >= 0xE000 && WideChar <= 0xF8FF))
                    {
                        SetLastError(ERROR_NO_UNICODE_TRANSLATION);
                        return 0;
                    }
                }
 
                TempString++;
            }
        }
 
        /* Does caller query for output buffer size? */
        if (WideCharCount == 0)
        {
            for (; MultiByteString < MbsEnd; WideCharCount++)
            {
                Char = *MultiByteString++;
 
                DBCSOffset = CodePageTable->DBCSOffsets[Char];
 
                if (!DBCSOffset)
                    continue;
 
                if (MultiByteString < MbsEnd)
                    MultiByteString++;
            }
 
            return WideCharCount;
        }
 
        for (Count = 0; Count < WideCharCount && MultiByteString < MbsEnd; Count++)
        {
            Char = *MultiByteString++;
 
            DBCSOffset = CodePageTable->DBCSOffsets[Char];
 
            if (!DBCSOffset)
            {
                *WideCharString++ = MultiByteTable[Char];
                continue;
            }
 
            if (MultiByteString == MbsEnd || *MultiByteString == 0)
            {
                *WideCharString++ = CodePageTable->UniDefaultChar;
            }
            else
            {
                *WideCharString++ = CodePageTable->DBCSOffsets[DBCSOffset + (UCHAR)*MultiByteString++];
            }
        }
 
        if (MultiByteString < MbsEnd)
        {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return 0;
        }
 
        return Count;
    }
    else /* SBCS code page */
    {
        /* Check for invalid characters. */
        if (Flags & MB_ERR_INVALID_CHARS)
        {
            for (TempString = MultiByteString, TempLength = MultiByteCount;
                 TempLength > 0;
                 TempString++, TempLength--)
            {
                WideChar = MultiByteTable[(UCHAR)*TempString];
 
                if ((WideChar == CodePageTable->UniDefaultChar &&
                    *TempString != CodePageTable->TransUniDefaultChar) ||
                    /* "Private Use" characters */
                    (WideChar >= 0xE000 && WideChar <= 0xF8FF))
                {
                    SetLastError(ERROR_NO_UNICODE_TRANSLATION);
                    return 0;
                }
            }
        }
 
        /* Does caller query for output buffer size? */
        if (WideCharCount == 0)
            return MultiByteCount;
 
        /* Fill the WideCharString buffer with what will fit: Verified on WinXP */
        for (TempLength = (WideCharCount < MultiByteCount) ? WideCharCount : MultiByteCount;
            TempLength > 0;
            MultiByteString++, TempLength--)
        {
            *WideCharString++ = MultiByteTable[(UCHAR)*MultiByteString];
        }
 
        /* Adjust buffer size. Wine trick ;-) */
        if (WideCharCount < MultiByteCount)
        {
            MultiByteCount = WideCharCount;
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return 0;
        }
        return MultiByteCount;
    }
}

Referenced by MultiByteToWideChar().

IntMultiByteToWideCharSYMBOL()

static INT WINAPI IntMultiByteToWideCharSYMBOL ( DWORD  Flags, LPCSTR  MultiByteString, INT  MultiByteCount, LPWSTR  WideCharString, INT  WideCharCount  )

static

Definition at line 856 of file nls.c.

{
    LONG Count;
    UCHAR Char;
    INT WideCharMaxLen;
 
 
    if (Flags != 0)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    if (WideCharCount == 0)
    {
        return MultiByteCount;
    }
 
    WideCharMaxLen = WideCharCount > MultiByteCount ? MultiByteCount : WideCharCount;
 
    for (Count = 0; Count < WideCharMaxLen; Count++)
    {
        Char = MultiByteString[Count];
        if ( Char < 0x20 )
        {
            WideCharString[Count] = Char;
        }
        else
        {
            WideCharString[Count] = Char + 0xf000;
        }
    }
    if (MultiByteCount > WideCharMaxLen)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return 0;
    }
 
    return WideCharMaxLen;
}

Referenced by MultiByteToWideChar().

IntMultiByteToWideCharUTF8()

static INT WINAPI IntMultiByteToWideCharUTF8 ( DWORD  Flags, LPCSTR  MultiByteString, INT  MultiByteCount, LPWSTR  WideCharString, INT  WideCharCount  )

static

Definition at line 490 of file nls.c.

{
    LPCSTR MbsEnd, MbsPtrSave;
    UCHAR Char, TrailLength;
    WCHAR WideChar;
    LONG Count;
    BOOL CharIsValid, StringIsValid = TRUE;
    const WCHAR InvalidChar = 0xFFFD;
 
    if (Flags != 0 && Flags != MB_ERR_INVALID_CHARS)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    /* Does caller query for output buffer size? */
    if (WideCharCount == 0)
    {
        /* validate and count the wide characters */
        MbsEnd = MultiByteString + MultiByteCount;
        for (; MultiByteString < MbsEnd; WideCharCount++)
        {
            Char = *MultiByteString++;
            if (Char < 0x80)
            {
                TrailLength = 0;
                continue;
            }
            if ((Char & 0xC0) == 0x80)
            {
                TrailLength = 0;
                StringIsValid = FALSE;
                continue;
            }
 
            TrailLength = UTF8Length[Char - 0x80];
            if (TrailLength == 0)
            {
                StringIsValid = FALSE;
                continue;
            }
 
            CharIsValid = TRUE;
            MbsPtrSave = MultiByteString;
            WideChar = Char & UTF8Mask[TrailLength];
 
            while (TrailLength && MultiByteString < MbsEnd)
            {
                if ((*MultiByteString & 0xC0) != 0x80)
                {
                    CharIsValid = StringIsValid = FALSE;
                    break;
                }
 
                WideChar = (WideChar << 6) | (*MultiByteString++ & 0x7f);
                TrailLength--;
            }
 
            if (!CharIsValid || WideChar < UTF8LBound[UTF8Length[Char - 0x80]])
            {
                MultiByteString = MbsPtrSave;
            }
        }
 
        if (TrailLength)
        {
            WideCharCount++;
            StringIsValid = FALSE;
        }
 
        if (Flags == MB_ERR_INVALID_CHARS && !StringIsValid)
        {
            SetLastError(ERROR_NO_UNICODE_TRANSLATION);
            return 0;
        }
 
        return WideCharCount;
    }
 
    /* convert */
    MbsEnd = MultiByteString + MultiByteCount;
    for (Count = 0; Count < WideCharCount && MultiByteString < MbsEnd; Count++)
    {
        Char = *MultiByteString++;
        if (Char < 0x80)
        {
            *WideCharString++ = Char;
            TrailLength = 0;
            continue;
        }
        if ((Char & 0xC0) == 0x80)
        {
            *WideCharString++ = InvalidChar;
            TrailLength = 0;
            StringIsValid = FALSE;
            continue;
        }
 
        TrailLength = UTF8Length[Char - 0x80];
        if (TrailLength == 0)
        {
            *WideCharString++ = InvalidChar;
            StringIsValid = FALSE;
            continue;
        }
 
        CharIsValid = TRUE;
        MbsPtrSave = MultiByteString;
        WideChar = Char & UTF8Mask[TrailLength];
 
        while (TrailLength && MultiByteString < MbsEnd)
        {
            if ((*MultiByteString & 0xC0) != 0x80)
            {
                CharIsValid = StringIsValid = FALSE;
                break;
            }
 
            WideChar = (WideChar << 6) | (*MultiByteString++ & 0x7f);
            TrailLength--;
        }
 
        if (CharIsValid && UTF8LBound[UTF8Length[Char - 0x80]] <= WideChar)
        {
            *WideCharString++ = WideChar;
        }
        else
        {
            *WideCharString++ = InvalidChar;
            MultiByteString = MbsPtrSave;
            StringIsValid = FALSE;
        }
    }
 
    if (TrailLength && Count < WideCharCount && MultiByteString < MbsEnd)
    {
        *WideCharString = InvalidChar;
        WideCharCount++;
    }
 
    if (MultiByteString < MbsEnd)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return 0;
    }
 
    if (Flags == MB_ERR_INVALID_CHARS && (!StringIsValid || TrailLength))
    {
        SetLastError(ERROR_NO_UNICODE_TRANSLATION);
        return 0;
    }
 
    return Count;
}

Referenced by MultiByteToWideChar().

IntWideCharToMultiByteCP()

static INT WINAPI IntWideCharToMultiByteCP ( UINT  CodePage, DWORD  Flags, LPCWSTR  WideCharString, INT  WideCharCount, LPSTR  MultiByteString, INT  MultiByteCount, LPCSTR  DefaultChar, LPBOOL  UsedDefaultChar  )

static

Definition at line 1159 of file nls.c.

{
    PCODEPAGE_ENTRY CodePageEntry;
    PCPTABLEINFO CodePageTable;
    INT TempLength;
 
    /* Get code page table. */
    CodePageEntry = IntGetCodePageEntry(CodePage);
    if (CodePageEntry == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    CodePageTable = &CodePageEntry->CodePageTable;
 
 
    /* Different handling for DBCS code pages. */
    if (CodePageTable->DBCSCodePage)
    {
        /* If Flags, DefaultChar or UsedDefaultChar were given, we have to do some more work */
        if (Flags || DefaultChar || UsedDefaultChar)
        {
            BOOL TempUsedDefaultChar;
            USHORT DefChar;
 
            /* If UsedDefaultChar is not set, set it to a temporary value, so we don't have
               to check on every character */
            if (!UsedDefaultChar)
                UsedDefaultChar = &TempUsedDefaultChar;
 
            *UsedDefaultChar = FALSE;
 
            /* Use the CodePage's TransDefaultChar if none was given. Don't modify the DefaultChar pointer here. */
            if (DefaultChar)
                DefChar = DefaultChar[1] ? ((DefaultChar[0] << 8) | DefaultChar[1]) : DefaultChar[0];
            else
                DefChar = CodePageTable->TransDefaultChar;
 
            /* Does caller query for output buffer size? */
            if (!MultiByteCount)
            {
                for (TempLength = 0; WideCharCount; WideCharCount--, WideCharString++, TempLength++)
                {
                    USHORT uChar;
 
                    if ((Flags & WC_COMPOSITECHECK) && WideCharCount > 1)
                    {
                        /* FIXME: Handle WC_COMPOSITECHECK */
                        DPRINT("WC_COMPOSITECHECK flag UNIMPLEMENTED\n");
                    }
 
                    uChar = ((PUSHORT) CodePageTable->WideCharTable)[*WideCharString];
 
                    /* Verify if the mapping is valid for handling DefaultChar and UsedDefaultChar */
                    if (!IntIsValidDBCSMapping(CodePageTable, Flags, *WideCharString, uChar))
                    {
                        uChar = DefChar;
                        *UsedDefaultChar = TRUE;
                    }
 
                    /* Increment TempLength again if this is a double-byte character */
                    if (uChar & 0xff00)
                        TempLength++;
                }
 
                return TempLength;
            }
 
            /* Convert the WideCharString to the MultiByteString and verify if the mapping is valid */
            for (TempLength = MultiByteCount;
                 WideCharCount && TempLength;
                 TempLength--, WideCharString++, WideCharCount--)
            {
                USHORT uChar;
 
                if ((Flags & WC_COMPOSITECHECK) && WideCharCount > 1)
                {
                    /* FIXME: Handle WC_COMPOSITECHECK */
                    DPRINT("WC_COMPOSITECHECK flag UNIMPLEMENTED\n");
                }
 
                uChar = ((PUSHORT)CodePageTable->WideCharTable)[*WideCharString];
 
                /* Verify if the mapping is valid for handling DefaultChar and UsedDefaultChar */
                if (!IntIsValidDBCSMapping(CodePageTable, Flags, *WideCharString, uChar))
                {
                    uChar = DefChar;
                    *UsedDefaultChar = TRUE;
                }
 
                /* Handle double-byte characters */
                if (uChar & 0xff00)
                {
                    /* Don't output a partial character */
                    if (TempLength == 1)
                        break;
 
                    TempLength--;
                    *MultiByteString++ = uChar >> 8;
                }
 
                *MultiByteString++ = (char)uChar;
            }
 
            /* WideCharCount should be 0 if all characters were converted */
            if (WideCharCount)
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
 
            return MultiByteCount - TempLength;
        }
 
        /* Does caller query for output buffer size? */
        if (!MultiByteCount)
        {
            for (TempLength = 0; WideCharCount; WideCharCount--, WideCharString++, TempLength++)
            {
                /* Increment TempLength again if this is a double-byte character */
                if (((PWCHAR)CodePageTable->WideCharTable)[*WideCharString] & 0xff00)
                    TempLength++;
            }
 
            return TempLength;
        }
 
        /* Convert the WideCharString to the MultiByteString */
        for (TempLength = MultiByteCount;
             WideCharCount && TempLength;
             TempLength--, WideCharString++, WideCharCount--)
        {
            USHORT uChar = ((PUSHORT) CodePageTable->WideCharTable)[*WideCharString];
 
            /* Is this a double-byte character? */
            if (uChar & 0xff00)
            {
                /* Don't output a partial character */
                if (TempLength == 1)
                    break;
 
                TempLength--;
                *MultiByteString++ = uChar >> 8;
            }
 
            *MultiByteString++ = (char)uChar;
        }
 
        /* WideCharCount should be 0 if all characters were converted */
        if (WideCharCount)
        {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return 0;
        }
 
        return MultiByteCount - TempLength;
    }
    else /* SBCS code page */
    {
        INT nReturn;
 
        /* If Flags, DefaultChar or UsedDefaultChar were given, we have to do some more work */
        if (Flags || DefaultChar || UsedDefaultChar)
        {
            BOOL TempUsedDefaultChar;
            CHAR DefChar;
 
            /* If UsedDefaultChar is not set, set it to a temporary value, so we don't have
               to check on every character */
            if (!UsedDefaultChar)
                UsedDefaultChar = &TempUsedDefaultChar;
 
            *UsedDefaultChar = FALSE;
 
            /* Does caller query for output buffer size? */
            if (!MultiByteCount)
            {
                /* Loop through the whole WideCharString and check if we can get a valid mapping for each character */
                for (TempLength = 0; WideCharCount; TempLength++, WideCharString++, WideCharCount--)
                {
                    if ((Flags & WC_COMPOSITECHECK) && WideCharCount > 1)
                    {
                        /* FIXME: Handle WC_COMPOSITECHECK */
                        DPRINT("WC_COMPOSITECHECK flag UNIMPLEMENTED\n");
                    }
 
                    if (!*UsedDefaultChar)
                        *UsedDefaultChar = !IntIsValidSBCSMapping(CodePageTable,
                                                                  Flags,
                                                                  *WideCharString,
                                                                  ((PCHAR)CodePageTable->WideCharTable)[*WideCharString]);
                }
 
                return TempLength;
            }
 
            /* Use the CodePage's TransDefaultChar if none was given. Don't modify the DefaultChar pointer here. */
            if (DefaultChar)
                DefChar = *DefaultChar;
            else
                DefChar = (CHAR)CodePageTable->TransDefaultChar;
 
            /* Convert the WideCharString to the MultiByteString and verify if the mapping is valid */
            for (TempLength = MultiByteCount;
                 WideCharCount && TempLength;
                 MultiByteString++, TempLength--, WideCharString++, WideCharCount--)
            {
                if ((Flags & WC_COMPOSITECHECK) && WideCharCount > 1)
                {
                    /* FIXME: Handle WC_COMPOSITECHECK */
                    DPRINT("WC_COMPOSITECHECK flag UNIMPLEMENTED\n");
                }
 
                *MultiByteString = ((PCHAR)CodePageTable->WideCharTable)[*WideCharString];
 
                if (!IntIsValidSBCSMapping(CodePageTable, Flags, *WideCharString, *MultiByteString))
                {
                    *MultiByteString = DefChar;
                    *UsedDefaultChar = TRUE;
                }
            }
 
            /* WideCharCount should be 0 if all characters were converted */
            if (WideCharCount)
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
 
            return MultiByteCount - TempLength;
        }
 
        /* Does caller query for output buffer size? */
        if (!MultiByteCount)
            return WideCharCount;
 
        /* Is the buffer large enough? */
        if (MultiByteCount < WideCharCount)
        {
            /* Convert the string up to MultiByteCount and return 0 */
            WideCharCount = MultiByteCount;
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            nReturn = 0;
        }
        else
        {
            /* Otherwise WideCharCount will be the number of converted characters */
            nReturn = WideCharCount;
        }
 
        /* Convert the WideCharString to the MultiByteString */
        for (TempLength = WideCharCount; --TempLength >= 0; WideCharString++, MultiByteString++)
        {
            *MultiByteString = ((PCHAR)CodePageTable->WideCharTable)[*WideCharString];
        }
 
        return nReturn;
    }
}

Referenced by WideCharToMultiByte().

IntWideCharToMultiByteSYMBOL()

static INT WINAPI IntWideCharToMultiByteSYMBOL ( DWORD  Flags, LPCWSTR  WideCharString, INT  WideCharCount, LPSTR  MultiByteString, INT  MultiByteCount  )

static

Definition at line 911 of file nls.c.

{
    LONG Count;
    INT MaxLen;
    WCHAR Char;
 
    if (Flags!=0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
 
    if (MultiByteCount == 0)
    {
        return WideCharCount;
    }
 
    MaxLen = MultiByteCount > WideCharCount ? WideCharCount : MultiByteCount;
    for (Count = 0; Count < MaxLen; Count++)
    {
        Char = WideCharString[Count];
        if (Char < 0x20)
        {
            MultiByteString[Count] = (CHAR)Char;
        }
        else
        {
            if ((Char >= 0xf020) && (Char < 0xf100))
            {
                MultiByteString[Count] = Char - 0xf000;
            }
            else
            {
                SetLastError(ERROR_NO_UNICODE_TRANSLATION);
                return 0;
            }
        }
    }
 
    if (WideCharCount > MaxLen)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return 0;
    }
    return MaxLen;
}

Referenced by WideCharToMultiByte().

IntWideCharToMultiByteUTF8()

static INT WINAPI IntWideCharToMultiByteUTF8 ( UINT  CodePage, DWORD  Flags, LPCWSTR  WideCharString, INT  WideCharCount, LPSTR  MultiByteString, INT  MultiByteCount, LPCSTR  DefaultChar, LPBOOL  UsedDefaultChar  )

static

Definition at line 973 of file nls.c.

{
    INT TempLength;
    DWORD Char;
 
    if (Flags)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return 0;
    }
 
    /* Does caller query for output buffer size? */
    if (MultiByteCount == 0)
    {
        for (TempLength = 0; WideCharCount;
            WideCharCount--, WideCharString++)
        {
            TempLength++;
            if (*WideCharString >= 0x80)
            {
                TempLength++;
                if (*WideCharString >= 0x800)
                {
                    TempLength++;
                    if (*WideCharString >= 0xd800 && *WideCharString < 0xdc00 &&
                        WideCharCount >= 1 &&
                        WideCharString[1] >= 0xdc00 && WideCharString[1] <= 0xe000)
                    {
                        WideCharCount--;
                        WideCharString++;
                        TempLength++;
                    }
                }
            }
        }
        return TempLength;
    }
 
    for (TempLength = MultiByteCount; WideCharCount; WideCharCount--, WideCharString++)
    {
        Char = *WideCharString;
        if (Char < 0x80)
        {
            if (!TempLength)
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                break;
            }
            TempLength--;
            *MultiByteString++ = (CHAR)Char;
            continue;
        }
 
        if (Char < 0x800)  /* 0x80-0x7ff: 2 bytes */
        {
            if (TempLength < 2)
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                break;
            }
            MultiByteString[1] = 0x80 | (Char & 0x3f); Char >>= 6;
            MultiByteString[0] = 0xc0 | Char;
            MultiByteString += 2;
            TempLength -= 2;
            continue;
        }
 
        /* surrogate pair 0x10000-0x10ffff: 4 bytes */
        if (Char >= 0xd800 && Char < 0xdc00 &&
            WideCharCount >= 1 &&
            WideCharString[1] >= 0xdc00 && WideCharString[1] < 0xe000)
        {
            WideCharCount--;
            WideCharString++;
 
            if (TempLength < 4)
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                break;
            }
 
            Char = (Char - 0xd800) << 10;
            Char |= *WideCharString - 0xdc00;
            ASSERT(Char <= 0xfffff);
            Char += 0x10000;
            ASSERT(Char <= 0x10ffff);
 
            MultiByteString[3] = 0x80 | (Char & 0x3f); Char >>= 6;
            MultiByteString[2] = 0x80 | (Char & 0x3f); Char >>= 6;
            MultiByteString[1] = 0x80 | (Char & 0x3f); Char >>= 6;
            MultiByteString[0] = 0xf0 | Char;
            MultiByteString += 4;
            TempLength -= 4;
            continue;
        }
 
        /* 0x800-0xffff: 3 bytes */
        if (TempLength < 3)
        {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            break;
        }
        MultiByteString[2] = 0x80 | (Char & 0x3f); Char >>= 6;
        MultiByteString[1] = 0x80 | (Char & 0x3f); Char >>= 6;
        MultiByteString[0] = 0xe0 | Char;
        MultiByteString += 3;
        TempLength -= 3;
    }
 
    return MultiByteCount - TempLength;
}

Referenced by WideCharToMultiByte().

IsDBCSLeadByte()

BOOL WINAPI IsDBCSLeadByte

(

BYTE

TestByte

)

Definition at line 2361 of file nls.c.

{
    return IntIsLeadByte(&AnsiCodePage.CodePageTable, TestByte);
}

IsDBCSLeadByteEx()

BOOL WINAPI IsDBCSLeadByteEx	(	UINT	CodePage,
		BYTE	TestByte
	)

Definition at line 2339 of file nls.c.

{
    PCODEPAGE_ENTRY CodePageEntry;
 
    CodePageEntry = IntGetCodePageEntry(CodePage);
    if (CodePageEntry != NULL)
        return IntIsLeadByte(&CodePageEntry->CodePageTable, TestByte);
 
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
}

IsNLSDefinedString()

BOOL WINAPI IsNLSDefinedString	(	IN NLS_FUNCTION	Function,
		IN DWORD	dwFlags,
		IN LPNLSVERSIONINFO	lpVersionInformation,
		IN LPCWSTR	lpString,
		IN INT	cchStr
	)

Definition at line 2563 of file nls.c.

{
    STUB;
    return TRUE;
}

IsValidCodePage()

BOOL WINAPI IsValidCodePage

(

UINT

CodePage

)

Definition at line 1604 of file nls.c.

{
    if (CodePage == 0) return FALSE;
    if (CodePage == CP_UTF8 || CodePage == CP_UTF7)
        return TRUE;
    if (IntGetLoadedCodePageEntry(CodePage))
        return TRUE;
    return GetCPFileNameFromRegistry(CodePage, NULL, 0);
}

IsValidUILanguage()

BOOL WINAPI IsValidUILanguage

(

LANGID

langid

)

Definition at line 2469 of file nls.c.

{
    STUB;
    return 0;
}

MultiByteToWideChar()

INT WINAPI MultiByteToWideChar	(	UINT	CodePage,
		DWORD	Flags,
		LPCSTR	MultiByteString,
		INT	MultiByteCount,
		LPWSTR	WideCharString,
		INT	WideCharCount
	)

Definition at line 1763 of file nls.c.

{
    /* Check the parameters. */
    if (MultiByteString == NULL ||
        MultiByteCount == 0 || WideCharCount < 0 ||
        (WideCharCount && (WideCharString == NULL ||
        (PVOID)MultiByteString == (PVOID)WideCharString)))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    /* Determine the input string length. */
    if (MultiByteCount < 0)
    {
        MultiByteCount = lstrlenA(MultiByteString) + 1;
    }
 
    switch (CodePage)
    {
        case CP_UTF8:
            return IntMultiByteToWideCharUTF8(Flags,
                                              MultiByteString,
                                              MultiByteCount,
                                              WideCharString,
                                              WideCharCount);
 
        case CP_UTF7:
            if (Flags)
            {
                SetLastError(ERROR_INVALID_FLAGS);
                return 0;
            }
            return Utf7ToWideChar(MultiByteString, MultiByteCount,
                                  WideCharString, WideCharCount);
 
        case CP_SYMBOL:
            return IntMultiByteToWideCharSYMBOL(Flags,
                                                MultiByteString,
                                                MultiByteCount,
                                                WideCharString,
                                                WideCharCount);
        default:
            return IntMultiByteToWideCharCP(CodePage,
                                            Flags,
                                            MultiByteString,
                                            MultiByteCount,
                                            WideCharString,
                                            WideCharCount);
    }
}

NlsConvertIntegerToString()

VOID WINAPI NlsConvertIntegerToString	(	ULONG	Value,
		ULONG	Base,
		ULONG	strsize,
		LPWSTR	str,
		ULONG	strsize2
	)

Definition at line 2478 of file nls.c.

{
    STUB;
}

NlsGetCacheUpdateCount()

ULONG WINAPI NlsGetCacheUpdateCount

(

VOID

)

Definition at line 2552 of file nls.c.

{
    STUB;
    return 0;
}

NlsInit()

BOOL FASTCALL NlsInit

(

VOID

)

Definition at line 151 of file nls.c.

{
    NTSTATUS Status;
    UNICODE_STRING DirName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE Handle;
    UCHAR SecurityDescriptor[NLS_SECTION_SECURITY_DESCRIPTOR_SIZE +
                             NLS_SIZEOF_ACE_AND_SIDS(2)];
 
    InitializeListHead(&CodePageListHead);
    RtlInitializeCriticalSection(&CodePageListLock);
 
    /*
     * FIXME: Eventually this should be done only for the NLS Server
     * process, but since we don't have anything like that (yet?) we
     * always try to create the "\NLS" directory here.
     */
    RtlInitUnicodeString(&DirName, L"\\NLS");
 
    /* Create a security descriptor for the NLS directory */
    Status = CreateNlsDirectorySecurity(&SecurityDescriptor,
                                        sizeof(SecurityDescriptor));
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create NLS directory security (Status 0x%08x)\n", Status);
        return FALSE;
    }
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &DirName,
                               OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
                               NULL,
                               &SecurityDescriptor);
 
    Status = NtCreateDirectoryObject(&Handle,
                                     DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT,
                                     &ObjectAttributes);
    if (NT_SUCCESS(Status))
    {
        NtClose(Handle);
    }
 
    /* Setup ANSI code page. */
    AnsiCodePage.SectionHandle = NULL;
    AnsiCodePage.SectionMapping = NtCurrentTeb()->ProcessEnvironmentBlock->AnsiCodePageData;
 
    RtlInitCodePageTable((PUSHORT)AnsiCodePage.SectionMapping,
                         &AnsiCodePage.CodePageTable);
    AnsiCodePage.CodePage = AnsiCodePage.CodePageTable.CodePage;
 
    InsertTailList(&CodePageListHead, &AnsiCodePage.Entry);
 
    /* Setup OEM code page. */
    OemCodePage.SectionHandle = NULL;
    OemCodePage.SectionMapping = NtCurrentTeb()->ProcessEnvironmentBlock->OemCodePageData;
 
    RtlInitCodePageTable((PUSHORT)OemCodePage.SectionMapping,
                         &OemCodePage.CodePageTable);
    OemCodePage.CodePage = OemCodePage.CodePageTable.CodePage;
    InsertTailList(&CodePageListHead, &OemCodePage.Entry);
 
    return TRUE;
}

Referenced by DllMain().

NlsResetProcessLocale()

BOOL WINAPI NlsResetProcessLocale

(

VOID

)

Definition at line 2508 of file nls.c.

{
    STUB;
    return TRUE;
}

NlsUninit()

VOID FASTCALL NlsUninit

(

VOID

)

Definition at line 223 of file nls.c.

{
    PCODEPAGE_ENTRY Current;
 
    /* Delete the code page list. */
    while (!IsListEmpty(&CodePageListHead))
    {
        Current = CONTAINING_RECORD(CodePageListHead.Flink, CODEPAGE_ENTRY, Entry);
        if (Current->SectionHandle != NULL)
        {
            UnmapViewOfFile(Current->SectionMapping);
            NtClose(Current->SectionHandle);
        }
        RemoveHeadList(&CodePageListHead);
    }
    RtlDeleteCriticalSection(&CodePageListLock);
}

Referenced by DllMain().

SetCPGlobal()

UINT WINAPI SetCPGlobal

(

UINT

CodePage

)

Definition at line 2486 of file nls.c.

{
    STUB;
    return 0;
}

utf7_can_directly_encode()

static BOOL utf7_can_directly_encode ( WCHAR  codepoint )

inlinestatic

Definition at line 1820 of file nls.c.

{
    static const BOOL directly_encodable_table[] =
    {
        1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, /* 0x00 - 0x0F */
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1F */
        1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* 0x20 - 0x2F */
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 0x30 - 0x3F */
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4F */
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 0x50 - 0x5F */
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6F */
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1                 /* 0x70 - 0x7A */
    };
 
    return codepoint <= 0x7A ? directly_encodable_table[codepoint] : FALSE;
}

Referenced by WideCharToUtf7().

utf7_write_c()

static BOOL utf7_write_c ( char *  dst, int  dstlen, int *  index, char  character  )

inlinestatic

Definition at line 1837 of file nls.c.

{
    if (dstlen > 0)
    {
        if (*index >= dstlen)
            return FALSE;
 
        dst[*index] = character;
    }
 
    (*index)++;
 
    return TRUE;
}

Referenced by WideCharToUtf7().

utf7_write_w()

static BOOL utf7_write_w ( WCHAR *  dst, int  dstlen, int *  index, WCHAR  character  )

inlinestatic

Definition at line 1614 of file nls.c.

{
    if (dstlen > 0)
    {
        if (*index >= dstlen)
            return FALSE;
 
        dst[*index] = character;
    }
 
    (*index)++;
 
    return TRUE;
}

Referenced by Utf7ToWideChar().

Utf7ToWideChar()

static INT Utf7ToWideChar ( const char *  src, int  srclen, WCHAR *  dst, int  dstlen  )

static

Definition at line 1629 of file nls.c.

{
    static const signed char base64_decoding_table[] =
    {
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00-0x0F */
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10-0x1F */
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, /* 0x20-0x2F */
        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* 0x30-0x3F */
        -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, /* 0x40-0x4F */
        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, /* 0x50-0x5F */
        -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60-0x6F */
        41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1  /* 0x70-0x7F */
    };
 
    const char *source_end = src + srclen;
    int dest_index = 0;
 
    DWORD byte_pair = 0;
    short offset = 0;
 
    while (src < source_end)
    {
        if (*src == '+')
        {
            src++;
            if (src >= source_end)
                break;
 
            if (*src == '-')
            {
                /* just a plus sign escaped as +- */
                if (!utf7_write_w(dst, dstlen, &dest_index, '+'))
                {
                    SetLastError(ERROR_INSUFFICIENT_BUFFER);
                    return 0;
                }
                src++;
                continue;
            }
 
            do
            {
                signed char sextet = *src;
                if (sextet == '-')
                {
                    /* skip over the dash and end base64 decoding
                     * the current, unfinished byte pair is discarded */
                    src++;
                    offset = 0;
                    break;
                }
                if (sextet < 0)
                {
                    /* the next character of src is < 0 and therefore not part of a base64 sequence
                     * the current, unfinished byte pair is NOT discarded in this case
                     * this is probably a bug in Windows */
                    break;
                }
 
                sextet = base64_decoding_table[sextet];
                if (sextet == -1)
                {
                    /* -1 means that the next character of src is not part of a base64 sequence
                     * in other words, all sextets in this base64 sequence have been processed
                     * the current, unfinished byte pair is discarded */
                    offset = 0;
                    break;
                }
 
                byte_pair = (byte_pair << 6) | sextet;
                offset += 6;
 
                if (offset >= 16)
                {
                    /* this byte pair is done */
                    if (!utf7_write_w(dst, dstlen, &dest_index, (byte_pair >> (offset - 16)) & 0xFFFF))
                    {
                        SetLastError(ERROR_INSUFFICIENT_BUFFER);
                        return 0;
                    }
                    offset -= 16;
                }
 
                src++;
            }
            while (src < source_end);
        }
        else
        {
            /* we have to convert to unsigned char in case *src < 0 */
            if (!utf7_write_w(dst, dstlen, &dest_index, (unsigned char)*src))
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
            src++;
        }
    }
 
    return dest_index;
}

Referenced by MultiByteToWideChar().

ValidateLCType()

BOOL WINAPI ValidateLCType	(	int	a1,
		unsigned int	a2,
		int	a3,
		int	a4
	)

Definition at line 2497 of file nls.c.

{
    STUB;
    return FALSE;
}

ValidateLocale()

BOOL WINAPI ValidateLocale

(

IN ULONG

LocaleId

)

Definition at line 2541 of file nls.c.

{
    STUB;
    return TRUE;
}

WideCharToMultiByte()

INT WINAPI WideCharToMultiByte	(	UINT	CodePage,
		DWORD	Flags,
		LPCWSTR	WideCharString,
		INT	WideCharCount,
		LPSTR	MultiByteString,
		INT	MultiByteCount,
		LPCSTR	DefaultChar,
		LPBOOL	UsedDefaultChar
	)

Definition at line 2218 of file nls.c.

{
    /* Check the parameters. */
    if (WideCharString == NULL ||
        WideCharCount == 0 ||
        (MultiByteString == NULL && MultiByteCount > 0) ||
        (PVOID)WideCharString == (PVOID)MultiByteString ||
        MultiByteCount < 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    /* Determine the input string length. */
    if (WideCharCount < 0)
    {
        WideCharCount = lstrlenW(WideCharString) + 1;
    }
 
    switch (CodePage)
    {
        case CP_UTF8:
            if (DefaultChar != NULL || UsedDefaultChar != NULL)
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                return 0;
            }
            return IntWideCharToMultiByteUTF8(CodePage,
                                              Flags,
                                              WideCharString,
                                              WideCharCount,
                                              MultiByteString,
                                              MultiByteCount,
                                              DefaultChar,
                                              UsedDefaultChar);
 
        case CP_UTF7:
            if (DefaultChar != NULL || UsedDefaultChar != NULL)
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                return 0;
            }
            if (Flags)
            {
                SetLastError(ERROR_INVALID_FLAGS);
                return 0;
            }
            return WideCharToUtf7(WideCharString, WideCharCount,
                                  MultiByteString, MultiByteCount);
 
        case CP_SYMBOL:
            if ((DefaultChar!=NULL) || (UsedDefaultChar!=NULL))
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                return 0;
            }
            return IntWideCharToMultiByteSYMBOL(Flags,
                                                WideCharString,
                                                WideCharCount,
                                                MultiByteString,
                                                MultiByteCount);
 
        default:
            return IntWideCharToMultiByteCP(CodePage,
                                            Flags,
                                            WideCharString,
                                            WideCharCount,
                                            MultiByteString,
                                            MultiByteCount,
                                            DefaultChar,
                                            UsedDefaultChar);
   }
}

WideCharToUtf7()

static INT WideCharToUtf7 ( const WCHAR *  src, int  srclen, char *  dst, int  dstlen  )

static

Definition at line 1852 of file nls.c.

{
    static const char base64_encoding_table[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
    const WCHAR *source_end = src + srclen;
    int dest_index = 0;
 
    while (src < source_end)
    {
        if (*src == '+')
        {
            if (!utf7_write_c(dst, dstlen, &dest_index, '+'))
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
            if (!utf7_write_c(dst, dstlen, &dest_index, '-'))
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
            src++;
        }
        else if (utf7_can_directly_encode(*src))
        {
            if (!utf7_write_c(dst, dstlen, &dest_index, *src))
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
            src++;
        }
        else
        {
            unsigned int offset = 0;
            DWORD byte_pair = 0;
 
            if (!utf7_write_c(dst, dstlen, &dest_index, '+'))
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
 
            while (src < source_end && !utf7_can_directly_encode(*src))
            {
                byte_pair = (byte_pair << 16) | *src;
                offset += 16;
                while (offset >= 6)
                {
                    if (!utf7_write_c(dst, dstlen, &dest_index, base64_encoding_table[(byte_pair >> (offset - 6)) & 0x3F]))
                    {
                        SetLastError(ERROR_INSUFFICIENT_BUFFER);
                        return 0;
                    }
                    offset -= 6;
                }
                src++;
            }
 
            if (offset)
            {
                /* Windows won't create a padded base64 character if there's no room for the - sign
                 * as well ; this is probably a bug in Windows */
                if (dstlen > 0 && dest_index + 1 >= dstlen)
                {
                    SetLastError(ERROR_INSUFFICIENT_BUFFER);
                    return 0;
                }
 
                byte_pair <<= (6 - offset);
                if (!utf7_write_c(dst, dstlen, &dest_index, base64_encoding_table[byte_pair & 0x3F]))
                {
                    SetLastError(ERROR_INSUFFICIENT_BUFFER);
                    return 0;
                }
            }
 
            /* Windows always explicitly terminates the base64 sequence
               even though RFC 2152 (page 3, rule 2) does not require this */
            if (!utf7_write_c(dst, dstlen, &dest_index, '-'))
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                return 0;
            }
        }
    }
 
    return dest_index;
}

Referenced by WideCharToMultiByte().

Variable Documentation

AnsiCodePage

CODEPAGE_ENTRY AnsiCodePage

static

Definition at line 46 of file nls.c.

Referenced by EngGetCurrentCodePage(), GetACP(), IntGetCodePageEntry(), IsDBCSLeadByte(), NlsInit(), and RtlGetDefaultCodePage().

CodePageListHead

LIST_ENTRY CodePageListHead

static

Definition at line 45 of file nls.c.

Referenced by IntGetCodePageEntry(), IntGetLoadedCodePageEntry(), NlsInit(), and NlsUninit().

CodePageListLock

RTL_CRITICAL_SECTION CodePageListLock

static

Definition at line 48 of file nls.c.

Referenced by IntGetCodePageEntry(), IntGetLoadedCodePageEntry(), NlsInit(), and NlsUninit().

OemCodePage

CODEPAGE_ENTRY OemCodePage

static

Definition at line 47 of file nls.c.

Referenced by CreateStockFonts(), EngGetCurrentCodePage(), GetOEMCP(), IntGetCodePageEntry(), NlsInit(), and RtlGetDefaultCodePage().

UTF8LBound

const unsigned long UTF8LBound[]

static

Initial value:

=
    {0, 0x80, 0x800, 0x10000, 0x200000, 0x2000000, 0xFFFFFFFF}

Definition at line 41 of file nls.c.

Referenced by IntMultiByteToWideCharUTF8().

UTF8Length

const char UTF8Length[128]

static

Initial value:

=
{
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
   0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
   3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0  
}

Definition at line 25 of file nls.c.

Referenced by IntMultiByteToWideCharUTF8().

UTF8Mask

const unsigned char UTF8Mask[6] = {0x7f, 0x1f, 0x0f, 0x07, 0x03, 0x01}

static

Definition at line 38 of file nls.c.

Referenced by IntMultiByteToWideCharUTF8().