nsresult nsCollationWin::AllocateRawSortKey(PRInt32 strength,
const nsAString& stringIn, PRUint8** key, PRUint32* outLen)
{
int byteLen;
void *buffer;
nsresult res = NS_OK;
DWORD dwMapFlags = LCMAP_SORTKEY;
if (strength == kCollationCaseInSensitive)
dwMapFlags |= NORM_IGNORECASE;
byteLen = LCMapStringW(mLCID, dwMapFlags,
(LPCWSTR) PromiseFlatString(stringIn).get(),
-1, NULL, 0);
buffer = PR_Malloc(byteLen);
if (!buffer) {
res = NS_ERROR_OUT_OF_MEMORY;
} else {
*key = (PRUint8 *)buffer;
*outLen = LCMapStringW(mLCID, dwMapFlags,
(LPCWSTR) PromiseFlatString(stringIn).get(),
-1, (LPWSTR) buffer, byteLen);
}
return res;
}
QCollatorSortKey QCollator::sortKey(const QString &string) const
{
if (d->dirty)
d->init();
#ifndef USE_COMPARESTRINGEX
int size = LCMapStringW(d->localeID, LCMAP_SORTKEY | d->collator,
reinterpret_cast<const wchar_t*>(string.constData()), string.size(),
0, 0);
#else
int size = LCMapStringEx(LPCWSTR(d->localeName.utf16()), LCMAP_SORTKEY | d->collator,
reinterpret_cast<LPCWSTR>(string.constData()), string.size(),
0, 0, NULL, NULL, 0);
#endif
QString ret(size, Qt::Uninitialized);
#ifndef USE_COMPARESTRINGEX
int finalSize = LCMapStringW(d->localeID, LCMAP_SORTKEY | d->collator,
reinterpret_cast<const wchar_t*>(string.constData()), string.size(),
reinterpret_cast<wchar_t*>(ret.data()), ret.size());
#else
int finalSize = LCMapStringEx(LPCWSTR(d->localeName.utf16()), LCMAP_SORTKEY | d->collator,
reinterpret_cast<LPCWSTR>(string.constData()), string.size(),
reinterpret_cast<LPWSTR>(ret.data()), ret.size(),
NULL, NULL, 0);
#endif
if (finalSize == 0) {
qWarning() << "there were problems when generating the ::sortKey by LCMapStringW with error:" << GetLastError();
}
return QCollatorSortKey(new QCollatorSortKeyPrivate(ret));
}
inline std::wstring win_map_string_l(unsigned flags,wchar_t const *begin,wchar_t const *end,winlocale const &l)
{
std::wstring res;
int len = LCMapStringW(l.lcid,flags,begin,end-begin,0,0);
if(len == 0)
return res;
std::vector<wchar_t> buf(len+1);
int l2 = LCMapStringW(l.lcid,flags,begin,end-begin,&buf.front(),buf.size());
res.assign(&buf.front(),l2);
return res;
}
VOID
WINAPI
SvchostCharLowerW (
_In_ LPCWSTR lpSrcStr
)
{
DWORD cchSrc;
/* If there's nothing to do, bail out */
if (lpSrcStr == NULL) return;
/* Get the length of the input string */
cchSrc = wcslen(lpSrcStr);
/* Call the locale API to lower-case it */
if (LCMapStringW(LANG_USER_DEFAULT,
LCMAP_LOWERCASE,
lpSrcStr,
cchSrc + 1,
(LPWSTR)lpSrcStr,
cchSrc + 1) == FALSE)
{
DBG_ERR("SvchostCharLowerW failed for %ws\n", lpSrcStr);
}
}
wint_t _Locale_wchar_toupper(struct _Locale_ctype* ltype, wint_t c)
{
wint_t res;
LCMapStringW(ltype->lcid, LCMAP_UPPERCASE, &c, 1, &res, 1);
return res;
}
DWORD WINAPI CharLowerBuffW(
LPWSTR pwsz,
DWORD cwch)
{
int cwchT;
DWORD i;
if (cwch == 0) {
return 0;
}
cwchT = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
pwsz, cwch, pwsz, cwch);
if (cwchT != 0) {
return cwchT;
}
/*
* LCMapString failed! The caller is not expecting failure,
* CharLowerBuffW does not have a failure indicator, so we
* convert the buffer to lower case as best we can.
*/
RIPMSG1(RIP_WARNING, "CharLowerBuffW(%ls) failed", pwsz);
for (i=0; i < cwch; i++) {
if (IS_UNICODE_BLK1(pwsz[i]) && IsCharUpperA((char)pwsz[i])) {
pwsz[i] += 'a'-'A';
}
}
return cwch;
}
static HRESULT lcid_to_rfc1766(LCID lcid, WCHAR *rfc1766, INT len)
{
WCHAR buffer[6 /* MAX_RFC1766_NAME */];
INT n = GetLocaleInfoW(lcid, LOCALE_SISO639LANGNAME, buffer, ARRAY_SIZE(buffer));
INT i;
if (n)
{
i = PRIMARYLANGID(lcid);
if ((((i == LANG_ENGLISH) || (i == LANG_CHINESE) || (i == LANG_ARABIC)) &&
(SUBLANGID(lcid) == SUBLANG_DEFAULT)) ||
(SUBLANGID(lcid) > SUBLANG_DEFAULT)) {
buffer[n - 1] = '-';
i = GetLocaleInfoW(lcid, LOCALE_SISO3166CTRYNAME, buffer + n, ARRAY_SIZE(buffer) - n);
if (!i)
buffer[n - 1] = '\0';
}
else
i = 0;
LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, buffer, n + i, rfc1766, len);
return ((n + i) > len) ? E_INVALIDARG : S_OK;
}
return E_FAIL;
}
bool Cx_TextUtil::ToDBC(std::wstring& text, bool punct)
{
bool changed = false;
std::wstring dest('\0', text.size() + 1);
if (!text.empty() && punct)
{
int ret = LCMapStringW(
MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED),
LCMAP_HALFWIDTH,
text.c_str(), text.size(),
&dest[0], dest.size() + 1);
if (ret > 0 && dest != text)
{
text = dest;
changed = true;
}
}
else if (!text.empty())
{
LPCWSTR psrc = text.c_str();
LPWSTR pdest = &dest[0];
int i = 0, n = 0;
for (; psrc[i] != 0; i++)
{
if (psrc[i] >= 0xA3B0 && psrc[i] <= 0xA3B9) // £°..£¹
{
pdest[i] = WCHAR('0' + psrc[i] - 0xA3B0);
n++;
}
else if (psrc[i] >= 0xA3C1 && psrc[i] <= 0xA3DA) // £Á..£Ú
{
pdest[i] = WCHAR('A' + psrc[i] - 0xA3C1);
n++;
}
else if (psrc[i] >= 0xA3E1 && psrc[i] <= 0xA3FA) // £á..£ú
{
pdest[i] = WCHAR('a' + psrc[i] - 0xA3E1);
n++;
}
else
{
pdest[i] = psrc[i];
}
}
pdest[i] = 0;
if (n > 0)
{
text = dest;
changed = true;
}
}
return changed;
}
/*********************************************************************
* __crtLCMapStringW (MSVCRT.@)
*/
int __crtLCMapStringW(
LCID lcid, DWORD mapflags, LPCWSTR src, int srclen, LPWSTR dst,
int dstlen, unsigned int codepage, int xflag
) {
TRACE("(lcid %lx, flags %lx, %s(%d), %p(%d), %x, %d), partial stub!\n",
lcid,mapflags,src,srclen,dst,dstlen,codepage,xflag);
return LCMapStringW(lcid,mapflags,src,srclen,dst,dstlen);
}
int env_strncmp(const wchar_t* a, int na, const wchar_t* b) {
wchar_t* a_eq;
wchar_t* b_eq;
wchar_t* A;
wchar_t* B;
int nb;
int r;
if (na < 0) {
a_eq = wcschr(a, L'=');
assert(a_eq);
na = (int)(long)(a_eq - a);
} else {
na--;
}
b_eq = wcschr(b, L'=');
assert(b_eq);
nb = b_eq - b;
A = alloca((na+1) * sizeof(wchar_t));
B = alloca((nb+1) * sizeof(wchar_t));
r = LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, a, na, A, na);
assert(r==na);
A[na] = L'\0';
r = LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, b, nb, B, nb);
assert(r==nb);
B[nb] = L'\0';
while (1) {
wchar_t AA = *A++;
wchar_t BB = *B++;
if (AA < BB) {
return -1;
} else if (AA > BB) {
return 1;
} else if (!AA && !BB) {
return 0;
}
}
}
/*
=======================================
LCMapStringEx
=======================================
*/
int __stdcall
myLCMapStringEx (
__CR_IN__ void* lpLocaleName,
__CR_IN__ unsigned long dwMapFlags,
__CR_IN__ void* lpSrcStr,
__CR_IN__ int cchSrc,
__CR_IN__ void* lpDestStr,
__CR_IN__ int cchDest,
__CR_IN__ void* lpVersionInformation,
__CR_IN__ void* lpReserved,
__CR_IN__ unsigned long sortHandle
)
{
CR_NOUSE(lpVersionInformation);
CR_NOUSE(lpReserved); CR_NOUSE(sortHandle);
return (LCMapStringW(myLocaleNameToLCID(lpLocaleName), dwMapFlags,
lpSrcStr, cchSrc, lpDestStr, cchDest));
}
int wcs2mbs( unsigned int codepage, const unsigned short* src, int srclen, char* dst, int dstlen, bool* usedDefChar )
{
BOOL usedDefaultChar = FALSE;
int ret = WideCharToMultiByte(codepage, WC_COMPOSITECHECK, (LPCWSTR)src, srclen, dst, dstlen-1, "?", &usedDefaultChar);
if( usedDefaultChar && (codepage == 950 || codepage == 932) ) // BIG5(TW) or SHIFT-JIS(JP)
{
if( srclen<0 ) srclen = wcslen((LPCWSTR)src);
wchar_t* convsrc = new wchar_t[srclen+1];
int rett = LCMapStringW( 0x804, LCMAP_TRADITIONAL_CHINESE, (LPCWSTR)src, srclen, convsrc, srclen ) ;
ret = WideCharToMultiByte(codepage, WC_COMPOSITECHECK, convsrc, srclen, dst, dstlen-1, "?", &usedDefaultChar);
delete[] convsrc;
}
dst[ret] = 0;
if(usedDefChar) *usedDefChar = usedDefaultChar!=FALSE;
return ret;
}
LPWSTR WINAPI CharLowerW(
LPWSTR pwsz)
{
/*
* Early out for NULL string or '\0'
*/
if (pwsz == NULL) {
return pwsz;
}
if (!IS_PTR(pwsz)) {
if (!LCMapStringW(
LOCALE_USER_DEFAULT,
LCMAP_LOWERCASE,
(LPWSTR)&pwsz,
1,
(LPWSTR)&pwsz,
1
)) {
/*
* We don't expect LCMapString to fail! The caller is not expecting
* failure, CharLowerW does not have a failure indicator, so we do
* nothing.
*/
RIPMSG1(RIP_WARNING, "CharLowerW(%#p): LCMapString failed\n", pwsz);
}
return pwsz;
}
/*
* pwsz is a null-terminated string
*/
CharLowerBuffW(pwsz, wcslen(pwsz)+1);
return pwsz;
}
int __cdecl __crtLCMapStringA(
LCID Locale,
DWORD dwMapFlags,
LPCSTR lpSrcStr,
int cchSrc,
LPSTR lpDestStr,
int cchDest,
int code_page,
BOOL bError
)
{
static int f_use = 0;
/*
* Look for unstubbed 'preferred' flavor. Otherwise use available flavor.
* Must actually call the function to ensure it's not a stub.
* (Always try wide version first so WinNT can process codepage correctly.)
*/
if (0 == f_use) {
if (0 != LCMapStringW(0, LCMAP_LOWERCASE, L"\0", 1, NULL, 0))
f_use = USE_W;
else if (0 != LCMapStringA(0, LCMAP_LOWERCASE, "\0", 1, NULL, 0))
f_use = USE_A;
else
return 0;
}
/*
* LCMapString will map past NULL. Must find NULL if in string
* before cchSrc characters.
*/
if (cchSrc > 0)
cchSrc = strncnt(lpSrcStr, cchSrc);
/* Use "A" version */
if (USE_A == f_use) {
return LCMapStringA( Locale, dwMapFlags, lpSrcStr, cchSrc,
lpDestStr, cchDest );
}
/* Use "W" version */
if (USE_W == f_use)
{
int retval;
int inbuff_size;
int outbuff_size;
wchar_t *inwbuffer;
wchar_t *outwbuffer;
/*
* Convert string and return the requested information. Note that
* we are converting to a wide string so there is not a
* one-to-one correspondence between number of wide chars in the
* input string and the number of *bytes* in the buffer. However,
* there had *better be* a one-to-one correspondence between the
* number of wide characters and the number of multibyte characters
* or the resulting mapped string will be worthless to the user.
*/
/*
* Use __lc_codepage for conversion if code_page not specified
*/
if (0 == code_page)
code_page = __lc_codepage;
/* find out how big a buffer we need (includes NULL if any) */
if ( 0 == (inbuff_size =
MultiByteToWideChar( code_page,
bError ? MB_PRECOMPOSED |
MB_ERR_INVALID_CHARS :
MB_PRECOMPOSED,
lpSrcStr,
cchSrc,
NULL,
0 )) )
return 0;
/* allocate enough space for wide chars */
__try {
inwbuffer = (wchar_t *)_alloca( inbuff_size * sizeof(wchar_t) );
}
__except(EXCEPTION_EXECUTE_HANDLER) {
inwbuffer = NULL;
}
if ( inwbuffer == NULL )
return 0;
/* do the conversion */
if ( 0 == MultiByteToWideChar( code_page,
MB_PRECOMPOSED,
lpSrcStr,
cchSrc,
inwbuffer,
inbuff_size) )
return 0;
/* get size required for string mapping */
if ( 0 == (retval = LCMapStringW( Locale,
dwMapFlags,
inwbuffer,
inbuff_size,
NULL,
0 )) )
return 0;
if (dwMapFlags & LCMAP_SORTKEY) {
/* retval is size in BYTES */
if (0 != cchDest) {
if (retval > cchDest)
return 0;
/* do string mapping */
if ( 0 == LCMapStringW( Locale,
dwMapFlags,
inwbuffer,
inbuff_size,
(LPWSTR)lpDestStr,
cchDest ) )
return 0;
}
}
else {
/* retval is size in wide chars */
outbuff_size = retval;
/* allocate enough space for wide chars (includes NULL if any) */
__try {
outwbuffer = (wchar_t *)_alloca( outbuff_size * sizeof(wchar_t) );
}
__except(EXCEPTION_EXECUTE_HANDLER) {
outwbuffer = NULL;
}
if ( outwbuffer == NULL )
return 0;
/* do string mapping */
if ( 0 == LCMapStringW( Locale,
dwMapFlags,
inwbuffer,
inbuff_size,
outwbuffer,
outbuff_size ) )
return 0;
if (0 == cchDest) {
/* get size required */
if ( 0 == (retval =
WideCharToMultiByte( code_page,
WC_COMPOSITECHECK |
WC_SEPCHARS,
outwbuffer,
outbuff_size,
NULL,
0,
NULL,
NULL )) )
return 0;
}
else {
/* convert mapping */
if ( 0 == (retval =
WideCharToMultiByte( code_page,
WC_COMPOSITECHECK |
WC_SEPCHARS,
outwbuffer,
outbuff_size,
lpDestStr,
cchDest,
NULL,
NULL )) )
return 0;
}
}
return retval;
}
static int __cdecl __crtLCMapStringW_stat(
_locale_t plocinfo,
LCID Locale,
DWORD dwMapFlags,
LPCWSTR lpSrcStr,
int cchSrc,
LPWSTR lpDestStr,
int cchDest,
int code_page
) {
static int f_use = 0;
/*
* Look for unstubbed 'preferred' flavor. Otherwise use available flavor.
* Must actually call the function to ensure it's not a stub.
*/
if (0 == f_use) {
if (0 != LCMapStringW(0, LCMAP_LOWERCASE, L"\0", 1, NULL, 0)) {
f_use = USE_W;
} else if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
f_use = USE_A;
}
}
/*
* LCMapString will map past NULL. Must find NULL if in string
* before cchSrc wide characters.
*/
if (cchSrc > 0) {
cchSrc = wcsncnt(lpSrcStr, cchSrc);
}
/* Use "W" version */
if (USE_W == f_use) {
return LCMapStringW(Locale, dwMapFlags, lpSrcStr, cchSrc,
lpDestStr, cchDest);
}
/* Use "A" version */
if (USE_A == f_use || f_use == 0) {
int retval = 0;
int inbuff_size;
int outbuff_size;
unsigned char* inbuffer = NULL;
unsigned char* outbuffer = NULL;
int AnsiCP = 0;
/*
* Convert string and return the requested information. Note that
* we are converting to a multibyte string so there is not a
* one-to-one correspondence between number of wide chars in the
* input string and the number of *bytes* in the buffer. However,
* there had *better be* a one-to-one correspondence between the
* number of wide characters and the number of multibyte characters
* (enforced by WC_SEPCHARS) in the buffer or the resulting mapped
* string will be worthless to the user.
*
*/
/*
* Use __lc_codepage for conversion if code_page not specified
*/
if (0 == Locale) {
Locale = plocinfo->locinfo->lc_handle[LC_CTYPE];
}
if (0 == code_page) {
code_page = plocinfo->locinfo->lc_codepage;
}
/*
* Always use Ansi codepage with Ansi WinAPI because they use
* Ansi codepage
*/
if (code_page != (AnsiCP = __ansicp(Locale))) {
if (AnsiCP != -1) {
code_page = AnsiCP;
}
}
/* find out how big a buffer we need (includes NULL if any) */
if (0 == (inbuff_size = WideCharToMultiByte(code_page,
0,
lpSrcStr,
cchSrc,
NULL,
0,
NULL,
NULL))) {
return 0;
}
/* allocate enough space for chars */
inbuffer = (unsigned char*)_calloca(inbuff_size, sizeof(char));
if (inbuffer == NULL) {
return 0;
}
/* do the conversion */
if (0 == WideCharToMultiByte(code_page,
0,
lpSrcStr,
cchSrc,
(char*)inbuffer,
inbuff_size,
NULL,
NULL)) {
goto error_cleanup;
}
/* get size required for string mapping */
if (0 == (outbuff_size = LCMapStringA(Locale,
dwMapFlags,
(const char*)inbuffer,
inbuff_size,
NULL,
0))) {
goto error_cleanup;
}
/* allocate enough space for chars and NULL */
outbuffer = (unsigned char*)_calloca(outbuff_size, sizeof(char));
if (outbuffer == NULL) {
goto error_cleanup;
}
/* do string mapping */
if (0 == LCMapStringA(Locale,
dwMapFlags,
(const char*)inbuffer,
inbuff_size,
(char*)outbuffer,
outbuff_size)) {
goto error_cleanup;
}
if (dwMapFlags & LCMAP_SORTKEY) {
/* outbuff_size > cchDest is allowed */
retval = outbuff_size;
if (0 != cchDest)
/* SORTKEY returns BYTES, just copy */
_ERRCHECK(strncpy_s((char*)lpDestStr,
cchDest,
(char*)outbuffer,
cchDest <= outbuff_size ? cchDest - 1 : outbuff_size));
} else {
if (0 == cchDest) {
/* get size required */
if (0 == (retval = MultiByteToWideChar(code_page,
MB_PRECOMPOSED,
(const char*)outbuffer,
outbuff_size,
NULL,
0))) {
goto error_cleanup;
}
} else {
/* convert mapping */
if (0 == (retval = MultiByteToWideChar(code_page,
MB_PRECOMPOSED,
(const char*)outbuffer,
outbuff_size,
lpDestStr,
cchDest))) {
goto error_cleanup;
}
}
}
error_cleanup:
if (outbuffer != NULL) {
_freea(outbuffer);
}
_freea(inbuffer);
return retval;
} else { /* f_use is neither USE_A nor USE_W */
return 0;
}
}
size_t _Locale_strwxfrm(struct _Locale_collate* lcol,
wchar_t* dst, size_t dst_size,
const wchar_t* src, size_t src_size) {
return LCMapStringW(lcol->lcid, LCMAP_SORTKEY, src, src_size, dst, dst_size);
}
int __cdecl __crtLCMapStringW(
LCID Locale,
DWORD dwMapFlags,
LPCWSTR lpSrcStr,
int cchSrc,
LPWSTR lpDestStr,
int cchDest,
int code_page
)
{
static int f_use = 0;
/*
* Look for unstubbed 'preferred' flavor. Otherwise use available flavor.
* Must actually call the function to ensure it's not a stub.
*/
if (0 == f_use) {
if (0 != LCMapStringW(0, LCMAP_LOWERCASE, L"\0", 1, NULL, 0))
f_use = USE_W;
else if (0 != LCMapStringA(0, LCMAP_LOWERCASE, "\0", 1, NULL, 0))
f_use = USE_A;
else
return 0;
}
/*
* LCMapString will map past NULL. Must find NULL if in string
* before cchSrc wide characters.
*/
if (cchSrc > 0)
cchSrc = wcsncnt(lpSrcStr, cchSrc);
/* Use "W" version */
if (USE_W == f_use) {
return LCMapStringW( Locale, dwMapFlags, lpSrcStr, cchSrc,
lpDestStr, cchDest );
}
/* Use "A" version */
if (USE_A == f_use) {
int retval;
int inbuff_size;
int outbuff_size;
unsigned char *inbuffer;
unsigned char *outbuffer;
/*
* Convert string and return the requested information. Note that
* we are converting to a multibyte string so there is not a
* one-to-one correspondence between number of wide chars in the
* input string and the number of *bytes* in the buffer. However,
* there had *better be* a one-to-one correspondence between the
* number of wide characters and the number of multibyte characters
* (enforced by WC_SEPCHARS) in the buffer or the resulting mapped
* string will be worthless to the user.
*
*/
/*
* Use __lc_codepage for conversion if code_page not specified
*/
if (0 == code_page)
code_page = __lc_codepage;
/* find out how big a buffer we need (includes NULL if any) */
if ( 0 == (inbuff_size = WideCharToMultiByte( code_page,
WC_COMPOSITECHECK |
WC_SEPCHARS,
lpSrcStr,
cchSrc,
NULL,
0,
NULL,
NULL )) )
return 0;
/* allocate enough space for chars */
__try {
inbuffer = (unsigned char *)_alloca( inbuff_size * sizeof(char) );
}
__except(EXCEPTION_EXECUTE_HANDLER) {
inbuffer = NULL;
}
if ( inbuffer == NULL )
return 0;
/* do the conversion */
if ( 0 == WideCharToMultiByte( code_page,
WC_COMPOSITECHECK | WC_SEPCHARS,
lpSrcStr,
cchSrc,
inbuffer,
inbuff_size,
NULL,
NULL ) )
return 0;
/* get size required for string mapping */
if ( 0 == (outbuff_size = LCMapStringA( Locale,
dwMapFlags,
inbuffer,
inbuff_size,
NULL,
0 )) )
return 0;
/* allocate enough space for chars and NULL */
__try {
outbuffer = (unsigned char *)_alloca( outbuff_size * sizeof(char) );
}
__except(EXCEPTION_EXECUTE_HANDLER) {
outbuffer = NULL;
}
if ( outbuffer == NULL )
return 0;
/* do string mapping */
if ( 0 == LCMapStringA( Locale,
dwMapFlags,
inbuffer,
inbuff_size,
outbuffer,
outbuff_size ) )
return 0;
if (dwMapFlags & LCMAP_SORTKEY) {
/* outbuff_size > cchDest is allowed */
retval = outbuff_size;
if (0 != cchDest)
/* SORTKEY returns BYTES, just copy */
strncpy( (char *)lpDestStr,
(char *)outbuffer,
cchDest < outbuff_size ? cchDest : outbuff_size );
}
else {
if (0 == cchDest) {
/* get size required */
if ( 0 == (retval = MultiByteToWideChar( code_page,
MB_PRECOMPOSED,
outbuffer,
outbuff_size,
NULL,
0 )) )
return 0;
}
else {
/* convert mapping */
if ( 0 == (retval = MultiByteToWideChar( code_page,
MB_PRECOMPOSED,
outbuffer,
outbuff_size,
lpDestStr,
cchDest )) )
return 0;
}
}
return retval;
}
