What are some ways to integrate the features of ctype.h into JavaScript?

Question

What are some ways to integrate the features of ctype.h into JavaScript?

How can glibc's ctype.h be effectively translated into JavaScript? While I believe it is possible, I am struggling to locate the tables and bitshifting operations used in the C source code. What are the best techniques to employ in this situation?

isalnum(c)
isalpha(c)
iscntrl(c)
isdigit(c)
islower(c)
isgraph(c)
isprint(c)
ispunct(c)
isspace(c)
isupper(c)
isxdigit(c)
isblank(c)

It seems that various techniques are utilized to create these functions depending on the architecture. However, what is the fundamental process for manually converting this to JavaScript? It appears that tables are being used, but I am unable to identify them in the source code.

Examining the openbsd ctype.h source code provides some insight, although the tables remain elusive, leaving uncertainty regarding whether this is the most efficient method for JavaScript. For instance:

__only_inline int isdigit(int _c)
{
  return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & _N));
}

The use of & _N and (_ctype_ + 1)[index] raises questions about their origins and meanings.

The definition of _ctype_ is as follows:

extern const char   *_ctype_;

My limited knowledge of C makes it challenging to grasp the significance of 'extern' and where to locate this table implementation. Perhaps it may be found in ctype_.c, yet its functionality remains unclear to me at this point.

javascript arrays c string byte

Answer 1

Answer №1

Discussing the implementation in OpenBSD:

You may come across a lookup table filled with bitmasks, tailored to match the range of an unsigned char (0-255), which encompasses the ASCII table (0-127).

The higher range (128-255) contains zeros as padding.

It's important to note that there's a preceding byte, providing everything with an offset of +1.

The specific masks are listed at the top of ctype.h:

#define _U  0x01
#define _L  0x02
#define _N  0x04
#define _S  0x08
#define _P  0x10
#define _C  0x20
#define _X  0x40
#define _B  0x80

Each of their binary representations consists of one distinct bit.

The isXXX functions take their argument as int, which is then clamped to an unsigned char after checking for EOF (-1). This numerical value is used to access the lookup table, fetching a value representing the characteristics of each ASCII character.

For example, the first 32 characters of the ASCII table are control characters, indicated here by the mask _C.

LF, or line-feed, acts as both a control and a space character. Its decimal value is 10 (0xA).

If we find this index in the lookup table, we observe that the mask is created by bitwise ORing _C with _S, like so: _C|_S.

isXXX functions assess qualities using bitwise AND (&) and the corresponding bitmask.

For instance, isalnum checks for Uppercase, Lowercase, and Numeric using the mask (_U|_L|_N).

A similar approach can be applied in JavaScript, roughly like this:

const _U = 0x01;
const _L = 0x02;
const _N = 0x04;
/* ... */
const _X = 0x40;

const lookup = {
'A': _U | _X,
/* ... */
'0': _N,
/* ... */
'e': _L | _X,
'p': _L,
};

const get = c => lookup[c] ?? 0;
const isupper = c => get(c) & _U;
const isxdigit = c => get(c) & (_N | _X);

for (let letter of "Apple0")
console.log(isupper(letter), isxdigit(letter));

Note that all of this pertains more or less to the "C" locale. Changing locales will alter the functioning of these functions (man 7 locale).

Answer 2

Discussing the implementation in OpenBSD:

You may come across a lookup table filled with bitmasks, tailored to match the range of an unsigned char (0-255), which encompasses the ASCII table (0-127).

The higher range (128-255) contains zeros as padding.

It's important to note that there's a preceding byte, providing everything with an offset of +1.

The specific masks are listed at the top of ctype.h:

#define _U  0x01
#define _L  0x02
#define _N  0x04
#define _S  0x08
#define _P  0x10
#define _C  0x20
#define _X  0x40
#define _B  0x80