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
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	CreateNlsDirectorySecurity (_Out_ PSECURITY_DESCRIPTOR *NlsSecurityDescriptor)
	Creates a security descriptor for the NLS object directory name. More...
NTSTATUS WINAPI	CreateNlsSecurityDescriptor (_Out_ PSECURITY_DESCRIPTOR *SecurityDescriptor, _In_ SIZE_T DescriptorSize, _In_ ULONG AccessMask)
	Creates a security descriptor for each NLS section name. More...
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()

NTSTATUS CreateNlsDirectorySecurity

(

_Out_ PSECURITY_DESCRIPTOR *

NlsSecurityDescriptor

)

Creates a security descriptor for the NLS object directory name.

Parameters

[out]

SecurityDescriptor

A pointer to an allocated and created security descriptor that is given to the caller.

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

Everyone (aka World SID) is given read access to the NLS directory whereas admins are given full power.

Definition at line 2294 of file nls.c.

{
    NTSTATUS Status;
    PACL Dacl;
    PSID WorldSid = NULL, AdminsSid = NULL;
    ULONG DaclSize, RelSdSize = 0;
    PSECURITY_DESCRIPTOR RelativeSd = NULL;
    SECURITY_DESCRIPTOR AbsoluteSd;
    static SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
    static SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};

    /* Create the World SID */
    Status = RtlAllocateAndInitializeSid(&WorldAuthority,
                                         1,
                                         SECURITY_WORLD_RID,
                                         0, 0, 0, 0, 0, 0, 0,
                                         &WorldSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsDirectorySecurity(): Failed to create world SID (Status 0x%08x)\n", Status);
        return Status;
    }

    /* Create the admins SID */
    Status = RtlAllocateAndInitializeSid(&NtAuthority,
                                         2,
                                         SECURITY_BUILTIN_DOMAIN_RID,
                                         DOMAIN_ALIAS_RID_ADMINS,
                                         0, 0, 0, 0, 0, 0,
                                         &AdminsSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsDirectorySecurity(): Failed to create admins SID (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Build up the size of our DACL, including the World and admins SIDs */
    DaclSize = sizeof(ACL) +
               sizeof(ACCESS_ALLOWED_ACE) + RtlLengthSid(WorldSid) +
               sizeof(ACCESS_ALLOWED_ACE) + RtlLengthSid(AdminsSid);

    /* Allocate memory for our DACL */
    Dacl = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, DaclSize);
    if (Dacl == NULL)
    {
        DPRINT1("CreateNlsDirectorySecurity(): Could not allocate memory for DACL, not enough memory!\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quit;
    }

    /* Create the DACL */
    Status = RtlCreateAcl(Dacl, DaclSize, ACL_REVISION);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsDirectorySecurity(): Failed to create the DACL (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Give everyone basic directory access */
    Status = RtlAddAccessAllowedAce(Dacl,
                                    ACL_REVISION,
                                    DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT,
                                    WorldSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsDirectorySecurity(): Failed to insert allowed access ACE to DACL for World SID (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Give admins full power */
    Status = RtlAddAccessAllowedAce(Dacl,
                                    ACL_REVISION,
                                    DIRECTORY_ALL_ACCESS,
                                    AdminsSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsDirectorySecurity(): Failed to insert allowed access ACE to DACL for admins SID (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Initialize the security descriptor */
    Status = RtlCreateSecurityDescriptor(&AbsoluteSd,
                                         SECURITY_DESCRIPTOR_REVISION);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsDirectorySecurity(): Failed to initialize the security descriptor (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Set the DACL to descriptor */
    Status = RtlSetDaclSecurityDescriptor(&AbsoluteSd,
                                          TRUE,
                                          Dacl,
                                          FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsDirectorySecurity(): Failed to insert DACL into the descriptor (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Determine how much size is needed to convert the absolute SD into self-relative one */
    Status = RtlAbsoluteToSelfRelativeSD(&AbsoluteSd,
                                         NULL,
                                         &RelSdSize);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        DPRINT1("CreateNlsDirectorySecurity(): Unexpected status code, must be STATUS_BUFFER_TOO_SMALL (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Allocate buffer for relative SD */
    RelativeSd = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, RelSdSize);
    if (RelativeSd == NULL)
    {
        DPRINT1("CreateNlsDirectorySecurity(): Could not allocate memory for relative SD, not enough memory!\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quit;
    }

    /* Convert it now */
    Status = RtlAbsoluteToSelfRelativeSD(&AbsoluteSd,
                                         RelativeSd,
                                         &RelSdSize);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsDirectorySecurity(): Failed to convert absolute SD to self-relative format (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Give the security descriptor to the caller */
    *NlsSecurityDescriptor = RelativeSd;

Quit:
    if (WorldSid != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid);
    }

    if (AdminsSid != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, AdminsSid);
    }

    if (Dacl != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
    }

    if (!NT_SUCCESS(Status))
    {
        if (RelativeSd != NULL)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
        }
    }

    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 name.

Parameters

[in]	AccessMask	An access mask bit to supply to the function. This access mask grants everyone access specific to that bit mask.
[out]	SecurityDescriptor	A pointer to an allocated and created security descriptor that is given to the caller.

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

The implementation of CreateNlsSecurityDescriptor on Windows Server 2003 is slightly different compared to ours. The second parameter takes the size of a security descriptor, in bytes. This is implied that on Windows the caller is responsible to submit the exact size of the descriptor. On ReactOS we're going to do it different, let the function be responsible for security descriptor creation and its size. DescriptorSize will act like a dummy parameter for us in this case. Everyone (aka World SID) is given read access to each NLS section name.

Definition at line 2483 of file nls.c.

{
    NTSTATUS Status;
    PACL Dacl;
    PSID WorldSid = NULL;
    ULONG DaclSize, RelSdSize = 0;
    PSECURITY_DESCRIPTOR RelativeSd = NULL;
    SECURITY_DESCRIPTOR AbsoluteSd;
    static SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};

    /* DescriptorSize is just a dummy parameter */
    UNREFERENCED_PARAMETER(DescriptorSize);

    /* Create the World SID */
    Status = RtlAllocateAndInitializeSid(&WorldAuthority,
                                         1,
                                         SECURITY_WORLD_RID,
                                         0, 0, 0, 0, 0, 0, 0,
                                         &WorldSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Failed to create world SID (Status 0x%08x)\n", Status);
        return Status;
    }

    /* Build up the size of our DACL, including the World SID */
    DaclSize = sizeof(ACL) +
               sizeof(ACCESS_ALLOWED_ACE) + RtlLengthSid(WorldSid);

    /* Allocate memory for our DACL */
    Dacl = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, DaclSize);
    if (Dacl == NULL)
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Could not allocate memory for DACL, not enough memory!\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quit;
    }

    /* Create the DACL */
    Status = RtlCreateAcl(Dacl, DaclSize, ACL_REVISION);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Failed to create the DACL (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Add a ACE with allow access to the World SID */
    Status = RtlAddAccessAllowedAce(Dacl,
                                    ACL_REVISION,
                                    AccessMask,
                                    WorldSid);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Failed to insert allowed access ACE to DACL for World SID (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Initialize the security descriptor */
    Status = RtlCreateSecurityDescriptor(&AbsoluteSd,
                                         SECURITY_DESCRIPTOR_REVISION);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Failed to insert allowed access ACE to DACL for World SID (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Set the DACL to descriptor */
    Status = RtlSetDaclSecurityDescriptor(&AbsoluteSd,
                                          TRUE,
                                          Dacl,
                                          FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Failed to insert DACL into the descriptor (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Determine how much size is needed to convert the absolute SD into self-relative one */
    Status = RtlAbsoluteToSelfRelativeSD(&AbsoluteSd,
                                         NULL,
                                         &RelSdSize);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Unexpected status code, must be STATUS_BUFFER_TOO_SMALL (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Allocate buffer for relative SD */
    RelativeSd = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, RelSdSize);
    if (RelativeSd == NULL)
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Could not allocate memory for relative SD, not enough memory!\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quit;
    }

    /* Convert it now */
    Status = RtlAbsoluteToSelfRelativeSD(&AbsoluteSd,
                                         RelativeSd,
                                         &RelSdSize);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateNlsSecurityDescriptor(): Failed to convert absolute SD to self-relative format (Status 0x%08x)\n", Status);
        goto Quit;
    }

    /* Give the security descriptor to the caller */
    *SecurityDescriptor = RelativeSd;

Quit:
    if (WorldSid != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid);
    }

    if (Dacl != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
    }

    if (!NT_SUCCESS(Status))
    {
        if (RelativeSd != NULL)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
        }
    }

    return Status;
}

Referenced by IntGetCodePageEntry().

GetACP()

UINT WINAPI GetACP

(

VOID

)

Definition at line 2218 of file nls.c.

{
    return AnsiCodePage.CodePageTable.CodePage;
}

Referenced by _setmbcp_l(), CON_API(), EngGetCurrentCodePage(), get_codeset(), GetStringTypeA(), GetSupportedCP(), Global_Chr(), Imm32InquireIme(), IPropertyStorage_fnReadMultiple(), IPropertyStorage_fnWriteMultiple(), ME_StreamOutRTFHeader(), METADC_ExtTextOut(), MFDRV_ExtTextOut(), MimeInternat_ConvertString(), MimeInternat_GetDefaultCharset(), name_to_codepage(), PropertyStorage_ConstructEmpty(), PropertyStorage_ReadFromStream(), test_bitmap_font_metrics(), test_defaultcharset(), test_EnumFontFamiliesEx_default_charset(), test_file_monikers(), test_FoldStringA(), test_GdiGetCodePage(), test_GetFullPathNameA(), test_mbcp(), test_nonexistent_font(), test_text_metrics(), and test_threadcp().

GetCPFileNameFromRegistry()

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

Definition at line 1439 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 1950 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:
                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;
    }

    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 _Locale_codecvt_create(), _Locale_ctype_create(), _setmbcp_l(), GetCPInfoExW(), GetKerningPairsA(), Global_Chr(), make_csconv(), ME_GetTextLengthEx(), MSVCRT__create_locale(), test_GetCPInfo(), and test_mbcp().

GetCPInfoExA()

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

Definition at line 2063 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;
}

Referenced by init_procs(), and test_threadcp().

GetCPInfoExW()

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

Definition at line 2004 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 AddCodePage(), FillCharacterSetComboList(), GetCPInfoExA(), GetSupportedCP(), and ME_StreamOutRTFHeader().

GetDefaultSortkeySize()

VOID WINAPI GetDefaultSortkeySize

(

LPVOID

lpUnknown

)

Definition at line 2667 of file nls.c.

{
    STUB;
    lpUnknown = NULL;
}

GetLinguistLangSize()

VOID WINAPI GetLinguistLangSize

(

LPVOID

lpUnknown

)

Definition at line 2678 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 1863 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 1394 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 2726 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 2739 of file nls.c.

{
    STUB;
    return TRUE;
}

GetOEMCP()

UINT WINAPI GetOEMCP

(

VOID

)

Definition at line 2233 of file nls.c.

{
    return OemCodePage.CodePageTable.CodePage;
}

Referenced by _setmbcp_l(), ConCfgInitDefaultSettings(), ConSrvInitConsole(), EngGetCurrentCodePage(), GetKBCodePage(), GetSupportedCP(), ME_StreamOutRTFHeader(), METADC_ExtTextOut(), MFDRV_ExtTextOut(), OnNcCreate(), SetUpConsoleInfo(), and START_TEST().

IntGetCodePageEntry()

PCODEPAGE_ENTRY FASTCALL IntGetCodePageEntry

(

UINT

CodePage

)

Definition at line 213 of file nls.c.

{
    CHAR SectionName[40];
    NTSTATUS Status;
    HANDLE SectionHandle = INVALID_HANDLE_VALUE, FileHandle;
    PBYTE SectionMapping;
    OBJECT_ATTRIBUTES ObjectAttributes;
    ANSI_STRING AnsiName;
    UNICODE_STRING UnicodeName;
    WCHAR FileName[MAX_PATH + 1];
    UINT FileNamePos;
    PCODEPAGE_ENTRY CodePageEntry;
    PSECURITY_DESCRIPTOR NlsSd;
    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(&NlsSd, sizeof(SECURITY_DESCRIPTOR), SECTION_MAP_READ);
    if (!NT_SUCCESS(Status))
    {
        RtlLeaveCriticalSection(&CodePageListLock);
        return NULL;
    }

    InitializeObjectAttributes(&ObjectAttributes, &UnicodeName, 0, NULL, NlsSd);

    /* 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);
    HeapFree(GetProcessHeap(), 0, NlsSd);

    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 177 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 1347 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 1036 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 1013 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 573 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 767 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 401 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 1070 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 822 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 884 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 2270 of file nls.c.

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

Referenced by CharNextA(), COMCTL32_ChrCmpHelperA(), IsShortName_U(), map_wparam_AtoW(), PathGetDriveNumberA(), PathIsLFNFileSpecA(), PathIsRelativeA(), PathMakePrettyA(), PathSkipRootA(), RealDefWindowProcA(), server_end_to_end_callback(), SHLWAPI_ChrCmpHelperA(), SHLWAPI_StrRChrHelperA(), SHTruncateString(), StrRChrA(), StrRChrIA(), StrRStrIA(), VkKeyScanA(), and VkKeyScanExA().

IsDBCSLeadByteEx()

BOOL WINAPI IsDBCSLeadByteEx	(	UINT	CodePage,
		BYTE	TestByte
	)

Definition at line 2248 of file nls.c.

{
    PCODEPAGE_ENTRY CodePageEntry;

    CodePageEntry = IntGetCodePageEntry(CodePage);
    if (CodePageEntry != NULL)
        return IntIsLeadByte(&CodePageEntry->CodePageTable, TestByte);

    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
}

Referenced by CharNextExA(), dbcs_mblen(), Global_Chr(), IchWideFromAnsi(), Imm32CompAttrAnsiToWide(), METADC_ExtTextOut(), MFDRV_ExtTextOut(), START_TEST(), test_bitmap_font_glyph_index(), test_text_metrics(), and test_threadcp().

IsNLSDefinedString()

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

Definition at line 2711 of file nls.c.

{
    STUB;
    return TRUE;
}

IsValidCodePage()

BOOL WINAPI IsValidCodePage

(

UINT

CodePage

)

Definition at line 1515 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);
}

Referenced by AddCodePage(), ChangeOutputCP_(), ConCfgReadUserSettings(), ConDrvInitConsole(), ConDrvSetConsoleCP(), ConSrvApplyUserSettings(), fnIMultiLanguage3_ValidateCodePageEx(), make_csconv(), match_name_table_language(), MSVCRT_locale_to_LCID(), test_CP_ThreadLang(), test_EnumCodePages(), test_IsCodePageInstallable(), test_string_conversion(), test_undefined_byte_char(), testScreenBuffer(), and validate_codepage().

IsValidUILanguage()

BOOL WINAPI IsValidUILanguage

(

LANGID

langid

)

Definition at line 2617 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 1674 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 2626 of file nls.c.

{
    STUB;
}

NlsGetCacheUpdateCount()

ULONG WINAPI NlsGetCacheUpdateCount

(

VOID

)

Definition at line 2700 of file nls.c.

{
    STUB;
    return 0;
}

NlsInit()

BOOL FASTCALL NlsInit

(

VOID

)

Definition at line 75 of file nls.c.

{
    UNICODE_STRING DirName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PSECURITY_DESCRIPTOR NlsDirSd;
    HANDLE Handle;
    NTSTATUS Status;

    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 NLS directory */
    Status = CreateNlsDirectorySecurity(&NlsDirSd);
    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,
                               NlsDirSd);

    if (NT_SUCCESS(NtCreateDirectoryObject(&Handle, DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT, &ObjectAttributes)))
    {
        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);

    RtlFreeHeap(RtlGetProcessHeap(), 0, NlsDirSd);
    return TRUE;
}

Referenced by DllMain().

NlsResetProcessLocale()

BOOL WINAPI NlsResetProcessLocale

(

VOID

)

Definition at line 2656 of file nls.c.

{
    STUB;
    return TRUE;
}

NlsUninit()

VOID FASTCALL NlsUninit

(

VOID

)

Definition at line 143 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 2634 of file nls.c.

{
    STUB;
    return 0;
}

utf7_can_directly_encode()

static BOOL utf7_can_directly_encode ( WCHAR  codepoint )

inlinestatic

Definition at line 1731 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 1748 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 1525 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 1540 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 2645 of file nls.c.

{
    STUB;
    return FALSE;
}

ValidateLocale()

BOOL WINAPI ValidateLocale

(

IN ULONG

LocaleId

)

Definition at line 2689 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 2127 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);
   }
}

Referenced by GetCPInfoExA().

WideCharToUtf7()

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

static

Definition at line 1763 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().