mirror of
https://github.com/mangosfour/server.git
synced 2025-12-12 10:37:03 +00:00
377 lines
9.6 KiB
C++
377 lines
9.6 KiB
C++
// $Id: OS_NS_wchar.cpp 91286 2010-08-05 09:04:31Z johnnyw $
|
|
|
|
#include "ace/OS_NS_wchar.h"
|
|
|
|
|
|
|
|
#if !defined (ACE_HAS_INLINED_OSCALLS)
|
|
# include "ace/OS_NS_wchar.inl"
|
|
#endif /* ACE_HAS_INLINED_OSCALLS */
|
|
|
|
#if defined (ACE_HAS_WCHAR)
|
|
# include "ace/OS_NS_ctype.h"
|
|
# include "ace/OS_NS_string.h"
|
|
#endif /* ACE_HAS_WCHAR */
|
|
|
|
// The following wcs*_emulation methods were created based on BSD code:
|
|
/*-
|
|
* Copyright (c) 1991, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* James W. Williams of NASA Goddard Space Flight Center.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSCAT)
|
|
wchar_t *
|
|
ACE_OS::wcscat_emulation (wchar_t *destination,
|
|
const wchar_t *source)
|
|
{
|
|
wchar_t *save = destination;
|
|
|
|
for (; *destination; ++destination);
|
|
while ((*destination++ = *source++));
|
|
return save;
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSCAT */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSCHR)
|
|
wchar_t *
|
|
ACE_OS::wcschr_emulation (const wchar_t *string, wchar_t c)
|
|
{
|
|
for (;*string ; ++string)
|
|
if (*string == c)
|
|
return const_cast<wchar_t *> (string);
|
|
|
|
return 0;
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSCHR */
|
|
|
|
#if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSCMP)
|
|
int
|
|
ACE_OS::wcscmp_emulation (const ACE_WCHAR_T *string1,
|
|
const ACE_WCHAR_T *string2)
|
|
{
|
|
while (*string1 == *string2++)
|
|
if (*string1++ == 0)
|
|
return 0;
|
|
return (*string1 - *--string2);
|
|
}
|
|
#endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSCMP */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSCPY)
|
|
wchar_t *
|
|
ACE_OS::wcscpy_emulation (wchar_t *destination,
|
|
const wchar_t *source)
|
|
{
|
|
wchar_t *save = destination;
|
|
|
|
for (; (*destination = *source); ++source, ++destination);
|
|
return save;
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSCPY */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSCSPN)
|
|
size_t
|
|
ACE_OS::wcscspn_emulation (const wchar_t *s, const wchar_t *reject)
|
|
{
|
|
const wchar_t *scan = 0;
|
|
const wchar_t *rej_scan = 0;
|
|
int count = 0;
|
|
|
|
for (scan = s; *scan; scan++)
|
|
{
|
|
|
|
for (rej_scan = reject; *rej_scan; rej_scan++)
|
|
if (*scan == *rej_scan)
|
|
return count;
|
|
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSCSPN */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSICMP)
|
|
int
|
|
ACE_OS::wcsicmp_emulation (const wchar_t *s, const wchar_t *t)
|
|
{
|
|
const wchar_t *scan1 = s;
|
|
const wchar_t *scan2 = t;
|
|
|
|
while (*scan1 != 0
|
|
&& ACE_OS::ace_towlower (*scan1)
|
|
== ACE_OS::ace_towlower (*scan2))
|
|
{
|
|
++scan1;
|
|
++scan2;
|
|
}
|
|
|
|
// The following case analysis is necessary so that characters which
|
|
// look negative collate low against normal characters but high
|
|
// against the end-of-string NUL.
|
|
|
|
if (*scan1 == '\0' && *scan2 == '\0')
|
|
return 0;
|
|
else if (*scan1 == '\0')
|
|
return -1;
|
|
else if (*scan2 == '\0')
|
|
return 1;
|
|
else
|
|
return ACE_OS::ace_tolower (*scan1) - ACE_OS::ace_towlower (*scan2);
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSICMP */
|
|
|
|
#if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSLEN)
|
|
size_t
|
|
ACE_OS::wcslen_emulation (const ACE_WCHAR_T *string)
|
|
{
|
|
const ACE_WCHAR_T *s = 0;
|
|
|
|
for (s = string; *s; ++s)
|
|
continue;
|
|
|
|
return s - string;
|
|
}
|
|
#endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSLEN */
|
|
|
|
#if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSNCAT)
|
|
ACE_WCHAR_T *
|
|
ACE_OS::wcsncat_emulation (ACE_WCHAR_T *destination,
|
|
const ACE_WCHAR_T *source,
|
|
size_t count)
|
|
{
|
|
if (count != 0)
|
|
{
|
|
ACE_WCHAR_T *d = destination;
|
|
const ACE_WCHAR_T *s = source;
|
|
|
|
while (*d != 0)
|
|
++d;
|
|
|
|
do
|
|
{
|
|
if ((*d = *s++) == 0)
|
|
break;
|
|
|
|
++d;
|
|
} while (--count != 0);
|
|
|
|
*d = 0;
|
|
}
|
|
|
|
return destination;
|
|
}
|
|
#endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSCAT */
|
|
|
|
#if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSNCMP)
|
|
int
|
|
ACE_OS::wcsncmp_emulation (const ACE_WCHAR_T *s1,
|
|
const ACE_WCHAR_T *s2,
|
|
size_t len)
|
|
{
|
|
if (len == 0)
|
|
return 0;
|
|
|
|
do
|
|
{
|
|
if (*s1 != *s2++)
|
|
return (*s1 - *--s2);
|
|
if (*s1++ == 0)
|
|
break;
|
|
} while (--len != 0);
|
|
|
|
return 0;
|
|
}
|
|
#endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSNCMP */
|
|
|
|
#if !defined (ACE_HAS_WCHAR) || defined (ACE_LACKS_WCSNCPY)
|
|
ACE_WCHAR_T *
|
|
ACE_OS::wcsncpy_emulation (ACE_WCHAR_T *destination,
|
|
const ACE_WCHAR_T *source,
|
|
size_t len)
|
|
{
|
|
if (len != 0)
|
|
{
|
|
ACE_WCHAR_T *d = destination;
|
|
const ACE_WCHAR_T *s = source;
|
|
|
|
do
|
|
{
|
|
if ((*d++ = *s++) == 0)
|
|
{
|
|
// NUL pad the remaining n-1 bytes
|
|
while (--len != 0)
|
|
*d++ = 0;
|
|
break;
|
|
}
|
|
} while (--len != 0);
|
|
}
|
|
|
|
return destination;
|
|
}
|
|
#endif /* !ACE_HAS_WCHAR || ACE_LACKS_WCSNCPY */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSNICMP)
|
|
int
|
|
ACE_OS::wcsnicmp_emulation (const wchar_t *s,
|
|
const wchar_t *t,
|
|
size_t len)
|
|
{
|
|
const wchar_t *scan1 = s;
|
|
const wchar_t *scan2 = t;
|
|
size_t count = 0;
|
|
|
|
while (count++ < len
|
|
&& *scan1 != 0
|
|
&& ACE_OS::ace_towlower (*scan1)
|
|
== ACE_OS::ace_towlower (*scan2))
|
|
{
|
|
++scan1;
|
|
++scan2;
|
|
}
|
|
|
|
if (count > len)
|
|
return 0;
|
|
|
|
// The following case analysis is necessary so that characters which
|
|
// look negative collate low against normal characters but high
|
|
// against the end-of-string NUL.
|
|
|
|
if (*scan1 == '\0' && *scan2 == '\0')
|
|
return 0;
|
|
else if (*scan1 == '\0')
|
|
return -1;
|
|
else if (*scan2 == '\0')
|
|
return 1;
|
|
else
|
|
return ACE_OS::ace_towlower (*scan1) - ACE_OS::ace_towlower (*scan2);
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSNICMP */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSPBRK)
|
|
wchar_t *
|
|
ACE_OS::wcspbrk_emulation (const wchar_t *string,
|
|
const wchar_t *charset)
|
|
{
|
|
const wchar_t *scanp = 0;
|
|
int c, sc;
|
|
|
|
while ((c = *string++) != 0)
|
|
{
|
|
for (scanp = charset; (sc = *scanp++) != 0;)
|
|
if (sc == c)
|
|
return const_cast<wchar_t *> (string - 1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSPBRK */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSRCHR)
|
|
const wchar_t *
|
|
ACE_OS::wcsrchr_emulation (const wchar_t *s, wint_t c)
|
|
{
|
|
const wchar_t *p = s + ACE_OS::strlen (s);
|
|
|
|
while (*p != static_cast<wchar_t> (c))
|
|
if (p == s)
|
|
return 0;
|
|
else
|
|
p--;
|
|
|
|
return p;
|
|
}
|
|
|
|
wchar_t *
|
|
ACE_OS::wcsrchr_emulation (wchar_t *s, wint_t c)
|
|
{
|
|
wchar_t *p = s + ACE_OS::strlen (s);
|
|
|
|
while (*p != static_cast<wchar_t> (c))
|
|
if (p == s)
|
|
return 0;
|
|
else
|
|
p--;
|
|
|
|
return p;
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSRCHR */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSSPN)
|
|
size_t
|
|
ACE_OS::wcsspn_emulation (const wchar_t *string,
|
|
const wchar_t *charset)
|
|
{
|
|
const wchar_t *p = string;
|
|
const wchar_t *spanp = 0;
|
|
wchar_t c, sc;
|
|
|
|
// Skip any characters in charset, excluding the terminating \0.
|
|
cont:
|
|
c = *p++;
|
|
for (spanp = charset; (sc = *spanp++) != 0;)
|
|
if (sc == c)
|
|
goto cont;
|
|
return (p - 1 - string);
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSSPN */
|
|
|
|
#if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSSTR)
|
|
wchar_t *
|
|
ACE_OS::wcsstr_emulation (const wchar_t *string,
|
|
const wchar_t *charset)
|
|
{
|
|
wchar_t c, sc;
|
|
size_t len;
|
|
|
|
if ((c = *charset++) != 0)
|
|
{
|
|
len = ACE_OS::strlen (charset);
|
|
do
|
|
{
|
|
do
|
|
{
|
|
if ((sc = *string++) == 0)
|
|
return 0;
|
|
} while (sc != c);
|
|
} while (ACE_OS::strncmp (string, charset, len) != 0);
|
|
string--;
|
|
}
|
|
|
|
return const_cast<wchar_t *> (string);
|
|
}
|
|
#endif /* ACE_HAS_WCHAR && ACE_LACKS_WCSSTR */
|
|
|
|
ACE_END_VERSIONED_NAMESPACE_DECL
|