[cppx] Characters & nasal daemons…

Consider this innocent-looking code:

#include <iostream>
#include <ctype.h>      // isalpha
#include <locale.h>     // setlocale

int main( int argc, char* argv[] )
{
    char const* progname = argv[0];
    setlocale( LC_ALL, "" );        // User's default locale.
    if( isalpha( progname[0] ) )    // Uh...
    {
        std::cout << "My name starts with a letter!" << std::endl;
    }
}

Running the program from a command interpreter, as file [a.exe] it reports that its name starts with a letter, OK, check. As file [7.exe] it doesn’t say anything, OK, check. But as file [å.exe] (‘å’ is the last letter in the Norwegian alphabet) it also says nothing, even on my Norwegian PC!

What’s wrong?

Well, there’s a great many things wrong, including that in Windows the program may receive a full path, instead of just a filename, as argv[0] 🙂 But the main thing here is the use of the isalpha function from the C library because that function requires an argument value that is non-negative, or else the special value EOF. And with an ordinary 8-bit ASCII based character set and a signed type (which is the default on all extant computers except reportedly two archaic beasts that use sign and magnitude integers) 'å' cannot be positive, since there’s no such character in ASCII, so it must be negative…

And the result of that is Undefined Behavior, causing nasal daemons to appear at the most embarassing moment!

The proper thing to do is to cast that character to unsigned char before passing it to isalpha. More generally, if you have a Byte type then it’s probably defined as unsigned char, and indicates more clearly what’s going on. And so for this kind of usage, in the cppx library I define types Byte and SignedByte as follows, …

In [progrock/cppx/primitive_types.h]:

namespace progrock{ namespace cppx{

    typedef unsigned char       Byte;
    typedef signed char         SignedByte;

    // More stuff here …

} }  // namespace progrock::cppx

… as well as do-it-once-and-be-over-with-it wrappers for the C library character classification functions, …

In [progrock/cppx/text/char_util.h]:

namespace progrock{ namespace cppx{

    inline bool isAlphaNum( char const ch )             { return !!isalnum( Byte( ch ) ); }
    inline bool isControl( char const ch )              { return !!iscntrl( Byte( ch ) ); }
    inline bool isAlpha( char const ch )                { return !!isalpha( Byte( ch ) ); }
    inline bool isDigit( char const ch )                { return !!isdigit( Byte( ch ) ); }
    inline bool isGraphic( char const ch   )            { return !!isgraph( Byte( ch ) ); }
    inline bool isLowercase( char const ch )            { return !!islower( Byte( ch ) ); }
    inline bool isGraphicOrSpace( char const ch )       { return !!isprint( Byte( ch ) ); }
    inline bool isPunctuation( char const ch )          { return !!ispunct( Byte( ch ) ); }
    inline bool isWhitespace( char const ch )           { return !!isspace( Byte( ch ) ); }
    inline bool isUppercase( char const ch )            { return !!isupper( Byte( ch ) ); }
    inline bool isHexDigit( char const ch )             { return !!isxdigit( Byte( ch ) ); }

    inline bool isAlphaNum( wchar_t const ch )          { return !!iswalnum( ch ); }
    inline bool isControl( wchar_t const ch )           { return !!iswcntrl( ch ); }
    inline bool isAlpha( wchar_t const ch )             { return !!iswalpha( ch ); }
    inline bool isDigit( wchar_t const ch )             { return !!iswdigit( ch ); }
    inline bool isGraphic( wchar_t const ch   )         { return !!iswgraph( ch ); }
    inline bool isLowercase( wchar_t const ch )         { return !!iswlower( ch ); }
    inline bool isGraphicOrSpace( wchar_t const ch )    { return !!iswprint( ch ); }
    inline bool isPunctuation( wchar_t const ch )       { return !!iswpunct( ch ); }
    inline bool isWhitespace( wchar_t const ch )        { return !!iswspace( ch ); }
    inline bool isUppercase( wchar_t const ch )         { return !!iswupper( ch ); }
    inline bool isHexDigit( wchar_t const ch )          { return !!iswxdigit( ch ); }

} }  // namespace progrock::cppx

In C such wrappers would have the problem of not handling the EOF constant properly (it’s intentionally a value that cannot be represented as char). But in C++ I’ve needed and written a wrapper like isAlpha above numerous times and have never needed EOF-value handling. So I think that these functions are Good, what the doctor ordered :-), and that if EOF needs to be handled some place then it’s no big deal to do that: it’s easy to add complexity on top of simplicity, but difficult to simplify the complex!