mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-25 22:10:17 +00:00
997 lines
25 KiB
C
997 lines
25 KiB
C
#include "pocketpy/common/str.h"
|
|
#include "pocketpy/common/sstream.h"
|
|
#include "pocketpy/common/utils.h"
|
|
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
|
|
c11_string* c11_string__new(const char* data) { return c11_string__new2(data, strlen(data)); }
|
|
|
|
c11_string* c11_string__new2(const char* data, int size) {
|
|
c11_string* retval = PK_MALLOC(sizeof(c11_string) + size + 1);
|
|
c11_string__ctor2(retval, data, size);
|
|
return retval;
|
|
}
|
|
|
|
c11_string* c11_string__new3(const char* fmt, ...) {
|
|
c11_sbuf buf;
|
|
c11_sbuf__ctor(&buf);
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
// c11_sbuf__write_vfmt(&buf, fmt, args);
|
|
pk_vsprintf(&buf, fmt, args);
|
|
va_end(args);
|
|
return c11_sbuf__submit(&buf);
|
|
}
|
|
|
|
void c11_string__ctor(c11_string* self, const char* data) {
|
|
c11_string__ctor2(self, data, strlen(data));
|
|
}
|
|
|
|
void c11_string__ctor2(c11_string* self, const char* data, int size) {
|
|
self->size = size;
|
|
char* p = (char*)self->data;
|
|
memcpy(p, data, size);
|
|
p[size] = '\0';
|
|
}
|
|
|
|
void c11_string__ctor3(c11_string* self, int size) {
|
|
self->size = size;
|
|
char* p = (char*)self->data;
|
|
p[size] = '\0';
|
|
}
|
|
|
|
c11_string* c11_string__copy(c11_string* self) {
|
|
int total_size = sizeof(c11_string) + self->size + 1;
|
|
c11_string* retval = PK_MALLOC(total_size);
|
|
memcpy(retval, self, total_size);
|
|
return retval;
|
|
}
|
|
|
|
void c11_string__delete(c11_string* self) { PK_FREE(self); }
|
|
|
|
c11_sv c11_string__sv(c11_string* self) { return (c11_sv){self->data, self->size}; }
|
|
|
|
c11_string* c11_sv__replace(c11_sv self, char old, char new_) {
|
|
c11_string* retval = c11_string__new2(self.data, self.size);
|
|
char* p = (char*)retval->data;
|
|
for(int i = 0; i < retval->size; i++) {
|
|
if(p[i] == old) p[i] = new_;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
c11_string* c11_sv__replace2(c11_sv self, c11_sv old, c11_sv new_) {
|
|
c11_sbuf buf;
|
|
c11_sbuf__ctor(&buf);
|
|
int start = 0;
|
|
while(true) {
|
|
int i = c11_sv__index2(self, old, start);
|
|
if(i == -1) break;
|
|
c11_sv tmp = c11_sv__slice2(self, start, i);
|
|
c11_sbuf__write_sv(&buf, tmp);
|
|
c11_sbuf__write_sv(&buf, new_);
|
|
start = i + old.size;
|
|
}
|
|
c11_sv tmp = c11_sv__slice2(self, start, self.size);
|
|
c11_sbuf__write_sv(&buf, tmp);
|
|
return c11_sbuf__submit(&buf);
|
|
}
|
|
|
|
int c11_sv__u8_length(c11_sv sv) { return c11__byte_index_to_unicode(sv.data, sv.size); }
|
|
|
|
c11_sv c11_sv__u8_getitem(c11_sv sv, int i) {
|
|
i = c11__unicode_index_to_byte(sv.data, i);
|
|
int size = c11__u8_header(sv.data[i], false);
|
|
return c11_sv__slice2(sv, i, i + size);
|
|
}
|
|
|
|
c11_string* c11_sv__u8_slice(c11_sv sv, int start, int stop, int step) {
|
|
c11_sbuf ss;
|
|
c11_sbuf__ctor(&ss);
|
|
assert(step != 0);
|
|
for(int i = start; step > 0 ? i < stop : i > stop; i += step) {
|
|
c11_sv unicode = c11_sv__u8_getitem(sv, i);
|
|
c11_sbuf__write_sv(&ss, unicode);
|
|
}
|
|
return c11_sbuf__submit(&ss);
|
|
}
|
|
|
|
/////////////////////////////////////////
|
|
c11_sv c11_sv__slice(c11_sv sv, int start) { return c11_sv__slice2(sv, start, sv.size); }
|
|
|
|
c11_sv c11_sv__slice2(c11_sv sv, int start, int stop) {
|
|
if(start < 0) start = 0;
|
|
if(stop < start) stop = start;
|
|
if(stop > sv.size) stop = sv.size;
|
|
return (c11_sv){sv.data + start, stop - start};
|
|
}
|
|
|
|
c11_sv c11_sv__strip(c11_sv sv, c11_sv chars, bool left, bool right) {
|
|
int L = 0;
|
|
int R = c11_sv__u8_length(sv);
|
|
if(left) {
|
|
while(L < R) {
|
|
c11_sv tmp = c11_sv__u8_getitem(sv, L);
|
|
bool found = c11_sv__index2(chars, tmp, 0) != -1;
|
|
if(!found) break;
|
|
L++;
|
|
}
|
|
}
|
|
if(right) {
|
|
while(L < R) {
|
|
c11_sv tmp = c11_sv__u8_getitem(sv, R - 1);
|
|
bool found = c11_sv__index2(chars, tmp, 0) != -1;
|
|
if(!found) break;
|
|
R--;
|
|
}
|
|
}
|
|
int start = c11__unicode_index_to_byte(sv.data, L);
|
|
int stop = c11__unicode_index_to_byte(sv.data, R);
|
|
return c11_sv__slice2(sv, start, stop);
|
|
}
|
|
|
|
int c11_sv__index(c11_sv self, char c) {
|
|
for(int i = 0; i < self.size; i++) {
|
|
if(self.data[i] == c) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int c11_sv__rindex(c11_sv self, char c) {
|
|
for(int i = self.size - 1; i >= 0; i--) {
|
|
if(self.data[i] == c) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int c11_sv__index2(c11_sv self, c11_sv sub, int start) {
|
|
if(sub.size == 0) return start;
|
|
int max_end = self.size - sub.size;
|
|
for(int i = start; i <= max_end; i++) {
|
|
int res = memcmp(self.data + i, sub.data, sub.size);
|
|
if(res == 0) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int c11_sv__count(c11_sv self, c11_sv sub) {
|
|
if(sub.size == 0) return self.size + 1;
|
|
int cnt = 0;
|
|
int start = 0;
|
|
while(true) {
|
|
int i = c11_sv__index2(self, sub, start);
|
|
if(i == -1) break;
|
|
cnt++;
|
|
start = i + sub.size;
|
|
}
|
|
return cnt;
|
|
}
|
|
|
|
bool c11_sv__startswith(c11_sv self, c11_sv prefix) {
|
|
if(prefix.size > self.size) return false;
|
|
return memcmp(self.data, prefix.data, prefix.size) == 0;
|
|
}
|
|
|
|
bool c11_sv__endswith(c11_sv self, c11_sv suffix) {
|
|
if(suffix.size > self.size) return false;
|
|
return memcmp(self.data + self.size - suffix.size, suffix.data, suffix.size) == 0;
|
|
}
|
|
|
|
uint64_t c11_sv__hash(c11_sv self) {
|
|
uint64_t hash = 5381;
|
|
for(int i = 0; i < self.size; i++) {
|
|
// hash * 33 + c
|
|
hash = ((hash << 5) + hash) + (unsigned char)self.data[i];
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
c11_vector /* T=c11_sv */ c11_sv__splitwhitespace(c11_sv self) {
|
|
c11_vector retval;
|
|
c11_vector__ctor(&retval, sizeof(c11_sv));
|
|
const char* data = self.data;
|
|
int i = 0;
|
|
for(int j = 0; j < self.size; j++) {
|
|
if(isspace(data[j])) {
|
|
assert(j >= i);
|
|
c11_sv tmp = {data + i, j - i};
|
|
c11_vector__push(c11_sv, &retval, tmp);
|
|
i = j + 1;
|
|
}
|
|
}
|
|
if(i <= self.size) {
|
|
c11_sv tmp = {data + i, self.size - i};
|
|
c11_vector__push(c11_sv, &retval, tmp);
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
c11_vector /* T=c11_sv */ c11_sv__split(c11_sv self, char sep) {
|
|
c11_vector retval;
|
|
c11_vector__ctor(&retval, sizeof(c11_sv));
|
|
const char* data = self.data;
|
|
int i = 0;
|
|
for(int j = 0; j < self.size; j++) {
|
|
if(data[j] == sep) {
|
|
assert(j >= i);
|
|
c11_sv tmp = {data + i, j - i};
|
|
c11_vector__push(c11_sv, &retval, tmp);
|
|
i = j + 1;
|
|
}
|
|
}
|
|
if(i <= self.size) {
|
|
c11_sv tmp = {data + i, self.size - i};
|
|
c11_vector__push(c11_sv, &retval, tmp);
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
c11_vector /* T=c11_sv */ c11_sv__split2(c11_sv self, c11_sv sep) {
|
|
if(sep.size == 1) return c11_sv__split(self, sep.data[0]);
|
|
c11_vector retval;
|
|
c11_vector__ctor(&retval, sizeof(c11_sv));
|
|
int start = 0;
|
|
const char* data = self.data;
|
|
while(true) {
|
|
int i = c11_sv__index2(self, sep, start);
|
|
if(i == -1) break;
|
|
c11_sv tmp = {data + start, i - start};
|
|
c11_vector__push(c11_sv, &retval, tmp);
|
|
start = i + sep.size;
|
|
}
|
|
c11_sv tmp = {data + start, self.size - start};
|
|
c11_vector__push(c11_sv, &retval, tmp);
|
|
return retval;
|
|
}
|
|
|
|
int c11__unicode_index_to_byte(const char* data, int i) {
|
|
int j = 0;
|
|
while(i > 0) {
|
|
j += c11__u8_header(data[j], false);
|
|
i--;
|
|
}
|
|
return j;
|
|
}
|
|
|
|
int c11__byte_index_to_unicode(const char* data, int n) {
|
|
int cnt = 0;
|
|
for(int i = 0; i < n; i++) {
|
|
if((data[i] & 0xC0) != 0x80) cnt++;
|
|
}
|
|
return cnt;
|
|
}
|
|
|
|
//////////////
|
|
bool c11_bytes__eq(c11_bytes* self, c11_bytes* other) {
|
|
if(self->size != other->size) return false;
|
|
return memcmp(self->data, other->data, self->size) == 0;
|
|
}
|
|
|
|
int c11_sv__cmp(c11_sv self, c11_sv other) {
|
|
int res = strncmp(self.data, other.data, c11__min(self.size, other.size));
|
|
if(res != 0) return res;
|
|
return self.size - other.size;
|
|
}
|
|
|
|
int c11_sv__cmp2(c11_sv self, const char* other) {
|
|
int size = strlen(other);
|
|
int res = strncmp(self.data, other, c11__min(self.size, size));
|
|
if(res != 0) return res;
|
|
return self.size - size;
|
|
}
|
|
|
|
bool c11__streq(const char* a, const char* b) { return strcmp(a, b) == 0; }
|
|
|
|
bool c11__sveq(c11_sv a, c11_sv b) {
|
|
if(a.size != b.size) return false;
|
|
return memcmp(a.data, b.data, a.size) == 0;
|
|
}
|
|
|
|
bool c11__sveq2(c11_sv a, const char* b) {
|
|
int size = strlen(b);
|
|
if(a.size != size) return false;
|
|
return memcmp(a.data, b, size) == 0;
|
|
}
|
|
|
|
int c11__u8_header(unsigned char c, bool suppress) {
|
|
if((c & 0b10000000) == 0) return 1;
|
|
if((c & 0b11100000) == 0b11000000) return 2;
|
|
if((c & 0b11110000) == 0b11100000) return 3;
|
|
if((c & 0b11111000) == 0b11110000) return 4;
|
|
if((c & 0b11111100) == 0b11111000) return 5;
|
|
if((c & 0b11111110) == 0b11111100) return 6;
|
|
if(!suppress) c11__abort("invalid utf8 char");
|
|
return 0;
|
|
}
|
|
|
|
int c11__u8_value(int u8bytes, const char* data) {
|
|
assert(u8bytes != 0);
|
|
if(u8bytes == 1) return (int)data[0];
|
|
uint32_t value = 0;
|
|
for(int k = 0; k < u8bytes; k++) {
|
|
uint8_t b = data[k];
|
|
if(k == 0) {
|
|
if(u8bytes == 2)
|
|
value = (b & 0b00011111) << 6;
|
|
else if(u8bytes == 3)
|
|
value = (b & 0b00001111) << 12;
|
|
else if(u8bytes == 4)
|
|
value = (b & 0b00000111) << 18;
|
|
} else {
|
|
value |= (b & 0b00111111) << (6 * (u8bytes - k - 1));
|
|
}
|
|
}
|
|
return (int)value;
|
|
}
|
|
|
|
int c11__u32_to_u8(uint32_t utf32_char, char utf8_output[4]) {
|
|
int length = 0;
|
|
|
|
if(utf32_char <= 0x7F) {
|
|
// 1-byte UTF-8
|
|
utf8_output[0] = (char)utf32_char;
|
|
length = 1;
|
|
} else if(utf32_char <= 0x7FF) {
|
|
// 2-byte UTF-8
|
|
utf8_output[0] = (char)(0xC0 | ((utf32_char >> 6) & 0x1F));
|
|
utf8_output[1] = (char)(0x80 | (utf32_char & 0x3F));
|
|
length = 2;
|
|
} else if(utf32_char <= 0xFFFF) {
|
|
// 3-byte UTF-8
|
|
utf8_output[0] = (char)(0xE0 | ((utf32_char >> 12) & 0x0F));
|
|
utf8_output[1] = (char)(0x80 | ((utf32_char >> 6) & 0x3F));
|
|
utf8_output[2] = (char)(0x80 | (utf32_char & 0x3F));
|
|
length = 3;
|
|
} else if(utf32_char <= 0x10FFFF) {
|
|
// 4-byte UTF-8
|
|
utf8_output[0] = (char)(0xF0 | ((utf32_char >> 18) & 0x07));
|
|
utf8_output[1] = (char)(0x80 | ((utf32_char >> 12) & 0x3F));
|
|
utf8_output[2] = (char)(0x80 | ((utf32_char >> 6) & 0x3F));
|
|
utf8_output[3] = (char)(0x80 | (utf32_char & 0x3F));
|
|
length = 4;
|
|
} else {
|
|
// Invalid UTF-32 character
|
|
return -1;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
char* c11_strdup(const char* str) {
|
|
int len = strlen(str);
|
|
char* dst = PK_MALLOC(len + 1);
|
|
memcpy(dst, str, len);
|
|
dst[len] = '\0';
|
|
return dst;
|
|
}
|
|
|
|
unsigned char* c11_memdup(const unsigned char* src, int size) {
|
|
unsigned char* dst = PK_MALLOC(size);
|
|
memcpy(dst, src, size);
|
|
return dst;
|
|
}
|
|
|
|
IntParsingResult c11__parse_uint(c11_sv text, int64_t* out, int base) {
|
|
*out = 0;
|
|
|
|
c11_sv prefix = {.data = text.data, .size = c11__min(2, text.size)};
|
|
if(base == -1) {
|
|
if(c11__sveq2(prefix, "0b"))
|
|
base = 2;
|
|
else if(c11__sveq2(prefix, "0o"))
|
|
base = 8;
|
|
else if(c11__sveq2(prefix, "0x"))
|
|
base = 16;
|
|
else
|
|
base = 10;
|
|
}
|
|
|
|
if(base == 10) {
|
|
// 10-base 12334
|
|
if(text.size == 0) return IntParsing_FAILURE;
|
|
for(int i = 0; i < text.size; i++) {
|
|
char c = text.data[i];
|
|
if(c >= '0' && c <= '9') {
|
|
*out = (*out * 10) + (c - '0');
|
|
} else {
|
|
return IntParsing_FAILURE;
|
|
}
|
|
}
|
|
// "9223372036854775807".__len__() == 19
|
|
if(text.size > 19) return IntParsing_OVERFLOW;
|
|
return IntParsing_SUCCESS;
|
|
} else if(base == 2) {
|
|
// 2-base 0b101010
|
|
if(c11__sveq2(prefix, "0b")) {
|
|
// text.remove_prefix(2);
|
|
text = (c11_sv){text.data + 2, text.size - 2};
|
|
}
|
|
if(text.size == 0) return IntParsing_FAILURE;
|
|
for(int i = 0; i < text.size; i++) {
|
|
char c = text.data[i];
|
|
if(c == '0' || c == '1') {
|
|
*out = (*out << 1) | (c - '0');
|
|
} else {
|
|
return IntParsing_FAILURE;
|
|
}
|
|
}
|
|
// "111111111111111111111111111111111111111111111111111111111111111".__len__() == 63
|
|
if(text.size > 63) return IntParsing_OVERFLOW;
|
|
return IntParsing_SUCCESS;
|
|
} else if(base == 8) {
|
|
// 8-base 0o123
|
|
if(c11__sveq2(prefix, "0o")) {
|
|
// text.remove_prefix(2);
|
|
text = (c11_sv){text.data + 2, text.size - 2};
|
|
}
|
|
if(text.size == 0) return IntParsing_FAILURE;
|
|
for(int i = 0; i < text.size; i++) {
|
|
char c = text.data[i];
|
|
if(c >= '0' && c <= '7') {
|
|
*out = (*out << 3) | (c - '0');
|
|
} else {
|
|
return IntParsing_FAILURE;
|
|
}
|
|
}
|
|
// "777777777777777777777".__len__() == 21
|
|
if(text.size > 21) return IntParsing_OVERFLOW;
|
|
return IntParsing_SUCCESS;
|
|
} else if(base == 16) {
|
|
// 16-base 0x123
|
|
if(c11__sveq2(prefix, "0x")) {
|
|
// text.remove_prefix(2);
|
|
text = (c11_sv){text.data + 2, text.size - 2};
|
|
}
|
|
if(text.size == 0) return IntParsing_FAILURE;
|
|
for(int i = 0; i < text.size; i++) {
|
|
char c = text.data[i];
|
|
if(c >= '0' && c <= '9') {
|
|
*out = (*out << 4) | (c - '0');
|
|
} else if(c >= 'a' && c <= 'f') {
|
|
*out = (*out << 4) | (c - 'a' + 10);
|
|
} else if(c >= 'A' && c <= 'F') {
|
|
*out = (*out << 4) | (c - 'A' + 10);
|
|
} else {
|
|
return IntParsing_FAILURE;
|
|
}
|
|
}
|
|
// "7fffffffffffffff".__len__() == 16
|
|
if(text.size > 16) return IntParsing_OVERFLOW;
|
|
return IntParsing_SUCCESS;
|
|
}
|
|
return IntParsing_FAILURE;
|
|
}
|
|
|
|
const char* c11__search_u32_ranges(int c, const c11_u32_range* p, int n_ranges) {
|
|
int lbound = 0;
|
|
int ubound = n_ranges - 1;
|
|
|
|
if(c < p[0].start || c > p[ubound].end) return NULL;
|
|
while(ubound >= lbound) {
|
|
int mid = (lbound + ubound) / 2;
|
|
if(c > p[mid].end) {
|
|
lbound = mid + 1;
|
|
} else if(c < p[mid].start) {
|
|
ubound = mid - 1;
|
|
} else {
|
|
return p[mid].data;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// clang-format off
|
|
const static c11_u32_range kLoRanges[] = {
|
|
{ 170, 170 },
|
|
{ 186, 186 },
|
|
{ 443, 443 },
|
|
{ 448, 451 },
|
|
{ 660, 660 },
|
|
{ 1488, 1514 },
|
|
{ 1519, 1522 },
|
|
{ 1568, 1599 },
|
|
{ 1601, 1610 },
|
|
{ 1646, 1647 },
|
|
{ 1649, 1747 },
|
|
{ 1749, 1749 },
|
|
{ 1774, 1775 },
|
|
{ 1786, 1788 },
|
|
{ 1791, 1791 },
|
|
{ 1808, 1808 },
|
|
{ 1810, 1839 },
|
|
{ 1869, 1957 },
|
|
{ 1969, 1969 },
|
|
{ 1994, 2026 },
|
|
{ 2048, 2069 },
|
|
{ 2112, 2136 },
|
|
{ 2144, 2154 },
|
|
{ 2160, 2183 },
|
|
{ 2185, 2190 },
|
|
{ 2208, 2248 },
|
|
{ 2308, 2361 },
|
|
{ 2365, 2365 },
|
|
{ 2384, 2384 },
|
|
{ 2392, 2401 },
|
|
{ 2418, 2432 },
|
|
{ 2437, 2444 },
|
|
{ 2447, 2448 },
|
|
{ 2451, 2472 },
|
|
{ 2474, 2480 },
|
|
{ 2482, 2482 },
|
|
{ 2486, 2489 },
|
|
{ 2493, 2493 },
|
|
{ 2510, 2510 },
|
|
{ 2524, 2525 },
|
|
{ 2527, 2529 },
|
|
{ 2544, 2545 },
|
|
{ 2556, 2556 },
|
|
{ 2565, 2570 },
|
|
{ 2575, 2576 },
|
|
{ 2579, 2600 },
|
|
{ 2602, 2608 },
|
|
{ 2610, 2611 },
|
|
{ 2613, 2614 },
|
|
{ 2616, 2617 },
|
|
{ 2649, 2652 },
|
|
{ 2654, 2654 },
|
|
{ 2674, 2676 },
|
|
{ 2693, 2701 },
|
|
{ 2703, 2705 },
|
|
{ 2707, 2728 },
|
|
{ 2730, 2736 },
|
|
{ 2738, 2739 },
|
|
{ 2741, 2745 },
|
|
{ 2749, 2749 },
|
|
{ 2768, 2768 },
|
|
{ 2784, 2785 },
|
|
{ 2809, 2809 },
|
|
{ 2821, 2828 },
|
|
{ 2831, 2832 },
|
|
{ 2835, 2856 },
|
|
{ 2858, 2864 },
|
|
{ 2866, 2867 },
|
|
{ 2869, 2873 },
|
|
{ 2877, 2877 },
|
|
{ 2908, 2909 },
|
|
{ 2911, 2913 },
|
|
{ 2929, 2929 },
|
|
{ 2947, 2947 },
|
|
{ 2949, 2954 },
|
|
{ 2958, 2960 },
|
|
{ 2962, 2965 },
|
|
{ 2969, 2970 },
|
|
{ 2972, 2972 },
|
|
{ 2974, 2975 },
|
|
{ 2979, 2980 },
|
|
{ 2984, 2986 },
|
|
{ 2990, 3001 },
|
|
{ 3024, 3024 },
|
|
{ 3077, 3084 },
|
|
{ 3086, 3088 },
|
|
{ 3090, 3112 },
|
|
{ 3114, 3129 },
|
|
{ 3133, 3133 },
|
|
{ 3160, 3162 },
|
|
{ 3165, 3165 },
|
|
{ 3168, 3169 },
|
|
{ 3200, 3200 },
|
|
{ 3205, 3212 },
|
|
{ 3214, 3216 },
|
|
{ 3218, 3240 },
|
|
{ 3242, 3251 },
|
|
{ 3253, 3257 },
|
|
{ 3261, 3261 },
|
|
{ 3293, 3294 },
|
|
{ 3296, 3297 },
|
|
{ 3313, 3314 },
|
|
{ 3332, 3340 },
|
|
{ 3342, 3344 },
|
|
{ 3346, 3386 },
|
|
{ 3389, 3389 },
|
|
{ 3406, 3406 },
|
|
{ 3412, 3414 },
|
|
{ 3423, 3425 },
|
|
{ 3450, 3455 },
|
|
{ 3461, 3478 },
|
|
{ 3482, 3505 },
|
|
{ 3507, 3515 },
|
|
{ 3517, 3517 },
|
|
{ 3520, 3526 },
|
|
{ 3585, 3632 },
|
|
{ 3634, 3635 },
|
|
{ 3648, 3653 },
|
|
{ 3713, 3714 },
|
|
{ 3716, 3716 },
|
|
{ 3718, 3722 },
|
|
{ 3724, 3747 },
|
|
{ 3749, 3749 },
|
|
{ 3751, 3760 },
|
|
{ 3762, 3763 },
|
|
{ 3773, 3773 },
|
|
{ 3776, 3780 },
|
|
{ 3804, 3807 },
|
|
{ 3840, 3840 },
|
|
{ 3904, 3911 },
|
|
{ 3913, 3948 },
|
|
{ 3976, 3980 },
|
|
{ 4096, 4138 },
|
|
{ 4159, 4159 },
|
|
{ 4176, 4181 },
|
|
{ 4186, 4189 },
|
|
{ 4193, 4193 },
|
|
{ 4197, 4198 },
|
|
{ 4206, 4208 },
|
|
{ 4213, 4225 },
|
|
{ 4238, 4238 },
|
|
{ 4352, 4680 },
|
|
{ 4682, 4685 },
|
|
{ 4688, 4694 },
|
|
{ 4696, 4696 },
|
|
{ 4698, 4701 },
|
|
{ 4704, 4744 },
|
|
{ 4746, 4749 },
|
|
{ 4752, 4784 },
|
|
{ 4786, 4789 },
|
|
{ 4792, 4798 },
|
|
{ 4800, 4800 },
|
|
{ 4802, 4805 },
|
|
{ 4808, 4822 },
|
|
{ 4824, 4880 },
|
|
{ 4882, 4885 },
|
|
{ 4888, 4954 },
|
|
{ 4992, 5007 },
|
|
{ 5121, 5740 },
|
|
{ 5743, 5759 },
|
|
{ 5761, 5786 },
|
|
{ 5792, 5866 },
|
|
{ 5873, 5880 },
|
|
{ 5888, 5905 },
|
|
{ 5919, 5937 },
|
|
{ 5952, 5969 },
|
|
{ 5984, 5996 },
|
|
{ 5998, 6000 },
|
|
{ 6016, 6067 },
|
|
{ 6108, 6108 },
|
|
{ 6176, 6210 },
|
|
{ 6212, 6264 },
|
|
{ 6272, 6276 },
|
|
{ 6279, 6312 },
|
|
{ 6314, 6314 },
|
|
{ 6320, 6389 },
|
|
{ 6400, 6430 },
|
|
{ 6480, 6509 },
|
|
{ 6512, 6516 },
|
|
{ 6528, 6571 },
|
|
{ 6576, 6601 },
|
|
{ 6656, 6678 },
|
|
{ 6688, 6740 },
|
|
{ 6917, 6963 },
|
|
{ 6981, 6988 },
|
|
{ 7043, 7072 },
|
|
{ 7086, 7087 },
|
|
{ 7098, 7141 },
|
|
{ 7168, 7203 },
|
|
{ 7245, 7247 },
|
|
{ 7258, 7287 },
|
|
{ 7401, 7404 },
|
|
{ 7406, 7411 },
|
|
{ 7413, 7414 },
|
|
{ 7418, 7418 },
|
|
{ 8501, 8504 },
|
|
{ 11568, 11623 },
|
|
{ 11648, 11670 },
|
|
{ 11680, 11686 },
|
|
{ 11688, 11694 },
|
|
{ 11696, 11702 },
|
|
{ 11704, 11710 },
|
|
{ 11712, 11718 },
|
|
{ 11720, 11726 },
|
|
{ 11728, 11734 },
|
|
{ 11736, 11742 },
|
|
{ 12294, 12294 },
|
|
{ 12348, 12348 },
|
|
{ 12353, 12438 },
|
|
{ 12447, 12447 },
|
|
{ 12449, 12538 },
|
|
{ 12543, 12543 },
|
|
{ 12549, 12591 },
|
|
{ 12593, 12686 },
|
|
{ 12704, 12735 },
|
|
{ 12784, 12799 },
|
|
{ 13312, 19903 },
|
|
{ 19968, 40980 },
|
|
{ 40982, 42124 },
|
|
{ 42192, 42231 },
|
|
{ 42240, 42507 },
|
|
{ 42512, 42527 },
|
|
{ 42538, 42539 },
|
|
{ 42606, 42606 },
|
|
{ 42656, 42725 },
|
|
{ 42895, 42895 },
|
|
{ 42999, 42999 },
|
|
{ 43003, 43009 },
|
|
{ 43011, 43013 },
|
|
{ 43015, 43018 },
|
|
{ 43020, 43042 },
|
|
{ 43072, 43123 },
|
|
{ 43138, 43187 },
|
|
{ 43250, 43255 },
|
|
{ 43259, 43259 },
|
|
{ 43261, 43262 },
|
|
{ 43274, 43301 },
|
|
{ 43312, 43334 },
|
|
{ 43360, 43388 },
|
|
{ 43396, 43442 },
|
|
{ 43488, 43492 },
|
|
{ 43495, 43503 },
|
|
{ 43514, 43518 },
|
|
{ 43520, 43560 },
|
|
{ 43584, 43586 },
|
|
{ 43588, 43595 },
|
|
{ 43616, 43631 },
|
|
{ 43633, 43638 },
|
|
{ 43642, 43642 },
|
|
{ 43646, 43695 },
|
|
{ 43697, 43697 },
|
|
{ 43701, 43702 },
|
|
{ 43705, 43709 },
|
|
{ 43712, 43712 },
|
|
{ 43714, 43714 },
|
|
{ 43739, 43740 },
|
|
{ 43744, 43754 },
|
|
{ 43762, 43762 },
|
|
{ 43777, 43782 },
|
|
{ 43785, 43790 },
|
|
{ 43793, 43798 },
|
|
{ 43808, 43814 },
|
|
{ 43816, 43822 },
|
|
{ 43968, 44002 },
|
|
{ 44032, 55203 },
|
|
{ 55216, 55238 },
|
|
{ 55243, 55291 },
|
|
{ 63744, 64109 },
|
|
{ 64112, 64217 },
|
|
{ 64285, 64285 },
|
|
{ 64287, 64296 },
|
|
{ 64298, 64310 },
|
|
{ 64312, 64316 },
|
|
{ 64318, 64318 },
|
|
{ 64320, 64321 },
|
|
{ 64323, 64324 },
|
|
{ 64326, 64433 },
|
|
{ 64467, 64829 },
|
|
{ 64848, 64911 },
|
|
{ 64914, 64967 },
|
|
{ 65008, 65019 },
|
|
{ 65136, 65140 },
|
|
{ 65142, 65276 },
|
|
{ 65382, 65391 },
|
|
{ 65393, 65437 },
|
|
{ 65440, 65470 },
|
|
{ 65474, 65479 },
|
|
{ 65482, 65487 },
|
|
{ 65490, 65495 },
|
|
{ 65498, 65500 },
|
|
{ 65536, 65547 },
|
|
{ 65549, 65574 },
|
|
{ 65576, 65594 },
|
|
{ 65596, 65597 },
|
|
{ 65599, 65613 },
|
|
{ 65616, 65629 },
|
|
{ 65664, 65786 },
|
|
{ 66176, 66204 },
|
|
{ 66208, 66256 },
|
|
{ 66304, 66335 },
|
|
{ 66349, 66368 },
|
|
{ 66370, 66377 },
|
|
{ 66384, 66421 },
|
|
{ 66432, 66461 },
|
|
{ 66464, 66499 },
|
|
{ 66504, 66511 },
|
|
{ 66640, 66717 },
|
|
{ 66816, 66855 },
|
|
{ 66864, 66915 },
|
|
{ 67072, 67382 },
|
|
{ 67392, 67413 },
|
|
{ 67424, 67431 },
|
|
{ 67584, 67589 },
|
|
{ 67592, 67592 },
|
|
{ 67594, 67637 },
|
|
{ 67639, 67640 },
|
|
{ 67644, 67644 },
|
|
{ 67647, 67669 },
|
|
{ 67680, 67702 },
|
|
{ 67712, 67742 },
|
|
{ 67808, 67826 },
|
|
{ 67828, 67829 },
|
|
{ 67840, 67861 },
|
|
{ 67872, 67897 },
|
|
{ 67968, 68023 },
|
|
{ 68030, 68031 },
|
|
{ 68096, 68096 },
|
|
{ 68112, 68115 },
|
|
{ 68117, 68119 },
|
|
{ 68121, 68149 },
|
|
{ 68192, 68220 },
|
|
{ 68224, 68252 },
|
|
{ 68288, 68295 },
|
|
{ 68297, 68324 },
|
|
{ 68352, 68405 },
|
|
{ 68416, 68437 },
|
|
{ 68448, 68466 },
|
|
{ 68480, 68497 },
|
|
{ 68608, 68680 },
|
|
{ 68864, 68899 },
|
|
{ 69248, 69289 },
|
|
{ 69296, 69297 },
|
|
{ 69376, 69404 },
|
|
{ 69415, 69415 },
|
|
{ 69424, 69445 },
|
|
{ 69488, 69505 },
|
|
{ 69552, 69572 },
|
|
{ 69600, 69622 },
|
|
{ 69635, 69687 },
|
|
{ 69745, 69746 },
|
|
{ 69749, 69749 },
|
|
{ 69763, 69807 },
|
|
{ 69840, 69864 },
|
|
{ 69891, 69926 },
|
|
{ 69956, 69956 },
|
|
{ 69959, 69959 },
|
|
{ 69968, 70002 },
|
|
{ 70006, 70006 },
|
|
{ 70019, 70066 },
|
|
{ 70081, 70084 },
|
|
{ 70106, 70106 },
|
|
{ 70108, 70108 },
|
|
{ 70144, 70161 },
|
|
{ 70163, 70187 },
|
|
{ 70272, 70278 },
|
|
{ 70280, 70280 },
|
|
{ 70282, 70285 },
|
|
{ 70287, 70301 },
|
|
{ 70303, 70312 },
|
|
{ 70320, 70366 },
|
|
{ 70405, 70412 },
|
|
{ 70415, 70416 },
|
|
{ 70419, 70440 },
|
|
{ 70442, 70448 },
|
|
{ 70450, 70451 },
|
|
{ 70453, 70457 },
|
|
{ 70461, 70461 },
|
|
{ 70480, 70480 },
|
|
{ 70493, 70497 },
|
|
{ 70656, 70708 },
|
|
{ 70727, 70730 },
|
|
{ 70751, 70753 },
|
|
{ 70784, 70831 },
|
|
{ 70852, 70853 },
|
|
{ 70855, 70855 },
|
|
{ 71040, 71086 },
|
|
{ 71128, 71131 },
|
|
{ 71168, 71215 },
|
|
{ 71236, 71236 },
|
|
{ 71296, 71338 },
|
|
{ 71352, 71352 },
|
|
{ 71424, 71450 },
|
|
{ 71488, 71494 },
|
|
{ 71680, 71723 },
|
|
{ 71935, 71942 },
|
|
{ 71945, 71945 },
|
|
{ 71948, 71955 },
|
|
{ 71957, 71958 },
|
|
{ 71960, 71983 },
|
|
{ 71999, 71999 },
|
|
{ 72001, 72001 },
|
|
{ 72096, 72103 },
|
|
{ 72106, 72144 },
|
|
{ 72161, 72161 },
|
|
{ 72163, 72163 },
|
|
{ 72192, 72192 },
|
|
{ 72203, 72242 },
|
|
{ 72250, 72250 },
|
|
{ 72272, 72272 },
|
|
{ 72284, 72329 },
|
|
{ 72349, 72349 },
|
|
{ 72368, 72440 },
|
|
{ 72704, 72712 },
|
|
{ 72714, 72750 },
|
|
{ 72768, 72768 },
|
|
{ 72818, 72847 },
|
|
{ 72960, 72966 },
|
|
{ 72968, 72969 },
|
|
{ 72971, 73008 },
|
|
{ 73030, 73030 },
|
|
{ 73056, 73061 },
|
|
{ 73063, 73064 },
|
|
{ 73066, 73097 },
|
|
{ 73112, 73112 },
|
|
{ 73440, 73458 },
|
|
{ 73648, 73648 },
|
|
{ 73728, 74649 },
|
|
{ 74880, 75075 },
|
|
{ 77712, 77808 },
|
|
{ 77824, 78894 },
|
|
{ 82944, 83526 },
|
|
{ 92160, 92728 },
|
|
{ 92736, 92766 },
|
|
{ 92784, 92862 },
|
|
{ 92880, 92909 },
|
|
{ 92928, 92975 },
|
|
{ 93027, 93047 },
|
|
{ 93053, 93071 },
|
|
{ 93952, 94026 },
|
|
{ 94032, 94032 },
|
|
{ 94208, 100343 },
|
|
{ 100352, 101589 },
|
|
{ 101632, 101640 },
|
|
{ 110592, 110882 },
|
|
{ 110928, 110930 },
|
|
{ 110948, 110951 },
|
|
{ 110960, 111355 },
|
|
{ 113664, 113770 },
|
|
{ 113776, 113788 },
|
|
{ 113792, 113800 },
|
|
{ 113808, 113817 },
|
|
{ 122634, 122634 },
|
|
{ 123136, 123180 },
|
|
{ 123214, 123214 },
|
|
{ 123536, 123565 },
|
|
{ 123584, 123627 },
|
|
{ 124896, 124902 },
|
|
{ 124904, 124907 },
|
|
{ 124909, 124910 },
|
|
{ 124912, 124926 },
|
|
{ 124928, 125124 },
|
|
{ 126464, 126467 },
|
|
{ 126469, 126495 },
|
|
{ 126497, 126498 },
|
|
{ 126500, 126500 },
|
|
{ 126503, 126503 },
|
|
{ 126505, 126514 },
|
|
{ 126516, 126519 },
|
|
{ 126521, 126521 },
|
|
{ 126523, 126523 },
|
|
{ 126530, 126530 },
|
|
{ 126535, 126535 },
|
|
{ 126537, 126537 },
|
|
{ 126539, 126539 },
|
|
{ 126541, 126543 },
|
|
{ 126545, 126546 },
|
|
{ 126548, 126548 },
|
|
{ 126551, 126551 },
|
|
{ 126553, 126553 },
|
|
{ 126555, 126555 },
|
|
{ 126557, 126557 },
|
|
{ 126559, 126559 },
|
|
{ 126561, 126562 },
|
|
{ 126564, 126564 },
|
|
{ 126567, 126570 },
|
|
{ 126572, 126578 },
|
|
{ 126580, 126583 },
|
|
{ 126585, 126588 },
|
|
{ 126590, 126590 },
|
|
{ 126592, 126601 },
|
|
{ 126603, 126619 },
|
|
{ 126625, 126627 },
|
|
{ 126629, 126633 },
|
|
{ 126635, 126651 },
|
|
{ 131072, 173791 },
|
|
{ 173824, 177976 },
|
|
{ 177984, 178205 },
|
|
{ 178208, 183969 },
|
|
{ 183984, 191456 },
|
|
{ 194560, 195101 },
|
|
{ 196608, 201546 },
|
|
};
|
|
// clang-format on
|
|
|
|
bool c11__is_unicode_Lo_char(int c) {
|
|
if(c == 0x1f955) return true;
|
|
const char* data =
|
|
c11__search_u32_ranges(c, kLoRanges, sizeof(kLoRanges) / sizeof(c11_u32_range));
|
|
return data != NULL;
|
|
}
|