60 lines
2.1 KiB
C
60 lines
2.1 KiB
C
#include "utf8.h"
|
|
|
|
// This macro tests if a char is a continuation byte in utf8.
|
|
#define IS_CONT(x) (((x) & 0xc0) == 0x80)
|
|
|
|
// This returns the code point encoded at **s and advances *s to point to the
|
|
// next character. Thus it can easily be used in a loop.
|
|
int decode_code_point(const char **s) {
|
|
int k = **s ? __builtin_clz(~(**s << 24)) : 0; // Count # of leading 1 bits.
|
|
int mask = (1 << (8 - k)) - 1; // All 1s with k leading 0s.
|
|
int value = **s & mask;
|
|
// k = 0 for one-byte code points; otherwise, k = #total bytes.
|
|
for (++(*s), --k; k > 0 && IS_CONT(**s); --k, ++(*s)) {
|
|
value <<= 6;
|
|
value += (**s & 0x3F);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
// This assumes that `code` is <= 0x10FFFF and ensures that nothing will be
|
|
// written at or beyond `end`. It advances *s so it's easy to use in a loop.
|
|
void encode_code_point(char **s, char *end, int code) {
|
|
char val[4];
|
|
int lead_byte_max = 0x7F;
|
|
int val_index = 0;
|
|
while (code > lead_byte_max) {
|
|
val[val_index++] = (code & 0x3F) | 0x80;
|
|
code >>= 6;
|
|
lead_byte_max >>= (val_index == 1 ? 2 : 1);
|
|
}
|
|
val[val_index++] = (code & lead_byte_max) | (~lead_byte_max << 1);
|
|
while (val_index-- && *s < end) {
|
|
**s = val[val_index];
|
|
(*s)++;
|
|
}
|
|
}
|
|
|
|
// This returns 0 if no split was needed.
|
|
int split_into_surrogates(int code, int *surr1, int *surr2) {
|
|
if (code <= 0xFFFF)
|
|
return 0;
|
|
*surr2 = 0xDC00 | (code & 0x3FF); // Save the low 10 bits.
|
|
code >>= 10; // Drop the low 10 bits.
|
|
// If `code` now has low bits "uuu uuxx xxxx", then the bits of *surr are
|
|
// "1101 10ww wwxx xxxx" where wwww = (uuuuu - 1).
|
|
*surr1 = 0xD800 | ((code & 0x7FF) - 0x40);
|
|
return 1;
|
|
}
|
|
|
|
// This expects to be used in a loop and see all code points in *code. Start
|
|
// *old at 0; this function updates *old for you - don't change it after
|
|
// initialization. This returns 0 when *code is the 1st of a surrogate pair;
|
|
// otherwise use *code as the final code point.
|
|
int join_from_surrogates(int *old, int *code) {
|
|
if (*old)
|
|
*code = (((*old & 0x3FF) + 0x40) << 10) + (*code & 0x3FF);
|
|
*old = ((*code & 0xD800) == 0xD800 ? *code : 0);
|
|
return !(*old);
|
|
}
|