able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/win32/winnls/ansi.c

2597 lines
73 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991-2000, Microsoft Corporation All rights reserved.
Module Name:
ansi.c
Abstract:
This file contains the ANSI versions of the NLS API functions.
APIs found in this file:
CompareStringA
LCMapStringA
GetLocaleInfoA
SetLocaleInfoA
GetCalendarInfoA
SetCalendarInfoA
GetTimeFormatA
GetDateFormatA
GetNumberFormatA
GetCurrencyFormatA
EnumCalendarInfoA
EnumCalendarInfoExA
EnumTimeFormatsA
EnumDateFormatsA
EnumDateFormatsExA
GetStringTypeExA
GetStringTypeA
FoldStringA
EnumSystemLanguageGroupsA
EnumLanguageGroupLocalesA
EnumUILanguagesA
EnumSystemLocalesA
EnumSystemCodePagesA
GetCPInfoExA
GetGeoInfoA
Revision History:
11-10-93 JulieB Created.
07-03-00 lguindon Began GEO API port
--*/
//
// Include Files.
//
#include "nls.h"
//
// Forward Declarations.
//
PCP_HASH
NlsGetACPFromLocale(
LCID Locale,
DWORD dwFlags);
BOOL
NlsAnsiToUnicode(
PCP_HASH pHashN,
DWORD dwFlags,
LPCSTR pAnsiBuffer,
int AnsiLength,
LPWSTR *ppUnicodeBuffer,
int *pUnicodeLength);
int
NlsUnicodeToAnsi(
PCP_HASH pHashN,
LPCWSTR pUnicodeBuffer,
int UnicodeLength,
LPSTR pAnsiBuffer,
int AnsiLength);
BOOL
NlsEnumUnicodeToAnsi(
PCP_HASH pHashN,
LPCWSTR pUnicodeBuffer,
LPSTR *ppAnsiBuffer);
//-------------------------------------------------------------------------//
// API ROUTINES //
//-------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////
//
// CompareStringA
//
// Compares two wide character strings of the same locale according to the
// supplied locale handle.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI CompareStringA(
LCID Locale,
DWORD dwCmpFlags,
LPCSTR lpString1,
int cchCount1,
LPCSTR lpString2,
int cchCount2)
{
PCP_HASH pHashN; // ptr to CP hash node
WCHAR pSTmp1[MAX_STRING_LEN]; // tmp Unicode buffer (string 1)
WCHAR pSTmp2[MAX_STRING_LEN]; // tmp Unicode buffer (string 2)
LPWSTR pUnicode1; // ptr to unicode string 1
LPWSTR pUnicode2; // ptr to unicode string 2
int UnicodeLength1; // length of Unicode string 1
int UnicodeLength2; // length of Unicode string 2
int ResultLen; // result length
BOOL fUseNegCounts = (cchCount1 < 0 && cchCount2 < 0); // flag to use negative counts
//
// Invalid Parameter Check:
// - Get the code page hash node for the given locale.
// - either string is null
//
pHashN = NlsGetACPFromLocale(Locale, dwCmpFlags);
if ((pHashN == NULL) ||
(lpString1 == NULL) || (lpString2 == NULL))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Invalid Flags Check:
// - invalid flags
//
if (dwCmpFlags & CS_INVALID_FLAG)
{
SetLastError(ERROR_INVALID_FLAGS);
return (0);
}
//
// Convert Ansi string 1 to Unicode.
//
pUnicode1 = pSTmp1;
if (!NlsAnsiToUnicode( pHashN,
0,
lpString1,
cchCount1,
&pUnicode1,
&UnicodeLength1 ))
{
return (0);
}
//
// Convert Ansi string 2 to Unicode.
//
pUnicode2 = pSTmp2;
if (!NlsAnsiToUnicode( pHashN,
0,
lpString2,
cchCount2,
&pUnicode2,
&UnicodeLength2 ))
{
NLS_FREE_TMP_BUFFER(pUnicode1, pSTmp1);
return (0);
}
//
// Call the W version of the API.
//
ResultLen = CompareStringW( Locale,
dwCmpFlags,
pUnicode1,
(fUseNegCounts) ? -1 : UnicodeLength1,
pUnicode2,
(fUseNegCounts) ? -1 : UnicodeLength2 );
//
// Free the allocated source buffers (if they were allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode1, pSTmp1);
NLS_FREE_TMP_BUFFER(pUnicode2, pSTmp2);
//
// Return the result of the call to CompareStringW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// LCMapStringA
//
// Maps one wide character string to another performing the specified
// translation. This mapping routine only takes flags that are locale
// dependent.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI LCMapStringA(
LCID Locale,
DWORD dwMapFlags,
LPCSTR lpSrcStr,
int cchSrc,
LPSTR lpDestStr,
int cchDest)
{
PCP_HASH pHashN; // ptr to CP hash node
LPWSTR pUnicode; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
WCHAR pDTmp[MAX_STRING_LEN]; // tmp Unicode buffer (destination)
LPWSTR pBuf; // ptr to destination buffer
int ResultLen; // result length
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, dwMapFlags);
//
// Invalid Parameter Check:
// - valid code page
// - destination buffer size is negative
// - length of dest string is NOT zero AND dest string is NULL
// - same buffer - src = destination
// if not UPPER or LOWER or
// UPPER or LOWER used with Japanese flags
//
if ((pHashN == NULL) ||
(cchDest < 0) ||
((cchDest != 0) && (lpDestStr == NULL)) ||
((lpSrcStr == lpDestStr) &&
((!(dwMapFlags & (LCMAP_UPPERCASE | LCMAP_LOWERCASE))) ||
(dwMapFlags & (LCMAP_HIRAGANA | LCMAP_KATAKANA |
LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)))))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Convert Ansi string to Unicode.
//
pUnicode = pSTmp;
if (!NlsAnsiToUnicode( pHashN,
0,
lpSrcStr,
cchSrc,
&pUnicode,
&UnicodeLength ))
{
return (0);
}
//
// Special case the sortkey flag, since the Unicode buffer does
// NOT need to be converted back to Ansi.
//
if (dwMapFlags & LCMAP_SORTKEY)
{
//
// Call the W version of the API.
//
ResultLen = LCMapStringW( Locale,
dwMapFlags,
pUnicode,
UnicodeLength,
(LPWSTR)lpDestStr,
cchDest );
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
//
// Return the result of LCMapStringW.
//
return (ResultLen);
}
//
// Call the W version of the API.
//
pBuf = pDTmp;
ResultLen = MAX_STRING_LEN;
while (1)
{
ResultLen = LCMapStringW( Locale,
dwMapFlags,
pUnicode,
UnicodeLength,
pBuf,
ResultLen );
//
// Make sure the static buffer was large enough.
//
if ((ResultLen != 0) || (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
{
break;
}
//
// Get the size of the buffer needed for the mapping.
//
if (ResultLen = LCMapStringW( Locale,
dwMapFlags,
pUnicode,
UnicodeLength,
NULL,
0 ))
{
//
// Allocate a buffer of the appropriate size.
//
if ((pBuf = (LPWSTR)NLS_ALLOC_MEM(ResultLen * sizeof(WCHAR))) == NULL)
{
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
SetLastError(ERROR_OUTOFMEMORY);
return (0);
}
}
}
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
//
// Convert the destination Unicode buffer to the given Ansi buffer.
//
if (ResultLen > 0)
{
ResultLen = NlsUnicodeToAnsi( pHashN,
pBuf,
ResultLen,
lpDestStr,
cchDest );
}
//
// Free the allocated destination buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
//
// Return the result of the call to LCMapStringW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// GetLocaleInfoA
//
// Returns one of the various pieces of information about a particular
// locale by querying the configuration registry. This call also indicates
// how much memory is necessary to contain the desired information.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI GetLocaleInfoA(
LCID Locale,
LCTYPE LCType,
LPSTR lpLCData,
int cchData)
{
PCP_HASH pHashN; // ptr to CP hash node
WCHAR pDTmp[MAX_STRING_LEN]; // tmp Unicode buffer (destination)
LPWSTR pBuf; // ptr to destination buffer
int ResultLen; // result length
//
// Invalid Parameter Check:
// - count is negative
// - NULL data pointer AND count is not zero
//
if ((cchData < 0) ||
(lpLCData == NULL) && (cchData != 0))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Call the W version of the API.
//
pBuf = pDTmp;
ResultLen = MAX_STRING_LEN;
while (1)
{
ResultLen = GetLocaleInfoW( Locale,
LCType,
pBuf,
ResultLen );
//
// Make sure the static buffer was large enough.
//
if ((ResultLen != 0) || (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
{
break;
}
//
// Get the size of the buffer needed for the mapping.
//
if (ResultLen = GetLocaleInfoW( Locale,
LCType,
NULL,
0 ))
{
//
// Allocate a buffer of the appropriate size.
//
if ((pBuf = (LPWSTR)NLS_ALLOC_MEM(ResultLen * sizeof(WCHAR))) == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return (0);
}
}
}
//
// Convert the destination Unicode buffer to the given Ansi buffer.
//
if (ResultLen > 0)
{
if ((LCType & LOCALE_RETURN_NUMBER) ||
(NLS_GET_LCTYPE_VALUE(LCType) == LOCALE_FONTSIGNATURE))
{
//
// For the font signature and number value, the result length
// will actually be twice the amount of the wide char version.
//
ResultLen *= 2;
//
// Make sure we can use the buffer.
//
if (cchData)
{
//
// Make sure the buffer is large enough.
//
if (cchData < ResultLen)
{
//
// The buffer is too small.
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
SetLastError(ERROR_INSUFFICIENT_BUFFER);
return (0);
}
//
// Convert the font signature or number value to its byte
// form. Since it's already byte reversed, just do a move
// memory.
//
RtlMoveMemory(lpLCData, pBuf, ResultLen);
}
}
else
{
//
// If this is LCTYPE == LOCALE_SLANGUAGE, then use the
// CP_ACP of the system. This is what Win9x has done,
// and we need to be compatible with this.
//
if (NLS_GET_LCTYPE_VALUE(LCType) == LOCALE_SLANGUAGE)
{
LCType |= LOCALE_USE_CP_ACP;
}
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, LCType);
if (pHashN == NULL)
{
ResultLen = 0;
}
else
{
//
// Convert to Ansi.
//
ResultLen = NlsUnicodeToAnsi( pHashN,
pBuf,
ResultLen,
lpLCData,
cchData );
}
}
}
//
// Free the allocated destination buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
//
// Return the result of the call to GetLocaleInfoW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// SetLocaleInfoA
//
// Sets one of the various pieces of information about a particular
// locale by making an entry in the user's portion of the configuration
// registry. This will only affect the user override portion of the locale
// settings. The system defaults will never be reset.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI SetLocaleInfoA(
LCID Locale,
LCTYPE LCType,
LPCSTR lpLCData)
{
PCP_HASH pHashN; // ptr to CP hash node
LPWSTR pUnicode; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
BOOL Result; // result
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, LCType);
if (pHashN == NULL)
{
return (0);
}
//
// Convert Ansi string to Unicode.
//
pUnicode = pSTmp;
if (!NlsAnsiToUnicode( pHashN,
0,
lpLCData,
-1,
&pUnicode,
&UnicodeLength ))
{
return (FALSE);
}
//
// Call the W version of the API.
//
Result = SetLocaleInfoW( Locale,
LCType,
pUnicode );
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
//
// Return the result of the call to SetLocaleInfoW.
//
return (Result);
}
////////////////////////////////////////////////////////////////////////////
//
// GetCalendarInfoA
//
// Returns one of the various pieces of information about a particular
// calendar by querying the configuration registry. This call also indicates
// how much memory is necessary to contain the desired information.
//
// 12-17-97 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI GetCalendarInfoA(
LCID Locale,
CALID Calendar,
CALTYPE CalType,
LPSTR lpCalData,
int cchData,
LPDWORD lpValue)
{
PCP_HASH pHashN; // ptr to CP hash node
WCHAR pDTmp[MAX_STRING_LEN]; // tmp Unicode buffer (destination)
LPWSTR pBuf; // ptr to destination buffer
int ResultLen; // result length
//
// Invalid Parameter Check:
// - count is negative
// - NULL data pointer AND count is not zero
//
if ((cchData < 0) ||
((lpCalData == NULL) && (cchData != 0)))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Need to check the parameters based on the CAL_RETURN_NUMBER
// CalType.
//
if (CalType & CAL_RETURN_NUMBER)
{
if ((lpCalData != NULL) || (cchData != 0) || (lpValue == NULL))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
}
else
{
if ((lpValue != NULL) ||
(cchData < 0) ||
((lpCalData == NULL) && (cchData != 0)))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
}
//
// Call the W version of the API.
//
pBuf = pDTmp;
ResultLen = MAX_STRING_LEN;
while (1)
{
ResultLen = GetCalendarInfoW( Locale,
Calendar,
CalType,
lpCalData ? pBuf : NULL,
lpCalData ? ResultLen : 0,
lpValue );
//
// Make sure the static buffer was large enough.
//
if ((ResultLen != 0) ||
(lpValue != NULL) ||
(GetLastError() != ERROR_INSUFFICIENT_BUFFER))
{
break;
}
//
// Get the size of the buffer needed for the mapping.
//
if (ResultLen = GetCalendarInfoW( Locale,
Calendar,
CalType,
NULL,
0,
NULL ))
{
//
// Allocate a buffer of the appropriate size.
//
if ((pBuf = (LPWSTR)NLS_ALLOC_MEM(ResultLen * sizeof(WCHAR))) == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return (0);
}
}
}
//
// Convert the destination Unicode buffer to the given Ansi buffer.
//
if (ResultLen > 0)
{
if (CalType & CAL_RETURN_NUMBER)
{
//
// For the number value, the result length will actually be
// twice the amount of the wide char version.
//
ResultLen *= 2;
//
// There is nothing else to do in this case, since the value
// has already been stored in lpValue.
//
}
else
{
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, CalType);
if (pHashN == NULL)
{
ResultLen = 0;
}
else
{
//
// Convert to Ansi.
//
ResultLen = NlsUnicodeToAnsi( pHashN,
pBuf,
ResultLen,
lpCalData,
cchData );
}
}
}
//
// Free the allocated destination buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
//
// Return the result of the call to GetCalendarInfoW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// SetCalendarInfoA
//
// Sets one of the various pieces of information about a particular
// calendar by making an entry in the user's portion of the configuration
// registry. This will only affect the user override portion of the
// calendar settings. The system defaults will never be reset.
//
// 12-17-97 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI SetCalendarInfoA(
LCID Locale,
CALID Calendar,
CALTYPE CalType,
LPCSTR lpCalData)
{
PCP_HASH pHashN; // ptr to CP hash node
LPWSTR pUnicode; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
BOOL Result; // result
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, CalType);
if (pHashN == NULL)
{
return (0);
}
//
// Convert Ansi string to Unicode.
//
pUnicode = pSTmp;
if (!NlsAnsiToUnicode( pHashN,
0,
lpCalData,
-1,
&pUnicode,
&UnicodeLength ))
{
return (FALSE);
}
//
// Call the W version of the API.
//
Result = SetCalendarInfoW( Locale,
Calendar,
CalType,
pUnicode );
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
//
// Return the result of the call to SetCalendarInfoW.
//
return (Result);
}
////////////////////////////////////////////////////////////////////////////
//
// GetTimeFormatA
//
// Returns a properly formatted time string for the given locale. It uses
// either the system time or the specified time. This call also indicates
// how much memory is necessary to contain the desired information.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI GetTimeFormatA(
LCID Locale,
DWORD dwFlags,
CONST SYSTEMTIME *lpTime,
LPCSTR lpFormat,
LPSTR lpTimeStr,
int cchTime)
{
PCP_HASH pHashN; // ptr to CP hash node
LPWSTR pUnicode; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
WCHAR pDTmp[MAX_STRING_LEN]; // tmp Unicode buffer (destination)
LPWSTR pBuf; // ptr to destination buffer
int ResultLen; // result length
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, dwFlags);
//
// Invalid Parameter Check:
// - valid code page
// - count is negative
// - NULL data pointer AND count is not zero
//
if ((pHashN == NULL) ||
(cchTime < 0) ||
((lpTimeStr == NULL) && (cchTime != 0)))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Convert Ansi string to Unicode.
//
pUnicode = pSTmp;
if (!NlsAnsiToUnicode( pHashN,
0,
lpFormat,
-1,
&pUnicode,
&UnicodeLength ))
{
return (0);
}
//
// Call the W version of the API.
//
pBuf = pDTmp;
ResultLen = MAX_STRING_LEN;
while (1)
{
ResultLen = GetTimeFormatW( Locale,
dwFlags,
lpTime,
pUnicode,
pBuf,
ResultLen );
//
// Make sure the static buffer was large enough.
//
if ((ResultLen != 0) || (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
{
break;
}
//
// Get the size of the buffer needed for the mapping.
//
if (ResultLen = GetTimeFormatW( Locale,
dwFlags,
lpTime,
pUnicode,
NULL,
0 ))
{
//
// Allocate a buffer of the appropriate size.
//
if ((pBuf = (LPWSTR)NLS_ALLOC_MEM(ResultLen * sizeof(WCHAR))) == NULL)
{
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
SetLastError(ERROR_OUTOFMEMORY);
return (0);
}
}
}
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
//
// Convert the destination Unicode buffer to the given Ansi buffer.
//
if (ResultLen > 0)
{
ResultLen = NlsUnicodeToAnsi( pHashN,
pBuf,
ResultLen,
lpTimeStr,
cchTime );
}
//
// Free the allocated destination buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
//
// Return the result of the call to GetTimeFormatW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// GetDateFormatA
//
// Returns a properly formatted date string for the given locale. It uses
// either the system date or the specified date. The user may specify
// the short date format, the long date format, or the year/month format.
// This call also indicates how much memory is necessary to contain the
// desired information.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI GetDateFormatA(
LCID Locale,
DWORD dwFlags,
CONST SYSTEMTIME *lpDate,
LPCSTR lpFormat,
LPSTR lpDateStr,
int cchDate)
{
PCP_HASH pHashN; // ptr to CP hash node
LPWSTR pUnicode; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
WCHAR pDTmp[MAX_STRING_LEN]; // tmp Unicode buffer (destination)
LPWSTR pBuf; // ptr to destination buffer
int ResultLen; // result length
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, dwFlags);
//
// Invalid Parameter Check:
// - valid code page
// - count is negative
// - NULL data pointer AND count is not zero
//
if ((pHashN == NULL) ||
(cchDate < 0) ||
((lpDateStr == NULL) && (cchDate != 0)))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Invalid Flags Check:
// - flags other than valid ones
// - more than one of either ltr reading or rtl reading
// - using LTR or RTL flag and not using cp 1255 or 1256
//
if ((dwFlags & GDF_INVALID_FLAG) ||
(MORE_THAN_ONE(dwFlags, GDF_SINGLE_FLAG)) ||
((dwFlags & (DATE_LTRREADING | DATE_RTLREADING)) &&
(pHashN->CodePage != 1255) && (pHashN->CodePage != 1256)))
{
SetLastError(ERROR_INVALID_FLAGS);
return (0);
}
//
// Convert Ansi string to Unicode.
//
pUnicode = pSTmp;
if (!NlsAnsiToUnicode( pHashN,
0,
lpFormat,
-1,
&pUnicode,
&UnicodeLength ))
{
return (0);
}
//
// Call the W version of the API.
//
pBuf = pDTmp;
ResultLen = MAX_STRING_LEN;
while (1)
{
ResultLen = GetDateFormatW( Locale,
dwFlags,
lpDate,
pUnicode,
pBuf,
ResultLen );
//
// Make sure the static buffer was large enough.
//
if ((ResultLen != 0) || (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
{
break;
}
//
// Get the size of the buffer needed for the mapping.
//
if (ResultLen = GetDateFormatW( Locale,
dwFlags,
lpDate,
pUnicode,
NULL,
0 ))
{
//
// Allocate a buffer of the appropriate size.
//
if ((pBuf = (LPWSTR)NLS_ALLOC_MEM(ResultLen * sizeof(WCHAR))) == NULL)
{
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
SetLastError(ERROR_OUTOFMEMORY);
return (0);
}
}
}
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
//
// Convert the destination Unicode buffer to the given Ansi buffer.
//
if (ResultLen > 0)
{
ResultLen = NlsUnicodeToAnsi( pHashN,
pBuf,
ResultLen,
lpDateStr,
cchDate );
}
//
// Free the allocated destination buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
//
// Return the result of the call to GetDateFormatW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// GetNumberFormatA
//
// Returns a properly formatted number string for the given locale.
// This call also indicates how much memory is necessary to contain
// the desired information.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI GetNumberFormatA(
LCID Locale,
DWORD dwFlags,
LPCSTR lpValue,
CONST NUMBERFMTA *lpFormat,
LPSTR lpNumberStr,
int cchNumber)
{
PCP_HASH pHashN; // ptr to CP hash node
LPWSTR pValueU; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
WCHAR pDTmp[MAX_STRING_LEN]; // tmp Unicode buffer (destination)
LPWSTR pBuf; // ptr to destination buffer
int ResultLen; // result length
NUMBERFMTW FormatU; // Unicode number format
LPNUMBERFMTW pFormatU = NULL; // ptr to Unicode number format
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, dwFlags);
//
// Invalid Parameter Check:
// - valid code page
// - count is negative
// - NULL data pointer AND count is not zero
// - ptrs to string buffers same
//
if ((pHashN == NULL) ||
(cchNumber < 0) ||
((lpNumberStr == NULL) && (cchNumber != 0)) ||
(lpValue == lpNumberStr))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Convert Ansi string to Unicode.
//
pValueU = pSTmp;
if (!NlsAnsiToUnicode( pHashN,
0,
lpValue,
-1,
&pValueU,
&UnicodeLength ))
{
return (0);
}
//
// If the format structure exists, convert the strings
// in the structure.
//
if (lpFormat)
{
//
// Copy Ansi structure to Unicode structure.
//
FormatU = *(NUMBERFMTW *)lpFormat;
FormatU.lpDecimalSep = NULL;
FormatU.lpThousandSep = NULL;
//
// Convert Ansi strings in structure to Unicode strings.
//
if (!NlsAnsiToUnicode( pHashN,
0,
lpFormat->lpDecimalSep,
-1,
&(FormatU.lpDecimalSep),
&UnicodeLength ) ||
!NlsAnsiToUnicode( pHashN,
0,
lpFormat->lpThousandSep,
-1,
&(FormatU.lpThousandSep),
&UnicodeLength ))
{
NLS_FREE_TMP_BUFFER(pValueU, pSTmp);
NLS_FREE_MEM(FormatU.lpDecimalSep);
return (0);
}
pFormatU = &FormatU;
}
//
// Call the W version of the API.
//
pBuf = pDTmp;
ResultLen = MAX_STRING_LEN;
while (1)
{
ResultLen = GetNumberFormatW( Locale,
dwFlags,
pValueU,
pFormatU,
pBuf,
ResultLen );
//
// Make sure the static buffer was large enough.
//
if ((ResultLen != 0) || (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
{
break;
}
//
// Get the size of the buffer needed for the mapping.
//
if (ResultLen = GetNumberFormatW( Locale,
dwFlags,
pValueU,
pFormatU,
NULL,
0 ))
{
//
// Allocate a buffer of the appropriate size.
//
if ((pBuf = (LPWSTR)NLS_ALLOC_MEM(ResultLen * sizeof(WCHAR))) == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
ResultLen = 0;
break;
}
}
}
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pValueU, pSTmp);
if (lpFormat)
{
NLS_FREE_MEM(FormatU.lpDecimalSep);
NLS_FREE_MEM(FormatU.lpThousandSep);
}
//
// Convert the destination Unicode buffer to the given Ansi buffer.
//
if (ResultLen > 0)
{
ResultLen = NlsUnicodeToAnsi( pHashN,
pBuf,
ResultLen,
lpNumberStr,
cchNumber );
}
//
// Free the allocated destination buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
//
// Return the result of the call to GetNumberFormatW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// GetCurrencyFormatA
//
// Returns a properly formatted currency string for the given locale.
// This call also indicates how much memory is necessary to contain
// the desired information.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI GetCurrencyFormatA(
LCID Locale,
DWORD dwFlags,
LPCSTR lpValue,
CONST CURRENCYFMTA *lpFormat,
LPSTR lpCurrencyStr,
int cchCurrency)
{
PCP_HASH pHashN; // ptr to CP hash node
LPWSTR pValueU; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
WCHAR pDTmp[MAX_STRING_LEN]; // tmp Unicode buffer (destination)
LPWSTR pBuf; // ptr to destination buffer
int ResultLen; // result length
CURRENCYFMTW FormatU; // Unicode currency format
LPCURRENCYFMTW pFormatU = NULL; // ptr to Unicode currency format
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, dwFlags);
//
// Invalid Parameter Check:
// - count is negative
// - NULL data pointer AND count is not zero
// - ptrs to string buffers same
//
if ((pHashN == NULL) ||
(cchCurrency < 0) ||
((lpCurrencyStr == NULL) && (cchCurrency != 0)) ||
(lpValue == lpCurrencyStr))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Convert Ansi string to Unicode.
//
pValueU = pSTmp;
if (!NlsAnsiToUnicode( pHashN,
0,
lpValue,
-1,
&pValueU,
&UnicodeLength ))
{
return (0);
}
//
// If the format structure exists, convert the strings
// in the structure.
//
if (lpFormat)
{
//
// Copy Ansi structure to Unicode structure.
//
FormatU = *(CURRENCYFMTW *)lpFormat;
FormatU.lpDecimalSep = NULL;
FormatU.lpThousandSep = NULL;
FormatU.lpCurrencySymbol = NULL;
//
// Convert Ansi strings in structure to Unicode strings.
//
if (!NlsAnsiToUnicode( pHashN,
0,
lpFormat->lpDecimalSep,
-1,
&(FormatU.lpDecimalSep),
&UnicodeLength ) ||
!NlsAnsiToUnicode( pHashN,
0,
lpFormat->lpThousandSep,
-1,
&(FormatU.lpThousandSep),
&UnicodeLength ) ||
!NlsAnsiToUnicode( pHashN,
0,
lpFormat->lpCurrencySymbol,
-1,
&(FormatU.lpCurrencySymbol),
&UnicodeLength ))
{
NLS_FREE_TMP_BUFFER(pValueU, pSTmp);
NLS_FREE_MEM(FormatU.lpDecimalSep);
NLS_FREE_MEM(FormatU.lpThousandSep);
return (0);
}
pFormatU = &FormatU;
}
//
// Call the W version of the API.
//
pBuf = pDTmp;
ResultLen = MAX_STRING_LEN;
while (1)
{
ResultLen = GetCurrencyFormatW( Locale,
dwFlags,
pValueU,
pFormatU,
pBuf,
ResultLen );
//
// Make sure the static buffer was large enough.
//
if ((ResultLen != 0) || (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
{
break;
}
//
// Get the size of the buffer needed for the mapping.
//
if (ResultLen = GetCurrencyFormatW( Locale,
dwFlags,
pValueU,
pFormatU,
NULL,
0 ))
{
//
// Allocate a buffer of the appropriate size.
//
if ((pBuf = (LPWSTR)NLS_ALLOC_MEM(ResultLen * sizeof(WCHAR))) == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
ResultLen = 0;
break;
}
}
}
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pValueU, pSTmp);
if (lpFormat)
{
NLS_FREE_MEM(FormatU.lpDecimalSep);
NLS_FREE_MEM(FormatU.lpThousandSep);
NLS_FREE_MEM(FormatU.lpCurrencySymbol);
}
//
// Convert the destination Unicode buffer to the given Ansi buffer.
//
if (ResultLen > 0)
{
ResultLen = NlsUnicodeToAnsi( pHashN,
pBuf,
ResultLen,
lpCurrencyStr,
cchCurrency );
}
//
// Free the allocated destination buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
//
// Return the result of the call to GetCurrencyFormatW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// EnumCalendarInfoA
//
// Enumerates the specified calendar information that is available for the
// specified locale, based on the CalType parameter. It does so by
// passing the pointer to the string buffer containing the calendar info
// to an application-defined callback function. It continues until the
// last calendar info is found or the callback function returns FALSE.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumCalendarInfoA(
CALINFO_ENUMPROCA lpCalInfoEnumProc,
LCID Locale,
CALID Calendar,
CALTYPE CalType)
{
return (Internal_EnumCalendarInfo( (NLS_ENUMPROC)lpCalInfoEnumProc,
Locale,
Calendar,
CalType,
FALSE,
FALSE ));
}
////////////////////////////////////////////////////////////////////////////
//
// EnumCalendarInfoExA
//
// Enumerates the specified calendar information that is available for the
// specified locale, based on the CalType parameter. It does so by
// passing the pointer to the string buffer containing the calendar info
// and the calendar id to an application-defined callback function. It
// continues until the last calendar info is found or the callback function
// returns FALSE.
//
// 10-14-96 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumCalendarInfoExA(
CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx,
LCID Locale,
CALID Calendar,
CALTYPE CalType)
{
return (Internal_EnumCalendarInfo( (NLS_ENUMPROC)lpCalInfoEnumProcEx,
Locale,
Calendar,
CalType,
FALSE,
TRUE ));
}
////////////////////////////////////////////////////////////////////////////
//
// EnumTimeFormatsA
//
// Enumerates the time formats that are available for the
// specified locale, based on the dwFlags parameter. It does so by
// passing the pointer to the string buffer containing the time format
// to an application-defined callback function. It continues until the
// last time format is found or the callback function returns FALSE.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumTimeFormatsA(
TIMEFMT_ENUMPROCA lpTimeFmtEnumProc,
LCID Locale,
DWORD dwFlags)
{
return (Internal_EnumTimeFormats( (NLS_ENUMPROC)lpTimeFmtEnumProc,
Locale,
dwFlags,
FALSE ));
}
////////////////////////////////////////////////////////////////////////////
//
// EnumDateFormatsA
//
// Enumerates the short date, long date, or year/month formats that are
// available for the specified locale, based on the dwFlags parameter.
// It does so by passing the pointer to the string buffer containing the
// date format to an application-defined callback function. It continues
// until the last date format is found or the callback function returns
// FALSE.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumDateFormatsA(
DATEFMT_ENUMPROCA lpDateFmtEnumProc,
LCID Locale,
DWORD dwFlags)
{
return (Internal_EnumDateFormats( (NLS_ENUMPROC)lpDateFmtEnumProc,
Locale,
dwFlags,
FALSE,
FALSE ));
}
////////////////////////////////////////////////////////////////////////////
//
// EnumDateFormatsExA
//
// Enumerates the short date, long date, or year/month formats that are
// available for the specified locale, based on the dwFlags parameter.
// It does so by passing the pointer to the string buffer containing the
// date format and the calendar id to an application-defined callback
// function. It continues until the last date format is found or the
// callback function returns FALSE.
//
// 10-14-96 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumDateFormatsExA(
DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx,
LCID Locale,
DWORD dwFlags)
{
return (Internal_EnumDateFormats( (NLS_ENUMPROC)lpDateFmtEnumProcEx,
Locale,
dwFlags,
FALSE,
TRUE ));
}
////////////////////////////////////////////////////////////////////////////
//
// GetStringTypeExA
//
// Returns character type information about a particular Ansi string.
//
// 01-18-94 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI GetStringTypeExA(
LCID Locale,
DWORD dwInfoType,
LPCSTR lpSrcStr,
int cchSrc,
LPWORD lpCharType)
{
return (GetStringTypeA( Locale,
dwInfoType,
lpSrcStr,
cchSrc,
lpCharType));
}
////////////////////////////////////////////////////////////////////////////
//
// GetStringTypeA
//
// Returns character type information about a particular Ansi string.
//
// NOTE: The number of parameters is different from GetStringTypeW.
// The 16-bit OLE product shipped this routine with the wrong
// parameters (ported from Chicago) and now we must support it.
//
// Use GetStringTypeEx to get the same set of parameters between
// the A and W version.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI GetStringTypeA(
LCID Locale,
DWORD dwInfoType,
LPCSTR lpSrcStr,
int cchSrc,
LPWORD lpCharType)
{
PCP_HASH pHashCP; // ptr to CP hash node
LPWSTR pUnicode; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
BOOL Result; // result
//
// Get the code page hash node for the given locale.
// This will also return an error if the locale id is invalid,
// so there is no need to check the locale id separately.
//
pHashCP = NlsGetACPFromLocale(Locale, 0);
//
// Invalid Parameter Check:
// - Validate LCID
// - valid code page
// - same buffer - src and destination
//
if ((pHashCP == NULL) ||
(lpSrcStr == (LPSTR)lpCharType))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Convert Ansi string to Unicode.
//
pUnicode = pSTmp;
if (!NlsAnsiToUnicode( pHashCP,
MB_INVALID_CHAR_CHECK,
lpSrcStr,
cchSrc,
&pUnicode,
&UnicodeLength ))
{
return (0);
}
//
// Call the W version of the API.
//
Result = GetStringTypeW( dwInfoType,
pUnicode,
UnicodeLength,
lpCharType );
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
//
// Return the result of the call to GetStringTypeW.
//
return (Result);
}
////////////////////////////////////////////////////////////////////////////
//
// FoldStringA
//
// Maps one wide character string to another performing the specified
// translation. This mapping routine only takes flags that are locale
// independent.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI FoldStringA(
DWORD dwMapFlags,
LPCSTR lpSrcStr,
int cchSrc,
LPSTR lpDestStr,
int cchDest)
{
LPWSTR pUnicode; // ptr to unicode string
int UnicodeLength; // length of Unicode string
WCHAR pSTmp[MAX_STRING_LEN]; // tmp Unicode buffer (source)
WCHAR pDTmp[MAX_STRING_LEN]; // tmp Unicode buffer (destination)
LPWSTR pBuf; // ptr to destination buffer
int ResultLen; // result length
//
// Invalid Parameter Check:
// - dest buffer size is negative
// - length of dest string is NOT zero AND dest string is NULL
// - same buffer - src = destination
//
if ((cchDest < 0) ||
((cchDest != 0) && (lpDestStr == NULL)) ||
(lpSrcStr == lpDestStr))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (0);
}
//
// Convert Ansi string to Unicode.
//
RtlZeroMemory(pSTmp, sizeof(pSTmp));
pUnicode = pSTmp;
if (!NlsAnsiToUnicode( gpACPHashN,
0,
lpSrcStr,
cchSrc,
&pUnicode,
&UnicodeLength ))
{
return (0);
}
//
// Call the W version of the API.
//
pBuf = pDTmp;
ResultLen = MAX_STRING_LEN;
while (1)
{
ResultLen = FoldStringW( dwMapFlags,
pUnicode,
UnicodeLength,
pBuf,
ResultLen );
//
// Make sure the static buffer was large enough.
//
if ((ResultLen != 0) || (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
{
break;
}
//
// Get the size of the buffer needed for the mapping.
//
if (ResultLen = FoldStringW( dwMapFlags,
pUnicode,
UnicodeLength,
NULL,
0 ))
{
//
// Allocate a buffer of the appropriate size.
//
if ((pBuf = (LPWSTR)NLS_ALLOC_MEM(ResultLen * sizeof(WCHAR))) == NULL)
{
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
SetLastError(ERROR_OUTOFMEMORY);
return (0);
}
}
}
//
// Free the allocated source buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, pSTmp);
//
// Convert the destination Unicode buffer to the given Ansi buffer.
//
if (ResultLen > 0)
{
ResultLen = NlsUnicodeToAnsi( gpACPHashN,
pBuf,
ResultLen,
lpDestStr,
cchDest );
}
//
// Free the allocated destination buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pBuf, pDTmp);
//
// Return the result of the call to FoldStringW.
//
return (ResultLen);
}
////////////////////////////////////////////////////////////////////////////
//
// EnumSystemLanguageGroupsA
//
// Enumerates the system language groups that are installed or supported,
// based on the dwFlags parameter. It does so by passing the pointer to
// the string buffer containing the language group id to an
// application-defined callback function. It continues until the last
// language group id is found or the callback function returns FALSE.
//
// 03-10-98 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumSystemLanguageGroupsA(
LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc,
DWORD dwFlags,
LONG_PTR lParam)
{
return (Internal_EnumSystemLanguageGroups(
(NLS_ENUMPROC)lpLanguageGroupEnumProc,
dwFlags,
lParam,
FALSE ));
}
////////////////////////////////////////////////////////////////////////////
//
// EnumLanguageGroupLocalesA
//
// Enumerates the locales in a given language group. It does so by
// passing the appropriate information to an application-defined
// callback function. It continues until the last locale in the language
// group is found or the callback function returns FALSE.
//
// 03-10-98 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumLanguageGroupLocalesA(
LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc,
LGRPID LanguageGroup,
DWORD dwFlags,
LONG_PTR lParam)
{
return (Internal_EnumLanguageGroupLocales(
(NLS_ENUMPROC)lpLangGroupLocaleEnumProc,
LanguageGroup,
dwFlags,
lParam,
FALSE ));
}
////////////////////////////////////////////////////////////////////////////
//
// EnumUILanguagesA
//
// Enumerates the system UI languages that are installed. It does so by
// passing the pointer to the string buffer containing the UI language id
// to an application-defined callback function. It continues until the
// last UI language id is found or the callback function returns FALSE.
//
// 03-10-98 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumUILanguagesA(
UILANGUAGE_ENUMPROCA lpUILanguageEnumProc,
DWORD dwFlags,
LONG_PTR lParam)
{
return (Internal_EnumUILanguages( (NLS_ENUMPROC)lpUILanguageEnumProc,
dwFlags,
lParam,
FALSE ));
}
////////////////////////////////////////////////////////////////////////////
//
// EnumSystemLocalesA
//
// Enumerates the system locales that are installed or supported, based on
// the dwFlags parameter. It does so by passing the pointer to the string
// buffer containing the locale id to an application-defined callback
// function. It continues until the last locale id is found or the
// callback function returns FALSE.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumSystemLocalesA(
LOCALE_ENUMPROCA lpLocaleEnumProc,
DWORD dwFlags)
{
return (Internal_EnumSystemLocales( (NLS_ENUMPROC)lpLocaleEnumProc,
dwFlags,
FALSE ));
}
////////////////////////////////////////////////////////////////////////////
//
// EnumSystemCodePagesA
//
// Enumerates the system code pages that are installed or supported, based on
// the dwFlags parameter. It does so by passing the pointer to the string
// buffer containing the code page id to an application-defined callback
// function. It continues until the last code page is found or the
// callback function returns FALSE.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI EnumSystemCodePagesA(
CODEPAGE_ENUMPROCA lpCodePageEnumProc,
DWORD dwFlags)
{
return (Internal_EnumSystemCodePages( (NLS_ENUMPROC)lpCodePageEnumProc,
dwFlags,
FALSE ));
}
////////////////////////////////////////////////////////////////////////////
//
// GetCPInfoExA
//
// Returns information about a given code page.
//
// 11-15-96 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI GetCPInfoExA(
UINT CodePage,
DWORD dwFlags,
LPCPINFOEXA lpCPInfoEx)
{
CPINFOEXW lpCPInfoExW;
BOOL rc;
//
// Invalid Parameter Check:
// - lpCPInfoEx is NULL
//
if (lpCPInfoEx == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return (FALSE);
}
//
// Call the W version of the API.
//
rc = GetCPInfoExW(CodePage, dwFlags, &lpCPInfoExW);
//
// Convert the code page name from Unicode to Ansi.
//
if (rc == TRUE)
{
if (!NlsUnicodeToAnsi( gpACPHashN,
lpCPInfoExW.CodePageName,
-1,
lpCPInfoEx->CodePageName,
MAX_PATH ))
{
return (FALSE);
}
}
//
// Copy the rest of the information from the Unicode buffer to the
// Ansi buffer.
//
RtlMoveMemory( lpCPInfoEx,
&lpCPInfoExW,
FIELD_OFFSET(CPINFOEXW, CodePageName) );
//
// Return the result.
//
return (rc);
}
////////////////////////////////////////////////////////////////////////////
//
// GetGeoInfoA
//
// Wrapper funtion of GetGeoInfoW for ANSI. This function return information
// about a geographical region.
//
// 11-20-99 WeiWu Created
// 07-03-00 lguindon Began GEO API port
////////////////////////////////////////////////////////////////////////////
int WINAPI GetGeoInfoA(
GEOID GeoId,
DWORD GeoType,
LPSTR lpGeoData,
int cchData,
LANGID LangId)
{
int iRet = 0;
//
// Create buffer initialized to zero.
//
WCHAR wszBuffer[MAX_REG_VAL_SIZE] = {0};
//
// Sanity check.
//
if ((lpGeoData == NULL) && (cchData > 0))
{
SetLastError(ERROR_INVALID_PARAMETER);
return (iRet);
}
//
// Call the unicode version.
//
iRet = GetGeoInfoW( GeoId,
GeoType,
wszBuffer,
sizeof(wszBuffer) / sizeof(WCHAR),
LangId );
//
// Convert to ANSI if we get something.
//
if (iRet)
{
iRet = WideCharToMultiByte( CP_ACP,
0,
wszBuffer,
iRet,
lpGeoData,
cchData,
NULL,
NULL );
}
return (iRet);
}
//-------------------------------------------------------------------------//
// INTERNAL ROUTINES //
//-------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////
//
// NlsGetACPFromLocale
//
// Gets the CP hash node for the default ACP of the given locale. If
// either the locale or the code page are invalid, then NULL is returned.
//
// 01-19-94 JulieB Created.
////////////////////////////////////////////////////////////////////////////
PCP_HASH NlsGetACPFromLocale(
LCID Locale,
DWORD dwFlags)
{
PLOC_HASH pHashN; // ptr to LOC hash node
PCP_HASH pHashCP; // ptr to CP hash node
UNICODE_STRING ObUnicodeStr; // value string
UINT CodePage; // code page value
//
// See if the system ACP should be used.
//
if (dwFlags & (LOCALE_USE_CP_ACP | LOCALE_RETURN_NUMBER))
{
return (gpACPHashN);
}
//
// Get the locale hash node.
//
VALIDATE_LOCALE(Locale, pHashN, FALSE);
if (pHashN == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return (NULL);
}
//
// Get the ACP code page. If it's equal to CP_ACP (0), then return
// the system ACP hash node.
//
CodePage = pHashN->pLocaleFixed->DefaultACP;
if (CodePage == CP_ACP)
{
return (gpACPHashN);
}
//
// Get the CP hash node for the code page.
//
pHashCP = GetCPHashNode(CodePage);
if (pHashCP == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
}
//
// Return the code page hash node.
//
return (pHashCP);
}
////////////////////////////////////////////////////////////////////////////
//
// NlsAnsiToUnicode
//
// Converts an Ansi string to a Unicode string.
//
// NOTE: The Unicode buffer is allocated if the routine succeeds, so the
// caller will need to free the buffer when it is no longer needed.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL NlsAnsiToUnicode(
PCP_HASH pHashN,
DWORD dwFlags,
LPCSTR pAnsiBuffer,
int AnsiLength,
LPWSTR *ppUnicodeBuffer,
int *pUnicodeLength)
{
LPWSTR pUnicode; // ptr to Unicode buffer
ULONG UnicodeLength; // length of the Unicode string
int ResultLength; // result length of Unicode string
//
// Make sure the pointer passed in is not null.
//
if (pAnsiBuffer == NULL)
{
*ppUnicodeBuffer = NULL;
*pUnicodeLength = 0;
return (TRUE);
}
//
// Make sure the Ansi length is set properly (in bytes).
//
if (AnsiLength < 0)
{
AnsiLength = strlen(pAnsiBuffer) + 1;
}
//
// See if the static buffer is big enough.
//
if ((*ppUnicodeBuffer == NULL) || (AnsiLength > (MAX_STRING_LEN - 1)))
{
//
// Get the size of the Unicode string, including the
// null terminator.
//
UnicodeLength = AnsiLength;
//
// Allocate the Unicode buffer.
//
if ((pUnicode = (LPWSTR)NLS_ALLOC_MEM(
(UnicodeLength + 1) * sizeof(WCHAR) )) == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return (FALSE);
}
}
else
{
UnicodeLength = MAX_STRING_LEN - 1;
pUnicode = *ppUnicodeBuffer;
}
//
// Make sure the length of the Ansi string is not zero.
//
if (AnsiLength == 0)
{
pUnicode[0] = 0;
*ppUnicodeBuffer = pUnicode;
*pUnicodeLength = 0;
return (TRUE);
}
//
// Convert the Ansi string to a Unicode string.
//
ResultLength = SpecialMBToWC( pHashN,
dwFlags,
pAnsiBuffer,
AnsiLength,
pUnicode,
UnicodeLength );
if (ResultLength == 0)
{
//
// Free the allocated Unicode buffer (if one was allocated).
//
NLS_FREE_TMP_BUFFER(pUnicode, *ppUnicodeBuffer);
//
// See if the failure was due to insufficient buffer size.
//
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
//
// Get the size of the buffer needed to hold the
// Unicode string.
//
UnicodeLength = SpecialMBToWC( pHashN,
dwFlags,
pAnsiBuffer,
AnsiLength,
NULL,
0 );
//
// Allocate the Unicode buffer.
//
if ((pUnicode = (LPWSTR)NLS_ALLOC_MEM(
(UnicodeLength + 1) * sizeof(WCHAR) )) == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return (FALSE);
}
//
// Try the translation again.
//
ResultLength = SpecialMBToWC( pHashN,
dwFlags,
pAnsiBuffer,
AnsiLength,
pUnicode,
UnicodeLength );
}
//
// If there was still an error, return failure.
//
if (ResultLength == 0)
{
SetLastError(ERROR_INVALID_PARAMETER);
return (FALSE);
}
}
//
// Make sure there is room in the buffer for the null terminator.
//
ASSERT(ResultLength <= (int)UnicodeLength);
//
// Null terminate the string.
//
pUnicode[ResultLength] = UNICODE_NULL;
//
// Return the Unicode buffer and success.
//
*ppUnicodeBuffer = pUnicode;
*pUnicodeLength = ResultLength;
return (TRUE);
}
////////////////////////////////////////////////////////////////////////////
//
// NlsUnicodeToAnsi
//
// Converts a Unicode string to an Ansi string.
//
// This routine does NOT allocate the Ansi buffer. Instead, it uses the
// Ansi buffer passed in (unless AnsiLength is 0) and checks for buffer
// overflow.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int NlsUnicodeToAnsi(
PCP_HASH pHashN,
LPCWSTR pUnicodeBuffer,
int UnicodeLength,
LPSTR pAnsiBuffer,
int AnsiLength)
{
//
// Convert the Unicode string to an Ansi string and return the
// result. The last error will be set appropriately by
// WideCharToMultiByte.
//
return (WideCharToMultiByte( pHashN->CodePage,
0,
pUnicodeBuffer,
UnicodeLength,
pAnsiBuffer,
AnsiLength,
NULL,
NULL ));
}
////////////////////////////////////////////////////////////////////////////
//
// NlsEnumUnicodeToAnsi
//
// Converts a Unicode string to an Ansi string.
//
// NOTE: The Ansi buffer is allocated if the routine succeeds, so the
// caller will need to free the buffer when it is no longer needed.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL NlsEnumUnicodeToAnsi(
PCP_HASH pHashN,
LPCWSTR pUnicodeBuffer,
LPSTR *ppAnsiBuffer)
{
LPSTR pAnsi; // ptr to Ansi buffer
ULONG AnsiLength; // length of the Ansi string
ULONG UnicodeLength; // length of the Unicode string
ULONG ResultLength; // result length of Ansi string
//
// Get the length of the Unicode string (in bytes), including the
// null terminator.
//
UnicodeLength = NlsStrLenW(pUnicodeBuffer) + 1;
//
// Get the size of the Ansi string (in bytes), including the
// null terminator.
//
AnsiLength = UnicodeLength * sizeof(WCHAR);
//
// Allocate the Ansi buffer.
//
if ((pAnsi = (LPSTR)NLS_ALLOC_MEM(AnsiLength)) == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return (FALSE);
}
//
// Convert the Unicode string to an Ansi string.
// It will already be null terminated.
//
ResultLength = WideCharToMultiByte( pHashN->CodePage,
0,
pUnicodeBuffer,
UnicodeLength,
pAnsi,
AnsiLength,
NULL,
NULL );
if (ResultLength == 0)
{
//
// Free the allocated Ansi buffer.
//
NLS_FREE_MEM(pAnsi);
//
// See if the failure was due to insufficient buffer size.
//
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
//
// Get the size of the buffer needed to hold the
// ansi string.
//
AnsiLength = WideCharToMultiByte( pHashN->CodePage,
0,
pUnicodeBuffer,
UnicodeLength,
0,
0,
NULL,
NULL );
//
// Allocate the Ansi buffer.
//
if ((pAnsi = (LPSTR)NLS_ALLOC_MEM(AnsiLength)) == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return (FALSE);
}
//
// Try the translation again.
//
ResultLength = WideCharToMultiByte( pHashN->CodePage,
0,
pUnicodeBuffer,
UnicodeLength,
pAnsi,
AnsiLength,
NULL,
NULL );
}
//
// If there was still an error, return failure.
//
if (ResultLength == 0)
{
SetLastError(ERROR_INVALID_PARAMETER);
return (FALSE);
}
}
//
// Return the Ansi buffer and success.
//
*ppAnsiBuffer = pAnsi;
return (TRUE);
}
////////////////////////////////////////////////////////////////////////////
//
// NlsDispatchAnsiEnumProc
//
// Converts a Unicode string to an Ansi string.
//
// 11-10-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL NlsDispatchAnsiEnumProc(
LCID Locale,
NLS_ENUMPROC pNlsEnumProc,
DWORD dwFlags,
LPWSTR pUnicodeBuffer1,
LPWSTR pUnicodeBuffer2,
DWORD dwValue1,
DWORD dwValue2,
LONG_PTR lParam,
BOOL fVersion)
{
PCP_HASH pHashN; // ptr to CP hash node
LPSTR pAnsiBuffer1 = NULL; // ptr to ansi buffer
LPSTR pAnsiBuffer2 = NULL; // ptr to ansi buffer
BOOL rc = FALSE; // return code
//
// Get the code page hash node for the given locale.
//
pHashN = NlsGetACPFromLocale(Locale, dwFlags);
if (pHashN == NULL)
{
return (0);
}
//
// Convert the null-terminated Unicode string to a
// null-terminated Ansi string.
//
if (!NlsEnumUnicodeToAnsi( pHashN,
pUnicodeBuffer1,
&pAnsiBuffer1 ))
{
return (FALSE);
}
if ((pUnicodeBuffer2 != NULL) &&
(!NlsEnumUnicodeToAnsi( pHashN,
pUnicodeBuffer2,
&pAnsiBuffer2 )))
{
NLS_FREE_MEM(pAnsiBuffer1);
return (FALSE);
}
//
// Call the callback function.
//
switch (fVersion)
{
case ( 0 ) :
{
rc = (*pNlsEnumProc)(pAnsiBuffer1);
break;
}
case ( 1 ) :
{
rc = (*((NLS_ENUMPROCEX)pNlsEnumProc))(pAnsiBuffer1, dwValue1);
break;
}
case ( 2 ) :
{
rc = (*((NLS_ENUMPROC2)pNlsEnumProc))( dwValue1,
dwValue2,
pAnsiBuffer1,
lParam );
break;
}
case ( 3 ) :
{
rc = (*((NLS_ENUMPROC3)pNlsEnumProc))( dwValue1,
pAnsiBuffer1,
pAnsiBuffer2,
dwValue2,
lParam );
break;
}
case ( 4 ) :
{
rc = (*((NLS_ENUMPROC4)pNlsEnumProc))( pAnsiBuffer1,
lParam );
break;
}
}
//
// Free any allocated memory.
//
NLS_FREE_MEM(pAnsiBuffer1);
if (pAnsiBuffer2)
{
NLS_FREE_MEM(pAnsiBuffer2);
}
//
// Return the result.
//
return (rc);
}
Reference in a new issue Copy permalink