wctype.cpp

Go to the documentation of this file.

 
#include <cwctype>     // for iswxxx(), wint_t
#include <stdexcept>   // for runtime_error
#include <iomanip>     // for setfill, setw
#include <ios>         // for oct
#include <iostream>    // for cerr, cout
#include <locale>      // for isxxx(), locale
 
 
static std::locale
make_named_locale ()
{
    static const char* const
    locale_names [] = {
        "es_ES.ISO8859-1",       // AIX, Solaris, Tru64
        "es_ES.iso88591",        // HP-UX, Linux
        "es_ES.88591",
        "De_DE.88591",           // Reliant
        "es_ES",
        "es",                    // Linux, Solaris
        "Spanish",
        "spanish",               // Linux
        "espanol",               // Linux
        "spanish_spain.1252",    // Windows
        "POSIX",                 // POSIX systems
        "C",                     // all C/C++ systems
        0                        // (sentinel)
    };
 
    std::locale german;
 
    // iterate over the know locale names above until a valid one
    // is found (i.e., one that doesn't cause locale to throw)
    for (const char* const *names = locale_names; ; ) {
        try {
            german = std::locale (names [0]);
            break;
        }
        catch (std::runtime_error&) {
            // continue trying until the next name is null
            if (0 == *++names)
                throw;
        }
        catch (...) {
            throw;
        }
    }
 
    return german;
}
 
 
int main ()
{
    std::locale locale;
 
    try {
        // try to contruct a named locale
        locale = make_named_locale ();
    }
    catch (std::runtime_error& e) {
        // a runtime_error will be thrown if the locale cannot be constructed
        std::cerr << "Caught runtime_error:\n"; 
        std::cerr << e.what () << '\n';
 
        return 1;
    }
    catch (...) {
        std::cerr << "Caught an unknown exception\n"; 
 
        return 2;
    }
 
    // set the global C/C++ locale to be used by the C classification
    // functions (such as iswalpha())
    std::locale::global (locale);
 
    // imbue the named locale in wcout
    std::wcout.imbue (locale);
 
    std::wcout << "Wide character classification in "
               << locale.name ().c_str () << " locale.\n";
 
 
    // number of mismatched classifications between C and C++
    // (expect zero for 100% conforming implementation)
    int mismatch_count = 0;
 
    // iterate over all characters in the extended ASCII range
    // printing out the value of each along with its character
    // class using the letters A, a, C, D, G, L, P, p, S, U,
    // and X to denote each of the C/C++ classes corresponding
    // to the C and C++ classification functions
    for (std::wint_t wi = 0; wi < std::wint_t (256); ++wi) {
 
        // convert the wint_t to wchar_t
        const wchar_t wc (wi);
 
        char cxx_class [11];   // C++ classification letters
        char c_class   [11];   // C classification letters
 
        std::size_t i = 0;
 
        // assign the appropriate letter for the C++ classification
        cxx_class [i++] = (std::isalnum)(wc, locale)  ? 'A' : '-';
        cxx_class [i++] = (std::isalpha)(wc, locale)  ? 'a' : '-';
        cxx_class [i++] = (std::iscntrl)(wc, locale)  ? 'C' : '-';
        cxx_class [i++] = (std::isdigit)(wc, locale)  ? 'D' : '-';
        cxx_class [i++] = (std::isgraph)(wc, locale)  ? 'G' : '-';
        cxx_class [i++] = (std::islower)(wc, locale)  ? 'L' : '-';
        cxx_class [i++] = (std::isprint)(wc, locale)  ? 'P' : '-';
        cxx_class [i++] = (std::ispunct)(wc, locale)  ? 'p' : '-';
        cxx_class [i++] = (std::isspace)(wc, locale)  ? 'S' : '-';
        cxx_class [i++] = (std::isupper)(wc, locale)  ? 'U' : '-';
        cxx_class [i++] = (std::isxdigit)(wc, locale) ? 'X' : '-';
 
        i = 0;
 
        // assign the appropriate letter for the C classification
        c_class [i++] = (std::iswalnum)(wc)  ? 'A' : '-';
        c_class [i++] = (std::iswalpha)(wc)  ? 'a' : '-';
        c_class [i++] = (std::iswcntrl)(wc)  ? 'C' : '-';
        c_class [i++] = (std::iswdigit)(wc)  ? 'D' : '-';
        c_class [i++] = (std::iswgraph)(wc)  ? 'G' : '-';
        c_class [i++] = (std::iswlower)(wc)  ? 'L' : '-';
        c_class [i++] = (std::iswprint)(wc)  ? 'P' : '-';
        c_class [i++] = (std::iswpunct)(wc)  ? 'p' : '-';
        c_class [i++] = (std::iswspace)(wc)  ? 'S' : '-';
        c_class [i++] = (std::iswupper)(wc)  ? 'U' : '-';
        c_class [i++] = (std::iswxdigit)(wc) ? 'X' : '-';
 
        // print the value of the character and its glyph only when
        // it's printable, otherwise print a space
        std::wcout << "  '\\" << std::setw (3)
                   << std::setfill (L'0') << std::oct << wi
                   << "' ('" << ((std::isprint)(wc, locale) ? wc : L' ')
                   << "')   ";
 
        bool mismatch = false;
 
        // print out the letters denoting each character class
        for (i = 0; i != sizeof cxx_class; ++i) {
 
            if (cxx_class [i] == c_class [i])
                std::wcout << cxx_class [i] << ' ';
            else {
                std::wcout << cxx_class [i] << ':' << c_class [i] << ' ';
                mismatch = true;
            }
        }
 
        if (mismatch) {
            std::wcout << "   *** C/C++ mismatch ***";
 
            // increment the number of mimatched character classes
            ++mismatch_count;
        }
 
        std::wcout << '\n';
    }
 
    return mismatch_count ? 1 : 0;
}