2597 lines
73 KiB
C
2597 lines
73 KiB
C
/*++
|
|
|
|
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);
|
|
}
|