67 Character classification — <ctype.h>

67.1 The twelve functions at a glance

<ctype.h> fixes eleven predicates and two conversions. The naming rule is simple — is asks a true-or-false question, to changes something.

isdigit is special. The standard nails the set of characters for which it is true to the ten from 0 to 9, regardless of the locale. That contrasts with the other predicates, which may widen. It is the one thing code that parses numbers can lean on.

67.2 The first trap — never pass a char straight in

#include <stdio.h>
#include <ctype.h>
#include <limits.h>
#include <string.h>

/* The ctype functions take an int — but that int is not a char */
int main(void)
{
    printf("CHAR_MIN = %d (char on this machine is %s)\n",
           CHAR_MIN, CHAR_MIN < 0 ? "signed" : "unsigned");

    /* the ASCII range gives no trouble */
    printf("isalpha('A') = %d, isdigit('7') = %d, isspace(' ') = %d\n",
           isalpha('A') != 0, isdigit('7') != 0, isspace(' ') != 0);

    /* bytes of 128 and above are the trouble: passed as a char they go negative */
    char bytes[] = { (char)0xC7, (char)0x41, 'A', '\0' };   /* the first byte of the Korean syllable 가 in CP949 */
    printf("byte 0xC7 held in a char: %d\n", bytes[0]);

    /* the right idiom: convert to unsigned char before passing */
    printf("the right call: isalpha((unsigned char)b) = %d\n",
           isalpha((unsigned char)bytes[0]) != 0);

    /* toupper and tolower follow the same rule */
    const char *s = "Hello, World!";
    char up[32];
    size_t i = 0;
    for (; s[i] && i + 1 < sizeof up; i++)
        up[i] = (char)toupper((unsigned char)s[i]);
    up[i] = '\0';
    printf("toupper applied: [%s]\n", up);

    /* EOF is a valid argument too — which is why the parameter type is int */
    printf("isalpha(EOF) = %d (EOF is an allowed argument)\n", isalpha(EOF) != 0);
    return 0;
}

CHAR_MIN = -128 (char on this machine is signed)
isalpha('A') = 1, isdigit('7') = 1, isspace(' ') = 1
byte 0xC7 held in a char: -57
the right call: isalpha((unsigned char)b) = 0
toupper applied: [HELLO, WORLD!]
isalpha(EOF) = 0 (EOF is an allowed argument)

Every function in <ctype.h> takes an int. And the value the standard requires of that argument is one representable as an unsigned char, or EOF.

The trouble is that char is signed on many implementations (chapter 27). As the example prints, the byte 0xC7 held in a char becomes −57, and passing that straight into isalpha passes a value that is not allowed — outside the contract. Real implementations are usually built as array lookups, so it becomes a read from before the start of an array.

There is one idiom.

isalpha((unsigned char)c)
toupper((unsigned char)c)

char *p = line;
while (*p) { if (isspace(*p)) ... ; p++; }   /* outside the contract past 0x80 */

while (*p) { if (isspace((unsigned char)*p)) ... ; p++; }

67.3 The second trap — EOF is mixed in

There is a reason the argument type is int and not char. EOF is a valid argument too. What fgetc returns must be passable straight in (chapter 63), and that value may be a byte or may be EOF.

int c;
while ((c = fgetc(f)) != EOF)
    if (isalpha(c)) ...          /* what fgetc gave is already unsigned char or EOF */

Receive c as a char here and two things break at once — EOF becomes indistinguishable from the byte 0xFF, and the value can go negative and fall into the first trap. Chapter 63′s rule, “always receive what fgetc returns in an int”, comes back here.

67.4 The judgement depends on the locale

The set of bytes for which isalpha is true is not fixed. The current locale (precisely, the LC_CTYPE category) settles it. A program starts in the "C" locale, so at first the basis is ASCII — but it can change the moment setlocale is called.

And it is not only the predicates. toupper('i') becoming the dotted capital İ in a Turkish locale is the famous case, and in a locale whose decimal point is a comma even the output of printf("%f") changes.

The locale is a subject in its own right. By what rule its names are made, which standards fix them, and how much it changes are the next two chapters (chapters 68 and 69).

67.5 It means nothing for multibyte characters

One thing remains. The functions of this header look at one byte. “한” in UTF-8 is three bytes, so no byte of it means anything on its own — passing 0xED to isalpha asks “is this fragment a letter?”, and that question has no answer.

To judge a character made of several bytes, there are two roads. Convert to wide characters and use <wctype.h>‘s iswalpha (chapters 70 and 71 treat it), or work on the byte string as it is and do only the judgements you need yourself (chapter 72). This book recommends the latter, and chapter 72 says why.

The judgement of a single byte is done. Now for the thing that governed it — the locale. The next chapter starts from what a locale is and by what rule a name like ko_KR.UTF-8 is made.