/*
* stress_wcscoll()
* stress on wcscoll
*/
static void stress_wcscoll(
const char *name,
wchar_t *str1,
const size_t len1,
wchar_t *str2,
const size_t len2)
{
register size_t i;
(void)len2;
for (i = 1; i < len1; i++) {
WCSCHK(name, 0 == wcscoll(str1, str1));
WCSCHK(name, 0 == wcscoll(str2, str2));
WCSCHK(name, 0 != wcscoll(str2, str1));
WCSCHK(name, 0 != wcscoll(str1, str2));
WCSCHK(name, 0 != wcscoll(str1 + i, str1));
WCSCHK(name, 0 != wcscoll(str1, str1 + i));
WCSCHK(name, 0 == wcscoll(str1 + i, str1 + i));
WCSCHK(name, 0 != wcscoll(str1 + i, str2));
WCSCHK(name, 0 != wcscoll(str2, str1 + i));
}
}
/*
* Compare two wide-character strings
*/
static int
wide_str_coll(const wchar_t *s1, const wchar_t *s2)
{
int ret = 0;
errno = 0;
ret = wcscoll(s1, s2);
if (errno == EILSEQ) {
errno = 0;
ret = wcscmp(s1, s2);
if (errno != 0) {
for (size_t i = 0; ; ++i) {
wchar_t c1 = s1[i];
wchar_t c2 = s2[i];
if (c1 == L'\0')
return ((c2 == L'\0') ? 0 : -1);
if (c2 == L'\0')
return (+1);
if (c1 == c2)
continue;
return ((int)(c1 - c2));
}
}
}
return (ret);
}
int word_list_add(struct word_list *list, const wchar_t *word) {
struct word_list *l2 = list;
struct word_list *flunkey;
struct word_list *new_word_list;
int compare;
flunkey = list;
l2 = list->next;
while (l2 != NULL) {
compare = wcscoll(l2->word, word);
if (compare < 0) {
l2 = l2->next;
flunkey = flunkey->next;
}
else if (compare > 0) {
new_word_list = malloc(sizeof(word_list));
wcscpy(new_word_list->word, word);
new_word_list->next = l2;
flunkey->next = new_word_list;
return 1;
}
else {
return 0;
}
}
new_word_list = malloc(sizeof(word_list));
wcscpy(new_word_list->word, word);
new_word_list->next = NULL;
flunkey->next = new_word_list;
return 1;
}
static TACommandVerdict wcscoll_cmd(TAThread thread, TAInputStream stream)
{
wchar_t* ws1;
wchar_t* ws2;
int res;
int save_errno;
// Prepare
ws1 = ta_wcsalign(readWString(&stream)); //align on copy
ws2 = ta_wcsalign(readWString(&stream)); //align on copy
START_TARGET_OPERATION(thread);
// Execute
errno = 0;
res = wcscoll(ws1, ws2);
save_errno = errno;
END_TARGET_OPERATION(thread);
// Response
writeInt(thread, res);
writeInt(thread, save_errno);
sendResponse(thread);
ta_dealloc_memory(ws1);
ta_dealloc_memory(ws2);
return taDefaultVerdict;
}
static int
collate_range_cmp(wchar_t c1, wchar_t c2)
{
static wchar_t s1[2], s2[2];
s1[0] = c1;
s2[0] = c2;
return (wcscoll(s1, s2));
}
int CUnicodeString::Collate(LPCSTR lpsz)
{
ASSERT(IsValidString(lpsz));
DWORD dwszLen = strlen(lpsz);
LPWSTR lpwsz = (LPWSTR)malloc((dwszLen + 1) * sizeof(WCHAR));
lpwsz[dwszLen] = L'\0';
MultiByteToWideChar(CP_ACP, 0, lpsz, dwszLen, lpwsz, dwszLen);
int iRet = wcscoll(m_Buffer, lpwsz);
free(lpwsz);
return iRet;
}
int
wcsicoll(const wchar_t *s1, const wchar_t *s2)
{
wchar_t *p, line1[MAXLINELEN], line2[MAXLINELEN];
for (p = line1; *s1; s1++)
*p++ = towlower(*s1);
*p = '\0';
for (p = line2; *s2; s2++)
*p++ = towlower(*s2);
*p = '\0';
return (wcscoll(line1, line2));
}
int
globcharcoll(__Char c1, __Char c2, int cs)
{
#if defined(NLS) && defined(LC_COLLATE) && defined(HAVE_STRCOLL)
# if defined(WIDE_STRINGS)
wchar_t s1[2], s2[2];
if (c1 == c2)
return (0);
if (cs) {
c1 = towlower(c1);
c2 = towlower(c2);
} else {
/* This should not be here, but I'll rather leave it in than engage in
a LC_COLLATE flamewar about a shell I don't use... */
if (iswlower(c1) && iswupper(c2))
return (1);
if (iswupper(c1) && iswlower(c2))
return (-1);
}
s1[0] = c1;
s2[0] = c2;
s1[1] = s2[1] = '\0';
return wcscoll(s1, s2);
# else /* not WIDE_STRINGS */
char s1[2], s2[2];
if (c1 == c2)
return (0);
/*
* From kevin lyda <*****@*****.**>:
* strcoll does not guarantee case sorting, so we pre-process now:
*/
if (cs) {
c1 = islower(c1) ? c1 : tolower(c1);
c2 = islower(c2) ? c2 : tolower(c2);
} else {
if (islower(c1) && isupper(c2))
return (1);
if (isupper(c1) && islower(c2))
return (-1);
}
s1[0] = c1;
s2[0] = c2;
s1[1] = s2[1] = '\0';
return strcoll(s1, s2);
# endif
#else
return (c1 - c2);
#endif
}
static int
int_mbscoll(const char *s1, const char *s2, int icase)
{ size_t l1 = strlen(s1);
size_t l2 = strlen(s2);
wchar_t *w1;
wchar_t *w2;
int ml1, ml2;
mbstate_t mbs;
int rc;
#if HAVE_ALLOCA
if ( l1 < 1024 && (w1 = alloca(sizeof(wchar_t)*(l1+1))) )
{ ml1 = FALSE;
} else
#endif
{ w1 = PL_malloc_atomic(sizeof(wchar_t)*(l1+1));
ml1 = TRUE;
}
#if HAVE_ALLOCA
if ( l2 < 1024 && (w2 = alloca(sizeof(wchar_t)*(l2+1))) )
{ ml2 = FALSE;
} else
#endif
{ w2 = PL_malloc_atomic(sizeof(wchar_t)*(l2+1));
ml2 = TRUE;
}
memset(&mbs, 0, sizeof(mbs));
if ( mbsrtowcs(w1, &s1, l1+1, &mbs) == (size_t)-1 )
{ rc = -2;
goto out;
}
if ( mbsrtowcs(w2, &s2, l2+1, &mbs) == (size_t)-1 )
{ rc = 2;
goto out;
}
if ( icase )
{ wstolower(w1, l1);
wstolower(w2, l2);
}
rc = wcscoll(w1, w2);
out:
if ( ml1 ) PL_free(w1);
if ( ml2 ) PL_free(w2);
return rc;
}
static int
mbscoll(const char *s1, const char *s2)
{
wchar_t *w1, *w2;
int ret;
if (MB_CUR_MAX == 1)
return (strcoll(s1, s2));
if ((w1 = towcs(s1)) == NULL || (w2 = towcs(s2)) == NULL)
err(1, NULL); /* XXX */
ret = wcscoll(w1, w2);
free(w1);
free(w2);
return (ret);
}
static int32_t
collate_range_cmp(char32_t c1, char32_t c2)
{
typedef union _nulltermchar {
uint64_t force8;
char32_t char32[2];
wchar_t wchar[sizeof(uint64_t)/sizeof(wchar_t)];
} _nulltermchar_t;
_nulltermchar_t s1;
_nulltermchar_t s2;
s1.force8 = c1;
s2.force8 = c2;
return (wcscoll(s1.wchar, s2.wchar));
}
void *wstaw_wierzcholek(struct wierzcholek *w,wchar_t *s){
int wynik_porownania;
if (w==NULL){
w=nowy_wierzcholek(s);
}
else if((wynik_porownania = wcscoll(s,w->slowo)==0)){
w->liczba_wystapien++;
}
else if(wynik_porownania<0){
w->lewe_poddrzewo = wstaw_wierzcholek(w->lewe_poddrzewo,s);
}
else{
w->prawe_poddrzewo = wstaw_wierzcholek(w->prawe_poddrzewo,s);
}
return w;
}
int main()
{
wchar_t *samples[ ] = { L"anejo", L"añeja",};
setlocale( LC_COLLATE, "es_US.UTF-8" );
int result = wcscoll( samples[0], samples[1] );
wprintf( L"In the locale %s, ", setlocale( LC_COLLATE, NULL ));
if ( result == 0 )
wprintf( L"the wide strings \"%ls\" and \"%ls\" are alphabetically "
"equivalent.\n", samples[0], samples[1] );
else if ( result < 0 )
wprintf( L"the wide string \"%ls\" precedes \"%ls\" "
"alphabetically.\n", samples[0], samples[1] );
else if ( result > 0 )
wprintf( L"the wide string \"%ls\" comes after \"%ls\" "
"alphabetically.\n", samples[0], samples[1] );
return 0;
}
static PyObject*
PyLocale_strcoll(PyObject* self, PyObject* args)
{
PyObject *os1, *os2, *result = NULL;
wchar_t *ws1 = NULL, *ws2 = NULL;
if (!PyArg_ParseTuple(args, "UU:strcoll", &os1, &os2))
return NULL;
/* Convert the unicode strings to wchar[]. */
ws1 = PyUnicode_AsWideCharString(os1, NULL);
if (ws1 == NULL)
goto done;
ws2 = PyUnicode_AsWideCharString(os2, NULL);
if (ws2 == NULL)
goto done;
/* Collate the strings. */
result = PyLong_FromLong(wcscoll(ws1, ws2));
done:
/* Deallocate everything. */
if (ws1) PyMem_FREE(ws1);
if (ws2) PyMem_FREE(ws2);
return result;
}
static PyObject*
PyLocale_strcoll(PyObject* self, PyObject* args)
{
PyObject *os1, *os2, *result = NULL;
wchar_t *ws1 = NULL, *ws2 = NULL;
Py_ssize_t len1, len2;
if (!PyArg_ParseTuple(args, "UU:strcoll", &os1, &os2))
return NULL;
/* Convert the unicode strings to wchar[]. */
len1 = PyUnicode_GET_SIZE(os1) + 1;
ws1 = PyMem_MALLOC(len1 * sizeof(wchar_t));
if (!ws1) {
PyErr_NoMemory();
goto done;
}
if (PyUnicode_AsWideChar((PyUnicodeObject*)os1, ws1, len1) == -1)
goto done;
ws1[len1 - 1] = 0;
len2 = PyUnicode_GET_SIZE(os2) + 1;
ws2 = PyMem_MALLOC(len2 * sizeof(wchar_t));
if (!ws2) {
PyErr_NoMemory();
goto done;
}
if (PyUnicode_AsWideChar((PyUnicodeObject*)os2, ws2, len2) == -1)
goto done;
ws2[len2 - 1] = 0;
/* Collate the strings. */
result = PyLong_FromLong(wcscoll(ws1, ws2));
done:
/* Deallocate everything. */
if (ws1) PyMem_FREE(ws1);
if (ws2) PyMem_FREE(ws2);
return result;
}
gcc_pure gcc_nonnull_all
static inline int
StringCollate(const wchar_t *a, const wchar_t *b)
{
return wcscoll(a, b);
}
int CCOMStringW::Collate(CCOMStringW &str) const
{
ATLASSERT((const WCHAR* ) str != NULL);
ATLASSERT(::IsBadStringPtrW((const WCHAR* ) str, -1) == 0);
return wcscoll(m_pszString, (const WCHAR* ) str);
}
int CUnicodeString::Collate(LPCWSTR lpsz)
{
ASSERT(IsValidString(lpsz));
return wcscoll(m_Buffer, lpsz);
}
int CCOMStringW::Collate(const WCHAR* lpsz) const
{
ATLASSERT(lpsz != NULL);
ATLASSERT(::IsBadStringPtrW(lpsz, -1) == 0);
return wcscoll(m_pszString, lpsz);
}
int __wcscoll_l(const wchar_t *l, const wchar_t *r, locale_t locale)
{
return wcscoll(l, r);
}
/**
Testuje dictionary_hints_word_without_ignores
@param[in,out] state Środowisko
*/
static void dictionary_hints_word_without_ignores_test(void **state)
{
(void)state;
assert_int_equal(wcscoll(L"abc", dictionary_hints_word_without_ignores(L"^a^b^c^")), 0);
assert_int_equal(wcscoll(L"", dictionary_hints_word_without_ignores(L"^^^")), 0);
}
int
main(int argc, char *argv[])
{
int comp, file1done = 0, file2done = 0, read1, read2;
int ch, flag1, flag2, flag3, iflag;
FILE *fp1, *fp2;
const wchar_t *col1, *col2, *col3;
wchar_t line1[MAXLINELEN], line2[MAXLINELEN];
const wchar_t **p;
flag1 = flag2 = flag3 = 1;
iflag = 0;
(void) setlocale(LC_ALL, "");
while ((ch = getopt(argc, argv, "123i")) != -1)
switch(ch) {
case '1':
flag1 = 0;
break;
case '2':
flag2 = 0;
break;
case '3':
flag3 = 0;
break;
case 'i':
iflag = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2 || !argv[0] || !argv[1])
usage();
fp1 = file(argv[0]);
fp2 = file(argv[1]);
/* for each column printed, add another tab offset */
p = tabs;
col1 = col2 = col3 = NULL;
if (flag1)
col1 = *p++;
if (flag2)
col2 = *p++;
if (flag3)
col3 = *p;
for (read1 = read2 = 1;;) {
/* read next line, check for EOF */
if (read1) {
file1done = !fgetws(line1, MAXLINELEN, fp1);
if (file1done && ferror(fp1))
err(1, "%s", argv[0]);
}
if (read2) {
file2done = !fgetws(line2, MAXLINELEN, fp2);
if (file2done && ferror(fp2))
err(1, "%s", argv[1]);
}
/* if one file done, display the rest of the other file */
if (file1done) {
if (!file2done && col2)
show(fp2, argv[1], col2, line2);
break;
}
if (file2done) {
if (!file1done && col1)
show(fp1, argv[0], col1, line1);
break;
}
/* lines are the same */
if(iflag)
comp = wcsicoll(line1, line2);
else
comp = wcscoll(line1, line2);
if (!comp) {
read1 = read2 = 1;
if (col3)
(void)printf("%ls%ls", col3, line1);
continue;
}
/* lines are different */
if (comp < 0) {
read1 = 1;
read2 = 0;
if (col1)
(void)printf("%ls%ls", col1, line1);
} else {
read1 = 0;
read2 = 1;
if (col2)
(void)printf("%ls%ls", col2, line2);
}
}
exit(0);
}
static PyObject*
PyLocale_strcoll(PyObject* self, PyObject* args)
{
#if !defined(HAVE_WCSCOLL) || !defined(Py_USING_UNICODE)
char *s1,*s2;
if (!PyArg_ParseTuple(args, "ss:strcoll", &s1, &s2))
return NULL;
return PyInt_FromLong(strcoll(s1, s2));
#else
PyObject *os1, *os2, *result = NULL;
wchar_t *ws1 = NULL, *ws2 = NULL;
int rel1 = 0, rel2 = 0, len1, len2;
if (!PyArg_ParseTuple(args, "OO:strcoll", &os1, &os2))
return NULL;
/* If both arguments are byte strings, use strcoll. */
if (PyString_Check(os1) && PyString_Check(os2))
return PyInt_FromLong(strcoll(PyString_AS_STRING(os1),
PyString_AS_STRING(os2)));
/* If neither argument is unicode, it's an error. */
if (!PyUnicode_Check(os1) && !PyUnicode_Check(os2)) {
PyErr_SetString(PyExc_ValueError, "strcoll arguments must be strings");
}
/* Convert the non-unicode argument to unicode. */
if (!PyUnicode_Check(os1)) {
os1 = PyUnicode_FromObject(os1);
if (!os1)
return NULL;
rel1 = 1;
}
if (!PyUnicode_Check(os2)) {
os2 = PyUnicode_FromObject(os2);
if (!os2) {
Py_DECREF(os1);
return NULL;
}
rel2 = 1;
}
/* Convert the unicode strings to wchar[]. */
len1 = PyUnicode_GET_SIZE(os1) + 1;
ws1 = PyMem_MALLOC(len1 * sizeof(wchar_t));
if (!ws1) {
PyErr_NoMemory();
goto done;
}
if (PyUnicode_AsWideChar((PyUnicodeObject*)os1, ws1, len1) == -1)
goto done;
ws1[len1 - 1] = 0;
len2 = PyUnicode_GET_SIZE(os2) + 1;
ws2 = PyMem_MALLOC(len2 * sizeof(wchar_t));
if (!ws2) {
PyErr_NoMemory();
goto done;
}
if (PyUnicode_AsWideChar((PyUnicodeObject*)os2, ws2, len2) == -1)
goto done;
ws2[len2 - 1] = 0;
/* Collate the strings. */
result = PyInt_FromLong(wcscoll(ws1, ws2));
done:
/* Deallocate everything. */
if (ws1) PyMem_FREE(ws1);
if (ws2) PyMem_FREE(ws2);
if (rel1) {
Py_DECREF(os1);
}
if (rel2) {
Py_DECREF(os2);
}
return result;
#endif
}
int
main(int argc, char *argv[])
{
int comp, read1, read2;
int ch, flag1, flag2, flag3;
FILE *fp1, *fp2;
const char *col1, *col2, *col3;
size_t line1len, line2len;
char *line1, *line2;
ssize_t n1, n2;
wchar_t *tline1, *tline2;
const char **p;
(void) setlocale(LC_ALL, "");
flag1 = flag2 = flag3 = 1;
while ((ch = getopt(argc, argv, "123i")) != -1)
switch(ch) {
case '1':
flag1 = 0;
break;
case '2':
flag2 = 0;
break;
case '3':
flag3 = 0;
break;
case 'i':
iflag = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
fp1 = file(argv[0]);
fp2 = file(argv[1]);
/* for each column printed, add another tab offset */
p = tabs;
col1 = col2 = col3 = NULL;
if (flag1)
col1 = *p++;
if (flag2)
col2 = *p++;
if (flag3)
col3 = *p;
line1len = line2len = 0;
line1 = line2 = NULL;
n1 = n2 = -1;
for (read1 = read2 = 1;;) {
/* read next line, check for EOF */
if (read1) {
n1 = getline(&line1, &line1len, fp1);
if (n1 < 0 && ferror(fp1))
err(1, "%s", argv[0]);
if (n1 > 0 && line1[n1 - 1] == '\n')
line1[n1 - 1] = '\0';
}
if (read2) {
n2 = getline(&line2, &line2len, fp2);
if (n2 < 0 && ferror(fp2))
err(1, "%s", argv[1]);
if (n2 > 0 && line2[n2 - 1] == '\n')
line2[n2 - 1] = '\0';
}
/* if one file done, display the rest of the other file */
if (n1 < 0) {
if (n2 >= 0 && col2 != NULL)
show(fp2, argv[1], col2, &line2, &line2len);
break;
}
if (n2 < 0) {
if (n1 >= 0 && col1 != NULL)
show(fp1, argv[0], col1, &line1, &line1len);
break;
}
tline2 = NULL;
if ((tline1 = convert(line1)) != NULL)
tline2 = convert(line2);
if (tline1 == NULL || tline2 == NULL)
comp = strcmp(line1, line2);
else
comp = wcscoll(tline1, tline2);
if (tline1 != NULL)
free(tline1);
if (tline2 != NULL)
free(tline2);
/* lines are the same */
if (!comp) {
read1 = read2 = 1;
if (col3 != NULL)
(void)printf("%s%s\n", col3, line1);
continue;
}
/* lines are different */
if (comp < 0) {
read1 = 1;
read2 = 0;
if (col1 != NULL)
(void)printf("%s%s\n", col1, line1);
} else {
read1 = 0;
read2 = 1;
if (col2 != NULL)
(void)printf("%s%s\n", col2, line2);
}
}
exit(0);
}
/**
* Porównuje dwa stringi wchar_t zgodnie z zadanymi locale.
* @return true wtw. argumenty są uporządkowane.
* @param [in] l Pierwsza wartość.
* @param [in] r Druga wartość.
*/
static
bool are_ordered(const wchar_t * const l, const wchar_t * const r)
{
return wcscoll(l, r) <= 0;
}
int
main (int argc, char *argv[])
{
wchar_t *tprev, *tthis;
FILE *ifp, *ofp;
int ch, comp;
size_t prevbuflen, thisbuflen, b1;
char *prevline, *thisline, *p;
const char *ifn;
cap_rights_t rights;
(void) setlocale(LC_ALL, "");
obsolete(argv);
while ((ch = getopt(argc, argv, "cdif:s:u")) != -1)
switch (ch) {
case 'c':
cflag = 1;
break;
case 'd':
dflag = 1;
break;
case 'i':
iflag = 1;
break;
case 'f':
numfields = strtol(optarg, &p, 10);
if (numfields < 0 || *p)
errx(1, "illegal field skip value: %s", optarg);
break;
case 's':
numchars = strtol(optarg, &p, 10);
if (numchars < 0 || *p)
errx(1, "illegal character skip value: %s", optarg);
break;
case 'u':
uflag = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
/* If no flags are set, default is -d -u. */
if (cflag) {
if (dflag || uflag)
usage();
} else if (!dflag && !uflag)
dflag = uflag = 1;
if (argc > 2)
usage();
ifp = stdin;
ifn = "stdin";
ofp = stdout;
if (argc > 0 && strcmp(argv[0], "-") != 0)
ifp = file(ifn = argv[0], "r");
cap_rights_init(&rights, CAP_FSTAT, CAP_READ);
if (cap_rights_limit(fileno(ifp), &rights) < 0 && errno != ENOSYS)
err(1, "unable to limit rights for %s", ifn);
cap_rights_init(&rights, CAP_FSTAT, CAP_WRITE);
if (argc > 1)
ofp = file(argv[1], "w");
else
cap_rights_set(&rights, CAP_IOCTL);
if (cap_rights_limit(fileno(ofp), &rights) < 0 && errno != ENOSYS) {
err(1, "unable to limit rights for %s",
argc > 1 ? argv[1] : "stdout");
}
if (cap_rights_is_set(&rights, CAP_IOCTL)) {
unsigned long cmd;
cmd = TIOCGETA; /* required by isatty(3) in printf(3) */
if (cap_ioctls_limit(fileno(ofp), &cmd, 1) < 0 &&
errno != ENOSYS) {
err(1, "unable to limit ioctls for %s",
argc > 1 ? argv[1] : "stdout");
}
}
strerror_init();
if (cap_enter() < 0 && errno != ENOSYS)
err(1, "unable to enter capability mode");
prevbuflen = thisbuflen = 0;
prevline = thisline = NULL;
if (getline(&prevline, &prevbuflen, ifp) < 0) {
if (ferror(ifp))
err(1, "%s", ifn);
exit(0);
}
tprev = convert(prevline);
if (!cflag && uflag && dflag)
show(ofp, prevline);
tthis = NULL;
while (getline(&thisline, &thisbuflen, ifp) >= 0) {
if (tthis != NULL)
free(tthis);
tthis = convert(thisline);
if (tthis == NULL && tprev == NULL)
comp = inlcmp(thisline, prevline);
else if (tthis == NULL || tprev == NULL)
comp = 1;
else
comp = wcscoll(tthis, tprev);
if (comp) {
/* If different, print; set previous to new value. */
if (cflag || !dflag || !uflag)
show(ofp, prevline);
p = prevline;
b1 = prevbuflen;
prevline = thisline;
prevbuflen = thisbuflen;
if (tprev != NULL)
free(tprev);
tprev = tthis;
if (!cflag && uflag && dflag)
show(ofp, prevline);
thisline = p;
thisbuflen = b1;
tthis = NULL;
repeats = 0;
} else
++repeats;
}
if (ferror(ifp))
err(1, "%s", ifn);
if (cflag || !dflag || !uflag)
show(ofp, prevline);
exit(0);
}
static int
posix_compare(NODE *s1, NODE *s2)
{
int ret = 0;
char save1, save2;
size_t l = 0;
save1 = s1->stptr[s1->stlen];
s1->stptr[s1->stlen] = '\0';
save2 = s2->stptr[s2->stlen];
s2->stptr[s2->stlen] = '\0';
if (gawk_mb_cur_max == 1) {
if (strlen(s1->stptr) == s1->stlen && strlen(s2->stptr) == s2->stlen)
ret = strcoll(s1->stptr, s2->stptr);
else {
char b1[2], b2[2];
char *p1, *p2;
size_t i;
if (s1->stlen < s2->stlen)
l = s1->stlen;
else
l = s2->stlen;
b1[1] = b2[1] = '\0';
for (i = ret = 0, p1 = s1->stptr, p2 = s2->stptr;
ret == 0 && i < l;
p1++, p2++) {
b1[0] = *p1;
b2[0] = *p2;
ret = strcoll(b1, b2);
}
}
/*
* Either worked through the strings or ret != 0.
* In either case, ret will be the right thing to return.
*/
}
#if MBS_SUPPORT
else {
/* Similar logic, using wide characters */
(void) force_wstring(s1);
(void) force_wstring(s2);
if (wcslen(s1->wstptr) == s1->wstlen && wcslen(s2->wstptr) == s2->wstlen)
ret = wcscoll(s1->wstptr, s2->wstptr);
else {
wchar_t b1[2], b2[2];
wchar_t *p1, *p2;
size_t i;
if (s1->wstlen < s2->wstlen)
l = s1->wstlen;
else
l = s2->wstlen;
b1[1] = b2[1] = L'\0';
for (i = ret = 0, p1 = s1->wstptr, p2 = s2->wstptr;
ret == 0 && i < l;
p1++, p2++) {
b1[0] = *p1;
b2[0] = *p2;
ret = wcscoll(b1, b2);
}
}
/*
* Either worked through the strings or ret != 0.
* In either case, ret will be the right thing to return.
*/
}
#endif
s1->stptr[s1->stlen] = save1;
s2->stptr[s2->stlen] = save2;
return ret;
}
int main()
{
mbstate_t mb = {0};
size_t s = 0;
tm tm = {0};
wint_t w = 0;
::FILE* fp = 0;
__darwin_va_list va;
char* ns = 0;
wchar_t* ws = 0;
static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), "");
static_assert((std::is_same<decltype(swscanf(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(vfwprintf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vfwscanf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswprintf(ws, s, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswscanf(L"", L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vwscanf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(wprintf(L"")), int>::value), "");
static_assert((std::is_same<decltype(wscanf(L"")), int>::value), "");
static_assert((std::is_same<decltype(fgetwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fgetws(ws, 0, fp)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(fputwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fputws(L"", fp)), int>::value), "");
static_assert((std::is_same<decltype(fwide(fp, 0)), int>::value), "");
static_assert((std::is_same<decltype(getwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(getwchar()), wint_t>::value), "");
static_assert((std::is_same<decltype(putwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(putwchar(L' ')), wint_t>::value), "");
static_assert((std::is_same<decltype(ungetwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(wcstod(L"", (wchar_t**)0)), double>::value), "");
static_assert((std::is_same<decltype(wcstof(L"", (wchar_t**)0)), float>::value), "");
static_assert((std::is_same<decltype(wcstold(L"", (wchar_t**)0)), long double>::value), "");
static_assert((std::is_same<decltype(wcstol(L"", (wchar_t**)0, 0)), long>::value), "");
static_assert((std::is_same<decltype(wcstoll(L"", (wchar_t**)0, 0)), long long>::value), "");
static_assert((std::is_same<decltype(wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), "");
static_assert((std::is_same<decltype(wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), "");
static_assert((std::is_same<decltype(wcscpy(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscat(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncat(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscmp(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), "");
static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemmove(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemset(ws, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsftime(ws, s, L"", &tm)), size_t>::value), "");
static_assert((std::is_same<decltype(btowc(0)), wint_t>::value), "");
static_assert((std::is_same<decltype(wctob(w)), int>::value), "");
static_assert((std::is_same<decltype(mbsinit(&mb)), int>::value), "");
static_assert((std::is_same<decltype(mbrlen("", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbrtowc(ws, "", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcrtomb(ns, L' ', &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), "");
}
/*
* @implemented
*/
int CHString::Collate(LPCWSTR lpsz) const
{
// Just call the deprecated function here - no matter we are null terminated
// Did you read my statement about how safe is this implementation?
return wcscoll(m_pchData, lpsz);
}
int wcscoll_l(const wchar_t *ws1, const wchar_t *ws2, locale_t) {
return wcscoll(ws1, ws2);
}
