To find if a character is a delimiter

Question

I have a function to check if a character is a delimiter and I wonder if it is consistent or can be improved:

int chDelimit(int ch)
{
    return
        (ch == '\n' || ch == '\t') ||
        (ch >= ' ' && ch <= '/') ||
        (ch >= ':' && ch <= '@') ||
        (ch >= '[' && ch <= '`') ||
        (ch >= '{' && ch <= '~') ||
        (ch == '\0');
}

Answer 1

There's no particular ordering of characters' code-points in C (other than the digits 0..9). This code assumes (for example) that '[' is less than '`', but that's not the case in EBCDIC at least.

I think you might be better off creating a table of boolean values, and indexing into that with the (unsigned value of) ch, in the way that standard <ctype.h> functions are normally implemented. This will probably improve performance (one lookup, rather than up to 11 comparisons, per call).

Alternatively, and depending on what characters are considered "delimiters", you may be able to use standard library functions (e.g. isalnum()) in combination.

Answer 2

1. Function Name It isn't clear that chDelimit() is a function that tests whether a character is a delimiter character. For functions that return boolean, it's generally accepted to call it Is<Condition>() where condition is phrased in the affirmative. For example, I'd name this function IsDelimiter() and not IsNonDelimiterCharacter()

2. Depending on your application, it might be worthwhile to create macros for boolean values (or enums). See SO: Using Boolean Values in C

3. If the list of delimiter characters isn't going to grow too large, create a character array, DelimiterCharacters, and have your function do a one-pass search.

Answer 3

Strictly speaking you can't assume that the various characters are in range, portably. The only characters actually guaranteed to be located in a continuous range in the symbol table are '0' to '9'. That's mostly a nitpick though, since 99.9% of all systems are ASCII or UTF.

What's more serious is that this look-up is slow. You have numerous branches which the CPU must execute. If you have to call this function repeatedly from a loop, it will be performance-heavy. Instead, you can replace all of this with a look-up table.

For boolean checks, you should be using bool.

A fixed function might look like this:

#include <stdbool.h>

bool isdelimit (char ch)
{
  ch &= 0x7F; // ensure 7 bit 

  const bool DELIMIT[128] = 
  {
    ['\n'] = true,
    ['\t'] = true,
    [' ']  = true,
    ['\0'] = true,
    // ...
  };
  return DELIMIT[ch];
}

The table DELIMIT will per default initialize all items to false save for those that you explicitly initialize. By using the character value as the search key, the algorithm turns branchless and efficient.

The above trick with using designated initializers means that you only need to type out those delimiters you are interested in, rather than typing out a big table of 127 values.

Also check out the rarely used but 100% standard C functions strpbrk and strcspn (string.h) that can be used for this very purpose too.