MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
fix really slow string table during compile
+89
-11
+1
include/utf8.h
+1
include/utf8.h
···
20
20
21
21
size_t utf8_strlen(const char *str, size_t byte_len);
22
22
size_t utf16_strlen(const char *str, size_t byte_len);
23
+
size_t byte_offset_to_utf16(const char *str, size_t byte_off);
23
24
size_t utf8_char_len_at(const char *str, size_t byte_len, size_t pos);
24
25
char *utf8_json_quote(const char *str, size_t byte_len, size_t *out_len);
25
26
+19
-10
src/ant.c
+19
-10
src/ant.c
···
8246
8246
ant_offset_t str_len, str_off = vstr(js, str, &str_len);
8247
8247
ant_offset_t search_len, search_off = vstr(js, search, &search_len);
8248
8248
8249
-
ant_offset_t start = 0;
8250
-
double dstr_len = D(str_len);
8249
+
const char *str_ptr = (char *)(uintptr_t)(str_off);
8250
+
const char *search_ptr = (char *)(uintptr_t)(search_off);
8251
+
size_t utf16_len = utf16_strlen(str_ptr, str_len);
8252
+
8253
+
ant_offset_t start_utf16 = 0;
8251
8254
if (nargs >= 2 && vtype(args[1]) == T_NUM) {
8252
8255
double pos = tod(args[1]);
8253
8256
if (pos < 0) pos = 0;
8254
-
if (pos > dstr_len) pos = dstr_len;
8255
-
start = (ant_offset_t) pos;
8257
+
if (pos > D(utf16_len)) pos = D(utf16_len);
8258
+
start_utf16 = (ant_offset_t) pos;
8256
8259
}
8257
8260
8258
-
if (search_len == 0) return tov(D(start));
8259
-
if (start + search_len > str_len) return tov(-1);
8261
+
if (search_len == 0) return tov(D(start_utf16));
8262
+
8263
+
size_t byte_start = 0;
8264
+
if (start_utf16 > 0) {
8265
+
int off = utf16_index_to_byte_offset(str_ptr, str_len, start_utf16, NULL);
8266
+
if (off < 0) return tov(-1);
8267
+
byte_start = (size_t)off;
8268
+
}
8260
8269
8261
-
const char *str_ptr = (char *)(uintptr_t)(str_off);
8262
-
const char *search_ptr = (char *)(uintptr_t)(search_off);
8270
+
if (byte_start + search_len > (size_t)str_len) return tov(-1);
8263
8271
8264
-
for (ant_offset_t i = start; i <= str_len - search_len; i++) {
8265
-
if (memcmp(str_ptr + i, search_ptr, search_len) == 0) return tov(D(i));
8272
+
for (size_t i = byte_start; i <= (size_t)str_len - search_len; i++) {
8273
+
if (memcmp(str_ptr + i, search_ptr, search_len) == 0)
8274
+
return tov(D(byte_offset_to_utf16(str_ptr, i)));
8266
8275
}
8267
8276
return tov(-1);
8268
8277
}
+52
-1
src/silver/compiler.c
+52
-1
src/silver/compiler.c
···
12
12
#include <string.h>
13
13
#include <stdio.h>
14
14
15
+
15
16
enum {
16
17
SV_ITER_HINT_GENERIC = 0,
17
18
SV_ITER_HINT_ARRAY = 1,
···
122
123
int deferred_export_cap;
123
124
124
125
struct const_dedup_entry *const_dedup;
126
+
struct sv_line_table *line_table;
125
127
} sv_compiler_t;
126
128
127
129
typedef struct const_dedup_entry {
···
131
133
UT_hash_handle hh;
132
134
} const_dedup_entry_t;
133
135
136
+
typedef struct sv_line_table {
137
+
uint32_t *offsets;
138
+
int count;
139
+
} sv_line_table_t;
140
+
141
+
static sv_line_table_t *build_line_table(const char *source, ant_offset_t source_len) {
142
+
if (!source || source_len <= 0) return NULL;
143
+
sv_line_table_t *lt = malloc(sizeof(sv_line_table_t));
144
+
if (!lt) return NULL;
145
+
146
+
int cap = (int)(source_len / 32) + 64;
147
+
lt->offsets = malloc((size_t)cap * sizeof(uint32_t));
148
+
lt->count = 0;
149
+
lt->offsets[lt->count++] = 0;
150
+
151
+
for (ant_offset_t i = 0; i < source_len; i++) {
152
+
if (source[i] == '\n') {
153
+
if (lt->count >= cap) {
154
+
cap *= 2;
155
+
lt->offsets = realloc(lt->offsets, (size_t)cap * sizeof(uint32_t));
156
+
}
157
+
lt->offsets[lt->count++] = (uint32_t)(i + 1);
158
+
}
159
+
}
160
+
return lt;
161
+
}
162
+
163
+
static void free_line_table(sv_line_table_t *lt) {
164
+
if (!lt) return;
165
+
free(lt->offsets);
166
+
free(lt);
167
+
}
168
+
169
+
static void line_table_lookup(sv_line_table_t *lt, uint32_t off, uint32_t *out_line, uint32_t *out_col) {
170
+
int lo = 0, hi = lt->count - 1;
171
+
while (lo < hi) {
172
+
int mid = lo + (hi - lo + 1) / 2;
173
+
if (lt->offsets[mid] <= off) lo = mid;
174
+
else hi = mid - 1;
175
+
}
176
+
*out_line = (uint32_t)(lo + 1);
177
+
*out_col = off - lt->offsets[lo] + 1;
178
+
}
179
+
134
180
static sv_func_t *compile_function_body(
135
181
sv_compiler_t *enclosing,
136
182
sv_ast_t *node, sv_compile_mode_t mode
···
231
277
if (c->srcpos_count > 0 && c->last_srcpos_off == off && c->last_srcpos_end == end) return;
232
278
233
279
uint32_t line, col;
234
-
if (c->srcpos_count > 0 && off >= c->last_srcpos_off) {
280
+
if (c->line_table) {
281
+
line_table_lookup(c->line_table, off, &line, &col);
282
+
} else if (c->srcpos_count > 0 && off >= c->last_srcpos_off) {
235
283
line = c->srcpos[c->srcpos_count - 1].line;
236
284
col = c->srcpos[c->srcpos_count - 1].col;
237
285
for (uint32_t i = c->last_srcpos_off; i < off; i++) {
···
4075
4123
comp.filename = enclosing->filename;
4076
4124
comp.source = enclosing->source;
4077
4125
comp.source_len = enclosing->source_len;
4126
+
comp.line_table = enclosing->line_table;
4078
4127
comp.enclosing = enclosing;
4079
4128
comp.scope_depth = 0;
4080
4129
comp.is_arrow = !!(node->flags & FN_ARROW);
···
4724
4773
root.mode = mode;
4725
4774
root.is_strict = ((program->flags & FN_PARSE_STRICT) != 0);
4726
4775
4776
+
root.line_table = build_line_table(root.source, source_len);
4727
4777
sv_func_t *func = compile_function_body(&root, &top_fn, mode);
4778
+
free_line_table(root.line_table);
4728
4779
if (js->thrown_exists || !func) return NULL;
4729
4780
return func;
4730
4781
}
+17
src/utf8.c
+17
src/utf8.c
···
236
236
return 0;
237
237
}
238
238
239
+
size_t byte_offset_to_utf16(const char *str, size_t byte_off) {
240
+
const unsigned char *p = (const unsigned char *)str;
241
+
const unsigned char *end = p + byte_off;
242
+
size_t utf16_pos = 0;
243
+
244
+
while (p < end) {
245
+
unsigned char c = *p;
246
+
if (c < 0x80) { p++; utf16_pos++; }
247
+
else if ((c & 0xE0) == 0xC0) { p += 2; utf16_pos++; }
248
+
else if ((c & 0xF0) == 0xE0) { p += 3; utf16_pos++; }
249
+
else if ((c & 0xF8) == 0xF0) { p += 4; utf16_pos += 2; }
250
+
else { p++; utf16_pos++; }
251
+
if (p > end) p = end;
252
+
}
253
+
return utf16_pos;
254
+
}
255
+
239
256
uint32_t utf16_code_unit_at(const char *str, size_t byte_len, size_t utf16_idx) {
240
257
const unsigned char *p = (const unsigned char *)str;
241
258
const unsigned char *end = p + byte_len;