| /*************************************************************************** |
| * |
| * 22.locale.ctype.cpp - Tests exercising the ctype facet |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 2001-2006 Rogue Wave Software. |
| * |
| **************************************************************************/ |
| |
| // DESCRIPTION: test iterates over the locales installed on a machine, |
| // calling the C character classification functions and |
| // their C++ counterpart(s), comparing the results of |
| // the calls against one another. |
| |
| |
| #include <rw/_defs.h> |
| |
| #if defined __linux__ |
| // on Linux define _XOPEN_SOURCE to get CODESET defined in <langinfo.h> |
| # define _XOPEN_SOURCE 500 /* Single Unix conformance */ |
| // bring __int32_t into scope (otherwise <wctype.h> fails to compile) |
| # include <sys/types.h> |
| #endif // __linux__ |
| |
| // see Onyx PR #28150 |
| #if defined (__SUNPRO_CC) && __SUNPRO_CC <= 0x540 |
| # include <wchar.h> |
| #endif // defined (__SUNPRO_CC) && __SUNPRO_CC <= 0x540 |
| |
| #include <locale> |
| |
| #include <climits> |
| #include <clocale> |
| #include <cstring> |
| #include <cctype> |
| #include <cstdio> |
| #include <cstdlib> |
| #include <cwchar> // for WEOF, btowc(), wctob() |
| #include <cwctype> // for iswxxx() |
| |
| |
| #if !defined (_MSC_VER) |
| # if !defined (LC_MESSAGES) |
| # define LC_MESSAGES _RWSTD_LC_MESSAGES |
| # endif // LC_MESSAGES |
| # include <langinfo.h> |
| #endif // _MSC_VER |
| |
| #include <driver.h> |
| #include <file.h> // for SLASH |
| #include <rw_locale.h> // for rw_locales() |
| |
| /**************************************************************************/ |
| |
| // the root of the locale directory (RWSTD_LOCALE_ROOT) |
| // not set here to avoid Solaris 7 putenv() bug (PR #30017) |
| const char* locale_root; |
| |
| #define NLOOPS 25 |
| #define MAX_STR_SIZE 16 |
| |
| #define BEGIN_LOCALE_LOOP(num, locname, loop_cntrl) \ |
| for (const char* locname = rw_locales (LC_CTYPE, 0); \ |
| locname && *locname; locname += std::strlen (locname) + 1) { \ |
| _TRY { \ |
| const std::locale loc (locname); \ |
| const std::ctype<char> &ctc = \ |
| _STD_USE_FACET (std::ctype<char>, loc); \ |
| _RWSTD_UNUSED (ctc); \ |
| const std::ctype<charT> &ctp = \ |
| _STD_USE_FACET (std::ctype<charT>, loc); \ |
| for (int loop_cntrl = 0; loop_cntrl < int (num); loop_cntrl++) |
| |
| #define END_LOCALE_LOOP(locname) \ |
| } \ |
| _CATCH (...) { \ |
| rw_assert (0, 0, __LINE__, \ |
| "locale (\"%s\") threw an exception", locname); \ |
| } \ |
| } |
| |
| |
| // for notational convenience |
| typedef unsigned char UChar; |
| |
| #define ALPHA std::ctype_base::alpha |
| #define UPPER std::ctype_base::upper |
| #define LOWER std::ctype_base::lower |
| #define DIGIT std::ctype_base::digit |
| #define SPACE std::ctype_base::space |
| #define CNTRL std::ctype_base::cntrl |
| #define PUNCT std::ctype_base::punct |
| #define XDIGIT std::ctype_base::xdigit |
| #define GRAPH std::ctype_base::graph |
| #define PRINT std::ctype_base::print |
| |
| |
| // wrapper functions for the c library char and wchar_t functions |
| int libc_isalpha (char ch) |
| { |
| return (std::isalpha)(UChar (ch)); |
| } |
| |
| int libc_isspace (char ch) |
| { |
| return (std::isspace)(UChar (ch)); |
| } |
| |
| int libc_isprint (char ch) |
| { |
| return (std::isprint)(UChar (ch)); |
| } |
| |
| int libc_iscntrl (char ch) |
| { |
| return (std::iscntrl)(UChar (ch)); |
| } |
| |
| int libc_isupper (char ch) |
| { |
| return (std::isupper)(UChar (ch)); |
| } |
| |
| int libc_islower (char ch) |
| { |
| return (std::islower)(UChar (ch)); |
| } |
| |
| int libc_isdigit (char ch) |
| { |
| return (std::isdigit)(UChar (ch)); |
| } |
| |
| int libc_ispunct (char ch) |
| { |
| return (std::ispunct)(UChar (ch)); |
| } |
| |
| int libc_isxdigit (char ch) |
| { |
| return (std::isxdigit)(UChar (ch)); |
| } |
| |
| int libc_isalnum (char ch) |
| { |
| return (std::isalnum)(UChar (ch)); |
| } |
| |
| int libc_isgraph (char ch) |
| { |
| return (std::isgraph)(UChar (ch)); |
| } |
| |
| char libc_tolower (char ch) |
| { |
| return std::tolower (UChar (ch)); |
| } |
| |
| char libc_toupper (char ch) |
| { |
| return (std::toupper)(UChar (ch)); |
| } |
| |
| std::ctype_base::mask libc_mask (int mask, char ch, const char *locname) |
| { |
| char curlocname [256]; |
| |
| if (locname) { |
| std::strcpy (curlocname, std::setlocale (LC_CTYPE, 0)); |
| |
| if (0 == std::setlocale (LC_CTYPE, locname)) |
| return std::ctype_base::mask (); |
| } |
| |
| const int c = UChar (ch); |
| |
| int result = 0; |
| |
| if (mask & ALPHA && (std::isalpha)(c)) |
| result |= ALPHA; |
| if (mask & CNTRL && (std::iscntrl)(c)) |
| result |= CNTRL; |
| if (mask & DIGIT && (std::isdigit)(c)) |
| result |= DIGIT; |
| if (mask & GRAPH && (std::isgraph)(c)) |
| result |= GRAPH; |
| if (mask & LOWER && (std::islower)(c)) |
| result |= LOWER; |
| if (mask & PRINT && (std::isprint)(c)) |
| result |= PRINT; |
| if (mask & PUNCT && (std::ispunct)(c)) |
| result |= PUNCT; |
| if (mask & SPACE && (std::isspace)(c)) |
| result |= SPACE; |
| if (mask & UPPER && (std::isupper)(c)) |
| result |= UPPER; |
| if (mask & XDIGIT && (std::isxdigit)(c)) |
| result |= XDIGIT; |
| |
| if (locname) |
| std::setlocale (LC_CTYPE, curlocname); |
| |
| return std::ctype_base::mask (result); |
| } |
| |
| inline bool libc_is (std::ctype_base::mask mask, char ch, const char *locname) |
| { |
| const std::ctype_base::mask m = libc_mask (mask, ch, locname); |
| |
| return 0 != (m & mask); |
| } |
| |
| std::size_t c_strlen (const char *s1) |
| { |
| return std::strlen (s1); |
| } |
| |
| int c_strcmp (const char *s1, const char *s2) |
| { |
| int ret = std::strcoll (s1, s2); |
| return ret ? ret > 0 ? 1 : -1 : 0; |
| } |
| |
| const char* narrow (char *dst, const char *src) |
| { |
| if (src == dst || !src || !dst) |
| return src; |
| |
| std::memcpy (dst, src, std::strlen (src) + 1); |
| return dst; |
| } |
| |
| |
| const char* widen (char *dst, const char *src) |
| { |
| if (src == dst || !src || !dst) |
| return src; |
| |
| std::memcpy (dst, src, std::strlen (src) + 1); |
| return dst; |
| } |
| |
| |
| char widen (char, char ch, const char*) |
| { |
| return ch; |
| } |
| |
| char narrow (char ch, const char*) |
| { |
| return ch; |
| } |
| |
| // cond1() verifies condition [1] in Test::test_narrow_widen() |
| // below using libc functions |
| bool cond1 (std::ctype_base::mask mask, char ch, const char *locname) |
| { |
| char curlocname [256]; |
| std::strcpy (curlocname, std::setlocale (LC_CTYPE, 0)); |
| |
| if (0 == std::setlocale (LC_CTYPE, locname)) |
| return false; |
| |
| #ifdef __SUNPRO_CC |
| |
| // working around a SunPro bug (PR #28150) |
| using std::wint_t; |
| |
| #endif // __SUNPRO_CC |
| |
| #ifndef _RWSTD_NO_BTOWC |
| |
| const std::wint_t wc = std::btowc (UChar (ch)); |
| |
| #elif !defined (_RWSTD_NO_MBSTOWCS) |
| |
| wchar_t tmp; |
| const std::wint_t wc = 1 == std::mbstowcs (&tmp, &ch, 1) ? tmp : WEOF; |
| |
| #else |
| |
| const std::wint_t wc = WEOF; |
| |
| #endif // _RWSTD_NO_BTOWC, _RWSTD_NO_MBSTOWCS |
| |
| const bool result = |
| WEOF == wc || libc_is (mask, ch, 0) || !libc_is (mask, wchar_t (wc), 0); |
| |
| std::setlocale (LC_CTYPE, curlocname); |
| |
| return result; |
| } |
| |
| |
| // cond3() overloads verify condition [3] in Test::test_narrow_widen() |
| // below using libc functions |
| bool cond3 (std::ctype_base::mask, char, const char*) |
| { |
| return true; |
| } |
| |
| |
| #ifndef _RWSTD_NO_WCHAR_T |
| |
| int libc_isalpha (wchar_t ch) |
| { |
| return (std::iswalpha)(ch); |
| } |
| |
| int libc_isspace (wchar_t ch) |
| { |
| return (std::iswspace)(ch); |
| } |
| |
| int libc_isprint (wchar_t ch) |
| { |
| return (std::iswprint)(ch); |
| } |
| |
| int libc_iscntrl (wchar_t ch) |
| { |
| return (std::iswcntrl)(ch); |
| } |
| |
| int libc_isupper (wchar_t ch) |
| { |
| return (std::iswupper)(ch); |
| } |
| |
| int libc_islower (wchar_t ch) |
| { |
| return (std::iswlower)(ch); |
| } |
| |
| int libc_isdigit (wchar_t ch) |
| { |
| return (std::iswdigit)(ch); |
| } |
| |
| int libc_ispunct (wchar_t ch) |
| { |
| return (std::iswpunct)(ch); |
| } |
| |
| int libc_isxdigit (wchar_t ch) |
| { |
| return (std::iswxdigit)(ch); |
| } |
| |
| int libc_isalnum (wchar_t ch) |
| { |
| return (std::iswalnum)(ch); |
| } |
| |
| int libc_isgraph (wchar_t ch) |
| { |
| return (std::iswgraph)(ch); |
| } |
| |
| wchar_t libc_tolower (wchar_t ch) |
| { |
| return (std::towlower)(ch); |
| } |
| |
| wchar_t libc_toupper (wchar_t ch) |
| { |
| return (std::towupper)(ch); |
| } |
| |
| std::size_t c_strlen (const wchar_t *s1) |
| { |
| return std::wcslen (s1); |
| } |
| |
| int c_strcmp (const wchar_t *s1, const wchar_t *s2) |
| { |
| int ret = std::wcscmp (s1, s2); |
| return ret ? ret > 0 ? 1 : -1 : 0; |
| } |
| |
| |
| const char* narrow (char *dst, const wchar_t *src) |
| { |
| static char buf [4096]; |
| |
| if (!src) |
| return 0; |
| |
| if (!dst) |
| dst = buf; |
| |
| std::size_t len = std::wcslen (src); |
| |
| _RWSTD_ASSERT (len < sizeof buf); |
| |
| len = std::wcstombs (dst, src, sizeof buf / sizeof *buf); |
| |
| if (std::size_t (-1) == len) |
| *dst = 0; |
| |
| return dst; |
| } |
| |
| |
| const wchar_t* widen (wchar_t *dst, const char *src) |
| { |
| static wchar_t buf [4096]; |
| |
| if (!src) |
| return 0; |
| |
| if (!dst) |
| dst = buf; |
| |
| std::size_t len = std::strlen (src); |
| |
| _RWSTD_ASSERT (len < sizeof buf /sizeof *buf); |
| |
| len = std::mbstowcs (dst, src, sizeof buf / sizeof *buf); |
| |
| if (std::size_t (-1) == len) |
| *dst = 0; |
| |
| return dst; |
| } |
| |
| std::ctype_base::mask libc_mask (int mask, wchar_t ch, const char *locname) |
| { |
| char curlocname [256]; |
| |
| if (locname) { |
| std::strcpy (curlocname, std::setlocale (LC_CTYPE, 0)); |
| |
| if (0 == std::setlocale (LC_CTYPE, locname)) |
| return std::ctype_base::mask (); |
| } |
| |
| int result = 0; |
| |
| if (mask & ALPHA && (std::iswalpha)(ch)) |
| result |= ALPHA; |
| if (mask & CNTRL && (std::iswcntrl)(ch)) |
| result |= CNTRL; |
| if (mask & DIGIT && (std::iswdigit)(ch)) |
| result |= DIGIT; |
| if (mask & GRAPH && (std::iswgraph)(ch)) |
| result |= GRAPH; |
| if (mask & LOWER && (std::iswlower)(ch)) |
| result |= LOWER; |
| if (mask & PRINT && (std::iswprint)(ch)) |
| result |= PRINT; |
| if (mask & PUNCT && (std::iswpunct)(ch)) |
| result |= PUNCT; |
| if (mask & SPACE && (std::iswspace)(ch)) |
| result |= SPACE; |
| if (mask & UPPER && (std::iswupper)(ch)) |
| result |= UPPER; |
| if (mask & XDIGIT && (std::iswxdigit)(ch)) |
| result |= XDIGIT; |
| |
| if (locname) |
| std::setlocale (LC_CTYPE, curlocname); |
| |
| return std::ctype_base::mask (result); |
| } |
| |
| bool libc_is (std::ctype_base::mask mask, wchar_t ch, const char *locname) |
| { |
| const std::ctype_base::mask m = libc_mask (mask, ch, locname); |
| |
| return 0 != (m & mask); |
| } |
| |
| wchar_t widen (wchar_t, char ch, const char *locname) |
| { |
| char curlocname [256]; |
| std::strcpy (curlocname, std::setlocale (LC_CTYPE, 0)); |
| |
| if (0 == std::setlocale (LC_CTYPE, locname)) |
| return UChar (ch); |
| |
| wchar_t result; |
| |
| #ifndef _RWSTD_NO_BTOWC |
| |
| result = std::btowc (UChar (ch)); |
| |
| #elif !defined (_RWSTD_NO_MBTOWC) |
| |
| if (1 != std::mbtowc (&result, &ch, 1)) |
| result = wchar_t (WEOF); |
| |
| #else |
| |
| result = UChar (ch); |
| |
| #endif // _RWSTD_NO_BTOWC, _RWSTD_NO_MBTOWC |
| |
| if (locname) |
| std::setlocale (LC_CTYPE, curlocname); |
| |
| return result; |
| } |
| |
| char narrow (wchar_t ch, const char *locname) |
| { |
| char curlocname [256]; |
| std::strcpy (curlocname, std::setlocale (LC_CTYPE, 0)); |
| |
| if (0 == std::setlocale (LC_CTYPE, locname)) |
| return UChar (ch); |
| |
| char result [MB_LEN_MAX]; |
| |
| #ifndef _RWSTD_NO_WCTOB |
| |
| result [0] = std::wctob (ch); |
| |
| #elif !defined (_RWSTD_NO_WCTOMB) |
| |
| if (1 != std::wctomb (result, ch)) |
| result [0] = '\377'; |
| |
| #else |
| |
| result [0] = char (ch); |
| |
| #endif // _RWSTD_NO_WCTOB, _RWSTD_NO_WCTOMB |
| |
| if (locname) |
| std::setlocale (LC_CTYPE, curlocname); |
| |
| return result [0]; |
| } |
| |
| bool cond3 (std::ctype_base::mask mask, wchar_t ch, const char *locname) |
| { |
| char curlocname [256]; |
| std::strcpy (curlocname, std::setlocale (LC_CTYPE, 0)); |
| |
| if (0 == std::setlocale (LC_CTYPE, locname)) |
| return false; |
| |
| #ifndef _RWSTD_NO_WCTOB |
| |
| const int byte = std::wctob (ch); |
| |
| #elif !defined (_RWSTD_NO_WCTOMB) |
| |
| char buf [MB_LEN_MAX]; |
| const int byte = 1 == std::wctomb (buf, ch) ? buf [0] : EOF; |
| |
| #else |
| |
| const int byte = EOF; |
| |
| #endif // _RWSTD_NO_WCTOB, _RWSTD_NO_WCTOMB |
| |
| const bool result = |
| EOF == byte || !libc_is (mask, char (byte), 0) || libc_is (mask, ch, 0); |
| |
| std::setlocale (LC_CTYPE, curlocname); |
| |
| return result; |
| } |
| |
| #endif // _RWSTD_NO_WCHAR_T |
| |
| |
| template <class charT> |
| void gen_str (charT *str, std::size_t size) |
| { |
| // generate a random string with the given size |
| // we do not attempt to check that the size is within the |
| // valid range for the string. |
| |
| for (std::size_t i = 0; i < size; i++){ |
| str [i] = UChar (std::rand () % UCHAR_MAX); |
| // only increment if we are not going to roll over |
| if (str [i] != charT (UCHAR_MAX - 1U)) |
| ++str [i]; |
| } |
| |
| str [size] = charT (); |
| |
| _RWSTD_ASSERT (c_strlen (str) == size); |
| } |
| |
| |
| |
| // The character map, as well as the source file generated below use |
| // Unicode literal strings for character symbolic names; the algorithm in |
| // localedef utility will generate correct databases even if the platform |
| // does not have a C library locale encoded with the character set we are |
| // creating. |
| void write_string (std::FILE *fp, const char *str) |
| { |
| // ASCII (ISO-646) character map definition |
| static const char* const base_chset [] = { |
| "<U0000>", "<U0001>", "<U0002>", "<U0003>", "<U0004>", "<U0005>", |
| "<U0006>", "<U0007>", "<U0008>", "<U0009>", "<U000a>", "<U000b>", |
| "<U000c>", "<U000d>", "<U000e>", "<U000f>", "<U0010>", "<U0011>", |
| "<U0012>", "<U0013>", "<U0014>", "<U0015>", "<U0016>", "<U0017>", |
| "<U0018>", "<U0019>", "<U001a>", "<U001b>", "<U001c>", "<U001d>", |
| "<U001e>", "<U001f>", "<U0020>", "<U0021>", "<U0022>", "<U0023>", |
| "<U0024>", "<U0025>", "<U0026>", "<U0027>", "<U0028>", "<U0029>", |
| "<U002a>", "<U002b>", "<U002c>", "<U002d>", "<U002e>", "<U002f>", |
| "<U0030>", "<U0031>", "<U0032>", "<U0033>", "<U0034>", "<U0035>", |
| "<U0036>", "<U0037>", "<U0038>", "<U0039>", "<U003a>", "<U003b>", |
| "<U003c>", "<U003d>", "<U003e>", "<U003f>", "<U0040>", "<U0041>", |
| "<U0042>", "<U0043>", "<U0044>", "<U0045>", "<U0046>", "<U0047>", |
| "<U0048>", "<U0049>", "<U004a>", "<U004b>", "<U004c>", "<U004d>", |
| "<U004e>", "<U004f>", "<U0050>", "<U0051>", "<U0052>", "<U0053>", |
| "<U0054>", "<U0055>", "<U0056>", "<U0057>", "<U0058>", "<U0059>", |
| "<U005a>", "<U005b>", "<U005c>", "<U005d>", "<U005e>", "<U005f>", |
| "<U0060>", "<U0061>", "<U0062>", "<U0063>", "<U0064>", "<U0065>", |
| "<U0066>", "<U0067>", "<U0068>", "<U0069>", "<U006a>", "<U006b>", |
| "<U006c>", "<U006d>", "<U006e>", "<U006f>", "<U0070>", "<U0071>", |
| "<U0072>", "<U0073>", "<U0074>", "<U0075>", "<U0076>", "<U0077>", |
| "<U0078>", "<U0079>", "<U007a>", "<U007b>", "<U007c>", "<U007d>", |
| "<U007e>", "<U007f>" |
| }; |
| |
| static const char* const supp_chset [] = { |
| // And a set of characters above 128, which have wide equivalents |
| // with values above 256 |
| /* <U1000> */ "<U1000> \\xa0", |
| /* <U1001> */ "<U1001> \\xa1", |
| /* <U1002> */ "<U1002> \\xa2" |
| }; |
| |
| if (str) { |
| // write out `str' using the charmap above |
| for (; *str; ++str) |
| std::fprintf (fp, "%s", base_chset [UChar (*str)]); |
| |
| } |
| else { |
| |
| #ifndef _RWSTD_NO_NL_LANGINFO |
| |
| const char* const codeset = nl_langinfo (CODESET); |
| |
| std::fprintf (fp, "<code_set_name> \"%s\"\n", codeset); |
| std::fprintf (fp, "<mb_cur_max> 1\n"); |
| std::fprintf (fp, "<mb_cur_min> 1\n"); |
| |
| std::fprintf (fp, "CHARMAP\n"); |
| |
| // write out the basic character set |
| for (unsigned i = 0; i < sizeof base_chset / sizeof *base_chset; ++i) |
| std::fprintf (fp, "%s \\x%02x\n", base_chset [i], i); |
| |
| // write out the additional characters |
| for (unsigned j = 0; j < sizeof supp_chset / sizeof *supp_chset; ++j) |
| std::fprintf (fp, "%s\n", supp_chset [j]); |
| |
| std::fprintf (fp, "END CHARMAP\n"); |
| |
| #endif // _RWSTD_NO_NL_LANGINFO |
| |
| } |
| } |
| |
| |
| // invoke localedef to build a simple locale for testing |
| const char* create_locale () |
| { |
| // only one locale is enough (avoid invoking localedef more than once) |
| static const char* locname; |
| |
| if (locname) |
| return locname; |
| |
| // set up RWSTD_LOCALE_ROOT and other environment variables |
| locale_root = rw_set_locale_root (); |
| |
| if (0 == locale_root) |
| return 0; |
| |
| // create a temporary locale definition file that exercises as |
| // many different parts of the collate standard as possible |
| char srcfname [256]; |
| std::sprintf (srcfname, "%s%slocale.src", locale_root, SLASH); |
| |
| std::FILE *fout = std::fopen (srcfname, "w"); |
| |
| if (!fout) { |
| std::fprintf (stderr, "%s:%d: fopen(\"%s\", \"w\") failed\n", |
| __FILE__, __LINE__, srcfname); |
| return 0; |
| } |
| |
| static const char text[] = { |
| "escape_char /\n" |
| "LC_CTYPE\n" |
| "# <A> <B> <C> MYANMAR LETTER KHA\n" |
| "upper <U0041>;<U0042>;<U0043>;<U1001>\n" |
| " <a> <b> <c> MYANMAR LETTER KA\n" |
| "lower <U0061>;<U0062>;<U0063>;<U1000>\n" |
| "alpha <U0061>;<U0062>;<U0063>;<U0041>;" |
| "<U0042>;<U0043>;<U1000>;<U1001>\n" |
| "digit <U0031>;<U0032>;<U0033>;<U1002>\n" |
| "space <U0020>\n" |
| "cntrl <U0000>\n" |
| " <!> <\">\n" |
| "punct <U0021>; <U0022>\n" |
| "graph <U0041>;<U0042>;<U0043>;<U0061>;<U0062>;<U0063>;" |
| "<U1000>;<U1001>;<U1002>;<U1003>;<U1004>;<U1005>;" |
| "<U0031>;<U0032>;<U0033>;<U0020>;<U0021>;<U0022>\n" |
| "print <U0041>;<U0042>;<U0043>;" |
| "<U0061>;<U0062>;<U0063>;" |
| "<U1000>;<U1001>;<U1002>;<U1003>;<U1004>;<U1005>;" |
| "<U0031>;<U0032>;<U0033>;<U0020>;<U0021>;<U0022>\n" |
| "xdigit <U0041>;<U0042>;<U0043>;<U0061>;<U0062>;" |
| "<U0063>;<U0031>;<U0032>;<U0033>\n" |
| "toupper (<U0061>,<U0041>);(<U0062>,<U0042>);" |
| "(<U0063>,<U0043>);(<U1000>,<U1001>)\n" |
| "tolower (<U0041>,<U0061>);(<U0042>,<U0062>);" |
| "(<U0043>,<U0063>);(<U1001>,<U1000>)\n" |
| "END LC_CTYPE\n" |
| }; |
| |
| std::fprintf (fout, "%s", text); |
| |
| std::fclose (fout); |
| |
| // create a temporary character map file |
| char cmfname [256]; |
| std::sprintf (cmfname, "%s%scharmap.src", locale_root, SLASH); |
| |
| fout = std::fopen (cmfname, "w"); |
| |
| if (!fout) { |
| std::fprintf (stderr, "%s:%d: fopen(\"%s\", \"w\") failed\n", |
| __FILE__, __LINE__, cmfname); |
| return 0; |
| } |
| |
| write_string (fout, 0); |
| |
| std::fclose (fout); |
| |
| locname = "test-locale"; |
| |
| // process the locale definition file and character map |
| if (0 == rw_localedef ("-w", srcfname, cmfname, locname)) |
| locname = 0; |
| |
| return locname; |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_is (charT, const char *cname) |
| { |
| charT str [MAX_STR_SIZE + 1]; |
| |
| BEGIN_LOCALE_LOOP (NLOOPS, locname, j) { |
| |
| std::size_t size = std::size_t (j % MAX_STR_SIZE); |
| |
| gen_str (str, size); |
| |
| // create a mask for each character in the string using the c library |
| // to make sure that it is the same as the mask returned by is |
| std::ctype_base::mask vec [MAX_STR_SIZE + 1]; |
| |
| // set the global C locale to default to make sure |
| // the C++ library does not asume a set value |
| std::setlocale (LC_CTYPE, ""); |
| |
| ctp.is (str, str + size, vec); |
| |
| // set the global C locale to the current locale for calls to the |
| // C library |
| std::setlocale (LC_CTYPE, locname); |
| |
| for (std::size_t i = 0; i < size ; i++) { |
| |
| int libc_result = 0; |
| |
| if (libc_isalpha (str [i])) |
| libc_result |= ALPHA; |
| if (libc_isprint (str [i])) |
| libc_result |= PRINT; |
| if (libc_isspace (str [i])) |
| libc_result |= SPACE; |
| if (libc_iscntrl (str [i])) |
| libc_result |= CNTRL; |
| if (libc_isupper (str [i])) |
| libc_result |= UPPER; |
| if (libc_islower (str [i])) |
| libc_result |= LOWER; |
| if (libc_isdigit (str [i])) |
| libc_result |= DIGIT; |
| if (libc_ispunct (str [i])) |
| libc_result |= PUNCT; |
| if (libc_isxdigit (str [i])) |
| libc_result |= XDIGIT; |
| if (libc_isgraph (str [i])) |
| libc_result |= GRAPH; |
| |
| rw_assert (vec [i] == libc_result, 0, __LINE__, |
| "ctype<%s>::is(%{*Ac}, ..., v) in locale(%#s) " |
| "at offset %zu; got %{LC} expected %{LC}\n", |
| cname, int (sizeof *str), str, |
| locname, i, vec [i], libc_result); |
| } |
| } END_LOCALE_LOOP (locname); |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_toupper_tolower (charT, const char *cname) |
| { |
| rw_info (0, 0, __LINE__, "std::ctype<%s>::tolower(%1$s)", cname); |
| |
| BEGIN_LOCALE_LOOP (UCHAR_MAX, locname, i) { |
| |
| const charT ch = charT (i); |
| |
| // set the global C locale to locname for the C library call |
| std::setlocale (LC_CTYPE, locname); |
| |
| const charT lch = libc_tolower (ch); |
| |
| // set the global C locale to default to make sure |
| // the C++ library does not asume a set value |
| std::setlocale (LC_CTYPE, ""); |
| |
| // exercise tolower using ctype<>::tolower () |
| rw_assert (lch == (ctp.tolower)(ch), 0, __LINE__, |
| "ctype<%s>::tolower(%{#lc}) == %{#lc}, got %{#lc} " |
| "in locale(%#s)", |
| cname, ch, lch, (ctp.tolower)(ch), locname); |
| |
| // exercise tolower using tolower (char, locale) |
| rw_assert (lch == (charT)(std::tolower)(ch, loc), 0, __LINE__, |
| "tolower<%s>(%{#lc}, locale(%#s)) == %{#lc}, got %{#lc}", |
| cname, ch, locname, lch, (std::tolower)(ch, loc)); |
| } END_LOCALE_LOOP (locname); |
| |
| rw_info (0, 0, __LINE__, "std::ctype<%s>::toupper(%1$s)", cname); |
| |
| BEGIN_LOCALE_LOOP (UCHAR_MAX, locname2, i) { |
| |
| const charT ch = charT (i); |
| |
| // set the global C locale to the locale name for the C library call |
| std::setlocale (LC_CTYPE, locname2); |
| |
| const charT uch = libc_toupper (ch); |
| |
| // set the global C locale to default to make sure |
| // the C++ library does not asume a set value |
| std::setlocale (LC_CTYPE, ""); |
| |
| // exercise toupper using ctype<>::toupper () |
| rw_assert (uch == (ctp.toupper)(ch), 0, __LINE__, |
| "ctype<%s>::toupper(%{#lc}) == %{#lc}, got %{#lc} " |
| "in locale(%#s)", |
| cname, ch, uch, (ctp.toupper)(ch), locname2); |
| |
| // exercise toupper using toupper (char, locale) |
| rw_assert (uch == (charT)(std::toupper)(ch, loc), 0, __LINE__, |
| "toupper<%s>(%{#lc}, locale(%#s)) == %{#lc}, got %{#lc}", |
| cname, ch, locname2, uch, (std::toupper)(ch, loc)); |
| } END_LOCALE_LOOP (locname2); |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_scan (charT, const char *cname) |
| { |
| rw_info (0, 0, __LINE__, "std::ctype<%s>::scan_is(), scan_not()", cname); |
| |
| charT str [MAX_STR_SIZE + 1]; |
| |
| BEGIN_LOCALE_LOOP (NLOOPS, locname, j) { |
| |
| const std::size_t size = std::size_t (j % MAX_STR_SIZE); |
| |
| // generate a random string |
| gen_str (str, size); |
| |
| // set the global C locale to default to make sure |
| // the C++ library does not asume a set value |
| std::setlocale (LC_CTYPE, ""); |
| |
| // call scan_is and scan_not using each mask and compare it to |
| // the results found when using the c library |
| |
| const charT* alpha_is = ctp.scan_is (ALPHA, str, str + size); |
| const charT* alpha_not = ctp.scan_not (ALPHA, str, str + size); |
| const charT* space_is = ctp.scan_is (SPACE, str, str + size); |
| const charT* space_not = ctp.scan_not (SPACE, str, str + size); |
| const charT* print_is = ctp.scan_is (PRINT, str, str + size); |
| const charT* print_not = ctp.scan_not (PRINT, str, str + size); |
| const charT* cntrl_is = ctp.scan_is (CNTRL, str, str + size); |
| const charT* cntrl_not = ctp.scan_not (CNTRL, str, str + size); |
| const charT* upper_is = ctp.scan_is (UPPER, str, str + size); |
| const charT* upper_not = ctp.scan_not (UPPER, str, str + size); |
| const charT* lower_is = ctp.scan_is (LOWER, str, str + size); |
| const charT* lower_not = ctp.scan_not (LOWER, str, str + size); |
| const charT* digit_is = ctp.scan_is (DIGIT, str, str + size); |
| const charT* digit_not = ctp.scan_not (DIGIT, str, str + size); |
| const charT* punct_is = ctp.scan_is (PUNCT, str, str + size); |
| const charT* punct_not = ctp.scan_not (PUNCT, str, str + size); |
| const charT* xdigit_is = ctp.scan_is (XDIGIT, str, str + size); |
| const charT* xdigit_not = ctp.scan_not (XDIGIT, str, str + size); |
| |
| // set the global C locale to locname for the C library call |
| std::setlocale (LC_CTYPE, locname); |
| |
| // find the first character in the string that is of the specified |
| // type |
| charT first = 0; |
| charT first_not = 0; |
| _RWSTD_SIZE_T i; |
| int success; |
| |
| #define SCAN(what) \ |
| for (i = 0; i < size; i++) { \ |
| if (libc_is##what (str [i])) { \ |
| first = (str [i]); \ |
| break; \ |
| } \ |
| } \ |
| success = what##_is != (str + size) || 0 == first \ |
| || *what##_is != first; \ |
| rw_assert (success, 0, __LINE__, \ |
| "ctype<%s>::scan_is(" #what ", %{#lc}) " \ |
| "== %{*Ac}, got %{*Ac} in locale (%#s)", \ |
| cname, int (sizeof *str), first, \ |
| int (sizeof *what##_is), what##_is, \ |
| locname); \ |
| \ |
| first = 0; \ |
| for (i = 0; i < size; i++) { \ |
| if (!libc_is##what (str[i])) { \ |
| first_not = (str[i]); \ |
| break; \ |
| } \ |
| } \ |
| success = what##_not != (str + size) || 0 == first_not \ |
| || *what##_not == first_not; \ |
| rw_assert (success, 0, __LINE__, \ |
| "ctype<%s>::scan_not(" #what ", %{#lc}) " \ |
| "== %{*Ac}, got %{*Ac} in locale (%#s)", \ |
| cname, int (sizeof *str), first, \ |
| int (sizeof *what##_not), what##_not, \ |
| locname); \ |
| \ |
| first_not = 0 |
| |
| // test all classes of characters |
| SCAN (alpha); |
| SCAN (space); |
| SCAN (print); |
| SCAN (cntrl); |
| SCAN (upper); |
| SCAN (lower); |
| SCAN (digit); |
| SCAN (punct); |
| SCAN (xdigit); |
| |
| } END_LOCALE_LOOP (locname); |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_narrow_widen (charT, const char *cname) |
| { |
| // 22.2.1.1.2, p11 requires that the conditions below hold for all |
| // facets ctc and ct whose types are ctype<char> and ctype<charT>, |
| // respectively: |
| |
| // [1] (ctc.is (M, c) || !ct.is (M, ctc.do_widen (c))) holds for |
| // all narrow characters c |
| // i.e., narrow characters that are NOT members of a certain |
| // category may not belong to the same category when widened |
| // Note: this implies that some sort of code conversion may |
| // be necessary in order to implement a conforming do_widen() |
| |
| // 22.2.1.1.2, p13 requires that: |
| // [2] (ct.do_widen (ct.do_narrow (c, dfault)) == c) holds unless |
| // (ct.do_narrow (c, dfault) == dfault) holds |
| // [3] (ct.is (M, c) || !ctc.is (M, ct.do_narrow (c, dfault))) holds |
| // unless (ct.do_narrow(c, dfault) == dfault) holds |
| // |
| // C99: each of the iswxxx() functions returns true for each |
| // wide character that corresponds (as if by a call to the |
| // wctob() function) to a single-byte character for which the |
| // corresponding character classification function from 7.4.1 |
| // returns true, except that the iswgraph() and iswpunct() |
| // functions may differ with respect to wide characters other |
| // than L' ' that are both printing and white-space wide |
| // characters. |
| // |
| // [4] (ct.do_narrow (c, default) - '0') evaluates to the digit |
| // value of the character for all c for which ct.is(digit, c) |
| // returns true |
| |
| rw_info (0, 0, __LINE__, |
| "std::ctype<%s>::narrow(%1$s), widen(char)", |
| cname); |
| |
| rw_info (0, 0, __LINE__, |
| "std::ctype<%s>::narrow(const %1$s*, const %1$s*, char*), " |
| "widen(const char*, const char*, %1$s*)", cname); |
| |
| #define STR(x) #x |
| |
| // verify condition [1] above; if it fails, verify that |
| // the same condition also fails to hold when using the |
| // corresponding libc functions |
| #define COND1(what) \ |
| if (!(ctc.is (what, c) || !ctp.is (what, ctp.widen (c)))) { \ |
| rw_assert (!cond1 (what, c, locname), 0, __LINE__, \ |
| "ctype<char>::is (" STR (what) ", %{#lc})" \ |
| " || !ctype<%1$s>::is (" STR (what) ", " \ |
| "ctype<%s>::widen (%{#lc}) = %{#lc})" \ |
| " returned false in locale(%#s)", \ |
| c, cname, c, ctp.widen (c), locname); \ |
| } else (void)0 |
| |
| // verify condition [3] above; if it fails, verify that |
| // the same condition also fails to hold when using the |
| // corresponding libc functions |
| #define COND3(what) \ |
| if ( ctp.narrow (ch, dfault) != dfault \ |
| && !(ctp.is (what, ch) || !ctc.is (what, ctp.narrow (ch, dfault)))) { \ |
| rw_assert (!cond3 (what, ch, locname), 0, __LINE__, \ |
| "ctype<%s>::is (" STR (what) ", %{#lc})" \ |
| " || !ctype<char>::is (" STR (what) ", " \ |
| "ctype<%1$s>::narrow (%{#lc}, %{#c}) = %{#lc})" \ |
| " returned false in locale(%#s)", cname, \ |
| ch, cname, ch, dfault, ctp.narrow (ch, '\0'), \ |
| locname); \ |
| } else (void)0 |
| |
| |
| char c_locname [256]; |
| std::strcpy (c_locname, std::setlocale (LC_ALL, 0)); |
| |
| BEGIN_LOCALE_LOOP (UCHAR_MAX, locname, i) { |
| |
| #if defined (_RWSTD_OS_SUNOS) && _RWSTD_OS_MAJOR == 5 && _RWSTD_OS_MINOR <= 10 |
| |
| // avoid a libc SIGSEGV in mbtowc() in zh_HK and zh_TW |
| // locales encoded using the BIG5 codeset (see bug #603) |
| if ( 0 == std::strncmp ("zh_HK.BIG5", locname, 10) |
| || 0 == std::strncmp ("zh_TW.BIG5", locname, 10)) |
| continue; |
| |
| #endif // SunOS < 5.10 |
| |
| { |
| // verify that the global C locale stays unchanged |
| const char* const curlocname = std::setlocale (LC_ALL, 0); |
| |
| rw_assert (!std::strcmp (c_locname, curlocname), 0, __LINE__, |
| "setlocale(LC_ALL, 0) == \"%s\", got \"%s\"", |
| c_locname, curlocname); |
| } |
| |
| const char c = char (i); |
| const charT ch = charT (i); |
| |
| // verify that condition [1] holds |
| COND1 (ALPHA); |
| COND1 (CNTRL); |
| COND1 (DIGIT); |
| COND1 (GRAPH); |
| COND1 (LOWER); |
| COND1 (PRINT); |
| COND1 (PUNCT); |
| COND1 (SPACE); |
| COND1 (UPPER); |
| COND1 (XDIGIT); |
| |
| // verify that condition [2] holds |
| char dfault = c ? '\0' : '\1'; |
| const charT ret = ctp.widen (ctp.narrow (ch, dfault)); |
| |
| if (ret != charT (dfault) && ret != ch) { |
| rw_assert (ch != widen (ch, narrow (ch, locname), locname), |
| 0, __LINE__, |
| "ctype<%s>::widen (ctype<%1$s>::narrow " |
| "(%{#lc}, %{#c})) == %{#c}; got %{#c} " |
| "in locale (%#s)", |
| cname, ch, dfault, ch, ret, locname); |
| } |
| |
| // finally verify that condition [3] holds |
| COND3 (ALPHA); |
| COND3 (CNTRL); |
| COND3 (DIGIT); |
| COND3 (GRAPH); |
| COND3 (LOWER); |
| COND3 (PRINT); |
| COND3 (PUNCT); |
| COND3 (SPACE); |
| COND3 (UPPER); |
| COND3 (XDIGIT); |
| |
| // now perform a relitively simple sanity check on the 3-argument |
| // overloads of narrow() and widen(). Make sure that the 3-argument |
| // overloads return the same value that the other overload produces |
| // Only do this the first time through the locale list. |
| |
| if (i == 0) { |
| // arrays of all tested narrow and wide characters |
| charT wide_chars [UCHAR_MAX + 1]; |
| char narrow_chars [UCHAR_MAX + 1]; |
| charT narrow_in [UCHAR_MAX + 1]; |
| char widen_in [UCHAR_MAX + 1]; |
| |
| // zero out the last element to allow printing |
| wide_chars [UCHAR_MAX] = charT (); |
| narrow_chars [UCHAR_MAX] = char (); |
| narrow_in [UCHAR_MAX] = charT (); |
| widen_in [UCHAR_MAX] = char (); |
| |
| // set the `dfault' character to something unlikely |
| // but other than '\0' |
| dfault = '\377'; |
| |
| for (unsigned j = 0; j <= UCHAR_MAX; j++) { |
| wide_chars [j] = ctp.widen (char (j)); |
| narrow_chars [j] = ctp.narrow (wide_chars [j], dfault); |
| narrow_in [j] = ctp.widen (char (j)); |
| widen_in [j] = char (j); |
| } |
| |
| charT widen_out [UCHAR_MAX + 1]; |
| char narrow_out [UCHAR_MAX + 1]; |
| |
| widen_out [UCHAR_MAX] = charT (); |
| narrow_out [UCHAR_MAX] = char (); |
| |
| // narrow source buffer into the destination |
| // and compare with expected values |
| ctp.narrow (narrow_in, |
| narrow_in + UCHAR_MAX + 1, |
| dfault, |
| narrow_out); |
| |
| bool success = |
| !std::memcmp (narrow_chars, narrow_out, sizeof narrow_chars); |
| |
| rw_assert (success, 0, __LINE__, |
| "ctype<%s>::narrow (%{*.*Ac}\", ... , %#c) " |
| "== %{.*Ac}, got %{.Ac} in locale (%#s)", cname, |
| int (sizeof *narrow_in), UCHAR_MAX, narrow_in, dfault, |
| UCHAR_MAX, narrow_chars, UCHAR_MAX, narrow_out, |
| locname); |
| |
| // widen source buffer into the destination |
| // and compare with expected values |
| ctp.widen (widen_in, |
| widen_in + UCHAR_MAX + 1, |
| widen_out); |
| |
| success = !std::memcmp (wide_chars, widen_out, sizeof wide_chars); |
| |
| rw_assert (success, 0, __LINE__, |
| "ctype<%s>::widen (%{.*Ac}, ...) == " |
| "%{*.*Ac}, got %{*.*Ac} in locale (%#s)", |
| cname, UCHAR_MAX, widen_in, |
| int (sizeof *wide_chars), UCHAR_MAX, wide_chars, |
| int (sizeof *wide_chars), UCHAR_MAX, widen_out, |
| locname); |
| } |
| |
| } END_LOCALE_LOOP (locname); |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_is_ch (charT, const char *cname) |
| { |
| // buffers to hold the character classification |
| // e.g., for `a' in the "C" locale the string will be |
| // "print lower alpha xdigit alnum graph " |
| |
| static char is_C [80]; // C character classification |
| static char is_CXX [80]; // C++ classification using ctype<char> facet |
| static char is_CXX2 [80]; // C++ classification using convenience funcs |
| |
| rw_info (0, 0, __LINE__, "std::ctype<%s>::is(mask, %1$s)", cname); |
| |
| BEGIN_LOCALE_LOOP (UCHAR_MAX, locname, i) { |
| |
| const charT ch = charT (i); |
| const UChar uch = ch; |
| |
| *is_C = |
| *is_CXX = |
| *is_CXX2 = '\0'; |
| |
| // set the global C locale to locname for the C library calls |
| std::setlocale (LC_CTYPE, locname); |
| |
| #define IS(what) \ |
| libc_is##what (ch) \ |
| ? (void)std::strcat (is_C, #what" ") : (void)0; |
| |
| // test all classes of characters |
| IS (space); IS (print); IS (cntrl); IS (upper); IS (lower); |
| IS (alpha); IS (digit); IS (punct); IS (xdigit); IS (alnum); |
| IS (graph); |
| |
| // set the global C locale to default to make sure |
| // the C++ library does not asume a set value |
| std::setlocale (LC_CTYPE, ""); |
| |
| #undef IS |
| // convenience macro |
| #define IS(what) \ |
| ctp.is (std::ctype_base::what, ch) \ |
| ? (void)std::strcat (is_CXX, #what" ") : (void)0; \ |
| (std::is##what)(ch, loc) \ |
| ? (void)std::strcat (is_CXX2, #what" ") : (void)0; |
| |
| // test all classes of characters |
| // (must be in the same order as the IS() calls above) |
| IS (space); IS (print); IS (cntrl); IS (upper); IS (lower); |
| IS (alpha); IS (digit); IS (punct); IS (xdigit); IS (alnum); |
| IS (graph); |
| |
| // compare the two strings (should match) |
| |
| rw_assert (0 == std::strcmp (is_C, is_CXX), 0, __LINE__, |
| "ctype<%s>::is(..., %{#lc}) in locale(%#s) " |
| "expected to hold for { %s}, got { %s}", |
| cname, uch, locname, is_C, is_CXX); |
| |
| // convenience functions must produce the same results |
| rw_assert (0 == std::strcmp (is_C, is_CXX2), 0, __LINE__, |
| "is* (%{#lc}, locale (%#s)) expected to hold for " |
| "{ %s}, got { %s}", |
| uch, locname, is_C, is_CXX2); |
| |
| #if !defined (_WIN32) && !defined (_WIN64) |
| |
| // exercise POSIX requirements only on POSIX platforms |
| |
| static const std::ctype_base::mask masks[] = { |
| ALPHA, std::ctype_base::mask (), CNTRL, DIGIT, |
| GRAPH, LOWER, PRINT, PUNCT, |
| SPACE, UPPER, XDIGIT |
| }; |
| |
| // see the POSIX description of LC_CTYPE in Locale for a table |
| // of required and allowed combinations of character classes |
| |
| // a character in a given /* class */ below is also required |
| // to be included in the following set of classes |
| static const int required [sizeof masks / sizeof *masks] = { |
| /* alpha */ ALPHA | GRAPH | PRINT, |
| /* blank */ SPACE, |
| /* cntrl */ CNTRL, |
| /* digit */ DIGIT | GRAPH | PRINT | XDIGIT, |
| /* graph */ GRAPH | PRINT, |
| /* lower */ ALPHA | GRAPH | LOWER | PRINT, |
| /* print */ PRINT, |
| /* punct */ GRAPH | PRINT | PUNCT, |
| /* space */ SPACE, |
| /* upper */ ALPHA | GRAPH | PRINT | UPPER, |
| /* xdigit */ GRAPH | PRINT | XDIGIT |
| }; |
| |
| // a character in a given /* class */ below may also |
| // be included in the following set of classes |
| static const int allowed [sizeof masks / sizeof *masks] = { |
| /* alpha */ UPPER | LOWER | XDIGIT, |
| /* blank */ CNTRL, |
| /* cntrl */ SPACE, |
| /* digit */ 0, |
| /* graph */ UPPER | LOWER | ALPHA | DIGIT | SPACE | PUNCT |XDIGIT, |
| /* lower */ UPPER | XDIGIT, |
| /* print */ UPPER | LOWER | ALPHA | DIGIT | SPACE | PUNCT |XDIGIT, |
| /* punct */ SPACE, |
| /* space */ CNTRL, |
| /* upper */ LOWER | XDIGIT, |
| /* xdigit */ UPPER | LOWER | ALPHA | DIGIT |
| }; |
| |
| // a character in a given /* class */ below is explicitly |
| // disallowed to be included in the following set of classes |
| static const int disallowed [sizeof masks / sizeof *masks] = { |
| /* alpha */ DIGIT | SPACE | CNTRL | PUNCT, |
| /* blank */ UPPER | LOWER | ALPHA | DIGIT, |
| /* cntrl */ UPPER | LOWER | ALPHA | DIGIT | PUNCT | GRAPH | PRINT, |
| /* digit */ UPPER | LOWER | ALPHA | SPACE | SPACE | CNTRL, |
| /* graph */ CNTRL, |
| /* lower */ DIGIT | SPACE | CNTRL | PUNCT, |
| /* print */ CNTRL, |
| /* punct */ UPPER | LOWER | ALPHA | DIGIT | CNTRL | XDIGIT, |
| /* space */ UPPER | LOWER | ALPHA | DIGIT | XDIGIT, |
| /* upper */ DIGIT | SPACE | CNTRL | PUNCT, |
| /* xdigit */ SPACE | CNTRL | PUNCT |
| }; |
| |
| // obtain the mask of a single character |
| std::ctype_base::mask m; |
| ctp.is (&ch, &ch + 1, &m); |
| |
| int missing = 0; // required bits missing in ch's mask |
| int all_allowed = 0; // all bits allowed to be set in ch's mask |
| int all_disallowed = 0; // all bits disallowed to be set in the mask |
| |
| for (std::size_t k = 0; k != sizeof masks / sizeof *masks; ++k) { |
| |
| // assumes masks [k] has a single bit set |
| const int bit = m & masks [k]; |
| if (!bit) |
| continue; |
| |
| if ((bit & required [k]) && (m & required [k]) != required [k]) { |
| // character in a class given by masks[k] is required |
| // to also belong to all classes in required[k] |
| |
| missing |= ~(m & required [k]) & required [k]; |
| } |
| |
| // character in a class given by masks[k] is only allowed |
| // to belong to classes in (allowed[k] | required[k]) and |
| // is not allowed to belong to those in disallowed[k] |
| all_allowed |= required [k] | allowed [k]; |
| all_disallowed |= disallowed [k]; |
| } |
| |
| // the space character automatically belongs to the print class |
| // but cannot belong to the punct or graph classes; other characters |
| // that belong to the space class can belong to the punct and graph |
| // classes |
| if (' ' == ch) { |
| all_disallowed |= PUNCT | GRAPH; |
| if (!(m & PRINT)) |
| missing |= PRINT; |
| } |
| |
| int cmask = -1; |
| |
| if (missing) { |
| |
| if (-1 == cmask) |
| cmask = libc_mask (-1, ch, locname); |
| |
| rw_assert (m == cmask, 0, __LINE__, |
| "mask of %{#lc} in locale(%#s) " |
| "is missing bits %{LC}: %{LC}", |
| ch, locname, missing, m); |
| } |
| |
| if (m & ~all_allowed) { |
| |
| if (-1 == cmask) |
| cmask = libc_mask (-1, ch, locname); |
| |
| rw_assert (m == cmask, 0, __LINE__, |
| "mask of %{#lc} in locale (%#s) " |
| "contains extra bits %{LC}: %{LC}", |
| ch, locname, m & ~all_allowed, m); |
| } |
| |
| if (m & all_disallowed) { |
| |
| if (-1 == cmask) |
| cmask = libc_mask (-1, ch, locname); |
| |
| rw_assert (m == cmask, 0, __LINE__, |
| "mask of %{#lc} in locale (%s#) " |
| "contains disallowed bits { %s }: { %s }", |
| ch, locname, m & all_disallowed, m); |
| } |
| |
| #endif // !WIN32 && !WIN64 |
| |
| } END_LOCALE_LOOP (locname); |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_libc (charT, const char *cname) |
| { |
| test_is_ch (charT (), cname); |
| test_toupper_tolower (charT (), cname); |
| test_narrow_widen (charT (), cname); |
| test_is (charT (), cname); |
| test_scan (charT (), cname); |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_libstd_scan_is (charT, const char *cname, |
| const std::ctype<charT> &ct, |
| const char* str, std::ctype_base::mask mask, |
| int expected_idx, int fwiden = 0) |
| { |
| // convert narrow string to a (possibly) wide representation |
| charT wstrbuf [256]; |
| charT* wstr = wstrbuf; |
| |
| // If instructed to use the facet widen method, do so, otherwise |
| // use widen helper function that in turn uses C lib mbstowcs |
| if (fwiden == 0) |
| widen (wstrbuf, str); |
| else |
| ct.widen (str, str + std::strlen (str), wstrbuf); |
| |
| const int success = |
| &wstr [expected_idx] == ct.scan_is (mask, wstr, wstr + c_strlen (wstr)); |
| |
| rw_assert (success, 0, __LINE__, |
| "ctype<%s>::scan_is() returned an unexpected value", |
| cname); |
| |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_libstd_scan_not (charT, const char *cname, |
| const std::ctype<charT> &ct, |
| const char* str, std::ctype_base::mask mask, |
| int expected_idx, int fwiden = 0) |
| { |
| // convert narrow string to a (possibly) wide representation |
| charT wstrbuf [256]; |
| charT* wstr = wstrbuf; |
| |
| // If instructed to use the facet widen method, do so, otherwise |
| // use widen helper function that in turn uses C lib mbstowcs |
| if (fwiden == 0) |
| widen (wstrbuf, str); |
| else |
| ct.widen (str, str + std::strlen (str), wstrbuf); |
| |
| const int success = |
| &wstr[expected_idx] == ct.scan_not (mask, wstr, wstr + c_strlen (wstr)); |
| |
| rw_assert (success, 0, __LINE__, |
| "ctype<%s>::scan_not() returned an unexpected value", |
| cname); |
| |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_libstd_toupper_tolower (charT, const char *cname, |
| const std::ctype<charT> &ct, |
| const char *locname) |
| { |
| rw_info (0, 0, __LINE__, |
| "std::ctype<%s>::tolower(%1$s) toupper(%1$s) in locale(%#s)", |
| cname, locname); |
| |
| int success; |
| |
| #undef TEST |
| #define TEST(lower, upper) \ |
| success = ct.widen (upper) == ct.toupper (ct.widen (lower)); \ |
| rw_assert (success, 0, __LINE__, \ |
| "ctype<%s>::toupper(%d) == %d, got %d", cname, \ |
| lower, upper, ct.toupper((charT)lower)); \ |
| success = ct.widen (lower) == ct.tolower (ct.widen (upper)); \ |
| rw_assert (success, 0, __LINE__, \ |
| "ctype<%s>::tolower(%d) == %d, got %d", \ |
| cname, upper, lower, ct.tolower((charT)upper)) |
| |
| TEST ('a', 'A'); |
| TEST ('b', 'B'); |
| TEST ('c', 'C'); |
| |
| if (sizeof(charT) > 1) |
| TEST ('\xa0', '\xa1'); |
| |
| #undef TEST |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_libstd_mask (charT, const char *cname, |
| const std::ctype<charT> &ct, const char *locname) |
| { |
| |
| rw_info (0, 0, __LINE__, "std::ctype<%s>::is(mask, %1$s) in locale(%#s)", |
| cname, locname); |
| |
| #undef TEST |
| #define TEST(ch, m) \ |
| rw_assert (ct.is (m, ch), 0, __LINE__, \ |
| "ctype<%s>::is(%d, %d) failed", cname, m, ch) |
| |
| // make sure the characters have the correct masks |
| TEST (charT ('a'), ALPHA); |
| TEST (charT ('a'), LOWER); |
| TEST (charT ('a'), XDIGIT); |
| TEST (charT ('a'), GRAPH); |
| TEST (charT ('a'), PRINT); |
| TEST (charT ('a'), ALPHA | LOWER | XDIGIT | PRINT); |
| |
| TEST (charT ('b'), ALPHA); |
| TEST (charT ('b'), LOWER); |
| TEST (charT ('b'), XDIGIT); |
| TEST (charT ('b'), GRAPH); |
| TEST (charT ('b'), PRINT); |
| TEST (charT ('b'), ALPHA | LOWER | XDIGIT | PRINT); |
| |
| TEST (charT ('c'), ALPHA); |
| TEST (charT ('c'), LOWER); |
| TEST (charT ('c'), XDIGIT); |
| TEST (charT ('c'), GRAPH); |
| TEST (charT ('c'), PRINT); |
| TEST (charT ('c'), ALPHA | LOWER | XDIGIT | PRINT); |
| |
| TEST (charT ('A'), ALPHA); |
| TEST (charT ('A'), UPPER); |
| TEST (charT ('A'), XDIGIT); |
| TEST (charT ('A'), GRAPH); |
| TEST (charT ('A'), PRINT); |
| TEST (charT ('A'), ALPHA | UPPER | XDIGIT | PRINT); |
| |
| TEST (charT ('B'), ALPHA); |
| TEST (charT ('B'), UPPER); |
| TEST (charT ('B'), XDIGIT); |
| TEST (charT ('B'), GRAPH); |
| TEST (charT ('B'), PRINT); |
| TEST (charT ('B'), ALPHA | UPPER | XDIGIT | PRINT); |
| |
| TEST (charT ('C'), ALPHA); |
| TEST (charT ('C'), UPPER); |
| TEST (charT ('C'), XDIGIT); |
| TEST (charT ('C'), GRAPH); |
| TEST (charT ('C'), PRINT); |
| TEST (charT ('C'), ALPHA | UPPER | XDIGIT | PRINT); |
| |
| TEST (charT ('1'), DIGIT); |
| TEST (charT ('1'), XDIGIT); |
| TEST (charT ('1'), GRAPH); |
| TEST (charT ('1'), PRINT); |
| TEST (charT ('1'), DIGIT | XDIGIT | GRAPH | PRINT); |
| |
| TEST (charT ('2'), DIGIT); |
| TEST (charT ('2'), XDIGIT); |
| TEST (charT ('2'), GRAPH); |
| TEST (charT ('2'), PRINT); |
| TEST (charT ('2'), DIGIT | XDIGIT | GRAPH | PRINT); |
| |
| TEST (charT ('3'), DIGIT); |
| TEST (charT ('3'), XDIGIT); |
| TEST (charT ('3'), GRAPH); |
| TEST (charT ('3'), PRINT); |
| TEST (charT ('3'), DIGIT | XDIGIT | GRAPH | PRINT); |
| |
| TEST (charT (' '), SPACE); |
| TEST (charT (' '), GRAPH); |
| TEST (charT (' '), PRINT); |
| TEST (charT (' '), SPACE | GRAPH | PRINT); |
| |
| if (sizeof (charT) > 1) { |
| TEST (ct.widen ('\xa0'), ALPHA); |
| TEST (ct.widen ('\xa0'), LOWER); |
| TEST (ct.widen ('\xa0'), GRAPH); |
| TEST (ct.widen ('\xa0'), PRINT); |
| TEST (ct.widen ('\xa0'), ALPHA | LOWER | GRAPH | PRINT); |
| |
| TEST (ct.widen ('\xa1'), ALPHA); |
| TEST (ct.widen ('\xa1'), UPPER); |
| TEST (ct.widen ('\xa1'), GRAPH); |
| TEST (ct.widen ('\xa1'), PRINT); |
| TEST (ct.widen ('\xa1'), ALPHA | UPPER | GRAPH | PRINT); |
| |
| TEST (ct.widen ('\xa2'), DIGIT); |
| TEST (ct.widen ('\xa2'), GRAPH); |
| TEST (ct.widen ('\xa2'), PRINT); |
| TEST (ct.widen ('\xa0'), DIGIT | GRAPH | PRINT); |
| } |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void test_libstd (charT, const char *cname) |
| { |
| // invoke localedef to build a locale to test with |
| const char* const locname = create_locale (); |
| |
| if (!rw_error (0 != locname, 0, __LINE__, |
| "failed to create a locale in %s", locale_root)) |
| return; |
| |
| const std::locale loc (locname); |
| |
| const std::ctype<charT> &ct = |
| _STD_USE_FACET (std::ctype<charT>, loc); |
| |
| ct._C_opts |= ct._C_use_libstd; |
| ct._C_opts &= ~ct._C_use_libc; |
| |
| test_libstd_mask (charT (), cname, ct, locname); |
| test_libstd_toupper_tolower (charT (), cname, ct, locname); |
| |
| // now check the scan functions |
| rw_info (0, 0, __LINE__, |
| "std::ctype<%s>::scan_is(const %1$s*, const %1$s, mask*) " |
| "in locale(%#s)", cname, locname); |
| |
| test_libstd_scan_is (charT (), cname, ct, "abc1BC", DIGIT, 3); |
| test_libstd_scan_is (charT (), cname, ct, "abc123B ", SPACE, 7); |
| test_libstd_scan_is (charT (), cname, ct, "abc123", LOWER, 0); |
| test_libstd_scan_is (charT (), cname, ct, "abc123", UPPER, 6); |
| test_libstd_scan_is (charT (), cname, ct, "abc1ABC", DIGIT | UPPER, 3); |
| test_libstd_scan_is (charT (), cname, ct, "abcA2BC", DIGIT | UPPER, 3); |
| |
| if (sizeof(charT) > 1) { |
| test_libstd_scan_is (charT (), cname, ct, "ABC\xa0xyz", LOWER, 3, 1); |
| test_libstd_scan_is (charT (), cname, ct, "abcx\xa1yz", UPPER, 4, 1); |
| } |
| |
| rw_info (0, 0, __LINE__, |
| "std::ctype<%s>::scan_not(const %1$s*, const %1$s, mask*) " |
| "in locale(%#s)", cname, locname); |
| |
| test_libstd_scan_not (charT (), cname, ct, "abc1BC", ALPHA, 3); |
| test_libstd_scan_not (charT (), cname, ct, "aaBBcc", LOWER, 2); |
| test_libstd_scan_not (charT (), cname, ct, "abc1BC", DIGIT, 0); |
| test_libstd_scan_not (charT (), cname, ct, "abc1BC", PRINT, 6); |
| |
| if (sizeof(charT) > 1) { |
| test_libstd_scan_not (charT (), cname, ct, "abc\xa2xyz", ALPHA, 3, 1); |
| test_libstd_scan_not (charT (), cname, ct, "123\xa1yz ", DIGIT, 3, 1); |
| } |
| } |
| |
| /**************************************************************************/ |
| |
| template <class charT> |
| void run_test (charT, const char *cname) |
| { |
| if (0) { |
| // do a compile time only test on use_facet and has_facet |
| _STD_HAS_FACET (std::ctype_byname<charT>, std::locale ()); |
| _STD_USE_FACET (std::ctype_byname<charT>, std::locale ()); |
| } |
| |
| test_libstd (charT (), cname); |
| test_libc (charT (), cname); |
| } |
| |
| /**************************************************************************/ |
| |
| static int |
| run_test (int, char**) |
| { |
| run_test (char (), "char"); |
| run_test (wchar_t (), "wchar_t"); |
| |
| return 0; |
| } |
| |
| /**************************************************************************/ |
| |
| int main (int argc, char *argv[]) |
| { |
| return rw_test (argc, argv, __FILE__, |
| "lib.category.ctype", |
| 0 /* no comment */, |
| run_test, |
| "", |
| (void*)0 /* sentinel */); |
| } |
