janet_abstract_begin: 1389| 20.6k|void *janet_abstract_begin(const JanetAbstractType *atype, size_t size) { 1390| 20.6k| JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_NONE, 1391| 20.6k| sizeof(JanetAbstractHead) + size); 1392| 20.6k| header->size = size; 1393| 20.6k| header->type = atype; 1394| 20.6k| return (void *) & (header->data); 1395| 20.6k|} janet_abstract_end: 1397| 20.6k|void *janet_abstract_end(void *x) { 1398| 20.6k| janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_ABSTRACT); ------------------ | | 679| 20.6k|#define janet_gc_settype(m, t) ((janet_gc_header(m)->flags |= (0xFF & (t)))) | | ------------------ | | | | 673| 20.6k|#define janet_gc_header(mem) ((JanetGCObject *)(mem)) | | ------------------ ------------------ 1399| 20.6k| return x; 1400| 20.6k|} janet_abstract: 1402| 20.6k|void *janet_abstract(const JanetAbstractType *atype, size_t size) { 1403| 20.6k| return janet_abstract_end(janet_abstract_begin(atype, size)); 1404| 20.6k|} janet_array: 1621| 19.9k|JanetArray *janet_array(int32_t capacity) { 1622| 19.9k| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); 1623| 19.9k| janet_array_impl(array, capacity); 1624| 19.9k| return array; 1625| 19.9k|} janet_array_ensure: 1648| 116M|void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) { 1649| 116M| Janet *newData; 1650| 116M| Janet *old = array->data; 1651| 116M| if (capacity <= array->capacity) return; ------------------ | Branch (1651:9): [True: 116M, False: 1.11k] ------------------ 1652| 1.11k| int64_t new_capacity = ((int64_t) capacity) * growth; 1653| 1.11k| if (new_capacity > INT32_MAX) new_capacity = INT32_MAX; ------------------ | Branch (1653:9): [True: 0, False: 1.11k] ------------------ 1654| 1.11k| capacity = (int32_t) new_capacity; 1655| 1.11k| newData = janet_realloc(old, capacity * sizeof(Janet)); ------------------ | | 2409| 1.11k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 1656| 1.11k| if (NULL == newData) { ------------------ | Branch (1656:9): [True: 0, False: 1.11k] ------------------ 1657| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 1658| 0| } 1659| 1.11k| janet_vm.next_collection += (capacity - array->capacity) * sizeof(Janet); 1660| 1.11k| array->data = newData; 1661| 1.11k| array->capacity = capacity; 1662| 1.11k|} janet_array_push: 1679| 116M|void janet_array_push(JanetArray *array, Janet x) { 1680| 116M| if (array->count == INT32_MAX) { ------------------ | Branch (1680:9): [True: 0, False: 116M] ------------------ 1681| 0| janet_panic("array overflow"); 1682| 0| } 1683| 116M| int32_t newcount = array->count + 1; 1684| 116M| janet_array_ensure(array, newcount, 2); 1685| 116M| array->data[array->count] = x; 1686| 116M| array->count = newcount; 1687| 116M|} janet_lib_array: 1978| 5.65k|void janet_lib_array(JanetTable *env) { 1979| 5.65k| JanetRegExt array_cfuns[] = { 1980| 5.65k| JANET_CORE_REG("array/new", cfun_array_new), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1981| 5.65k| JANET_CORE_REG("array/weak", cfun_array_weak), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1982| 5.65k| JANET_CORE_REG("array/new-filled", cfun_array_new_filled), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1983| 5.65k| JANET_CORE_REG("array/fill", cfun_array_fill), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1984| 5.65k| JANET_CORE_REG("array/pop", cfun_array_pop), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1985| 5.65k| JANET_CORE_REG("array/peek", cfun_array_peek), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1986| 5.65k| JANET_CORE_REG("array/push", cfun_array_push), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1987| 5.65k| JANET_CORE_REG("array/ensure", cfun_array_ensure), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1988| 5.65k| JANET_CORE_REG("array/slice", cfun_array_slice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1989| 5.65k| JANET_CORE_REG("array/concat", cfun_array_concat), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1990| 5.65k| JANET_CORE_REG("array/insert", cfun_array_insert), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1991| 5.65k| JANET_CORE_REG("array/remove", cfun_array_remove), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1992| 5.65k| JANET_CORE_REG("array/trim", cfun_array_trim), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1993| 5.65k| JANET_CORE_REG("array/clear", cfun_array_clear), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1994| 5.65k| JANET_CORE_REG("array/join", cfun_array_join), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1995| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 1996| 5.65k| }; 1997| | janet_core_cfuns_ext(env, NULL, array_cfuns); 1998| 5.65k|} janet_lib_asm: 3143| 5.65k|void janet_lib_asm(JanetTable *env) { 3144| 5.65k| JanetRegExt asm_cfuns[] = { 3145| 5.65k| JANET_CORE_REG("asm", cfun_asm), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3146| 5.65k| JANET_CORE_REG("disasm", cfun_disasm), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3147| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3148| 5.65k| }; 3149| | janet_core_cfuns_ext(env, NULL, asm_cfuns); 3150| 5.65k|} janet_buffer_init: 3211| 9.17M|JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) { 3212| 9.17M| janet_buffer_init_impl(buffer, capacity); 3213| 9.17M| buffer->gc.data.next = NULL; 3214| 9.17M| buffer->gc.flags = JANET_MEM_DISABLED; ------------------ | | 677| 9.17M|#define JANET_MEM_DISABLED 0x200 ------------------ 3215| 9.17M| return buffer; 3216| 9.17M|} janet_buffer_deinit: 3231| 9.18M|void janet_buffer_deinit(JanetBuffer *buffer) { 3232| 9.18M| if (!(buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) { ------------------ | | 1780| 9.18M|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3232:9): [True: 9.18M, False: 0] ------------------ 3233| 9.18M| janet_free(buffer->data); ------------------ | | 2415| 9.18M|#define janet_free(X) free((X)) ------------------ 3234| | buffer->data = NULL; 3235| 9.18M| } 3236| 9.18M|} janet_buffer: 3239| 10.1k|JanetBuffer *janet_buffer(int32_t capacity) { 3240| 10.1k| JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer)); 3241| 10.1k| return janet_buffer_init_impl(buffer, capacity); 3242| 10.1k|} janet_buffer_extra: 3275| 94.1M|void janet_buffer_extra(JanetBuffer *buffer, int32_t n) { 3276| | /* Check for buffer overflow */ 3277| 94.1M| if ((int64_t)n + buffer->count > INT32_MAX) { ------------------ | Branch (3277:9): [True: 0, False: 94.1M] ------------------ 3278| 0| janet_panic("buffer overflow"); 3279| 0| } 3280| 94.1M| int32_t new_size = buffer->count + n; 3281| 94.1M| if (new_size > buffer->capacity) { ------------------ | Branch (3281:9): [True: 7.17M, False: 87.0M] ------------------ 3282| 7.17M| janet_buffer_can_realloc(buffer); 3283| 7.17M| int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2); ------------------ | Branch (3283:32): [True: 0, False: 7.17M] ------------------ 3284| 7.17M| uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t)); ------------------ | | 2409| 7.17M|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 3285| 7.17M| janet_gcpressure(new_capacity - buffer->capacity); 3286| 7.17M| if (NULL == new_data) { ------------------ | Branch (3286:13): [True: 0, False: 7.17M] ------------------ 3287| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 3288| 0| } 3289| 7.17M| buffer->data = new_data; 3290| 7.17M| buffer->capacity = new_capacity; 3291| 7.17M| } 3292| 94.1M|} janet_buffer_push_cstring: 3295| 27.7k|void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) { 3296| 27.7k| int32_t len = (int32_t) strlen(cstring); 3297| 27.7k| janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len); 3298| 27.7k|} janet_buffer_push_bytes: 3301| 9.37M|void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) { 3302| 9.37M| if (0 == length) return; ------------------ | Branch (3302:9): [True: 3.97k, False: 9.36M] ------------------ 3303| 9.36M| janet_buffer_extra(buffer, length); 3304| 9.36M| memcpy(buffer->data + buffer->count, string, length); 3305| 9.36M| buffer->count += length; 3306| 9.36M|} janet_buffer_push_u8: 3313| 84.8M|void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t byte) { 3314| 84.8M| janet_buffer_extra(buffer, 1); 3315| 84.8M| buffer->data[buffer->count] = byte; 3316| 84.8M| buffer->count++; 3317| 84.8M|} janet_lib_buffer: 3837| 5.65k|void janet_lib_buffer(JanetTable *env) { 3838| 5.65k| JanetRegExt buffer_cfuns[] = { 3839| 5.65k| JANET_CORE_REG("buffer/new", cfun_buffer_new), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3840| 5.65k| JANET_CORE_REG("buffer/new-filled", cfun_buffer_new_filled), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3841| 5.65k| JANET_CORE_REG("buffer/from-bytes", cfun_buffer_frombytes), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3842| 5.65k| JANET_CORE_REG("buffer/fill", cfun_buffer_fill), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3843| 5.65k| JANET_CORE_REG("buffer/trim", cfun_buffer_trim), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3844| 5.65k| JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3845| 5.65k| JANET_CORE_REG("buffer/push-word", cfun_buffer_word), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3846| 5.65k| JANET_CORE_REG("buffer/push-string", cfun_buffer_chars), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3847| 5.65k| JANET_CORE_REG("buffer/push-uint16", cfun_buffer_push_uint16), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3848| 5.65k| JANET_CORE_REG("buffer/push-uint32", cfun_buffer_push_uint32), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3849| 5.65k| JANET_CORE_REG("buffer/push-uint64", cfun_buffer_push_uint64), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3850| 5.65k| JANET_CORE_REG("buffer/push-float32", cfun_buffer_push_float32), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3851| 5.65k| JANET_CORE_REG("buffer/push-float64", cfun_buffer_push_float64), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3852| 5.65k| JANET_CORE_REG("buffer/push", cfun_buffer_push), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3853| 5.65k| JANET_CORE_REG("buffer/push-at", cfun_buffer_push_at), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3854| 5.65k| JANET_CORE_REG("buffer/popn", cfun_buffer_popn), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3855| 5.65k| JANET_CORE_REG("buffer/clear", cfun_buffer_clear), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3856| 5.65k| JANET_CORE_REG("buffer/slice", cfun_buffer_slice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3857| 5.65k| JANET_CORE_REG("buffer/bit-set", cfun_buffer_bitset), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3858| 5.65k| JANET_CORE_REG("buffer/bit-clear", cfun_buffer_bitclear), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3859| 5.65k| JANET_CORE_REG("buffer/bit", cfun_buffer_bitget), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3860| 5.65k| JANET_CORE_REG("buffer/bit-toggle", cfun_buffer_bittoggle), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3861| 5.65k| JANET_CORE_REG("buffer/blit", cfun_buffer_blit), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3862| 5.65k| JANET_CORE_REG("buffer/format", cfun_buffer_format), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3863| 5.65k| JANET_CORE_REG("buffer/format-at", cfun_buffer_format_at), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3864| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3865| 5.65k| }; 3866| | janet_core_cfuns_ext(env, NULL, buffer_cfuns); 3867| 5.65k|} janet_verify: 5644| 3.02M|int janet_verify(JanetFuncDef *def) { 5645| 3.02M| int vargs = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG); ------------------ | | 1097| 3.02M|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ 5646| 3.02M| int32_t i; 5647| 3.02M| int32_t maxslot = def->arity + vargs; 5648| 3.02M| int32_t sc = def->slotcount; 5649| | 5650| 3.02M| if (def->environments_length > 256) return 15; ------------------ | Branch (5650:9): [True: 0, False: 3.02M] ------------------ 5651| 3.02M| if (def->bytecode_length == 0) return 1; ------------------ | Branch (5651:9): [True: 0, False: 3.02M] ------------------ 5652| | 5653| 3.02M| if (maxslot > sc) return 2; ------------------ | Branch (5653:9): [True: 0, False: 3.02M] ------------------ 5654| | 5655| | /* Verify each instruction */ 5656| 86.5M| for (i = 0; i < def->bytecode_length; i++) { ------------------ | Branch (5656:17): [True: 83.5M, False: 3.02M] ------------------ 5657| 83.5M| uint32_t instr = def->bytecode[i]; 5658| | /* Check for invalid instructions */ 5659| 83.5M| if ((instr & 0x7F) >= JOP_INSTRUCTION_COUNT) { ------------------ | Branch (5659:13): [True: 0, False: 83.5M] ------------------ 5660| 0| return 3; 5661| 0| } 5662| 83.5M| enum JanetInstructionType type = janet_instructions[instr & 0x7F]; 5663| 83.5M| switch (type) { ------------------ | Branch (5663:17): [True: 83.5M, False: 0] ------------------ 5664| 435k| case JINT_0: ------------------ | Branch (5664:13): [True: 435k, False: 83.1M] ------------------ 5665| 435k| continue; 5666| 16.0M| case JINT_S: { ------------------ | Branch (5666:13): [True: 16.0M, False: 67.5M] ------------------ 5667| 16.0M| if ((int32_t)(instr >> 8) >= sc) return 4; ------------------ | Branch (5667:21): [True: 0, False: 16.0M] ------------------ 5668| 16.0M| continue; 5669| 16.0M| } 5670| 16.0M| case JINT_SI: ------------------ | Branch (5670:13): [True: 1.91M, False: 81.6M] ------------------ 5671| 1.91M| case JINT_SU: ------------------ | Branch (5671:13): [True: 0, False: 83.5M] ------------------ 5672| 1.91M| case JINT_ST: { ------------------ | Branch (5672:13): [True: 0, False: 83.5M] ------------------ 5673| 1.91M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5673:21): [True: 0, False: 1.91M] ------------------ 5674| 1.91M| continue; 5675| 1.91M| } 5676| 3.52M| case JINT_L: { ------------------ | Branch (5676:13): [True: 3.52M, False: 80.0M] ------------------ 5677| 3.52M| int32_t jumpdest = i + (((int32_t)instr) >> 8); 5678| 3.52M| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (5678:21): [True: 0, False: 3.52M] | Branch (5678:37): [True: 0, False: 3.52M] ------------------ 5679| 3.52M| continue; 5680| 3.52M| } 5681| 22.3M| case JINT_SS: { ------------------ | Branch (5681:13): [True: 22.3M, False: 61.1M] ------------------ 5682| 22.3M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5682:21): [True: 0, False: 22.3M] ------------------ 5683| 22.3M| (int32_t)(instr >> 16) >= sc) return 4; ------------------ | Branch (5683:25): [True: 0, False: 22.3M] ------------------ 5684| 22.3M| continue; 5685| 22.3M| } 5686| 22.3M| case JINT_SSI: ------------------ | Branch (5686:13): [True: 1.47M, False: 82.0M] ------------------ 5687| 2.35M| case JINT_SSU: { ------------------ | Branch (5687:13): [True: 876k, False: 82.6M] ------------------ 5688| 2.35M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5688:21): [True: 0, False: 2.35M] ------------------ 5689| 2.35M| (int32_t)((instr >> 16) & 0xFF) >= sc) return 4; ------------------ | Branch (5689:25): [True: 0, False: 2.35M] ------------------ 5690| 2.35M| continue; 5691| 2.35M| } 5692| 6.10M| case JINT_SL: { ------------------ | Branch (5692:13): [True: 6.10M, False: 77.4M] ------------------ 5693| 6.10M| int32_t jumpdest = i + (((int32_t)instr) >> 16); 5694| 6.10M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5694:21): [True: 0, False: 6.10M] ------------------ 5695| 6.10M| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (5695:21): [True: 0, False: 6.10M] | Branch (5695:37): [True: 0, False: 6.10M] ------------------ 5696| 6.10M| continue; 5697| 6.10M| } 5698| 11.2M| case JINT_SSS: { ------------------ | Branch (5698:13): [True: 11.2M, False: 72.3M] ------------------ 5699| 11.2M| if (((int32_t)(instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5699:21): [True: 0, False: 11.2M] ------------------ 5700| 11.2M| ((int32_t)(instr >> 16) & 0xFF) >= sc || ------------------ | Branch (5700:25): [True: 0, False: 11.2M] ------------------ 5701| 11.2M| ((int32_t)(instr >> 24) & 0xFF) >= sc) return 4; ------------------ | Branch (5701:25): [True: 0, False: 11.2M] ------------------ 5702| 11.2M| continue; 5703| 11.2M| } 5704| 11.2M| case JINT_SD: { ------------------ | Branch (5704:13): [True: 881k, False: 82.6M] ------------------ 5705| 881k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5705:21): [True: 0, False: 881k] ------------------ 5706| 881k| if ((int32_t)(instr >> 16) >= def->defs_length) return 6; ------------------ | Branch (5706:21): [True: 0, False: 881k] ------------------ 5707| 881k| continue; 5708| 881k| } 5709| 15.2M| case JINT_SC: { ------------------ | Branch (5709:13): [True: 15.2M, False: 68.3M] ------------------ 5710| 15.2M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5710:21): [True: 0, False: 15.2M] ------------------ 5711| 15.2M| if ((int32_t)(instr >> 16) >= def->constants_length) return 7; ------------------ | Branch (5711:21): [True: 0, False: 15.2M] ------------------ 5712| 15.2M| continue; 5713| 15.2M| } 5714| 15.2M| case JINT_SES: { ------------------ | Branch (5714:13): [True: 3.44M, False: 80.1M] ------------------ 5715| | /* How can we check the last slot index? We need info parent funcdefs. Resort 5716| | * to runtime checks for now. Maybe invalid upvalue references could be defaulted 5717| | * to nil? (don't commit to this in the long term, though) */ 5718| 3.44M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5718:21): [True: 0, False: 3.44M] ------------------ 5719| 3.44M| if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8; ------------------ | Branch (5719:21): [True: 0, False: 3.44M] ------------------ 5720| 3.44M| continue; 5721| 3.44M| } 5722| 83.5M| } 5723| 83.5M| } 5724| | 5725| | /* Verify last instruction is either a jump, return, return-nil, or tailcall. Eventually, 5726| | * some real flow analysis would be ideal, but this should be very effective. Will completely 5727| | * prevent running over the end of bytecode. However, valid functions with dead code will 5728| | * be rejected. */ 5729| 3.02M| { 5730| 3.02M| uint32_t lastop = def->bytecode[def->bytecode_length - 1] & 0xFF; 5731| 3.02M| switch (lastop) { 5732| 0| default: ------------------ | Branch (5732:13): [True: 0, False: 3.02M] ------------------ 5733| 0| return 9; 5734| 1.78M| case JOP_RETURN: ------------------ | Branch (5734:13): [True: 1.78M, False: 1.24M] ------------------ 5735| 2.01M| case JOP_RETURN_NIL: ------------------ | Branch (5735:13): [True: 231k, False: 2.79M] ------------------ 5736| 2.01M| case JOP_JUMP: ------------------ | Branch (5736:13): [True: 5.65k, False: 3.01M] ------------------ 5737| 2.05M| case JOP_ERROR: ------------------ | Branch (5737:13): [True: 39.5k, False: 2.98M] ------------------ 5738| 3.02M| case JOP_TAILCALL: ------------------ | Branch (5738:13): [True: 966k, False: 2.05M] ------------------ 5739| 3.02M| break; 5740| 3.02M| } 5741| 3.02M| } 5742| | 5743| | /* Verify debug info - slotmapping, etc. */ 5744| 31.7M| for (int32_t i = def->symbolmap_length - 1; i >= 0; i--) { ------------------ | Branch (5744:49): [True: 28.7M, False: 3.02M] ------------------ 5745| 28.7M| JanetSymbolMap jsm = def->symbolmap[i]; 5746| 28.7M| if (jsm.birth_pc == UINT32_MAX) { ------------------ | Branch (5746:13): [True: 14.8M, False: 13.9M] ------------------ 5747| 14.8M| if (jsm.death_pc >= (uint32_t) def->environments_length) { ------------------ | Branch (5747:17): [True: 0, False: 14.8M] ------------------ 5748| 0| return 10; 5749| | /* We should also check jsm.slot_index */ 5750| 0| } 5751| 14.8M| } else { 5752| 13.9M| if (jsm.slot_index >= (uint32_t) def->slotcount) { ------------------ | Branch (5752:17): [True: 0, False: 13.9M] ------------------ 5753| 0| return 11; 5754| 0| } 5755| 13.9M| if (jsm.birth_pc != UINT32_MAX && jsm.birth_pc >= (uint32_t) def->bytecode_length) { ------------------ | Branch (5755:17): [True: 13.9M, False: 0] | Branch (5755:47): [True: 0, False: 13.9M] ------------------ 5756| 0| return 12; 5757| 0| } 5758| 13.9M| if (jsm.death_pc != UINT32_MAX && jsm.death_pc > (uint32_t) def->bytecode_length) { ------------------ | Branch (5758:17): [True: 13.9M, False: 0] | Branch (5758:47): [True: 0, False: 13.9M] ------------------ 5759| 0| return 13; 5760| 0| } 5761| 13.9M| } 5762| 28.7M| if (jsm.symbol == NULL) { ------------------ | Branch (5762:13): [True: 0, False: 28.7M] ------------------ 5763| 0| return 14; 5764| 0| } 5765| 28.7M| } 5766| | 5767| 3.02M| return 0; 5768| 3.02M|} janet_signalv: 5878| 2.20k|void janet_signalv(JanetSignal sig, Janet message) { 5879| 2.20k| if (janet_vm.return_reg != NULL) { ------------------ | Branch (5879:9): [True: 2.20k, False: 0] ------------------ 5880| | /* Should match logic in janet_call for coercing everything not ok to an error (no awaits, yields, etc.) */ 5881| 2.20k| if (janet_vm.coerce_error && sig != JANET_SIGNAL_OK) { ------------------ | Branch (5881:13): [True: 0, False: 2.20k] | Branch (5881:38): [True: 0, False: 0] ------------------ 5882| 0|#ifdef JANET_EV 5883| 0| if (NULL != janet_vm.root_fiber && sig == JANET_SIGNAL_EVENT) { ------------------ | Branch (5883:17): [True: 0, False: 0] | Branch (5883:48): [True: 0, False: 0] ------------------ 5884| 0| janet_vm.root_fiber->sched_id++; 5885| 0| } 5886| 0|#endif 5887| 0| if (sig != JANET_SIGNAL_ERROR) { ------------------ | Branch (5887:17): [True: 0, False: 0] ------------------ 5888| 0| message = janet_wrap_string(janet_formatc("%v coerced from %s to error", message, janet_signal_names[sig])); ------------------ | | 848| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5889| 0| } 5890| 0| sig = JANET_SIGNAL_ERROR; 5891| 0| } 5892| 2.20k| *janet_vm.return_reg = message; 5893| 2.20k| if (NULL != janet_vm.fiber) { ------------------ | Branch (5893:13): [True: 0, False: 2.20k] ------------------ 5894| 0| janet_vm.fiber->flags |= JANET_FIBER_DID_LONGJUMP; ------------------ | | 837| 0|#define JANET_FIBER_DID_LONGJUMP 0x8000000 ------------------ 5895| 0| } 5896| |#if defined(JANET_BSD) || defined(JANET_APPLE) 5897| | _longjmp(*janet_vm.signal_buf, sig); 5898| |#else 5899| 2.20k| longjmp(*janet_vm.signal_buf, sig); 5900| 2.20k|#endif 5901| 2.20k| } else { 5902| 0| const char *str = (const char *)janet_formatc("janet top level signal - %v\n", message); 5903| 0| janet_top_level_signal(str); 5904| 0| } 5905| 2.20k|} janet_panicv: 5907| 2.20k|void janet_panicv(Janet message) { 5908| 2.20k| janet_signalv(JANET_SIGNAL_ERROR, message); 5909| 2.20k|} janet_panicf: 5911| 2.20k|void janet_panicf(const char *format, ...) { 5912| 2.20k| va_list args; 5913| 2.20k| const uint8_t *ret; 5914| 2.20k| JanetBuffer buffer; 5915| 2.20k| int32_t len = 0; 5916| 52.8k| while (format[len]) len++; ------------------ | Branch (5916:12): [True: 50.6k, False: 2.20k] ------------------ 5917| 2.20k| janet_buffer_init(&buffer, len); 5918| 2.20k| va_start(args, format); 5919| 2.20k| janet_formatbv(&buffer, format, args); 5920| | va_end(args); 5921| 2.20k| ret = janet_string(buffer.data, buffer.count); 5922| 2.20k| janet_buffer_deinit(&buffer); 5923| 2.20k| janet_panics(ret); 5924| 2.20k|} janet_panics: 5930| 2.20k|void janet_panics(const uint8_t *message) { 5931| 2.20k| janet_panicv(janet_wrap_string(message)); ------------------ | | 848| 2.20k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 2.20k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.20k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.20k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5932| 2.20k|} janet_arity: 5947| 3.43k|void janet_arity(int32_t arity, int32_t min, int32_t max) { 5948| 3.43k| if (min >= 0 && arity < min) ------------------ | Branch (5948:9): [True: 3.43k, False: 0] | Branch (5948:21): [True: 0, False: 3.43k] ------------------ 5949| 0| janet_panicf("arity mismatch, expected at least %d, got %d", min, arity); 5950| 3.43k| if (max >= 0 && arity > max) ------------------ | Branch (5950:9): [True: 0, False: 3.43k] | Branch (5950:21): [True: 0, False: 0] ------------------ 5951| 0| janet_panicf("arity mismatch, expected at most %d, got %d", max, arity); 5952| 3.43k|} janet_getbytes: 6246| 1.23k|JanetByteView janet_getbytes(const Janet *argv, int32_t n) { 6247| 1.23k| Janet x = argv[n]; 6248| 1.23k| JanetByteView view; 6249| 1.23k| if (!janet_bytes_view(x, &view.bytes, &view.len)) { ------------------ | Branch (6249:9): [True: 0, False: 1.23k] ------------------ 6250| 0| janet_panic_type(x, n, JANET_TFLAG_BYTES); ------------------ | | 612| 0|#define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | ------------------ | | | | 599| 0|#define JANET_TFLAG_STRING (1 << JANET_STRING) | | ------------------ | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | ------------------ | | | | 600| 0|#define JANET_TFLAG_SYMBOL (1 << JANET_SYMBOL) | | ------------------ | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | ------------------ | | | | 606| 0|#define JANET_TFLAG_BUFFER (1 << JANET_BUFFER) | | ------------------ | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | ------------------ | | | | 601| 0|#define JANET_TFLAG_KEYWORD (1 << JANET_KEYWORD) | | ------------------ ------------------ 6251| 0| } 6252| 1.23k| return view; 6253| 1.23k|} janet_dyn: 6287| 9.30M|Janet janet_dyn(const char *name) { 6288| 9.30M| if (!janet_vm.fiber) { ------------------ | Branch (6288:9): [True: 9.30M, False: 0] ------------------ 6289| 9.30M| if (!janet_vm.top_dyns) return janet_wrap_nil(); ------------------ | | 831| 9.30M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 9.30M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 9.30M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9.30M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (6289:13): [True: 9.30M, False: 0] ------------------ 6290| 0| return janet_table_get(janet_vm.top_dyns, janet_ckeywordv(name)); ------------------ | | 1843| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6291| 9.30M| } 6292| 0| if (janet_vm.fiber->env) { ------------------ | Branch (6292:9): [True: 0, False: 0] ------------------ 6293| 0| return janet_table_get_keyword(janet_vm.fiber->env, name); 6294| 0| } else { 6295| 0| return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6296| 0| } 6297| 0|} janet_lib_compile: 8261| 5.65k|void janet_lib_compile(JanetTable *env) { 8262| 5.65k| JanetRegExt cfuns[] = { 8263| 5.65k| JANET_CORE_REG("compile", cfun_compile), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8264| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 8265| 5.65k| }; 8266| | janet_core_cfuns_ext(env, NULL, cfuns); 8267| 5.65k|} janet_core_env: 9672| 5.65k|JanetTable *janet_core_env(JanetTable *replacements) { 9673| | /* Memoize core env, ignoring replacements the second time around. */ 9674| 5.65k| if (NULL != janet_vm.core_env) { ------------------ | Branch (9674:9): [True: 0, False: 5.65k] ------------------ 9675| 0| return janet_vm.core_env; 9676| 0| } 9677| | 9678| 5.65k| JanetTable *dict = janet_core_lookup_table(replacements); 9679| | 9680| | /* Unmarshal bytecode */ 9681| 5.65k| Janet marsh_out = janet_unmarshal( 9682| 5.65k| janet_core_image, 9683| 5.65k| janet_core_image_size, 9684| 5.65k| 0, 9685| 5.65k| dict, 9686| 5.65k| NULL); 9687| | 9688| | /* Memoize */ 9689| 5.65k| janet_gcroot(marsh_out); 9690| 5.65k| JanetTable *env = janet_unwrap_table(marsh_out); ------------------ | | 861| 5.65k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9691| 5.65k| janet_vm.core_env = env; 9692| | 9693| | /* Invert image dict manually here. We can't do this in boot.janet as it 9694| | * breaks deterministic builds */ 9695| 5.65k| Janet lidv, midv; 9696| 5.65k| lidv = midv = janet_wrap_nil(); ------------------ | | 831| 5.65k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 5.65k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 5.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9697| 5.65k| janet_resolve(env, janet_csymbol("load-image-dict"), &lidv); 9698| 5.65k| janet_resolve(env, janet_csymbol("make-image-dict"), &midv); 9699| | 9700| | /* Check that we actually got tables - if we are using a smaller corelib, may not exist */ 9701| 5.65k| if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 806| 11.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 5.65k, False: 0] | | | Branch (806:6): [Folded, False: 5.65k] | | ------------------ | | 807| 11.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 11.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.65k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.65k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 806| 5.65k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 5.65k, False: 0] | | | Branch (806:6): [Folded, False: 5.65k] | | ------------------ | | 807| 5.65k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 5.65k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.65k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.65k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9702| 5.65k| JanetTable *lid = janet_unwrap_table(lidv); ------------------ | | 861| 5.65k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9703| 5.65k| JanetTable *mid = janet_unwrap_table(midv); ------------------ | | 861| 5.65k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9704| 11.5M| for (int32_t i = 0; i < lid->capacity; i++) { ------------------ | Branch (9704:29): [True: 11.5M, False: 5.65k] ------------------ 9705| 11.5M| const JanetKV *kv = lid->data + i; 9706| 11.5M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 11.5M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 11.5M] | | ------------------ | | 807| 11.5M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 11.5M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 11.5M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 11.5M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 11.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 11.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (9706:17): [True: 3.72M, False: 7.85M] ------------------ 9707| 3.72M| janet_table_put(mid, kv->value, kv->key); 9708| 3.72M| } 9709| 11.5M| } 9710| 5.65k| } 9711| | 9712| 5.65k| return env; 9713| 5.65k|} janet_core_lookup_table: 9717| 5.65k|JanetTable *janet_core_lookup_table(JanetTable *replacements) { 9718| 5.65k| JanetTable *dict = janet_table(512); 9719| 5.65k| janet_load_libs(dict); 9720| | 9721| | /* Add replacements */ 9722| 5.65k| if (replacements != NULL) { ------------------ | Branch (9722:9): [True: 0, False: 5.65k] ------------------ 9723| 0| for (int32_t i = 0; i < replacements->capacity; i++) { ------------------ | Branch (9723:29): [True: 0, False: 0] ------------------ 9724| 0| JanetKV kv = replacements->data[i]; 9725| 0| if (!janet_checktype(kv.key, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (9725:17): [True: 0, False: 0] ------------------ 9726| 0| janet_table_put(dict, kv.key, kv.value); 9727| | /* Add replacement functions to registry? */ 9728| 0| } 9729| 0| } 9730| 0| } 9731| | 9732| 5.65k| return dict; 9733| 5.65k|} janet_lib_debug: 10185| 5.65k|void janet_lib_debug(JanetTable *env) { 10186| 5.65k| JanetRegExt debug_cfuns[] = { 10187| 5.65k| JANET_CORE_REG("debug/break", cfun_debug_break), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10188| 5.65k| JANET_CORE_REG("debug/unbreak", cfun_debug_unbreak), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10189| 5.65k| JANET_CORE_REG("debug/fbreak", cfun_debug_fbreak), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10190| 5.65k| JANET_CORE_REG("debug/unfbreak", cfun_debug_unfbreak), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10191| 5.65k| JANET_CORE_REG("debug/arg-stack", cfun_debug_argstack), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10192| 5.65k| JANET_CORE_REG("debug/stack", cfun_debug_stack), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10193| 5.65k| JANET_CORE_REG("debug/stacktrace", cfun_debug_stacktrace), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10194| 5.65k| JANET_CORE_REG("debug/lineage", cfun_debug_lineage), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10195| 5.65k| JANET_CORE_REG("debug/step", cfun_debug_step), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10196| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 10197| 5.65k| }; 10198| | janet_core_cfuns_ext(env, NULL, debug_cfuns); 10199| 5.65k|} janet_ev_init_common: 11165| 5.65k|void janet_ev_init_common(void) { 11166| 5.65k| janet_q_init(&janet_vm.spawn); 11167| 5.65k| janet_vm.tq = NULL; 11168| 5.65k| janet_vm.tq_count = 0; 11169| 5.65k| janet_vm.tq_capacity = 0; 11170| 5.65k| janet_table_init_raw(&janet_vm.threaded_abstracts, 0); 11171| 5.65k| janet_table_init_raw(&janet_vm.active_tasks, 0); 11172| 5.65k| janet_table_init_raw(&janet_vm.signal_handlers, 0); 11173| 5.65k| janet_rng_seed(&janet_vm.ev_rng, 0); 11174| 5.65k|#ifndef JANET_WINDOWS 11175| 5.65k| pthread_attr_init(&janet_vm.new_thread_attr); 11176| | pthread_attr_setdetachstate(&janet_vm.new_thread_attr, PTHREAD_CREATE_DETACHED); 11177| 5.65k|#endif 11178| 5.65k|} janet_ev_deinit_common: 11211| 5.65k|void janet_ev_deinit_common(void) { 11212| 5.65k| JanetTimeout to; 11213| 5.65k| while (peek_timeout(&to)) { ------------------ | Branch (11213:12): [True: 0, False: 5.65k] ------------------ 11214| 0| handle_timeout_worker(to, 1); 11215| 0| pop_timeout(0); 11216| 0| } 11217| 5.65k| janet_q_deinit(&janet_vm.spawn); 11218| 5.65k| janet_free(janet_vm.tq); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 11219| 5.65k| janet_table_deinit(&janet_vm.threaded_abstracts); 11220| 5.65k| janet_table_deinit(&janet_vm.active_tasks); 11221| 5.65k| janet_table_deinit(&janet_vm.signal_handlers); 11222| 5.65k|#ifndef JANET_WINDOWS 11223| 5.65k| pthread_attr_destroy(&janet_vm.new_thread_attr); 11224| 5.65k|#endif 11225| 5.65k|} janet_ev_init: 12502| 5.65k|void janet_ev_init(void) { 12503| 5.65k| janet_ev_init_common(); 12504| 5.65k| janet_ev_setup_selfpipe(); 12505| 5.65k| janet_vm.epoll = epoll_create1(EPOLL_CLOEXEC); 12506| 5.65k| janet_vm.timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); 12507| 5.65k| janet_vm.timer_enabled = 0; 12508| 5.65k| if (janet_vm.epoll == -1 || janet_vm.timerfd == -1) goto error; ------------------ | Branch (12508:9): [True: 0, False: 5.65k] | Branch (12508:33): [True: 0, False: 5.65k] ------------------ 12509| 5.65k| struct epoll_event ev; 12510| 5.65k| ev.events = EPOLLIN | EPOLLET; 12511| 5.65k| ev.data.ptr = &janet_vm.timerfd; 12512| 5.65k| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.timerfd, &ev)) goto error; ------------------ | Branch (12512:9): [True: 0, False: 5.65k] ------------------ 12513| 5.65k| ev.events = EPOLLIN | EPOLLET; 12514| 5.65k| ev.data.ptr = janet_vm.selfpipe; 12515| 5.65k| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.selfpipe[0], &ev)) goto error; ------------------ | Branch (12515:9): [True: 0, False: 5.65k] ------------------ 12516| 5.65k| return; 12517| 5.65k|error: 12518| | JANET_EXIT("failed to initialize event loop"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 12519| 0|} janet_ev_deinit: 12521| 5.65k|void janet_ev_deinit(void) { 12522| 5.65k| janet_ev_deinit_common(); 12523| 5.65k| close(janet_vm.epoll); 12524| 5.65k| close(janet_vm.timerfd); 12525| 5.65k| janet_ev_cleanup_selfpipe(); 12526| 5.65k| janet_vm.epoll = 0; 12527| 5.65k|} janet_make_pipe: 13624| 5.65k|int janet_make_pipe(JanetHandle handles[2], int mode) { 13625| |#ifdef JANET_WINDOWS 13626| | /* 13627| | * On windows, the built in CreatePipe function doesn't support overlapped IO 13628| | * so we lift from the windows source code and modify for our own version. 13629| | */ 13630| | JanetHandle shandle, chandle; 13631| | CHAR PipeNameBuffer[MAX_PATH]; 13632| | SECURITY_ATTRIBUTES saAttr; 13633| | memset(&saAttr, 0, sizeof(saAttr)); 13634| | saAttr.nLength = sizeof(saAttr); 13635| | saAttr.bInheritHandle = TRUE; 13636| | if (mode == 3) { 13637| | /* No overlapped IO involved, just call CreatePipe */ 13638| | if (!CreatePipe(handles, handles + 1, &saAttr, 0)) return -1; 13639| | return 0; 13640| | } 13641| | snprintf(PipeNameBuffer, 13642| | sizeof(PipeNameBuffer), 13643| | "\\\\.\\Pipe\\JanetPipeFile.%08x.%08x", 13644| | (unsigned int) GetCurrentProcessId(), 13645| | (unsigned int) InterlockedIncrement(&PipeSerialNumber)); 13646| | 13647| | /* server handle goes to subprocess */ 13648| | shandle = CreateNamedPipeA( 13649| | PipeNameBuffer, 13650| | (mode == 2 ? PIPE_ACCESS_INBOUND : PIPE_ACCESS_OUTBOUND) | FILE_FLAG_OVERLAPPED, 13651| | PIPE_TYPE_BYTE | PIPE_WAIT, 13652| | 255, /* Max number of pipes for duplication. */ 13653| | 4096, /* Out buffer size */ 13654| | 4096, /* In buffer size */ 13655| | 120 * 1000, /* Timeout in ms */ 13656| | &saAttr); 13657| | if (shandle == INVALID_HANDLE_VALUE) { 13658| | return -1; 13659| | } 13660| | 13661| | /* we keep client handle */ 13662| | chandle = CreateFileA( 13663| | PipeNameBuffer, 13664| | (mode == 2 ? GENERIC_WRITE : GENERIC_READ), 13665| | 0, 13666| | &saAttr, 13667| | OPEN_EXISTING, 13668| | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 13669| | NULL); 13670| | 13671| | if (chandle == INVALID_HANDLE_VALUE) { 13672| | CloseHandle(shandle); 13673| | return -1; 13674| | } 13675| | if (mode == 2) { 13676| | handles[0] = shandle; 13677| | handles[1] = chandle; 13678| | } else { 13679| | handles[0] = chandle; 13680| | handles[1] = shandle; 13681| | } 13682| | return 0; 13683| |#else 13684| 5.65k| if (pipe(handles)) return -1; ------------------ | Branch (13684:9): [True: 0, False: 5.65k] ------------------ 13685| 5.65k| if (mode != 2 && fcntl(handles[0], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (13685:9): [True: 5.65k, False: 0] | Branch (13685:22): [True: 0, False: 5.65k] ------------------ 13686| 5.65k| if (mode != 1 && fcntl(handles[1], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (13686:9): [True: 0, False: 5.65k] | Branch (13686:22): [True: 0, False: 0] ------------------ 13687| 5.65k| if (mode != 2 && mode != 3 && fcntl(handles[0], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (13687:9): [True: 5.65k, False: 0] | Branch (13687:22): [True: 5.65k, False: 0] | Branch (13687:35): [True: 0, False: 5.65k] ------------------ 13688| 5.65k| if (mode != 1 && mode != 3 && fcntl(handles[1], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (13688:9): [True: 0, False: 5.65k] | Branch (13688:22): [True: 0, False: 0] | Branch (13688:35): [True: 0, False: 0] ------------------ 13689| 5.65k| return 0; 13690| 0|error: 13691| 0| close(handles[0]); 13692| 0| close(handles[1]); 13693| 0| return -1; 13694| 5.65k|#endif 13695| 5.65k|} janet_lib_ev: 14280| 5.65k|void janet_lib_ev(JanetTable *env) { 14281| 5.65k| JanetRegExt ev_cfuns_ext[] = { 14282| 5.65k| JANET_CORE_REG("ev/give", cfun_channel_push), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14283| 5.65k| JANET_CORE_REG("ev/take", cfun_channel_pop), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14284| 5.65k| JANET_CORE_REG("ev/full", cfun_channel_full), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14285| 5.65k| JANET_CORE_REG("ev/capacity", cfun_channel_capacity), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14286| 5.65k| JANET_CORE_REG("ev/count", cfun_channel_count), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14287| 5.65k| JANET_CORE_REG("ev/select", cfun_channel_choice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14288| 5.65k| JANET_CORE_REG("ev/rselect", cfun_channel_rchoice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14289| 5.65k| JANET_CORE_REG("ev/chan", cfun_channel_new), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14290| 5.65k| JANET_CORE_REG("ev/thread-chan", cfun_channel_new_threaded), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14291| 5.65k| JANET_CORE_REG("ev/chan-close", cfun_channel_close), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14292| 5.65k| JANET_CORE_REG("ev/go", cfun_ev_go), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14293| 5.65k| JANET_CORE_REG("ev/thread", cfun_ev_thread), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14294| 5.65k| JANET_CORE_REG("ev/give-supervisor", cfun_ev_give_supervisor), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14295| 5.65k| JANET_CORE_REG("ev/sleep", cfun_ev_sleep), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14296| 5.65k| JANET_CORE_REG("ev/deadline", cfun_ev_deadline), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14297| 5.65k| JANET_CORE_REG("ev/cancel", cfun_ev_cancel), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14298| 5.65k| JANET_CORE_REG("ev/close", janet_cfun_stream_close), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14299| 5.65k| JANET_CORE_REG("ev/read", janet_cfun_stream_read), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14300| 5.65k| JANET_CORE_REG("ev/chunk", janet_cfun_stream_chunk), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14301| 5.65k| JANET_CORE_REG("ev/write", janet_cfun_stream_write), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14302| 5.65k| JANET_CORE_REG("ev/lock", janet_cfun_mutex), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14303| 5.65k| JANET_CORE_REG("ev/acquire-lock", janet_cfun_mutex_acquire), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14304| 5.65k| JANET_CORE_REG("ev/release-lock", janet_cfun_mutex_release), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14305| 5.65k| JANET_CORE_REG("ev/rwlock", janet_cfun_rwlock), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14306| 5.65k| JANET_CORE_REG("ev/acquire-rlock", janet_cfun_rwlock_read_lock), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14307| 5.65k| JANET_CORE_REG("ev/acquire-wlock", janet_cfun_rwlock_write_lock), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14308| 5.65k| JANET_CORE_REG("ev/release-rlock", janet_cfun_rwlock_read_release), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14309| 5.65k| JANET_CORE_REG("ev/release-wlock", janet_cfun_rwlock_write_release), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14310| 5.65k| JANET_CORE_REG("ev/to-file", janet_cfun_to_file), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14311| 5.65k| JANET_CORE_REG("ev/all-tasks", janet_cfun_ev_all_tasks), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14312| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 14313| 5.65k| }; 14314| | 14315| | janet_core_cfuns_ext(env, NULL, ev_cfuns_ext); 14316| 5.65k| janet_register_abstract_type(&janet_stream_type); 14317| 5.65k| janet_register_abstract_type(&janet_channel_type); 14318| 5.65k| janet_register_abstract_type(&janet_mutex_type); 14319| 5.65k| janet_register_abstract_type(&janet_rwlock_type); 14320| 5.65k|} janet_lib_ffi: 16250| 5.65k|void janet_lib_ffi(JanetTable *env) { 16251| 5.65k| JanetRegExt ffi_cfuns[] = { 16252| 5.65k| JANET_CORE_REG("ffi/native", janet_core_raw_native), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16253| 5.65k| JANET_CORE_REG("ffi/lookup", janet_core_native_lookup), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16254| 5.65k| JANET_CORE_REG("ffi/close", janet_core_native_close), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16255| 5.65k| JANET_CORE_REG("ffi/signature", cfun_ffi_signature), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16256| 5.65k| JANET_CORE_REG("ffi/call", cfun_ffi_call), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16257| 5.65k| JANET_CORE_REG("ffi/struct", cfun_ffi_struct), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16258| 5.65k| JANET_CORE_REG("ffi/write", cfun_ffi_buffer_write), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16259| 5.65k| JANET_CORE_REG("ffi/read", cfun_ffi_buffer_read), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16260| 5.65k| JANET_CORE_REG("ffi/size", cfun_ffi_size), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16261| 5.65k| JANET_CORE_REG("ffi/align", cfun_ffi_align), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16262| 5.65k| JANET_CORE_REG("ffi/trampoline", cfun_ffi_get_callback_trampoline), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16263| 5.65k| JANET_CORE_REG("ffi/jitfn", cfun_ffi_jitfn), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16264| 5.65k| JANET_CORE_REG("ffi/malloc", cfun_ffi_malloc), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16265| 5.65k| JANET_CORE_REG("ffi/free", cfun_ffi_free), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16266| 5.65k| JANET_CORE_REG("ffi/pointer-buffer", cfun_ffi_pointer_buffer), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16267| 5.65k| JANET_CORE_REG("ffi/pointer-cfunction", cfun_ffi_pointer_cfunction), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16268| 5.65k| JANET_CORE_REG("ffi/calling-conventions", cfun_ffi_supported_calling_conventions), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16269| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 16270| 5.65k| }; 16271| | janet_core_cfuns_ext(env, NULL, ffi_cfuns); 16272| 5.65k|} janet_lib_fiber: 16952| 5.65k|void janet_lib_fiber(JanetTable *env) { 16953| 5.65k| JanetRegExt fiber_cfuns[] = { 16954| 5.65k| JANET_CORE_REG("fiber/new", cfun_fiber_new), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16955| 5.65k| JANET_CORE_REG("fiber/status", cfun_fiber_status), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16956| 5.65k| JANET_CORE_REG("fiber/root", cfun_fiber_root), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16957| 5.65k| JANET_CORE_REG("fiber/current", cfun_fiber_current), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16958| 5.65k| JANET_CORE_REG("fiber/maxstack", cfun_fiber_maxstack), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16959| 5.65k| JANET_CORE_REG("fiber/setmaxstack", cfun_fiber_setmaxstack), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16960| 5.65k| JANET_CORE_REG("fiber/getenv", cfun_fiber_getenv), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16961| 5.65k| JANET_CORE_REG("fiber/setenv", cfun_fiber_setenv), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16962| 5.65k| JANET_CORE_REG("fiber/can-resume?", cfun_fiber_can_resume), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16963| 5.65k| JANET_CORE_REG("fiber/last-value", cfun_fiber_last_value), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16964| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 16965| 5.65k| }; 16966| | janet_core_cfuns_ext(env, NULL, fiber_cfuns); 16967| 5.65k|} janet_lib_filewatch: 17962| 5.65k|void janet_lib_filewatch(JanetTable *env) { 17963| 5.65k| JanetRegExt cfuns[] = { 17964| 5.65k| JANET_CORE_REG("filewatch/new", cfun_filewatch_make), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17965| 5.65k| JANET_CORE_REG("filewatch/add", cfun_filewatch_add), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17966| 5.65k| JANET_CORE_REG("filewatch/remove", cfun_filewatch_remove), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17967| 5.65k| JANET_CORE_REG("filewatch/listen", cfun_filewatch_listen), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17968| 5.65k| JANET_CORE_REG("filewatch/unlisten", cfun_filewatch_unlisten), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17969| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 17970| 5.65k| }; 17971| | janet_core_cfuns_ext(env, NULL, cfuns); 17972| 5.65k|} janet_gcpressure: 18032| 16.3M|void janet_gcpressure(size_t s) { 18033| 16.3M| janet_vm.next_collection += s; 18034| 16.3M|} janet_gcalloc: 18506| 50.2M|void *janet_gcalloc(enum JanetMemoryType type, size_t size) { 18507| 50.2M| JanetGCObject *mem; 18508| | 18509| | /* Make sure everything is inited */ 18510| 50.2M| janet_assert(NULL != janet_vm.cache, "please initialize janet before use"); ------------------ | | 389| 50.2M|#define janet_assert(c, m) do { \ | | 390| 50.2M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 50.2M] | | ------------------ | | 391| 50.2M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 50.2M] | | ------------------ ------------------ 18511| 50.2M| mem = janet_malloc(size); ------------------ | | 2406| 50.2M|#define janet_malloc(X) malloc((X)) ------------------ 18512| | 18513| | /* Check for bad malloc */ 18514| 50.2M| if (NULL == mem) { ------------------ | Branch (18514:9): [True: 0, False: 50.2M] ------------------ 18515| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18516| 0| } 18517| | 18518| | /* Configure block */ 18519| 50.2M| mem->flags = type; 18520| | 18521| | /* Prepend block to heap list */ 18522| 50.2M| janet_vm.next_collection += size; 18523| 50.2M| if (type < JANET_MEMORY_TABLE_WEAKK) { ------------------ | Branch (18523:9): [True: 50.2M, False: 0] ------------------ 18524| | /* normal heap */ 18525| 50.2M| mem->data.next = janet_vm.blocks; 18526| 50.2M| janet_vm.blocks = mem; 18527| 50.2M| } else { 18528| | /* weak heap */ 18529| 0| mem->data.next = janet_vm.weak_blocks; 18530| 0| janet_vm.weak_blocks = mem; 18531| 0| } 18532| 50.2M| janet_vm.block_count++; 18533| | 18534| 50.2M| return (void *)mem; 18535| 50.2M|} janet_gcroot: 18596| 11.3k|void janet_gcroot(Janet root) { 18597| 11.3k| size_t newcount = janet_vm.root_count + 1; 18598| 11.3k| if (newcount > janet_vm.root_capacity) { ------------------ | Branch (18598:9): [True: 5.65k, False: 5.65k] ------------------ 18599| 5.65k| size_t newcap = 2 * newcount; 18600| 5.65k| janet_vm.roots = janet_realloc(janet_vm.roots, sizeof(Janet) * newcap); ------------------ | | 2409| 5.65k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18601| 5.65k| if (NULL == janet_vm.roots) { ------------------ | Branch (18601:13): [True: 0, False: 5.65k] ------------------ 18602| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18603| 0| } 18604| 5.65k| janet_vm.root_capacity = newcap; 18605| 5.65k| } 18606| 11.3k| janet_vm.roots[janet_vm.root_count] = root; 18607| 11.3k| janet_vm.root_count = newcount; 18608| 11.3k|} janet_clear_memory: 18654| 5.65k|void janet_clear_memory(void) { 18655| 5.65k|#ifdef JANET_EV 18656| 5.65k| JanetKV *items = janet_vm.threaded_abstracts.data; 18657| 11.3k| for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) { ------------------ | Branch (18657:25): [True: 5.65k, False: 5.65k] ------------------ 18658| 5.65k| if (janet_checktype(items[i].key, JANET_ABSTRACT)) { ------------------ | | 806| 5.65k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 5.65k] | | | Branch (806:6): [Folded, False: 5.65k] | | ------------------ | | 807| 5.65k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 5.65k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.65k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.65k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18659| 0| void *abst = janet_unwrap_abstract(items[i].key); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 18660| 0| JanetAbstractHead *head = janet_abstract_head(abst); ------------------ | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) ------------------ 18661| 0| if (head->type->gcperthread) { ------------------ | Branch (18661:17): [True: 0, False: 0] ------------------ 18662| 0| janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 18663| 0| } 18664| 0| janet_abstract_decref_maybe_free(abst); 18665| 0| } 18666| 5.65k| } 18667| 5.65k|#endif 18668| 5.65k| JanetGCObject *current = janet_vm.blocks; 18669| 50.2M| while (NULL != current) { ------------------ | Branch (18669:12): [True: 50.2M, False: 5.65k] ------------------ 18670| 50.2M| janet_deinit_block(current); 18671| 50.2M| JanetGCObject *next = current->data.next; 18672| 50.2M| janet_free(current); ------------------ | | 2415| 50.2M|#define janet_free(X) free((X)) ------------------ 18673| 50.2M| current = next; 18674| 50.2M| } 18675| 5.65k| janet_vm.blocks = NULL; 18676| 5.65k| janet_free_all_scratch(); 18677| 5.65k| janet_free(janet_vm.scratch_mem); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 18678| 5.65k|} janet_smalloc: 18692| 9.04M|void *janet_smalloc(size_t size) { 18693| 9.04M| JanetScratch *s = janet_malloc(sizeof(JanetScratch) + size); ------------------ | | 2406| 9.04M|#define janet_malloc(X) malloc((X)) ------------------ 18694| 9.04M| if (NULL == s) { ------------------ | Branch (18694:9): [True: 0, False: 9.04M] ------------------ 18695| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18696| 0| } 18697| 9.04M| s->finalize = NULL; 18698| 9.04M| if (janet_vm.scratch_len == janet_vm.scratch_cap) { ------------------ | Branch (18698:9): [True: 11.3k, False: 9.03M] ------------------ 18699| 11.3k| size_t newcap = 2 * janet_vm.scratch_cap + 2; 18700| 11.3k| JanetScratch **newmem = (JanetScratch **) janet_realloc(janet_vm.scratch_mem, newcap * sizeof(JanetScratch)); ------------------ | | 2409| 11.3k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18701| 11.3k| if (NULL == newmem) { ------------------ | Branch (18701:13): [True: 0, False: 11.3k] ------------------ 18702| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18703| 0| } 18704| 11.3k| janet_vm.scratch_cap = newcap; 18705| 11.3k| janet_vm.scratch_mem = newmem; 18706| 11.3k| } 18707| 9.04M| janet_vm.scratch_mem[janet_vm.scratch_len++] = s; 18708| 9.04M| return (char *)(s->mem); 18709| 9.04M|} janet_srealloc: 18721| 176k|void *janet_srealloc(void *mem, size_t size) { 18722| 176k| if (NULL == mem) return janet_smalloc(size); ------------------ | Branch (18722:9): [True: 19.0k, False: 157k] ------------------ 18723| 157k| JanetScratch *s = janet_mem2scratch(mem); 18724| 157k| if (janet_vm.scratch_len) { ------------------ | Branch (18724:9): [True: 157k, False: 0] ------------------ 18725| 265k| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 18726| 265k| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (18726:17): [True: 157k, False: 107k] ------------------ 18727| 157k| JanetScratch *news = janet_realloc(s, size + sizeof(JanetScratch)); ------------------ | | 2409| 157k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18728| 157k| if (NULL == news) { ------------------ | Branch (18728:21): [True: 0, False: 157k] ------------------ 18729| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18730| 0| } 18731| 157k| janet_vm.scratch_mem[i] = news; 18732| 157k| return (char *)(news->mem); 18733| 157k| } 18734| 107k| if (i == 0) break; ------------------ | Branch (18734:17): [True: 0, False: 107k] ------------------ 18735| 107k| } 18736| 157k| } 18737| 0| JANET_EXIT("invalid janet_srealloc"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 18738| 0|} janet_sfree: 18745| 9.04M|void janet_sfree(void *mem) { 18746| 9.04M| if (NULL == mem) return; ------------------ | Branch (18746:9): [True: 0, False: 9.04M] ------------------ 18747| 9.04M| JanetScratch *s = janet_mem2scratch(mem); 18748| 9.04M| if (janet_vm.scratch_len) { ------------------ | Branch (18748:9): [True: 9.04M, False: 0] ------------------ 18749| 9.05M| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 18750| 9.05M| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (18750:17): [True: 9.04M, False: 10.6k] ------------------ 18751| 9.04M| janet_vm.scratch_mem[i] = janet_vm.scratch_mem[--janet_vm.scratch_len]; 18752| 9.04M| free_one_scratch(s); 18753| 9.04M| return; 18754| 9.04M| } 18755| 10.6k| if (i == 0) break; ------------------ | Branch (18755:17): [True: 0, False: 10.6k] ------------------ 18756| 10.6k| } 18757| 9.04M| } 18758| 0| JANET_EXIT("invalid janet_sfree"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 18759| 0|} janet_wrap_s64: 18944| 1.38k|Janet janet_wrap_s64(int64_t x) { 18945| 1.38k| int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t)); 18946| 1.38k| *box = (int64_t)x; 18947| 1.38k| return janet_wrap_abstract(box); ------------------ | | 851| 1.38k|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 1.38k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.38k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.38k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18948| 1.38k|} janet_wrap_u64: 18950| 1.09k|Janet janet_wrap_u64(uint64_t x) { 18951| 1.09k| uint64_t *box = janet_abstract(&janet_u64_type, sizeof(uint64_t)); 18952| 1.09k| *box = (uint64_t)x; 18953| 1.09k| return janet_wrap_abstract(box); ------------------ | | 851| 1.09k|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 1.09k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.09k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.09k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18954| 1.09k|} janet_lib_inttypes: 19436| 5.65k|void janet_lib_inttypes(JanetTable *env) { 19437| 5.65k| JanetRegExt it_cfuns[] = { 19438| 5.65k| JANET_CORE_REG("int/s64", cfun_it_s64_new), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19439| 5.65k| JANET_CORE_REG("int/u64", cfun_it_u64_new), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19440| 5.65k| JANET_CORE_REG("int/to-number", cfun_to_number), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19441| 5.65k| JANET_CORE_REG("int/to-bytes", cfun_to_bytes), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19442| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 19443| 5.65k| }; 19444| | janet_core_cfuns_ext(env, NULL, it_cfuns); 19445| 5.65k| janet_register_abstract_type(&janet_s64_type); 19446| 5.65k| janet_register_abstract_type(&janet_u64_type); 19447| 5.65k|} janet_file_close: 19763| 16.9k|int janet_file_close(JanetFile *file) { 19764| 16.9k| int ret = 0; 19765| 16.9k| if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2278| 16.9k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2279| 16.9k|#define JANET_FILE_CLOSED 32 ------------------ | Branch (19765:9): [True: 0, False: 16.9k] ------------------ 19766| 0| ret = fclose(file->file); 19767| 0| file->flags |= JANET_FILE_CLOSED; ------------------ | | 2279| 0|#define JANET_FILE_CLOSED 32 ------------------ 19768| 0| file->file = NULL; /* NULL dereference is easier to debug then other problems */ 19769| 0| return ret; 19770| 0| } 19771| 16.9k| return 0; 19772| 16.9k|} janet_dynprintf: 20201| 9.17M|void janet_dynprintf(const char *name, FILE *dflt_file, const char *format, ...) { 20202| 9.17M| va_list args; 20203| 9.17M| va_start(args, format); 20204| 9.17M| JanetType xtype; 20205| 9.17M| Janet x; 20206| 9.17M| if (!name || name[0] == '\0') { /* Allow NULL or empty string to just use dflt_file directly */ ------------------ | Branch (20206:9): [True: 0, False: 9.17M] | Branch (20206:18): [True: 0, False: 9.17M] ------------------ 20207| 0| x = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20208| 0| xtype = JANET_NIL; 20209| 9.17M| } else { 20210| 9.17M| x = janet_dyn(name); 20211| 9.17M| xtype = janet_type(x); ------------------ | | 795| 9.17M| (isnan((x).number) \ | | 796| 9.17M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 9.17M| : JANET_NUMBER) ------------------ | Branch (20211:17): [True: 9.17M, False: 0] ------------------ 20212| 9.17M| } 20213| 9.17M| switch (xtype) { 20214| 0| default: ------------------ | Branch (20214:9): [True: 0, False: 9.17M] ------------------ 20215| | /* Other values simply do nothing */ 20216| 0| break; 20217| 9.17M| case JANET_NIL: ------------------ | Branch (20217:9): [True: 9.17M, False: 0] ------------------ 20218| 9.17M| case JANET_ABSTRACT: { ------------------ | Branch (20218:9): [True: 0, False: 9.17M] ------------------ 20219| 9.17M| FILE *f = dflt_file; 20220| 9.17M| JanetBuffer buffer; 20221| 9.17M| int32_t len = 0; 20222| 111M| while (format[len]) len++; ------------------ | Branch (20222:20): [True: 102M, False: 9.17M] ------------------ 20223| 9.17M| janet_buffer_init(&buffer, len); 20224| 9.17M| janet_formatbv(&buffer, format, args); 20225| 9.17M| if (xtype == JANET_ABSTRACT) { ------------------ | Branch (20225:17): [True: 0, False: 9.17M] ------------------ 20226| 0| void *abstract = janet_unwrap_abstract(x); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 20227| 0| if (janet_abstract_type(abstract) != &janet_file_type) ------------------ | | 1899| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ | Branch (20227:21): [True: 0, False: 0] ------------------ 20228| 0| break; 20229| 0| JanetFile *iofile = abstract; 20230| 0| io_assert_writeable(iofile); 20231| 0| f = iofile->file; 20232| 0| } 20233| 9.17M| fwrite(buffer.data, buffer.count, 1, f); 20234| 9.17M| janet_buffer_deinit(&buffer); 20235| 9.17M| break; 20236| 9.17M| } 20237| 0| case JANET_FUNCTION: { ------------------ | Branch (20237:9): [True: 0, False: 9.17M] ------------------ 20238| 0| JanetFunction *fun = janet_unwrap_function(x); ------------------ | | 868| 0|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 20239| 0| int32_t len = 0; 20240| 0| while (format[len]) len++; ------------------ | Branch (20240:20): [True: 0, False: 0] ------------------ 20241| 0| JanetBuffer *buf = janet_buffer(len); 20242| 0| janet_formatbv(buf, format, args); 20243| 0| Janet args[1] = { janet_wrap_buffer(buf) }; ------------------ | | 847| 0|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20244| 0| janet_call(fun, 1, args); 20245| 0| break; 20246| 9.17M| } 20247| 0| case JANET_BUFFER: ------------------ | Branch (20247:9): [True: 0, False: 9.17M] ------------------ 20248| 0| janet_formatbv(janet_unwrap_buffer(x), format, args); ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 20249| 0| break; 20250| 9.17M| } 20251| 9.17M| va_end(args); 20252| 9.17M| return; 20253| 9.17M|} janet_makefile: 20271| 16.9k|Janet janet_makefile(FILE *f, int32_t flags) { 20272| 16.9k| return janet_wrap_abstract(makef(f, flags, BUFSIZ)); ------------------ | | 851| 16.9k|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 16.9k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20273| 16.9k|} janet_lib_io: 20286| 5.65k|void janet_lib_io(JanetTable *env) { 20287| 5.65k| JanetRegExt io_cfuns[] = { 20288| 5.65k| JANET_CORE_REG("print", cfun_io_print), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20289| 5.65k| JANET_CORE_REG("prin", cfun_io_prin), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20290| 5.65k| JANET_CORE_REG("printf", cfun_io_printf), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20291| 5.65k| JANET_CORE_REG("prinf", cfun_io_prinf), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20292| 5.65k| JANET_CORE_REG("eprin", cfun_io_eprin), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20293| 5.65k| JANET_CORE_REG("eprint", cfun_io_eprint), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20294| 5.65k| JANET_CORE_REG("eprintf", cfun_io_eprintf), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20295| 5.65k| JANET_CORE_REG("eprinf", cfun_io_eprinf), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20296| 5.65k| JANET_CORE_REG("xprint", cfun_io_xprint), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20297| 5.65k| JANET_CORE_REG("xprin", cfun_io_xprin), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20298| 5.65k| JANET_CORE_REG("xprintf", cfun_io_xprintf), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20299| 5.65k| JANET_CORE_REG("xprinf", cfun_io_xprinf), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20300| 5.65k| JANET_CORE_REG("flush", cfun_io_flush), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20301| 5.65k| JANET_CORE_REG("eflush", cfun_io_eflush), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20302| 5.65k| JANET_CORE_REG("file/temp", cfun_io_temp), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20303| 5.65k| JANET_CORE_REG("file/open", cfun_io_fopen), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20304| 5.65k| JANET_CORE_REG("file/close", cfun_io_fclose), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20305| 5.65k| JANET_CORE_REG("file/read", cfun_io_fread), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20306| 5.65k| JANET_CORE_REG("file/write", cfun_io_fwrite), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20307| 5.65k| JANET_CORE_REG("file/flush", cfun_io_fflush), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20308| 5.65k| JANET_CORE_REG("file/seek", cfun_io_fseek), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20309| 5.65k| JANET_CORE_REG("file/tell", cfun_io_ftell), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20310| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 20311| 5.65k| }; 20312| 5.65k| janet_core_cfuns_ext(env, NULL, io_cfuns); 20313| 5.65k| janet_register_abstract_type(&janet_file_type); 20314| 5.65k| int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2278| 5.65k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2281| 5.65k|#define JANET_FILE_SERIALIZABLE 128 ------------------ 20315| | /* stdout */ 20316| 5.65k| JANET_CORE_DEF(env, "stdout", ------------------ | | 520| 5.65k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20317| 5.65k| janet_makefile(stdout, JANET_FILE_APPEND | default_flags), 20318| 5.65k| "The standard output file."); 20319| | /* stderr */ 20320| 5.65k| JANET_CORE_DEF(env, "stderr", ------------------ | | 520| 5.65k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20321| 5.65k| janet_makefile(stderr, JANET_FILE_APPEND | default_flags), 20322| 5.65k| "The standard error file."); 20323| | /* stdin */ 20324| 5.65k| JANET_CORE_DEF(env, "stdin", ------------------ | | 520| 5.65k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20325| 5.65k| janet_makefile(stdin, JANET_FILE_READ | default_flags), 20326| 5.65k| "The standard input file."); 20327| | 20328| 5.65k|} janet_unmarshal: 21991| 5.65k| const uint8_t **next) { 21992| 5.65k| UnmarshalState st; 21993| 5.65k| st.start = bytes; 21994| 5.65k| st.end = bytes + len; 21995| 5.65k| st.lookup_defs = NULL; 21996| 5.65k| st.lookup_envs = NULL; 21997| 5.65k| st.lookup = NULL; 21998| 5.65k| st.reg = reg; 21999| 5.65k| Janet out; 22000| 5.65k| const uint8_t *nextbytes = unmarshal_one(&st, bytes, &out, flags); 22001| 5.65k| if (next) *next = nextbytes; ------------------ | Branch (22001:9): [True: 0, False: 5.65k] ------------------ 22002| 5.65k| janet_v_free(st.lookup_defs); ------------------ | | 756| 5.65k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 5.65k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 5.65k, False: 0] | | ------------------ ------------------ 22003| 5.65k| janet_v_free(st.lookup_envs); ------------------ | | 756| 5.65k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 5.65k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 5.65k, False: 0] | | ------------------ ------------------ 22004| | janet_v_free(st.lookup); ------------------ | | 756| 5.65k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 5.65k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 5.65k, False: 0] | | ------------------ ------------------ 22005| 5.65k| return out; 22006| 5.65k|} janet_lib_marsh: 22067| 5.65k|void janet_lib_marsh(JanetTable *env) { 22068| 5.65k| JanetRegExt marsh_cfuns[] = { 22069| 5.65k| JANET_CORE_REG("marshal", cfun_marshal), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22070| 5.65k| JANET_CORE_REG("unmarshal", cfun_unmarshal), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22071| 5.65k| JANET_CORE_REG("env-lookup", cfun_env_lookup), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22072| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 22073| 5.65k| }; 22074| | janet_core_cfuns_ext(env, NULL, marsh_cfuns); 22075| 5.65k|} janet_default_rng: 22150| 5.65k|JanetRNG *janet_default_rng(void) { 22151| 5.65k| return &janet_vm.rng; 22152| 5.65k|} janet_rng_seed: 22154| 11.3k|void janet_rng_seed(JanetRNG *rng, uint32_t seed) { 22155| 11.3k| rng->a = seed; 22156| 11.3k| rng->b = 0x97654321u; 22157| 11.3k| rng->c = 123871873u; 22158| 11.3k| rng->d = 0xf23f56c8u; 22159| 11.3k| rng->counter = 0u; 22160| | /* First several numbers aren't that random. */ 22161| 192k| for (int i = 0; i < 16; i++) janet_rng_u32(rng); ------------------ | Branch (22161:21): [True: 180k, False: 11.3k] ------------------ 22162| 11.3k|} janet_rng_u32: 22178| 180k|uint32_t janet_rng_u32(JanetRNG *rng) { 22179| | /* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */ 22180| 180k| uint32_t t = rng->d; 22181| 180k| uint32_t const s = rng->a; 22182| 180k| rng->d = rng->c; 22183| 180k| rng->c = rng->b; 22184| 180k| rng->b = s; 22185| 180k| t ^= t >> 2; 22186| 180k| t ^= t << 1; 22187| 180k| t ^= s ^ (s << 4); 22188| 180k| rng->a = t; 22189| 180k| rng->counter += 362437; 22190| 180k| return t + rng->counter; 22191| 180k|} janet_lib_math: 22458| 5.65k|void janet_lib_math(JanetTable *env) { 22459| 5.65k| JanetRegExt math_cfuns[] = { 22460| 5.65k| JANET_CORE_REG("not", janet_not), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22461| 5.65k| JANET_CORE_REG("math/random", janet_rand), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22462| 5.65k| JANET_CORE_REG("math/seedrandom", janet_srand), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22463| 5.65k| JANET_CORE_REG("math/cos", janet_cos), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22464| 5.65k| JANET_CORE_REG("math/sin", janet_sin), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22465| 5.65k| JANET_CORE_REG("math/tan", janet_tan), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22466| 5.65k| JANET_CORE_REG("math/acos", janet_acos), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22467| 5.65k| JANET_CORE_REG("math/asin", janet_asin), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22468| 5.65k| JANET_CORE_REG("math/atan", janet_atan), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22469| 5.65k| JANET_CORE_REG("math/exp", janet_exp), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22470| 5.65k| JANET_CORE_REG("math/log", janet_log), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22471| 5.65k| JANET_CORE_REG("math/log10", janet_log10), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22472| 5.65k| JANET_CORE_REG("math/log2", janet_log2), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22473| 5.65k| JANET_CORE_REG("math/sqrt", janet_sqrt), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22474| 5.65k|#ifndef JANET_PLAN9 22475| 5.65k| JANET_CORE_REG("math/cbrt", janet_cbrt), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22476| 5.65k| JANET_CORE_REG("math/gamma", janet_tgamma), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22477| 5.65k| JANET_CORE_REG("math/log-gamma", janet_lgamma), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22478| 5.65k| JANET_CORE_REG("math/erfc", janet_erfc), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22479| 5.65k| JANET_CORE_REG("math/erf", janet_erf), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22480| 5.65k| JANET_CORE_REG("math/expm1", janet_expm1), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22481| 5.65k| JANET_CORE_REG("math/atanh", janet_atanh), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22482| 5.65k| JANET_CORE_REG("math/asinh", janet_asinh), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22483| 5.65k| JANET_CORE_REG("math/next", janet_nextafter), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22484| 5.65k|#endif 22485| 5.65k| JANET_CORE_REG("math/floor", janet_floor), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22486| 5.65k| JANET_CORE_REG("math/ceil", janet_ceil), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22487| 5.65k| JANET_CORE_REG("math/pow", janet_pow), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22488| 5.65k| JANET_CORE_REG("math/abs", janet_fabs), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22489| 5.65k| JANET_CORE_REG("math/sinh", janet_sinh), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22490| 5.65k| JANET_CORE_REG("math/cosh", janet_cosh), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22491| 5.65k| JANET_CORE_REG("math/tanh", janet_tanh), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22492| 5.65k| JANET_CORE_REG("math/acosh", janet_acosh), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22493| 5.65k| JANET_CORE_REG("math/atan2", janet_atan2), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22494| 5.65k| JANET_CORE_REG("math/rng", cfun_rng_make), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22495| 5.65k| JANET_CORE_REG("math/rng-uniform", cfun_rng_uniform), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22496| 5.65k| JANET_CORE_REG("math/rng-int", cfun_rng_int), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22497| 5.65k| JANET_CORE_REG("math/rng-buffer", cfun_rng_buffer), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22498| 5.65k| JANET_CORE_REG("math/hypot", janet_hypot), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22499| 5.65k| JANET_CORE_REG("math/exp2", janet_exp2), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22500| 5.65k| JANET_CORE_REG("math/log1p", janet_log1p), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22501| 5.65k| JANET_CORE_REG("math/trunc", janet_trunc), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22502| 5.65k| JANET_CORE_REG("math/round", janet_round), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22503| 5.65k| JANET_CORE_REG("math/gcd", janet_cfun_gcd), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22504| 5.65k| JANET_CORE_REG("math/lcm", janet_cfun_lcm), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22505| 5.65k| JANET_CORE_REG("math/frexp", janet_cfun_frexp), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22506| 5.65k| JANET_CORE_REG("math/ldexp", janet_cfun_ldexp), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22507| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 22508| 5.65k| }; 22509| 5.65k| janet_core_cfuns_ext(env, NULL, math_cfuns); 22510| 5.65k| janet_register_abstract_type(&janet_rng_type); 22511| |#ifdef JANET_BOOTSTRAP 22512| | JANET_CORE_DEF(env, "math/pi", janet_wrap_number(3.1415926535897931), 22513| | "The value pi."); 22514| | JANET_CORE_DEF(env, "math/e", janet_wrap_number(2.7182818284590451), 22515| | "The base of the natural log."); 22516| | JANET_CORE_DEF(env, "math/inf", janet_wrap_number(INFINITY), 22517| | "The number representing positive infinity"); 22518| | JANET_CORE_DEF(env, "math/-inf", janet_wrap_number(-INFINITY), 22519| | "The number representing negative infinity"); 22520| | JANET_CORE_DEF(env, "math/int32-min", janet_wrap_number(INT32_MIN), 22521| | "The minimum contiguous integer representable by a 32 bit signed integer"); 22522| | JANET_CORE_DEF(env, "math/int32-max", janet_wrap_number(INT32_MAX), 22523| | "The maximum contiguous integer representable by a 32 bit signed integer"); 22524| | JANET_CORE_DEF(env, "math/int-min", janet_wrap_number(JANET_INTMIN_DOUBLE), 22525| | "The minimum contiguous integer representable by a double (-(2^53))"); 22526| | JANET_CORE_DEF(env, "math/int-max", janet_wrap_number(JANET_INTMAX_DOUBLE), 22527| | "The maximum contiguous integer representable by a double (2^53)"); 22528| |#ifdef NAN 22529| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(NAN), "Not a number (IEEE-754 NaN)"); 22530| |#else 22531| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(0.0 / 0.0), "Not a number (IEEE-754 NaN)"); 22532| |#endif 22533| |#endif 22534| 5.65k|} janet_lib_net: 23805| 5.65k|void janet_lib_net(JanetTable *env) { 23806| 5.65k| JanetRegExt net_cfuns[] = { 23807| 5.65k| JANET_CORE_REG("net/address", cfun_net_sockaddr), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23808| 5.65k| JANET_CORE_REG("net/listen", cfun_net_listen), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23809| 5.65k| JANET_CORE_REG("net/socket", cfun_net_socket), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23810| 5.65k| JANET_CORE_REG("net/accept", cfun_stream_accept), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23811| 5.65k| JANET_CORE_REG("net/accept-loop", cfun_stream_accept_loop), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23812| 5.65k| JANET_CORE_REG("net/read", cfun_stream_read), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23813| 5.65k| JANET_CORE_REG("net/chunk", cfun_stream_chunk), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23814| 5.65k| JANET_CORE_REG("net/write", cfun_stream_write), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23815| 5.65k| JANET_CORE_REG("net/send-to", cfun_stream_send_to), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23816| 5.65k| JANET_CORE_REG("net/recv-from", cfun_stream_recv_from), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23817| 5.65k| JANET_CORE_REG("net/flush", cfun_stream_flush), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23818| 5.65k| JANET_CORE_REG("net/connect", cfun_net_connect), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23819| 5.65k| JANET_CORE_REG("net/shutdown", cfun_net_shutdown), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23820| 5.65k| JANET_CORE_REG("net/peername", cfun_net_getpeername), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23821| 5.65k| JANET_CORE_REG("net/localname", cfun_net_getsockname), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23822| 5.65k| JANET_CORE_REG("net/address-unpack", cfun_net_address_unpack), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23823| 5.65k| JANET_CORE_REG("net/setsockopt", cfun_net_setsockopt), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23824| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 23825| 5.65k| }; 23826| | janet_core_cfuns_ext(env, NULL, net_cfuns); 23827| 5.65k|} janet_net_init: 23829| 5.65k|void janet_net_init(void) { 23830| |#ifdef JANET_WINDOWS 23831| | WSADATA wsaData; 23832| | janet_assert(!WSAStartup(MAKEWORD(2, 2), &wsaData), "could not start winsock"); 23833| | janet_vm.connect_ex_loaded = 0; 23834| | janet_vm.connect_ex = NULL; 23835| |#endif 23836| 5.65k|} janet_net_deinit: 23838| 5.65k|void janet_net_deinit(void) { 23839| |#ifdef JANET_WINDOWS 23840| | WSACleanup(); 23841| |#endif 23842| 5.65k|} janet_lib_os: 26854| 5.65k|void janet_lib_os(JanetTable *env) { 26855| |#if !defined(JANET_REDUCED_OS) && defined(JANET_WINDOWS) && defined(JANET_THREADS) 26856| | /* During start up, the top-most abstract machine (thread) 26857| | * in the thread tree sets up the critical section. */ 26858| | static volatile long env_lock_initializing = 0; 26859| | static volatile long env_lock_initialized = 0; 26860| | if (!InterlockedExchange(&env_lock_initializing, 1)) { 26861| | InitializeCriticalSection(&env_lock); 26862| | InterlockedOr(&env_lock_initialized, 1); 26863| | } else { 26864| | while (!InterlockedOr(&env_lock_initialized, 0)) { 26865| | Sleep(0); 26866| | } 26867| | } 26868| | 26869| |#endif 26870| 5.65k|#ifndef JANET_NO_PROCESSES 26871| 5.65k|#endif 26872| 5.65k| JanetRegExt os_cfuns[] = { 26873| 5.65k| JANET_CORE_REG("os/exit", os_exit), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26874| 5.65k| JANET_CORE_REG("os/which", os_which), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26875| 5.65k| JANET_CORE_REG("os/arch", os_arch), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26876| 5.65k| JANET_CORE_REG("os/compiler", os_compiler), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26877| 5.65k|#ifndef JANET_REDUCED_OS 26878| | 26879| | /* misc (un-sandboxed) */ 26880| 5.65k| JANET_CORE_REG("os/cpu-count", os_cpu_count), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26881| 5.65k| JANET_CORE_REG("os/cwd", os_cwd), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26882| 5.65k| JANET_CORE_REG("os/cryptorand", os_cryptorand), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26883| 5.65k| JANET_CORE_REG("os/perm-string", os_permission_string), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26884| 5.65k| JANET_CORE_REG("os/perm-int", os_permission_int), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26885| 5.65k| JANET_CORE_REG("os/mktime", os_mktime), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26886| 5.65k| JANET_CORE_REG("os/time", os_time), /* not high resolution */ ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26887| 5.65k| JANET_CORE_REG("os/date", os_date), /* not high resolution */ ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26888| 5.65k| JANET_CORE_REG("os/strftime", os_strftime), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26889| 5.65k| JANET_CORE_REG("os/sleep", os_sleep), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26890| 5.65k| JANET_CORE_REG("os/isatty", os_isatty), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26891| 5.65k|#ifndef JANET_NO_LOCALES 26892| 5.65k| JANET_CORE_REG("os/setlocale", os_setlocale), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26893| 5.65k|#endif 26894| | 26895| | /* env functions */ 26896| 5.65k|#ifndef JANET_PLAN9 26897| 5.65k| JANET_CORE_REG("os/environ", os_environ), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26898| 5.65k|#endif 26899| 5.65k| JANET_CORE_REG("os/getenv", os_getenv), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26900| 5.65k| JANET_CORE_REG("os/setenv", os_setenv), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26901| | 26902| | /* fs read */ 26903| 5.65k| JANET_CORE_REG("os/dir", os_dir), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26904| 5.65k| JANET_CORE_REG("os/stat", os_stat), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26905| 5.65k| JANET_CORE_REG("os/lstat", os_lstat), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26906| 5.65k| JANET_CORE_REG("os/realpath", os_realpath), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26907| 5.65k| JANET_CORE_REG("os/cd", os_cd), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26908| 5.65k|#ifndef JANET_NO_UMASK 26909| 5.65k| JANET_CORE_REG("os/umask", os_umask), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26910| 5.65k|#endif 26911| 5.65k|#ifndef JANET_NO_SYMLINKS 26912| 5.65k| JANET_CORE_REG("os/readlink", os_readlink), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26913| 5.65k|#endif 26914| | 26915| | /* fs write */ 26916| 5.65k| JANET_CORE_REG("os/mkdir", os_mkdir), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26917| 5.65k| JANET_CORE_REG("os/rmdir", os_rmdir), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26918| 5.65k| JANET_CORE_REG("os/rm", os_remove), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26919| 5.65k| JANET_CORE_REG("os/link", os_link), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26920| 5.65k| JANET_CORE_REG("os/rename", os_rename), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26921| 5.65k| JANET_CORE_REG("os/chmod", os_chmod), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26922| 5.65k| JANET_CORE_REG("os/touch", os_touch), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26923| 5.65k|#ifndef JANET_NO_SYMLINKS 26924| 5.65k| JANET_CORE_REG("os/symlink", os_symlink), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26925| 5.65k|#endif 26926| | 26927| | /* processes */ 26928| 5.65k|#ifndef JANET_NO_PROCESSES 26929| 5.65k| JANET_CORE_REG("os/execute", os_execute), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26930| 5.65k| JANET_CORE_REG("os/spawn", os_spawn), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26931| 5.65k| JANET_CORE_REG("os/shell", os_shell), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26932| 5.65k| JANET_CORE_REG("os/posix-fork", os_posix_fork), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26933| 5.65k| JANET_CORE_REG("os/posix-exec", os_posix_exec), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26934| 5.65k| JANET_CORE_REG("os/posix-chroot", os_posix_chroot), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26935| | /* no need to sandbox process management if you can't create processes 26936| | * (allows for limited functionality if use exposes C-functions to create specific processes) */ 26937| 5.65k| JANET_CORE_REG("os/proc-wait", os_proc_wait), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26938| 5.65k| JANET_CORE_REG("os/proc-kill", os_proc_kill), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26939| 5.65k| JANET_CORE_REG("os/proc-close", os_proc_close), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26940| 5.65k| JANET_CORE_REG("os/getpid", os_proc_getpid), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26941| 5.65k|#ifdef JANET_EV 26942| 5.65k| JANET_CORE_REG("os/sigaction", os_sigaction), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26943| 5.65k|#endif 26944| 5.65k|#endif 26945| | 26946| | /* high resolution timers */ 26947| 5.65k| JANET_CORE_REG("os/clock", os_clock), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26948| | 26949| 5.65k|#ifdef JANET_EV 26950| 5.65k| JANET_CORE_REG("os/open", os_open), /* fs read and write */ ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26951| 5.65k| JANET_CORE_REG("os/pipe", os_pipe), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26952| 5.65k|#endif 26953| 5.65k|#endif 26954| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 26955| 5.65k| }; 26956| | janet_core_cfuns_ext(env, NULL, os_cfuns); 26957| 5.65k|} janet_is_symbol_char: 27017| 165k|int janet_is_symbol_char(uint8_t c) { 27018| 165k| return symchars[c >> 5] & ((uint32_t)1 << (c & 0x1F)); 27019| 165k|} janet_valid_utf8: 27024| 807|int janet_valid_utf8(const uint8_t *str, int32_t len) { 27025| 807| int32_t i = 0; 27026| 807| int32_t j; 27027| 3.23k| while (i < len) { ------------------ | Branch (27027:12): [True: 2.81k, False: 424] ------------------ 27028| 2.81k| int32_t nexti; 27029| 2.81k| uint8_t c = str[i]; 27030| | 27031| | /* Check the number of bytes in code point */ 27032| 2.81k| if (c < 0x80) nexti = i + 1; ------------------ | Branch (27032:13): [True: 1.74k, False: 1.07k] ------------------ 27033| 1.07k| else if ((c >> 5) == 0x06) nexti = i + 2; ------------------ | Branch (27033:18): [True: 330, False: 743] ------------------ 27034| 743| else if ((c >> 4) == 0x0E) nexti = i + 3; ------------------ | Branch (27034:18): [True: 301, False: 442] ------------------ 27035| 442| else if ((c >> 3) == 0x1E) nexti = i + 4; ------------------ | Branch (27035:18): [True: 252, False: 190] ------------------ 27036| | /* Don't allow 5 or 6 byte code points */ 27037| 190| else return 0; 27038| | 27039| | /* No overflow */ 27040| 2.62k| if (nexti > len) return 0; ------------------ | Branch (27040:13): [True: 98, False: 2.52k] ------------------ 27041| | 27042| | /* Ensure trailing bytes are well formed (10XX XXXX) */ 27043| 3.94k| for (j = i + 1; j < nexti; j++) { ------------------ | Branch (27043:25): [True: 1.49k, False: 2.45k] ------------------ 27044| 1.49k| if ((str[j] >> 6) != 2) return 0; ------------------ | Branch (27044:17): [True: 73, False: 1.42k] ------------------ 27045| 1.49k| } 27046| | 27047| | /* Check for overlong encoding */ 27048| 2.45k| if ((nexti == i + 2) && str[i] < 0xC2) return 0; ------------------ | Branch (27048:13): [True: 234, False: 2.21k] | Branch (27048:33): [True: 5, False: 229] ------------------ 27049| 2.44k| if ((str[i] == 0xE0) && str[i + 1] < 0xA0) return 0; ------------------ | Branch (27049:13): [True: 128, False: 2.31k] | Branch (27049:33): [True: 11, False: 117] ------------------ 27050| 2.43k| if ((str[i] == 0xF0) && str[i + 1] < 0x90) return 0; ------------------ | Branch (27050:13): [True: 98, False: 2.33k] | Branch (27050:33): [True: 6, False: 92] ------------------ 27051| | 27052| 2.43k| i = nexti; 27053| 2.43k| } 27054| 424| return 1; 27055| 807|} janet_parser_consume: 27659| 257k|void janet_parser_consume(JanetParser *parser, uint8_t c) { 27660| 257k| int consumed = 0; 27661| 257k| janet_parser_checkdead(parser); 27662| 257k| if (c == '\r') { ------------------ | Branch (27662:9): [True: 2.38k, False: 255k] ------------------ 27663| 2.38k| parser->line++; 27664| 2.38k| parser->column = 0; 27665| 255k| } else if (c == '\n') { ------------------ | Branch (27665:16): [True: 8.87k, False: 246k] ------------------ 27666| 8.87k| parser->column = 0; 27667| 8.87k| if (parser->lookback != '\r') ------------------ | Branch (27667:13): [True: 8.41k, False: 457] ------------------ 27668| 8.41k| parser->line++; 27669| 246k| } else { 27670| 246k| parser->column++; 27671| 246k| } 27672| 578k| while (!consumed && !parser->error) { ------------------ | Branch (27672:12): [True: 321k, False: 257k] | Branch (27672:25): [True: 320k, False: 755] ------------------ 27673| 320k| JanetParseState *state = parser->states + parser->statecount - 1; 27674| 320k| consumed = state->consumer(parser, state, c); 27675| 320k| } 27676| 257k| parser->lookback = c; 27677| 257k|} janet_parser_eof: 27679| 4.91k|void janet_parser_eof(JanetParser *parser) { 27680| 4.91k| janet_parser_checkdead(parser); 27681| 4.91k| size_t oldcolumn = parser->column; 27682| 4.91k| size_t oldline = parser->line; 27683| 4.91k| janet_parser_consume(parser, '\n'); 27684| 4.91k| if (parser->statecount > 1) { ------------------ | Branch (27684:9): [True: 1.38k, False: 3.52k] ------------------ 27685| 1.38k| delim_error(parser, parser->statecount - 1, 0, "unexpected end of source"); 27686| 1.38k| } 27687| 4.91k| parser->line = oldline; 27688| 4.91k| parser->column = oldcolumn; 27689| 4.91k| parser->flag |= JANET_PARSER_DEAD; ------------------ | |26991| 4.91k|#define JANET_PARSER_DEAD 0x1 ------------------ 27690| 4.91k|} janet_parser_status: 27692| 264k|enum JanetParserStatus janet_parser_status(JanetParser *parser) { 27693| 264k| if (parser->error) return JANET_PARSE_ERROR; ------------------ | Branch (27693:9): [True: 3.60k, False: 260k] ------------------ 27694| 260k| if (parser->flag) return JANET_PARSE_DEAD; ------------------ | Branch (27694:9): [True: 3.52k, False: 257k] ------------------ 27695| 257k| if (parser->statecount > 1) return JANET_PARSE_PENDING; ------------------ | Branch (27695:9): [True: 239k, False: 17.6k] ------------------ 27696| 17.6k| return JANET_PARSE_ROOT; 27697| 257k|} janet_parser_produce: 27718| 3.43k|Janet janet_parser_produce(JanetParser *parser) { 27719| 3.43k| Janet ret; 27720| 3.43k| size_t i; 27721| 3.43k| if (parser->pending == 0) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (27721:9): [True: 0, False: 3.43k] ------------------ 27722| 3.43k| ret = janet_unwrap_tuple(parser->args[0])[0]; ------------------ | | 858| 3.43k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 27723| 9.65k| for (i = 1; i < parser->argcount; i++) { ------------------ | Branch (27723:17): [True: 6.22k, False: 3.43k] ------------------ 27724| 6.22k| parser->args[i - 1] = parser->args[i]; 27725| 6.22k| } 27726| 3.43k| parser->pending--; 27727| 3.43k| parser->argcount--; 27728| 3.43k| parser->states[0].argn--; 27729| 3.43k| return ret; 27730| 3.43k|} janet_parser_init: 27746| 5.65k|void janet_parser_init(JanetParser *parser) { 27747| 5.65k| parser->args = NULL; 27748| 5.65k| parser->states = NULL; 27749| 5.65k| parser->buf = NULL; 27750| 5.65k| parser->argcount = 0; 27751| 5.65k| parser->argcap = 0; 27752| 5.65k| parser->bufcount = 0; 27753| 5.65k| parser->bufcap = 0; 27754| 5.65k| parser->statecount = 0; 27755| 5.65k| parser->statecap = 0; 27756| 5.65k| parser->error = NULL; 27757| 5.65k| parser->lookback = -1; 27758| 5.65k| parser->line = 1; 27759| 5.65k| parser->column = 0; 27760| 5.65k| parser->pending = 0; 27761| 5.65k| parser->flag = 0; 27762| | 27763| 5.65k| pushstate(parser, root, PFLAG_CONTAINER); ------------------ | |27096| 5.65k|#define PFLAG_CONTAINER 0x100 ------------------ 27764| 5.65k|} janet_parser_deinit: 27766| 5.65k|void janet_parser_deinit(JanetParser *parser) { 27767| 5.65k| janet_free(parser->args); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 27768| 5.65k| janet_free(parser->buf); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 27769| 5.65k| janet_free(parser->states); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 27770| 5.65k|} janet_parser_has_more: 27817| 3.52k|int janet_parser_has_more(JanetParser *parser) { 27818| 3.52k| return !!parser->pending; 27819| 3.52k|} janet_lib_parse: 28271| 5.65k|void janet_lib_parse(JanetTable *env) { 28272| 5.65k| JanetRegExt parse_cfuns[] = { 28273| 5.65k| JANET_CORE_REG("parser/new", cfun_parse_parser), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28274| 5.65k| JANET_CORE_REG("parser/clone", cfun_parse_clone), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28275| 5.65k| JANET_CORE_REG("parser/has-more", cfun_parse_has_more), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28276| 5.65k| JANET_CORE_REG("parser/produce", cfun_parse_produce), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28277| 5.65k| JANET_CORE_REG("parser/consume", cfun_parse_consume), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28278| 5.65k| JANET_CORE_REG("parser/byte", cfun_parse_byte), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28279| 5.65k| JANET_CORE_REG("parser/error", cfun_parse_error), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28280| 5.65k| JANET_CORE_REG("parser/status", cfun_parse_status), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28281| 5.65k| JANET_CORE_REG("parser/flush", cfun_parse_flush), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28282| 5.65k| JANET_CORE_REG("parser/state", cfun_parse_state), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28283| 5.65k| JANET_CORE_REG("parser/where", cfun_parse_where), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28284| 5.65k| JANET_CORE_REG("parser/eof", cfun_parse_eof), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28285| 5.65k| JANET_CORE_REG("parser/insert", cfun_parse_insert), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28286| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 28287| 5.65k| }; 28288| | janet_core_cfuns_ext(env, NULL, parse_cfuns); 28289| 5.65k|} cfun_peg_match: 30306| 3.43k| "Returns nil if text does not match the language defined by peg. The syntax of PEGs is documented on the Janet website.") { 30307| 3.43k| PegCall c = peg_cfun_init(argc, argv, 0); 30308| 3.43k| const uint8_t *result = peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + c.start); 30309| 3.43k| return result ? janet_wrap_array(c.s.captures) : janet_wrap_nil(); ------------------ | | 845| 734|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 734| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 734|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 734|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return result ? janet_wrap_array(c.s.captures) : janet_wrap_nil(); ------------------ | | 831| 2.69k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 2.69k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2.69k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.69k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (30309:12): [True: 734, False: 2.69k] ------------------ 30310| 3.43k|} janet_lib_peg: 30407| 5.65k|void janet_lib_peg(JanetTable *env) { 30408| 5.65k| JanetRegExt cfuns[] = { 30409| 5.65k| JANET_CORE_REG("peg/compile", cfun_peg_compile), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30410| 5.65k| JANET_CORE_REG("peg/match", cfun_peg_match), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30411| 5.65k| JANET_CORE_REG("peg/find", cfun_peg_find), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30412| 5.65k| JANET_CORE_REG("peg/find-all", cfun_peg_find_all), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30413| 5.65k| JANET_CORE_REG("peg/replace", cfun_peg_replace), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30414| 5.65k| JANET_CORE_REG("peg/replace-all", cfun_peg_replace_all), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30415| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 30416| 5.65k| }; 30417| | janet_core_cfuns_ext(env, NULL, cfuns); 30418| 5.65k| janet_register_abstract_type(&janet_peg_type); 30419| 5.65k|} janet_to_string_b: 30649| 27.8k|void janet_to_string_b(JanetBuffer *buffer, Janet x) { 30650| 27.8k| switch (janet_type(x)) { ------------------ | | 795| 27.8k| (isnan((x).number) \ | | 796| 27.8k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 27.8k| : JANET_NUMBER) ------------------ | Branch (30650:13): [True: 24.8k, False: 2.94k] ------------------ 30651| 0| case JANET_NIL: ------------------ | Branch (30651:9): [True: 0, False: 27.8k] ------------------ 30652| 0| janet_buffer_push_cstring(buffer, ""); 30653| 0| break; 30654| 27| case JANET_BOOLEAN: ------------------ | Branch (30654:9): [True: 27, False: 27.7k] ------------------ 30655| 27| janet_buffer_push_cstring(buffer, 30656| 27| janet_unwrap_boolean(x) ? "true" : "false"); ------------------ | | 838| 27|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) | | ------------------ | | | Branch (838:33): [True: 8, False: 19] | | ------------------ ------------------ 30657| 27| break; 30658| 2.94k| case JANET_NUMBER: ------------------ | Branch (30658:9): [True: 2.94k, False: 24.8k] ------------------ 30659| 2.94k| number_to_string_b(buffer, janet_unwrap_number(x)); ------------------ | | 839| 2.94k|#define janet_unwrap_number(x) ((x).number) ------------------ 30660| 2.94k| break; 30661| 0| case JANET_STRING: ------------------ | Branch (30661:9): [True: 0, False: 27.8k] ------------------ 30662| 24.0k| case JANET_SYMBOL: ------------------ | Branch (30662:9): [True: 24.0k, False: 3.75k] ------------------ 30663| 24.7k| case JANET_KEYWORD: ------------------ | Branch (30663:9): [True: 742, False: 27.0k] ------------------ 30664| 24.7k| janet_buffer_push_bytes(buffer, 30665| 24.7k| janet_unwrap_string(x), ------------------ | | 863| 24.7k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 30666| 24.7k| janet_string_length(janet_unwrap_string(x))); ------------------ | | 1813| 24.7k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 24.7k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30667| 24.7k| break; 30668| 0| case JANET_BUFFER: { ------------------ | Branch (30668:9): [True: 0, False: 27.8k] ------------------ 30669| 0| JanetBuffer *to = janet_unwrap_buffer(x); ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 30670| | /* Prevent resizing buffer while appending */ 30671| 0| if (buffer == to) janet_buffer_extra(buffer, to->count); ------------------ | Branch (30671:17): [True: 0, False: 0] ------------------ 30672| 0| janet_buffer_push_bytes(buffer, to->data, to->count); 30673| 0| break; 30674| 24.0k| } 30675| 0| case JANET_ABSTRACT: { ------------------ | Branch (30675:9): [True: 0, False: 27.8k] ------------------ 30676| 0| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 30677| 0| const JanetAbstractType *t = janet_abstract_type(p); ------------------ | | 1899| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 30678| 0| if (t->tostring != NULL) { ------------------ | Branch (30678:17): [True: 0, False: 0] ------------------ 30679| 0| t->tostring(p, buffer); 30680| 0| } else { 30681| 0| string_description_b(buffer, t->name, p); 30682| 0| } 30683| 0| } 30684| 0| return; 30685| 0| case JANET_CFUNCTION: { ------------------ | Branch (30685:9): [True: 0, False: 27.8k] ------------------ 30686| 0| JanetCFunRegistry *reg = janet_registry_get(janet_unwrap_cfunction(x)); ------------------ | | 869| 0|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 30687| 0| if (NULL != reg) { ------------------ | Branch (30687:17): [True: 0, False: 0] ------------------ 30688| 0| janet_buffer_push_cstring(buffer, "name_prefix) { ------------------ | Branch (30689:21): [True: 0, False: 0] ------------------ 30690| 0| janet_buffer_push_cstring(buffer, reg->name_prefix); 30691| 0| janet_buffer_push_u8(buffer, '/'); 30692| 0| } 30693| 0| janet_buffer_push_cstring(buffer, reg->name); 30694| 0| janet_buffer_push_u8(buffer, '>'); 30695| 0| break; 30696| 0| } 30697| 0| goto fallthrough; 30698| 0| } 30699| 0| case JANET_FUNCTION: { ------------------ | Branch (30699:9): [True: 0, False: 27.8k] ------------------ 30700| 0| JanetFunction *fun = janet_unwrap_function(x); ------------------ | | 868| 0|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 30701| 0| JanetFuncDef *def = fun->def; 30702| 0| if (def == NULL) { ------------------ | Branch (30702:17): [True: 0, False: 0] ------------------ 30703| 0| janet_buffer_push_cstring(buffer, ""); 30704| 0| break; 30705| 0| } 30706| 0| if (def->name) { ------------------ | Branch (30706:17): [True: 0, False: 0] ------------------ 30707| 0| const uint8_t *n = def->name; 30708| 0| janet_buffer_push_cstring(buffer, "length) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30710| 0| janet_buffer_push_u8(buffer, '>'); 30711| 0| break; 30712| 0| } 30713| 0| goto fallthrough; 30714| 0| } 30715| 0| fallthrough: 30716| 37| default: ------------------ | Branch (30716:9): [True: 37, False: 27.7k] ------------------ 30717| 37| string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 795| 37| (isnan((x).number) \ | | 796| 37| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 37| : JANET_NUMBER) ------------------ string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 867| 37|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (30717:59): [True: 37, False: 0] ------------------ 30718| 37| break; 30719| 27.8k| } 30720| 27.8k|} janet_description_b: 30735| 9.05M|void janet_description_b(JanetBuffer *buffer, Janet x) { 30736| 9.05M| switch (janet_type(x)) { ------------------ | | 795| 9.05M| (isnan((x).number) \ | | 796| 9.05M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 9.05M| : JANET_NUMBER) ------------------ | Branch (30736:13): [True: 9.04M, False: 2.94k] ------------------ 30737| 27.0k| default: ------------------ | Branch (30737:9): [True: 27.0k, False: 9.02M] ------------------ 30738| 27.0k| break; 30739| 27.0k| case JANET_NIL: ------------------ | Branch (30739:9): [True: 17, False: 9.05M] ------------------ 30740| 17| janet_buffer_push_cstring(buffer, "nil"); 30741| 17| return; 30742| 742| case JANET_KEYWORD: ------------------ | Branch (30742:9): [True: 742, False: 9.04M] ------------------ 30743| 742| janet_buffer_push_u8(buffer, ':'); 30744| 742| break; 30745| 9.02M| case JANET_STRING: ------------------ | Branch (30745:9): [True: 9.02M, False: 28.8k] ------------------ 30746| 9.02M| janet_escape_string_b(buffer, janet_unwrap_string(x)); ------------------ | | 863| 9.02M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 30747| 9.02M| return; 30748| 154| case JANET_BUFFER: { ------------------ | Branch (30748:9): [True: 154, False: 9.05M] ------------------ 30749| 154| JanetBuffer *b = janet_unwrap_buffer(x); ------------------ | | 862| 154|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 30750| 154| janet_escape_buffer_b(buffer, b); 30751| 154| return; 30752| 0| } 30753| 854| case JANET_ABSTRACT: { ------------------ | Branch (30753:9): [True: 854, False: 9.04M] ------------------ 30754| 854| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 866| 854|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 30755| 854| const JanetAbstractType *t = janet_abstract_type(p); ------------------ | | 1899| 854|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 854|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 30756| 854| if (t->tostring != NULL) { ------------------ | Branch (30756:17): [True: 854, False: 0] ------------------ 30757| 854| janet_buffer_push_cstring(buffer, "<"); 30758| 854| janet_buffer_push_cstring(buffer, t->name); 30759| 854| janet_buffer_push_cstring(buffer, " "); 30760| 854| t->tostring(p, buffer); 30761| 854| janet_buffer_push_cstring(buffer, ">"); 30762| 854| } else { 30763| 0| string_description_b(buffer, t->name, p); 30764| 0| } 30765| 854| return; 30766| 0| } 30767| 9.05M| } 30768| 27.8k| janet_to_string_b(buffer, x); 30769| 27.8k|} janet_formatbv: 31422| 9.17M|void janet_formatbv(JanetBuffer *b, const char *format, va_list args) { 31423| 9.17M| const char *format_end = format + strlen(format); 31424| 9.17M| const char *c = format; 31425| 9.17M| int32_t startlen = b->count; 31426| 93.3M| while (c < format_end) { ------------------ | Branch (31426:12): [True: 84.1M, False: 9.17M] ------------------ 31427| 84.1M| if (*c != '%') { ------------------ | Branch (31427:13): [True: 65.8M, False: 18.3M] ------------------ 31428| 65.8M| janet_buffer_push_u8(b, (uint8_t) *c++); 31429| 65.8M| } else if (*++c == '%') { ------------------ | Branch (31429:20): [True: 0, False: 18.3M] ------------------ 31430| 0| janet_buffer_push_u8(b, (uint8_t) *c++); 31431| 18.3M| } else { 31432| 18.3M| char form[MAX_FORMAT], item[MAX_ITEM]; 31433| 18.3M| char width[3], precision[3]; 31434| 18.3M| int nb = 0; /* number of bytes in added item */ 31435| 18.3M| c = scanformat(c, form, width, precision); 31436| 18.3M| switch (*c++) { 31437| 0| case 'c': { ------------------ | Branch (31437:17): [True: 0, False: 18.3M] ------------------ 31438| 0| int n = va_arg(args, int); 31439| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31345| 0|#define MAX_ITEM 256 ------------------ 31440| 0| break; 31441| 0| } 31442| 9.17M| case 'd': ------------------ | Branch (31442:17): [True: 9.17M, False: 9.15M] ------------------ 31443| 9.17M| case 'i': { ------------------ | Branch (31443:17): [True: 0, False: 18.3M] ------------------ 31444| 9.17M| int64_t n = (int64_t) va_arg(args, int32_t); 31445| 9.17M| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31345| 9.17M|#define MAX_ITEM 256 ------------------ 31446| 9.17M| break; 31447| 9.17M| } 31448| 0| case 'D': ------------------ | Branch (31448:17): [True: 0, False: 18.3M] ------------------ 31449| 0| case 'I': { ------------------ | Branch (31449:17): [True: 0, False: 18.3M] ------------------ 31450| 0| int64_t n = va_arg(args, int64_t); 31451| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31345| 0|#define MAX_ITEM 256 ------------------ 31452| 0| break; 31453| 0| } 31454| 0| case 'x': ------------------ | Branch (31454:17): [True: 0, False: 18.3M] ------------------ 31455| 0| case 'X': ------------------ | Branch (31455:17): [True: 0, False: 18.3M] ------------------ 31456| 0| case 'o': ------------------ | Branch (31456:17): [True: 0, False: 18.3M] ------------------ 31457| 0| case 'u': { ------------------ | Branch (31457:17): [True: 0, False: 18.3M] ------------------ 31458| 0| uint64_t n = va_arg(args, uint64_t); 31459| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31345| 0|#define MAX_ITEM 256 ------------------ 31460| 0| break; 31461| 0| } 31462| 0| case 'a': ------------------ | Branch (31462:17): [True: 0, False: 18.3M] ------------------ 31463| 0| case 'A': ------------------ | Branch (31463:17): [True: 0, False: 18.3M] ------------------ 31464| 0| case 'e': ------------------ | Branch (31464:17): [True: 0, False: 18.3M] ------------------ 31465| 0| case 'E': ------------------ | Branch (31465:17): [True: 0, False: 18.3M] ------------------ 31466| 0| case 'f': ------------------ | Branch (31466:17): [True: 0, False: 18.3M] ------------------ 31467| 0| case 'g': ------------------ | Branch (31467:17): [True: 0, False: 18.3M] ------------------ 31468| 0| case 'G': { ------------------ | Branch (31468:17): [True: 0, False: 18.3M] ------------------ 31469| 0| double d = va_arg(args, double); 31470| 0| nb = snprintf(item, MAX_ITEM, form, d); ------------------ | |31345| 0|#define MAX_ITEM 256 ------------------ 31471| 0| break; 31472| 0| } 31473| 134k| case 's': ------------------ | Branch (31473:17): [True: 134k, False: 18.1M] ------------------ 31474| 135k| case 'S': { ------------------ | Branch (31474:17): [True: 522, False: 18.3M] ------------------ 31475| 135k| const char *str = va_arg(args, const char *); 31476| 135k| int32_t len = (c[-1] == 's') ------------------ | Branch (31476:35): [True: 134k, False: 522] ------------------ 31477| 135k| ? (int32_t) strlen(str) 31478| 135k| : janet_string_length((JanetString) str); ------------------ | | 1813| 522|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 522|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31479| 135k| if (form[2] == '\0') ------------------ | Branch (31479:25): [True: 135k, False: 0] ------------------ 31480| 135k| janet_buffer_push_bytes(b, (const uint8_t *) str, len); 31481| 0| else { 31482| 0| if (len != (int32_t) strlen((const char *) str)) ------------------ | Branch (31482:29): [True: 0, False: 0] ------------------ 31483| 0| janet_panic("string contains zeros"); 31484| 0| if (!strchr(form, '.') && len >= 100) { ------------------ | Branch (31484:29): [True: 0, False: 0] | Branch (31484:51): [True: 0, False: 0] ------------------ 31485| 0| janet_panic("no precision and string is too long to be formatted"); 31486| 0| } else { 31487| 0| nb = snprintf(item, MAX_ITEM, form, str); ------------------ | |31345| 0|#define MAX_ITEM 256 ------------------ 31488| 0| } 31489| 0| } 31490| 135k| break; 31491| 135k| } 31492| 135k| case 'V': ------------------ | Branch (31492:17): [True: 0, False: 18.3M] ------------------ 31493| 0| janet_to_string_b(b, va_arg(args, Janet)); 31494| 0| break; 31495| 524| case 'v': ------------------ | Branch (31495:17): [True: 524, False: 18.3M] ------------------ 31496| 524| janet_description_b(b, va_arg(args, Janet)); 31497| 524| break; 31498| 0| case 't': ------------------ | Branch (31498:17): [True: 0, False: 18.3M] ------------------ 31499| 0| janet_buffer_push_cstring(b, typestr(va_arg(args, Janet))); 31500| 0| break; 31501| 0| case 'T': { ------------------ | Branch (31501:17): [True: 0, False: 18.3M] ------------------ 31502| 0| int types = va_arg(args, int); 31503| 0| pushtypes(b, types); 31504| 0| break; 31505| 135k| } 31506| 0| case 'M': ------------------ | Branch (31506:17): [True: 0, False: 18.3M] ------------------ 31507| 9.01M| case 'm': ------------------ | Branch (31507:17): [True: 9.01M, False: 9.31M] ------------------ 31508| 9.01M| case 'N': ------------------ | Branch (31508:17): [True: 0, False: 18.3M] ------------------ 31509| 9.01M| case 'n': ------------------ | Branch (31509:17): [True: 0, False: 18.3M] ------------------ 31510| 9.01M| case 'Q': ------------------ | Branch (31510:17): [True: 0, False: 18.3M] ------------------ 31511| 9.01M| case 'q': ------------------ | Branch (31511:17): [True: 0, False: 18.3M] ------------------ 31512| 9.01M| case 'P': ------------------ | Branch (31512:17): [True: 0, False: 18.3M] ------------------ 31513| 9.02M| case 'p': { /* janet pretty , precision = depth */ ------------------ | Branch (31513:17): [True: 2.20k, False: 18.3M] ------------------ 31514| 9.02M| int depth = atoi(precision); 31515| 9.02M| if (depth < 1) depth = JANET_RECURSION_GUARD; ------------------ | | 296| 9.02M|#define JANET_RECURSION_GUARD 1024 ------------------ | Branch (31515:25): [True: 9.02M, False: 0] ------------------ 31516| 9.02M| char d = c[-1]; 31517| 9.02M| int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N'); ------------------ | Branch (31517:37): [True: 0, False: 9.02M] | Branch (31517:51): [True: 0, False: 9.02M] | Branch (31517:65): [True: 0, False: 9.02M] | Branch (31517:79): [True: 0, False: 9.02M] ------------------ 31518| 9.02M| int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n'); ------------------ | Branch (31518:39): [True: 0, False: 9.02M] | Branch (31518:53): [True: 0, False: 9.02M] | Branch (31518:67): [True: 0, False: 9.02M] | Branch (31518:81): [True: 0, False: 9.02M] ------------------ 31519| 9.02M| int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n'); ------------------ | Branch (31519:39): [True: 0, False: 9.02M] | Branch (31519:53): [True: 9.01M, False: 2.20k] | Branch (31519:67): [True: 0, False: 2.20k] | Branch (31519:81): [True: 0, False: 2.20k] ------------------ 31520| 9.02M| int columns = atoi(width); 31521| 9.02M| if (columns == 0) { ------------------ | Branch (31521:25): [True: 9.02M, False: 0] ------------------ 31522| 9.02M| columns = JANET_COLUMNS; ------------------ | |31258| 9.02M|#define JANET_COLUMNS 80 ------------------ 31523| 9.02M| } else if (columns < 0) { ------------------ | Branch (31523:32): [True: 0, False: 0] ------------------ 31524| 0| has_oneline = 1; 31525| 0| } 31526| 9.02M| int flags = 0; 31527| 9.02M| flags |= has_color ? JANET_PRETTY_COLOR : 0; ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31527:30): [True: 0, False: 9.02M] ------------------ 31528| 9.02M| flags |= has_oneline ? JANET_PRETTY_ONELINE : 0; ------------------ | | 1968| 0|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (31528:30): [True: 0, False: 9.02M] ------------------ 31529| 9.02M| flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0; ------------------ | | 1969| 9.01M|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (31529:30): [True: 9.01M, False: 2.20k] ------------------ 31530| 9.02M| janet_pretty_(b, depth, columns, flags, 31531| 9.02M| va_arg(args, Janet), startlen, b->count); 31532| 9.02M| break; 31533| 9.01M| } 31534| 0| case 'j': { ------------------ | Branch (31534:17): [True: 0, False: 18.3M] ------------------ 31535| 0| int depth = atoi(precision); 31536| 0| if (depth < 1) { ------------------ | Branch (31536:25): [True: 0, False: 0] ------------------ 31537| 0| depth = JANET_RECURSION_GUARD; ------------------ | | 296| 0|#define JANET_RECURSION_GUARD 1024 ------------------ 31538| 0| } 31539| 0| janet_jdn_(b, depth, va_arg(args, Janet), startlen, b->count); 31540| 0| break; 31541| 9.01M| } 31542| 0| default: { ------------------ | Branch (31542:17): [True: 0, False: 18.3M] ------------------ 31543| | /* also treat cases 'nLlh' */ 31544| 0| janet_panicf("invalid conversion '%s' to 'format'", 31545| 0| form); 31546| 9.01M| } 31547| 18.3M| } 31548| 18.3M| if (nb >= MAX_ITEM) ------------------ | |31345| 18.3M|#define MAX_ITEM 256 ------------------ | Branch (31548:17): [True: 0, False: 18.3M] ------------------ 31549| 0| janet_panic("format buffer overflow"); 31550| 18.3M| if (nb > 0) ------------------ | Branch (31550:17): [True: 9.17M, False: 9.15M] ------------------ 31551| 9.17M| janet_buffer_push_bytes(b, (uint8_t *) item, nb); 31552| 18.3M| } 31553| | 31554| 84.1M| } 31555| 9.17M|} janet_formatc: 31559| 1.17k|const uint8_t *janet_formatc(const char *format, ...) { 31560| 1.17k| va_list args; 31561| 1.17k| const uint8_t *ret; 31562| 1.17k| JanetBuffer buffer; 31563| 1.17k| int32_t len = 0; 31564| | 31565| | /* Calculate length, init buffer and args */ 31566| 29.6k| while (format[len]) len++; ------------------ | Branch (31566:12): [True: 28.4k, False: 1.17k] ------------------ 31567| 1.17k| janet_buffer_init(&buffer, len); 31568| 1.17k| va_start(args, format); 31569| | 31570| | /* Run format */ 31571| 1.17k| janet_formatbv(&buffer, format, args); 31572| | 31573| | /* Iterate length */ 31574| 1.17k| va_end(args); 31575| | 31576| 1.17k| ret = janet_string(buffer.data, buffer.count); 31577| 1.17k| janet_buffer_deinit(&buffer); 31578| 1.17k| return ret; 31579| 1.17k|} janet_formatb: 31581| 1.41k|JanetBuffer *janet_formatb(JanetBuffer *buffer, const char *format, ...) { 31582| 1.41k| va_list args; 31583| 1.41k| va_start(args, format); 31584| 1.41k| janet_formatbv(buffer, format, args); 31585| | va_end(args); 31586| 1.41k| return buffer; 31587| 1.41k|} janet_string: 33498| 25.1M|const uint8_t *janet_string(const uint8_t *buf, int32_t len) { 33499| 25.1M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1); 33500| 25.1M| head->length = len; 33501| 25.1M| head->hash = janet_string_calchash(buf, len); 33502| 25.1M| uint8_t *data = (uint8_t *)head->data; 33503| 25.1M| safe_memcpy(data, buf, len); 33504| 25.1M| data[len] = 0; 33505| 25.1M| return data; 33506| 25.1M|} janet_string_compare: 33509| 5.45k|int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) { 33510| 5.45k| int32_t xlen = janet_string_length(lhs); ------------------ | | 1813| 5.45k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 5.45k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33511| 5.45k| int32_t ylen = janet_string_length(rhs); ------------------ | | 1813| 5.45k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 5.45k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33512| 5.45k| int32_t len = xlen > ylen ? ylen : xlen; ------------------ | Branch (33512:19): [True: 863, False: 4.58k] ------------------ 33513| 5.45k| int res = memcmp(lhs, rhs, len); 33514| 5.45k| if (res) return res > 0 ? 1 : -1; ------------------ | Branch (33514:9): [True: 1.78k, False: 3.67k] | Branch (33514:21): [True: 492, False: 1.29k] ------------------ 33515| 3.67k| if (xlen == ylen) return 0; ------------------ | Branch (33515:9): [True: 3.47k, False: 197] ------------------ 33516| 197| return xlen < ylen ? -1 : 1; ------------------ | Branch (33516:12): [True: 98, False: 99] ------------------ 33517| 3.67k|} janet_string_equalconst: 33520| 36.0M|int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) { 33521| 36.0M| int32_t lhash = janet_string_hash(lhs); ------------------ | | 1814| 36.0M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 36.0M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33522| 36.0M| int32_t llen = janet_string_length(lhs); ------------------ | | 1813| 36.0M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 36.0M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33523| 36.0M| if (lhash != rhash || llen != rlen) ------------------ | Branch (33523:9): [True: 16.1M, False: 19.9M] | Branch (33523:27): [True: 11, False: 19.9M] ------------------ 33524| 16.1M| return 0; 33525| 19.9M| if (lhs == rhs) ------------------ | Branch (33525:9): [True: 11.3M, False: 8.63M] ------------------ 33526| 11.3M| return 1; 33527| 8.63M| return !memcmp(lhs, rhs, rlen); 33528| 19.9M|} janet_string_equal: 33531| 2.26k|int janet_string_equal(const uint8_t *lhs, const uint8_t *rhs) { 33532| 2.26k| return janet_string_equalconst(lhs, rhs, 33533| 2.26k| janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1813| 2.26k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 2.26k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1814| 2.26k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 2.26k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33534| 2.26k|} janet_lib_string: 34106| 5.65k|void janet_lib_string(JanetTable *env) { 34107| 5.65k| JanetRegExt string_cfuns[] = { 34108| 5.65k| JANET_CORE_REG("string/slice", cfun_string_slice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34109| 5.65k| JANET_CORE_REG("keyword/slice", cfun_keyword_slice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34110| 5.65k| JANET_CORE_REG("symbol/slice", cfun_symbol_slice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34111| 5.65k| JANET_CORE_REG("string/repeat", cfun_string_repeat), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34112| 5.65k| JANET_CORE_REG("string/bytes", cfun_string_bytes), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34113| 5.65k| JANET_CORE_REG("string/from-bytes", cfun_string_frombytes), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34114| 5.65k| JANET_CORE_REG("string/ascii-lower", cfun_string_asciilower), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34115| 5.65k| JANET_CORE_REG("string/ascii-upper", cfun_string_asciiupper), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34116| 5.65k| JANET_CORE_REG("string/reverse", cfun_string_reverse), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34117| 5.65k| JANET_CORE_REG("string/find", cfun_string_find), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34118| 5.65k| JANET_CORE_REG("string/find-all", cfun_string_findall), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34119| 5.65k| JANET_CORE_REG("string/has-prefix?", cfun_string_hasprefix), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34120| 5.65k| JANET_CORE_REG("string/has-suffix?", cfun_string_hassuffix), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34121| 5.65k| JANET_CORE_REG("string/replace", cfun_string_replace), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34122| 5.65k| JANET_CORE_REG("string/replace-all", cfun_string_replaceall), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34123| 5.65k| JANET_CORE_REG("string/split", cfun_string_split), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34124| 5.65k| JANET_CORE_REG("string/check-set", cfun_string_checkset), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34125| 5.65k| JANET_CORE_REG("string/join", cfun_string_join), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34126| 5.65k| JANET_CORE_REG("string/format", cfun_string_format), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34127| 5.65k| JANET_CORE_REG("string/trim", cfun_string_trim), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34128| 5.65k| JANET_CORE_REG("string/triml", cfun_string_triml), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34129| 5.65k| JANET_CORE_REG("string/trimr", cfun_string_trimr), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34130| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 34131| 5.65k| }; 34132| | janet_core_cfuns_ext(env, NULL, string_cfuns); 34133| 5.65k|} janet_scan_number_base: 34394| 13.0k| double *out) { 34395| 13.0k| const uint8_t *end = str + len; 34396| 13.0k| int seenadigit = 0; 34397| 13.0k| int ex = 0; 34398| 13.0k| int seenpoint = 0; 34399| 13.0k| int foundexp = 0; 34400| 13.0k| int neg = 0; 34401| 13.0k| struct BigNat mant; 34402| 13.0k| bignat_zero(&mant); 34403| | 34404| | /* Prevent some kinds of overflow bugs relating to the exponent 34405| | * overflowing. For example, if a string was passed 2GB worth of 0s after 34406| | * the decimal point, exponent could wrap around and become positive. It's 34407| | * easier to reject ridiculously large inputs than to check for overflows. 34408| | * */ 34409| 13.0k| if (len > JANET_NUMBER_LENGTH_RIDICULOUS) goto error; ------------------ | |34190| 13.0k|#define JANET_NUMBER_LENGTH_RIDICULOUS 0xFFFF ------------------ | Branch (34409:9): [True: 0, False: 13.0k] ------------------ 34410| | 34411| | /* Get sign */ 34412| 13.0k| if (str >= end) goto error; ------------------ | Branch (34412:9): [True: 0, False: 13.0k] ------------------ 34413| 13.0k| if (*str == '-') { ------------------ | Branch (34413:9): [True: 2.00k, False: 11.0k] ------------------ 34414| 2.00k| neg = 1; 34415| 2.00k| str++; 34416| 11.0k| } else if (*str == '+') { ------------------ | Branch (34416:16): [True: 953, False: 10.0k] ------------------ 34417| 953| str++; 34418| 953| } 34419| | 34420| | /* Check for leading 0x or digit digit r */ 34421| 13.0k| if (base == 0) { ------------------ | Branch (34421:9): [True: 13.0k, False: 0] ------------------ 34422| 13.0k| if (str + 1 < end && str[0] == '0' && str[1] == 'x') { ------------------ | Branch (34422:13): [True: 7.24k, False: 5.80k] | Branch (34422:30): [True: 1.50k, False: 5.73k] | Branch (34422:47): [True: 170, False: 1.33k] ------------------ 34423| 170| base = 16; 34424| 170| str += 2; 34425| 12.8k| } else if (str + 1 < end && ------------------ | Branch (34425:20): [True: 7.07k, False: 5.80k] ------------------ 34426| 7.07k| str[0] >= '0' && str[0] <= '9' && ------------------ | Branch (34426:20): [True: 5.02k, False: 2.04k] | Branch (34426:37): [True: 4.83k, False: 186] ------------------ 34427| 4.83k| str[1] == 'r') { ------------------ | Branch (34427:20): [True: 79, False: 4.76k] ------------------ 34428| 79| base = str[0] - '0'; 34429| 79| str += 2; 34430| 12.7k| } else if (str + 2 < end && ------------------ | Branch (34430:20): [True: 5.30k, False: 7.49k] ------------------ 34431| 5.30k| str[0] >= '0' && str[0] <= '9' && ------------------ | Branch (34431:20): [True: 3.79k, False: 1.50k] | Branch (34431:37): [True: 3.65k, False: 138] ------------------ 34432| 3.65k| str[1] >= '0' && str[1] <= '9' && ------------------ | Branch (34432:20): [True: 2.57k, False: 1.08k] | Branch (34432:37): [True: 2.17k, False: 400] ------------------ 34433| 2.17k| str[2] == 'r') { ------------------ | Branch (34433:20): [True: 128, False: 2.04k] ------------------ 34434| 128| base = 10 * (str[0] - '0') + (str[1] - '0'); 34435| 128| if (base < 2 || base > 36) goto error; ------------------ | Branch (34435:17): [True: 11, False: 117] | Branch (34435:29): [True: 38, False: 79] ------------------ 34436| 79| str += 3; 34437| 79| } 34438| 13.0k| } 34439| | 34440| | /* If still base is 0, set to default (10) */ 34441| 12.9k| if (base == 0) { ------------------ | Branch (34441:9): [True: 12.6k, False: 322] ------------------ 34442| 12.6k| base = 10; 34443| 12.6k| } 34444| 12.9k| int exp_base = base; 34445| | 34446| | /* Skip leading zeros */ 34447| 19.5k| while (str < end && (*str == '0' || *str == '.')) { ------------------ | Branch (34447:12): [True: 16.5k, False: 3.04k] | Branch (34447:26): [True: 4.31k, False: 12.2k] | Branch (34447:41): [True: 2.58k, False: 9.63k] ------------------ 34448| 6.89k| if (seenpoint) ex--; ------------------ | Branch (34448:13): [True: 629, False: 6.26k] ------------------ 34449| 6.89k| if (*str == '.') { ------------------ | Branch (34449:13): [True: 2.58k, False: 4.31k] ------------------ 34450| 2.58k| if (seenpoint) goto error; ------------------ | Branch (34450:17): [True: 319, False: 2.26k] ------------------ 34451| 2.26k| seenpoint = 1; 34452| 4.31k| } else { 34453| 4.31k| seenadigit = 1; 34454| 4.31k| } 34455| 6.57k| str++; 34456| 6.57k| } 34457| | 34458| | /* Parse significant digits */ 34459| 37.3k| while (str < end) { ------------------ | Branch (34459:12): [True: 27.4k, False: 9.84k] ------------------ 34460| 27.4k| if (*str == '.') { ------------------ | Branch (34460:13): [True: 368, False: 27.0k] ------------------ 34461| 368| if (seenpoint) goto error; ------------------ | Branch (34461:17): [True: 89, False: 279] ------------------ 34462| 279| seenpoint = 1; 34463| 27.0k| } else if (*str == '&') { ------------------ | Branch (34463:20): [True: 1.52k, False: 25.5k] ------------------ 34464| 1.52k| foundexp = 1; 34465| 1.52k| break; 34466| 25.5k| } else if (base == 16 && (*str == 'P' || *str == 'p')) { /* IEEE hex float */ ------------------ | Branch (34466:20): [True: 1.97k, False: 23.6k] | Branch (34466:35): [True: 16, False: 1.95k] | Branch (34466:50): [True: 31, False: 1.92k] ------------------ 34467| 47| foundexp = 1; 34468| 47| exp_base = 10; 34469| 47| base = 2; 34470| 47| ex *= 4; /* We need to correct the current exponent after we change the base */ 34471| 47| break; 34472| 25.5k| } else if (base == 10 && (*str == 'E' || *str == 'e')) { ------------------ | Branch (34472:20): [True: 22.6k, False: 2.87k] | Branch (34472:35): [True: 140, False: 22.5k] | Branch (34472:50): [True: 180, False: 22.3k] ------------------ 34473| 320| foundexp = 1; 34474| 320| break; 34475| 25.2k| } else if (*str == '_') { ------------------ | Branch (34475:20): [True: 730, False: 24.4k] ------------------ 34476| 730| if (!seenadigit) goto error; ------------------ | Branch (34476:17): [True: 137, False: 593] ------------------ 34477| 24.4k| } else { 34478| 24.4k| int digit = digit_lookup[*str & 0x7F]; 34479| 24.4k| if (*str > 127 || digit >= base) goto error; ------------------ | Branch (34479:17): [True: 101, False: 24.3k] | Branch (34479:31): [True: 609, False: 23.7k] ------------------ 34480| 23.7k| if (seenpoint) ex--; ------------------ | Branch (34480:17): [True: 6.15k, False: 17.6k] ------------------ 34481| 23.7k| bignat_muladd(&mant, base, digit); 34482| 23.7k| seenadigit = 1; 34483| 23.7k| } 34484| 24.6k| str++; 34485| 24.6k| } 34486| | 34487| 11.7k| if (!seenadigit) ------------------ | Branch (34487:9): [True: 1.29k, False: 10.4k] ------------------ 34488| 1.29k| goto error; 34489| | 34490| | /* Read exponent */ 34491| 10.4k| if (str < end && foundexp) { ------------------ | Branch (34491:9): [True: 1.84k, False: 8.60k] | Branch (34491:22): [True: 1.84k, False: 0] ------------------ 34492| 1.84k| int eneg = 0; 34493| 1.84k| int32_t ee = 0; 34494| 1.84k| seenadigit = 0; 34495| 1.84k| str++; 34496| 1.84k| if (str >= end) goto error; ------------------ | Branch (34496:13): [True: 108, False: 1.73k] ------------------ 34497| 1.73k| if (*str == '-') { ------------------ | Branch (34497:13): [True: 311, False: 1.42k] ------------------ 34498| 311| eneg = 1; 34499| 311| str++; 34500| 1.42k| } else if (*str == '+') { ------------------ | Branch (34500:20): [True: 87, False: 1.33k] ------------------ 34501| 87| str++; 34502| 87| } 34503| | /* Skip leading 0s in exponent */ 34504| 2.29k| while (str < end && *str == '0') { ------------------ | Branch (34504:16): [True: 2.13k, False: 156] | Branch (34504:29): [True: 560, False: 1.57k] ------------------ 34505| 560| str++; 34506| 560| seenadigit = 1; 34507| 560| } 34508| 5.90k| while (str < end) { ------------------ | Branch (34508:16): [True: 4.34k, False: 1.56k] ------------------ 34509| 4.34k| int digit = digit_lookup[*str & 0x7F]; 34510| 4.34k| if (*str > 127 || digit >= exp_base) goto error; ------------------ | Branch (34510:17): [True: 36, False: 4.30k] | Branch (34510:31): [True: 137, False: 4.16k] ------------------ 34511| 4.16k| if (ee < (INT32_MAX / 40)) { ------------------ | Branch (34511:17): [True: 3.60k, False: 562] ------------------ 34512| 3.60k| ee = exp_base * ee + digit; 34513| 3.60k| } 34514| 4.16k| str++; 34515| 4.16k| seenadigit = 1; 34516| 4.16k| } 34517| 1.56k| if (eneg) ex -= ee; ------------------ | Branch (34517:13): [True: 284, False: 1.27k] ------------------ 34518| 1.27k| else ex += ee; 34519| 1.56k| } 34520| | 34521| 10.1k| if (!seenadigit) ------------------ | Branch (34521:9): [True: 45, False: 10.1k] ------------------ 34522| 45| goto error; 34523| | 34524| 10.1k| *out = convert(neg, &mant, base, ex); 34525| 10.1k| janet_free(mant.digits); ------------------ | | 2415| 10.1k|#define janet_free(X) free((X)) ------------------ 34526| 10.1k| return 0; 34527| | 34528| 2.92k|error: 34529| 2.92k| janet_free(mant.digits); ------------------ | | 2415| 2.92k|#define janet_free(X) free((X)) ------------------ 34530| 2.92k| return 1; 34531| 10.1k|} janet_scan_int64: 34604| 1.38k|int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out) { 34605| 1.38k| int neg; 34606| 1.38k| uint64_t bi; 34607| 1.38k| if (scan_uint64(str, len, &bi, &neg)) { ------------------ | Branch (34607:9): [True: 1.11k, False: 269] ------------------ 34608| 1.11k| if (neg && bi <= ((UINT64_MAX / 2) + 1)) { ------------------ | Branch (34608:13): [True: 282, False: 836] | Branch (34608:20): [True: 261, False: 21] ------------------ 34609| 261| if (bi > INT64_MAX) { ------------------ | Branch (34609:17): [True: 10, False: 251] ------------------ 34610| 10| *out = INT64_MIN; 34611| 251| } else { 34612| 251| *out = -((int64_t) bi); 34613| 251| } 34614| 261| return 1; 34615| 261| } 34616| 857| if (!neg && bi <= INT64_MAX) { ------------------ | Branch (34616:13): [True: 836, False: 21] | Branch (34616:21): [True: 774, False: 62] ------------------ 34617| 774| *out = (int64_t) bi; 34618| 774| return 1; 34619| 774| } 34620| 857| } 34621| 352| return 0; 34622| 1.38k|} janet_scan_uint64: 34624| 1.09k|int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out) { 34625| 1.09k| int neg; 34626| 1.09k| uint64_t bi; 34627| 1.09k| if (scan_uint64(str, len, &bi, &neg)) { ------------------ | Branch (34627:9): [True: 706, False: 386] ------------------ 34628| 706| if (!neg) { ------------------ | Branch (34628:13): [True: 686, False: 20] ------------------ 34629| 686| *out = bi; 34630| 686| return 1; 34631| 686| } 34632| 706| } 34633| 406| return 0; 34634| 1.09k|} janet_scan_numeric: 34641| 15.6k| Janet *out) { 34642| 15.6k| int result; 34643| 15.6k| double num; 34644| 15.6k| int64_t i64 = 0; 34645| 15.6k| uint64_t u64 = 0; 34646| 15.6k| if (len < 2 || str[len - 2] != ':') { ------------------ | Branch (34646:9): [True: 5.31k, False: 10.2k] | Branch (34646:20): [True: 7.70k, False: 2.59k] ------------------ 34647| 13.0k| result = janet_scan_number_base(str, len, 0, &num); 34648| 13.0k| *out = janet_wrap_number(num); ------------------ | | 835| 13.0k|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 34649| 13.0k| return result; 34650| 13.0k| } 34651| 2.59k| switch (str[len - 1]) { 34652| 93| default: ------------------ | Branch (34652:9): [True: 93, False: 2.50k] ------------------ 34653| 93| return 1; 34654| 23| case 'n': ------------------ | Branch (34654:9): [True: 23, False: 2.57k] ------------------ 34655| 23| result = janet_scan_number_base(str, len - 2, 0, &num); 34656| 23| *out = janet_wrap_number(num); ------------------ | | 835| 23|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 34657| 23| return result; 34658| | /* Condition is inverted janet_scan_int64 and janet_scan_uint64 */ 34659| 1.38k| case 's': ------------------ | Branch (34659:9): [True: 1.38k, False: 1.20k] ------------------ 34660| 1.38k| result = !janet_scan_int64(str, len - 2, &i64); 34661| 1.38k| *out = janet_wrap_s64(i64); 34662| 1.38k| return result; 34663| 1.09k| case 'u': ------------------ | Branch (34663:9): [True: 1.09k, False: 1.50k] ------------------ 34664| 1.09k| result = !janet_scan_uint64(str, len - 2, &u64); 34665| 1.09k| *out = janet_wrap_u64(u64); 34666| 1.09k| return result; 34667| 2.59k| } 34668| 2.59k|} janet_struct_begin: 34722| 46.4k|JanetKV *janet_struct_begin(int32_t count) { 34723| | /* Calculate capacity as power of 2 after 2 * count. */ 34724| 46.4k| int32_t capacity = janet_tablen(2 * count); 34725| 46.4k| if (capacity < 0) capacity = janet_tablen(count + 1); ------------------ | Branch (34725:9): [True: 0, False: 46.4k] ------------------ 34726| | 34727| 46.4k| size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV); 34728| 46.4k| JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size); 34729| 46.4k| head->length = count; 34730| 46.4k| head->capacity = capacity; 34731| 46.4k| head->hash = 0; 34732| 46.4k| head->proto = NULL; 34733| | 34734| 46.4k| JanetKV *st = (JanetKV *)(head->data); 34735| 46.4k| janet_memempty(st, capacity); 34736| 46.4k| return st; 34737| 46.4k|} janet_struct_put_ext: 34752| 274k|void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) { 34753| 274k| int32_t cap = janet_struct_capacity(st); ------------------ | | 1849| 274k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 274k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34754| 274k| int32_t hash = janet_hash(key); 34755| 274k| int32_t index = janet_maphash(cap, hash); ------------------ | | 396| 274k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34756| 274k| int32_t i, j, dist; 34757| 274k| int32_t bounds[4] = {index, cap, 0, index}; 34758| 274k| if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 806| 548k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 28, False: 274k] | | | Branch (806:6): [Folded, False: 274k] | | ------------------ | | 807| 548k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 548k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 274k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 274k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 274k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 274k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 806| 274k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 10, False: 274k] | | | Branch (806:6): [Folded, False: 274k] | | ------------------ | | 807| 274k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 274k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 274k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 274k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 274k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 274k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34759| 274k| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 806| 548k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.07k, False: 273k] | | | Branch (806:6): [True: 274k, Folded] | | ------------------ | | 807| 548k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 274k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 1.07k, False: 273k] | | | | | Branch (803:28): [True: 0, False: 273k] | | | | ------------------ | | ------------------ | | 808| 548k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34759:47): [True: 0, False: 1.07k] ------------------ 34760| | /* Avoid extra items */ 34761| 274k| if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1850| 274k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 274k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1848| 274k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 274k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34761:9): [True: 0, False: 274k] ------------------ 34762| 274k| for (dist = 0, j = 0; j < 4; j += 2) ------------------ | Branch (34762:27): [True: 274k, False: 0] ------------------ 34763| 389k| for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) { ------------------ | Branch (34763:29): [True: 389k, False: 213] ------------------ 34764| 389k| int status; 34765| 389k| int32_t otherhash; 34766| 389k| int32_t otherindex, otherdist; 34767| 389k| JanetKV *kv = st + i; 34768| | /* We found an empty slot, so just add key and value */ 34769| 389k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 389k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 272k, False: 116k] | | | Branch (806:6): [Folded, False: 389k] | | ------------------ | | 807| 389k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 389k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 389k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 389k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 389k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 389k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34770| 272k| kv->key = key; 34771| 272k| kv->value = value; 34772| | /* Update the temporary count */ 34773| 272k| janet_struct_hash(st)++; ------------------ | | 1850| 272k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 272k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34774| 272k| return; 34775| 272k| } 34776| | /* Robinhood hashing - check if colliding kv pair 34777| | * is closer to their source than current. We use robinhood 34778| | * hashing to ensure that equivalent structs that are constructed 34779| | * with different order have the same internal layout, and therefor 34780| | * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}. 34781| | * Collisions are resolved via an insertion sort insertion. */ 34782| 116k| otherhash = janet_hash(kv->key); 34783| 116k| otherindex = janet_maphash(cap, otherhash); ------------------ | | 396| 116k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34784| 116k| otherdist = (i + cap - otherindex) & (cap - 1); 34785| 116k| if (dist < otherdist) ------------------ | Branch (34785:17): [True: 56.7k, False: 60.1k] ------------------ 34786| 56.7k| status = -1; 34787| 60.1k| else if (otherdist < dist) ------------------ | Branch (34787:22): [True: 322, False: 59.8k] ------------------ 34788| 322| status = 1; 34789| 59.8k| else if (hash < otherhash) ------------------ | Branch (34789:22): [True: 57.2k, False: 2.57k] ------------------ 34790| 57.2k| status = -1; 34791| 2.57k| else if (otherhash < hash) ------------------ | Branch (34791:22): [True: 607, False: 1.97k] ------------------ 34792| 607| status = 1; 34793| 1.97k| else 34794| 1.97k| status = janet_compare(key, kv->key); 34795| | /* If other is closer to their ideal slot */ 34796| 116k| if (status == 1) { ------------------ | Branch (34796:17): [True: 954, False: 115k] ------------------ 34797| | /* Swap current kv pair with pair in slot */ 34798| 954| JanetKV temp = *kv; 34799| 954| kv->key = key; 34800| 954| kv->value = value; 34801| 954| key = temp.key; 34802| 954| value = temp.value; 34803| | /* Save dist and hash of new kv pair */ 34804| 954| dist = otherdist; 34805| 954| hash = otherhash; 34806| 115k| } else if (status == 0) { ------------------ | Branch (34806:24): [True: 1.90k, False: 114k] ------------------ 34807| 1.90k| if (replace) { ------------------ | Branch (34807:21): [True: 1.90k, False: 0] ------------------ 34808| | /* A key was added to the struct more than once - replace old value */ 34809| 1.90k| kv->value = value; 34810| 1.90k| } 34811| 1.90k| return; 34812| 1.90k| } 34813| 116k| } 34814| 274k|} janet_struct_put: 34816| 274k|void janet_struct_put(JanetKV *st, Janet key, Janet value) { 34817| 274k| janet_struct_put_ext(st, key, value, 1); 34818| 274k|} janet_struct_end: 34821| 45.9k|const JanetKV *janet_struct_end(JanetKV *st) { 34822| 45.9k| if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1850| 45.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 45.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1848| 45.9k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 45.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34822:9): [True: 488, False: 45.4k] ------------------ 34823| | /* Error building struct, probably duplicate values. We need to rebuild 34824| | * the struct using only the values that went in. The second creation should always 34825| | * succeed. */ 34826| 488| JanetKV *newst = janet_struct_begin(janet_struct_hash(st)); ------------------ | | 1850| 488|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 488|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34827| 13.3k| for (int32_t i = 0; i < janet_struct_capacity(st); i++) { ------------------ | | 1849| 13.3k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 13.3k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34827:29): [True: 12.8k, False: 488] ------------------ 34828| 12.8k| JanetKV *kv = st + i; 34829| 12.8k| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 12.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 12.8k] | | ------------------ | | 807| 12.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 12.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 12.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 12.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 12.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 12.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34829:17): [True: 2.20k, False: 10.6k] ------------------ 34830| 2.20k| janet_struct_put(newst, kv->key, kv->value); 34831| 2.20k| } 34832| 12.8k| } 34833| 488| janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1851| 488|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 488|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1851| 488|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 488|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34834| 488| st = newst; 34835| 488| } 34836| 45.9k| janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1850| 45.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 45.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1849| 45.9k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 45.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34837| 45.9k| if (janet_struct_proto(st)) { ------------------ | | 1851| 45.9k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 45.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 0, False: 45.9k] | | ------------------ ------------------ 34838| 0| janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1850| 0|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1850| 0|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34839| 0| } 34840| 45.9k| return (const JanetKV *)st; 34841| 45.9k|} janet_lib_struct: 34988| 5.65k|void janet_lib_struct(JanetTable *env) { 34989| 5.65k| JanetRegExt struct_cfuns[] = { 34990| 5.65k| JANET_CORE_REG("struct/with-proto", cfun_struct_with_proto), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34991| 5.65k| JANET_CORE_REG("struct/getproto", cfun_struct_getproto), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34992| 5.65k| JANET_CORE_REG("struct/proto-flatten", cfun_struct_flatten), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34993| 5.65k| JANET_CORE_REG("struct/to-table", cfun_struct_to_table), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34994| 5.65k| JANET_CORE_REG("struct/rawget", cfun_struct_rawget), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34995| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 34996| 5.65k| }; 34997| | janet_core_cfuns_ext(env, NULL, struct_cfuns); 34998| 5.65k|} janet_symcache_init: 35043| 5.65k|void janet_symcache_init() { 35044| 5.65k| janet_vm.cache_capacity = 1024; 35045| 5.65k| janet_vm.cache = janet_calloc(1, (size_t) janet_vm.cache_capacity * sizeof(const uint8_t *)); ------------------ | | 2412| 5.65k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 35046| 5.65k| if (NULL == janet_vm.cache) { ------------------ | Branch (35046:9): [True: 0, False: 5.65k] ------------------ 35047| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35048| 0| } 35049| 5.65k| memset(&janet_vm.gensym_counter, '0', sizeof(janet_vm.gensym_counter)); 35050| 5.65k| janet_vm.gensym_counter[0] = '_'; 35051| 5.65k| janet_vm.cache_count = 0; 35052| 5.65k| janet_vm.cache_deleted = 0; 35053| 5.65k|} janet_symcache_deinit: 35056| 5.65k|void janet_symcache_deinit() { 35057| 5.65k| janet_free((void *)janet_vm.cache); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 35058| | janet_vm.cache = NULL; 35059| 5.65k| janet_vm.cache_capacity = 0; 35060| 5.65k| janet_vm.cache_count = 0; 35061| 5.65k| janet_vm.cache_deleted = 0; 35062| 5.65k|} janet_symbol_deinit: 35164| 11.3M|void janet_symbol_deinit(const uint8_t *sym) { 35165| 11.3M| int status = 0; 35166| 11.3M| const uint8_t **bucket = janet_symcache_find(sym, &status); ------------------ | |35119| 11.3M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 11.3M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 11.3M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1814| 11.3M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 11.3M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35167| 11.3M| if (status) { ------------------ | Branch (35167:9): [True: 11.3M, False: 0] ------------------ 35168| 11.3M| janet_vm.cache_count--; 35169| 11.3M| janet_vm.cache_deleted++; 35170| 11.3M| *bucket = JANET_SYMCACHE_DELETED; 35171| 11.3M| } 35172| 11.3M|} janet_symbol: 35175| 16.0M|const uint8_t *janet_symbol(const uint8_t *str, int32_t len) { 35176| 16.0M| int32_t hash = janet_string_calchash(str, len); 35177| 16.0M| uint8_t *newstr; 35178| 16.0M| int success = 0; 35179| 16.0M| const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success); 35180| 16.0M| if (success) ------------------ | Branch (35180:9): [True: 4.73M, False: 11.3M] ------------------ 35181| 4.73M| return *bucket; 35182| 11.3M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1); 35183| 11.3M| head->hash = hash; 35184| 11.3M| head->length = len; 35185| 11.3M| newstr = (uint8_t *)(head->data); 35186| 11.3M| safe_memcpy(newstr, str, len); 35187| 11.3M| newstr[len] = 0; 35188| 11.3M| janet_symcache_put((const uint8_t *)newstr, bucket); 35189| 11.3M| return newstr; 35190| 16.0M|} janet_csymbol: 35193| 2.11M|const uint8_t *janet_csymbol(const char *cstr) { 35194| 2.11M| return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr)); 35195| 2.11M|} janet_table_init: 35319| 9.02M|JanetTable *janet_table_init(JanetTable *table, int32_t capacity) { 35320| 9.02M| return janet_table_init_impl(table, capacity, 1); 35321| 9.02M|} janet_table_init_raw: 35324| 16.9k|JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity) { 35325| 16.9k| return janet_table_init_impl(table, capacity, 0); 35326| 16.9k|} janet_table_deinit: 35329| 9.03M|void janet_table_deinit(JanetTable *table) { 35330| 9.03M| if (table->gc.flags & JANET_TABLE_FLAG_STACK) { ------------------ | |35279| 9.03M|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (35330:9): [True: 9.02M, False: 16.9k] ------------------ 35331| 9.02M| janet_sfree(table->data); 35332| 9.02M| } else { 35333| 16.9k| janet_free(table->data); ------------------ | | 2415| 16.9k|#define janet_free(X) free((X)) ------------------ 35334| 16.9k| } 35335| 9.03M|} janet_table: 35339| 4.15M|JanetTable *janet_table(int32_t capacity) { 35340| 4.15M| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); 35341| 4.15M| return janet_table_init_impl(table, capacity, 0); 35342| 4.15M|} janet_table_find: 35361| 77.7M|JanetKV *janet_table_find(JanetTable *t, Janet key) { 35362| 77.7M| return (JanetKV *) janet_dict_find(t->data, t->capacity, key); 35363| 77.7M|} janet_table_get: 35397| 11.1M|Janet janet_table_get(JanetTable *t, Janet key) { 35398| 20.2M| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 11.1M|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (35398:41): [True: 11.1M, False: 9.10M] | Branch (35398:46): [True: 11.1M, False: 0] ------------------ 35399| 11.1M| JanetKV *bucket = janet_table_find(t, key); 35400| 11.1M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 11.1M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 11.1M] | | ------------------ | | 807| 11.1M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 11.1M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 11.1M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 11.1M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 11.1M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 11.1M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35400:13): [True: 11.1M, False: 0] | Branch (35400:31): [True: 2.02M, False: 9.10M] ------------------ 35401| 2.02M| return bucket->value; 35402| 11.1M| } 35403| 9.10M| return janet_wrap_nil(); ------------------ | | 831| 9.10M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 9.10M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 9.10M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9.10M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35404| 11.1M|} janet_table_get_keyword: 35407| 67.8k|Janet janet_table_get_keyword(JanetTable *t, const char *keyword) { 35408| 67.8k| int32_t keyword_len = (int32_t) strlen(keyword); 35409| 118k| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 67.8k|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (35409:41): [True: 67.8k, False: 50.8k] | Branch (35409:46): [True: 67.8k, False: 0] ------------------ 35410| 67.8k| JanetKV *bucket = (JanetKV *) janet_dict_find_keyword(t->data, t->capacity, (const uint8_t *) keyword, keyword_len); 35411| 67.8k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 67.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 67.8k] | | ------------------ | | 807| 67.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 67.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 67.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 67.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 67.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 67.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35411:13): [True: 67.8k, False: 0] | Branch (35411:31): [True: 16.9k, False: 50.8k] ------------------ 35412| 16.9k| return bucket->value; 35413| 67.8k| } 35414| 50.8k| return janet_wrap_nil(); ------------------ | | 831| 50.8k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 50.8k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 50.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35415| 67.8k|} janet_table_get_ex: 35418| 40|Janet janet_table_get_ex(JanetTable *t, Janet key, JanetTable **which) { 35419| 80| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 40|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (35419:41): [True: 40, False: 40] | Branch (35419:46): [True: 40, False: 0] ------------------ 35420| 40| JanetKV *bucket = janet_table_find(t, key); 35421| 40| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 40| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 40] | | ------------------ | | 807| 40| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 40| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 40| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 40|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 40|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 40|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35421:13): [True: 40, False: 0] | Branch (35421:31): [True: 0, False: 40] ------------------ 35422| 0| *which = t; 35423| 0| return bucket->value; 35424| 0| } 35425| 40| } 35426| 40| return janet_wrap_nil(); ------------------ | | 831| 40|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 40| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 40|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 40|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35427| 40|} janet_table_rawget: 35430| 8.89k|Janet janet_table_rawget(JanetTable *t, Janet key) { 35431| 8.89k| JanetKV *bucket = janet_table_find(t, key); 35432| 8.89k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 8.89k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 8.89k] | | ------------------ | | 807| 8.89k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 8.89k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 8.89k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 8.89k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 8.89k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.89k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35432:9): [True: 8.89k, False: 0] | Branch (35432:27): [True: 223, False: 8.67k] ------------------ 35433| 223| return bucket->value; 35434| 8.67k| else 35435| 8.67k| return janet_wrap_nil(); ------------------ | | 831| 8.67k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 8.67k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 8.67k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.67k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35436| 8.89k|} janet_table_remove: 35440| 9.07M|Janet janet_table_remove(JanetTable *t, Janet key) { 35441| 9.07M| JanetKV *bucket = janet_table_find(t, key); 35442| 9.07M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 9.07M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 9.07M] | | ------------------ | | 807| 9.07M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 9.07M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 9.07M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 9.07M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 9.07M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9.07M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35442:9): [True: 9.07M, False: 0] | Branch (35442:27): [True: 9.04M, False: 26.6k] ------------------ 35443| 9.04M| Janet ret = bucket->value; 35444| 9.04M| t->count--; 35445| 9.04M| t->deleted++; 35446| 9.04M| bucket->key = janet_wrap_nil(); ------------------ | | 831| 9.04M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 9.04M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 9.04M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9.04M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35447| 9.04M| bucket->value = janet_wrap_false(); ------------------ | | 833| 9.04M|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 9.04M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 9.04M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9.04M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35448| 9.04M| return ret; 35449| 9.04M| } else { 35450| 26.6k| return janet_wrap_nil(); ------------------ | | 831| 26.6k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 26.6k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 26.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 26.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35451| 26.6k| } 35452| 9.07M|} janet_table_put: 35455| 35.6M|void janet_table_put(JanetTable *t, Janet key, Janet value) { 35456| 35.6M| if (janet_checktype(key, JANET_NIL)) return; ------------------ | | 806| 35.6M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 19, False: 35.6M] | | | Branch (806:6): [Folded, False: 35.6M] | | ------------------ | | 807| 35.6M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 35.6M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 35.6M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 35.6M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 35.6M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 35.6M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35457| 35.6M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 806| 71.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.58k, False: 35.6M] | | | Branch (806:6): [True: 35.6M, Folded] | | ------------------ | | 807| 71.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 35.6M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 1.58k, False: 35.6M] | | | | | Branch (803:28): [True: 0, False: 35.6M] | | | | ------------------ | | ------------------ | | 808| 71.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35457:47): [True: 0, False: 1.58k] ------------------ 35458| 35.6M| if (janet_checktype(value, JANET_NIL)) { ------------------ | | 806| 35.6M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 14, False: 35.6M] | | | Branch (806:6): [Folded, False: 35.6M] | | ------------------ | | 807| 35.6M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 35.6M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 35.6M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 35.6M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 35.6M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 35.6M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35459| 14| janet_table_remove(t, key); 35460| 35.6M| } else { 35461| 35.6M| JanetKV *bucket = janet_table_find(t, key); 35462| 35.6M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 35.6M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 35.6M] | | ------------------ | | 807| 35.6M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 35.6M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 35.6M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 35.6M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 35.6M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 35.6M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35462:13): [True: 35.6M, False: 0] | Branch (35462:31): [True: 435, False: 35.6M] ------------------ 35463| 435| bucket->value = value; 35464| 35.6M| } else { 35465| 35.6M| if (NULL == bucket || 2 * (t->count + t->deleted + 1) > t->capacity) { ------------------ | Branch (35465:17): [True: 0, False: 35.6M] | Branch (35465:35): [True: 3.35M, False: 32.3M] ------------------ 35466| 3.35M| janet_table_rehash(t, janet_tablen(2 * t->count + 2)); 35467| 3.35M| bucket = janet_table_find(t, key); 35468| 3.35M| } 35469| 35.6M| if (janet_checktype(bucket->value, JANET_BOOLEAN)) ------------------ | | 806| 35.6M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 35.6M] | | | Branch (806:6): [Folded, False: 35.6M] | | ------------------ | | 807| 35.6M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 35.6M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 35.6M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 35.6M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 35.6M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 35.6M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35470| 0| --t->deleted; 35471| 35.6M| bucket->key = key; 35472| 35.6M| bucket->value = value; 35473| 35.6M| ++t->count; 35474| 35.6M| } 35475| 35.6M| } 35476| 35.6M|} janet_table_clone: 35505| 102|JanetTable *janet_table_clone(JanetTable *table) { 35506| 102| JanetTable *newTable = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); 35507| 102| newTable->count = table->count; 35508| 102| newTable->capacity = table->capacity; 35509| 102| newTable->deleted = table->deleted; 35510| 102| newTable->proto = table->proto; 35511| 102| newTable->data = array_allocate(sizeof(JanetKV), newTable->capacity); 35512| 102| if (NULL == newTable->data) { ------------------ | Branch (35512:9): [True: 0, False: 102] ------------------ 35513| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35514| 0| } 35515| 102| memcpy(newTable->data, table->data, (size_t) table->capacity * sizeof(JanetKV)); 35516| 102| return newTable; 35517| 102|} janet_lib_table: 35685| 5.65k|void janet_lib_table(JanetTable *env) { 35686| 5.65k| JanetRegExt table_cfuns[] = { 35687| 5.65k| JANET_CORE_REG("table/new", cfun_table_new), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35688| 5.65k| JANET_CORE_REG("table/weak", cfun_table_weak), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35689| 5.65k| JANET_CORE_REG("table/weak-keys", cfun_table_weak_keys), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35690| 5.65k| JANET_CORE_REG("table/weak-values", cfun_table_weak_values), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35691| 5.65k| JANET_CORE_REG("table/to-struct", cfun_table_tostruct), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35692| 5.65k| JANET_CORE_REG("table/getproto", cfun_table_getproto), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35693| 5.65k| JANET_CORE_REG("table/setproto", cfun_table_setproto), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35694| 5.65k| JANET_CORE_REG("table/rawget", cfun_table_rawget), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35695| 5.65k| JANET_CORE_REG("table/clone", cfun_table_clone), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35696| 5.65k| JANET_CORE_REG("table/clear", cfun_table_clear), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35697| 5.65k| JANET_CORE_REG("table/proto-flatten", cfun_table_proto_flatten), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35698| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 35699| 5.65k| }; 35700| | janet_core_cfuns_ext(env, NULL, table_cfuns); 35701| 5.65k|} janet_tuple_begin: 35740| 4.30M|Janet *janet_tuple_begin(int32_t length) { 35741| 4.30M| size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet)); 35742| 4.30M| JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size); 35743| 4.30M| head->sm_line = -1; 35744| 4.30M| head->sm_column = -1; 35745| 4.30M| head->length = length; 35746| 4.30M| return (Janet *)(head->data); 35747| 4.30M|} janet_tuple_end: 35750| 4.30M|const Janet *janet_tuple_end(Janet *tuple) { 35751| 4.30M| janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1803| 4.30M|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 4.30M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1802| 4.30M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 4.30M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 35752| 4.30M| return (const Janet *)tuple; 35753| 4.30M|} janet_tuple_n: 35756| 14.5k|const Janet *janet_tuple_n(const Janet *values, int32_t n) { 35757| 14.5k| Janet *t = janet_tuple_begin(n); 35758| 14.5k| safe_memcpy(t, values, sizeof(Janet) * n); 35759| 14.5k| return janet_tuple_end(t); 35760| 14.5k|} janet_lib_tuple: 35860| 5.65k|void janet_lib_tuple(JanetTable *env) { 35861| 5.65k| JanetRegExt tuple_cfuns[] = { 35862| 5.65k| JANET_CORE_REG("tuple/brackets", cfun_tuple_brackets), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35863| 5.65k| JANET_CORE_REG("tuple/slice", cfun_tuple_slice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35864| 5.65k| JANET_CORE_REG("tuple/type", cfun_tuple_type), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35865| 5.65k| JANET_CORE_REG("tuple/sourcemap", cfun_tuple_sourcemap), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35866| 5.65k| JANET_CORE_REG("tuple/setmap", cfun_tuple_setmap), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35867| 5.65k| JANET_CORE_REG("tuple/join", cfun_tuple_join), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35868| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 35869| 5.65k| }; 35870| | janet_core_cfuns_ext(env, NULL, tuple_cfuns); 35871| 5.65k|} janet_hash_mix: 35997| 38.5M|uint32_t janet_hash_mix(uint32_t input, uint32_t more) { 35998| 38.5M| uint32_t mix1 = (more + 0x9e3779b9 + (input << 6) + (input >> 2)); 35999| 38.5M| return input ^ (0x9e3779b9 + (mix1 << 6) + (mix1 >> 2)); 36000| 38.5M|} janet_string_calchash: 36004| 41.2M|int32_t janet_string_calchash(const uint8_t *str, int32_t len) { 36005| 41.2M| if (NULL == str || len == 0) return 5381; ------------------ | Branch (36005:9): [True: 383, False: 41.2M] | Branch (36005:24): [True: 16.7M, False: 24.4M] ------------------ 36006| 24.4M| const uint8_t *end = str + len; 36007| 24.4M| uint32_t hash = 5381; 36008| 1.01G| while (str < end) ------------------ | Branch (36008:12): [True: 986M, False: 24.4M] ------------------ 36009| 986M| hash = (hash << 5) + hash + *str++; 36010| 24.4M| hash = janet_hash_mix(hash, (uint32_t) len); 36011| 24.4M| return (int32_t) hash; 36012| 41.2M|} janet_array_calchash: 36127| 4.30M|int32_t janet_array_calchash(const Janet *array, int32_t len) { 36128| 4.30M| const Janet *end = array + len; 36129| 4.30M| uint32_t hash = 33; 36130| 16.9M| while (array < end) { ------------------ | Branch (36130:12): [True: 12.6M, False: 4.30M] ------------------ 36131| 12.6M| hash = janet_hash_mix(hash, janet_hash(*array++)); 36132| 12.6M| } 36133| 4.30M| return (int32_t) hash; 36134| 4.30M|} janet_kv_calchash: 36137| 45.9k|int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) { 36138| 45.9k| const JanetKV *end = kvs + len; 36139| 45.9k| uint32_t hash = 33; 36140| 749k| while (kvs < end) { ------------------ | Branch (36140:12): [True: 703k, False: 45.9k] ------------------ 36141| 703k| hash = janet_hash_mix(hash, janet_hash(kvs->key)); 36142| 703k| hash = janet_hash_mix(hash, janet_hash(kvs->value)); 36143| 703k| kvs++; 36144| 703k| } 36145| 45.9k| return (int32_t) hash; 36146| 45.9k|} janet_tablen: 36150| 16.6M|int32_t janet_tablen(int32_t n) { 36151| 16.6M| if (n < 0) return 0; ------------------ | Branch (36151:9): [True: 0, False: 16.6M] ------------------ 36152| 16.6M| n |= n >> 1; 36153| 16.6M| n |= n >> 2; 36154| 16.6M| n |= n >> 4; 36155| 16.6M| n |= n >> 8; 36156| 16.6M| n |= n >> 16; 36157| 16.6M| return n == INT32_MAX ? INT32_MAX : n + 1; ------------------ | Branch (36157:12): [True: 0, False: 16.6M] ------------------ 36158| 16.6M|} safe_memcpy: 36161| 36.4M|void safe_memcpy(void *dest, const void *src, size_t len) { 36162| 36.4M| if (!len) return; ------------------ | Branch (36162:9): [True: 16.7M, False: 19.6M] ------------------ 36163| 19.6M| memcpy(dest, src, len); 36164| 19.6M|} janet_dict_find_deep: 36168| 27.2M|const JanetKV *janet_dict_find_deep(const JanetKV *buckets, int32_t cap, Janet key) { 36169| 27.2M| int32_t index = janet_maphash(cap, janet_hash(key)); ------------------ | | 396| 27.2M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 36170| 27.2M| int32_t i; 36171| 27.2M| const JanetKV *first_bucket = NULL; 36172| | /* Higher half */ 36173| 27.3M| for (i = index; i < cap; i++) { ------------------ | Branch (36173:21): [True: 27.3M, False: 3.80k] ------------------ 36174| 27.3M| const JanetKV *kv = buckets + i; 36175| 27.3M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 27.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 18.2M, False: 9.11M] | | | Branch (806:6): [Folded, False: 27.3M] | | ------------------ | | 807| 27.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 27.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 27.3M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 27.3M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 27.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 27.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36176| 18.2M| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 18.2M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 18.1M, False: 25.9k] | | | Branch (806:6): [Folded, False: 18.2M] | | ------------------ | | 807| 18.2M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 18.2M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 18.2M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 18.2M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 18.2M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 18.2M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36177| 18.1M| return kv; 36178| 18.1M| } else if (NULL == first_bucket) { ------------------ | Branch (36178:24): [True: 12.1k, False: 13.7k] ------------------ 36179| 12.1k| first_bucket = kv; 36180| 12.1k| } 36181| 18.2M| } else if (janet_bitwise_same(kv->key, key) || janet_equals(kv->key, key)) { ------------------ | | 401| 18.2M|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 9.11M|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 9.11M|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 9.04M, False: 67.1k] | | ------------------ ------------------ | Branch (36181:56): [True: 1.44k, False: 65.7k] ------------------ 36182| 9.04M| return buckets + i; 36183| 9.04M| } 36184| 27.3M| } 36185| | /* Lower half */ 36186| 7.19k| for (i = 0; i < index; i++) { ------------------ | Branch (36186:17): [True: 7.19k, False: 0] ------------------ 36187| 7.19k| const JanetKV *kv = buckets + i; 36188| 7.19k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 7.19k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 4.68k, False: 2.50k] | | | Branch (806:6): [Folded, False: 7.19k] | | ------------------ | | 807| 7.19k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 7.19k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.19k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.19k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.19k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.19k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36189| 4.68k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 4.68k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 3.28k, False: 1.40k] | | | Branch (806:6): [Folded, False: 4.68k] | | ------------------ | | 807| 4.68k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 4.68k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 4.68k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 4.68k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 4.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36190| 3.28k| return kv; 36191| 3.28k| } else if (NULL == first_bucket) { ------------------ | Branch (36191:24): [True: 123, False: 1.27k] ------------------ 36192| 123| first_bucket = kv; 36193| 123| } 36194| 4.68k| } else if (janet_bitwise_same(kv->key, key) || janet_equals(kv->key, key)) { ------------------ | | 401| 5.01k|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 2.50k|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 2.50k|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 382, False: 2.12k] | | ------------------ ------------------ | Branch (36194:56): [True: 131, False: 1.99k] ------------------ 36195| 513| return buckets + i; 36196| 513| } 36197| 7.19k| } 36198| 0| return first_bucket; 36199| 3.80k|} janet_dict_find_keyword: 36205| 67.8k| const uint8_t *cstr, int32_t cstr_len) { 36206| 67.8k| int32_t hash = janet_string_calchash(cstr, cstr_len); 36207| 67.8k| int32_t index = janet_maphash(cap, hash); ------------------ | | 396| 67.8k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 36208| 67.8k| int32_t i; 36209| 67.8k| const JanetKV *first_bucket = NULL; 36210| | /* Higher half */ 36211| 101k| for (i = index; i < cap; i++) { ------------------ | Branch (36211:21): [True: 101k, False: 0] ------------------ 36212| 101k| const JanetKV *kv = buckets + i; 36213| 101k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 101k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 50.8k, False: 50.8k] | | | Branch (806:6): [Folded, False: 101k] | | ------------------ | | 807| 101k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 101k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 101k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 101k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 101k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 101k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36214| 50.8k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 50.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 50.8k, False: 0] | | | Branch (806:6): [Folded, False: 50.8k] | | ------------------ | | 807| 50.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 50.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 50.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 50.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 50.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36215| 50.8k| return kv; 36216| 50.8k| } else if (NULL == first_bucket) { ------------------ | Branch (36216:24): [True: 0, False: 0] ------------------ 36217| 0| first_bucket = kv; 36218| 0| } 36219| 50.8k| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 806| 50.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 50.8k, False: 0] | | | Branch (806:6): [Folded, False: 50.8k] | | ------------------ | | 807| 50.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 50.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 50.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 50.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 50.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36220| | /* Works for symbol and keyword, too */ 36221| 50.8k| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 863| 50.8k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 36222| 50.8k| int32_t len = janet_string_length(str); ------------------ | | 1813| 50.8k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 50.8k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36223| 50.8k| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1814| 101k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 50.8k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (36223:17): [True: 16.9k, False: 33.9k] | Branch (36223:51): [True: 16.9k, False: 0] | Branch (36223:70): [True: 16.9k, False: 0] ------------------ 36224| 16.9k| return buckets + i; 36225| 16.9k| } 36226| 50.8k| } 36227| 101k| } 36228| | /* Lower half */ 36229| 0| for (i = 0; i < index; i++) { ------------------ | Branch (36229:17): [True: 0, False: 0] ------------------ 36230| 0| const JanetKV *kv = buckets + i; 36231| 0| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36232| 0| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36233| 0| return kv; 36234| 0| } else if (NULL == first_bucket) { ------------------ | Branch (36234:24): [True: 0, False: 0] ------------------ 36235| 0| first_bucket = kv; 36236| 0| } 36237| 0| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36238| | /* Works for symbol and keyword, too */ 36239| 0| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 863| 0|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 36240| 0| int32_t len = janet_string_length(str); ------------------ | | 1813| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36241| 0| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1814| 0|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (36241:17): [True: 0, False: 0] | Branch (36241:51): [True: 0, False: 0] | Branch (36241:70): [True: 0, False: 0] ------------------ 36242| 0| return buckets + i; 36243| 0| } 36244| 0| } 36245| 0| } 36246| 0| return first_bucket; 36247| 0|} janet_cstrcmp: 36272| 38.4k|int janet_cstrcmp(const uint8_t *str, const char *other) { 36273| 38.4k| int32_t len = janet_string_length(str); ------------------ | | 1813| 38.4k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 38.4k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36274| 38.4k| int32_t index; 36275| 69.6k| for (index = 0; index < len; index++) { ------------------ | Branch (36275:21): [True: 62.6k, False: 7.01k] ------------------ 36276| 62.6k| uint8_t c = str[index]; 36277| 62.6k| uint8_t k = ((const uint8_t *)other)[index]; 36278| 62.6k| if (c < k) return -1; ------------------ | Branch (36278:13): [True: 11.8k, False: 50.8k] ------------------ 36279| 50.8k| if (c > k) return 1; ------------------ | Branch (36279:13): [True: 19.6k, False: 31.2k] ------------------ 36280| 31.2k| if (k == '\0') break; ------------------ | Branch (36280:13): [True: 0, False: 31.2k] ------------------ 36281| 31.2k| } 36282| 7.01k| return (other[index] == '\0') ? 0 : -1; ------------------ | Branch (36282:12): [True: 6.99k, False: 14] ------------------ 36283| 38.4k|} janet_strbinsearch: 36292| 7.52k| const uint8_t *key) { 36293| 7.52k| size_t low = 0; 36294| 7.52k| size_t hi = tabcount; 36295| 7.52k| const char *t = (const char *)tab; 36296| 38.9k| while (low < hi) { ------------------ | Branch (36296:12): [True: 38.4k, False: 522] ------------------ 36297| 38.4k| size_t mid = low + ((hi - low) / 2); 36298| 38.4k| const char **item = (const char **)(t + mid * itemsize); 36299| 38.4k| const char *name = *item; 36300| 38.4k| int comp = janet_cstrcmp(key, name); 36301| 38.4k| if (comp < 0) { ------------------ | Branch (36301:13): [True: 11.8k, False: 26.6k] ------------------ 36302| 11.8k| hi = mid; 36303| 26.6k| } else if (comp > 0) { ------------------ | Branch (36303:20): [True: 19.6k, False: 6.99k] ------------------ 36304| 19.6k| low = mid + 1; 36305| 19.6k| } else { 36306| 6.99k| return (const void *)item; 36307| 6.99k| } 36308| 38.4k| } 36309| 522| return NULL; 36310| 7.52k|} janet_registry_put: 36372| 1.98M| int32_t source_line) { 36373| 1.98M| if (janet_vm.registry_count == janet_vm.registry_cap) { ------------------ | Branch (36373:9): [True: 5.65k, False: 1.98M] ------------------ 36374| 5.65k| size_t newcap = (janet_vm.registry_count + 1) * 2; 36375| | /* Size it nicely with core by default */ 36376| 5.65k| if (newcap < 512) { ------------------ | Branch (36376:13): [True: 5.65k, False: 0] ------------------ 36377| 5.65k| newcap = 512; 36378| 5.65k| } 36379| 5.65k| void *newmem = janet_realloc(janet_vm.registry, newcap * sizeof(JanetCFunRegistry)); ------------------ | | 2409| 5.65k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 36380| 5.65k| if (NULL == newmem) { ------------------ | Branch (36380:13): [True: 0, False: 5.65k] ------------------ 36381| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 36382| 0| } 36383| 5.65k| janet_vm.registry = newmem; 36384| 5.65k| janet_vm.registry_cap = newcap; 36385| 5.65k| } 36386| 1.98M| JanetCFunRegistry value = { 36387| 1.98M| key, 36388| 1.98M| name, 36389| 1.98M| name_prefix, 36390| 1.98M| source_file, 36391| 1.98M| source_line 36392| 1.98M| }; 36393| 1.98M| janet_vm.registry[janet_vm.registry_count++] = value; 36394| 1.98M| janet_vm.registry_dirty = 1; 36395| 1.98M|} janet_register_abstract_type: 36521| 50.8k|void janet_register_abstract_type(const JanetAbstractType *at) { 36522| 50.8k| janet_check_pointer_align((void *) at); 36523| 50.8k| Janet sym = janet_csymbolv(at->name); ------------------ | | 1837| 50.8k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 50.8k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 50.8k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 50.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 50.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36524| 50.8k| Janet check = janet_table_get(janet_vm.abstract_registry, sym); 36525| 50.8k| if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 806| 101k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 50.8k] | | ------------------ | | 807| 101k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 101k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 50.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 50.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 50.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (36525:9): [True: 0, False: 50.8k] | Branch (36525:47): [True: 0, False: 0] ------------------ 36526| 0| janet_panicf("cannot register abstract type %s, " 36527| 0| "a type with the same name exists", at->name); 36528| 0| } 36529| 50.8k| janet_table_put(janet_vm.abstract_registry, sym, janet_wrap_pointer((void *) at)); ------------------ | | 854| 50.8k|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 825| 50.8k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 50.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36530| 50.8k|} janet_core_def_sm: 36541| 16.9k|void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl) { 36542| 16.9k| (void) sf; 36543| 16.9k| (void) sl; 36544| 16.9k| (void) p; 36545| 16.9k| Janet key = janet_csymbolv(name); ------------------ | | 1837| 16.9k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 16.9k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 16.9k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36546| 16.9k| janet_table_put(env, key, x); 36547| 16.9k| if (janet_checktype(x, JANET_CFUNCTION)) { ------------------ | | 806| 16.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 16.9k] | | | Branch (806:6): [Folded, False: 16.9k] | | ------------------ | | 807| 16.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 16.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 16.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 16.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36548| 0| janet_registry_put(janet_unwrap_cfunction(x), name, NULL, NULL, 0); ------------------ | | 869| 0|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 36549| 0| } 36550| 16.9k|} janet_core_cfuns_ext: 36552| 124k|void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) { 36553| 124k| (void) regprefix; 36554| 2.11M| while (cfuns->name) { ------------------ | Branch (36554:12): [True: 1.98M, False: 124k] ------------------ 36555| 1.98M| janet_check_pointer_align(cfuns->cfun); 36556| 1.98M| Janet fun = janet_wrap_cfunction(cfuns->cfun); ------------------ | | 853| 1.98M|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 825| 1.98M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.98M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.98M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36557| 1.98M| janet_table_put(env, janet_csymbolv(cfuns->name), fun); ------------------ | | 1837| 1.98M|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 1.98M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 1.98M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.98M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.98M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36558| 1.98M| janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line); 36559| 1.98M| cfuns++; 36560| 1.98M| } 36561| 124k|} janet_binding_from_entry: 36564| 16.9k|JanetBinding janet_binding_from_entry(Janet entry) { 36565| 16.9k| JanetTable *entry_table; 36566| 16.9k| JanetBinding binding = { 36567| 16.9k| JANET_BINDING_NONE, 36568| 16.9k| janet_wrap_nil(), ------------------ | | 831| 16.9k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 16.9k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36569| 16.9k| JANET_BINDING_DEP_NONE 36570| 16.9k| }; 36571| | 36572| | /* Check environment for entry */ 36573| 16.9k| if (!janet_checktype(entry, JANET_TABLE)) ------------------ | | 806| 16.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 16.9k] | | ------------------ | | 807| 16.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 16.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 16.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 16.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36573:9): [True: 0, False: 16.9k] ------------------ 36574| 0| return binding; 36575| 16.9k| entry_table = janet_unwrap_table(entry); ------------------ | | 861| 16.9k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36576| | 36577| 16.9k| Janet deprecate = janet_table_get_keyword(entry_table, "deprecated"); 36578| 16.9k| int macro = janet_truthy(janet_table_get_keyword(entry_table, "macro")); ------------------ | | 818| 16.9k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 33.9k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 16.9k] | | | | ------------------ | | | | 807| 33.9k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 33.9k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 16.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 16.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 16.9k] | | ------------------ | | 819| 16.9k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ 36579| 16.9k| Janet value = janet_table_get_keyword(entry_table, "value"); 36580| 16.9k| Janet ref = janet_table_get_keyword(entry_table, "ref"); 36581| | 36582| 16.9k| if (janet_checktype(deprecate, JANET_KEYWORD)) { ------------------ | | 806| 16.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 16.9k] | | | Branch (806:6): [Folded, False: 16.9k] | | ------------------ | | 807| 16.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 16.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 16.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 16.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36583| 0| JanetKeyword depkw = janet_unwrap_keyword(deprecate); ------------------ | | 865| 0|#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) ------------------ 36584| 0| if (!janet_cstrcmp(depkw, "relaxed")) { ------------------ | Branch (36584:13): [True: 0, False: 0] ------------------ 36585| 0| binding.deprecation = JANET_BINDING_DEP_RELAXED; 36586| 0| } else if (!janet_cstrcmp(depkw, "normal")) { ------------------ | Branch (36586:20): [True: 0, False: 0] ------------------ 36587| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 36588| 0| } else if (!janet_cstrcmp(depkw, "strict")) { ------------------ | Branch (36588:20): [True: 0, False: 0] ------------------ 36589| 0| binding.deprecation = JANET_BINDING_DEP_STRICT; 36590| 0| } 36591| 16.9k| } else if (!janet_checktype(deprecate, JANET_NIL)) { ------------------ | | 806| 16.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 16.9k] | | ------------------ | | 807| 16.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 16.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 16.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 16.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36591:16): [True: 0, False: 16.9k] ------------------ 36592| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 36593| 0| } 36594| | 36595| 16.9k| int ref_is_valid = janet_checktype(ref, JANET_ARRAY); ------------------ | | 806| 16.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 16.9k] | | ------------------ | | 807| 16.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 16.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 16.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 16.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36596| 16.9k| int redef = ref_is_valid && janet_truthy(janet_table_get_keyword(entry_table, "redef")); ------------------ | | 818| 16.9k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 0] | | ------------------ | | 819| 16.9k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (36596:17): [True: 0, False: 16.9k] ------------------ 36597| | 36598| 16.9k| if (macro) { ------------------ | Branch (36598:9): [True: 0, False: 16.9k] ------------------ 36599| 0| binding.value = redef ? ref : value; ------------------ | Branch (36599:25): [True: 0, False: 0] ------------------ 36600| 0| binding.type = redef ? JANET_BINDING_DYNAMIC_MACRO : JANET_BINDING_MACRO; ------------------ | Branch (36600:24): [True: 0, False: 0] ------------------ 36601| 0| return binding; 36602| 0| } 36603| | 36604| 16.9k| if (ref_is_valid) { ------------------ | Branch (36604:9): [True: 0, False: 16.9k] ------------------ 36605| 0| binding.value = ref; 36606| 0| binding.type = redef ? JANET_BINDING_DYNAMIC_DEF : JANET_BINDING_VAR; ------------------ | Branch (36606:24): [True: 0, False: 0] ------------------ 36607| 16.9k| } else { 36608| 16.9k| binding.value = value; 36609| 16.9k| binding.type = JANET_BINDING_DEF; 36610| 16.9k| } 36611| | 36612| 16.9k| return binding; 36613| 16.9k|} janet_resolve_ext: 36668| 16.9k|JanetBinding janet_resolve_ext(JanetTable *env, const uint8_t *sym) { 36669| 16.9k| Janet entry = janet_table_get(env, janet_wrap_symbol(sym)); ------------------ | | 849| 16.9k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 16.9k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36670| 16.9k| return janet_binding_from_entry(entry); 36671| 16.9k|} janet_resolve: 36673| 16.9k|JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out) { 36674| 16.9k| JanetBinding binding = janet_resolve_ext(env, sym); 36675| 16.9k| if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) { ------------------ | Branch (36675:9): [True: 0, False: 16.9k] | Branch (36675:54): [True: 0, False: 16.9k] ------------------ 36676| 0| *out = janet_array_peek(janet_unwrap_array(binding.value)); ------------------ | | 860| 0|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 36677| 16.9k| } else { 36678| 16.9k| *out = binding.value; 36679| 16.9k| } 36680| 16.9k| return binding.type; 36681| 16.9k|} janet_resolve_core: 36684| 5.65k|Janet janet_resolve_core(const char *name) { 36685| 5.65k| JanetTable *env = janet_core_env(NULL); 36686| 5.65k| Janet out = janet_wrap_nil(); ------------------ | | 831| 5.65k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 5.65k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 5.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36687| 5.65k| janet_resolve(env, janet_csymbol(name), &out); 36688| 5.65k| return out; 36689| 5.65k|} janet_indexed_view: 36693| 20.3k|int janet_indexed_view(Janet seq, const Janet **data, int32_t *len) { 36694| 20.3k| if (janet_checktype(seq, JANET_ARRAY)) { ------------------ | | 806| 20.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 421, False: 19.9k] | | | Branch (806:6): [Folded, False: 20.3k] | | ------------------ | | 807| 20.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 20.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 20.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 20.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 20.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 20.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36695| 421| *data = janet_unwrap_array(seq)->data; ------------------ | | 860| 421|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 36696| 421| *len = janet_unwrap_array(seq)->count; ------------------ | | 860| 421|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 36697| 421| return 1; 36698| 19.9k| } else if (janet_checktype(seq, JANET_TUPLE)) { ------------------ | | 806| 19.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 19.9k, False: 0] | | | Branch (806:6): [Folded, False: 19.9k] | | ------------------ | | 807| 19.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 19.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 19.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 19.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 19.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 19.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36699| 19.9k| *data = janet_unwrap_tuple(seq); ------------------ | | 858| 19.9k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 36700| 19.9k| *len = janet_tuple_length(janet_unwrap_tuple(seq)); ------------------ | | 1802| 19.9k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 19.9k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 36701| 19.9k| return 1; 36702| 19.9k| } 36703| 0| return 0; 36704| 20.3k|} janet_bytes_view: 36708| 1.23k|int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len) { 36709| 1.23k| JanetType t = janet_type(str); ------------------ | | 795| 1.23k| (isnan((x).number) \ | | 796| 1.23k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 1.23k| : JANET_NUMBER) ------------------ | Branch (36709:19): [True: 1.23k, False: 0] ------------------ 36710| 1.23k| if (t == JANET_STRING || t == JANET_SYMBOL || t == JANET_KEYWORD) { ------------------ | Branch (36710:9): [True: 1.23k, False: 0] | Branch (36710:30): [True: 0, False: 0] | Branch (36710:51): [True: 0, False: 0] ------------------ 36711| 1.23k| *data = janet_unwrap_string(str); ------------------ | | 863| 1.23k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 36712| 1.23k| *len = janet_string_length(janet_unwrap_string(str)); ------------------ | | 1813| 1.23k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 1.23k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36713| 1.23k| return 1; 36714| 1.23k| } else if (t == JANET_BUFFER) { ------------------ | Branch (36714:16): [True: 0, False: 0] ------------------ 36715| 0| *data = janet_unwrap_buffer(str)->data; ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 36716| 0| *len = janet_unwrap_buffer(str)->count; ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 36717| 0| return 1; 36718| 0| } else if (t == JANET_ABSTRACT) { ------------------ | Branch (36718:16): [True: 0, False: 0] ------------------ 36719| 0| void *abst = janet_unwrap_abstract(str); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 36720| 0| const JanetAbstractType *atype = janet_abstract_type(abst); ------------------ | | 1899| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 36721| 0| if (NULL == atype->bytes) { ------------------ | Branch (36721:13): [True: 0, False: 0] ------------------ 36722| 0| return 0; 36723| 0| } 36724| 0| JanetByteView view = atype->bytes(abst, janet_abstract_size(abst)); ------------------ | | 1900| 0|#define janet_abstract_size(u) (janet_abstract_head(u)->size) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 36725| 0| *data = view.bytes; 36726| 0| *len = view.len; 36727| 0| return 1; 36728| 0| } 36729| 0| return 0; 36730| 1.23k|} janet_dictionary_view: 36735| 2.66k|int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap) { 36736| 2.66k| if (janet_checktype(tab, JANET_TABLE)) { ------------------ | | 806| 2.66k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 215, False: 2.44k] | | | Branch (806:6): [Folded, False: 2.66k] | | ------------------ | | 807| 2.66k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.66k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.66k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.66k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.66k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.66k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36737| 215| *data = janet_unwrap_table(tab)->data; ------------------ | | 861| 215|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36738| 215| *cap = janet_unwrap_table(tab)->capacity; ------------------ | | 861| 215|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36739| 215| *len = janet_unwrap_table(tab)->count; ------------------ | | 861| 215|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36740| 215| return 1; 36741| 2.44k| } else if (janet_checktype(tab, JANET_STRUCT)) { ------------------ | | 806| 2.44k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.44k, False: 0] | | | Branch (806:6): [Folded, False: 2.44k] | | ------------------ | | 807| 2.44k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.44k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.44k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.44k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.44k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.44k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36742| 2.44k| *data = janet_unwrap_struct(tab); ------------------ | | 857| 2.44k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 36743| 2.44k| *cap = janet_struct_capacity(janet_unwrap_struct(tab)); ------------------ | | 1849| 2.44k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 2.44k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 36744| 2.44k| *len = janet_struct_length(janet_unwrap_struct(tab)); ------------------ | | 1848| 2.44k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 2.44k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 36745| 2.44k| return 1; 36746| 2.44k| } 36747| 0| return 0; 36748| 2.66k|} janet_checkint: 36750| 10.0k|int janet_checkint(Janet x) { 36751| 10.0k| if (!janet_checktype(x, JANET_NUMBER)) ------------------ | | 806| 10.0k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [True: 10.0k, Folded] | | ------------------ | | 807| 10.0k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 10.0k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 2.45k, False: 7.63k] | | | | | Branch (803:28): [True: 0, False: 7.63k] | | | | ------------------ | | ------------------ | | 808| 10.0k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36751:9): [True: 7.63k, False: 2.45k] ------------------ 36752| 7.63k| return 0; 36753| 2.45k| double dval = janet_unwrap_number(x); ------------------ | | 839| 2.45k|#define janet_unwrap_number(x) ((x).number) ------------------ 36754| | return janet_checkintrange(dval); ------------------ | | 962| 2.45k|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | ------------------ | | | Branch (962:33): [True: 2.40k, False: 51] | | | Branch (962:53): [True: 2.27k, False: 125] | | | Branch (962:73): [True: 2.08k, False: 192] | | ------------------ ------------------ 36755| 10.0k|} janet_sorted_keys: 36832| 2.66k|int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer) { 36833| | 36834| | /* First, put populated indices into index_buffer */ 36835| 2.66k| int32_t next_index = 0; 36836| 17.0k| for (int32_t i = 0; i < cap; i++) { ------------------ | Branch (36836:25): [True: 14.3k, False: 2.66k] ------------------ 36837| 14.3k| if (!janet_checktype(dict[i].key, JANET_NIL)) { ------------------ | | 806| 14.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 14.3k] | | ------------------ | | 807| 14.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 14.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 14.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 14.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 14.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 14.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36837:13): [True: 3.96k, False: 10.4k] ------------------ 36838| 3.96k| index_buffer[next_index++] = i; 36839| 3.96k| } 36840| 14.3k| } 36841| | 36842| | /* Next, sort those (simple insertion sort here for now) */ 36843| 5.57k| for (int32_t i = 1; i < next_index; i++) { ------------------ | Branch (36843:25): [True: 2.91k, False: 2.66k] ------------------ 36844| 2.91k| int32_t index_to_insert = index_buffer[i]; 36845| 2.91k| Janet lhs = dict[index_to_insert].key; 36846| 7.94k| for (int32_t j = i - 1; j >= 0; j--) { ------------------ | Branch (36846:33): [True: 7.28k, False: 652] ------------------ 36847| 7.28k| index_buffer[j + 1] = index_buffer[j]; 36848| 7.28k| Janet rhs = dict[index_buffer[j]].key; 36849| 7.28k| if (janet_compare(lhs, rhs) >= 0) { ------------------ | Branch (36849:17): [True: 2.26k, False: 5.02k] ------------------ 36850| 2.26k| index_buffer[j + 1] = index_to_insert; 36851| 2.26k| break; 36852| 5.02k| } else if (j == 0) { ------------------ | Branch (36852:24): [True: 652, False: 4.37k] ------------------ 36853| 652| index_buffer[0] = index_to_insert; 36854| 652| } 36855| 7.28k| } 36856| 2.91k| } 36857| | 36858| | /* Return number of indices found */ 36859| 2.66k| return next_index; 36860| | 36861| 2.66k|} array_allocate: 37094| 28.0M|void *array_allocate(size_t element_size, int32_t count) { 37095| 28.0M| if (count < 0) return NULL; ------------------ | Branch (37095:9): [True: 0, False: 28.0M] ------------------ 37096| 28.0M| if ((size_t) count > (SIZE_MAX / element_size)) return NULL; ------------------ | Branch (37096:9): [True: 0, False: 28.0M] ------------------ 37097| 28.0M| return janet_malloc(element_size * count); ------------------ | | 2406| 28.0M|#define janet_malloc(X) malloc((X)) ------------------ 37098| 28.0M|} janet_equals: 37400| 69.2k|int janet_equals(Janet x, Janet y) { 37401| 69.2k| if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 69.2k| (isnan((x).number) \ | | 796| 69.2k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 69.2k| : JANET_NUMBER) ------------------ if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 69.2k| (isnan((x).number) \ | | 796| 69.2k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 69.2k| : JANET_NUMBER) ------------------ | Branch (37401:9): [True: 68.3k, False: 870] | Branch (37401:9): [True: 20.7k, False: 48.4k] | Branch (37401:26): [True: 68.5k, False: 715] ------------------ 37402| 48.4k| if (janet_checktypes(x, JANET_TFLAG_TUPLE | JANET_TFLAG_STRUCT)) return janet_equals_containers(x, y); ------------------ | | 969| 48.4k|#define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps)) | | ------------------ | | | | 795| 48.4k| (isnan((x).number) \ | | | | 796| 48.4k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | | | 797| 48.4k| : JANET_NUMBER) | | ------------------ | | | Branch (969:34): [True: 45.9k, False: 2.48k] | | ------------------ ------------------ | Branch (37402:9): [True: 48.3k, False: 173] ------------------ 37403| 2.48k| return janet_equals_leaf(x, y); 37404| 48.4k|} janet_hash: 37416| 51.2M|int32_t janet_hash(Janet x) { 37417| 51.2M| int32_t hash = 0; 37418| 51.2M| switch (janet_type(x)) { ------------------ | | 795| 51.2M| (isnan((x).number) \ | | 796| 51.2M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 51.2M| : JANET_NUMBER) ------------------ | Branch (37418:13): [True: 43.4M, False: 7.82M] ------------------ 37419| 878k| case JANET_NIL: ------------------ | Branch (37419:9): [True: 878k, False: 50.3M] ------------------ 37420| 878k| hash = 0; 37421| 878k| break; 37422| 34.0k| case JANET_BOOLEAN: ------------------ | Branch (37422:9): [True: 34.0k, False: 51.2M] ------------------ 37423| 34.0k| hash = janet_unwrap_boolean(x); ------------------ | | 838| 34.0k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 37424| 34.0k| break; 37425| 31.7M| case JANET_STRING: ------------------ | Branch (37425:9): [True: 31.7M, False: 19.4M] ------------------ 37426| 32.0M| case JANET_SYMBOL: ------------------ | Branch (37426:9): [True: 299k, False: 50.9M] ------------------ 37427| 32.5M| case JANET_KEYWORD: ------------------ | Branch (37427:9): [True: 515k, False: 50.7M] ------------------ 37428| 32.5M| hash = janet_string_hash(janet_unwrap_string(x)); ------------------ | | 1814| 32.5M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 32.5M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 37429| 32.5M| break; 37430| 195k| case JANET_TUPLE: ------------------ | Branch (37430:9): [True: 195k, False: 51.0M] ------------------ 37431| 195k| hash = janet_tuple_hash(janet_unwrap_tuple(x)); ------------------ | | 1803| 195k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 195k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 37432| 195k| uint32_t inc = (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0; ------------------ | | 1806| 195k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 195k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ uint32_t inc = (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0; ------------------ | | 1798| 195k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (37432:28): [True: 2.43k, False: 193k] ------------------ 37433| 195k| hash = (int32_t)((uint32_t)hash + inc); /* avoid overflow undefined behavior */ 37434| 195k| break; 37435| 16.4k| case JANET_STRUCT: ------------------ | Branch (37435:9): [True: 16.4k, False: 51.2M] ------------------ 37436| 16.4k| hash = janet_struct_hash(janet_unwrap_struct(x)); ------------------ | | 1850| 16.4k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 16.4k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37437| 16.4k| break; 37438| 7.82M| case JANET_NUMBER: { ------------------ | Branch (37438:9): [True: 7.82M, False: 43.4M] ------------------ 37439| 7.82M| union { 37440| 7.82M| double d; 37441| 7.82M| uint64_t u; 37442| 7.82M| } as; 37443| 7.82M| as.d = janet_unwrap_number(x); ------------------ | | 839| 7.82M|#define janet_unwrap_number(x) ((x).number) ------------------ 37444| 7.82M| as.d += 0.0; /* normalize negative 0 */ 37445| 7.82M| as.u = murmur64(as.u); 37446| 7.82M| uint32_t hi = (uint32_t)(as.u >> 32); 37447| 7.82M| hash = (int32_t)hi; 37448| 7.82M| break; 37449| 32.0M| } 37450| 38.9k| case JANET_ABSTRACT: { ------------------ | Branch (37450:9): [True: 38.9k, False: 51.1M] ------------------ 37451| 38.9k| JanetAbstract xx = janet_unwrap_abstract(x); ------------------ | | 866| 38.9k|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37452| 38.9k| const JanetAbstractType *at = janet_abstract_type(xx); ------------------ | | 1899| 38.9k|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 38.9k|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37453| 38.9k| if (at->hash != NULL) { ------------------ | Branch (37453:17): [True: 5.04k, False: 33.9k] ------------------ 37454| 5.04k| hash = at->hash(xx, janet_abstract_size(xx)); ------------------ | | 1900| 5.04k|#define janet_abstract_size(u) (janet_abstract_head(u)->size) | | ------------------ | | | | 1897| 5.04k|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37455| 5.04k| break; 37456| 5.04k| } 37457| 38.9k| } 37458| | /* fallthrough */ 37459| 9.70M| default: ------------------ | Branch (37459:9): [True: 9.67M, False: 41.5M] ------------------ 37460| 9.70M| if (sizeof(double) == sizeof(void *)) { ------------------ | Branch (37460:17): [True: 9.70M, Folded] ------------------ 37461| | /* Assuming 8 byte pointer (8 byte aligned) */ 37462| 9.70M| uint64_t i = murmur64(janet_u64(x)); ------------------ | | 788| 9.70M|#define janet_u64(x) ((x).u64) ------------------ 37463| 9.70M| hash = (int32_t)(i >> 32); 37464| 9.70M| } else { 37465| | /* Assuming 4 byte pointer (or smaller) */ 37466| 0| uintptr_t diff = (uintptr_t) janet_unwrap_pointer(x); ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ 37467| 0| uint32_t hilo = (uint32_t) diff * 2654435769u; 37468| 0| hash = (int32_t)((hilo << 16) | (hilo >> 16)); 37469| 0| } 37470| 9.70M| break; 37471| 51.2M| } 37472| 51.2M| return hash; 37473| 51.2M|} janet_compare: 37478| 9.25k|int janet_compare(Janet x, Janet y) { 37479| 9.25k| janet_vm.traversal = janet_vm.traversal_base; 37480| 9.25k| int status; 37481| 15.8k| do { 37482| 15.8k| JanetType tx = janet_type(x); ------------------ | | 795| 15.8k| (isnan((x).number) \ | | 796| 15.8k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 15.8k| : JANET_NUMBER) ------------------ | Branch (37482:24): [True: 15.1k, False: 773] ------------------ 37483| 15.8k| JanetType ty = janet_type(y); ------------------ | | 795| 15.8k| (isnan((x).number) \ | | 796| 15.8k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 15.8k| : JANET_NUMBER) ------------------ | Branch (37483:24): [True: 15.2k, False: 677] ------------------ 37484| 15.8k| if (tx != ty) return tx < ty ? -1 : 1; ------------------ | Branch (37484:13): [True: 4.10k, False: 11.7k] | Branch (37484:30): [True: 2.94k, False: 1.15k] ------------------ 37485| 11.7k| switch (tx) { 37486| 1.23k| case JANET_NIL: ------------------ | Branch (37486:13): [True: 1.23k, False: 10.5k] ------------------ 37487| 1.23k| break; 37488| 10| case JANET_BOOLEAN: { ------------------ | Branch (37488:13): [True: 10, False: 11.7k] ------------------ 37489| 10| int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 838| 10|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 838| 10|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 37490| 10| if (diff) return diff; ------------------ | Branch (37490:21): [True: 0, False: 10] ------------------ 37491| 10| break; 37492| 10| } 37493| 308| case JANET_NUMBER: { ------------------ | Branch (37493:13): [True: 308, False: 11.4k] ------------------ 37494| 308| double xx = janet_unwrap_number(x); ------------------ | | 839| 308|#define janet_unwrap_number(x) ((x).number) ------------------ 37495| 308| double yy = janet_unwrap_number(y); ------------------ | | 839| 308|#define janet_unwrap_number(x) ((x).number) ------------------ 37496| 308| if (xx == yy) { ------------------ | Branch (37496:21): [True: 114, False: 194] ------------------ 37497| 114| break; 37498| 194| } else { 37499| 194| return (xx < yy) ? -1 : 1; ------------------ | Branch (37499:28): [True: 121, False: 73] ------------------ 37500| 194| } 37501| 308| } 37502| 499| case JANET_STRING: ------------------ | Branch (37502:13): [True: 499, False: 11.2k] ------------------ 37503| 5.35k| case JANET_SYMBOL: ------------------ | Branch (37503:13): [True: 4.85k, False: 6.93k] ------------------ 37504| 5.45k| case JANET_KEYWORD: { ------------------ | Branch (37504:13): [True: 98, False: 11.6k] ------------------ 37505| 5.45k| int diff = janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 5.45k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ int diff = janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 5.45k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 37506| 5.45k| if (diff) return diff; ------------------ | Branch (37506:21): [True: 1.97k, False: 3.47k] ------------------ 37507| 3.47k| break; 37508| 5.45k| } 37509| 3.47k| case JANET_ABSTRACT: { ------------------ | Branch (37509:13): [True: 659, False: 11.1k] ------------------ 37510| 659| int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 659|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 659|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37511| 659| if (diff) return diff; ------------------ | Branch (37511:21): [True: 542, False: 117] ------------------ 37512| 117| break; 37513| 659| } 37514| 158| default: { ------------------ | Branch (37514:13): [True: 158, False: 11.6k] ------------------ 37515| 158| if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 867| 158|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 867| 158|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (37515:21): [True: 0, False: 158] ------------------ 37516| 0| break; 37517| 158| } else { 37518| 158| return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 867| 158|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 867| 158|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (37518:28): [True: 58, False: 100] ------------------ 37519| 158| } 37520| 158| } 37521| 3.03k| case JANET_TUPLE: { ------------------ | Branch (37521:13): [True: 3.03k, False: 8.75k] ------------------ 37522| 3.03k| const Janet *lhs = janet_unwrap_tuple(x); ------------------ | | 858| 3.03k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37523| 3.03k| const Janet *rhs = janet_unwrap_tuple(y); ------------------ | | 858| 3.03k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37524| 3.03k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1798| 3.03k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1806| 3.03k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 3.03k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1806| 3.03k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 3.03k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37524:21): [True: 23, False: 3.01k] ------------------ 37525| 23| return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1806| 23|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 23|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1798| 23|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (37525:28): [True: 6, False: 17] ------------------ 37526| 23| } 37527| 3.01k| push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1800| 3.01k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1800| 3.01k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 37528| 3.01k| break; 37529| 3.03k| } 37530| 930| case JANET_STRUCT: { ------------------ | Branch (37530:13): [True: 930, False: 10.8k] ------------------ 37531| 930| const JanetKV *lhs = janet_unwrap_struct(x); ------------------ | | 857| 930|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37532| 930| const JanetKV *rhs = janet_unwrap_struct(y); ------------------ | | 857| 930|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37533| 930| int32_t llen = janet_struct_capacity(lhs); ------------------ | | 1849| 930|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 930|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37534| 930| int32_t rlen = janet_struct_capacity(rhs); ------------------ | | 1849| 930|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 930|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37535| 930| int32_t lhash = janet_struct_hash(lhs); ------------------ | | 1850| 930|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 930|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37536| 930| int32_t rhash = janet_struct_hash(rhs); ------------------ | | 1850| 930|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 930|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37537| 930| if (llen < rlen) return -1; ------------------ | Branch (37537:21): [True: 108, False: 822] ------------------ 37538| 822| if (llen > rlen) return 1; ------------------ | Branch (37538:21): [True: 64, False: 758] ------------------ 37539| 758| if (lhash < rhash) return -1; ------------------ | Branch (37539:21): [True: 87, False: 671] ------------------ 37540| 671| if (lhash > rhash) return 1; ------------------ | Branch (37540:21): [True: 82, False: 589] ------------------ 37541| 589| push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1846| 589|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1846| 589|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 37542| 589| break; 37543| 671| } 37544| 11.7k| } 37545| 11.7k| } while (!(status = traversal_next(&x, &y))); ------------------ | Branch (37545:14): [True: 6.63k, False: 1.92k] ------------------ 37546| 1.92k| return status - 2; 37547| 9.25k|} janet_v_grow: 37951| 176k|void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) { 37952| 176k| int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0; ------------------ | | 765| 157k|#define janet_v__cap(v) janet_v__raw(v)[0] | | ------------------ | | | | 764| 157k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ | Branch (37952:23): [True: 157k, False: 18.4k] ------------------ 37953| 176k| int32_t min_needed = janet_v_count(v) + increment; ------------------ | | 759| 176k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 157k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 157k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 157k, False: 18.4k] | | ------------------ ------------------ 37954| 176k| int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed; ------------------ | Branch (37954:17): [True: 139k, False: 36.8k] ------------------ 37955| 176k| size_t newsize = ((size_t) itemsize) * m + sizeof(int32_t) * 2; 37956| 176k| int32_t *p = (int32_t *) janet_srealloc(v ? janet_v__raw(v) : 0, newsize); ------------------ | | 764| 157k|#define janet_v__raw(v) ((int32_t *)(v) - 2) ------------------ | Branch (37956:45): [True: 157k, False: 18.4k] ------------------ 37957| 176k| if (!v) p[1] = 0; ------------------ | Branch (37957:9): [True: 18.4k, False: 157k] ------------------ 37958| 176k| p[0] = m; 37959| 176k| return p + 2; 37960| 176k|} janet_try_init: 39467| 3.43k|void janet_try_init(JanetTryState *state) { 39468| 3.43k| state->stackn = janet_vm.stackn++; 39469| 3.43k| state->gc_handle = janet_vm.gc_suspend; 39470| 3.43k| state->vm_fiber = janet_vm.fiber; 39471| 3.43k| state->vm_jmp_buf = janet_vm.signal_buf; 39472| 3.43k| state->vm_return_reg = janet_vm.return_reg; 39473| 3.43k| state->coerce_error = janet_vm.coerce_error; 39474| 3.43k| janet_vm.return_reg = &(state->payload); 39475| 3.43k| janet_vm.signal_buf = &(state->buf); 39476| 3.43k| janet_vm.coerce_error = 0; 39477| 3.43k|} janet_restore: 39479| 3.43k|void janet_restore(JanetTryState *state) { 39480| 3.43k| janet_vm.stackn = state->stackn; 39481| 3.43k| janet_vm.gc_suspend = state->gc_handle; 39482| 3.43k| janet_vm.fiber = state->vm_fiber; 39483| 3.43k| janet_vm.signal_buf = state->vm_jmp_buf; 39484| 3.43k| janet_vm.return_reg = state->vm_return_reg; 39485| 3.43k| janet_vm.coerce_error = state->coerce_error; 39486| 3.43k|} janet_init: 39641| 5.65k|int janet_init(void) { 39642| | 39643| | /* Garbage collection */ 39644| 5.65k| janet_vm.blocks = NULL; 39645| 5.65k| janet_vm.weak_blocks = NULL; 39646| 5.65k| janet_vm.next_collection = 0; 39647| 5.65k| janet_vm.gc_interval = 0x400000; 39648| 5.65k| janet_vm.block_count = 0; 39649| 5.65k| janet_vm.gc_mark_phase = 0; 39650| | 39651| 5.65k| janet_symcache_init(); 39652| | 39653| | /* Initialize gc roots */ 39654| 5.65k| janet_vm.roots = NULL; 39655| 5.65k| janet_vm.root_count = 0; 39656| 5.65k| janet_vm.root_capacity = 0; 39657| | 39658| | /* Scratch memory */ 39659| 5.65k| janet_vm.user = NULL; 39660| 5.65k| janet_vm.scratch_mem = NULL; 39661| 5.65k| janet_vm.scratch_len = 0; 39662| 5.65k| janet_vm.scratch_cap = 0; 39663| | 39664| | /* Sandbox flags */ 39665| 5.65k| janet_vm.sandbox_flags = 0; 39666| | 39667| | /* Initialize registry */ 39668| 5.65k| janet_vm.registry = NULL; 39669| 5.65k| janet_vm.registry_cap = 0; 39670| 5.65k| janet_vm.registry_count = 0; 39671| 5.65k| janet_vm.registry_dirty = 0; 39672| | 39673| | /* Initialize abstract registry */ 39674| 5.65k| janet_vm.abstract_registry = janet_table(0); 39675| 5.65k| janet_gcroot(janet_wrap_table(janet_vm.abstract_registry)); ------------------ | | 846| 5.65k|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 5.65k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 5.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39676| | 39677| | /* Traversal */ 39678| 5.65k| janet_vm.traversal = NULL; 39679| 5.65k| janet_vm.traversal_base = NULL; 39680| 5.65k| janet_vm.traversal_top = NULL; 39681| | 39682| | /* Core env */ 39683| 5.65k| janet_vm.core_env = NULL; 39684| | 39685| | /* Auto suspension */ 39686| 5.65k| janet_vm.auto_suspend = 0; 39687| | 39688| | /* Dynamic bindings */ 39689| 5.65k| janet_vm.top_dyns = NULL; 39690| | 39691| | /* Seed RNG */ 39692| 5.65k| janet_rng_seed(janet_default_rng(), 0); 39693| | 39694| | /* Fibers */ 39695| 5.65k| janet_vm.fiber = NULL; 39696| 5.65k| janet_vm.root_fiber = NULL; 39697| 5.65k| janet_vm.stackn = 0; 39698| | 39699| 5.65k|#ifdef JANET_EV 39700| 5.65k| janet_ev_init(); 39701| 5.65k|#endif 39702| 5.65k|#ifdef JANET_NET 39703| 5.65k| janet_net_init(); 39704| 5.65k|#endif 39705| 5.65k| return 0; 39706| 5.65k|} janet_deinit: 39721| 5.65k|void janet_deinit(void) { 39722| 5.65k| janet_clear_memory(); 39723| 5.65k| janet_symcache_deinit(); 39724| 5.65k| janet_free(janet_vm.roots); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 39725| 5.65k| janet_vm.roots = NULL; 39726| 5.65k| janet_vm.root_count = 0; 39727| 5.65k| janet_vm.root_capacity = 0; 39728| 5.65k| janet_vm.abstract_registry = NULL; 39729| 5.65k| janet_vm.core_env = NULL; 39730| 5.65k| janet_vm.top_dyns = NULL; 39731| 5.65k| janet_vm.user = NULL; 39732| 5.65k| janet_free(janet_vm.traversal_base); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 39733| 5.65k| janet_vm.fiber = NULL; 39734| 5.65k| janet_vm.root_fiber = NULL; 39735| 5.65k| janet_free(janet_vm.registry); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 39736| | janet_vm.registry = NULL; 39737| 5.65k|#ifdef JANET_EV 39738| 5.65k| janet_ev_deinit(); 39739| 5.65k|#endif 39740| 5.65k|#ifdef JANET_NET 39741| 5.65k| janet_net_deinit(); 39742| 5.65k|#endif 39743| 5.65k|} janet_memalloc_empty: 39911| 7.52M|void *janet_memalloc_empty(int32_t count) { 39912| 7.52M| int32_t i; 39913| 7.52M| void *mem = array_allocate(sizeof(JanetKV), count); 39914| 7.52M| janet_vm.next_collection += (size_t) count * sizeof(JanetKV); 39915| 7.52M| if (NULL == mem) { ------------------ | Branch (39915:9): [True: 0, False: 7.52M] ------------------ 39916| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 39917| 0| } 39918| 7.52M| JanetKV *mmem = (JanetKV *)mem; 39919| 118M| for (i = 0; i < count; i++) { ------------------ | Branch (39919:17): [True: 110M, False: 7.52M] ------------------ 39920| 110M| JanetKV *kv = mmem + i; 39921| 110M| kv->key = janet_wrap_nil(); ------------------ | | 831| 110M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 110M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 110M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 110M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39922| 110M| kv->value = janet_wrap_nil(); ------------------ | | 831| 110M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 110M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 110M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 110M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39923| 110M| } 39924| 7.52M| return mem; 39925| 7.52M|} janet_memempty: 39927| 46.4k|void janet_memempty(JanetKV *mem, int32_t count) { 39928| 46.4k| int32_t i; 39929| 763k| for (i = 0; i < count; i++) { ------------------ | Branch (39929:17): [True: 716k, False: 46.4k] ------------------ 39930| 716k| mem[i].key = janet_wrap_nil(); ------------------ | | 831| 716k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 716k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 716k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 716k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39931| 716k| mem[i].value = janet_wrap_nil(); ------------------ | | 831| 716k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 716k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 716k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 716k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39932| 716k| } 39933| 46.4k|} janet_wrap_number_safe: 39937| 39.5k|Janet janet_wrap_number_safe(double d) { 39938| 39.5k| Janet ret; 39939| 39.5k| ret.number = isnan(d) ? NAN : d; ------------------ | Branch (39939:18): [True: 5.65k, False: 33.9k] ------------------ 39940| 39.5k| return ret; 39941| 39.5k|} janet_nanbox_to_pointer: 39943| 117M|void *janet_nanbox_to_pointer(Janet x) { 39944| 117M| x.i64 &= JANET_NANBOX_PAYLOADBITS; ------------------ | | 791| 117M|#define JANET_NANBOX_PAYLOADBITS 0x00007FFFFFFFFFFFllu ------------------ 39945| 117M| x.u64 <<= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 117M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39946| 117M| return x.pointer; 39947| 117M|} janet_nanbox_from_pointer: 39949| 8.38M|Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask) { 39950| 8.38M| Janet ret; 39951| 8.38M| ret.pointer = p; 39952| | /* Should be noop when pointer shift is 0 */ 39953| | /* 39954| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 39955| | */ 39956| 8.38M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 8.38M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39957| 8.38M| ret.u64 |= tagmask; 39958| 8.38M| return ret; 39959| 8.38M|} janet_nanbox_from_cpointer: 39961| 45.5M|Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask) { 39962| 45.5M| Janet ret; 39963| 45.5M| ret.pointer = (void *)p; 39964| | /* Should be noop when pointer shift is 0 */ 39965| | /* 39966| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 39967| | */ 39968| 45.5M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 45.5M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39969| 45.5M| ret.u64 |= tagmask; 39970| 45.5M| return ret; 39971| 45.5M|} janet_nanbox_from_double: 39973| 116M|Janet janet_nanbox_from_double(double d) { 39974| 116M| Janet ret; 39975| 116M| ret.number = d; 39976| 116M| return ret; 39977| 116M|} janet_nanbox_from_bits: 39979| 549M|Janet janet_nanbox_from_bits(uint64_t bits) { 39980| 549M| Janet ret; 39981| 549M| ret.u64 = bits; 39982| 549M| return ret; 39983| 549M|} janet.c:janet_array_impl: 1606| 19.9k|static void janet_array_impl(JanetArray *array, int32_t capacity) { 1607| 19.9k| Janet *data = NULL; 1608| 19.9k| if (capacity > 0) { ------------------ | Branch (1608:9): [True: 17.3k, False: 2.62k] ------------------ 1609| 17.3k| janet_vm.next_collection += capacity * sizeof(Janet); 1610| 17.3k| data = (Janet *) array_allocate(sizeof(Janet), capacity); 1611| 17.3k| if (NULL == data) { ------------------ | Branch (1611:13): [True: 0, False: 17.3k] ------------------ 1612| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 1613| 0| } 1614| 17.3k| } 1615| 19.9k| array->count = 0; 1616| 19.9k| array->capacity = capacity; 1617| 19.9k| array->data = data; 1618| 19.9k|} janet.c:janet_buffer_init_impl: 3196| 9.18M|static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) { 3197| 9.18M| uint8_t *data = NULL; 3198| 9.18M| if (capacity < 4) capacity = 4; ------------------ | Branch (3198:9): [True: 6.07k, False: 9.18M] ------------------ 3199| 9.18M| janet_gcpressure(capacity); 3200| 9.18M| data = array_allocate(sizeof(uint8_t), capacity); 3201| 9.18M| if (NULL == data) { ------------------ | Branch (3201:9): [True: 0, False: 9.18M] ------------------ 3202| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 3203| 0| } 3204| 9.18M| buffer->count = 0; 3205| 9.18M| buffer->capacity = capacity; 3206| 9.18M| buffer->data = data; 3207| 9.18M| return buffer; 3208| 9.18M|} janet.c:janet_buffer_can_realloc: 3189| 7.17M|static void janet_buffer_can_realloc(JanetBuffer *buffer) { 3190| 7.17M| if (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) { ------------------ | | 1780| 7.17M|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3190:9): [True: 0, False: 7.17M] ------------------ 3191| 0| janet_panic("buffer cannot reallocate foreign memory"); 3192| 0| } 3193| 7.17M|} janet.c:janet_load_libs: 9378| 5.65k|static void janet_load_libs(JanetTable *env) { 9379| 5.65k| JanetRegExt corelib_cfuns[] = { 9380| 5.65k| JANET_CORE_REG("native", janet_core_native), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9381| 5.65k| JANET_CORE_REG("describe", janet_core_describe), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9382| 5.65k| JANET_CORE_REG("string", janet_core_string), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9383| 5.65k| JANET_CORE_REG("symbol", janet_core_symbol), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9384| 5.65k| JANET_CORE_REG("keyword", janet_core_keyword), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9385| 5.65k| JANET_CORE_REG("buffer", janet_core_buffer), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9386| 5.65k| JANET_CORE_REG("abstract?", janet_core_is_abstract), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9387| 5.65k| JANET_CORE_REG("table", janet_core_table), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9388| 5.65k| JANET_CORE_REG("array", janet_core_array), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9389| 5.65k| JANET_CORE_REG("scan-number", janet_core_scannumber), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9390| 5.65k| JANET_CORE_REG("tuple", janet_core_tuple), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9391| 5.65k| JANET_CORE_REG("struct", janet_core_struct), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9392| 5.65k| JANET_CORE_REG("gensym", janet_core_gensym), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9393| 5.65k| JANET_CORE_REG("gccollect", janet_core_gccollect), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9394| 5.65k| JANET_CORE_REG("gcsetinterval", janet_core_gcsetinterval), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9395| 5.65k| JANET_CORE_REG("gcinterval", janet_core_gcinterval), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9396| 5.65k| JANET_CORE_REG("type", janet_core_type), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9397| 5.65k| JANET_CORE_REG("hash", janet_core_hash), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9398| 5.65k| JANET_CORE_REG("getline", janet_core_getline), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9399| 5.65k| JANET_CORE_REG("dyn", janet_core_dyn), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9400| 5.65k| JANET_CORE_REG("setdyn", janet_core_setdyn), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9401| 5.65k| JANET_CORE_REG("trace", janet_core_trace), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9402| 5.65k| JANET_CORE_REG("untrace", janet_core_untrace), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9403| 5.65k| JANET_CORE_REG("module/expand-path", janet_core_expand_path), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9404| 5.65k| JANET_CORE_REG("int?", janet_core_check_int), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9405| 5.65k| JANET_CORE_REG("nat?", janet_core_check_nat), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9406| 5.65k| JANET_CORE_REG("bytes?", janet_core_is_bytes), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9407| 5.65k| JANET_CORE_REG("indexed?", janet_core_is_indexed), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9408| 5.65k| JANET_CORE_REG("dictionary?", janet_core_is_dictionary), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9409| 5.65k| JANET_CORE_REG("lengthable?", janet_core_is_lengthable), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9410| 5.65k| JANET_CORE_REG("slice", janet_core_slice), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9411| 5.65k| JANET_CORE_REG("range", janet_core_range), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9412| 5.65k| JANET_CORE_REG("signal", janet_core_signal), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9413| 5.65k| JANET_CORE_REG("memcmp", janet_core_memcmp), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9414| 5.65k| JANET_CORE_REG("getproto", janet_core_getproto), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9415| 5.65k| JANET_CORE_REG("sandbox", janet_core_sandbox), ------------------ | | 518| 5.65k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 5.65k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9416| 5.65k| JANET_REG_END ------------------ | | 2110| 5.65k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 9417| 5.65k| }; 9418| | janet_core_cfuns_ext(env, NULL, corelib_cfuns); 9419| 5.65k| janet_lib_io(env); 9420| 5.65k| janet_lib_math(env); 9421| 5.65k| janet_lib_array(env); 9422| 5.65k| janet_lib_tuple(env); 9423| 5.65k| janet_lib_buffer(env); 9424| 5.65k| janet_lib_table(env); 9425| 5.65k| janet_lib_struct(env); 9426| 5.65k| janet_lib_fiber(env); 9427| 5.65k| janet_lib_os(env); 9428| 5.65k| janet_lib_parse(env); 9429| 5.65k| janet_lib_compile(env); 9430| 5.65k| janet_lib_debug(env); 9431| 5.65k| janet_lib_string(env); 9432| 5.65k| janet_lib_marsh(env); 9433| 5.65k|#ifdef JANET_PEG 9434| 5.65k| janet_lib_peg(env); 9435| 5.65k|#endif 9436| 5.65k|#ifdef JANET_ASSEMBLER 9437| 5.65k| janet_lib_asm(env); 9438| 5.65k|#endif 9439| 5.65k|#ifdef JANET_INT_TYPES 9440| 5.65k| janet_lib_inttypes(env); 9441| 5.65k|#endif 9442| 5.65k|#ifdef JANET_EV 9443| 5.65k| janet_lib_ev(env); 9444| 5.65k|#ifdef JANET_FILEWATCH 9445| 5.65k| janet_lib_filewatch(env); 9446| 5.65k|#endif 9447| 5.65k|#endif 9448| 5.65k|#ifdef JANET_NET 9449| 5.65k| janet_lib_net(env); 9450| 5.65k|#endif 9451| 5.65k|#ifdef JANET_FFI 9452| 5.65k| janet_lib_ffi(env); 9453| 5.65k|#endif 9454| 5.65k|} janet.c:janet_q_init: 10696| 5.65k|static void janet_q_init(JanetQueue *q) { 10697| | q->data = NULL; 10698| 5.65k| q->head = 0; 10699| 5.65k| q->tail = 0; 10700| 5.65k| q->capacity = 0; 10701| 5.65k|} janet.c:peek_timeout: 10778| 5.65k|static int peek_timeout(JanetTimeout *out) { 10779| 5.65k| if (janet_vm.tq_count == 0) return 0; ------------------ | Branch (10779:9): [True: 5.65k, False: 0] ------------------ 10780| 0| *out = janet_vm.tq[0]; 10781| 0| return 1; 10782| 5.65k|} janet.c:janet_q_deinit: 10703| 5.65k|static void janet_q_deinit(JanetQueue *q) { 10704| 5.65k| janet_free(q->data); ------------------ | | 2415| 5.65k|#define janet_free(X) free((X)) ------------------ 10705| 5.65k|} janet.c:janet_ev_setup_selfpipe: 12265| 5.65k|static void janet_ev_setup_selfpipe(void) { 12266| 5.65k| if (janet_make_pipe(janet_vm.selfpipe, 1)) { ------------------ | Branch (12266:9): [True: 0, False: 5.65k] ------------------ 12267| | JANET_EXIT("failed to initialize self pipe in event loop"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 12268| 0| } 12269| 5.65k|} janet.c:janet_ev_cleanup_selfpipe: 12288| 5.65k|static void janet_ev_cleanup_selfpipe(void) { 12289| 5.65k| close(janet_vm.selfpipe[0]); 12290| 5.65k| close(janet_vm.selfpipe[1]); 12291| 5.65k|} janet.c:janet_deinit_block: 18295| 50.2M|static void janet_deinit_block(JanetGCObject *mem) { 18296| 50.2M| switch (mem->flags & JANET_MEM_TYPEBITS) { ------------------ | | 675| 50.2M|#define JANET_MEM_TYPEBITS 0xFF ------------------ 18297| 29.4M| default: ------------------ | Branch (18297:9): [True: 29.4M, False: 20.7M] ------------------ 18298| 31.6M| case JANET_MEMORY_FUNCTION: ------------------ | Branch (18298:9): [True: 2.16M, False: 48.0M] ------------------ 18299| 31.6M| break; /* Do nothing for non gc types */ 18300| 11.3M| case JANET_MEMORY_SYMBOL: ------------------ | Branch (18300:9): [True: 11.3M, False: 38.9M] ------------------ 18301| 11.3M| janet_symbol_deinit(((JanetStringHead *) mem)->data); 18302| 11.3M| break; 18303| 19.9k| case JANET_MEMORY_ARRAY: ------------------ | Branch (18303:9): [True: 19.9k, False: 50.1M] ------------------ 18304| 19.9k| case JANET_MEMORY_ARRAY_WEAK: ------------------ | Branch (18304:9): [True: 0, False: 50.2M] ------------------ 18305| 19.9k| janet_free(((JanetArray *) mem)->data); ------------------ | | 2415| 19.9k|#define janet_free(X) free((X)) ------------------ 18306| 19.9k| break; 18307| 4.15M| case JANET_MEMORY_TABLE: ------------------ | Branch (18307:9): [True: 4.15M, False: 46.0M] ------------------ 18308| 4.15M| case JANET_MEMORY_TABLE_WEAKK: ------------------ | Branch (18308:9): [True: 0, False: 50.2M] ------------------ 18309| 4.15M| case JANET_MEMORY_TABLE_WEAKV: ------------------ | Branch (18309:9): [True: 0, False: 50.2M] ------------------ 18310| 4.15M| case JANET_MEMORY_TABLE_WEAKKV: ------------------ | Branch (18310:9): [True: 0, False: 50.2M] ------------------ 18311| 4.15M| janet_free(((JanetTable *) mem)->data); ------------------ | | 2415| 4.15M|#define janet_free(X) free((X)) ------------------ 18312| 4.15M| break; 18313| 0| case JANET_MEMORY_FIBER: { ------------------ | Branch (18313:9): [True: 0, False: 50.2M] ------------------ 18314| 0| JanetFiber *f = (JanetFiber *)mem; 18315| 0|#ifdef JANET_EV 18316| 0| if (f->ev_state && !(f->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) { ------------------ | | 847| 0|#define JANET_FIBER_EV_FLAG_IN_FLIGHT 0x1 ------------------ | Branch (18316:17): [True: 0, False: 0] | Branch (18316:32): [True: 0, False: 0] ------------------ 18317| 0| janet_ev_dec_refcount(); 18318| 0| janet_free(f->ev_state); ------------------ | | 2415| 0|#define janet_free(X) free((X)) ------------------ 18319| 0| } else if (f->gc.flags & JANET_FIBER_EV_GCFLAG_SUSPENDED) { ------------------ | | 843| 0|#define JANET_FIBER_EV_GCFLAG_SUSPENDED 0x2000000 ------------------ | Branch (18319:24): [True: 0, False: 0] ------------------ 18320| 0| janet_ev_dec_refcount(); 18321| 0| } 18322| 0|#endif 18323| 0| janet_free(f->data); ------------------ | | 2415| 0|#define janet_free(X) free((X)) ------------------ 18324| 0| } 18325| 0| break; 18326| 10.1k| case JANET_MEMORY_BUFFER: ------------------ | Branch (18326:9): [True: 10.1k, False: 50.2M] ------------------ 18327| 10.1k| janet_buffer_deinit((JanetBuffer *) mem); 18328| 10.1k| break; 18329| 20.6k| case JANET_MEMORY_ABSTRACT: { ------------------ | Branch (18329:9): [True: 20.6k, False: 50.1M] ------------------ 18330| 20.6k| JanetAbstractHead *head = (JanetAbstractHead *)mem; 18331| 20.6k| if (head->type->gcperthread) { ------------------ | Branch (18331:17): [True: 0, False: 20.6k] ------------------ 18332| 0| janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 18333| 0| } 18334| 20.6k| if (head->type->gc) { ------------------ | Branch (18334:17): [True: 16.9k, False: 3.70k] ------------------ 18335| 16.9k| janet_assert(!head->type->gc(head->data, head->size), "finalizer failed"); ------------------ | | 389| 16.9k|#define janet_assert(c, m) do { \ | | 390| 16.9k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 16.9k] | | ------------------ | | 391| 16.9k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 16.9k] | | ------------------ ------------------ 18336| 16.9k| } 18337| 20.6k| } 18338| 20.6k| break; 18339| 45.2k| case JANET_MEMORY_FUNCENV: { ------------------ | Branch (18339:9): [True: 45.2k, False: 50.1M] ------------------ 18340| 45.2k| JanetFuncEnv *env = (JanetFuncEnv *)mem; 18341| 45.2k| if (0 == env->offset) ------------------ | Branch (18341:17): [True: 45.2k, False: 0] ------------------ 18342| 45.2k| janet_free(env->as.values); ------------------ | | 2415| 45.2k|#define janet_free(X) free((X)) ------------------ 18343| 45.2k| } 18344| 45.2k| break; 18345| 3.02M| case JANET_MEMORY_FUNCDEF: { ------------------ | Branch (18345:9): [True: 3.02M, False: 47.1M] ------------------ 18346| 3.02M| JanetFuncDef *def = (JanetFuncDef *)mem; 18347| | /* TODO - get this all with one alloc and one free */ 18348| 3.02M| janet_free(def->defs); ------------------ | | 2415| 3.02M|#define janet_free(X) free((X)) ------------------ 18349| 3.02M| janet_free(def->environments); ------------------ | | 2415| 3.02M|#define janet_free(X) free((X)) ------------------ 18350| 3.02M| janet_free(def->constants); ------------------ | | 2415| 3.02M|#define janet_free(X) free((X)) ------------------ 18351| 3.02M| janet_free(def->bytecode); ------------------ | | 2415| 3.02M|#define janet_free(X) free((X)) ------------------ 18352| 3.02M| janet_free(def->sourcemap); ------------------ | | 2415| 3.02M|#define janet_free(X) free((X)) ------------------ 18353| 3.02M| janet_free(def->closure_bitset); ------------------ | | 2415| 3.02M|#define janet_free(X) free((X)) ------------------ 18354| 3.02M| janet_free(def->symbolmap); ------------------ | | 2415| 3.02M|#define janet_free(X) free((X)) ------------------ 18355| 3.02M| } 18356| 3.02M| break; 18357| 50.2M| } 18358| 50.2M|} janet.c:janet_free_all_scratch: 18545| 5.65k|static void janet_free_all_scratch(void) { 18546| 6.34k| for (size_t i = 0; i < janet_vm.scratch_len; i++) { ------------------ | Branch (18546:24): [True: 694, False: 5.65k] ------------------ 18547| 694| free_one_scratch(janet_vm.scratch_mem[i]); 18548| 694| } 18549| 5.65k| janet_vm.scratch_len = 0; 18550| 5.65k|} janet.c:janet_mem2scratch: 18552| 9.20M|static JanetScratch *janet_mem2scratch(void *mem) { 18553| 9.20M| JanetScratch *s = (JanetScratch *)mem; 18554| 9.20M| return s - 1; 18555| 9.20M|} janet.c:free_one_scratch: 18537| 9.04M|static void free_one_scratch(JanetScratch *s) { 18538| 9.04M| if (NULL != s->finalize) { ------------------ | Branch (18538:9): [True: 0, False: 9.04M] ------------------ 18539| 0| s->finalize((char *) s->mem); 18540| 0| } 18541| 9.04M| janet_free(s); ------------------ | | 2415| 9.04M|#define janet_free(X) free((X)) ------------------ 18542| 9.04M|} janet.c:it_s64_tostring: 18838| 434|static void it_s64_tostring(void *p, JanetBuffer *buffer) { 18839| 434| char str[32]; 18840| | snprintf(str, sizeof(str), "%" PRId64, *((int64_t *)p)); 18841| 434| janet_buffer_push_cstring(buffer, str); 18842| 434|} janet.c:janet_int64_compare: 18815| 461|static int janet_int64_compare(void *p1, void *p2) { 18816| 461| int64_t x = *((int64_t *)p1); 18817| 461| int64_t y = *((int64_t *)p2); 18818| 461| return x == y ? 0 : x < y ? -1 : 1; ------------------ | Branch (18818:12): [True: 179, False: 282] | Branch (18818:25): [True: 159, False: 123] ------------------ 18819| 461|} janet.c:janet_int64_hash: 18809| 5.04k|static int32_t janet_int64_hash(void *p1, size_t size) { 18810| 5.04k| (void) size; 18811| 5.04k| int32_t *words = p1; 18812| 5.04k| return words[0] ^ words[1]; 18813| 5.04k|} janet.c:it_u64_tostring: 18844| 420|static void it_u64_tostring(void *p, JanetBuffer *buffer) { 18845| 420| char str[32]; 18846| | snprintf(str, sizeof(str), "%" PRIu64, *((uint64_t *)p)); 18847| 420| janet_buffer_push_cstring(buffer, str); 18848| 420|} janet.c:janet_uint64_compare: 18821| 284|static int janet_uint64_compare(void *p1, void *p2) { 18822| 284| uint64_t x = *((uint64_t *)p1); 18823| 284| uint64_t y = *((uint64_t *)p2); 18824| 284| return x == y ? 0 : x < y ? -1 : 1; ------------------ | Branch (18824:12): [True: 37, False: 247] | Branch (18824:25): [True: 132, False: 115] ------------------ 18825| 284|} janet.c:makef: 19567| 16.9k|static void *makef(FILE *f, int32_t flags, size_t bufsize) { 19568| 16.9k| JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile)); 19569| 16.9k| iof->file = f; 19570| 16.9k| iof->flags = flags; 19571| 16.9k| iof->vbufsize = bufsize; 19572| 16.9k|#if !(defined(JANET_WINDOWS) || defined(JANET_PLAN9)) 19573| | /* While we would like fopen to set cloexec by default (like O_CLOEXEC) with the e flag, that is 19574| | * not standard. */ 19575| 16.9k| if (!(flags & JANET_FILE_NOT_CLOSEABLE)) ------------------ | | 2278| 16.9k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ | Branch (19575:9): [True: 0, False: 16.9k] ------------------ 19576| 0| fcntl(fileno(f), F_SETFD, FD_CLOEXEC); 19577| 16.9k|#endif 19578| 16.9k| return iof; 19579| 16.9k|} janet.c:cfun_io_gc: 19775| 16.9k|static int cfun_io_gc(void *p, size_t len) { 19776| 16.9k| (void) len; 19777| 16.9k| JanetFile *iof = (JanetFile *)p; 19778| 16.9k| janet_file_close(iof); 19779| 16.9k| return 0; 19780| 16.9k|} janet.c:readint: 21059| 383M|static int32_t readint(UnmarshalState *st, const uint8_t **atdata) { 21060| 383M| const uint8_t *data = *atdata; 21061| 383M| int32_t ret; 21062| 383M| MARSH_EOS(st, data); ------------------ | |21054| 383M|#define MARSH_EOS(st, data) do { \ | |21055| 383M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 383M] | | ------------------ | |21056| 383M|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 383M] | | ------------------ ------------------ 21063| 383M| if (*data < 128) { ------------------ | Branch (21063:9): [True: 312M, False: 71.1M] ------------------ 21064| 312M| ret = *data++; 21065| 312M| } else if (*data < 192) { ------------------ | Branch (21065:16): [True: 67.1M, False: 3.98M] ------------------ 21066| 67.1M| MARSH_EOS(st, data + 1); ------------------ | |21054| 67.1M|#define MARSH_EOS(st, data) do { \ | |21055| 67.1M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 67.1M] | | ------------------ | |21056| 67.1M|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 67.1M] | | ------------------ ------------------ 21067| 67.1M| uint32_t uret = ((data[0] & 0x3F) << 8) + data[1]; 21068| | /* Sign extend 18 MSBs */ 21069| 67.1M| uret |= (uret >> 13) ? 0xFFFFC000 : 0; ------------------ | Branch (21069:17): [True: 18.7M, False: 48.3M] ------------------ 21070| 67.1M| ret = (int32_t)uret; 21071| 67.1M| data += 2; 21072| 67.1M| } else if (*data == LB_INTEGER) { ------------------ | Branch (21072:16): [True: 3.98M, False: 0] ------------------ 21073| 3.98M| MARSH_EOS(st, data + 4); ------------------ | |21054| 3.98M|#define MARSH_EOS(st, data) do { \ | |21055| 3.98M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 3.98M] | | ------------------ | |21056| 3.98M|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 3.98M] | | ------------------ ------------------ 21074| 3.98M| uint32_t ui = ((uint32_t)(data[1]) << 24) | 21075| 3.98M| ((uint32_t)(data[2]) << 16) | 21076| 3.98M| ((uint32_t)(data[3]) << 8) | 21077| 3.98M| (uint32_t)(data[4]); 21078| 3.98M| ret = (int32_t)ui; 21079| 3.98M| data += 5; 21080| 3.98M| } else { 21081| 0| janet_panicf("expected integer, got byte %x at index %d", 21082| 0| *data, 21083| 0| data - st->start); 21084| 0| ret = 0; 21085| 0| } 21086| 383M| *atdata = data; 21087| 383M| return ret; 21088| 383M|} janet.c:unmarshal_one: 21668| 102M| int flags) { 21669| 102M| uint8_t lead; 21670| 102M| MARSH_STACKCHECK; ------------------ | |20526| 102M|#define MARSH_STACKCHECK if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) janet_panic("stack overflow") | | ------------------ | | | | 296| 102M|#define JANET_RECURSION_GUARD 1024 | | ------------------ | | | Branch (20526:30): [True: 0, False: 102M] | | ------------------ ------------------ 21671| 102M| MARSH_EOS(st, data); ------------------ | |21054| 102M|#define MARSH_EOS(st, data) do { \ | |21055| 102M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 102M] | | ------------------ | |21056| 102M|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 102M] | | ------------------ ------------------ 21672| 102M| lead = data[0]; 21673| 102M| if (lead < LB_REAL) { ------------------ | Branch (21673:9): [True: 7.81M, False: 94.8M] ------------------ 21674| 7.81M| *out = janet_wrap_integer(readint(st, &data)); ------------------ | | 967| 7.81M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 7.81M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 21675| 7.81M| return data; 21676| 7.81M| } 21677| 94.8M| switch (lead) { 21678| 310k| case LB_NIL: ------------------ | Branch (21678:9): [True: 310k, False: 94.5M] ------------------ 21679| 310k| *out = janet_wrap_nil(); ------------------ | | 831| 310k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 310k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 310k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 310k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21680| 310k| return data + 1; 21681| 0| case LB_FALSE: ------------------ | Branch (21681:9): [True: 0, False: 94.8M] ------------------ 21682| 0| *out = janet_wrap_false(); ------------------ | | 833| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21683| 0| return data + 1; 21684| 751k| case LB_TRUE: ------------------ | Branch (21684:9): [True: 751k, False: 94.1M] ------------------ 21685| 751k| *out = janet_wrap_true(); ------------------ | | 832| 751k|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 751k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 751k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 751k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21686| 751k| return data + 1; 21687| 16.9k| case LB_INTEGER: ------------------ | Branch (21687:9): [True: 16.9k, False: 94.8M] ------------------ 21688| | /* Long integer */ 21689| 16.9k| MARSH_EOS(st, data + 4); ------------------ | |21054| 16.9k|#define MARSH_EOS(st, data) do { \ | |21055| 16.9k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 16.9k] | | ------------------ | |21056| 16.9k|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 16.9k] | | ------------------ ------------------ 21690| 16.9k| uint32_t ui = ((uint32_t)(data[4])) | 21691| 16.9k| ((uint32_t)(data[3]) << 8) | 21692| 16.9k| ((uint32_t)(data[2]) << 16) | 21693| 16.9k| ((uint32_t)(data[1]) << 24); 21694| 16.9k| int32_t si = (int32_t)ui; 21695| 16.9k| *out = janet_wrap_integer(si); ------------------ | | 967| 16.9k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 16.9k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 21696| 16.9k| return data + 5; 21697| 39.5k| case LB_REAL: ------------------ | Branch (21697:9): [True: 39.5k, False: 94.8M] ------------------ 21698| | /* Real */ 21699| 39.5k| { 21700| 39.5k| union { 21701| 39.5k| double d; 21702| 39.5k| uint8_t bytes[8]; 21703| 39.5k| } u; 21704| 39.5k| MARSH_EOS(st, data + 8); ------------------ | |21054| 39.5k|#define MARSH_EOS(st, data) do { \ | |21055| 39.5k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 39.5k] | | ------------------ | |21056| 39.5k|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 39.5k] | | ------------------ ------------------ 21705| |#ifdef JANET_BIG_ENDIAN 21706| | u.bytes[0] = data[8]; 21707| | u.bytes[1] = data[7]; 21708| | u.bytes[2] = data[6]; 21709| | u.bytes[3] = data[5]; 21710| | u.bytes[4] = data[4]; 21711| | u.bytes[5] = data[3]; 21712| | u.bytes[6] = data[2]; 21713| | u.bytes[7] = data[1]; 21714| |#else 21715| 39.5k| memcpy(&u.bytes, data + 1, sizeof(double)); 21716| 39.5k|#endif 21717| 39.5k| *out = janet_wrap_number_safe(u.d); 21718| 39.5k| janet_v_push(st->lookup, *out); ------------------ | | 757| 39.5k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 39.5k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 39.5k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 39.5k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 39.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 39.5k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 39.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 39.5k] | | | | | | | Branch (768:50): [True: 0, False: 39.5k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 39.5k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 39.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21719| 39.5k| return data + 9; 21720| 39.5k| } 21721| 8.35M| case LB_STRING: ------------------ | Branch (21721:9): [True: 8.35M, False: 86.4M] ------------------ 21722| 18.9M| case LB_SYMBOL: ------------------ | Branch (21722:9): [True: 10.5M, False: 84.2M] ------------------ 21723| 18.9M| case LB_BUFFER: ------------------ | Branch (21723:9): [True: 5.65k, False: 94.8M] ------------------ 21724| 20.2M| case LB_KEYWORD: ------------------ | Branch (21724:9): [True: 1.34M, False: 93.5M] ------------------ 21725| 22.2M| case LB_REGISTRY: { ------------------ | Branch (21725:9): [True: 2.00M, False: 92.8M] ------------------ 21726| 22.2M| data++; 21727| 22.2M| int32_t len = readnat(st, &data); 21728| 22.2M| MARSH_EOS(st, data - 1 + len); ------------------ | |21054| 22.2M|#define MARSH_EOS(st, data) do { \ | |21055| 22.2M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 22.2M] | | ------------------ | |21056| 22.2M|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 22.2M] | | ------------------ ------------------ 21729| 22.2M| if (lead == LB_STRING) { ------------------ | Branch (21729:17): [True: 8.35M, False: 13.9M] ------------------ 21730| 8.35M| const uint8_t *str = janet_string(data, len); 21731| 8.35M| *out = janet_wrap_string(str); ------------------ | | 848| 8.35M|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 8.35M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 8.35M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.35M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21732| 13.9M| } else if (lead == LB_SYMBOL) { ------------------ | Branch (21732:24): [True: 10.5M, False: 3.35M] ------------------ 21733| 10.5M| const uint8_t *str = janet_symbol(data, len); 21734| 10.5M| *out = janet_wrap_symbol(str); ------------------ | | 849| 10.5M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 10.5M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 10.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 10.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21735| 10.5M| } else if (lead == LB_KEYWORD) { ------------------ | Branch (21735:24): [True: 1.34M, False: 2.01M] ------------------ 21736| 1.34M| const uint8_t *str = janet_keyword(data, len); ------------------ | | 1840| 1.34M|#define janet_keyword janet_symbol ------------------ 21737| 1.34M| *out = janet_wrap_keyword(str); ------------------ | | 850| 1.34M|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | ------------------ | | | | 828| 1.34M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.34M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.34M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21738| 2.01M| } else if (lead == LB_REGISTRY) { ------------------ | Branch (21738:24): [True: 2.00M, False: 5.65k] ------------------ 21739| 2.00M| if (st->reg) { ------------------ | Branch (21739:21): [True: 2.00M, False: 0] ------------------ 21740| 2.00M| Janet regkey = janet_symbolv(data, len); ------------------ | | 1836| 2.00M|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 2.00M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 2.00M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 2.00M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 2.00M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21741| 2.00M| *out = janet_table_get(st->reg, regkey); 21742| 2.00M| } else { 21743| 0| *out = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21744| 0| } 21745| 2.00M| } else { /* (lead == LB_BUFFER) */ 21746| 5.65k| JanetBuffer *buffer = janet_buffer(len); 21747| 5.65k| buffer->count = len; 21748| 5.65k| safe_memcpy(buffer->data, data, len); 21749| 5.65k| *out = janet_wrap_buffer(buffer); ------------------ | | 847| 5.65k|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 5.65k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 5.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21750| 5.65k| } 21751| 22.2M| janet_v_push(st->lookup, *out); ------------------ | | 757| 22.2M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 22.2M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 22.2M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 22.2M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 22.2M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 22.2M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 22.2M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 22.2M] | | | | | | | Branch (768:50): [True: 67.8k, False: 22.2M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 67.8k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 22.2M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 22.2M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21752| 22.2M| return data + len; 21753| 22.2M| } 21754| 0| case LB_FIBER: { ------------------ | Branch (21754:9): [True: 0, False: 94.8M] ------------------ 21755| 0| JanetFiber *fiber; 21756| 0| data = unmarshal_one_fiber(st, data + 1, &fiber, flags + 1); 21757| 0| *out = janet_wrap_fiber(fiber); ------------------ | | 844| 0|#define janet_wrap_fiber(s) janet_nanbox_wrap_((s), JANET_FIBER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21758| 0| return data; 21759| 22.2M| } 21760| 2.16M| case LB_FUNCTION: { ------------------ | Branch (21760:9): [True: 2.16M, False: 92.6M] ------------------ 21761| 2.16M| JanetFunction *func; 21762| 2.16M| JanetFuncDef *def; 21763| 2.16M| data++; 21764| 2.16M| int32_t len = readnat(st, &data); 21765| 2.16M| if (len > 255) { ------------------ | Branch (21765:17): [True: 0, False: 2.16M] ------------------ 21766| 0| janet_panicf("invalid function - too many environments (%d)", len); 21767| 0| } 21768| 2.16M| func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + 21769| 2.16M| len * sizeof(JanetFuncEnv)); 21770| 2.16M| func->def = NULL; 21771| 2.40M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21771:33): [True: 243k, False: 2.16M] ------------------ 21772| 243k| func->envs[i] = NULL; 21773| 243k| } 21774| 2.16M| *out = janet_wrap_function(func); ------------------ | | 852| 2.16M|#define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION) | | ------------------ | | | | 825| 2.16M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.16M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.16M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21775| 2.16M| janet_v_push(st->lookup, *out); ------------------ | | 757| 2.16M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 2.16M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 2.16M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 2.16M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 2.16M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 2.16M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 2.16M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 2.16M] | | | | | | | Branch (768:50): [True: 0, False: 2.16M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 2.16M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.16M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21776| 2.16M| data = unmarshal_one_def(st, data, &def, flags + 1); 21777| 2.16M| if (def->environments_length != len) { ------------------ | Branch (21777:17): [True: 0, False: 2.16M] ------------------ 21778| 0| janet_panicf("invalid function - env count %d does not match funcdef (%d)", 21779| 0| len, def->environments_length); 21780| 0| } 21781| 2.16M| func->def = def; 21782| 2.40M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21782:33): [True: 243k, False: 2.16M] ------------------ 21783| 243k| data = unmarshal_one_env(st, data, &(func->envs[i]), flags + 1); 21784| 243k| } 21785| 2.16M| return data; 21786| 2.16M| } 21787| 0| case LB_ABSTRACT: { ------------------ | Branch (21787:9): [True: 0, False: 94.8M] ------------------ 21788| 0| data++; 21789| 0| return unmarshal_one_abstract(st, data, out, flags); 21790| 2.16M| } 21791| 60.8M| case LB_REFERENCE: ------------------ | Branch (21791:9): [True: 60.8M, False: 33.9M] ------------------ 21792| 60.8M| case LB_ARRAY: ------------------ | Branch (21792:9): [True: 16.9k, False: 94.8M] ------------------ 21793| 60.8M| case LB_ARRAY_WEAK: ------------------ | Branch (21793:9): [True: 0, False: 94.8M] ------------------ 21794| 65.1M| case LB_TUPLE: ------------------ | Branch (21794:9): [True: 4.25M, False: 90.6M] ------------------ 21795| 65.1M| case LB_STRUCT: ------------------ | Branch (21795:9): [True: 39.5k, False: 94.8M] ------------------ 21796| 65.1M| case LB_STRUCT_PROTO: ------------------ | Branch (21796:9): [True: 0, False: 94.8M] ------------------ 21797| 69.2M| case LB_TABLE: ------------------ | Branch (21797:9): [True: 4.13M, False: 90.7M] ------------------ 21798| 69.2M| case LB_TABLE_PROTO: ------------------ | Branch (21798:9): [True: 0, False: 94.8M] ------------------ 21799| 69.2M| case LB_TABLE_WEAKK: ------------------ | Branch (21799:9): [True: 0, False: 94.8M] ------------------ 21800| 69.2M| case LB_TABLE_WEAKV: ------------------ | Branch (21800:9): [True: 0, False: 94.8M] ------------------ 21801| 69.2M| case LB_TABLE_WEAKKV: ------------------ | Branch (21801:9): [True: 0, False: 94.8M] ------------------ 21802| 69.2M| case LB_TABLE_WEAKK_PROTO: ------------------ | Branch (21802:9): [True: 0, False: 94.8M] ------------------ 21803| 69.2M| case LB_TABLE_WEAKV_PROTO: ------------------ | Branch (21803:9): [True: 0, False: 94.8M] ------------------ 21804| 69.2M| case LB_TABLE_WEAKKV_PROTO: ------------------ | Branch (21804:9): [True: 0, False: 94.8M] ------------------ 21805| | /* Things that open with integers */ 21806| 69.2M| { 21807| 69.2M| data++; 21808| 69.2M| int32_t len = readnat(st, &data); 21809| | /* DOS check */ 21810| 69.2M| if (lead != LB_REFERENCE) { ------------------ | Branch (21810:17): [True: 8.43M, False: 60.8M] ------------------ 21811| 8.43M| MARSH_EOS(st, data - 1 + len); ------------------ | |21054| 8.43M|#define MARSH_EOS(st, data) do { \ | |21055| 8.43M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 8.43M] | | ------------------ | |21056| 8.43M|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 8.43M] | | ------------------ ------------------ 21812| 8.43M| } 21813| 69.2M| if (lead == LB_ARRAY || lead == LB_ARRAY_WEAK) { ------------------ | Branch (21813:17): [True: 16.9k, False: 69.2M] | Branch (21813:37): [True: 0, False: 69.2M] ------------------ 21814| | /* Array */ 21815| 16.9k| JanetArray *array = (lead == LB_ARRAY_WEAK) ? janet_array_weak(len) : janet_array(len); ------------------ | Branch (21815:37): [True: 0, False: 16.9k] ------------------ 21816| 16.9k| array->count = len; 21817| 16.9k| *out = janet_wrap_array(array); ------------------ | | 845| 16.9k|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 16.9k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 16.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 16.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21818| 16.9k| janet_v_push(st->lookup, *out); ------------------ | | 757| 16.9k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 16.9k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 16.9k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 16.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 16.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 16.9k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 16.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 16.9k] | | | | | | | Branch (768:50): [True: 0, False: 16.9k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 16.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 16.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21819| 146k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21819:37): [True: 129k, False: 16.9k] ------------------ 21820| 129k| data = unmarshal_one(st, data, array->data + i, flags + 1); 21821| 129k| } 21822| 69.2M| } else if (lead == LB_TUPLE) { ------------------ | Branch (21822:24): [True: 4.25M, False: 65.0M] ------------------ 21823| | /* Tuple */ 21824| 4.25M| Janet *tup = janet_tuple_begin(len); 21825| 4.25M| int32_t flag = readint(st, &data); 21826| 4.25M| janet_tuple_flag(tup) |= (int32_t)(((uint32_t) flag) << 16); /* Avoid left shift of negative value */ ------------------ | | 1806| 4.25M|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 4.25M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 21827| 16.8M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21827:37): [True: 12.5M, False: 4.25M] ------------------ 21828| 12.5M| data = unmarshal_one(st, data, tup + i, flags + 1); 21829| 12.5M| } 21830| 4.25M| *out = janet_wrap_tuple(janet_tuple_end(tup)); ------------------ | | 843| 4.25M|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 4.25M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 4.25M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.25M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21831| 4.25M| janet_v_push(st->lookup, *out); ------------------ | | 757| 4.25M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 4.25M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 4.25M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 4.25M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 4.25M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 4.25M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 4.25M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 4.25M] | | | | | | | Branch (768:50): [True: 0, False: 4.25M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 4.25M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 4.25M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21832| 65.0M| } else if (lead == LB_STRUCT || lead == LB_STRUCT_PROTO) { ------------------ | Branch (21832:24): [True: 39.5k, False: 64.9M] | Branch (21832:45): [True: 0, False: 64.9M] ------------------ 21833| | /* Struct */ 21834| 39.5k| JanetKV *struct_ = janet_struct_begin(len); 21835| 39.5k| if (lead == LB_STRUCT_PROTO) { ------------------ | Branch (21835:21): [True: 0, False: 39.5k] ------------------ 21836| 0| Janet proto; 21837| 0| data = unmarshal_one(st, data, &proto, flags + 1); 21838| 0| janet_asserttype(proto, JANET_STRUCT, st); 21839| 0| janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 1851| 0|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 857| 0|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 21840| 0| } 21841| 305k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21841:37): [True: 265k, False: 39.5k] ------------------ 21842| 265k| Janet key, value; 21843| 265k| data = unmarshal_one(st, data, &key, flags + 1); 21844| 265k| data = unmarshal_one(st, data, &value, flags + 1); 21845| 265k| janet_struct_put(struct_, key, value); 21846| 265k| } 21847| 39.5k| *out = janet_wrap_struct(janet_struct_end(struct_)); ------------------ | | 842| 39.5k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 39.5k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 39.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 39.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21848| 39.5k| janet_v_push(st->lookup, *out); ------------------ | | 757| 39.5k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 39.5k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 39.5k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 39.5k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 39.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 39.5k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 39.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 39.5k] | | | | | | | Branch (768:50): [True: 0, False: 39.5k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 39.5k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 39.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21849| 64.9M| } else if (lead == LB_REFERENCE) { ------------------ | Branch (21849:24): [True: 60.8M, False: 4.13M] ------------------ 21850| 60.8M| if (len >= janet_v_count(st->lookup)) ------------------ | | 759| 60.8M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 60.8M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 60.8M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 60.8M, False: 0] | | ------------------ ------------------ | Branch (21850:21): [True: 0, False: 60.8M] ------------------ 21851| 0| janet_panicf("invalid reference %d", len); 21852| 60.8M| *out = st->lookup[len]; 21853| 60.8M| } else { 21854| | /* Table */ 21855| 4.13M| JanetTable *t; 21856| 4.13M| if (lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKK) { ------------------ | Branch (21856:21): [True: 0, False: 4.13M] | Branch (21856:53): [True: 0, False: 4.13M] ------------------ 21857| 0| t = janet_table_weakk(len); 21858| 4.13M| } else if (lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKV) { ------------------ | Branch (21858:28): [True: 0, False: 4.13M] | Branch (21858:60): [True: 0, False: 4.13M] ------------------ 21859| 0| t = janet_table_weakv(len); 21860| 4.13M| } else if (lead == LB_TABLE_WEAKKV_PROTO || lead == LB_TABLE_WEAKKV) { ------------------ | Branch (21860:28): [True: 0, False: 4.13M] | Branch (21860:61): [True: 0, False: 4.13M] ------------------ 21861| 0| t = janet_table_weakkv(len); 21862| 4.13M| } else { 21863| 4.13M| t = janet_table(len); 21864| 4.13M| } 21865| 4.13M| *out = janet_wrap_table(t); ------------------ | | 846| 4.13M|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 4.13M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 4.13M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.13M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21866| 4.13M| janet_v_push(st->lookup, *out); ------------------ | | 757| 4.13M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 4.13M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 4.13M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 4.12M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 4.12M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 4.12M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 4.12M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 5.65k, False: 4.12M] | | | | | | | Branch (768:50): [True: 5.65k, False: 4.12M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 11.3k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 4.13M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 4.13M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21867| 4.13M| if (lead == LB_TABLE_PROTO || lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKKV_PROTO) { ------------------ | Branch (21867:21): [True: 0, False: 4.13M] | Branch (21867:47): [True: 0, False: 4.13M] | Branch (21867:79): [True: 0, False: 4.13M] | Branch (21867:111): [True: 0, False: 4.13M] ------------------ 21868| 0| Janet proto; 21869| 0| data = unmarshal_one(st, data, &proto, flags + 1); 21870| 0| janet_asserttype(proto, JANET_TABLE, st); 21871| 0| t->proto = janet_unwrap_table(proto); ------------------ | | 861| 0|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 21872| 0| } 21873| 24.9M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21873:37): [True: 20.8M, False: 4.13M] ------------------ 21874| 20.8M| Janet key, value; 21875| 20.8M| data = unmarshal_one(st, data, &key, flags + 1); 21876| 20.8M| data = unmarshal_one(st, data, &value, flags + 1); 21877| 20.8M| janet_table_put(t, key, value); 21878| 20.8M| } 21879| 4.13M| } 21880| 69.2M| return data; 21881| 69.2M| } 21882| 0| case LB_UNSAFE_POINTER: { ------------------ | Branch (21882:9): [True: 0, False: 94.8M] ------------------ 21883| 0| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21054| 0|#define MARSH_EOS(st, data) do { \ | |21055| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 0] | | ------------------ | |21056| 0|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 0] | | ------------------ ------------------ 21884| 0| data++; 21885| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21885:17): [True: 0, False: 0] ------------------ 21886| 0| janet_panicf("unsafe flag not given, " 21887| 0| "will not unmarshal raw pointer at index %d", 21888| 0| (int)(data - st->start)); 21889| 0| } 21890| 0| union { 21891| 0| void *ptr; 21892| 0| uint8_t bytes[sizeof(void *)]; 21893| 0| } u; 21894| 0| memcpy(u.bytes, data, sizeof(void *)); 21895| 0| data += sizeof(void *); 21896| 0| *out = janet_wrap_pointer(u.ptr); ------------------ | | 854| 0|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21897| 0| janet_v_push(st->lookup, *out); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21898| 0| return data; 21899| 0| } 21900| 0|#ifdef JANET_EV 21901| 0| case LB_POINTER_BUFFER: { ------------------ | Branch (21901:9): [True: 0, False: 94.8M] ------------------ 21902| 0| data++; 21903| 0| int32_t count = readnat(st, &data); 21904| 0| int32_t capacity = readnat(st, &data); 21905| 0| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21054| 0|#define MARSH_EOS(st, data) do { \ | |21055| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 0] | | ------------------ | |21056| 0|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 0] | | ------------------ ------------------ 21906| 0| union { 21907| 0| void *ptr; 21908| 0| uint8_t bytes[sizeof(void *)]; 21909| 0| } u; 21910| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21910:17): [True: 0, False: 0] ------------------ 21911| 0| janet_panicf("unsafe flag not given, " 21912| 0| "will not unmarshal raw pointer at index %d", 21913| 0| (int)(data - st->start)); 21914| 0| } 21915| 0| memcpy(u.bytes, data, sizeof(void *)); 21916| 0| data += sizeof(void *); 21917| 0| JanetBuffer *buffer = janet_pointer_buffer_unsafe(u.ptr, capacity, count); 21918| 0| *out = janet_wrap_buffer(buffer); ------------------ | | 847| 0|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21919| 0| janet_v_push(st->lookup, *out); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21920| 0| return data; 21921| 0| } 21922| 0|#endif 21923| 0| case LB_UNSAFE_CFUNCTION: { ------------------ | Branch (21923:9): [True: 0, False: 94.8M] ------------------ 21924| 0| MARSH_EOS(st, data + sizeof(JanetCFunction)); ------------------ | |21054| 0|#define MARSH_EOS(st, data) do { \ | |21055| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 0] | | ------------------ | |21056| 0|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 0] | | ------------------ ------------------ 21925| 0| data++; 21926| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21926:17): [True: 0, False: 0] ------------------ 21927| 0| janet_panicf("unsafe flag not given, " 21928| 0| "will not unmarshal function pointer at index %d", 21929| 0| (int)(data - st->start)); 21930| 0| } 21931| 0| union { 21932| 0| JanetCFunction ptr; 21933| 0| uint8_t bytes[sizeof(JanetCFunction)]; 21934| 0| } u; 21935| 0| memcpy(u.bytes, data, sizeof(JanetCFunction)); 21936| 0| data += sizeof(JanetCFunction); 21937| 0| *out = janet_wrap_cfunction(u.ptr); ------------------ | | 853| 0|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21938| 0| janet_v_push(st->lookup, *out); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21939| 0| return data; 21940| 0| } 21941| 0|#ifdef JANET_EV 21942| 0| case LB_THREADED_ABSTRACT: { ------------------ | Branch (21942:9): [True: 0, False: 94.8M] ------------------ 21943| 0| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21054| 0|#define MARSH_EOS(st, data) do { \ | |21055| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 0] | | ------------------ | |21056| 0|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 0] | | ------------------ ------------------ 21944| 0| data++; 21945| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21945:17): [True: 0, False: 0] ------------------ 21946| 0| janet_panicf("unsafe flag not given, " 21947| 0| "will not unmarshal threaded abstract pointer at index %d", 21948| 0| (int)(data - st->start)); 21949| 0| } 21950| 0| union { 21951| 0| void *ptr; 21952| 0| uint8_t bytes[sizeof(void *)]; 21953| 0| } u; 21954| 0| memcpy(u.bytes, data, sizeof(void *)); 21955| 0| data += sizeof(void *); 21956| | 21957| 0| if (flags & JANET_MARSHAL_DECREF) { ------------------ | | 387| 0|#define JANET_MARSHAL_DECREF 0x40000 ------------------ | Branch (21957:17): [True: 0, False: 0] ------------------ 21958| | /* Decrement immediately and don't bother putting into heap */ 21959| 0| janet_abstract_decref(u.ptr); 21960| 0| *out = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21961| 0| } else { 21962| 0| *out = janet_wrap_abstract(u.ptr); ------------------ | | 851| 0|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21963| 0| Janet check = janet_table_get(&janet_vm.threaded_abstracts, *out); 21964| 0| if (janet_checktype(check, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21965| | /* Transfers reference from threaded channel buffer to current heap */ 21966| 0| janet_table_put(&janet_vm.threaded_abstracts, *out, janet_wrap_false()); ------------------ | | 833| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21967| 0| } else { 21968| | /* Heap reference already accounted for, remove threaded channel reference. */ 21969| 0| janet_abstract_decref(u.ptr); 21970| 0| } 21971| 0| } 21972| | 21973| 0| janet_v_push(st->lookup, *out); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21974| 0| return data; 21975| 0| } 21976| 0|#endif 21977| 0| default: { ------------------ | Branch (21977:9): [True: 0, False: 94.8M] ------------------ 21978| 0| janet_panicf("unknown byte %x at index %d", 21979| 0| *data, 21980| 0| (int)(data - st->start)); 21981| 0| return NULL; 21982| 0| } 21983| 94.8M| } 21984| 94.8M|} janet.c:readnat: 21091| 118M|static int32_t readnat(UnmarshalState *st, const uint8_t **atdata) { 21092| 118M| int32_t ret = readint(st, atdata); 21093| 118M| if (ret < 0) { ------------------ | Branch (21093:9): [True: 0, False: 118M] ------------------ 21094| 0| janet_panicf("expected integer >= 0, got %d", ret); 21095| 0| } 21096| 118M| return ret; 21097| 118M|} janet.c:unmarshal_one_def: 21230| 3.04M| int flags) { 21231| 3.04M| MARSH_EOS(st, data); ------------------ | |21054| 3.04M|#define MARSH_EOS(st, data) do { \ | |21055| 3.04M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 3.04M] | | ------------------ | |21056| 3.04M|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 3.04M] | | ------------------ ------------------ 21232| 3.04M| if (*data == LB_FUNCDEF_REF) { ------------------ | Branch (21232:9): [True: 22.6k, False: 3.02M] ------------------ 21233| 22.6k| data++; 21234| 22.6k| int32_t index = readint(st, &data); 21235| 22.6k| if (index < 0 || index >= janet_v_count(st->lookup_defs)) ------------------ | | 759| 22.6k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 22.6k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 22.6k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 22.6k, False: 0] | | ------------------ ------------------ | Branch (21235:13): [True: 0, False: 22.6k] | Branch (21235:26): [True: 0, False: 22.6k] ------------------ 21236| 0| janet_panicf("invalid funcdef reference %d", index); 21237| 22.6k| *out = st->lookup_defs[index]; 21238| 3.02M| } else { 21239| | /* Initialize with values that will not break garbage collection 21240| | * if unmarshalling fails. */ 21241| 3.02M| JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); 21242| 3.02M| def->environments_length = 0; 21243| 3.02M| def->defs_length = 0; 21244| 3.02M| def->constants_length = 0; 21245| 3.02M| def->bytecode_length = 0; 21246| 3.02M| def->name = NULL; 21247| 3.02M| def->source = NULL; 21248| 3.02M| def->closure_bitset = NULL; 21249| 3.02M| def->defs = NULL; 21250| 3.02M| def->environments = NULL; 21251| 3.02M| def->constants = NULL; 21252| 3.02M| def->bytecode = NULL; 21253| 3.02M| def->sourcemap = NULL; 21254| 3.02M| def->symbolmap = NULL; 21255| 3.02M| def->symbolmap_length = 0; 21256| 3.02M| def->named_args_count = 0; 21257| 3.02M| janet_v_push(st->lookup_defs, def); ------------------ | | 757| 3.02M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 3.02M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 3.02M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 3.01M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 3.01M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 3.01M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 3.01M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 5.65k, False: 3.01M] | | | | | | | Branch (768:50): [True: 56.5k, False: 2.96M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 62.1k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 3.02M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.02M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21258| | 21259| | /* Set default lengths to zero */ 21260| 3.02M| int32_t bytecode_length = 0; 21261| 3.02M| int32_t constants_length = 0; 21262| 3.02M| int32_t environments_length = 0; 21263| 3.02M| int32_t defs_length = 0; 21264| 3.02M| int32_t symbolmap_length = 0; 21265| | 21266| | /* Read flags and other fixed values */ 21267| 3.02M| def->flags = readint(st, &data); 21268| 3.02M| def->slotcount = readnat(st, &data); 21269| 3.02M| def->arity = readnat(st, &data); 21270| 3.02M| def->min_arity = readnat(st, &data); 21271| 3.02M| def->max_arity = readnat(st, &data); 21272| | 21273| | /* Read some lengths */ 21274| 3.02M| constants_length = readnat(st, &data); 21275| 3.02M| bytecode_length = readnat(st, &data); 21276| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS) ------------------ | | 1107| 3.02M|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (21276:13): [True: 11.3k, False: 3.01M] ------------------ 21277| 11.3k| def->named_args_count = readnat(st, &data); 21278| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) ------------------ | | 1103| 3.02M|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (21278:13): [True: 2.83M, False: 186k] ------------------ 21279| 2.83M| environments_length = readnat(st, &data); 21280| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) ------------------ | | 1102| 3.02M|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (21280:13): [True: 395k, False: 2.62M] ------------------ 21281| 395k| defs_length = readnat(st, &data); 21282| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) ------------------ | | 1099| 3.02M|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (21282:13): [True: 2.79M, False: 226k] ------------------ 21283| 2.79M| symbolmap_length = readnat(st, &data); 21284| | 21285| | /* Check name and source (optional) */ 21286| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) { ------------------ | | 1100| 3.02M|#define JANET_FUNCDEF_FLAG_HASNAME 0x80000 ------------------ | Branch (21286:13): [True: 2.83M, False: 192k] ------------------ 21287| 2.83M| Janet x; 21288| 2.83M| data = unmarshal_one(st, data, &x, flags + 1); 21289| 2.83M| janet_asserttype(x, JANET_STRING, st); 21290| 2.83M| def->name = janet_unwrap_string(x); ------------------ | | 863| 2.83M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 21291| 2.83M| } 21292| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) { ------------------ | | 1101| 3.02M|#define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000 ------------------ | Branch (21292:13): [True: 2.83M, False: 186k] ------------------ 21293| 2.83M| Janet x; 21294| 2.83M| data = unmarshal_one(st, data, &x, flags + 1); 21295| 2.83M| janet_asserttype(x, JANET_STRING, st); 21296| 2.83M| def->source = janet_unwrap_string(x); ------------------ | | 863| 2.83M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 21297| 2.83M| } 21298| | 21299| | /* Unmarshal constants */ 21300| 3.02M| if (constants_length) { ------------------ | Branch (21300:13): [True: 2.30M, False: 717k] ------------------ 21301| 2.30M| def->constants = array_allocate(sizeof(Janet), constants_length); 21302| 2.30M| if (!def->constants) { ------------------ | Branch (21302:17): [True: 0, False: 2.30M] ------------------ 21303| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21304| 0| } 21305| 15.1M| for (int32_t i = 0; i < constants_length; i++) ------------------ | Branch (21305:33): [True: 12.8M, False: 2.30M] ------------------ 21306| 12.8M| data = unmarshal_one(st, data, def->constants + i, flags + 1); 21307| 2.30M| } else { 21308| 717k| def->constants = NULL; 21309| 717k| } 21310| 3.02M| def->constants_length = constants_length; 21311| | 21312| | /* Unmarshal symbol map, if needed */ 21313| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) { ------------------ | | 1099| 3.02M|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (21313:13): [True: 2.79M, False: 226k] ------------------ 21314| 2.79M| def->symbolmap = array_allocate(sizeof(JanetSymbolMap), symbolmap_length); 21315| 2.79M| if (def->symbolmap == NULL) { ------------------ | Branch (21315:17): [True: 0, False: 2.79M] ------------------ 21316| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21317| 0| } 21318| 31.5M| for (int32_t i = 0; i < symbolmap_length; i++) { ------------------ | Branch (21318:33): [True: 28.7M, False: 2.79M] ------------------ 21319| 28.7M| def->symbolmap[i].birth_pc = (uint32_t) readint(st, &data); 21320| 28.7M| def->symbolmap[i].death_pc = (uint32_t) readint(st, &data); 21321| 28.7M| def->symbolmap[i].slot_index = (uint32_t) readint(st, &data); 21322| 28.7M| Janet value; 21323| 28.7M| data = unmarshal_one(st, data, &value, flags + 1); 21324| 28.7M| if (!janet_checktype(value, JANET_SYMBOL)) { ------------------ | | 806| 28.7M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 28.7M] | | ------------------ | | 807| 28.7M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 28.7M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 28.7M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 28.7M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 28.7M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 28.7M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (21324:21): [True: 0, False: 28.7M] ------------------ 21325| 0| janet_panicf("corrupted symbolmap when unmarshalling debug info, got %v", value); 21326| 0| } 21327| 28.7M| def->symbolmap[i].symbol = janet_unwrap_symbol(value); ------------------ | | 864| 28.7M|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 21328| 28.7M| } 21329| 2.79M| def->symbolmap_length = (uint32_t) symbolmap_length; 21330| 2.79M| } 21331| | 21332| | /* Unmarshal bytecode */ 21333| 3.02M| def->bytecode = array_allocate(sizeof(uint32_t), bytecode_length); 21334| 3.02M| if (!def->bytecode) { ------------------ | Branch (21334:13): [True: 0, False: 3.02M] ------------------ 21335| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21336| 0| } 21337| 3.02M| data = janet_unmarshal_u32s(st, data, def->bytecode, bytecode_length); 21338| 3.02M| def->bytecode_length = bytecode_length; 21339| | 21340| | /* Unmarshal environments */ 21341| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) { ------------------ | | 1103| 3.02M|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (21341:13): [True: 2.83M, False: 186k] ------------------ 21342| 2.83M| def->environments = janet_calloc(1, sizeof(int32_t) * (size_t) environments_length); ------------------ | | 2412| 2.83M|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 21343| 2.83M| if (!def->environments) { ------------------ | Branch (21343:17): [True: 0, False: 2.83M] ------------------ 21344| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21345| 0| } 21346| 3.95M| for (int32_t i = 0; i < environments_length; i++) { ------------------ | Branch (21346:33): [True: 1.11M, False: 2.83M] ------------------ 21347| 1.11M| def->environments[i] = readint(st, &data); 21348| 1.11M| } 21349| 2.83M| } else { 21350| 186k| def->environments = NULL; 21351| 186k| } 21352| 3.02M| def->environments_length = environments_length; 21353| | 21354| | /* Unmarshal sub funcdefs */ 21355| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) { ------------------ | | 1102| 3.02M|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (21355:13): [True: 395k, False: 2.62M] ------------------ 21356| 395k| def->defs = janet_calloc(1, sizeof(JanetFuncDef *) * (size_t) defs_length); ------------------ | | 2412| 395k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 21357| 395k| if (!def->defs) { ------------------ | Branch (21357:17): [True: 0, False: 395k] ------------------ 21358| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21359| 0| } 21360| 1.27M| for (int32_t i = 0; i < defs_length; i++) { ------------------ | Branch (21360:33): [True: 881k, False: 395k] ------------------ 21361| 881k| data = unmarshal_one_def(st, data, def->defs + i, flags + 1); 21362| 881k| } 21363| 2.62M| } else { 21364| 2.62M| def->defs = NULL; 21365| 2.62M| } 21366| 3.02M| def->defs_length = defs_length; 21367| | 21368| | /* Unmarshal source maps if needed */ 21369| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCEMAP) { ------------------ | | 1104| 3.02M|#define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000 ------------------ | Branch (21369:13): [True: 2.83M, False: 186k] ------------------ 21370| 2.83M| int32_t current = 0; 21371| 2.83M| def->sourcemap = array_allocate(sizeof(JanetSourceMapping), bytecode_length); 21372| 2.83M| if (!def->sourcemap) { ------------------ | Branch (21372:17): [True: 0, False: 2.83M] ------------------ 21373| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21374| 0| } 21375| 84.1M| for (int32_t i = 0; i < bytecode_length; i++) { ------------------ | Branch (21375:33): [True: 81.3M, False: 2.83M] ------------------ 21376| 81.3M| current += readint(st, &data); 21377| 81.3M| def->sourcemap[i].line = current; 21378| 81.3M| def->sourcemap[i].column = readint(st, &data); 21379| 81.3M| } 21380| 2.83M| } else { 21381| 186k| def->sourcemap = NULL; 21382| 186k| } 21383| | 21384| | /* Unmarshal closure bitset if needed */ 21385| 3.02M| if (def->flags & JANET_FUNCDEF_FLAG_HASCLOBITSET) { ------------------ | | 1106| 3.02M|#define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000 ------------------ | Branch (21385:13): [True: 333k, False: 2.69M] ------------------ 21386| 333k| int32_t n = ((def->slotcount - 1) >> 5) + 1; 21387| 333k| def->closure_bitset = array_allocate(sizeof(uint32_t), n); 21388| 333k| if (NULL == def->closure_bitset) { ------------------ | Branch (21388:17): [True: 0, False: 333k] ------------------ 21389| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21390| 0| } 21391| 333k| data = janet_unmarshal_u32s(st, data, def->closure_bitset, n); 21392| 333k| } 21393| | 21394| | /* Validate */ 21395| 3.02M| int status; 21396| 3.02M| if ((status = janet_verify(def))) { ------------------ | Branch (21396:13): [True: 0, False: 3.02M] ------------------ 21397| 0| janet_panicf("funcdef has invalid bytecode: %d", status); 21398| 0| } 21399| | 21400| | /* Set def */ 21401| 3.02M| *out = def; 21402| 3.02M| } 21403| 3.04M| return data; 21404| 3.04M|} janet.c:janet_unmarshal_u32s: 21212| 3.35M|static const uint8_t *janet_unmarshal_u32s(UnmarshalState *st, const uint8_t *data, uint32_t *into, int32_t n) { 21213| 87.2M| for (int32_t i = 0; i < n; i++) { ------------------ | Branch (21213:25): [True: 83.9M, False: 3.35M] ------------------ 21214| 83.9M| MARSH_EOS(st, data + 3); ------------------ | |21054| 83.9M|#define MARSH_EOS(st, data) do { \ | |21055| 83.9M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 83.9M] | | ------------------ | |21056| 83.9M|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 83.9M] | | ------------------ ------------------ 21215| 83.9M| into[i] = 21216| 83.9M| (uint32_t)(data[0]) | 21217| 83.9M| ((uint32_t)(data[1]) << 8) | 21218| 83.9M| ((uint32_t)(data[2]) << 16) | 21219| 83.9M| ((uint32_t)(data[3]) << 24); 21220| 83.9M| data += 4; 21221| 83.9M| } 21222| 3.35M| return data; 21223| 3.35M|} janet.c:unmarshal_one_env: 21168| 243k| int flags) { 21169| 243k| MARSH_EOS(st, data); ------------------ | |21054| 243k|#define MARSH_EOS(st, data) do { \ | |21055| 243k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21055:9): [True: 0, False: 243k] | | ------------------ | |21056| 243k|} while (0) | | ------------------ | | | Branch (21056:10): [Folded, False: 243k] | | ------------------ ------------------ 21170| 243k| if (*data == LB_FUNCENV_REF) { ------------------ | Branch (21170:9): [True: 197k, False: 45.2k] ------------------ 21171| 197k| data++; 21172| 197k| int32_t index = readint(st, &data); 21173| 197k| if (index < 0 || index >= janet_v_count(st->lookup_envs)) ------------------ | | 759| 197k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 197k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 197k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 197k, False: 0] | | ------------------ ------------------ | Branch (21173:13): [True: 0, False: 197k] | Branch (21173:26): [True: 0, False: 197k] ------------------ 21174| 0| janet_panicf("invalid funcenv reference %d", index); 21175| 197k| *out = st->lookup_envs[index]; 21176| 197k| } else { 21177| 45.2k| JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); 21178| 45.2k| env->length = 0; 21179| 45.2k| env->offset = 0; 21180| 45.2k| env->as.values = NULL; 21181| 45.2k| janet_v_push(st->lookup_envs, env); ------------------ | | 757| 45.2k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 45.2k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 45.2k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 39.5k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 39.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 39.5k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 39.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 5.65k, False: 39.5k] | | | | | | | Branch (768:50): [True: 22.6k, False: 16.9k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 28.2k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 45.2k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 45.2k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21182| 45.2k| int32_t offset = readnat(st, &data); 21183| 45.2k| int32_t length = readnat(st, &data); 21184| 45.2k| if (offset > 0) { ------------------ | Branch (21184:13): [True: 0, False: 45.2k] ------------------ 21185| 0| Janet fiberv; 21186| | /* On stack variant */ 21187| 0| data = unmarshal_one(st, data, &fiberv, flags); 21188| 0| janet_asserttype(fiberv, JANET_FIBER, st); 21189| 0| env->as.fiber = janet_unwrap_fiber(fiberv); ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 21190| | /* Negative offset indicates untrusted input */ 21191| 0| env->offset = -offset; 21192| 45.2k| } else { 21193| | /* Off stack variant */ 21194| 45.2k| if (length == 0) { ------------------ | Branch (21194:17): [True: 0, False: 45.2k] ------------------ 21195| 0| janet_panic("invalid funcenv length"); 21196| 0| } 21197| 45.2k| env->as.values = array_allocate(sizeof(Janet), length); 21198| 45.2k| if (!env->as.values) { ------------------ | Branch (21198:17): [True: 0, False: 45.2k] ------------------ 21199| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21200| 0| } 21201| 45.2k| env->offset = 0; 21202| 559k| for (int32_t i = 0; i < length; i++) ------------------ | Branch (21202:33): [True: 514k, False: 45.2k] ------------------ 21203| 514k| data = unmarshal_one(st, data, env->as.values + i, flags); 21204| 45.2k| } 21205| 45.2k| env->length = length; 21206| 45.2k| *out = env; 21207| 45.2k| } 21208| 243k| return data; 21209| 243k|} janet.c:janet_asserttype: 21130| 5.66M|static void janet_asserttype(Janet x, JanetType t, UnmarshalState *st) { 21131| 5.66M| if (!janet_checktype(x, t)) { ------------------ | | 806| 5.66M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [True: 0, False: 5.66M] | | ------------------ | | 807| 5.66M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 5.66M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.66M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.66M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.66M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.66M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (21131:9): [True: 0, False: 5.66M] ------------------ 21132| |#ifdef JANET_MARSHAL_DEBUG 21133| | dump_reference_table(st); 21134| |#else 21135| 0| (void) st; 21136| 0|#endif 21137| 0| janet_panicf("expected type %T, got %v", 1 << t, x); 21138| 0| } 21139| 5.66M|} janet.c:janet_parser_checkdead: 27652| 262k|static void janet_parser_checkdead(JanetParser *parser) { 27653| 262k| if (parser->flag) janet_panic("parser is dead, cannot consume"); ------------------ | Branch (27653:9): [True: 0, False: 262k] ------------------ 27654| 262k| if (parser->error) janet_panic("parser has unchecked error, cannot consume"); ------------------ | Branch (27654:9): [True: 0, False: 262k] ------------------ 27655| 262k|} janet.c:delim_error: 27162| 1.49k|static void delim_error(JanetParser *parser, size_t stack_index, char c, const char *msg) { 27163| 1.49k| JanetParseState *s = parser->states + stack_index; 27164| 1.49k| JanetBuffer *buffer = janet_buffer(40); 27165| 1.49k| if (msg) { ------------------ | Branch (27165:9): [True: 1.49k, False: 0] ------------------ 27166| 1.49k| janet_buffer_push_cstring(buffer, msg); 27167| 1.49k| } 27168| 1.49k| if (c) { ------------------ | Branch (27168:9): [True: 103, False: 1.38k] ------------------ 27169| 103| janet_buffer_push_u8(buffer, c); 27170| 103| } 27171| 1.49k| if (stack_index > 0) { ------------------ | Branch (27171:9): [True: 1.41k, False: 77] ------------------ 27172| 1.41k| janet_buffer_push_cstring(buffer, ", "); 27173| 1.41k| if (s->flags & PFLAG_PARENS) { ------------------ | |27098| 1.41k|#define PFLAG_PARENS 0x400 ------------------ | Branch (27173:13): [True: 102, False: 1.31k] ------------------ 27174| 102| janet_buffer_push_u8(buffer, '('); 27175| 1.31k| } else if (s->flags & PFLAG_SQRBRACKETS) { ------------------ | |27099| 1.31k|#define PFLAG_SQRBRACKETS 0x800 ------------------ | Branch (27175:20): [True: 73, False: 1.24k] ------------------ 27176| 73| janet_buffer_push_u8(buffer, '['); 27177| 1.24k| } else if (s->flags & PFLAG_CURLYBRACKETS) { ------------------ | |27100| 1.24k|#define PFLAG_CURLYBRACKETS 0x1000 ------------------ | Branch (27177:20): [True: 112, False: 1.12k] ------------------ 27178| 112| janet_buffer_push_u8(buffer, '{'); 27179| 1.12k| } else if (s->flags & PFLAG_STRING) { ------------------ | |27101| 1.12k|#define PFLAG_STRING 0x2000 ------------------ | Branch (27179:20): [True: 380, False: 748] ------------------ 27180| 380| janet_buffer_push_u8(buffer, '"'); 27181| 748| } else if (s->flags & PFLAG_LONGSTRING) { ------------------ | |27102| 748|#define PFLAG_LONGSTRING 0x4000 ------------------ | Branch (27181:20): [True: 172, False: 576] ------------------ 27182| 172| int32_t i; 27183| 2.38k| for (i = 0; i < s->argn; i++) { ------------------ | Branch (27183:25): [True: 2.20k, False: 172] ------------------ 27184| 2.20k| janet_buffer_push_u8(buffer, '`'); 27185| 2.20k| } 27186| 172| } 27187| 1.41k| janet_formatb(buffer, " opened at line %d, column %d", (int32_t) s->line, (int32_t) s->column); 27188| 1.41k| } 27189| 1.49k| parser->error = (const char *) janet_string(buffer->data, buffer->count); 27190| 1.49k| parser->flag |= JANET_PARSER_GENERATED_ERROR; ------------------ | |26992| 1.49k|#define JANET_PARSER_GENERATED_ERROR 0x2 ------------------ 27191| 1.49k|} janet.c:pushstate: 27108| 101k|static void pushstate(JanetParser *p, Consumer consumer, int flags) { 27109| 101k| JanetParseState s; 27110| 101k| s.counter = 0; 27111| 101k| s.argn = 0; 27112| 101k| s.flags = flags; 27113| 101k| s.consumer = consumer; 27114| 101k| s.line = p->line; 27115| 101k| s.column = p->column; 27116| 101k| _pushstate(p, s); 27117| 101k|} janet.c:root: 27579| 136k|static int root(JanetParser *p, JanetParseState *state, uint8_t c) { 27580| 136k| switch (c) { 27581| 62.2k| default: ------------------ | Branch (27581:9): [True: 62.2k, False: 74.2k] ------------------ 27582| 62.2k| if (is_whitespace(c)) return 1; ------------------ | Branch (27582:17): [True: 31.4k, False: 30.8k] ------------------ 27583| 30.8k| if (!janet_is_symbol_char(c)) { ------------------ | Branch (27583:17): [True: 179, False: 30.6k] ------------------ 27584| 179| p->error = "unexpected character"; 27585| 179| return 1; 27586| 179| } 27587| 30.6k| pushstate(p, tokenchar, PFLAG_TOKEN); ------------------ | |27106| 30.6k|#define PFLAG_TOKEN 0x40000 ------------------ 27588| 30.6k| return 0; 27589| 14.8k| case '\'': ------------------ | Branch (27589:9): [True: 14.8k, False: 121k] ------------------ 27590| 22.0k| case ',': ------------------ | Branch (27590:9): [True: 7.19k, False: 129k] ------------------ 27591| 26.9k| case ';': ------------------ | Branch (27591:9): [True: 4.92k, False: 131k] ------------------ 27592| 35.2k| case '~': ------------------ | Branch (27592:9): [True: 8.26k, False: 128k] ------------------ 27593| 41.4k| case '|': ------------------ | Branch (27593:9): [True: 6.19k, False: 130k] ------------------ 27594| 41.4k| pushstate(p, root, PFLAG_READERMAC | c); ------------------ | |27103| 41.4k|#define PFLAG_READERMAC 0x8000 ------------------ 27595| 41.4k| return 1; 27596| 5.54k| case '"': ------------------ | Branch (27596:9): [True: 5.54k, False: 130k] ------------------ 27597| 5.54k| pushstate(p, stringchar, PFLAG_STRING); ------------------ | |27101| 5.54k|#define PFLAG_STRING 0x2000 ------------------ 27598| 5.54k| return 1; 27599| 288| case '#': ------------------ | Branch (27599:9): [True: 288, False: 136k] ------------------ 27600| 288| pushstate(p, comment, PFLAG_COMMENT); ------------------ | |27105| 288|#define PFLAG_COMMENT 0x20000 ------------------ 27601| 288| return 1; 27602| 2.33k| case '@': ------------------ | Branch (27602:9): [True: 2.33k, False: 134k] ------------------ 27603| 2.33k| pushstate(p, atsign, PFLAG_ATSYM); ------------------ | |27104| 2.33k|#define PFLAG_ATSYM 0x10000 ------------------ 27604| 2.33k| return 1; 27605| 1.26k| case '`': ------------------ | Branch (27605:9): [True: 1.26k, False: 135k] ------------------ 27606| 1.26k| pushstate(p, longstring, PFLAG_LONGSTRING); ------------------ | |27102| 1.26k|#define PFLAG_LONGSTRING 0x4000 ------------------ 27607| 1.26k| return 1; 27608| 3.25k| case ')': ------------------ | Branch (27608:9): [True: 3.25k, False: 133k] ------------------ 27609| 3.99k| case ']': ------------------ | Branch (27609:9): [True: 739, False: 135k] ------------------ 27610| 10.9k| case '}': { ------------------ | Branch (27610:9): [True: 6.95k, False: 129k] ------------------ 27611| 10.9k| Janet ds; 27612| 10.9k| if (p->statecount == 1) { ------------------ | Branch (27612:17): [True: 77, False: 10.8k] ------------------ 27613| 77| delim_error(p, 0, c, "unexpected closing delimiter "); 27614| 77| return 1; 27615| 77| } 27616| 10.8k| if ((c == ')' && (state->flags & PFLAG_PARENS)) || ------------------ | |27098| 3.23k|#define PFLAG_PARENS 0x400 ------------------ | Branch (27616:18): [True: 3.23k, False: 7.63k] | Branch (27616:30): [True: 3.21k, False: 15] ------------------ 27617| 7.65k| (c == ']' && (state->flags & PFLAG_SQRBRACKETS))) { ------------------ | |27099| 726|#define PFLAG_SQRBRACKETS 0x800 ------------------ | Branch (27617:22): [True: 726, False: 6.92k] | Branch (27617:34): [True: 724, False: 2] ------------------ 27618| 3.94k| if (state->flags & PFLAG_ATSYM) { ------------------ | |27104| 3.94k|#define PFLAG_ATSYM 0x10000 ------------------ | Branch (27618:21): [True: 581, False: 3.36k] ------------------ 27619| 581| ds = close_array(p, state); 27620| 3.36k| } else { 27621| 3.36k| ds = close_tuple(p, state, c == ']' ? JANET_TUPLE_FLAG_BRACKETCTOR : 0); ------------------ | | 1798| 555|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (27621:48): [True: 555, False: 2.80k] ------------------ 27622| 3.36k| } 27623| 6.92k| } else if (c == '}' && (state->flags & PFLAG_CURLYBRACKETS)) { ------------------ | |27100| 6.90k|#define PFLAG_CURLYBRACKETS 0x1000 ------------------ | Branch (27623:24): [True: 6.90k, False: 17] | Branch (27623:36): [True: 6.90k, False: 9] ------------------ 27624| 6.90k| if (state->argn & 1) { ------------------ | Branch (27624:21): [True: 24, False: 6.87k] ------------------ 27625| 24| p->error = "struct and table literals expect even number of arguments"; 27626| 24| return 1; 27627| 24| } 27628| 6.87k| if (state->flags & PFLAG_ATSYM) { ------------------ | |27104| 6.87k|#define PFLAG_ATSYM 0x10000 ------------------ | Branch (27628:21): [True: 467, False: 6.40k] ------------------ 27629| 467| ds = close_table(p, state); 27630| 6.40k| } else { 27631| 6.40k| ds = close_struct(p, state); 27632| 6.40k| } 27633| 6.87k| } else { 27634| 26| delim_error(p, p->statecount - 1, c, "mismatched delimiter "); 27635| 26| return 1; 27636| 26| } 27637| 10.8k| popstate(p, ds); 27638| 10.8k| } 27639| 0| return 1; 27640| 3.89k| case '(': ------------------ | Branch (27640:9): [True: 3.89k, False: 132k] ------------------ 27641| 3.89k| pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS); ------------------ | |27096| 3.89k|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS); ------------------ | |27098| 3.89k|#define PFLAG_PARENS 0x400 ------------------ 27642| 3.89k| return 1; 27643| 1.18k| case '[': ------------------ | Branch (27643:9): [True: 1.18k, False: 135k] ------------------ 27644| 1.18k| pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS); ------------------ | |27096| 1.18k|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS); ------------------ | |27099| 1.18k|#define PFLAG_SQRBRACKETS 0x800 ------------------ 27645| 1.18k| return 1; 27646| 7.38k| case '{': ------------------ | Branch (27646:9): [True: 7.38k, False: 129k] ------------------ 27647| 7.38k| pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS); ------------------ | |27096| 7.38k|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS); ------------------ | |27100| 7.38k|#define PFLAG_CURLYBRACKETS 0x1000 ------------------ 27648| 7.38k| return 1; 27649| 136k| } 27650| 136k|} janet.c:is_whitespace: 26995| 62.2k|static int is_whitespace(uint8_t c) { 26996| 62.2k| return c == ' ' ------------------ | Branch (26996:12): [True: 1.68k, False: 60.5k] ------------------ 26997| 60.5k| || c == '\t' ------------------ | Branch (26997:15): [True: 584, False: 59.9k] ------------------ 26998| 59.9k| || c == '\n' ------------------ | Branch (26998:15): [True: 5.62k, False: 54.3k] ------------------ 26999| 54.3k| || c == '\r' ------------------ | Branch (26999:15): [True: 1.01k, False: 53.3k] ------------------ 27000| 53.3k| || c == '\0' ------------------ | Branch (27000:15): [True: 21.5k, False: 31.7k] ------------------ 27001| 31.7k| || c == '\v' ------------------ | Branch (27001:15): [True: 594, False: 31.1k] ------------------ 27002| 31.1k| || c == '\f'; ------------------ | Branch (27002:15): [True: 391, False: 30.8k] ------------------ 27003| 62.2k|} janet.c:stringchar: 27374| 24.4k|static int stringchar(JanetParser *p, JanetParseState *state, uint8_t c) { 27375| | /* Enter escape */ 27376| 24.4k| if (c == '\\') { ------------------ | Branch (27376:9): [True: 2.08k, False: 22.3k] ------------------ 27377| 2.08k| state->consumer = escape1; 27378| 2.08k| return 1; 27379| 2.08k| } 27380| | /* String end */ 27381| 22.3k| if (c == '"') { ------------------ | Branch (27381:9): [True: 5.43k, False: 16.9k] ------------------ 27382| 5.43k| return stringend(p, state); 27383| 5.43k| } 27384| | /* normal char */ 27385| 16.9k| if (c != '\n' && c != '\r') ------------------ | Branch (27385:9): [True: 16.2k, False: 645] | Branch (27385:22): [True: 15.9k, False: 298] ------------------ 27386| 15.9k| push_buf(p, c); 27387| 16.9k| return 1; 27388| 22.3k|} janet.c:escape1: 27289| 2.08k|static int escape1(JanetParser *p, JanetParseState *state, uint8_t c) { 27290| 2.08k| int e = checkescape(c); 27291| 2.08k| if (e < 0) { ------------------ | Branch (27291:9): [True: 38, False: 2.05k] ------------------ 27292| 38| p->error = "invalid string escape sequence"; 27293| 38| return 1; 27294| 38| } 27295| 2.05k| if (c == 'x') { ------------------ | Branch (27295:9): [True: 230, False: 1.82k] ------------------ 27296| 230| state->counter = 2; 27297| 230| state->argn = 0; 27298| 230| state->consumer = escapeh; 27299| 1.82k| } else if (c == 'u' || c == 'U') { ------------------ | Branch (27299:16): [True: 283, False: 1.53k] | Branch (27299:28): [True: 208, False: 1.33k] ------------------ 27300| 491| state->counter = c == 'u' ? 4 : 6; ------------------ | Branch (27300:26): [True: 283, False: 208] ------------------ 27301| 491| state->argn = 0; 27302| 491| state->consumer = escapeu; 27303| 1.33k| } else { 27304| 1.33k| push_buf(p, (uint8_t) e); 27305| 1.33k| state->consumer = stringchar; 27306| 1.33k| } 27307| 2.05k| return 1; 27308| 2.08k|} janet.c:checkescape: 27193| 2.08k|static int checkescape(uint8_t c) { 27194| 2.08k| switch (c) { 27195| 38| default: ------------------ | Branch (27195:9): [True: 38, False: 2.05k] ------------------ 27196| 38| return -1; 27197| 230| case 'x': ------------------ | Branch (27197:9): [True: 230, False: 1.85k] ------------------ 27198| 513| case 'u': ------------------ | Branch (27198:9): [True: 283, False: 1.80k] ------------------ 27199| 721| case 'U': ------------------ | Branch (27199:9): [True: 208, False: 1.88k] ------------------ 27200| 721| return 1; 27201| 78| case 'n': ------------------ | Branch (27201:9): [True: 78, False: 2.01k] ------------------ 27202| 78| return '\n'; 27203| 73| case 't': ------------------ | Branch (27203:9): [True: 73, False: 2.01k] ------------------ 27204| 73| return '\t'; 27205| 38| case 'r': ------------------ | Branch (27205:9): [True: 38, False: 2.05k] ------------------ 27206| 38| return '\r'; 27207| 43| case '0': ------------------ | Branch (27207:9): [True: 43, False: 2.04k] ------------------ 27208| 43| return '\0'; 27209| 40| case 'z': ------------------ | Branch (27209:9): [True: 40, False: 2.04k] ------------------ 27210| 40| return '\0'; 27211| 73| case 'f': ------------------ | Branch (27211:9): [True: 73, False: 2.01k] ------------------ 27212| 73| return '\f'; 27213| 50| case 'v': ------------------ | Branch (27213:9): [True: 50, False: 2.03k] ------------------ 27214| 50| return '\v'; 27215| 89| case 'a': ------------------ | Branch (27215:9): [True: 89, False: 2.00k] ------------------ 27216| 89| return '\a'; 27217| 75| case 'b': ------------------ | Branch (27217:9): [True: 75, False: 2.01k] ------------------ 27218| 75| return '\b'; 27219| 44| case '\'': ------------------ | Branch (27219:9): [True: 44, False: 2.04k] ------------------ 27220| 44| return '\''; 27221| 36| case '?': ------------------ | Branch (27221:9): [True: 36, False: 2.05k] ------------------ 27222| 36| return '?'; 27223| 79| case 'e': ------------------ | Branch (27223:9): [True: 79, False: 2.01k] ------------------ 27224| 79| return 27; 27225| 104| case '"': ------------------ | Branch (27225:9): [True: 104, False: 1.98k] ------------------ 27226| 104| return '"'; 27227| 508| case '\\': ------------------ | Branch (27227:9): [True: 508, False: 1.58k] ------------------ 27228| 508| return '\\'; 27229| 2.08k| } 27230| 2.08k|} janet.c:escapeh: 27253| 439|static int escapeh(JanetParser *p, JanetParseState *state, uint8_t c) { 27254| 439| int digit = to_hex(c); 27255| 439| if (digit < 0) { ------------------ | Branch (27255:9): [True: 33, False: 406] ------------------ 27256| 33| p->error = "invalid hex digit in hex escape"; 27257| 33| return 1; 27258| 33| } 27259| 406| state->argn = (state->argn << 4) + digit; 27260| 406| state->counter--; 27261| 406| if (!state->counter) { ------------------ | Branch (27261:9): [True: 197, False: 209] ------------------ 27262| 197| push_buf(p, (uint8_t)(state->argn & 0xFF)); 27263| 197| state->argn = 0; 27264| 197| state->consumer = stringchar; 27265| 197| } 27266| 406| return 1; 27267| 439|} janet.c:to_hex: 27058| 2.66k|static int to_hex(uint8_t c) { 27059| 2.66k| if (c >= '0' && c <= '9') { ------------------ | Branch (27059:9): [True: 2.62k, False: 37] | Branch (27059:21): [True: 1.87k, False: 755] ------------------ 27060| 1.87k| return c - '0'; 27061| 1.87k| } else if (c >= 'A' && c <= 'F') { ------------------ | Branch (27061:16): [True: 747, False: 45] | Branch (27061:28): [True: 407, False: 340] ------------------ 27062| 407| return 10 + c - 'A'; 27063| 407| } else if (c >= 'a' && c <= 'f') { ------------------ | Branch (27063:16): [True: 331, False: 54] | Branch (27063:28): [True: 301, False: 30] ------------------ 27064| 301| return 10 + c - 'a'; 27065| 301| } else { 27066| 84| return -1; 27067| 84| } 27068| 2.66k|} janet.c:escapeu: 27269| 2.22k|static int escapeu(JanetParser *p, JanetParseState *state, uint8_t c) { 27270| 2.22k| int digit = to_hex(c); 27271| 2.22k| if (digit < 0) { ------------------ | Branch (27271:9): [True: 51, False: 2.17k] ------------------ 27272| 51| p->error = "invalid hex digit in unicode escape"; 27273| 51| return 1; 27274| 51| } 27275| 2.17k| state->argn = (state->argn << 4) + digit; 27276| 2.17k| state->counter--; 27277| 2.17k| if (!state->counter) { ------------------ | Branch (27277:9): [True: 440, False: 1.73k] ------------------ 27278| 440| if (state->argn > 0x10FFFF) { ------------------ | Branch (27278:13): [True: 6, False: 434] ------------------ 27279| 6| p->error = "invalid unicode codepoint"; 27280| 6| return 1; 27281| 6| } 27282| 434| write_codepoint(p, state->argn); 27283| 434| state->argn = 0; 27284| 434| state->consumer = stringchar; 27285| 434| } 27286| 2.17k| return 1; 27287| 2.17k|} janet.c:write_codepoint: 27235| 434|static void write_codepoint(JanetParser *p, int32_t codepoint) { 27236| 434| if (codepoint <= 0x7F) { ------------------ | Branch (27236:9): [True: 46, False: 388] ------------------ 27237| 46| push_buf(p, (uint8_t) codepoint); 27238| 388| } else if (codepoint <= 0x7FF) { ------------------ | Branch (27238:16): [True: 86, False: 302] ------------------ 27239| 86| push_buf(p, (uint8_t)((codepoint >> 6) & 0x1F) | 0xC0); 27240| 86| push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); 27241| 302| } else if (codepoint <= 0xFFFF) { ------------------ | Branch (27241:16): [True: 148, False: 154] ------------------ 27242| 148| push_buf(p, (uint8_t)((codepoint >> 12) & 0x0F) | 0xE0); 27243| 148| push_buf(p, (uint8_t)((codepoint >> 6) & 0x3F) | 0x80); 27244| 148| push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); 27245| 154| } else { 27246| 154| push_buf(p, (uint8_t)((codepoint >> 18) & 0x07) | 0xF0); 27247| 154| push_buf(p, (uint8_t)((codepoint >> 12) & 0x3F) | 0x80); 27248| 154| push_buf(p, (uint8_t)((codepoint >> 6) & 0x3F) | 0x80); 27249| 154| push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); 27250| 154| } 27251| 434|} janet.c:stringend: 27310| 6.68k|static int stringend(JanetParser *p, JanetParseState *state) { 27311| 6.68k| Janet ret; 27312| 6.68k| uint8_t *bufstart = p->buf; 27313| 6.68k| int32_t buflen = (int32_t) p->bufcount; 27314| 6.68k| if (state->flags & PFLAG_LONGSTRING) { ------------------ | |27102| 6.68k|#define PFLAG_LONGSTRING 0x4000 ------------------ | Branch (27314:9): [True: 1.24k, False: 5.43k] ------------------ 27315| | /* Post process to remove leading whitespace */ 27316| 1.24k| JanetParseState top = p->states[p->statecount - 1]; 27317| 1.24k| int32_t indent_col = (int32_t) top.column - 1; 27318| 1.24k| uint8_t *r = bufstart, *end = r + buflen; 27319| | /* Unless there are only spaces before EOLs, disable reindenting */ 27320| 1.24k| int reindent = 1; 27321| 8.48k| while (reindent && (r < end)) { ------------------ | Branch (27321:16): [True: 8.29k, False: 199] | Branch (27321:28): [True: 7.24k, False: 1.04k] ------------------ 27322| 7.24k| if (*r++ == '\n') { ------------------ | Branch (27322:17): [True: 1.28k, False: 5.96k] ------------------ 27323| 1.37k| for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++) { ------------------ | Branch (27323:37): [True: 1.06k, False: 315] | Branch (27323:50): [True: 573, False: 490] | Branch (27323:66): [True: 366, False: 207] ------------------ 27324| 366| if (*r != ' ') { ------------------ | Branch (27324:25): [True: 269, False: 97] ------------------ 27325| 269| reindent = 0; 27326| 269| break; 27327| 269| } 27328| 366| } 27329| 1.28k| if ((r + 1) < end && *r == '\r' && *(r + 1) == '\n') reindent = 1; ------------------ | Branch (27329:21): [True: 886, False: 395] | Branch (27329:38): [True: 330, False: 556] | Branch (27329:52): [True: 145, False: 185] ------------------ 27330| 1.28k| } 27331| 7.24k| } 27332| | /* Now reindent if able */ 27333| 1.24k| if (reindent) { ------------------ | Branch (27333:13): [True: 1.04k, False: 199] ------------------ 27334| 1.04k| uint8_t *w = bufstart; 27335| 1.04k| r = bufstart; 27336| 7.53k| while (r < end) { ------------------ | Branch (27336:20): [True: 6.48k, False: 1.04k] ------------------ 27337| 6.48k| if (*r == '\n') { ------------------ | Branch (27337:21): [True: 888, False: 5.60k] ------------------ 27338| 888| *w++ = *r++; 27339| 1.01k| for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++); ------------------ | Branch (27339:41): [True: 701, False: 315] | Branch (27339:54): [True: 334, False: 367] | Branch (27339:70): [True: 128, False: 206] ------------------ 27340| 888| if ((r + 1) < end && *r == '\r' && *(r + 1) == '\n') *w++ = *r++; ------------------ | Branch (27340:25): [True: 525, False: 363] | Branch (27340:42): [True: 138, False: 387] | Branch (27340:56): [True: 75, False: 63] ------------------ 27341| 5.60k| } else { 27342| 5.60k| *w++ = *r++; 27343| 5.60k| } 27344| 6.48k| } 27345| 1.04k| buflen = (int32_t)(w - bufstart); 27346| 1.04k| } 27347| | /* Check for leading EOL so we can remove it */ 27348| 1.24k| if (buflen > 1 && bufstart[0] == '\r' && bufstart[1] == '\n') { /* Windows EOL */ ------------------ | Branch (27348:13): [True: 939, False: 304] | Branch (27348:27): [True: 212, False: 727] | Branch (27348:50): [True: 80, False: 132] ------------------ 27349| 80| buflen = buflen - 2; 27350| 80| bufstart = bufstart + 2; 27351| 1.16k| } else if (buflen > 0 && bufstart[0] == '\n') { /* Unix EOL */ ------------------ | Branch (27351:20): [True: 1.16k, False: 0] | Branch (27351:34): [True: 279, False: 884] ------------------ 27352| 279| buflen--; 27353| 279| bufstart++; 27354| 279| } 27355| | /* Check for trailing EOL so we can remove it */ 27356| 1.24k| if (buflen > 1 && bufstart[buflen - 2] == '\r' && bufstart[buflen - 1] == '\n') { /* Windows EOL */ ------------------ | Branch (27356:13): [True: 833, False: 410] | Branch (27356:27): [True: 207, False: 626] | Branch (27356:59): [True: 45, False: 162] ------------------ 27357| 45| buflen = buflen - 2; 27358| 1.19k| } else if (buflen > 0 && bufstart[buflen - 1] == '\n') { /* Unix EOL */ ------------------ | Branch (27358:20): [True: 1.06k, False: 130] | Branch (27358:34): [True: 153, False: 915] ------------------ 27359| 153| buflen--; 27360| 153| } 27361| 1.24k| } 27362| 6.68k| if (state->flags & PFLAG_BUFFER) { ------------------ | |27097| 6.68k|#define PFLAG_BUFFER 0x200 ------------------ | Branch (27362:9): [True: 496, False: 6.18k] ------------------ 27363| 496| JanetBuffer *b = janet_buffer(buflen); 27364| 496| janet_buffer_push_bytes(b, bufstart, buflen); 27365| 496| ret = janet_wrap_buffer(b); ------------------ | | 847| 496|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 496| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 496|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 496|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27366| 6.18k| } else { 27367| 6.18k| ret = janet_wrap_string(janet_string(bufstart, buflen)); ------------------ | | 848| 6.18k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 6.18k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 6.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27368| 6.18k| } 27369| 6.68k| p->bufcount = 0; 27370| 6.68k| popstate(p, ret); 27371| 6.68k| return 1; 27372| 6.68k|} janet.c:comment: 27456| 2.03k|static int comment(JanetParser *p, JanetParseState *state, uint8_t c) { 27457| 2.03k| (void) state; 27458| 2.03k| if (c == '\n') { ------------------ | Branch (27458:9): [True: 288, False: 1.74k] ------------------ 27459| 288| p->statecount--; 27460| 288| p->bufcount = 0; 27461| 1.74k| } else { 27462| 1.74k| push_buf(p, c); 27463| 1.74k| } 27464| 2.03k| return 1; 27465| 2.03k|} janet.c:atsign: 27551| 2.33k|static int atsign(JanetParser *p, JanetParseState *state, uint8_t c) { 27552| 2.33k| (void) state; 27553| 2.33k| p->statecount--; 27554| 2.33k| switch (c) { 27555| 545| case '{': ------------------ | Branch (27555:9): [True: 545, False: 1.78k] ------------------ 27556| 545| pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM); ------------------ | |27096| 545|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM); ------------------ | |27100| 545|#define PFLAG_CURLYBRACKETS 0x1000 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM); ------------------ | |27104| 545|#define PFLAG_ATSYM 0x10000 ------------------ 27557| 545| return 1; 27558| 360| case '"': ------------------ | Branch (27558:9): [True: 360, False: 1.97k] ------------------ 27559| 360| pushstate(p, stringchar, PFLAG_BUFFER | PFLAG_STRING); ------------------ | |27097| 360|#define PFLAG_BUFFER 0x200 ------------------ pushstate(p, stringchar, PFLAG_BUFFER | PFLAG_STRING); ------------------ | |27101| 360|#define PFLAG_STRING 0x2000 ------------------ 27560| 360| return 1; 27561| 147| case '`': ------------------ | Branch (27561:9): [True: 147, False: 2.18k] ------------------ 27562| 147| pushstate(p, longstring, PFLAG_BUFFER | PFLAG_LONGSTRING); ------------------ | |27097| 147|#define PFLAG_BUFFER 0x200 ------------------ pushstate(p, longstring, PFLAG_BUFFER | PFLAG_LONGSTRING); ------------------ | |27102| 147|#define PFLAG_LONGSTRING 0x4000 ------------------ 27563| 147| return 1; 27564| 223| case '[': ------------------ | Branch (27564:9): [True: 223, False: 2.10k] ------------------ 27565| 223| pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM); ------------------ | |27096| 223|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM); ------------------ | |27099| 223|#define PFLAG_SQRBRACKETS 0x800 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM); ------------------ | |27104| 223|#define PFLAG_ATSYM 0x10000 ------------------ 27566| 223| return 1; 27567| 501| case '(': ------------------ | Branch (27567:9): [True: 501, False: 1.83k] ------------------ 27568| 501| pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM); ------------------ | |27096| 501|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM); ------------------ | |27098| 501|#define PFLAG_PARENS 0x400 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM); ------------------ | |27104| 501|#define PFLAG_ATSYM 0x10000 ------------------ 27569| 501| return 1; 27570| 556| default: ------------------ | Branch (27570:9): [True: 556, False: 1.77k] ------------------ 27571| 556| break; 27572| 2.33k| } 27573| 556| pushstate(p, tokenchar, PFLAG_TOKEN); ------------------ | |27106| 556|#define PFLAG_TOKEN 0x40000 ------------------ 27574| 556| push_buf(p, '@'); /* Push the leading at-sign that was dropped */ 27575| 556| return 0; 27576| 2.33k|} janet.c:longstring: 27507| 15.6k|static int longstring(JanetParser *p, JanetParseState *state, uint8_t c) { 27508| 15.6k| if (state->flags & PFLAG_INSTRING) { ------------------ | |27505| 15.6k|#define PFLAG_INSTRING 0x100000 ------------------ | Branch (27508:9): [True: 9.63k, False: 5.99k] ------------------ 27509| | /* We are inside the long string */ 27510| 9.63k| if (c == '`') { ------------------ | Branch (27510:13): [True: 1.48k, False: 8.14k] ------------------ 27511| 1.48k| state->flags |= PFLAG_END_CANDIDATE; ------------------ | |27506| 1.48k|#define PFLAG_END_CANDIDATE 0x200000 ------------------ 27512| 1.48k| state->flags &= ~PFLAG_INSTRING; ------------------ | |27505| 1.48k|#define PFLAG_INSTRING 0x100000 ------------------ 27513| 1.48k| state->counter = 1; /* Use counter to keep track of number of '=' seen */ 27514| 1.48k| return 1; 27515| 1.48k| } 27516| 8.14k| push_buf(p, c); 27517| 8.14k| return 1; 27518| 9.63k| } else if (state->flags & PFLAG_END_CANDIDATE) { ------------------ | |27506| 5.99k|#define PFLAG_END_CANDIDATE 0x200000 ------------------ | Branch (27518:16): [True: 2.31k, False: 3.67k] ------------------ 27519| 2.31k| int i; 27520| | /* We are checking a potential end of the string */ 27521| 2.31k| if (state->counter == state->argn) { ------------------ | Branch (27521:13): [True: 1.24k, False: 1.07k] ------------------ 27522| 1.24k| stringend(p, state); 27523| 1.24k| return 0; 27524| 1.24k| } 27525| 1.07k| if (c == '`' && state->counter < state->argn) { ------------------ | Branch (27525:13): [True: 826, False: 245] | Branch (27525:25): [True: 826, False: 0] ------------------ 27526| 826| state->counter++; 27527| 826| return 1; 27528| 826| } 27529| | /* Failed end candidate */ 27530| 1.09k| for (i = 0; i < state->counter; i++) { ------------------ | Branch (27530:21): [True: 846, False: 245] ------------------ 27531| 846| push_buf(p, '`'); 27532| 846| } 27533| 245| push_buf(p, c); 27534| 245| state->counter = 0; 27535| 245| state->flags &= ~PFLAG_END_CANDIDATE; ------------------ | |27506| 245|#define PFLAG_END_CANDIDATE 0x200000 ------------------ 27536| 245| state->flags |= PFLAG_INSTRING; ------------------ | |27505| 245|#define PFLAG_INSTRING 0x100000 ------------------ 27537| 245| return 1; 27538| 3.67k| } else { 27539| | /* We are at beginning of string */ 27540| 3.67k| state->argn++; 27541| 3.67k| if (c != '`') { ------------------ | Branch (27541:13): [True: 1.41k, False: 2.26k] ------------------ 27542| 1.41k| state->flags |= PFLAG_INSTRING; ------------------ | |27505| 1.41k|#define PFLAG_INSTRING 0x100000 ------------------ 27543| 1.41k| push_buf(p, c); 27544| 1.41k| } 27545| 3.67k| return 1; 27546| 3.67k| } 27547| 15.6k|} janet.c:close_array: 27475| 581|static Janet close_array(JanetParser *p, JanetParseState *state) { 27476| 581| JanetArray *array = janet_array(state->argn); 27477| 1.54k| for (int32_t i = state->argn - 1; i >= 0; i--) ------------------ | Branch (27477:39): [True: 968, False: 581] ------------------ 27478| 968| array->data[i] = p->args[--p->argcount]; 27479| 581| array->count = state->argn; 27480| 581| return janet_wrap_array(array); ------------------ | | 845| 581|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 581| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 581|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 581|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27481| 581|} janet.c:close_tuple: 27467| 3.36k|static Janet close_tuple(JanetParser *p, JanetParseState *state, int32_t flag) { 27468| 3.36k| Janet *ret = janet_tuple_begin(state->argn); 27469| 3.36k| janet_tuple_flag(ret) |= flag; ------------------ | | 1806| 3.36k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 3.36k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27470| 15.2k| for (int32_t i = state->argn - 1; i >= 0; i--) ------------------ | Branch (27470:39): [True: 11.8k, False: 3.36k] ------------------ 27471| 11.8k| ret[i] = p->args[--p->argcount]; 27472| 3.36k| return janet_wrap_tuple(janet_tuple_end(ret)); ------------------ | | 843| 3.36k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 3.36k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 3.36k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.36k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27473| 3.36k|} janet.c:close_table: 27494| 467|static Janet close_table(JanetParser *p, JanetParseState *state) { 27495| 467| JanetTable *table = janet_table(state->argn >> 1); 27496| 2.17k| for (size_t i = p->argcount - state->argn; i < p->argcount; i += 2) { ------------------ | Branch (27496:48): [True: 1.70k, False: 467] ------------------ 27497| 1.70k| Janet key = p->args[i]; 27498| 1.70k| Janet value = p->args[i + 1]; 27499| 1.70k| janet_table_put(table, key, value); 27500| 1.70k| } 27501| 467| p->argcount -= state->argn; 27502| 467| return janet_wrap_table(table); ------------------ | | 846| 467|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 467| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 467|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 467|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27503| 467|} janet.c:close_struct: 27483| 6.40k|static Janet close_struct(JanetParser *p, JanetParseState *state) { 27484| 6.40k| JanetKV *st = janet_struct_begin(state->argn >> 1); 27485| 12.8k| for (size_t i = p->argcount - state->argn; i < p->argcount; i += 2) { ------------------ | Branch (27485:48): [True: 6.40k, False: 6.40k] ------------------ 27486| 6.40k| Janet key = p->args[i]; 27487| 6.40k| Janet value = p->args[i + 1]; 27488| 6.40k| janet_struct_put(st, key, value); 27489| 6.40k| } 27490| 6.40k| p->argcount -= state->argn; 27491| 6.40k| return janet_wrap_struct(janet_struct_end(st)); ------------------ | | 842| 6.40k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 6.40k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 6.40k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.40k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27492| 6.40k|} janet.c:popstate: 27119| 47.9k|static void popstate(JanetParser *p, Janet val) { 27120| 87.5k| for (;;) { 27121| 87.5k| JanetParseState top = p->states[--p->statecount]; 27122| 87.5k| JanetParseState *newtop = p->states + p->statecount - 1; 27123| | /* Source mapping info */ 27124| 87.5k| if (janet_checktype(val, JANET_TUPLE)) { ------------------ | | 806| 87.5k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 43.0k, False: 44.5k] | | | Branch (806:6): [Folded, False: 87.5k] | | ------------------ | | 807| 87.5k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 87.5k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 87.5k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 87.5k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 87.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 87.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27125| 43.0k| janet_tuple_sm_line(janet_unwrap_tuple(val)) = (int32_t) top.line; ------------------ | | 1804| 43.0k|#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) | | ------------------ | | | | 1800| 43.0k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27126| 43.0k| janet_tuple_sm_column(janet_unwrap_tuple(val)) = (int32_t) top.column; ------------------ | | 1805| 43.0k|#define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column) | | ------------------ | | | | 1800| 43.0k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27127| 43.0k| } 27128| 87.5k| if (newtop->flags & PFLAG_CONTAINER) { ------------------ | |27096| 87.5k|#define PFLAG_CONTAINER 0x100 ------------------ | Branch (27128:13): [True: 47.9k, False: 39.6k] ------------------ 27129| 47.9k| newtop->argn++; 27130| | /* Keep track of number of values in the root state */ 27131| 47.9k| if (p->statecount == 1) { ------------------ | Branch (27131:17): [True: 14.5k, False: 33.3k] ------------------ 27132| 14.5k| p->pending++; 27133| | /* Root items are always wrapped in a tuple for source map info. */ 27134| 14.5k| const Janet *tup = janet_tuple_n(&val, 1); 27135| 14.5k| janet_tuple_sm_line(tup) = (int32_t) top.line; ------------------ | | 1804| 14.5k|#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) | | ------------------ | | | | 1800| 14.5k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27136| 14.5k| janet_tuple_sm_column(tup) = (int32_t) top.column; ------------------ | | 1805| 14.5k|#define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column) | | ------------------ | | | | 1800| 14.5k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27137| 14.5k| val = janet_wrap_tuple(tup); ------------------ | | 843| 14.5k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 14.5k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 14.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 14.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27138| 14.5k| } 27139| 47.9k| push_arg(p, val); 27140| 47.9k| return; 27141| 47.9k| } else if (newtop->flags & PFLAG_READERMAC) { ------------------ | |27103| 39.6k|#define PFLAG_READERMAC 0x8000 ------------------ | Branch (27141:20): [True: 39.6k, False: 0] ------------------ 27142| 39.6k| Janet *t = janet_tuple_begin(2); 27143| 39.6k| int c = newtop->flags & 0xFF; 27144| 39.6k| const char *which = 27145| 39.6k| (c == '\'') ? "quote" : ------------------ | Branch (27145:17): [True: 14.1k, False: 25.4k] ------------------ 27146| 39.6k| (c == ',') ? "unquote" : ------------------ | Branch (27146:17): [True: 6.78k, False: 18.7k] ------------------ 27147| 25.4k| (c == ';') ? "splice" : ------------------ | Branch (27147:17): [True: 4.73k, False: 13.9k] ------------------ 27148| 18.7k| (c == '|') ? "short-fn" : ------------------ | Branch (27148:17): [True: 6.03k, False: 7.93k] ------------------ 27149| 13.9k| (c == '~') ? "quasiquote" : ""; ------------------ | Branch (27149:17): [True: 7.93k, False: 0] ------------------ 27150| 39.6k| t[0] = janet_csymbolv(which); ------------------ | | 1837| 39.6k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 39.6k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 39.6k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 39.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 39.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27151| 39.6k| t[1] = val; 27152| | /* Quote source mapping info */ 27153| 39.6k| janet_tuple_sm_line(t) = (int32_t) newtop->line; ------------------ | | 1804| 39.6k|#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) | | ------------------ | | | | 1800| 39.6k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27154| 39.6k| janet_tuple_sm_column(t) = (int32_t) newtop->column; ------------------ | | 1805| 39.6k|#define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column) | | ------------------ | | | | 1800| 39.6k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27155| 39.6k| val = janet_wrap_tuple(janet_tuple_end(t)); ------------------ | | 843| 39.6k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 39.6k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 39.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 39.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27156| 39.6k| } else { 27157| 0| return; 27158| 0| } 27159| 87.5k| } 27160| 47.9k|} janet.c:tokenchar: 27403| 135k|static int tokenchar(JanetParser *p, JanetParseState *state, uint8_t c) { 27404| 135k| Janet ret; 27405| 135k| double numval; 27406| 135k| int32_t blen; 27407| 135k| if (janet_is_symbol_char(c)) { ------------------ | Branch (27407:9): [True: 103k, False: 31.1k] ------------------ 27408| 103k| push_buf(p, (uint8_t) c); 27409| 103k| if (c > 127) state->argn = 1; /* Use to indicate non ascii */ ------------------ | Branch (27409:13): [True: 4.15k, False: 99.7k] ------------------ 27410| 103k| return 1; 27411| 103k| } 27412| | /* Token finished */ 27413| 31.1k| blen = (int32_t) p->bufcount; 27414| 31.1k| int start_dig = p->buf[0] >= '0' && p->buf[0] <= '9'; ------------------ | Branch (27414:21): [True: 23.3k, False: 7.77k] | Branch (27414:41): [True: 9.51k, False: 13.8k] ------------------ 27415| 31.1k| int start_num = start_dig || p->buf[0] == '-' || p->buf[0] == '+' || p->buf[0] == '.'; ------------------ | Branch (27415:21): [True: 9.51k, False: 21.6k] | Branch (27415:34): [True: 2.62k, False: 19.0k] | Branch (27415:54): [True: 1.21k, False: 17.8k] | Branch (27415:74): [True: 2.25k, False: 15.5k] ------------------ 27416| 31.1k| if (p->buf[0] == ':') { ------------------ | Branch (27416:9): [True: 1.20k, False: 29.9k] ------------------ 27417| | /* Don't do full utf-8 check unless we have seen non ascii characters. */ 27418| 1.20k| int valid = (!state->argn) || janet_valid_utf8(p->buf + 1, blen - 1); ------------------ | Branch (27418:21): [True: 1.04k, False: 160] | Branch (27418:39): [True: 97, False: 63] ------------------ 27419| 1.20k| if (!valid) { ------------------ | Branch (27419:13): [True: 63, False: 1.14k] ------------------ 27420| 63| p->error = "invalid utf-8 in keyword"; 27421| 63| return 0; 27422| 63| } 27423| 1.14k| ret = janet_keywordv(p->buf + 1, blen - 1); ------------------ | | 1842| 1.14k|#define janet_keywordv(str, len) janet_wrap_keyword(janet_keyword((str), (len))) | | ------------------ | | | | 850| 1.14k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 1.14k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.14k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.14k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27424| 1.14k|#ifdef JANET_INT_TYPES 27425| 29.9k| } else if (start_num && !janet_scan_numeric(p->buf, blen, &ret)) { ------------------ | Branch (27425:16): [True: 15.6k, False: 14.3k] | Branch (27425:29): [True: 11.8k, False: 3.77k] ------------------ 27426| 11.8k| (void) numval; 27427| |#else 27428| | } else if (start_num && !janet_scan_number(p->buf, blen, &numval)) { 27429| | ret = janet_wrap_number(numval); 27430| |#endif 27431| 18.1k| } else if (!check_str_const("nil", p->buf, blen)) { ------------------ | Branch (27431:16): [True: 119, False: 18.0k] ------------------ 27432| 119| ret = janet_wrap_nil(); ------------------ | | 831| 119|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 119| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 119|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 119|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27433| 18.0k| } else if (!check_str_const("false", p->buf, blen)) { ------------------ | Branch (27433:16): [True: 61, False: 17.9k] ------------------ 27434| 61| ret = janet_wrap_false(); ------------------ | | 833| 61|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 61| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 61|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 61|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27435| 17.9k| } else if (!check_str_const("true", p->buf, blen)) { ------------------ | Branch (27435:16): [True: 44, False: 17.9k] ------------------ 27436| 44| ret = janet_wrap_true(); ------------------ | | 832| 44|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 44| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 44|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 44|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27437| 17.9k| } else { 27438| 17.9k| if (start_dig) { ------------------ | Branch (27438:13): [True: 372, False: 17.5k] ------------------ 27439| 372| p->error = "symbol literal cannot start with a digit"; 27440| 372| return 0; 27441| 17.5k| } else { 27442| | /* Don't do full utf-8 check unless we have seen non ascii characters. */ 27443| 17.5k| int valid = (!state->argn) || janet_valid_utf8(p->buf, blen); ------------------ | Branch (27443:25): [True: 16.8k, False: 647] | Branch (27443:43): [True: 327, False: 320] ------------------ 27444| 17.5k| if (!valid) { ------------------ | Branch (27444:17): [True: 320, False: 17.2k] ------------------ 27445| 320| p->error = "invalid utf-8 in symbol"; 27446| 320| return 0; 27447| 320| } 27448| 17.2k| ret = janet_symbolv(p->buf, blen); ------------------ | | 1836| 17.2k|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 17.2k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 17.2k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 17.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 17.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27449| 17.2k| } 27450| 17.9k| } 27451| 30.4k| p->bufcount = 0; 27452| 30.4k| popstate(p, ret); 27453| 30.4k| return 0; 27454| 31.1k|} janet.c:check_str_const: 27391| 54.0k|static int check_str_const(const char *cstr, const uint8_t *str, int32_t len) { 27392| 54.0k| int32_t index; 27393| 56.2k| for (index = 0; index < len; index++) { ------------------ | Branch (27393:21): [True: 55.3k, False: 904] ------------------ 27394| 55.3k| uint8_t c = str[index]; 27395| 55.3k| uint8_t k = ((const uint8_t *)cstr)[index]; 27396| 55.3k| if (c < k) return -1; ------------------ | Branch (27396:13): [True: 39.1k, False: 16.2k] ------------------ 27397| 16.2k| if (c > k) return 1; ------------------ | Branch (27397:13): [True: 14.0k, False: 2.18k] ------------------ 27398| 2.18k| if (k == '\0') break; ------------------ | Branch (27398:13): [True: 0, False: 2.18k] ------------------ 27399| 2.18k| } 27400| 904| return (cstr[index] == '\0') ? 0 : -1; ------------------ | Branch (27400:12): [True: 224, False: 680] ------------------ 27401| 54.0k|} janet.c:size_padded: 29929| 2.46k|static size_t size_padded(size_t offset, size_t size) { 29930| 2.46k| size_t x = size + offset - 1; 29931| 2.46k| return x - (x % size); 29932| 2.46k|} janet.c:compile_peg: 30206| 3.43k|static JanetPeg *compile_peg(Janet x) { 30207| 3.43k| Builder builder; 30208| 3.43k| builder.grammar = janet_table(0); 30209| 3.43k| builder.default_grammar = NULL; 30210| 3.43k| { 30211| 3.43k| Janet default_grammarv = janet_dyn("peg-grammar"); 30212| 3.43k| if (janet_checktype(default_grammarv, JANET_TABLE)) { ------------------ | | 806| 3.43k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 3.43k] | | | Branch (806:6): [Folded, False: 3.43k] | | ------------------ | | 807| 3.43k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.43k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.43k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.43k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.43k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.43k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 30213| 0| builder.default_grammar = janet_unwrap_table(default_grammarv); ------------------ | | 861| 0|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 30214| 0| } 30215| 3.43k| } 30216| 3.43k| builder.tags = janet_table(0); 30217| 3.43k| builder.constants = NULL; 30218| 3.43k| builder.bytecode = NULL; 30219| 3.43k| builder.nexttag = 1; 30220| 3.43k| builder.form = x; 30221| 3.43k| builder.depth = JANET_RECURSION_GUARD; ------------------ | | 296| 3.43k|#define JANET_RECURSION_GUARD 1024 ------------------ 30222| 3.43k| builder.has_backref = 0; 30223| 3.43k| peg_compile1(&builder, x); 30224| 3.43k| JanetPeg *peg = make_peg(&builder); 30225| 3.43k| builder_cleanup(&builder); 30226| 3.43k| return peg; 30227| 3.43k|} janet.c:peg_compile1: 29740| 13.2k|static uint32_t peg_compile1(Builder *b, Janet peg) { 29741| | 29742| | /* Keep track of the form being compiled for error purposes */ 29743| 13.2k| Janet old_form = b->form; 29744| 13.2k| JanetTable *old_grammar = b->grammar; 29745| 13.2k| b->form = peg; 29746| | 29747| | /* Resolve keyword references */ 29748| 13.2k| int i = JANET_RECURSION_GUARD; ------------------ | | 296| 13.2k|#define JANET_RECURSION_GUARD 1024 ------------------ 29749| 13.2k| JanetTable *grammar = old_grammar; 29750| 13.2k| for (; i > 0 && janet_checktype(peg, JANET_KEYWORD); --i) { ------------------ | | 806| 13.2k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 40, False: 13.1k] | | | Branch (806:6): [Folded, False: 13.2k] | | ------------------ | | 807| 13.2k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 13.2k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 13.2k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 13.2k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 13.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 13.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29750:12): [True: 13.2k, False: 0] ------------------ 29751| 40| Janet nextPeg = janet_table_get_ex(grammar, peg, &grammar); 29752| 40| if (!grammar || janet_checktype(nextPeg, JANET_NIL)) { ------------------ | | 806| 40| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 40, False: 0] | | | Branch (806:6): [Folded, False: 40] | | ------------------ | | 807| 40| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 40| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 40| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 40|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 40|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 40|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29752:13): [True: 0, False: 40] ------------------ 29753| 40| nextPeg = (b->default_grammar == NULL) ------------------ | Branch (29753:23): [True: 40, False: 0] ------------------ 29754| 40| ? janet_wrap_nil() ------------------ | | 831| 40|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 40| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 40|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 40|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29755| 40| : janet_table_get(b->default_grammar, peg); 29756| 40| if (janet_checktype(nextPeg, JANET_NIL)) { ------------------ | | 806| 40| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 40, False: 0] | | | Branch (806:6): [Folded, False: 40] | | ------------------ | | 807| 40| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 40| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 40| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 40|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 40|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 40|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29757| 40| peg_panic(b, "unknown rule"); 29758| 40| } 29759| 40| } 29760| 0| peg = nextPeg; 29761| 0| b->form = peg; 29762| 0| b->grammar = grammar; 29763| 0| } 29764| 13.1k| if (i == 0) ------------------ | Branch (29764:9): [True: 0, False: 13.1k] ------------------ 29765| 0| peg_panic(b, "reference chain too deep"); 29766| | 29767| | /* Check cache - for tuples we check only the local cache, as 29768| | * in a different grammar, the same tuple can compile to a different 29769| | * rule - for example, (+ :a :b) depends on whatever :a and :b are bound to. */ 29770| 13.1k| Janet check = janet_checktype(peg, JANET_TUPLE) ------------------ | | 806| 13.1k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 8.37k, False: 4.80k] | | | Branch (806:6): [Folded, False: 13.1k] | | ------------------ | | 807| 13.1k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 13.1k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 13.1k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 13.1k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 13.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 13.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29771| 13.1k| ? janet_table_rawget(grammar, peg) 29772| 13.1k| : janet_table_get(grammar, peg); 29773| 13.1k| if (!janet_checktype(check, JANET_NIL)) { ------------------ | | 806| 13.1k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 13.1k] | | ------------------ | | 807| 13.1k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 13.1k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 13.1k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 13.1k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 13.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 13.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29773:9): [True: 1.70k, False: 11.4k] ------------------ 29774| 1.70k| b->form = old_form; 29775| 1.70k| b->grammar = old_grammar; 29776| 1.70k| return (uint32_t) janet_unwrap_number(check); ------------------ | | 839| 1.70k|#define janet_unwrap_number(x) ((x).number) ------------------ 29777| 1.70k| } 29778| | 29779| | /* Check depth */ 29780| 11.4k| if (b->depth-- == 0) ------------------ | Branch (29780:9): [True: 0, False: 11.4k] ------------------ 29781| 0| peg_panic(b, "peg grammar recursed too deeply"); 29782| | 29783| | /* The final rule to return */ 29784| 11.4k| uint32_t rule = janet_v_count(b->bytecode); ------------------ | | 759| 11.4k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 8.07k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 8.07k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 8.07k, False: 3.39k] | | ------------------ ------------------ 29785| | 29786| | /* Add to cache. Do not cache structs, as we don't yet know 29787| | * what rule they will return! We can just as effectively cache 29788| | * the structs main rule. */ 29789| 11.4k| if (!janet_checktype(peg, JANET_STRUCT)) { ------------------ | | 806| 11.4k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 11.4k] | | ------------------ | | 807| 11.4k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 11.4k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 11.4k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 11.4k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 11.4k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 11.4k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29789:9): [True: 11.0k, False: 422] ------------------ 29790| 11.0k| JanetTable *which_grammar = grammar; 29791| | /* If we are a primitive pattern, add to the global cache (root grammar table) */ 29792| 11.0k| if (!janet_checktype(peg, JANET_TUPLE)) { ------------------ | | 806| 11.0k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 11.0k] | | ------------------ | | 807| 11.0k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 11.0k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 11.0k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 11.0k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 11.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 11.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29792:13): [True: 2.90k, False: 8.15k] ------------------ 29793| 2.90k| while (which_grammar->proto) ------------------ | Branch (29793:20): [True: 0, False: 2.90k] ------------------ 29794| 0| which_grammar = which_grammar->proto; 29795| 2.90k| } 29796| 11.0k| janet_table_put(which_grammar, peg, janet_wrap_number(rule)); ------------------ | | 835| 11.0k|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 29797| 11.0k| } 29798| | 29799| 11.4k| switch (janet_type(peg)) { ------------------ | | 795| 11.4k| (isnan((x).number) \ | | 796| 11.4k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 11.4k| : JANET_NUMBER) ------------------ | Branch (29799:13): [True: 9.95k, False: 1.51k] ------------------ 29800| 431| default: ------------------ | Branch (29800:9): [True: 431, False: 11.0k] ------------------ 29801| 431| peg_panic(b, "unexpected peg source"); 29802| 0| return 0; 29803| | 29804| 9| case JANET_BOOLEAN: { ------------------ | Branch (29804:9): [True: 9, False: 11.4k] ------------------ 29805| 9| int n = janet_unwrap_boolean(peg); ------------------ | | 838| 9|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 29806| 9| Reserve r = reserve(b, 2); 29807| 9| emit_1(r, n ? RULE_NCHAR : RULE_NOTNCHAR, 0); ------------------ | Branch (29807:23): [True: 3, False: 6] ------------------ 29808| 9| break; 29809| 0| } 29810| 1.51k| case JANET_NUMBER: { ------------------ | Branch (29810:9): [True: 1.51k, False: 9.95k] ------------------ 29811| 1.51k| int32_t n = peg_getinteger(b, peg); 29812| 1.51k| Reserve r = reserve(b, 2); 29813| 1.51k| if (n < 0) { ------------------ | Branch (29813:17): [True: 103, False: 1.41k] ------------------ 29814| 103| if (n == INT32_MIN) { ------------------ | Branch (29814:21): [True: 1, False: 102] ------------------ 29815| | /* Since buffers can't hold this many characters, will 29816| | * always match. Avoid undefined behavior negating INT32_MIN. */ 29817| 1| emit_1(r, RULE_NCHAR, 0); 29818| 102| } else { 29819| 102| emit_1(r, RULE_NOTNCHAR, -n); 29820| 102| } 29821| 1.41k| } else { 29822| 1.41k| emit_1(r, RULE_NCHAR, n); 29823| 1.41k| } 29824| 1.51k| break; 29825| 0| } 29826| 769| case JANET_STRING: { ------------------ | Branch (29826:9): [True: 769, False: 10.7k] ------------------ 29827| 769| const uint8_t *str = janet_unwrap_string(peg); ------------------ | | 863| 769|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 29828| 769| int32_t len = janet_string_length(str); ------------------ | | 1813| 769|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 769|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 29829| 769| emit_bytes(b, RULE_LITERAL, len, str); 29830| 769| break; 29831| 0| } 29832| 71| case JANET_BUFFER: { ------------------ | Branch (29832:9): [True: 71, False: 11.4k] ------------------ 29833| 71| const JanetBuffer *buf = janet_unwrap_buffer(peg); ------------------ | | 862| 71|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 29834| 71| emit_bytes(b, RULE_LITERAL, buf->count, buf->data); 29835| 71| break; 29836| 0| } 29837| 102| case JANET_TABLE: { ------------------ | Branch (29837:9): [True: 102, False: 11.3k] ------------------ 29838| | /* Build grammar table */ 29839| 102| JanetTable *new_grammar = janet_table_clone(janet_unwrap_table(peg)); ------------------ | | 861| 102|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 29840| 102| new_grammar->proto = grammar; 29841| 102| b->grammar = grammar = new_grammar; 29842| | /* Run the main rule */ 29843| 102| Janet main_rule = janet_table_rawget(grammar, janet_ckeywordv("main")); ------------------ | | 1843| 102|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 102|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 102| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 102|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 102|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29844| 102| if (janet_checktype(main_rule, JANET_NIL)) ------------------ | | 806| 102| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 102, False: 0] | | | Branch (806:6): [Folded, False: 102] | | ------------------ | | 807| 102| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 102| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 102| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 102|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 102|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 102|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29845| 102| peg_panic(b, "grammar requires :main rule"); 29846| 0| rule = peg_compile1(b, main_rule); 29847| 0| break; 29848| 102| } 29849| 422| case JANET_STRUCT: { ------------------ | Branch (29849:9): [True: 422, False: 11.0k] ------------------ 29850| | /* Build grammar table */ 29851| 422| const JanetKV *st = janet_unwrap_struct(peg); ------------------ | | 857| 422|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 29852| 422| JanetTable *new_grammar = janet_table(2 * janet_struct_capacity(st)); ------------------ | | 1849| 422|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 422|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 29853| 6.50k| for (int32_t i = 0; i < janet_struct_capacity(st); i++) { ------------------ | | 1849| 6.50k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 6.50k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (29853:33): [True: 6.08k, False: 422] ------------------ 29854| 6.08k| if (janet_checktype(st[i].key, JANET_KEYWORD)) { ------------------ | | 806| 6.08k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 35, False: 6.04k] | | | Branch (806:6): [Folded, False: 6.08k] | | ------------------ | | 807| 6.08k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.08k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 6.08k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 6.08k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 6.08k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.08k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29855| 35| janet_table_put(new_grammar, st[i].key, st[i].value); 29856| 35| } 29857| 6.08k| } 29858| 422| new_grammar->proto = grammar; 29859| 422| b->grammar = grammar = new_grammar; 29860| | /* Run the main rule */ 29861| 422| Janet main_rule = janet_table_rawget(grammar, janet_ckeywordv("main")); ------------------ | | 1843| 422|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 422|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 422| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 422|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 422|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29862| 422| if (janet_checktype(main_rule, JANET_NIL)) ------------------ | | 806| 422| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 422, False: 0] | | | Branch (806:6): [Folded, False: 422] | | ------------------ | | 807| 422| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 422| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 422| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 422|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 422|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 422|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29863| 422| peg_panic(b, "grammar requires :main rule"); 29864| 0| rule = peg_compile1(b, main_rule); 29865| 0| break; 29866| 422| } 29867| 8.15k| case JANET_TUPLE: { ------------------ | Branch (29867:9): [True: 8.15k, False: 3.32k] ------------------ 29868| 8.15k| const Janet *tup = janet_unwrap_tuple(peg); ------------------ | | 858| 8.15k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 29869| 8.15k| int32_t len = janet_tuple_length(tup); ------------------ | | 1802| 8.15k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 8.15k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 29870| 8.15k| if (len == 0) peg_panic(b, "tuple in grammar must have non-zero length"); ------------------ | Branch (29870:17): [True: 11, False: 8.14k] ------------------ 29871| 8.14k| if (janet_checkint(tup[0])) { ------------------ | Branch (29871:17): [True: 485, False: 7.65k] ------------------ 29872| 485| int32_t n = janet_unwrap_integer(tup[0]); ------------------ | | 966| 485|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 485|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 29873| 485| if (n < 0) { ------------------ | Branch (29873:21): [True: 32, False: 453] ------------------ 29874| 32| peg_panicf(b, "expected non-negative integer, got %d", n); ------------------ | |29181| 32|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29875| 32| } 29876| 453| spec_repeat(b, len, tup); 29877| 453| break; 29878| 485| } 29879| 7.65k| if (!janet_checktype(tup[0], JANET_SYMBOL)) ------------------ | | 806| 7.65k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 7.65k] | | ------------------ | | 807| 7.65k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 7.65k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.65k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.65k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29879:17): [True: 135, False: 7.52k] ------------------ 29880| 135| peg_panicf(b, "expected grammar command, found %v", tup[0]); ------------------ | |29181| 135|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29881| 7.52k| const uint8_t *sym = janet_unwrap_symbol(tup[0]); ------------------ | | 864| 7.52k|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 29882| 7.52k| const SpecialPair *sp = janet_strbinsearch( 29883| 7.52k| &peg_specials, 29884| 7.52k| sizeof(peg_specials) / sizeof(SpecialPair), 29885| 7.52k| sizeof(SpecialPair), 29886| 7.52k| sym); 29887| 7.52k| if (sp) { ------------------ | Branch (29887:17): [True: 6.99k, False: 522] ------------------ 29888| 6.99k| sp->special(b, len - 1, tup + 1); 29889| 6.99k| } else { 29890| 522| peg_panicf(b, "unknown special %S", sym); ------------------ | |29181| 522|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29891| 522| } 29892| 6.99k| break; 29893| 7.52k| } 29894| 11.4k| } 29895| | 29896| | /* Increase depth again */ 29897| 6.75k| b->depth++; 29898| 6.75k| b->form = old_form; 29899| 6.75k| b->grammar = old_grammar; 29900| 6.75k| return rule; 29901| 11.4k|} janet.c:peg_panic: 29176| 2.20k|JANET_NO_RETURN static void peg_panic(Builder *b, const char *msg) { 29177| 2.20k| builder_cleanup(b); 29178| 2.20k| janet_panicf("grammar error in %p, %s", b->form, msg); 29179| 2.20k|} janet.c:reserve: 29267| 7.60k|static Reserve reserve(Builder *b, int32_t size) { 29268| 7.60k| Reserve r; 29269| 7.60k| r.index = janet_v_count(b->bytecode); ------------------ | | 759| 7.60k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 6.60k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 6.60k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 6.60k, False: 994] | | ------------------ ------------------ 29270| 7.60k| r.builder = b; 29271| 7.60k| r.size = size; 29272| 29.5k| for (int32_t i = 0; i < size; i++) ------------------ | Branch (29272:25): [True: 21.9k, False: 7.60k] ------------------ 29273| | janet_v_push(b->bytecode, 0); ------------------ | | 757| 21.9k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 21.9k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 21.9k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 20.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 20.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 20.9k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 20.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 994, False: 20.9k] | | | | | | | Branch (768:50): [True: 3.25k, False: 17.7k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 4.24k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 21.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 21.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 29274| 7.60k| return r; 29275| 7.60k|} janet.c:emit_1: 29296| 1.36k|static void emit_1(Reserve r, uint32_t op, uint32_t arg) { 29297| 1.36k| emit_rule(r, op, 1, &arg); 29298| 1.36k|} janet.c:emit_rule: 29278| 5.12k|static void emit_rule(Reserve r, int32_t op, int32_t n, const uint32_t *body) { 29279| 5.12k| janet_assert(r.size == n + 1, "bad reserve"); ------------------ | | 389| 5.12k|#define janet_assert(c, m) do { \ | | 390| 5.12k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 5.12k] | | ------------------ | | 391| 5.12k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 5.12k] | | ------------------ ------------------ 29280| 5.12k| r.builder->bytecode[r.index] = op; 29281| 5.12k| memcpy(r.builder->bytecode + r.index + 1, body, n * sizeof(uint32_t)); 29282| 5.12k|} janet.c:peg_getinteger: 29217| 1.94k|static int32_t peg_getinteger(Builder *b, Janet x) { 29218| 1.94k| if (!janet_checkint(x)) ------------------ | Branch (29218:9): [True: 349, False: 1.60k] ------------------ 29219| 349| peg_panicf(b, "expected integer, got %v", x); ------------------ | |29181| 349|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29220| 1.60k| return janet_unwrap_integer(x); ------------------ | | 966| 1.60k|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 1.60k|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 29221| 1.94k|} janet.c:emit_bytes: 29285| 840|static void emit_bytes(Builder *b, uint32_t op, int32_t len, const uint8_t *bytes) { 29286| 840| uint32_t next_rule = janet_v_count(b->bytecode); ------------------ | | 759| 840|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 680|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 680|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 680, False: 160] | | ------------------ ------------------ 29287| 840| janet_v_push(b->bytecode, op); ------------------ | | 757| 840|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 840|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 840|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 680|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 680|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 680|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 680|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 160, False: 680] | | | | | | | Branch (768:50): [True: 66, False: 614] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 226|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 840|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 840|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 29288| 840| janet_v_push(b->bytecode, len); ------------------ | | 757| 840|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 840|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 840|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 840|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 840|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 840|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 840|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 840] | | | | | | | Branch (768:50): [True: 231, False: 609] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 231|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 840|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 840|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 29289| 840| int32_t words = ((len + 3) >> 2); 29290| 2.22k| for (int32_t i = 0; i < words; i++) ------------------ | Branch (29290:25): [True: 1.38k, False: 840] ------------------ 29291| | janet_v_push(b->bytecode, 0); ------------------ | | 757| 1.38k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.38k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.38k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.38k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.38k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.38k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.38k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 1.38k] | | | | | | | Branch (768:50): [True: 256, False: 1.13k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 256|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.38k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.38k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 29292| 840| memcpy(b->bytecode + next_rule + 2, bytes, len); 29293| 840|} janet.c:spec_repeat: 29440| 453|static void spec_repeat(Builder *b, int32_t argc, const Janet *argv) { 29441| 453| peg_fixarity(b, argc, 2); 29442| 453| Reserve r = reserve(b, 4); 29443| 453| int32_t n = peg_getnat(b, argv[0]); 29444| 453| uint32_t subrule = peg_compile1(b, argv[1]); 29445| 453| emit_3(r, RULE_BETWEEN, n, n, subrule); 29446| 453|} janet.c:peg_fixarity: 29183| 555|static void peg_fixarity(Builder *b, int32_t argc, int32_t arity) { 29184| 555| if (argc != arity) { ------------------ | Branch (29184:9): [True: 54, False: 501] ------------------ 29185| 54| peg_panicf(b, "expected %d argument%s, got %d", ------------------ | |29181| 108|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) | | ------------------ | | | Branch (29181:71): [True: 16, False: 38] | | ------------------ ------------------ 29186| 54| arity, 29187| 54| arity == 1 ? "" : "s", 29188| 54| argc); 29189| 54| } 29190| 555|} janet.c:peg_getnat: 29223| 415|static int32_t peg_getnat(Builder *b, Janet x) { 29224| 415| int32_t i = peg_getinteger(b, x); 29225| 415| if (i < 0) ------------------ | Branch (29225:9): [True: 0, False: 415] ------------------ 29226| 0| peg_panicf(b, "expected non-negative integer, got %v", x); ------------------ | |29181| 0|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29227| 415| return i; 29228| 415|} janet.c:emit_3: 29303| 509|static void emit_3(Reserve r, uint32_t op, uint32_t arg1, uint32_t arg2, uint32_t arg3) { 29304| 509| uint32_t arr[3] = {arg1, arg2, arg3}; 29305| 509| emit_rule(r, op, 3, arr); 29306| 509|} janet.c:spec_not: 29456| 54|static void spec_not(Builder *b, int32_t argc, const Janet *argv) { 29457| 54| spec_onerule(b, argc, argv, RULE_NOT); 29458| 54|} janet.c:spec_onerule: 29449| 54|static void spec_onerule(Builder *b, int32_t argc, const Janet *argv, uint32_t op) { 29450| 54| peg_fixarity(b, argc, 1); 29451| 54| Reserve r = reserve(b, 2); 29452| 54| uint32_t rule = peg_compile1(b, argv[0]); 29453| 54| emit_1(r, op, rule); 29454| 54|} janet.c:spec_position: 29548| 29|static void spec_position(Builder *b, int32_t argc, const Janet *argv) { 29549| 29| spec_tag1(b, argc, argv, RULE_POSITION); 29550| 29|} janet.c:spec_tag1: 29540| 138|static void spec_tag1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) { 29541| 138| peg_arity(b, argc, 0, 1); 29542| 138| Reserve r = reserve(b, 2); 29543| 138| uint32_t tag = (argc) ? emit_tag(b, argv[0]) : 0; ------------------ | Branch (29543:20): [True: 9, False: 129] ------------------ 29544| 138| (void) argv; 29545| 138| emit_1(r, op, tag); 29546| 138|} janet.c:peg_arity: 29192| 5.96k|static void peg_arity(Builder *b, int32_t arity, int32_t min, int32_t max) { 29193| 5.96k| if (min >= 0 && arity < min) ------------------ | Branch (29193:9): [True: 5.96k, False: 0] | Branch (29193:21): [True: 13, False: 5.94k] ------------------ 29194| 13| peg_panicf(b, "arity mismatch, expected at least %d, got %d", min, arity); ------------------ | |29181| 13|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29195| 5.94k| if (max >= 0 && arity > max) ------------------ | Branch (29195:9): [True: 5.89k, False: 48] | Branch (29195:21): [True: 28, False: 5.87k] ------------------ 29196| 28| peg_panicf(b, "arity mismatch, expected at most %d, got %d", max, arity); ------------------ | |29181| 28|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29197| 5.94k|} janet.c:emit_tag: 29240| 44|static uint32_t emit_tag(Builder *b, Janet t) { 29241| 44| if (!janet_checktype(t, JANET_KEYWORD)) ------------------ | | 806| 44| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 44] | | ------------------ | | 807| 44| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 44| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 44| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 44|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 44|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 44|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29241:9): [True: 29, False: 15] ------------------ 29242| 29| peg_panicf(b, "expected keyword for capture tag, got %v", t); ------------------ | |29181| 29|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29243| 15| Janet check = janet_table_get(b->tags, t); 29244| 15| if (janet_checktype(check, JANET_NIL)) { ------------------ | | 806| 15| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 14, False: 1] | | | Branch (806:6): [Folded, False: 15] | | ------------------ | | 807| 15| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 15| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 15| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 15|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 15|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 15|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29245| 14| uint32_t tag = b->nexttag++; 29246| 14| if (tag > 255) { ------------------ | Branch (29246:13): [True: 0, False: 14] ------------------ 29247| 0| peg_panic(b, "too many tags - up to 255 tags are supported per peg"); 29248| 0| } 29249| 14| Janet val = janet_wrap_number(tag); ------------------ | | 835| 14|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 29250| 14| janet_table_put(b->tags, t, val); 29251| 14| return tag; 29252| 14| } else { 29253| 1| return (uint32_t) janet_unwrap_number(check); ------------------ | | 839| 1|#define janet_unwrap_number(x) ((x).number) ------------------ 29254| 1| } 29255| 15|} janet.c:spec_accumulate: 29493| 107|static void spec_accumulate(Builder *b, int32_t argc, const Janet *argv) { 29494| 107| spec_cap1(b, argc, argv, RULE_ACCUMULATE); 29495| 107|} janet.c:spec_cap1: 29482| 5.49k|static void spec_cap1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) { 29483| 5.49k| peg_arity(b, argc, 1, 2); 29484| 5.49k| Reserve r = reserve(b, 3); 29485| 5.49k| uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0; ------------------ | Branch (29485:20): [True: 14, False: 5.47k] ------------------ 29486| 5.49k| uint32_t rule = peg_compile1(b, argv[0]); 29487| 5.49k| emit_2(r, op, rule, tag); 29488| 5.49k|} janet.c:emit_2: 29299| 3.14k|static void emit_2(Reserve r, uint32_t op, uint32_t arg1, uint32_t arg2) { 29300| 3.14k| uint32_t arr[2] = {arg1, arg2}; 29301| 3.14k| emit_rule(r, op, 2, arr); 29302| 3.14k|} janet.c:spec_sequence: 29371| 454|static void spec_sequence(Builder *b, int32_t argc, const Janet *argv) { 29372| 454| spec_variadic(b, argc, argv, RULE_SEQUENCE); 29373| 454|} janet.c:spec_variadic: 29356| 936|static void spec_variadic(Builder *b, int32_t argc, const Janet *argv, uint32_t op) { 29357| 936| uint32_t rule = janet_v_count(b->bytecode); ------------------ | | 759| 936|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 627|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 627|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 627, False: 309] | | ------------------ ------------------ 29358| 936| janet_v_push(b->bytecode, op); ------------------ | | 757| 936|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 936|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 936|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 627|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 627|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 627|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 627|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 309, False: 627] | | | | | | | Branch (768:50): [True: 53, False: 574] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 362|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 936|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 936|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 29359| 936| janet_v_push(b->bytecode, argc); ------------------ | | 757| 936|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 936|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 936|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 936|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 936|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 936|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 936|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 936] | | | | | | | Branch (768:50): [True: 348, False: 588] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 348|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 936|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 936|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 29360| 4.90k| for (int32_t i = 0; i < argc; i++) ------------------ | Branch (29360:25): [True: 3.97k, False: 936] ------------------ 29361| 3.97k| janet_v_push(b->bytecode, 0); ------------------ | | 757| 3.97k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 3.97k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 3.97k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 3.97k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 3.97k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 3.97k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 3.97k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 3.97k] | | | | | | | Branch (768:50): [True: 856, False: 3.11k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 856|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 3.97k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.97k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 29362| 4.60k| for (int32_t i = 0; i < argc; i++) { ------------------ | Branch (29362:25): [True: 3.66k, False: 936] ------------------ 29363| 3.66k| uint32_t rulei = peg_compile1(b, argv[i]); 29364| 3.66k| b->bytecode[rule + 2 + i] = rulei; 29365| 3.66k| } 29366| 936|} janet.c:spec_choice: 29368| 482|static void spec_choice(Builder *b, int32_t argc, const Janet *argv) { 29369| 482| spec_variadic(b, argc, argv, RULE_CHOICE); 29370| 482|} janet.c:spec_reference: 29531| 14|static void spec_reference(Builder *b, int32_t argc, const Janet *argv) { 29532| 14| peg_arity(b, argc, 1, 2); 29533| 14| Reserve r = reserve(b, 3); 29534| 14| uint32_t search = emit_tag(b, argv[0]); 29535| 14| uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0; ------------------ | Branch (29535:20): [True: 4, False: 10] ------------------ 29536| 14| b->has_backref = 1; 29537| 14| emit_2(r, RULE_GETTAG, search, tag); 29538| 14|} janet.c:spec_replace: 29586| 96|static void spec_replace(Builder *b, int32_t argc, const Janet *argv) { 29587| 96| peg_arity(b, argc, 2, 3); 29588| 96| Reserve r = reserve(b, 4); 29589| 96| uint32_t subrule = peg_compile1(b, argv[0]); 29590| 96| uint32_t constant = emit_constant(b, argv[1]); 29591| 96| uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0; ------------------ | Branch (29591:20): [True: 6, False: 90] ------------------ 29592| 96| emit_3(r, RULE_REPLACE, subrule, constant, tag); 29593| 96|} janet.c:emit_constant: 29234| 81|static uint32_t emit_constant(Builder *b, Janet c) { 29235| 81| uint32_t cindex = (uint32_t) janet_v_count(b->constants); ------------------ | | 759| 81|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 36|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 36|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 36, False: 45] | | ------------------ ------------------ 29236| | janet_v_push(b->constants, c); ------------------ | | 757| 81|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 81|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 81|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 36|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 36|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 36|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 36|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 45, False: 36] | | | | | | | Branch (768:50): [True: 36, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 81|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 81|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 81|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 29237| 81| return cindex; 29238| 81|} janet.c:spec_capture: 29490| 5.38k|static void spec_capture(Builder *b, int32_t argc, const Janet *argv) { 29491| 5.38k| spec_cap1(b, argc, argv, RULE_CAPTURE); 29492| 5.38k|} janet.c:spec_look: 29346| 73|static void spec_look(Builder *b, int32_t argc, const Janet *argv) { 29347| 73| peg_arity(b, argc, 1, 2); 29348| 73| Reserve r = reserve(b, 3); 29349| 73| int32_t rulearg = argc == 2 ? 1 : 0; ------------------ | Branch (29349:23): [True: 16, False: 57] ------------------ 29350| 73| int32_t offset = argc == 2 ? peg_getinteger(b, argv[0]) : 0; ------------------ | Branch (29350:22): [True: 16, False: 57] ------------------ 29351| 73| uint32_t subrule = peg_compile1(b, argv[rulearg]); 29352| 73| emit_2(r, RULE_LOOK, (uint32_t) offset, subrule); 29353| 73|} janet.c:spec_opt: 29433| 48|static void spec_opt(Builder *b, int32_t argc, const Janet *argv) { 29434| 48| peg_fixarity(b, argc, 1); 29435| 48| Reserve r = reserve(b, 4); 29436| 48| uint32_t subrule = peg_compile1(b, argv[0]); 29437| 48| emit_3(r, RULE_BETWEEN, 0, 1, subrule); 29438| 48|} janet.c:spec_debug: 29578| 99|static void spec_debug(Builder *b, int32_t argc, const Janet *argv) { 29579| 99| peg_arity(b, argc, 0, 0); 29580| 99| Reserve r = reserve(b, 1); 29581| 99| uint32_t empty = 0; 29582| 99| (void) argv; 29583| 99| emit_rule(r, RULE_DEBUG, 0, &empty); 29584| 99|} janet.c:spec_column: 29554| 52|static void spec_column(Builder *b, int32_t argc, const Janet *argv) { 29555| 52| spec_tag1(b, argc, argv, RULE_COLUMN); 29556| 52|} janet.c:spec_line: 29551| 57|static void spec_line(Builder *b, int32_t argc, const Janet *argv) { 29552| 57| spec_tag1(b, argc, argv, RULE_LINE); 29553| 57|} janet.c:spec_range: 29316| 49|static void spec_range(Builder *b, int32_t argc, const Janet *argv) { 29317| 49| peg_arity(b, argc, 1, -1); 29318| 49| if (argc == 1) { ------------------ | Branch (29318:9): [True: 18, False: 31] ------------------ 29319| 18| Reserve r = reserve(b, 2); 29320| 18| const uint8_t *str = peg_getrange(b, argv[0]); 29321| 18| uint32_t arg = str[0] | (str[1] << 16); 29322| 18| emit_1(r, RULE_RANGE, arg); 29323| 31| } else { 29324| | /* Compile as a set */ 29325| 31| Reserve r = reserve(b, 9); 29326| 31| uint32_t bitmap[8] = {0}; 29327| 80| for (int32_t i = 0; i < argc; i++) { ------------------ | Branch (29327:29): [True: 49, False: 31] ------------------ 29328| 49| const uint8_t *str = peg_getrange(b, argv[i]); 29329| 1.72k| for (uint32_t c = str[0]; c <= str[1]; c++) ------------------ | Branch (29329:39): [True: 1.67k, False: 49] ------------------ 29330| 1.67k| bitmap_set(bitmap, c); 29331| 49| } 29332| 31| emit_rule(r, RULE_SET, 8, bitmap); 29333| 31| } 29334| 49|} janet.c:peg_getrange: 29206| 67|static const uint8_t *peg_getrange(Builder *b, Janet x) { 29207| 67| if (!janet_checktype(x, JANET_STRING)) ------------------ | | 806| 67| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 67] | | ------------------ | | 807| 67| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 67| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 67| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 67|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 67|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 67|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29207:9): [True: 22, False: 45] ------------------ 29208| 22| peg_panic(b, "expected string for character range"); 29209| 45| const uint8_t *str = janet_unwrap_string(x); ------------------ | | 863| 45|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 29210| 45| if (janet_string_length(str) != 2) ------------------ | | 1813| 45|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 45|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (29210:9): [True: 9, False: 36] ------------------ 29211| 9| peg_panicf(b, "expected string to have length 2, got %v", x); ------------------ | |29181| 9|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29212| 36| if (str[1] < str[0]) ------------------ | Branch (29212:9): [True: 2, False: 34] ------------------ 29213| 2| peg_panicf(b, "range %v is empty", x); ------------------ | |29181| 2|#define peg_panicf(b,...) peg_panic((b), (const char *) janet_formatc(__VA_ARGS__)) ------------------ 29214| 34| return str; 29215| 36|} janet.c:bitmap_set: 29312| 1.67k|static void bitmap_set(uint32_t *bitmap, uint8_t c) { 29313| 1.67k| bitmap[c >> 5] |= ((uint32_t)1) << (c & 0x1F); 29314| 1.67k|} janet.c:make_peg: 30187| 1.23k|static JanetPeg *make_peg(Builder *b) { 30188| 1.23k| size_t bytecode_start = size_padded(sizeof(JanetPeg), sizeof(uint32_t)); 30189| 1.23k| size_t bytecode_size = janet_v_count(b->bytecode) * sizeof(uint32_t); ------------------ | | 759| 1.23k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.23k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.23k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.23k, False: 0] | | ------------------ ------------------ 30190| 1.23k| size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet)); 30191| 1.23k| size_t constants_size = janet_v_count(b->constants) * sizeof(Janet); ------------------ | | 759| 1.23k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 30|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 30|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 30, False: 1.20k] | | ------------------ ------------------ 30192| 1.23k| size_t total_size = constants_start + constants_size; 30193| 1.23k| char *mem = janet_abstract(&janet_peg_type, total_size); 30194| 1.23k| JanetPeg *peg = (JanetPeg *)mem; 30195| 1.23k| peg->bytecode = (uint32_t *)(mem + bytecode_start); 30196| 1.23k| peg->constants = (Janet *)(mem + constants_start); 30197| 1.23k| peg->num_constants = janet_v_count(b->constants); ------------------ | | 759| 1.23k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 30|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 30|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 30, False: 1.20k] | | ------------------ ------------------ 30198| 1.23k| safe_memcpy(peg->bytecode, b->bytecode, bytecode_size); 30199| 1.23k| safe_memcpy(peg->constants, b->constants, constants_size); 30200| | peg->bytecode_len = janet_v_count(b->bytecode); ------------------ | | 759| 1.23k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.23k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.23k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.23k, False: 0] | | ------------------ ------------------ 30201| 1.23k| peg->has_backref = b->has_backref; 30202| 1.23k| return peg; 30203| 1.23k|} janet.c:builder_cleanup: 29171| 3.43k|static void builder_cleanup(Builder *b) { 29172| 3.43k| janet_v_free(b->constants); ------------------ | | 756| 3.43k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 45|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 45, False: 3.38k] | | ------------------ ------------------ 29173| | janet_v_free(b->bytecode); ------------------ | | 756| 3.43k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 1.46k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 1.46k, False: 1.96k] | | ------------------ ------------------ 29174| 3.43k|} janet.c:peg_cfun_init: 30253| 3.43k|static PegCall peg_cfun_init(int32_t argc, Janet *argv, int get_replace) { 30254| 3.43k| PegCall ret; 30255| 3.43k| int32_t min = get_replace ? 3 : 2; ------------------ | Branch (30255:19): [True: 0, False: 3.43k] ------------------ 30256| 3.43k| janet_arity(argc, min, -1); 30257| 3.43k| if (janet_checktype(argv[0], JANET_ABSTRACT) && ------------------ | | 806| 6.86k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 77, False: 3.35k] | | | Branch (806:6): [Folded, False: 3.43k] | | ------------------ | | 807| 6.86k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.86k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.43k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.43k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.43k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.43k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 30258| 77| janet_abstract_type(janet_unwrap_abstract(argv[0])) == &janet_peg_type) { ------------------ | | 1899| 77|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 77|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ | Branch (30258:13): [True: 0, False: 77] ------------------ 30259| 0| ret.peg = janet_unwrap_abstract(argv[0]); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 30260| 3.43k| } else { 30261| 3.43k| ret.peg = compile_peg(argv[0]); 30262| 3.43k| } 30263| 3.43k| if (get_replace) { ------------------ | Branch (30263:9): [True: 0, False: 3.43k] ------------------ 30264| 0| ret.subst = argv[1]; 30265| 0| ret.bytes = janet_getbytes(argv, 2); 30266| 3.43k| } else { 30267| 3.43k| ret.bytes = janet_getbytes(argv, 1); 30268| 3.43k| } 30269| 3.43k| if (argc > min) { ------------------ | Branch (30269:9): [True: 0, False: 3.43k] ------------------ 30270| 0| ret.start = janet_gethalfrange(argv, min, ret.bytes.len, "offset"); 30271| 0| ret.s.extrac = argc - min - 1; 30272| 0| ret.s.extrav = janet_tuple_n(argv + min + 1, argc - min - 1); 30273| 3.43k| } else { 30274| 3.43k| ret.start = 0; 30275| 3.43k| ret.s.extrac = 0; 30276| 3.43k| ret.s.extrav = NULL; 30277| 3.43k| } 30278| 3.43k| ret.s.mode = PEG_MODE_NORMAL; 30279| 3.43k| ret.s.text_start = ret.bytes.bytes; 30280| 3.43k| ret.s.text_end = ret.bytes.bytes + ret.bytes.len; 30281| 3.43k| ret.s.outer_text_end = ret.s.text_end; 30282| 3.43k| ret.s.depth = JANET_RECURSION_GUARD; ------------------ | | 296| 3.43k|#define JANET_RECURSION_GUARD 1024 ------------------ 30283| 3.43k| ret.s.captures = janet_array(0); 30284| 3.43k| ret.s.tagged_captures = janet_array(0); 30285| 3.43k| ret.s.scratch = janet_buffer(10); 30286| 3.43k| ret.s.tags = janet_buffer(10); 30287| 3.43k| ret.s.constants = ret.peg->constants; 30288| 3.43k| ret.s.bytecode = ret.peg->bytecode; 30289| | ret.s.linemap = NULL; 30290| 3.43k| ret.s.linemaplen = -1; 30291| 3.43k| ret.s.has_backref = ret.peg->has_backref; 30292| 3.43k| return ret; 30293| 3.43k|} janet.c:peg_rule: 28479| 389M| const uint8_t *text) { 28480| 389M|tail: 28481| 389M| switch (*rule) { 28482| 0| default: ------------------ | Branch (28482:9): [True: 0, False: 389M] ------------------ 28483| 0| janet_panic("unexpected opcode"); 28484| 0| return NULL; 28485| | 28486| 859| case RULE_LITERAL: { ------------------ | Branch (28486:9): [True: 859, False: 389M] ------------------ 28487| 859| uint32_t len = rule[1]; 28488| 859| if (text + len > s->text_end) return NULL; ------------------ | Branch (28488:17): [True: 111, False: 748] ------------------ 28489| 748| return memcmp(text, rule + 2, len) ? NULL : text + len; ------------------ | Branch (28489:20): [True: 152, False: 596] ------------------ 28490| 859| } 28491| | 28492| 132k| case RULE_DEBUG: { ------------------ | Branch (28492:9): [True: 132k, False: 389M] ------------------ 28493| 132k| char buffer[32] = {0}; 28494| 132k| size_t len = (size_t)(s->outer_text_end - text); 28495| 132k| memcpy(buffer, text, (len > 31 ? 31 : len)); ------------------ | Branch (28495:35): [True: 4.38k, False: 128k] ------------------ 28496| 132k| janet_eprintf("?? at [%s] (index %d)\n", buffer, (int32_t)(text - s->text_start)); ------------------ | | 2195| 132k|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) ------------------ 28497| 132k| int has_color = janet_truthy(janet_dyn("err-color")); ------------------ | | 818| 132k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 264k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 132k] | | | | ------------------ | | | | 807| 264k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 264k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 132k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 132k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 132k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 132k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 132k] | | ------------------ | | 819| 132k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ 28498| | /* Accumulate buffer */ 28499| 132k| if (s->scratch->count) { ------------------ | Branch (28499:17): [True: 0, False: 132k] ------------------ 28500| 0| janet_eprintf("accumulate buffer: %v\n", janet_wrap_buffer(s->scratch)); ------------------ | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) ------------------ 28501| 0| } 28502| | /* Normal captures */ 28503| 132k| if (s->captures->count) { ------------------ | Branch (28503:17): [True: 20.4k, False: 111k] ------------------ 28504| 20.4k| janet_eprintf("stack [%d]:\n", s->captures->count); ------------------ | | 2195| 20.4k|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) ------------------ 28505| 9.04M| for (int32_t i = 0; i < s->captures->count; i++) { ------------------ | Branch (28505:37): [True: 9.01M, False: 20.4k] ------------------ 28506| 9.01M| if (has_color) { ------------------ | Branch (28506:25): [True: 0, False: 9.01M] ------------------ 28507| 0| janet_eprintf(" [%d]: %M\n", i, s->captures->data[i]); ------------------ | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) ------------------ 28508| 9.01M| } else { 28509| 9.01M| janet_eprintf(" [%d]: %m\n", i, s->captures->data[i]); ------------------ | | 2195| 9.01M|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) ------------------ 28510| 9.01M| } 28511| 9.01M| } 28512| 20.4k| } 28513| | /* Tagged captures */ 28514| 132k| if (s->tagged_captures->count) { ------------------ | Branch (28514:17): [True: 0, False: 132k] ------------------ 28515| 0| janet_eprintf("tag stack [%d]:\n", s->tagged_captures->count); ------------------ | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) ------------------ 28516| 0| for (int32_t i = 0; i < s->tagged_captures->count; i++) { ------------------ | Branch (28516:37): [True: 0, False: 0] ------------------ 28517| 0| if (has_color) { ------------------ | Branch (28517:25): [True: 0, False: 0] ------------------ 28518| 0| janet_eprintf(" [%d] tag=%d: %M\n", i, (int32_t) s->tags->data[i], s->tagged_captures->data[i]); ------------------ | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) ------------------ 28519| 0| } else { 28520| 0| janet_eprintf(" [%d] tag=%d: %m\n", i, (int32_t) s->tags->data[i], s->tagged_captures->data[i]); ------------------ | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) ------------------ 28521| 0| } 28522| 0| } 28523| 0| } 28524| 132k| return text; 28525| 859| } 28526| | 28527| 273M| case RULE_NCHAR: { ------------------ | Branch (28527:9): [True: 273M, False: 116M] ------------------ 28528| 273M| uint32_t n = rule[1]; 28529| 273M| return (text + n > s->text_end) ? NULL : text + n; ------------------ | Branch (28529:20): [True: 1.72k, False: 273M] ------------------ 28530| 859| } 28531| | 28532| 70.1k| case RULE_NOTNCHAR: { ------------------ | Branch (28532:9): [True: 70.1k, False: 389M] ------------------ 28533| 70.1k| uint32_t n = rule[1]; 28534| 70.1k| return (text + n > s->text_end) ? text : NULL; ------------------ | Branch (28534:20): [True: 4.49k, False: 65.6k] ------------------ 28535| 859| } 28536| | 28537| 12| case RULE_RANGE: { ------------------ | Branch (28537:9): [True: 12, False: 389M] ------------------ 28538| 12| uint8_t lo = rule[1] & 0xFF; 28539| 12| uint8_t hi = (rule[1] >> 16) & 0xFF; 28540| 12| return (text < s->text_end && ------------------ | Branch (28540:21): [True: 12, False: 0] ------------------ 28541| 12| text[0] >= lo && ------------------ | Branch (28541:21): [True: 8, False: 4] ------------------ 28542| 8| text[0] <= hi) ------------------ | Branch (28542:21): [True: 3, False: 5] ------------------ 28543| 12| ? text + 1 28544| 12| : NULL; 28545| 859| } 28546| | 28547| 3| case RULE_SET: { ------------------ | Branch (28547:9): [True: 3, False: 389M] ------------------ 28548| 3| if (text >= s->text_end) return NULL; ------------------ | Branch (28548:17): [True: 0, False: 3] ------------------ 28549| 3| uint32_t word = rule[1 + (text[0] >> 5)]; 28550| 3| uint32_t mask = (uint32_t)1 << (text[0] & 0x1F); 28551| 3| return (word & mask) ------------------ | Branch (28551:20): [True: 1, False: 2] ------------------ 28552| 3| ? text + 1 28553| 3| : NULL; 28554| 3| } 28555| | 28556| 352| case RULE_LOOK: { ------------------ | Branch (28556:9): [True: 352, False: 389M] ------------------ 28557| 352| text += ((int32_t *)rule)[1]; 28558| 352| if (text < s->text_start || text > s->text_end) return NULL; ------------------ | Branch (28558:17): [True: 1, False: 351] | Branch (28558:41): [True: 2, False: 349] ------------------ 28559| 349| down1(s); ------------------ | |28464| 349|#define down1(s) do { \ | |28465| 349| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 349] | | ------------------ | |28466| 349|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 349] | | ------------------ ------------------ 28560| 349| const uint8_t *result = peg_rule(s, s->bytecode + rule[2], text); 28561| 349| up1(s); ------------------ | |28467| 349|#define up1(s) ((s)->depth++) ------------------ 28562| 349| text -= ((int32_t *)rule)[1]; 28563| 349| return result ? text : NULL; ------------------ | Branch (28563:20): [True: 335, False: 14] ------------------ 28564| 349| } 28565| | 28566| 5.70k| case RULE_CHOICE: { ------------------ | Branch (28566:9): [True: 5.70k, False: 389M] ------------------ 28567| 5.70k| uint32_t len = rule[1]; 28568| 5.70k| const uint32_t *args = rule + 2; 28569| 5.70k| if (len == 0) return NULL; ------------------ | Branch (28569:17): [True: 1.94k, False: 3.76k] ------------------ 28570| 3.76k| down1(s); ------------------ | |28464| 3.76k|#define down1(s) do { \ | |28465| 3.76k| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 3.76k] | | ------------------ | |28466| 3.76k|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 3.76k] | | ------------------ ------------------ 28571| 3.76k| CapState cs = cap_save(s); 28572| 6.39k| for (uint32_t i = 0; i < len - 1; i++) { ------------------ | Branch (28572:34): [True: 3.44k, False: 2.95k] ------------------ 28573| 3.44k| const uint8_t *result = peg_rule(s, s->bytecode + args[i], text); 28574| 3.44k| if (result) { ------------------ | Branch (28574:21): [True: 803, False: 2.63k] ------------------ 28575| 803| up1(s); ------------------ | |28467| 803|#define up1(s) ((s)->depth++) ------------------ 28576| 803| return result; 28577| 803| } 28578| 2.63k| cap_load(s, cs); 28579| 2.63k| } 28580| 2.95k| up1(s); ------------------ | |28467| 2.95k|#define up1(s) ((s)->depth++) ------------------ 28581| 2.95k| rule = s->bytecode + args[len - 1]; 28582| 2.95k| goto tail; 28583| 3.76k| } 28584| | 28585| 3.30k| case RULE_SEQUENCE: { ------------------ | Branch (28585:9): [True: 3.30k, False: 389M] ------------------ 28586| 3.30k| uint32_t len = rule[1]; 28587| 3.30k| const uint32_t *args = rule + 2; 28588| 3.30k| if (len == 0) return text; ------------------ | Branch (28588:17): [True: 2.33k, False: 971] ------------------ 28589| 971| down1(s); ------------------ | |28464| 971|#define down1(s) do { \ | |28465| 971| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 971] | | ------------------ | |28466| 971|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 971] | | ------------------ ------------------ 28590| 1.60k| for (uint32_t i = 0; text && i < len - 1; i++) ------------------ | Branch (28590:34): [True: 1.48k, False: 114] | Branch (28590:42): [True: 632, False: 857] ------------------ 28591| 632| text = peg_rule(s, s->bytecode + args[i], text); 28592| 971| up1(s); ------------------ | |28467| 971|#define up1(s) ((s)->depth++) ------------------ 28593| 971| if (!text) return NULL; ------------------ | Branch (28593:17): [True: 114, False: 857] ------------------ 28594| 857| rule = s->bytecode + args[len - 1]; 28595| 857| goto tail; 28596| 971| } 28597| | 28598| 0| case RULE_IF: { ------------------ | Branch (28598:9): [True: 0, False: 389M] ------------------ 28599| 0| const uint32_t *rule_a = s->bytecode + rule[1]; 28600| 0| const uint32_t *rule_b = s->bytecode + rule[2]; 28601| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28602| 0| const uint8_t *result = peg_rule(s, rule_a, text); 28603| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28604| 0| if (!result) return NULL; ------------------ | Branch (28604:17): [True: 0, False: 0] ------------------ 28605| 0| rule = rule_b; 28606| 0| goto tail; 28607| 0| } 28608| 0| case RULE_IFNOT: { ------------------ | Branch (28608:9): [True: 0, False: 389M] ------------------ 28609| 0| const uint32_t *rule_a = s->bytecode + rule[1]; 28610| 0| const uint32_t *rule_b = s->bytecode + rule[2]; 28611| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28612| 0| CapState cs = cap_save(s); 28613| 0| const uint8_t *result = peg_rule(s, rule_a, text); 28614| 0| if (!!result) { ------------------ | Branch (28614:17): [True: 0, False: 0] ------------------ 28615| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28616| 0| return NULL; 28617| 0| } else { 28618| 0| cap_load(s, cs); 28619| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28620| 0| rule = rule_b; 28621| 0| goto tail; 28622| 0| } 28623| 0| } 28624| | 28625| 385| case RULE_NOT: { ------------------ | Branch (28625:9): [True: 385, False: 389M] ------------------ 28626| 385| const uint32_t *rule_a = s->bytecode + rule[1]; 28627| 385| down1(s); ------------------ | |28464| 385|#define down1(s) do { \ | |28465| 385| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 385] | | ------------------ | |28466| 385|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 385] | | ------------------ ------------------ 28628| 385| CapState cs = cap_save(s); 28629| 385| const uint8_t *result = peg_rule(s, rule_a, text); 28630| 385| if (result) { ------------------ | Branch (28630:17): [True: 30, False: 355] ------------------ 28631| 30| up1(s); ------------------ | |28467| 30|#define up1(s) ((s)->depth++) ------------------ 28632| 30| return NULL; 28633| 355| } else { 28634| 355| cap_load(s, cs); 28635| 355| up1(s); ------------------ | |28467| 355|#define up1(s) ((s)->depth++) ------------------ 28636| 355| return text; 28637| 355| } 28638| 385| } 28639| | 28640| 0| case RULE_THRU: ------------------ | Branch (28640:9): [True: 0, False: 389M] ------------------ 28641| 0| case RULE_TO: { ------------------ | Branch (28641:9): [True: 0, False: 389M] ------------------ 28642| 0| const uint32_t *rule_a = s->bytecode + rule[1]; 28643| 0| const uint8_t *next_text = NULL; 28644| 0| CapState cs = cap_save(s); 28645| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28646| 0| while (text <= s->text_end) { ------------------ | Branch (28646:20): [True: 0, False: 0] ------------------ 28647| 0| CapState cs2 = cap_save(s); 28648| 0| next_text = peg_rule(s, rule_a, text); 28649| 0| if (next_text) { ------------------ | Branch (28649:21): [True: 0, False: 0] ------------------ 28650| 0| if (rule[0] == RULE_TO) cap_load(s, cs2); ------------------ | Branch (28650:25): [True: 0, False: 0] ------------------ 28651| 0| break; 28652| 0| } 28653| 0| cap_load(s, cs2); 28654| 0| text++; 28655| 0| } 28656| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28657| 0| if (text > s->text_end) { ------------------ | Branch (28657:17): [True: 0, False: 0] ------------------ 28658| 0| cap_load(s, cs); 28659| 0| return NULL; 28660| 0| } 28661| 0| return rule[0] == RULE_TO ? text : next_text; ------------------ | Branch (28661:20): [True: 0, False: 0] ------------------ 28662| 0| } 28663| | 28664| 70.6k| case RULE_BETWEEN: { ------------------ | Branch (28664:9): [True: 70.6k, False: 389M] ------------------ 28665| 70.6k| uint32_t lo = rule[1]; 28666| 70.6k| uint32_t hi = rule[2]; 28667| 70.6k| const uint32_t *rule_a = s->bytecode + rule[3]; 28668| 70.6k| uint32_t captured = 0; 28669| 70.6k| const uint8_t *next_text; 28670| 70.6k| CapState cs = cap_save(s); 28671| 70.6k| down1(s); ------------------ | |28464| 70.6k|#define down1(s) do { \ | |28465| 70.6k| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 70.6k] | | ------------------ | |28466| 70.6k|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 70.6k] | | ------------------ ------------------ 28672| 373M| while (captured < hi) { ------------------ | Branch (28672:20): [True: 373M, False: 2.59k] ------------------ 28673| 373M| CapState cs2 = cap_save(s); 28674| 373M| next_text = peg_rule(s, rule_a, text); 28675| 373M| if (!next_text || ((next_text == text) && (hi == UINT32_MAX))) { ------------------ | Branch (28675:21): [True: 68.0k, False: 372M] | Branch (28675:36): [True: 372M, False: 515] | Branch (28675:59): [True: 0, False: 372M] ------------------ 28676| 68.0k| cap_load(s, cs2); 28677| 68.0k| break; 28678| 68.0k| } 28679| 372M| captured++; 28680| 372M| text = next_text; 28681| 372M| } 28682| 70.6k| up1(s); ------------------ | |28467| 70.6k|#define up1(s) ((s)->depth++) ------------------ 28683| 70.6k| if (captured < lo) { ------------------ | Branch (28683:17): [True: 1.88k, False: 68.7k] ------------------ 28684| 1.88k| cap_load(s, cs); 28685| 1.88k| return NULL; 28686| 1.88k| } 28687| 68.7k| return text; 28688| 70.6k| } 28689| | 28690| | /* Capturing rules */ 28691| | 28692| 4| case RULE_GETTAG: { ------------------ | Branch (28692:9): [True: 4, False: 389M] ------------------ 28693| 4| uint32_t search = rule[1]; 28694| 4| uint32_t tag = rule[2]; 28695| 4| for (int32_t i = s->tags->count - 1; i >= 0; i--) { ------------------ | Branch (28695:50): [True: 0, False: 4] ------------------ 28696| 0| if (s->tags->data[i] == search) { ------------------ | Branch (28696:21): [True: 0, False: 0] ------------------ 28697| 0| pushcap(s, s->tagged_captures->data[i], tag); 28698| 0| return text; 28699| 0| } 28700| 0| } 28701| 4| return NULL; 28702| 4| } 28703| | 28704| 90.4M| case RULE_POSITION: { ------------------ | Branch (28704:9): [True: 90.4M, False: 299M] ------------------ 28705| 90.4M| pushcap(s, janet_wrap_number((double)(text - s->text_start)), rule[1]); ------------------ | | 835| 90.4M|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 28706| 90.4M| return text; 28707| 4| } 28708| | 28709| 57| case RULE_LINE: { ------------------ | Branch (28709:9): [True: 57, False: 389M] ------------------ 28710| 57| LineCol lc = get_linecol_from_position(s, (int32_t)(text - s->text_start)); 28711| 57| pushcap(s, janet_wrap_number((double)(lc.line)), rule[1]); ------------------ | | 835| 57|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 28712| 57| return text; 28713| 4| } 28714| | 28715| 9.10M| case RULE_COLUMN: { ------------------ | Branch (28715:9): [True: 9.10M, False: 380M] ------------------ 28716| 9.10M| LineCol lc = get_linecol_from_position(s, (int32_t)(text - s->text_start)); 28717| 9.10M| pushcap(s, janet_wrap_number((double)(lc.col)), rule[1]); ------------------ | | 835| 9.10M|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 28718| 9.10M| return text; 28719| 4| } 28720| | 28721| 0| case RULE_ARGUMENT: { ------------------ | Branch (28721:9): [True: 0, False: 389M] ------------------ 28722| 0| int32_t index = ((int32_t *)rule)[1]; 28723| 0| Janet capture = (index >= s->extrac) ? janet_wrap_nil() : s->extrav[index]; ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (28723:29): [True: 0, False: 0] ------------------ 28724| 0| pushcap(s, capture, rule[2]); 28725| 0| return text; 28726| 4| } 28727| | 28728| 0| case RULE_CONSTANT: { ------------------ | Branch (28728:9): [True: 0, False: 389M] ------------------ 28729| 0| pushcap(s, s->constants[rule[1]], rule[2]); 28730| 0| return text; 28731| 4| } 28732| | 28733| 16.0M| case RULE_CAPTURE: { ------------------ | Branch (28733:9): [True: 16.0M, False: 373M] ------------------ 28734| 16.0M| down1(s); ------------------ | |28464| 16.0M|#define down1(s) do { \ | |28465| 16.0M| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 16.0M] | | ------------------ | |28466| 16.0M|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 16.0M] | | ------------------ ------------------ 28735| 16.0M| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 28736| 16.0M| up1(s); ------------------ | |28467| 16.0M|#define up1(s) ((s)->depth++) ------------------ 28737| 16.0M| if (!result) return NULL; ------------------ | Branch (28737:17): [True: 750, False: 16.0M] ------------------ 28738| | /* Specialized pushcap - avoid intermediate string creation */ 28739| 16.0M| if (!s->has_backref && s->mode == PEG_MODE_ACCUMULATE) { ------------------ | Branch (28739:17): [True: 16.0M, False: 0] | Branch (28739:36): [True: 1.19k, False: 16.0M] ------------------ 28740| 1.19k| janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text)); 28741| 16.0M| } else { 28742| 16.0M| uint32_t tag = rule[2]; 28743| 16.0M| pushcap(s, janet_stringv(text, (int32_t)(result - text)), tag); ------------------ | | 1827| 16.0M|#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) | | ------------------ | | | | 848| 16.0M|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 16.0M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 16.0M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 16.0M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 28744| 16.0M| } 28745| 16.0M| return result; 28746| 16.0M| } 28747| | 28748| 0| case RULE_CAPTURE_NUM: { ------------------ | Branch (28748:9): [True: 0, False: 389M] ------------------ 28749| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28750| 0| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 28751| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28752| 0| if (!result) return NULL; ------------------ | Branch (28752:17): [True: 0, False: 0] ------------------ 28753| | /* check number parsing */ 28754| 0| double x = 0.0; 28755| 0| int32_t base = (int32_t) rule[2]; 28756| 0| if (janet_scan_number_base(text, (int32_t)(result - text), base, &x)) return NULL; ------------------ | Branch (28756:17): [True: 0, False: 0] ------------------ 28757| | /* Specialized pushcap - avoid intermediate string creation */ 28758| 0| if (!s->has_backref && s->mode == PEG_MODE_ACCUMULATE) { ------------------ | Branch (28758:17): [True: 0, False: 0] | Branch (28758:36): [True: 0, False: 0] ------------------ 28759| 0| janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text)); 28760| 0| } else { 28761| 0| uint32_t tag = rule[3]; 28762| 0| pushcap(s, janet_wrap_number(x), tag); ------------------ | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 28763| 0| } 28764| 0| return result; 28765| 0| } 28766| | 28767| 701k| case RULE_ACCUMULATE: { ------------------ | Branch (28767:9): [True: 701k, False: 389M] ------------------ 28768| 701k| uint32_t tag = rule[2]; 28769| 701k| int oldmode = s->mode; 28770| 701k| if (!tag && oldmode == PEG_MODE_ACCUMULATE) { ------------------ | Branch (28770:17): [True: 701k, False: 5] | Branch (28770:25): [True: 20, False: 701k] ------------------ 28771| 20| rule = s->bytecode + rule[1]; 28772| 20| goto tail; 28773| 20| } 28774| 701k| CapState cs = cap_save(s); 28775| 701k| s->mode = PEG_MODE_ACCUMULATE; 28776| 701k| down1(s); ------------------ | |28464| 701k|#define down1(s) do { \ | |28465| 701k| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 701k] | | ------------------ | |28466| 701k|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 701k] | | ------------------ ------------------ 28777| 701k| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 28778| 701k| up1(s); ------------------ | |28467| 701k|#define up1(s) ((s)->depth++) ------------------ 28779| 701k| s->mode = oldmode; 28780| 701k| if (!result) return NULL; ------------------ | Branch (28780:17): [True: 74, False: 701k] ------------------ 28781| 701k| Janet cap = janet_stringv(s->scratch->data + cs.scratch, ------------------ | | 1827| 701k|#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) | | ------------------ | | | | 848| 701k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 701k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 701k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 701k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 28782| 701k| s->scratch->count - cs.scratch); 28783| 701k| cap_load_keept(s, cs); 28784| 701k| pushcap(s, cap, tag); 28785| 701k| return result; 28786| 701k| } 28787| | 28788| 0| case RULE_DROP: { ------------------ | Branch (28788:9): [True: 0, False: 389M] ------------------ 28789| 0| CapState cs = cap_save(s); 28790| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28791| 0| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 28792| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28793| 0| if (!result) return NULL; ------------------ | Branch (28793:17): [True: 0, False: 0] ------------------ 28794| 0| cap_load(s, cs); 28795| 0| return result; 28796| 0| } 28797| | 28798| 0| case RULE_ONLY_TAGS: { ------------------ | Branch (28798:9): [True: 0, False: 389M] ------------------ 28799| 0| CapState cs = cap_save(s); 28800| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28801| 0| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 28802| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28803| 0| if (!result) return NULL; ------------------ | Branch (28803:17): [True: 0, False: 0] ------------------ 28804| 0| cap_load_keept(s, cs); 28805| 0| return result; 28806| 0| } 28807| | 28808| 0| case RULE_GROUP: { ------------------ | Branch (28808:9): [True: 0, False: 389M] ------------------ 28809| 0| uint32_t tag = rule[2]; 28810| 0| int oldmode = s->mode; 28811| 0| CapState cs = cap_save(s); 28812| 0| s->mode = PEG_MODE_NORMAL; 28813| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28814| 0| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 28815| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28816| 0| s->mode = oldmode; 28817| 0| if (!result) return NULL; ------------------ | Branch (28817:17): [True: 0, False: 0] ------------------ 28818| 0| int32_t num_sub_captures = s->captures->count - cs.cap; 28819| 0| JanetArray *sub_captures = janet_array(num_sub_captures); 28820| 0| safe_memcpy(sub_captures->data, 28821| 0| s->captures->data + cs.cap, 28822| 0| sizeof(Janet) * num_sub_captures); 28823| 0| sub_captures->count = num_sub_captures; 28824| 0| cap_load_keept(s, cs); 28825| 0| pushcap(s, janet_wrap_array(sub_captures), tag); ------------------ | | 845| 0|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 28826| 0| return result; 28827| 0| } 28828| | 28829| 0| case RULE_NTH: { ------------------ | Branch (28829:9): [True: 0, False: 389M] ------------------ 28830| 0| uint32_t nth = rule[1]; 28831| 0| if (nth > INT32_MAX) nth = INT32_MAX; ------------------ | Branch (28831:17): [True: 0, False: 0] ------------------ 28832| 0| uint32_t tag = rule[3]; 28833| 0| int oldmode = s->mode; 28834| 0| CapState cs = cap_save(s); 28835| 0| s->mode = PEG_MODE_NORMAL; 28836| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28837| 0| const uint8_t *result = peg_rule(s, s->bytecode + rule[2], text); 28838| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28839| 0| s->mode = oldmode; 28840| 0| if (!result) return NULL; ------------------ | Branch (28840:17): [True: 0, False: 0] ------------------ 28841| 0| int32_t num_sub_captures = s->captures->count - cs.cap; 28842| 0| Janet cap; 28843| 0| if (num_sub_captures > (int32_t) nth) { ------------------ | Branch (28843:17): [True: 0, False: 0] ------------------ 28844| 0| cap = s->captures->data[cs.cap + nth]; 28845| 0| } else { 28846| 0| return NULL; 28847| 0| } 28848| 0| cap_load_keept(s, cs); 28849| 0| pushcap(s, cap, tag); 28850| 0| return result; 28851| 0| } 28852| | 28853| 0| case RULE_SUB: { ------------------ | Branch (28853:9): [True: 0, False: 389M] ------------------ 28854| 0| const uint8_t *text_start = text; 28855| 0| const uint32_t *rule_window = s->bytecode + rule[1]; 28856| 0| const uint32_t *rule_subpattern = s->bytecode + rule[2]; 28857| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28858| 0| const uint8_t *window_end = peg_rule(s, rule_window, text); 28859| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28860| 0| if (!window_end) { ------------------ | Branch (28860:17): [True: 0, False: 0] ------------------ 28861| 0| return NULL; 28862| 0| } 28863| 0| const uint8_t *saved_end = s->text_end; 28864| 0| s->text_end = window_end; 28865| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28866| 0| const uint8_t *next_text = peg_rule(s, rule_subpattern, text_start); 28867| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28868| 0| s->text_end = saved_end; 28869| | 28870| 0| if (!next_text) { ------------------ | Branch (28870:17): [True: 0, False: 0] ------------------ 28871| 0| return NULL; 28872| 0| } 28873| | 28874| 0| return window_end; 28875| 0| } 28876| | 28877| 0| case RULE_TIL: { ------------------ | Branch (28877:9): [True: 0, False: 389M] ------------------ 28878| 0| const uint32_t *rule_terminus = s->bytecode + rule[1]; 28879| 0| const uint32_t *rule_subpattern = s->bytecode + rule[2]; 28880| | 28881| 0| const uint8_t *terminus_start = text; 28882| 0| const uint8_t *terminus_end = NULL; 28883| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28884| 0| while (terminus_start <= s->text_end) { ------------------ | Branch (28884:20): [True: 0, False: 0] ------------------ 28885| 0| CapState cs2 = cap_save(s); 28886| 0| terminus_end = peg_rule(s, rule_terminus, terminus_start); 28887| 0| cap_load(s, cs2); 28888| 0| if (terminus_end) { ------------------ | Branch (28888:21): [True: 0, False: 0] ------------------ 28889| 0| break; 28890| 0| } 28891| 0| terminus_start++; 28892| 0| } 28893| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28894| | 28895| 0| if (!terminus_end) { ------------------ | Branch (28895:17): [True: 0, False: 0] ------------------ 28896| 0| return NULL; 28897| 0| } 28898| | 28899| 0| const uint8_t *saved_end = s->text_end; 28900| 0| s->text_end = terminus_start; 28901| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28902| 0| const uint8_t *matched = peg_rule(s, rule_subpattern, text); 28903| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28904| 0| s->text_end = saved_end; 28905| | 28906| 0| if (!matched) { ------------------ | Branch (28906:17): [True: 0, False: 0] ------------------ 28907| 0| return NULL; 28908| 0| } 28909| | 28910| 0| return terminus_end; 28911| 0| } 28912| | 28913| 0| case RULE_SPLIT: { ------------------ | Branch (28913:9): [True: 0, False: 389M] ------------------ 28914| 0| const uint8_t *saved_end = s->text_end; 28915| 0| const uint32_t *rule_separator = s->bytecode + rule[1]; 28916| 0| const uint32_t *rule_subpattern = s->bytecode + rule[2]; 28917| | 28918| 0| const uint8_t *chunk_start = text; 28919| 0| const uint8_t *chunk_end = NULL; 28920| | 28921| 0| while (text <= saved_end) { ------------------ | Branch (28921:20): [True: 0, False: 0] ------------------ 28922| | /* Find next split (or end of text) */ 28923| 0| CapState cs = cap_save(s); 28924| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28925| 0| while (text <= saved_end) { ------------------ | Branch (28925:24): [True: 0, False: 0] ------------------ 28926| 0| chunk_end = text; 28927| 0| const uint8_t *check = peg_rule(s, rule_separator, text); 28928| 0| cap_load(s, cs); 28929| 0| if (check) { ------------------ | Branch (28929:25): [True: 0, False: 0] ------------------ 28930| 0| text = check; 28931| 0| break; 28932| 0| } 28933| 0| text++; 28934| 0| } 28935| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28936| | 28937| | /* Match between splits */ 28938| 0| s->text_end = chunk_end; 28939| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 28940| 0| const uint8_t *subpattern_end = peg_rule(s, rule_subpattern, chunk_start); 28941| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 28942| 0| s->text_end = saved_end; 28943| 0| if (!subpattern_end) return NULL; /* Don't match anything */ ------------------ | Branch (28943:21): [True: 0, False: 0] ------------------ 28944| | 28945| | /* Ensure forward progress */ 28946| 0| if (text == chunk_start) return NULL; ------------------ | Branch (28946:21): [True: 0, False: 0] ------------------ 28947| 0| chunk_start = text; 28948| 0| } 28949| | 28950| 0| s->text_end = saved_end; 28951| 0| return s->text_end; 28952| 0| } 28953| | 28954| 349| case RULE_REPLACE: ------------------ | Branch (28954:9): [True: 349, False: 389M] ------------------ 28955| 349| case RULE_MATCHSPLICE: ------------------ | Branch (28955:9): [True: 0, False: 389M] ------------------ 28956| 349| case RULE_MATCHTIME: { ------------------ | Branch (28956:9): [True: 0, False: 389M] ------------------ 28957| 349| uint32_t tag = rule[3]; 28958| 349| int oldmode = s->mode; 28959| 349| CapState cs = cap_save(s); 28960| 349| s->mode = PEG_MODE_NORMAL; 28961| 349| down1(s); ------------------ | |28464| 349|#define down1(s) do { \ | |28465| 349| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 349] | | ------------------ | |28466| 349|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 349] | | ------------------ ------------------ 28962| 349| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 28963| 349| up1(s); ------------------ | |28467| 349|#define up1(s) ((s)->depth++) ------------------ 28964| 349| s->mode = oldmode; 28965| 349| if (!result) return NULL; ------------------ | Branch (28965:17): [True: 28, False: 321] ------------------ 28966| | 28967| 321| Janet cap = janet_wrap_nil(); ------------------ | | 831| 321|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 321| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 321|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 321|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 28968| 321| Janet constant = s->constants[rule[2]]; 28969| 321| switch (janet_type(constant)) { ------------------ | | 795| 321| (isnan((x).number) \ | | 796| 321| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 321| : JANET_NUMBER) ------------------ | Branch (28969:21): [True: 85, False: 236] ------------------ 28970| 321| default: ------------------ | Branch (28970:17): [True: 321, False: 0] ------------------ 28971| 321| cap = constant; 28972| 321| break; 28973| 0| case JANET_STRUCT: ------------------ | Branch (28973:17): [True: 0, False: 321] ------------------ 28974| 0| if (s->captures->count) { ------------------ | Branch (28974:25): [True: 0, False: 0] ------------------ 28975| 0| cap = janet_struct_get(janet_unwrap_struct(constant), ------------------ | | 857| 0|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 28976| 0| s->captures->data[s->captures->count - 1]); 28977| 0| } 28978| 0| break; 28979| 0| case JANET_TABLE: ------------------ | Branch (28979:17): [True: 0, False: 321] ------------------ 28980| 0| if (s->captures->count) { ------------------ | Branch (28980:25): [True: 0, False: 0] ------------------ 28981| 0| cap = janet_table_get(janet_unwrap_table(constant), ------------------ | | 861| 0|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 28982| 0| s->captures->data[s->captures->count - 1]); 28983| 0| } 28984| 0| break; 28985| 0| case JANET_CFUNCTION: ------------------ | Branch (28985:17): [True: 0, False: 321] ------------------ 28986| 0| cap = janet_unwrap_cfunction(constant)(s->captures->count - cs.cap, ------------------ | | 869| 0|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 28987| 0| s->captures->data + cs.cap); 28988| 0| break; 28989| 0| case JANET_FUNCTION: ------------------ | Branch (28989:17): [True: 0, False: 321] ------------------ 28990| 0| cap = janet_call(janet_unwrap_function(constant), ------------------ | | 868| 0|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 28991| 0| s->captures->count - cs.cap, 28992| 0| s->captures->data + cs.cap); 28993| 0| break; 28994| 321| } 28995| 321| cap_load_keept(s, cs); 28996| 321| if (rule[0] != RULE_REPLACE && !janet_truthy(cap)) return NULL; /* matchtime or matchtime flatten */ ------------------ | | 818| 0| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 0] | | ------------------ | | 819| 0| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (28996:17): [True: 0, False: 321] ------------------ 28997| 321| const Janet *elements = NULL; 28998| 321| int32_t len = 0; 28999| 321| if ((rule[0] == RULE_MATCHSPLICE) && janet_indexed_view(cap, &elements, &len)) { ------------------ | Branch (28999:17): [True: 0, False: 321] | Branch (28999:50): [True: 0, False: 0] ------------------ 29000| | /* unpack and flatten capture */ 29001| 0| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (29001:37): [True: 0, False: 0] ------------------ 29002| 0| pushcap(s, elements[i], tag); 29003| 0| } 29004| 321| } else { 29005| 321| pushcap(s, cap, tag); 29006| 321| } 29007| 321| return result; 29008| 321| } 29009| | 29010| 0| case RULE_ERROR: { ------------------ | Branch (29010:9): [True: 0, False: 389M] ------------------ 29011| 0| int oldmode = s->mode; 29012| 0| s->mode = PEG_MODE_NORMAL; 29013| 0| int32_t old_cap = s->captures->count; 29014| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 29015| 0| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 29016| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 29017| 0| s->mode = oldmode; 29018| 0| if (!result) return NULL; ------------------ | Branch (29018:17): [True: 0, False: 0] ------------------ 29019| 0| if (s->captures->count > old_cap) { ------------------ | Branch (29019:17): [True: 0, False: 0] ------------------ 29020| | /* Throw last capture */ 29021| 0| janet_panicv(s->captures->data[s->captures->count - 1]); 29022| 0| } else { 29023| | /* Throw generic error */ 29024| 0| int32_t start = (int32_t)(text - s->text_start); 29025| 0| LineCol lc = get_linecol_from_position(s, start); 29026| 0| janet_panicf("match error at line %d, column %d", lc.line, lc.col); 29027| 0| } 29028| 0| return NULL; 29029| 0| } 29030| | 29031| 0| case RULE_BACKMATCH: { ------------------ | Branch (29031:9): [True: 0, False: 389M] ------------------ 29032| 0| uint32_t search = rule[1]; 29033| 0| for (int32_t i = s->tags->count - 1; i >= 0; i--) { ------------------ | Branch (29033:50): [True: 0, False: 0] ------------------ 29034| 0| if (s->tags->data[i] == search) { ------------------ | Branch (29034:21): [True: 0, False: 0] ------------------ 29035| 0| Janet capture = s->tagged_captures->data[i]; 29036| 0| if (!janet_checktype(capture, JANET_STRING)) ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (29036:25): [True: 0, False: 0] ------------------ 29037| 0| return NULL; 29038| 0| const uint8_t *bytes = janet_unwrap_string(capture); ------------------ | | 863| 0|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 29039| 0| int32_t len = janet_string_length(bytes); ------------------ | | 1813| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 29040| 0| if (text + len > s->text_end) ------------------ | Branch (29040:25): [True: 0, False: 0] ------------------ 29041| 0| return NULL; 29042| 0| return memcmp(text, bytes, len) ? NULL : text + len; ------------------ | Branch (29042:28): [True: 0, False: 0] ------------------ 29043| 0| } 29044| 0| } 29045| 0| return NULL; 29046| 0| } 29047| | 29048| 0| case RULE_LENPREFIX: { ------------------ | Branch (29048:9): [True: 0, False: 389M] ------------------ 29049| 0| int oldmode = s->mode; 29050| 0| s->mode = PEG_MODE_NORMAL; 29051| 0| const uint8_t *next_text; 29052| 0| CapState cs = cap_save(s); 29053| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 29054| 0| next_text = peg_rule(s, s->bytecode + rule[1], text); 29055| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 29056| 0| if (NULL == next_text) return NULL; ------------------ | Branch (29056:17): [True: 0, False: 0] ------------------ 29057| 0| s->mode = oldmode; 29058| 0| int32_t num_sub_captures = s->captures->count - cs.cap; 29059| 0| Janet lencap; 29060| 0| if (num_sub_captures <= 0 || ------------------ | Branch (29060:17): [True: 0, False: 0] ------------------ 29061| 0| (lencap = s->captures->data[cs.cap], !janet_checkint(lencap))) { ------------------ | Branch (29061:21): [True: 0, False: 0] ------------------ 29062| 0| cap_load(s, cs); 29063| 0| return NULL; 29064| 0| } 29065| 0| int32_t nrep = janet_unwrap_integer(lencap); ------------------ | | 966| 0|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 29066| | /* drop captures from len pattern */ 29067| 0| cap_load(s, cs); 29068| 0| for (int32_t i = 0; i < nrep; i++) { ------------------ | Branch (29068:33): [True: 0, False: 0] ------------------ 29069| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 29070| 0| next_text = peg_rule(s, s->bytecode + rule[2], next_text); 29071| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 29072| 0| if (NULL == next_text) { ------------------ | Branch (29072:21): [True: 0, False: 0] ------------------ 29073| 0| cap_load(s, cs); 29074| 0| return NULL; 29075| 0| } 29076| 0| } 29077| 0| return next_text; 29078| 0| } 29079| | 29080| 0| case RULE_READINT: { ------------------ | Branch (29080:9): [True: 0, False: 389M] ------------------ 29081| 0| uint32_t tag = rule[2]; 29082| 0| uint32_t signedness = rule[1] & 0x10; 29083| 0| uint32_t endianness = rule[1] & 0x20; 29084| 0| int width = (int)(rule[1] & 0xF); 29085| 0| if (text + width > s->text_end) return NULL; ------------------ | Branch (29085:17): [True: 0, False: 0] ------------------ 29086| 0| uint64_t accum = 0; 29087| 0| if (endianness) { ------------------ | Branch (29087:17): [True: 0, False: 0] ------------------ 29088| | /* BE */ 29089| 0| for (int i = 0; i < width; i++) accum = (accum << 8) | text[i]; ------------------ | Branch (29089:33): [True: 0, False: 0] ------------------ 29090| 0| } else { 29091| | /* LE */ 29092| 0| for (int i = width - 1; i >= 0; i--) accum = (accum << 8) | text[i]; ------------------ | Branch (29092:41): [True: 0, False: 0] ------------------ 29093| 0| } 29094| | 29095| 0| Janet capture_value; 29096| | /* We can only parse integeres of greater than 6 bytes reliable if int-types are enabled. 29097| | * Otherwise, we may lose precision, so 6 is the maximum size when int-types are disabled. */ 29098| 0|#ifdef JANET_INT_TYPES 29099| 0| if (width > 6) { ------------------ | Branch (29099:17): [True: 0, False: 0] ------------------ 29100| 0| if (signedness) { ------------------ | Branch (29100:21): [True: 0, False: 0] ------------------ 29101| 0| capture_value = janet_wrap_s64(peg_convert_u64_s64(accum, width)); 29102| 0| } else { 29103| 0| capture_value = janet_wrap_u64(accum); 29104| 0| } 29105| 0| } else 29106| 0|#endif 29107| 0| { 29108| 0| double double_value; 29109| 0| if (signedness) { ------------------ | Branch (29109:21): [True: 0, False: 0] ------------------ 29110| 0| double_value = (double)(peg_convert_u64_s64(accum, width)); 29111| 0| } else { 29112| 0| double_value = (double)accum; 29113| 0| } 29114| 0| capture_value = janet_wrap_number(double_value); ------------------ | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 29115| 0| } 29116| | 29117| 0| pushcap(s, capture_value, tag); 29118| 0| return text + width; 29119| 0| } 29120| | 29121| 0| case RULE_UNREF: { ------------------ | Branch (29121:9): [True: 0, False: 389M] ------------------ 29122| 0| int32_t tcap = s->tags->count; 29123| 0| down1(s); ------------------ | |28464| 0|#define down1(s) do { \ | |28465| 0| if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \ | | ------------------ | | | Branch (28465:9): [True: 0, False: 0] | | ------------------ | |28466| 0|} while (0) | | ------------------ | | | Branch (28466:10): [Folded, False: 0] | | ------------------ ------------------ 29124| 0| const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text); 29125| 0| up1(s); ------------------ | |28467| 0|#define up1(s) ((s)->depth++) ------------------ 29126| 0| if (!result) return NULL; ------------------ | Branch (29126:17): [True: 0, False: 0] ------------------ 29127| 0| int32_t final_tcap = s->tags->count; 29128| | /* Truncate tagged captures to not include items of the given tag */ 29129| 0| int32_t w = tcap; 29130| | /* If no tag is given, drop ALL tagged captures */ 29131| 0| if (rule[2]) { ------------------ | Branch (29131:17): [True: 0, False: 0] ------------------ 29132| 0| for (int32_t i = tcap; i < final_tcap; i++) { ------------------ | Branch (29132:40): [True: 0, False: 0] ------------------ 29133| 0| if (s->tags->data[i] != (0xFF & rule[2])) { ------------------ | Branch (29133:25): [True: 0, False: 0] ------------------ 29134| 0| s->tags->data[w] = s->tags->data[i]; 29135| 0| s->tagged_captures->data[w] = s->tagged_captures->data[i]; 29136| 0| w++; 29137| 0| } 29138| 0| } 29139| 0| } 29140| 0| s->tags->count = w; 29141| 0| s->tagged_captures->count = w; 29142| 0| return result; 29143| 0| } 29144| | 29145| 389M| } 29146| 389M|} janet.c:cap_save: 28368| 373M|static CapState cap_save(PegState *s) { 28369| 373M| CapState cs; 28370| 373M| cs.scratch = s->scratch->count; 28371| 373M| cs.cap = s->captures->count; 28372| 373M| cs.tcap = s->tagged_captures->count; 28373| 373M| return cs; 28374| 373M|} janet.c:cap_load: 28377| 72.9k|static void cap_load(PegState *s, CapState cs) { 28378| 72.9k| s->scratch->count = cs.scratch; 28379| 72.9k| s->captures->count = cs.cap; 28380| 72.9k| s->tags->count = cs.tcap; 28381| 72.9k| s->tagged_captures->count = cs.tcap; 28382| 72.9k|} janet.c:pushcap: 28392| 116M|static void pushcap(PegState *s, Janet capture, uint32_t tag) { 28393| 116M| if (s->mode == PEG_MODE_ACCUMULATE) { ------------------ | Branch (28393:9): [True: 3, False: 116M] ------------------ 28394| 3| janet_to_string_b(s->scratch, capture); 28395| 3| } 28396| 116M| if (s->mode == PEG_MODE_NORMAL) { ------------------ | Branch (28396:9): [True: 116M, False: 3] ------------------ 28397| 116M| janet_array_push(s->captures, capture); 28398| 116M| } 28399| 116M| if (s->has_backref) { ------------------ | Branch (28399:9): [True: 0, False: 116M] ------------------ 28400| 0| janet_array_push(s->tagged_captures, capture); 28401| 0| janet_buffer_push_u8(s->tags, tag); 28402| 0| } 28403| 116M|} janet.c:get_linecol_from_position: 28411| 9.10M|static LineCol get_linecol_from_position(PegState *s, int32_t position) { 28412| | /* Generate if not made yet */ 28413| 9.10M| if (s->linemaplen < 0) { ------------------ | Branch (28413:9): [True: 108, False: 9.10M] ------------------ 28414| 108| int32_t newline_count = 0; 28415| 8.83M| for (const uint8_t *c = s->text_start; c < s->outer_text_end; c++) { ------------------ | Branch (28415:48): [True: 8.83M, False: 108] ------------------ 28416| 8.83M| if (*c == '\n') newline_count++; ------------------ | Branch (28416:17): [True: 76.6k, False: 8.76M] ------------------ 28417| 8.83M| } 28418| 108| int32_t *mem = janet_smalloc(sizeof(int32_t) * newline_count); 28419| 108| size_t index = 0; 28420| 8.83M| for (const uint8_t *c = s->text_start; c < s->outer_text_end; c++) { ------------------ | Branch (28420:48): [True: 8.83M, False: 108] ------------------ 28421| 8.83M| if (*c == '\n') mem[index++] = (int32_t)(c - s->text_start); ------------------ | Branch (28421:17): [True: 76.6k, False: 8.76M] ------------------ 28422| 8.83M| } 28423| 108| s->linemaplen = newline_count; 28424| 108| s->linemap = mem; 28425| 108| } 28426| | /* Do binary search for line. Slightly modified from classic binary search: 28427| | * - if we find that our current character is a line break, just return immediately. 28428| | * a newline character is consider to be on the same line as the character before 28429| | * (\n is line terminator, not line separator). 28430| | * - in the not-found case, we still want to find the greatest-indexed newline that 28431| | * is before position. we use that to calculate the line and column. 28432| | * - in the case that lo = 0 and s->linemap[0] is still greater than position, we 28433| | * are on the first line and our column is position + 1. */ 28434| 9.10M| int32_t hi = s->linemaplen; /* hi is greater than the actual line */ 28435| 9.10M| int32_t lo = 0; /* lo is less than or equal to the actual line */ 28436| 9.10M| LineCol ret; 28437| 48.5M| while (lo + 1 < hi) { ------------------ | Branch (28437:12): [True: 39.4M, False: 9.10M] ------------------ 28438| 39.4M| int32_t mid = lo + (hi - lo) / 2; 28439| 39.4M| if (s->linemap[mid] >= position) { ------------------ | Branch (28439:13): [True: 39.4M, False: 0] ------------------ 28440| 39.4M| hi = mid; 28441| 39.4M| } else { 28442| 0| lo = mid; 28443| 0| } 28444| 39.4M| } 28445| | /* first line case */ 28446| 9.10M| if (s->linemaplen == 0 || (lo == 0 && s->linemap[0] >= position)) { ------------------ | Branch (28446:9): [True: 283, False: 9.10M] | Branch (28446:32): [True: 9.10M, False: 0] | Branch (28446:43): [True: 9.10M, False: 0] ------------------ 28447| 9.10M| ret.line = 1; 28448| 9.10M| ret.col = position + 1; 28449| 9.10M| } else { 28450| 0| ret.line = lo + 2; 28451| 0| ret.col = position - s->linemap[lo]; 28452| 0| } 28453| 9.10M| return ret; 28454| 9.10M|} janet.c:cap_load_keept: 28386| 701k|static void cap_load_keept(PegState *s, CapState cs) { 28387| 701k| s->scratch->count = cs.scratch; 28388| 701k| s->captures->count = cs.cap; 28389| 701k|} janet.c:number_to_string_b: 30472| 2.94k|static void number_to_string_b(JanetBuffer *buffer, double x) { 30473| 2.94k| janet_buffer_extra(buffer, BUFSIZE); ------------------ | |30466| 2.94k|#define BUFSIZE 64 ------------------ 30474| 2.94k| const char *fmt = (x == floor(x) && ------------------ | Branch (30474:24): [True: 2.49k, False: 454] ------------------ 30475| 2.49k| x <= JANET_INTMAX_DOUBLE && ------------------ | | 165| 5.43k|#define JANET_INTMAX_DOUBLE 9007199254740992.0 ------------------ | Branch (30475:24): [True: 2.23k, False: 253] ------------------ 30476| 2.23k| x >= JANET_INTMIN_DOUBLE) ? "%.0f" : ("%." STR(DBL_DIG) "g"); ------------------ | | 166| 2.23k|#define JANET_INTMIN_DOUBLE (-9007199254740992.0) ------------------ | Branch (30476:24): [True: 2.13k, False: 108] ------------------ 30477| 2.94k| int count; 30478| 2.94k| if (x == 0.0) { ------------------ | Branch (30478:9): [True: 601, False: 2.34k] ------------------ 30479| | /* Prevent printing of '-0' */ 30480| 601| count = 1; 30481| 601| buffer->data[buffer->count] = '0'; 30482| 2.34k| } else { 30483| 2.34k| count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, fmt, x); ------------------ | |30466| 2.34k|#define BUFSIZE 64 ------------------ 30484| 2.34k| } 30485| 2.94k| buffer->count += count; 30486| 2.94k|} janet.c:string_description_b: 30532| 37|static void string_description_b(JanetBuffer *buffer, const char *title, void *pointer) { 30533| 37| janet_buffer_extra(buffer, BUFSIZE); ------------------ | |30466| 37|#define BUFSIZE 64 ------------------ 30534| 37| uint8_t *c = buffer->data + buffer->count; 30535| 37| int32_t i; 30536| 37| union { 30537| 37| uint8_t bytes[sizeof(void *)]; 30538| 37| void *p; 30539| 37| } pbuf; 30540| | 30541| 37| pbuf.p = pointer; 30542| 37| *c++ = '<'; 30543| | /* Maximum of 32 bytes for abstract type name */ 30544| 223| for (i = 0; i < 32 && title[i]; ++i) ------------------ | Branch (30544:17): [True: 223, False: 0] | Branch (30544:27): [True: 186, False: 37] ------------------ 30545| 186| *c++ = ((uint8_t *)title) [i]; 30546| 37| *c++ = ' '; 30547| 37| *c++ = '0'; 30548| 37| *c++ = 'x'; 30549| 37|#if defined(JANET_NANBOX_64) 30550| 37|#define POINTSIZE 6 30551| |#else 30552| |#define POINTSIZE (sizeof(void *)) 30553| |#endif 30554| 259| for (i = POINTSIZE; i > 0; --i) { ------------------ | |30550| 37|#define POINTSIZE 6 ------------------ | Branch (30554:25): [True: 222, False: 37] ------------------ 30555| 222| uint8_t byte = pbuf.bytes[i - 1]; 30556| 222| *c++ = HEX(byte >> 4); ------------------ | |30528| 222|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 30557| 222| *c++ = HEX(byte & 0xF); ------------------ | |30528| 222|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 30558| 222| } 30559| 37| *c++ = '>'; 30560| 37| buffer->count = (int32_t)(c - buffer->data); 30561| 37|#undef POINTSIZE 30562| 37|} janet.c:janet_escape_string_b: 30634| 9.02M|static void janet_escape_string_b(JanetBuffer *buffer, const uint8_t *str) { 30635| | janet_escape_string_impl(buffer, str, janet_string_length(str)); ------------------ | | 1813| 9.02M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 9.02M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30636| 9.02M|} janet.c:janet_escape_string_impl: 30564| 9.02M|static int janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) { 30565| 9.02M| janet_buffer_push_u8(buffer, '"'); 30566| 9.02M| int align = 1; 30567| 9.03M| for (int32_t i = 0; i < len; ++i) { ------------------ | Branch (30567:25): [True: 9.94k, False: 9.02M] ------------------ 30568| 9.94k| uint8_t c = str[i]; 30569| 9.94k| switch (c) { 30570| 241| case '"': ------------------ | Branch (30570:13): [True: 241, False: 9.70k] ------------------ 30571| 241| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\"", 2); 30572| 241| align += 2; 30573| 241| break; 30574| 338| case '\n': ------------------ | Branch (30574:13): [True: 338, False: 9.61k] ------------------ 30575| 338| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\n", 2); 30576| 338| align += 2; 30577| 338| break; 30578| 227| case '\r': ------------------ | Branch (30578:13): [True: 227, False: 9.72k] ------------------ 30579| 227| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\r", 2); 30580| 227| align += 2; 30581| 227| break; 30582| 1.41k| case '\0': ------------------ | Branch (30582:13): [True: 1.41k, False: 8.53k] ------------------ 30583| 1.41k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2); 30584| 1.41k| align += 2; 30585| 1.41k| break; 30586| 259| case '\f': ------------------ | Branch (30586:13): [True: 259, False: 9.69k] ------------------ 30587| 259| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2); 30588| 259| align += 2; 30589| 259| break; 30590| 276| case '\v': ------------------ | Branch (30590:13): [True: 276, False: 9.67k] ------------------ 30591| 276| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2); 30592| 276| align += 2; 30593| 276| break; 30594| 373| case '\a': ------------------ | Branch (30594:13): [True: 373, False: 9.57k] ------------------ 30595| 373| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2); 30596| 373| align += 2; 30597| 373| break; 30598| 280| case '\b': ------------------ | Branch (30598:13): [True: 280, False: 9.66k] ------------------ 30599| 280| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2); 30600| 280| align += 2; 30601| 280| break; 30602| 236| case 27: ------------------ | Branch (30602:13): [True: 236, False: 9.71k] ------------------ 30603| 236| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2); 30604| 236| align += 2; 30605| 236| break; 30606| 212| case '\\': ------------------ | Branch (30606:13): [True: 212, False: 9.73k] ------------------ 30607| 212| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2); 30608| 212| align += 2; 30609| 212| break; 30610| 240| case '\t': ------------------ | Branch (30610:13): [True: 240, False: 9.70k] ------------------ 30611| 240| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\t", 2); 30612| 240| align += 2; 30613| 240| break; 30614| 5.84k| default: ------------------ | Branch (30614:13): [True: 5.84k, False: 4.10k] ------------------ 30615| 5.84k| if (c < 32 || c > 126) { ------------------ | Branch (30615:21): [True: 1.23k, False: 4.61k] | Branch (30615:31): [True: 2.25k, False: 2.36k] ------------------ 30616| 3.48k| uint8_t buf[4]; 30617| 3.48k| buf[0] = '\\'; 30618| 3.48k| buf[1] = 'x'; 30619| 3.48k| buf[2] = janet_base64[(c >> 4) & 0xF]; 30620| 3.48k| buf[3] = janet_base64[c & 0xF]; 30621| 3.48k| janet_buffer_push_bytes(buffer, buf, 4); 30622| 3.48k| align += 4; 30623| 3.48k| } else { 30624| 2.36k| janet_buffer_push_u8(buffer, c); 30625| 2.36k| align++; 30626| 2.36k| } 30627| 5.84k| break; 30628| 9.94k| } 30629| 9.94k| } 30630| 9.02M| janet_buffer_push_u8(buffer, '"'); 30631| 9.02M| return align + 1; 30632| 9.02M|} janet.c:janet_escape_buffer_b: 30638| 154|static void janet_escape_buffer_b(JanetBuffer *buffer, JanetBuffer *bx) { 30639| 154| if (bx == buffer) { ------------------ | Branch (30639:9): [True: 0, False: 154] ------------------ 30640| | /* Ensures buffer won't resize while escaping */ 30641| 0| int64_t new_size = 6 * (int64_t) bx->count + 3; 30642| 0| if (new_size > INT32_MAX) janet_panic("buffer overflow"); ------------------ | Branch (30642:13): [True: 0, False: 0] ------------------ 30643| 0| janet_buffer_ensure(bx, (int32_t) new_size, 1); 30644| 0| } 30645| 154| janet_buffer_push_u8(buffer, '@'); 30646| 154| janet_escape_string_impl(buffer, bx->data, bx->count); 30647| 154|} janet.c:janet_pretty_: 31261| 9.02M| int flags, Janet x, int32_t startlen, int32_t lookback_barrier) { 31262| 9.02M| struct pretty S; 31263| 9.02M| if (NULL == buffer) { ------------------ | Branch (31263:9): [True: 0, False: 9.02M] ------------------ 31264| 0| buffer = janet_buffer(0); 31265| 0| } 31266| 9.02M| S.buffer = buffer; 31267| 9.02M| S.depth = depth; 31268| 9.02M| S.width = width; 31269| 9.02M| S.align = 0; 31270| 9.02M| S.flags = flags; 31271| 9.02M| S.bufstartlen = startlen; 31272| 9.02M| S.lookback_barrier = lookback_barrier; 31273| 9.02M| S.keysort_capacity = 0; 31274| | S.keysort_buffer = NULL; 31275| 9.02M| S.keysort_start = 0; 31276| 9.02M| janet_table_init(&S.seen, 10); 31277| 9.02M| janet_pretty_one(&S, x); 31278| 9.02M| backtrack_newlines(&S); 31279| 9.02M| janet_table_deinit(&S.seen); 31280| 9.02M| return S.buffer; 31281| 9.02M|} janet.c:janet_pretty_one: 31028| 9.07M|static void janet_pretty_one(struct pretty *S, Janet x) { 31029| | /* Add to seen */ 31030| 9.07M| switch (janet_type(x)) { ------------------ | | 795| 9.07M| (isnan((x).number) \ | | 796| 9.07M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 9.07M| : JANET_NUMBER) ------------------ | Branch (31030:13): [True: 9.07M, False: 2.56k] ------------------ 31031| 12| case JANET_NIL: ------------------ | Branch (31031:9): [True: 12, False: 9.07M] ------------------ 31032| 2.57k| case JANET_NUMBER: ------------------ | Branch (31032:9): [True: 2.56k, False: 9.07M] ------------------ 31033| 26.6k| case JANET_SYMBOL: ------------------ | Branch (31033:9): [True: 24.0k, False: 9.04M] ------------------ 31034| 26.6k| case JANET_BOOLEAN: ------------------ | Branch (31034:9): [True: 26, False: 9.07M] ------------------ 31035| 26.6k| break; 31036| 9.04M| default: { ------------------ | Branch (31036:9): [True: 9.04M, False: 26.6k] ------------------ 31037| 9.04M| Janet seenid = janet_table_get(&S->seen, x); 31038| 9.04M| if (janet_checktype(seenid, JANET_NUMBER)) { ------------------ | | 806| 9.04M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 9.04M] | | | Branch (806:6): [True: 9.04M, Folded] | | ------------------ | | 807| 9.04M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 9.04M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 9.04M] | | | | | Branch (803:28): [True: 0, False: 9.04M] | | | | ------------------ | | ------------------ | | 808| 9.04M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31039| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31039:21): [True: 0, False: 0] ------------------ 31040| 0| janet_buffer_push_cstring(S->buffer, janet_cycle_color); 31041| 0| } 31042| 0| janet_buffer_push_cstring(S->buffer, "align += 8 + integer_to_string_b(S->buffer, janet_unwrap_integer(seenid)); ------------------ | | 966| 0|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 31044| 0| janet_buffer_push_u8(S->buffer, '>'); 31045| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31045:21): [True: 0, False: 0] ------------------ 31046| 0| janet_buffer_push_cstring(S->buffer, "\x1B[0m"); 31047| 0| } 31048| 0| return; 31049| 9.04M| } else { 31050| 9.04M| janet_table_put(&S->seen, x, janet_wrap_integer(S->seen.count)); ------------------ | | 967| 9.04M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 9.04M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 31051| 9.04M| break; 31052| 9.04M| } 31053| 9.04M| } 31054| 9.07M| } 31055| | 31056| 9.07M| switch (janet_type(x)) { ------------------ | | 795| 9.07M| (isnan((x).number) \ | | 796| 9.07M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 9.07M| : JANET_NUMBER) ------------------ | Branch (31056:13): [True: 9.07M, False: 2.56k] ------------------ 31057| 9.04M| default: { ------------------ | Branch (31057:9): [True: 9.04M, False: 23.0k] ------------------ 31058| 9.04M| const char *color = janet_pretty_colors[janet_type(x)]; ------------------ | | 795| 9.04M| (isnan((x).number) \ | | 796| 9.04M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 9.04M| : JANET_NUMBER) ------------------ | Branch (31058:53): [True: 9.04M, False: 2.56k] ------------------ 31059| 9.04M| if (color && (S->flags & JANET_PRETTY_COLOR)) { ------------------ | | 1967| 9.04M|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31059:17): [True: 9.04M, False: 0] | Branch (31059:26): [True: 0, False: 9.04M] ------------------ 31060| 0| janet_buffer_push_cstring(S->buffer, color); 31061| 0| } 31062| 9.04M| if (janet_checktype(x, JANET_BUFFER) && janet_unwrap_buffer(x) == S->buffer) { ------------------ | | 806| 18.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 152, False: 9.04M] | | | Branch (806:6): [Folded, False: 9.04M] | | ------------------ | | 807| 18.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 18.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 9.04M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 9.04M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 9.04M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9.04M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(x, JANET_BUFFER) && janet_unwrap_buffer(x) == S->buffer) { ------------------ | | 862| 152|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ | Branch (31062:53): [True: 0, False: 152] ------------------ 31063| 0| int64_t new_size = (int64_t) S->buffer->count + S->bufstartlen * 4 + 3; 31064| 0| if (new_size > INT32_MAX) janet_panic("buffer overflow"); ------------------ | Branch (31064:21): [True: 0, False: 0] ------------------ 31065| 0| janet_buffer_ensure(S->buffer, (int32_t) new_size, 1); 31066| 0| janet_buffer_push_u8(S->buffer, '@'); 31067| | /* Use start len to print to self better */ 31068| 0| S->align += 1 + janet_escape_string_impl(S->buffer, S->buffer->data, S->bufstartlen); 31069| 9.04M| } else { 31070| 9.04M| S->align -= S->buffer->count; 31071| 9.04M| janet_description_b(S->buffer, x); 31072| 9.04M| S->align += S->buffer->count; 31073| 9.04M| } 31074| 9.04M| if (color && (S->flags & JANET_PRETTY_COLOR)) { ------------------ | | 1967| 9.04M|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31074:17): [True: 9.04M, False: 0] | Branch (31074:26): [True: 0, False: 9.04M] ------------------ 31075| 0| janet_buffer_push_cstring(S->buffer, "\x1B[0m"); 31076| 0| } 31077| 9.04M| break; 31078| 9.04M| } 31079| 421| case JANET_ARRAY: ------------------ | Branch (31079:9): [True: 421, False: 9.07M] ------------------ 31080| 20.3k| case JANET_TUPLE: { ------------------ | Branch (31080:9): [True: 19.9k, False: 9.05M] ------------------ 31081| 20.3k| int32_t i = 0, len = 0; 31082| 20.3k| const Janet *arr = NULL; 31083| 20.3k| int isarray = janet_checktype(x, JANET_ARRAY); ------------------ | | 806| 20.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 20.3k] | | ------------------ | | 807| 20.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 20.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 20.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 20.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 20.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 20.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31084| 20.3k| janet_indexed_view(x, &arr, &len); 31085| 20.3k| int hasbrackets = !isarray && (janet_tuple_flag(arr) & JANET_TUPLE_FLAG_BRACKETCTOR); ------------------ | | 1806| 19.9k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 19.9k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ int hasbrackets = !isarray && (janet_tuple_flag(arr) & JANET_TUPLE_FLAG_BRACKETCTOR); ------------------ | | 1798| 19.9k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (31085:31): [True: 19.9k, False: 421] | Branch (31085:43): [True: 201, False: 19.7k] ------------------ 31086| 20.3k| const char *startstr = isarray ? "@[" : hasbrackets ? "[" : "("; ------------------ | Branch (31086:36): [True: 421, False: 19.9k] | Branch (31086:53): [True: 201, False: 19.7k] ------------------ 31087| 20.3k| const char endchar = isarray ? ']' : hasbrackets ? ']' : ')'; ------------------ | Branch (31087:34): [True: 421, False: 19.9k] | Branch (31087:50): [True: 201, False: 19.7k] ------------------ 31088| 20.3k| janet_buffer_push_cstring(S->buffer, startstr); 31089| 20.3k| S->align += (int32_t) strlen(startstr); 31090| 20.3k| const int align = S->leaf_align = S->align; 31091| 20.3k| S->depth--; 31092| 20.3k| if (S->depth == 0) { ------------------ | Branch (31092:17): [True: 0, False: 20.3k] ------------------ 31093| 0| janet_buffer_push_cstring(S->buffer, "..."); 31094| 0| S->align += 3; 31095| 20.3k| } else { 31096| 20.3k| if (len > JANET_PRETTY_ARRAY_LIMIT && !(S->flags & JANET_PRETTY_NOTRUNC)) { ------------------ | |31025| 40.7k|#define JANET_PRETTY_ARRAY_LIMIT 160 ------------------ if (len > JANET_PRETTY_ARRAY_LIMIT && !(S->flags & JANET_PRETTY_NOTRUNC)) { ------------------ | | 1969| 0|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (31096:21): [True: 0, False: 20.3k] | Branch (31096:55): [True: 0, False: 0] ------------------ 31097| 0| for (i = 0; i < 3; i++) { ------------------ | Branch (31097:33): [True: 0, False: 0] ------------------ 31098| 0| if (i) print_newline(S, align); ------------------ | Branch (31098:29): [True: 0, False: 0] ------------------ 31099| 0| janet_pretty_one(S, arr[i]); 31100| 0| } 31101| 0| print_newline(S, align); 31102| 0| janet_buffer_push_cstring(S->buffer, "..."); 31103| 0| S->align += 3; 31104| 0| for (i = len - 3; i < len; i++) { ------------------ | Branch (31104:39): [True: 0, False: 0] ------------------ 31105| 0| print_newline(S, align); 31106| 0| janet_pretty_one(S, arr[i]); 31107| 0| } 31108| 20.3k| } else { 31109| 63.3k| for (i = 0; i < len; i++) { ------------------ | Branch (31109:33): [True: 43.0k, False: 20.3k] ------------------ 31110| 43.0k| if (i) print_newline(S, align); ------------------ | Branch (31110:29): [True: 22.9k, False: 20.1k] ------------------ 31111| 43.0k| janet_pretty_one(S, arr[i]); 31112| 43.0k| } 31113| 20.3k| } 31114| 20.3k| } 31115| 20.3k| S->depth++; 31116| 20.3k| janet_buffer_push_u8(S->buffer, endchar); 31117| 20.3k| S->align++; 31118| 20.3k| break; 31119| 421| } 31120| 2.44k| case JANET_STRUCT: ------------------ | Branch (31120:9): [True: 2.44k, False: 9.07M] ------------------ 31121| 2.66k| case JANET_TABLE: { ------------------ | Branch (31121:9): [True: 215, False: 9.07M] ------------------ 31122| 2.66k| int istable = janet_checktype(x, JANET_TABLE); ------------------ | | 806| 2.66k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.66k] | | ------------------ | | 807| 2.66k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.66k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.66k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.66k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.66k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.66k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31123| | 31124| | /* For object-like tables, print class name */ 31125| 2.66k| if (istable) { ------------------ | Branch (31125:17): [True: 215, False: 2.44k] ------------------ 31126| 215| JanetTable *t = janet_unwrap_table(x); ------------------ | | 861| 215|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 31127| 215| JanetTable *proto = t->proto; 31128| 215| S->align++; 31129| 215| janet_buffer_push_cstring(S->buffer, "@"); 31130| 215| if (NULL != proto) { ------------------ | Branch (31130:21): [True: 0, False: 215] ------------------ 31131| 0| Janet name = janet_table_get(proto, janet_ckeywordv("_name")); ------------------ | | 1843| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31132| 0| const uint8_t *n; 31133| 0| int32_t len; 31134| 0| if (janet_bytes_view(name, &n, &len)) { ------------------ | Branch (31134:25): [True: 0, False: 0] ------------------ 31135| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31135:29): [True: 0, False: 0] ------------------ 31136| 0| janet_buffer_push_cstring(S->buffer, janet_class_color); 31137| 0| } 31138| 0| janet_buffer_push_bytes(S->buffer, n, len); 31139| 0| S->align += len; 31140| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31140:29): [True: 0, False: 0] ------------------ 31141| 0| janet_buffer_push_cstring(S->buffer, "\x1B[0m"); 31142| 0| } 31143| 0| } 31144| 0| } 31145| 2.44k| } else { 31146| 2.44k| JanetStruct st = janet_unwrap_struct(x); ------------------ | | 857| 2.44k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 31147| 2.44k| JanetStruct proto = janet_struct_proto(st); ------------------ | | 1851| 2.44k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 2.44k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 31148| 2.44k| if (NULL != proto) { ------------------ | Branch (31148:21): [True: 0, False: 2.44k] ------------------ 31149| 0| Janet name = janet_struct_get(proto, janet_ckeywordv("_name")); ------------------ | | 1843| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31150| 0| const uint8_t *n; 31151| 0| int32_t len; 31152| 0| if (janet_bytes_view(name, &n, &len)) { ------------------ | Branch (31152:25): [True: 0, False: 0] ------------------ 31153| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31153:29): [True: 0, False: 0] ------------------ 31154| 0| janet_buffer_push_cstring(S->buffer, janet_class_color); 31155| 0| } 31156| 0| janet_buffer_push_bytes(S->buffer, n, len); 31157| 0| S->align += len; 31158| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31158:29): [True: 0, False: 0] ------------------ 31159| 0| janet_buffer_push_cstring(S->buffer, "\x1B[0m"); 31160| 0| } 31161| 0| } 31162| 0| } 31163| 2.44k| } 31164| 2.66k| janet_buffer_push_u8(S->buffer, '{'); 31165| 2.66k| const int align = S->leaf_align = ++S->align; 31166| | 31167| 2.66k| S->depth--; 31168| 2.66k| if (S->depth == 0) { ------------------ | Branch (31168:17): [True: 0, False: 2.66k] ------------------ 31169| 0| janet_buffer_push_cstring(S->buffer, "..."); 31170| 0| S->align += 3; 31171| 2.66k| } else { 31172| 2.66k| int32_t len = 0, cap = 0; 31173| 2.66k| const JanetKV *kvs = NULL; 31174| 2.66k| janet_dictionary_view(x, &kvs, &len, &cap); 31175| 2.66k| int32_t ks_start = S->keysort_start; 31176| 2.66k| int truncated = 0; 31177| | 31178| | /* Shortcut for huge dictionaries, don't bother sorting keys */ 31179| 2.66k| if (len > JANET_PRETTY_DICT_KEYSORT_LIMIT) { ------------------ | |31024| 2.66k|#define JANET_PRETTY_DICT_KEYSORT_LIMIT 2000 ------------------ | Branch (31179:21): [True: 0, False: 2.66k] ------------------ 31180| 0| if (!(S->flags & JANET_PRETTY_NOTRUNC)) { ------------------ | | 1969| 0|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (31180:25): [True: 0, False: 0] ------------------ 31181| 0| len = JANET_PRETTY_DICT_LIMIT; ------------------ | |31023| 0|#define JANET_PRETTY_DICT_LIMIT 30 ------------------ 31182| 0| truncated = 1; 31183| 0| } 31184| 0| int32_t j = 0; 31185| 0| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (31185:41): [True: 0, False: 0] ------------------ 31186| 0| while (janet_checktype(kvs[j].key, JANET_NIL)) j++; ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31187| 0| if (i) print_newline(S, align); ------------------ | Branch (31187:29): [True: 0, False: 0] ------------------ 31188| 0| janet_pretty_one(S, kvs[j].key); 31189| 0| janet_buffer_push_u8(S->buffer, ' '); 31190| 0| S->align++; 31191| 0| janet_pretty_one(S, kvs[j].value); 31192| 0| j++; 31193| 0| } 31194| 0| if (truncated) { ------------------ | Branch (31194:25): [True: 0, False: 0] ------------------ 31195| 0| print_newline(S, align); 31196| 0| janet_buffer_push_cstring(S->buffer, "..."); 31197| 0| S->align += 3; 31198| 0| } 31199| 2.66k| } else { 31200| | /* Sorted keys dictionaries */ 31201| | 31202| | /* Ensure buffer is large enough to sort keys. */ 31203| 2.66k| int64_t mincap = (int64_t) len + (int64_t) ks_start; 31204| 2.66k| if (mincap > INT32_MAX) { ------------------ | Branch (31204:25): [True: 0, False: 2.66k] ------------------ 31205| 0| truncated = 1; 31206| 0| len = 0; 31207| 0| mincap = ks_start; 31208| 0| } 31209| | 31210| 2.66k| if (S->keysort_capacity < mincap) { ------------------ | Branch (31210:25): [True: 651, False: 2.01k] ------------------ 31211| 651| if (mincap >= INT32_MAX / 2) { ------------------ | Branch (31211:29): [True: 0, False: 651] ------------------ 31212| 0| S->keysort_capacity = INT32_MAX; 31213| 651| } else { 31214| 651| S->keysort_capacity = (int32_t)(mincap * 2); 31215| 651| } 31216| 651| S->keysort_buffer = janet_srealloc(S->keysort_buffer, sizeof(int32_t) * S->keysort_capacity); 31217| 651| if (NULL == S->keysort_buffer) { ------------------ | Branch (31217:29): [True: 0, False: 651] ------------------ 31218| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 31219| 0| } 31220| 651| } 31221| | 31222| 2.66k| janet_sorted_keys(kvs, cap, S->keysort_buffer == NULL ? NULL : S->keysort_buffer + ks_start); ------------------ | Branch (31222:49): [True: 155, False: 2.50k] ------------------ 31223| 2.66k| S->keysort_start += len; 31224| 2.66k| if (!(S->flags & JANET_PRETTY_NOTRUNC) && (len > JANET_PRETTY_DICT_LIMIT)) { ------------------ | | 1969| 2.66k|#define JANET_PRETTY_NOTRUNC 4 ------------------ if (!(S->flags & JANET_PRETTY_NOTRUNC) && (len > JANET_PRETTY_DICT_LIMIT)) { ------------------ | |31023| 2.66k|#define JANET_PRETTY_DICT_LIMIT 30 ------------------ | Branch (31224:25): [True: 2.66k, False: 0] | Branch (31224:63): [True: 0, False: 2.66k] ------------------ 31225| 0| len = JANET_PRETTY_DICT_LIMIT; ------------------ | |31023| 0|#define JANET_PRETTY_DICT_LIMIT 30 ------------------ 31226| 0| truncated = 1; 31227| 0| } 31228| | 31229| 6.62k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (31229:41): [True: 3.96k, False: 2.66k] ------------------ 31230| 3.96k| if (i) print_newline(S, align); ------------------ | Branch (31230:29): [True: 2.91k, False: 1.04k] ------------------ 31231| 3.96k| int32_t j = S->keysort_buffer[i + ks_start]; 31232| 3.96k| janet_pretty_one(S, kvs[j].key); 31233| 3.96k| janet_buffer_push_u8(S->buffer, ' '); 31234| 3.96k| S->align++; 31235| 3.96k| janet_pretty_one(S, kvs[j].value); 31236| 3.96k| } 31237| | 31238| 2.66k| if (truncated) { ------------------ | Branch (31238:25): [True: 0, False: 2.66k] ------------------ 31239| 0| print_newline(S, align); 31240| 0| janet_buffer_push_cstring(S->buffer, "..."); 31241| 0| S->align += 3; 31242| 0| } 31243| | 31244| 2.66k| } 31245| 2.66k| S->keysort_start = ks_start; 31246| 2.66k| } 31247| 2.66k| S->depth++; 31248| 2.66k| janet_buffer_push_u8(S->buffer, '}'); 31249| 2.66k| S->align++; 31250| 2.66k| break; 31251| 2.66k| } 31252| 9.07M| } 31253| | /* Remove from seen */ 31254| 9.07M| janet_table_remove(&S->seen, x); 31255| 9.07M| return; 31256| 9.07M|} janet.c:print_newline: 30987| 25.8k|static void print_newline(struct pretty *S, int align) { 30988| 25.8k| int i; 30989| 25.8k| if (S->flags & JANET_PRETTY_ONELINE) { ------------------ | | 1968| 25.8k|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (30989:9): [True: 0, False: 25.8k] ------------------ 30990| 0| janet_buffer_push_u8(S->buffer, ' '); 30991| 0| return; 30992| 0| } 30993| 25.8k| backtrack_newlines(S); 30994| 25.8k| janet_buffer_push_u8(S->buffer, '\n'); 30995| 25.8k| S->leaf_align = S->align = align; 30996| 895k| for (i = 0; i < S->align; i++) { ------------------ | Branch (30996:17): [True: 869k, False: 25.8k] ------------------ 30997| 869k| janet_buffer_push_u8(S->buffer, ' '); 30998| 869k| } 30999| 25.8k|} janet.c:backtrack_newlines: 30927| 9.04M|static void backtrack_newlines(const struct pretty *S) { 30928| 9.04M| if (S->flags & JANET_PRETTY_ONELINE || S->buffer->count <= 0) ------------------ | | 1968| 18.0M|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (30928:9): [True: 0, False: 9.04M] | Branch (30928:44): [True: 0, False: 9.04M] ------------------ 30929| 0| return; 30930| 9.04M| switch (S->buffer->data[S->buffer->count - 1]) { 30931| 3.26k| case ')': ------------------ | Branch (30931:9): [True: 3.26k, False: 9.04M] ------------------ 30932| 4.76k| case '}': ------------------ | Branch (30932:9): [True: 1.50k, False: 9.04M] ------------------ 30933| 5.03k| case ']': ------------------ | Branch (30933:9): [True: 266, False: 9.04M] ------------------ 30934| 5.03k| break; 30935| 9.04M| default: ------------------ | Branch (30935:9): [True: 9.04M, False: 5.03k] ------------------ 30936| 9.04M| return; 30937| 9.04M| } 30938| 5.03k| int32_t removed = 0; 30939| 5.03k| int32_t old_count = S->buffer->count; 30940| 5.03k| int32_t offset = old_count; 30941| 5.03k| int32_t b0 = S->lookback_barrier; 30942| 5.03k| int32_t columns = S->width; 30943| 5.03k| int32_t align = 0; 30944| 159k| while (--offset >= b0) { ------------------ | Branch (30944:12): [True: 158k, False: 743] ------------------ 30945| 158k| const char *s = (const char *)S->buffer->data + offset; 30946| 158k| if (*s == '\n') { ------------------ | Branch (30946:13): [True: 8.58k, False: 150k] ------------------ 30947| 8.58k| if (align < S->leaf_align) { ------------------ | Branch (30947:17): [True: 3.92k, False: 4.66k] ------------------ 30948| 3.92k| break; 30949| 3.92k| } 30950| 4.66k| columns += align; 30951| 4.66k| removed += align; 30952| 4.66k| align = 0; 30953| 150k| } else if (*s == ' ') { ------------------ | Branch (30953:20): [True: 70.0k, False: 80.2k] ------------------ 30954| 70.0k| align++; 30955| 80.2k| } else { 30956| 80.2k| align = 0; 30957| | /* Don't count color sequences: \x1B(0|3\d)m */ 30958| 80.2k| if (S->flags & JANET_PRETTY_COLOR && *s == 'm') { ------------------ | | 1967| 160k|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (30958:17): [True: 0, False: 80.2k] | Branch (30958:50): [True: 0, False: 0] ------------------ 30959| 0| if (offset >= (3 + b0) && strncmp("\x1B[0m", s - 3, 4) == 0) { ------------------ | Branch (30959:21): [True: 0, False: 0] | Branch (30959:43): [True: 0, False: 0] ------------------ 30960| 0| offset -= 3; 30961| 0| columns++; 30962| 0| } else if (offset >= (4 + b0) && strncmp("\x1B[3", s - 4, 3) == 0) { ------------------ | Branch (30962:28): [True: 0, False: 0] | Branch (30962:50): [True: 0, False: 0] ------------------ 30963| 0| offset -= 4; 30964| 0| columns++; 30965| 0| } 30966| 0| } 30967| 80.2k| } 30968| 154k| if (--columns <= 0) { ------------------ | Branch (30968:13): [True: 368, False: 154k] ------------------ 30969| 368| return; 30970| 368| } 30971| 154k| } 30972| 4.66k| offset++; /* Don't mess with the last newline we found */ 30973| 4.66k| janet_assert(offset >= b0, "bad buffer index"); ------------------ | | 389| 4.66k|#define janet_assert(c, m) do { \ | | 390| 4.66k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 4.66k] | | ------------------ | | 391| 4.66k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 4.66k] | | ------------------ ------------------ 30974| 4.66k| S->buffer->count -= removed; 30975| 90.9k| for (int32_t i = offset; i < S->buffer->count; i++) { ------------------ | Branch (30975:30): [True: 86.2k, False: 4.66k] ------------------ 30976| 86.2k| if (S->buffer->data[offset] == '\n') { ------------------ | Branch (30976:13): [True: 3.63k, False: 82.6k] ------------------ 30977| 3.63k| S->buffer->data[i] = ' '; 30978| 33.7k| while (S->buffer->data[++offset] == ' ') { ------------------ | Branch (30978:20): [True: 30.1k, False: 3.63k] ------------------ 30979| 30.1k| janet_assert(offset < old_count, "bad replacement of newline"); ------------------ | | 389| 30.1k|#define janet_assert(c, m) do { \ | | 390| 30.1k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 30.1k] | | ------------------ | | 391| 30.1k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 30.1k] | | ------------------ ------------------ 30980| 30.1k| } 30981| 82.6k| } else { 30982| 82.6k| S->buffer->data[i] = S->buffer->data[offset++]; 30983| 82.6k| } 30984| 86.2k| } 30985| 4.66k|} janet.c:scanformat: 31380| 18.3M| char precision[3]) { 31381| 18.3M| const char *p = strfrmt; 31382| | 31383| | /* Parse strfrmt */ 31384| 18.3M| memset(width, '\0', 3); 31385| 18.3M| memset(precision, '\0', 3); 31386| 18.3M| while (*p != '\0' && strchr(FMT_FLAGS, *p) != NULL) ------------------ | |31346| 18.3M|#define FMT_FLAGS "-+ #0" ------------------ | Branch (31386:12): [True: 18.3M, False: 0] | Branch (31386:26): [True: 0, False: 18.3M] ------------------ 31387| 0| p++; /* skip flags */ 31388| 18.3M| if ((size_t)(p - strfrmt) >= sizeof(FMT_FLAGS)) janet_panic("invalid format (repeated flags)"); ------------------ | |31346| 18.3M|#define FMT_FLAGS "-+ #0" ------------------ | Branch (31388:9): [True: 0, False: 18.3M] ------------------ 31389| 18.3M| if (isdigit((int)(*p))) ------------------ | Branch (31389:9): [True: 0, False: 18.3M] ------------------ 31390| 0| width[0] = *p++; /* skip width */ 31391| 18.3M| if (isdigit((int)(*p))) ------------------ | Branch (31391:9): [True: 0, False: 18.3M] ------------------ 31392| 0| width[1] = *p++; /* (2 digits at most) */ 31393| 18.3M| if (*p == '.') { ------------------ | Branch (31393:9): [True: 0, False: 18.3M] ------------------ 31394| 0| p++; 31395| 0| if (isdigit((int)(*p))) ------------------ | Branch (31395:13): [True: 0, False: 0] ------------------ 31396| 0| precision[0] = *p++; /* skip precision */ 31397| 0| if (isdigit((int)(*p))) ------------------ | Branch (31397:13): [True: 0, False: 0] ------------------ 31398| 0| precision[1] = *p++; /* (2 digits at most) */ 31399| 0| } 31400| 18.3M| if (isdigit((int)(*p))) ------------------ | Branch (31400:9): [True: 0, False: 18.3M] ------------------ 31401| 0| janet_panic("invalid format (width or precision too long)"); 31402| | 31403| | /* Write to form - replace characters with fixed size stuff */ 31404| 18.3M| *(form++) = '%'; 31405| 18.3M| const char *p2 = strfrmt; 31406| 36.6M| while (p2 <= p) { ------------------ | Branch (31406:12): [True: 18.3M, False: 18.3M] ------------------ 31407| 18.3M| char *loc = strchr(FMT_REPLACE_INTTYPES, *p2); ------------------ | |31347| 18.3M|#define FMT_REPLACE_INTTYPES "diouxX" ------------------ 31408| 18.3M| if (loc != NULL && *loc != '\0') { ------------------ | Branch (31408:13): [True: 9.17M, False: 9.15M] | Branch (31408:28): [True: 9.17M, False: 0] ------------------ 31409| 9.17M| const char *mapping = get_fmt_mapping(*p2++); 31410| 9.17M| size_t len = strlen(mapping); 31411| 9.17M| memcpy(form, mapping, len); 31412| 9.17M| form += len; 31413| 9.17M| } else { 31414| 9.15M| *(form++) = *(p2++); 31415| 9.15M| } 31416| 18.3M| } 31417| 18.3M| *form = '\0'; 31418| | 31419| 18.3M| return p; 31420| 18.3M|} janet.c:get_fmt_mapping: 31368| 9.17M|static const char *get_fmt_mapping(char c) { 31369| 27.5M| for (size_t i = 0; i < (sizeof(format_mappings) / sizeof(struct FmtMapping)); i++) { ------------------ | Branch (31369:24): [True: 27.5M, False: 0] ------------------ 31370| 27.5M| if (format_mappings[i].c == c) ------------------ | Branch (31370:13): [True: 9.17M, False: 18.3M] ------------------ 31371| 9.17M| return format_mappings[i].mapping; 31372| 27.5M| } 31373| 0| janet_assert(0, "bad format mapping"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, Folded] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 31374| 0|} janet.c:bignat_zero: 34217| 13.0k|static void bignat_zero(struct BigNat *x) { 34218| 13.0k| x->first_digit = 0; 34219| 13.0k| x->n = 0; 34220| 13.0k| x->cap = 0; 34221| | x->digits = NULL; 34222| 13.0k|} janet.c:bignat_muladd: 34249| 42.8k|static void bignat_muladd(struct BigNat *mant, uint32_t factor, uint32_t term) { 34250| 42.8k| int32_t i; 34251| 42.8k| uint64_t carry = ((uint64_t) mant->first_digit) * factor + term; 34252| 42.8k| mant->first_digit = carry % BIGNAT_BASE; ------------------ | |34206| 42.8k|#define BIGNAT_BASE 0x80000000U ------------------ 34253| 42.8k| carry /= BIGNAT_BASE; ------------------ | |34206| 42.8k|#define BIGNAT_BASE 0x80000000U ------------------ 34254| 268k| for (i = 0; i < mant->n; i++) { ------------------ | Branch (34254:17): [True: 225k, False: 42.8k] ------------------ 34255| 225k| carry += ((uint64_t) mant->digits[i]) * factor; 34256| 225k| mant->digits[i] = carry % BIGNAT_BASE; ------------------ | |34206| 225k|#define BIGNAT_BASE 0x80000000U ------------------ 34257| 225k| carry /= BIGNAT_BASE; ------------------ | |34206| 225k|#define BIGNAT_BASE 0x80000000U ------------------ 34258| 225k| } 34259| 42.8k| if (carry) bignat_append(mant, (uint32_t) carry); ------------------ | Branch (34259:9): [True: 8.25k, False: 34.5k] ------------------ 34260| 42.8k|} janet.c:bignat_append: 34242| 8.25k|static void bignat_append(struct BigNat *mant, uint32_t dig) { 34243| 8.25k| bignat_extra(mant, 1)[0] = dig; 34244| 8.25k|} janet.c:bignat_extra: 34225| 10.0k|static uint32_t *bignat_extra(struct BigNat *mant, int32_t n) { 34226| 10.0k| int32_t oldn = mant->n; 34227| 10.0k| int32_t newn = oldn + n; 34228| 10.0k| if (mant->cap < newn) { ------------------ | Branch (34228:9): [True: 4.00k, False: 6.04k] ------------------ 34229| 4.00k| int32_t newcap = 2 * newn; 34230| 4.00k| uint32_t *mem = janet_realloc(mant->digits, (size_t) newcap * sizeof(uint32_t)); ------------------ | | 2409| 4.00k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 34231| 4.00k| if (NULL == mem) { ------------------ | Branch (34231:13): [True: 0, False: 4.00k] ------------------ 34232| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 34233| 0| } 34234| 4.00k| mant->cap = newcap; 34235| 4.00k| mant->digits = mem; 34236| 4.00k| } 34237| 10.0k| mant->n = newn; 34238| 10.0k| return mant->digits + oldn; 34239| 10.0k|} janet.c:convert: 34345| 10.1k| int32_t exponent) { 34346| | 34347| 10.1k| int32_t exponent2 = 0; 34348| | 34349| | /* Approximate exponent in base 2 of mant and exponent. This should get us a good estimate of the final size of the 34350| | * number, within * 2^32 or so. */ 34351| 10.1k| int64_t mant_exp2_approx = mant->n * 32 + 16; 34352| 10.1k| int64_t exp_exp2_approx = (int64_t)(floor(log2(base) * exponent)); 34353| 10.1k| int64_t exp2_approx = mant_exp2_approx + exp_exp2_approx; 34354| | 34355| | /* Short circuit zero, huge, and small numbers. We use the exponent range of valid IEEE754 doubles (-1022, 1023) 34356| | * with a healthy buffer to allow for inaccuracies in the approximation and denormailzed numbers. */ 34357| 10.1k| if (mant->n == 0 && mant->first_digit == 0) ------------------ | Branch (34357:9): [True: 9.80k, False: 315] | Branch (34357:25): [True: 2.01k, False: 7.79k] ------------------ 34358| 2.01k| return negative ? -0.0 : 0.0; ------------------ | Branch (34358:16): [True: 29, False: 1.98k] ------------------ 34359| 8.10k| if (exp2_approx > 1176) ------------------ | Branch (34359:9): [True: 72, False: 8.03k] ------------------ 34360| 72| return negative ? -INFINITY : INFINITY; ------------------ | Branch (34360:16): [True: 13, False: 59] ------------------ 34361| 8.03k| if (exp2_approx < -1175) ------------------ | Branch (34361:9): [True: 84, False: 7.95k] ------------------ 34362| 84| return negative ? -0.0 : 0.0; ------------------ | Branch (34362:16): [True: 34, False: 50] ------------------ 34363| | 34364| | /* Final value is X = mant * base ^ exponent * 2 ^ exponent2 34365| | * Get exponent to zero while holding X constant. */ 34366| | 34367| | /* Positive exponents are simple */ 34368| 25.9k| for (; exponent > 3; exponent -= 4) bignat_muladd(mant, base * base * base * base, 0); ------------------ | Branch (34368:12): [True: 17.9k, False: 7.95k] ------------------ 34369| 8.42k| for (; exponent > 1; exponent -= 2) bignat_muladd(mant, base * base, 0); ------------------ | Branch (34369:12): [True: 471, False: 7.95k] ------------------ 34370| 8.56k| for (; exponent > 0; exponent -= 1) bignat_muladd(mant, base, 0); ------------------ | Branch (34370:12): [True: 619, False: 7.95k] ------------------ 34371| | 34372| | /* Negative exponents are tricky - we don't want to loose bits 34373| | * from integer division, so we need to premultiply. */ 34374| 7.95k| if (exponent < 0) { ------------------ | Branch (34374:9): [True: 1.79k, False: 6.15k] ------------------ 34375| 1.79k| int32_t shamt = 5 - exponent / 4; 34376| 1.79k| bignat_lshift_n(mant, shamt); 34377| 1.79k| exponent2 -= shamt * BIGNAT_NBIT; ------------------ | |34205| 1.79k|#define BIGNAT_NBIT 31 ------------------ 34378| 10.0k| for (; exponent < -3; exponent += 4) bignat_div(mant, base * base * base * base); ------------------ | Branch (34378:16): [True: 8.27k, False: 1.79k] ------------------ 34379| 3.00k| for (; exponent < -1; exponent += 2) bignat_div(mant, base * base); ------------------ | Branch (34379:16): [True: 1.21k, False: 1.79k] ------------------ 34380| 2.59k| for (; exponent < 0; exponent += 1) bignat_div(mant, base); ------------------ | Branch (34380:16): [True: 804, False: 1.79k] ------------------ 34381| 1.79k| } 34382| | 34383| 7.95k| return negative ------------------ | Branch (34383:12): [True: 936, False: 7.01k] ------------------ 34384| 7.95k| ? -bignat_extract(mant, exponent2) 34385| 7.95k| : bignat_extract(mant, exponent2); 34386| 8.03k|} janet.c:bignat_lshift_n: 34281| 1.79k|static void bignat_lshift_n(struct BigNat *mant, int n) { 34282| 1.79k| if (!n) return; ------------------ | Branch (34282:9): [True: 0, False: 1.79k] ------------------ 34283| 1.79k| int32_t oldn = mant->n; 34284| 1.79k| bignat_extra(mant, n); 34285| 1.79k| memmove(mant->digits + n, mant->digits, sizeof(uint32_t) * oldn); 34286| 1.79k| memset(mant->digits, 0, sizeof(uint32_t) * (n - 1)); 34287| 1.79k| mant->digits[n - 1] = mant->first_digit; 34288| 1.79k| mant->first_digit = 0; 34289| 1.79k|} janet.c:bignat_div: 34263| 10.2k|static void bignat_div(struct BigNat *mant, uint32_t divisor) { 34264| 10.2k| int32_t i; 34265| 10.2k| uint32_t quotient, remainder; 34266| 10.2k| uint64_t dividend; 34267| 10.2k| remainder = 0, quotient = 0; 34268| 626k| for (i = mant->n - 1; i >= 0; i--) { ------------------ | Branch (34268:27): [True: 616k, False: 10.2k] ------------------ 34269| 616k| dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->digits[i]; ------------------ | |34206| 616k|#define BIGNAT_BASE 0x80000000U ------------------ 34270| 616k| if (i < mant->n - 1) mant->digits[i + 1] = quotient; ------------------ | Branch (34270:13): [True: 606k, False: 10.2k] ------------------ 34271| 616k| quotient = (uint32_t)(dividend / divisor); 34272| 616k| remainder = (uint32_t)(dividend % divisor); 34273| 616k| mant->digits[i] = remainder; 34274| 616k| } 34275| 10.2k| dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->first_digit; ------------------ | |34206| 10.2k|#define BIGNAT_BASE 0x80000000U ------------------ 34276| 10.2k| if (mant->n && mant->digits[mant->n - 1] == 0) mant->n--; ------------------ | Branch (34276:9): [True: 10.2k, False: 0] | Branch (34276:20): [True: 4.60k, False: 5.68k] ------------------ 34277| 10.2k| mant->first_digit = (uint32_t)(dividend / divisor); 34278| 10.2k|} janet.c:bignat_extract: 34306| 7.95k|static double bignat_extract(struct BigNat *mant, int32_t exponent2) { 34307| 7.95k| uint64_t top53; 34308| 7.95k| int32_t n = mant->n; 34309| | /* Get most significant 53 bits from mant. Bit 52 (0 indexed) should 34310| | * always be 1. This is essentially a large right shift on mant.*/ 34311| 7.95k| if (n) { ------------------ | Branch (34311:9): [True: 2.78k, False: 5.16k] ------------------ 34312| | /* Two or more digits */ 34313| 2.78k| uint64_t d1 = mant->digits[n - 1]; /* MSD (non-zero) */ 34314| 2.78k| uint64_t d2 = (n == 1) ? mant->first_digit : mant->digits[n - 2]; ------------------ | Branch (34314:23): [True: 304, False: 2.47k] ------------------ 34315| 2.78k| uint64_t d3 = (n > 2) ? mant->digits[n - 3] : (n == 2) ? mant->first_digit : 0; ------------------ | Branch (34315:23): [True: 2.23k, False: 547] | Branch (34315:55): [True: 243, False: 304] ------------------ 34316| 2.78k| int lz = clz((uint32_t) d1); ------------------ | |34292| 2.78k|#define clz(x) __builtin_clz(x) ------------------ 34317| 2.78k| int nbits = 32 - lz; 34318| | /* First get 54 bits */ 34319| 2.78k| top53 = (d2 << (54 - BIGNAT_NBIT)) + (d3 >> (2 * BIGNAT_NBIT - 54)); ------------------ | |34205| 2.78k|#define BIGNAT_NBIT 31 ------------------ top53 = (d2 << (54 - BIGNAT_NBIT)) + (d3 >> (2 * BIGNAT_NBIT - 54)); ------------------ | |34205| 2.78k|#define BIGNAT_NBIT 31 ------------------ 34320| 2.78k| top53 >>= nbits; 34321| 2.78k| top53 |= (d1 << (54 - nbits)); 34322| | /* Rounding based on lowest bit of 54 */ 34323| 2.78k| if (top53 & 1) top53++; ------------------ | Branch (34323:13): [True: 1.72k, False: 1.05k] ------------------ 34324| 2.78k| top53 >>= 1; 34325| 2.78k| if (top53 > 0x1FffffFFFFffffUL) { ------------------ | Branch (34325:13): [True: 16, False: 2.76k] ------------------ 34326| 16| top53 >>= 1; 34327| 16| exponent2++; 34328| 16| } 34329| | /* Correct exponent - to correct for large right shift to mantissa. */ 34330| 2.78k| exponent2 += (nbits - 53) + BIGNAT_NBIT * n; ------------------ | |34205| 2.78k|#define BIGNAT_NBIT 31 ------------------ 34331| 5.16k| } else { 34332| | /* One digit */ 34333| 5.16k| top53 = mant->first_digit; 34334| 5.16k| } 34335| 7.95k| return ldexp((double)top53, exponent2); 34336| 7.95k|} janet.c:scan_uint64: 34546| 2.47k| int *neg) { 34547| 2.47k| const uint8_t *end = str + len; 34548| 2.47k| int seenadigit = 0; 34549| 2.47k| int base = 10; 34550| 2.47k| *neg = 0; 34551| 2.47k| *out = 0; 34552| 2.47k| uint64_t accum = 0; 34553| 2.47k| if (len > JANET_NUMBER_LENGTH_RIDICULOUS) return 0; ------------------ | |34190| 2.47k|#define JANET_NUMBER_LENGTH_RIDICULOUS 0xFFFF ------------------ | Branch (34553:9): [True: 0, False: 2.47k] ------------------ 34554| | /* Get sign */ 34555| 2.47k| if (str >= end) return 0; ------------------ | Branch (34555:9): [True: 0, False: 2.47k] ------------------ 34556| 2.47k| if (*str == '-') { ------------------ | Branch (34556:9): [True: 542, False: 1.93k] ------------------ 34557| 542| *neg = 1; 34558| 542| str++; 34559| 1.93k| } else if (*str == '+') { ------------------ | Branch (34559:16): [True: 254, False: 1.68k] ------------------ 34560| 254| str++; 34561| 254| } 34562| | /* Check for leading 0x or digit digit r */ 34563| 2.47k| if (str + 1 < end && str[0] == '0' && str[1] == 'x') { ------------------ | Branch (34563:9): [True: 1.42k, False: 1.05k] | Branch (34563:26): [True: 321, False: 1.09k] | Branch (34563:43): [True: 36, False: 285] ------------------ 34564| 36| base = 16; 34565| 36| str += 2; 34566| 2.44k| } else if (str + 1 < end && ------------------ | Branch (34566:16): [True: 1.38k, False: 1.05k] ------------------ 34567| 1.38k| str[0] >= '0' && str[0] <= '9' && ------------------ | Branch (34567:16): [True: 1.28k, False: 96] | Branch (34567:33): [True: 1.21k, False: 72] ------------------ 34568| 1.21k| str[1] == 'r') { ------------------ | Branch (34568:16): [True: 24, False: 1.19k] ------------------ 34569| 24| base = str[0] - '0'; 34570| 24| str += 2; 34571| 2.41k| } else if (str + 2 < end && ------------------ | Branch (34571:16): [True: 1.19k, False: 1.22k] ------------------ 34572| 1.19k| str[0] >= '0' && str[0] <= '9' && ------------------ | Branch (34572:16): [True: 1.12k, False: 69] | Branch (34572:33): [True: 1.07k, False: 47] ------------------ 34573| 1.07k| str[1] >= '0' && str[1] <= '9' && ------------------ | Branch (34573:16): [True: 1.05k, False: 27] | Branch (34573:33): [True: 918, False: 132] ------------------ 34574| 918| str[2] == 'r') { ------------------ | Branch (34574:16): [True: 55, False: 863] ------------------ 34575| 55| base = 10 * (str[0] - '0') + (str[1] - '0'); 34576| 55| if (base < 2 || base > 36) return 0; ------------------ | Branch (34576:13): [True: 7, False: 48] | Branch (34576:25): [True: 16, False: 32] ------------------ 34577| 32| str += 3; 34578| 32| } 34579| | 34580| | /* Skip leading zeros */ 34581| 3.36k| while (str < end && *str == '0') { ------------------ | Branch (34581:12): [True: 3.11k, False: 249] | Branch (34581:25): [True: 907, False: 2.20k] ------------------ 34582| 907| seenadigit = 1; 34583| 907| str++; 34584| 907| } 34585| | /* Parse significant digits */ 34586| 14.0k| while (str < end) { ------------------ | Branch (34586:12): [True: 12.0k, False: 1.94k] ------------------ 34587| 12.0k| if (*str == '_') { ------------------ | Branch (34587:13): [True: 550, False: 11.5k] ------------------ 34588| 550| if (!seenadigit) return 0; ------------------ | Branch (34588:17): [True: 51, False: 499] ------------------ 34589| 11.5k| } else { 34590| 11.5k| int digit = digit_lookup[*str & 0x7F]; 34591| 11.5k| if (*str > 127 || digit >= base) return 0; ------------------ | Branch (34591:17): [True: 45, False: 11.4k] | Branch (34591:31): [True: 345, False: 11.1k] ------------------ 34592| 11.1k| if (accum > (UINT64_MAX - digit) / base) return 0; ------------------ | Branch (34592:17): [True: 73, False: 11.0k] ------------------ 34593| 11.0k| accum = accum * base + digit; 34594| 11.0k| seenadigit = 1; 34595| 11.0k| } 34596| 11.5k| str++; 34597| 11.5k| } 34598| | 34599| 1.94k| if (!seenadigit) return 0; ------------------ | Branch (34599:9): [True: 118, False: 1.82k] ------------------ 34600| 1.82k| *out = accum; 34601| 1.82k| return 1; 34602| 1.94k|} janet.c:janet_dict_find: 433| 77.7M|static inline const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) { 434| 77.7M| int32_t hash; 435| 77.7M| if (janet_checktype(key, JANET_KEYWORD) || janet_checktype(key, JANET_SYMBOL)) { ------------------ | | 806| 155M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 23.0M, False: 54.7M] | | | Branch (806:6): [Folded, False: 77.7M] | | ------------------ | | 807| 155M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 155M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 77.7M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 77.7M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 77.7M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 77.7M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(key, JANET_KEYWORD) || janet_checktype(key, JANET_SYMBOL)) { ------------------ | | 806| 54.7M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 17.9M, False: 36.7M] | | | Branch (806:6): [Folded, False: 54.7M] | | ------------------ | | 807| 54.7M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 54.7M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 54.7M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 54.7M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 54.7M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 54.7M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 436| 40.9M| hash = janet_string_hash(janet_unwrap_string(key)); ------------------ | | 1814| 40.9M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 40.9M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 437| 40.9M| } else if (janet_checktypes(key, JANET_TFLAG_NIL | JANET_TFLAG_STRING | JANET_TFLAG_TUPLE | JANET_TFLAG_STRUCT | JANET_TFLAG_ABSTRACT) || ------------------ | | 969| 73.5M|#define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps)) | | ------------------ | | | | 795| 36.7M| (isnan((x).number) \ | | | | 796| 36.7M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | | | 797| 36.7M| : JANET_NUMBER) | | ------------------ | | | Branch (969:34): [True: 27.2M, False: 9.53M] | | ------------------ ------------------ | Branch (437:16): [True: 36.7M, False: 7.69k] ------------------ 438| 27.2M| (janet_checktype(key, JANET_NUMBER) && janet_unwrap_number(key) == 0)) { ------------------ | | 806| 19.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 7.69k, False: 9.52M] | | | Branch (806:6): [True: 9.53M, Folded] | | ------------------ | | 807| 19.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 9.53M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 7.69k, False: 9.52M] | | | | | Branch (803:28): [True: 0, False: 9.52M] | | | | ------------------ | | ------------------ | | 808| 19.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ (janet_checktype(key, JANET_NUMBER) && janet_unwrap_number(key) == 0)) { ------------------ | | 839| 7.69k|#define janet_unwrap_number(x) ((x).number) ------------------ | Branch (438:55): [True: 1.41k, False: 6.28k] ------------------ 439| 27.2M| return janet_dict_find_deep(buckets, cap, key); 440| 27.2M| } else { 441| 9.53M| hash = janet_hash(key); 442| 9.53M| } 443| 50.5M| uint32_t mask = (uint32_t) cap - 1; 444| 50.5M| uint32_t i = (uint32_t) hash & mask; 445| 50.5M| const JanetKV *first_bucket = NULL; 446| 65.0M| for (int32_t n = 0; n < cap; n++, i = (i + 1) & mask) { ------------------ | Branch (446:25): [True: 65.0M, False: 0] ------------------ 447| 65.0M| const JanetKV *kv = buckets + i; 448| 65.0M| if (janet_bitwise_same(kv->key, key)) return kv; ------------------ | | 401| 65.0M|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 65.0M|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 65.0M|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 2.02M, False: 63.0M] | | ------------------ ------------------ 449| 63.0M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 63.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 48.4M, False: 14.5M] | | | Branch (806:6): [Folded, False: 63.0M] | | ------------------ | | 807| 63.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 63.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 63.0M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 63.0M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 63.0M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 63.0M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 450| 48.4M| if (janet_checktype(kv->value, JANET_NIL)) return kv; ------------------ | | 806| 48.4M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 48.4M, False: 5.21k] | | | Branch (806:6): [Folded, False: 48.4M] | | ------------------ | | 807| 48.4M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 48.4M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 48.4M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 48.4M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 48.4M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 48.4M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 451| 5.21k| if (NULL == first_bucket) first_bucket = kv; ------------------ | Branch (451:17): [True: 2.86k, False: 2.35k] ------------------ 452| 5.21k| } 453| 63.0M| } 454| 0| return first_bucket; 455| 50.5M|} janet.c:janet_symcache_findmem: 35074| 36.0M| int *success) { 35075| 36.0M| uint32_t bounds[4]; 35076| 36.0M| uint32_t i, j, index; 35077| 36.0M| const uint8_t **firstEmpty = NULL; 35078| | 35079| | /* We will search two ranges - index to the end, 35080| | * and 0 to the index. */ 35081| 36.0M| index = (uint32_t)hash & (janet_vm.cache_capacity - 1); 35082| 36.0M| bounds[0] = index; 35083| 36.0M| bounds[1] = janet_vm.cache_capacity; 35084| 36.0M| bounds[2] = 0; 35085| 36.0M| bounds[3] = index; 35086| 36.0M| for (j = 0; j < 4; j += 2) ------------------ | Branch (35086:17): [True: 36.0M, False: 0] ------------------ 35087| 56.0M| for (i = bounds[j]; i < bounds[j + 1]; ++i) { ------------------ | Branch (35087:29): [True: 56.0M, False: 11.3k] ------------------ 35088| 56.0M| const uint8_t *test = janet_vm.cache[i]; 35089| | /* Check empty spots */ 35090| 56.0M| if (NULL == test) { ------------------ | Branch (35090:17): [True: 20.0M, False: 36.0M] ------------------ 35091| 20.0M| if (NULL == firstEmpty) ------------------ | Branch (35091:21): [True: 20.0M, False: 0] ------------------ 35092| 20.0M| firstEmpty = janet_vm.cache + i; 35093| 20.0M| goto notfound; 35094| 20.0M| } 35095| | /* Check for marked deleted */ 35096| 36.0M| if (JANET_SYMCACHE_DELETED == test) { ------------------ | Branch (35096:17): [True: 5.64k, False: 36.0M] ------------------ 35097| 5.64k| if (firstEmpty == NULL) ------------------ | Branch (35097:21): [True: 5.64k, False: 0] ------------------ 35098| 5.64k| firstEmpty = janet_vm.cache + i; 35099| 5.64k| continue; 35100| 5.64k| } 35101| 36.0M| if (janet_string_equalconst(test, str, len, hash)) { ------------------ | Branch (35101:17): [True: 16.0M, False: 20.0M] ------------------ 35102| | /* Replace first deleted */ 35103| 16.0M| *success = 1; 35104| 16.0M| if (firstEmpty != NULL) { ------------------ | Branch (35104:21): [True: 5.64k, False: 16.0M] ------------------ 35105| 5.64k| *firstEmpty = test; 35106| 5.64k| janet_vm.cache[i] = JANET_SYMCACHE_DELETED; 35107| 5.64k| return firstEmpty; 35108| 5.64k| } 35109| 16.0M| return janet_vm.cache + i; 35110| 16.0M| } 35111| 36.0M| } 35112| 20.0M|notfound: 35113| 20.0M| *success = 0; 35114| 20.0M| janet_assert(firstEmpty != NULL, "symcache failed to get memory"); ------------------ | | 389| 20.0M|#define janet_assert(c, m) do { \ | | 390| 20.0M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 20.0M] | | ------------------ | | 391| 20.0M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 20.0M] | | ------------------ ------------------ 35115| 20.0M| return firstEmpty; 35116| 20.0M|} janet.c:janet_symcache_put: 35152| 11.3M|static void janet_symcache_put(const uint8_t *x, const uint8_t **bucket) { 35153| 11.3M| if ((janet_vm.cache_count + janet_vm.cache_deleted) * 2 > janet_vm.cache_capacity) { ------------------ | Branch (35153:9): [True: 11.3k, False: 11.2M] ------------------ 35154| 11.3k| int status; 35155| 11.3k| janet_cache_resize(janet_tablen((2 * janet_vm.cache_count + 1))); 35156| 11.3k| bucket = janet_symcache_find(x, &status); ------------------ | |35119| 11.3k| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 11.3k|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 11.3k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1814| 11.3k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 11.3k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35157| 11.3k| } 35158| | /* Add x to the cache */ 35159| 11.3M| janet_vm.cache_count++; 35160| 11.3M| *bucket = x; 35161| 11.3M|} janet.c:janet_cache_resize: 35122| 11.3k|static void janet_cache_resize(uint32_t newCapacity) { 35123| 11.3k| uint32_t i, oldCapacity; 35124| 11.3k| const uint8_t **oldCache = janet_vm.cache; 35125| 11.3k| const uint8_t **newCache = janet_calloc(1, (size_t) newCapacity * sizeof(const uint8_t *)); ------------------ | | 2412| 11.3k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 35126| 11.3k| if (newCache == NULL) { ------------------ | Branch (35126:9): [True: 0, False: 11.3k] ------------------ 35127| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35128| 0| } 35129| 11.3k| oldCapacity = janet_vm.cache_capacity; 35130| 11.3k| janet_vm.cache = newCache; 35131| 11.3k| janet_vm.cache_capacity = newCapacity; 35132| 11.3k| janet_vm.cache_deleted = 0; 35133| | /* Add all of the old cache entries back */ 35134| 17.3M| for (i = 0; i < oldCapacity; ++i) { ------------------ | Branch (35134:17): [True: 17.3M, False: 11.3k] ------------------ 35135| 17.3M| int status; 35136| 17.3M| const uint8_t **bucket; 35137| 17.3M| const uint8_t *x = oldCache[i]; 35138| 17.3M| if (x != NULL && x != JANET_SYMCACHE_DELETED) { ------------------ | Branch (35138:13): [True: 8.70M, False: 8.68M] | Branch (35138:26): [True: 8.70M, False: 0] ------------------ 35139| 8.70M| bucket = janet_symcache_find(x, &status); ------------------ | |35119| 8.70M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 8.70M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 8.70M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1814| 8.70M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 8.70M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35140| 8.70M| if (status || bucket == NULL) { ------------------ | Branch (35140:17): [True: 0, False: 8.70M] | Branch (35140:27): [True: 0, False: 8.70M] ------------------ 35141| | /* there was a problem with the algorithm. */ 35142| 0| break; 35143| 0| } 35144| 8.70M| *bucket = x; 35145| 8.70M| } 35146| 17.3M| } 35147| | /* Free the old cache */ 35148| 11.3k| janet_free((void *)oldCache); ------------------ | | 2415| 11.3k|#define janet_free(X) free((X)) ------------------ 35149| 11.3k|} janet.c:janet_table_init_impl: 35293| 13.1M|static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) { 35294| 13.1M| JanetKV *data; 35295| 13.1M| capacity = janet_tablen(capacity); 35296| 13.1M| if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK; ------------------ | |35279| 9.02M|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (35296:9): [True: 9.02M, False: 4.16M] ------------------ 35297| 13.1M| if (capacity) { ------------------ | Branch (35297:9): [True: 13.1M, False: 0] ------------------ 35298| 13.1M| if (stackalloc) { ------------------ | Branch (35298:13): [True: 9.02M, False: 4.16M] ------------------ 35299| 9.02M| data = janet_memalloc_empty_local(capacity); 35300| 9.02M| } else { 35301| 4.16M| data = (JanetKV *) janet_memalloc_empty(capacity); 35302| 4.16M| if (NULL == data) { ------------------ | Branch (35302:17): [True: 0, False: 4.16M] ------------------ 35303| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35304| 0| } 35305| 4.16M| } 35306| 13.1M| table->data = data; 35307| 13.1M| table->capacity = capacity; 35308| 13.1M| } else { 35309| 0| table->data = NULL; 35310| 0| table->capacity = 0; 35311| 0| } 35312| 13.1M| table->count = 0; 35313| 13.1M| table->deleted = 0; 35314| | table->proto = NULL; 35315| 13.1M| return table; 35316| 13.1M|} janet.c:janet_memalloc_empty_local: 35281| 9.02M|static void *janet_memalloc_empty_local(int32_t count) { 35282| 9.02M| int32_t i; 35283| 9.02M| void *mem = janet_smalloc((size_t) count * sizeof(JanetKV)); 35284| 9.02M| JanetKV *mmem = (JanetKV *)mem; 35285| 153M| for (i = 0; i < count; i++) { ------------------ | Branch (35285:17): [True: 144M, False: 9.02M] ------------------ 35286| 144M| JanetKV *kv = mmem + i; 35287| 144M| kv->key = janet_wrap_nil(); ------------------ | | 831| 144M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 144M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 144M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 144M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35288| 144M| kv->value = janet_wrap_nil(); ------------------ | | 831| 144M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 144M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 144M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 144M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35289| 144M| } 35290| 9.02M| return mem; 35291| 9.02M|} janet.c:janet_table_rehash: 35366| 3.35M|static void janet_table_rehash(JanetTable *t, int32_t size) { 35367| 3.35M| JanetKV *olddata = t->data; 35368| 3.35M| JanetKV *newdata; 35369| 3.35M| int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK; ------------------ | |35279| 3.35M|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ 35370| 3.35M| if (islocal) { ------------------ | Branch (35370:9): [True: 2.92k, False: 3.35M] ------------------ 35371| 2.92k| newdata = (JanetKV *) janet_memalloc_empty_local(size); 35372| 3.35M| } else { 35373| 3.35M| newdata = (JanetKV *) janet_memalloc_empty(size); 35374| 3.35M| if (NULL == newdata) { ------------------ | Branch (35374:13): [True: 0, False: 3.35M] ------------------ 35375| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35376| 0| } 35377| 3.35M| } 35378| 3.35M| int32_t oldcapacity = t->capacity; 35379| 3.35M| t->data = newdata; 35380| 3.35M| t->capacity = size; 35381| 3.35M| t->deleted = 0; 35382| 40.4M| for (int32_t i = 0; i < oldcapacity; i++) { ------------------ | Branch (35382:25): [True: 37.0M, False: 3.35M] ------------------ 35383| 37.0M| JanetKV *kv = olddata + i; 35384| 37.0M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 37.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 37.0M] | | ------------------ | | 807| 37.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 37.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 37.0M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 37.0M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 37.0M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 37.0M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35384:13): [True: 18.5M, False: 18.5M] ------------------ 35385| 18.5M| JanetKV *newkv = janet_table_find(t, kv->key); 35386| 18.5M| *newkv = *kv; 35387| 18.5M| } 35388| 37.0M| } 35389| 3.35M| if (islocal) { ------------------ | Branch (35389:9): [True: 2.92k, False: 3.35M] ------------------ 35390| 2.92k| janet_sfree(olddata); 35391| 3.35M| } else { 35392| 3.35M| janet_free(olddata); ------------------ | | 2415| 3.35M|#define janet_free(X) free((X)) ------------------ 35393| 3.35M| } 35394| 3.35M|} janet.c:janet_check_pointer_align: 36455| 2.04M|static void janet_check_pointer_align(void *p) { 36456| 2.04M| (void) p; 36457| |#if defined(JANET_NANBOX_64) && JANET_NANBOX_64_POINTER_SHIFT != 0 36458| | union { 36459| | void *p; 36460| | uintptr_t u; 36461| | } un; 36462| | un.p = p; 36463| | janet_assert(!(un.u & (uintptr_t)((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), 36464| | "unaligned pointer wrap - cfunction pointers and abstract types must be aligned with this nanboxing configuration."); 36465| |#endif 36466| 2.04M|} janet.c:janet_equals_containers: 37366| 45.9k|static int janet_equals_containers(Janet x, Janet y) { 37367| 45.9k| janet_vm.traversal = janet_vm.traversal_base; 37368| 47.3k| do { 37369| 47.3k| if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 47.3k| (isnan((x).number) \ | | 796| 47.3k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 47.3k| : JANET_NUMBER) ------------------ if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 47.3k| (isnan((x).number) \ | | 796| 47.3k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 47.3k| : JANET_NUMBER) ------------------ | Branch (37369:13): [True: 47.1k, False: 186] | Branch (37369:13): [True: 41, False: 47.3k] | Branch (37369:30): [True: 47.1k, False: 188] ------------------ 37370| 47.3k| switch (janet_type(x)) { ------------------ | | 795| 47.3k| (isnan((x).number) \ | | 796| 47.3k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 47.3k| : JANET_NUMBER) ------------------ | Branch (37370:17): [True: 47.1k, False: 173] ------------------ 37371| 1.23k| default: ------------------ | Branch (37371:13): [True: 1.23k, False: 46.0k] ------------------ 37372| 1.23k| if (!janet_equals_leaf(x, y)) return 0; ------------------ | Branch (37372:21): [True: 52, False: 1.18k] ------------------ 37373| 1.18k| break; 37374| 44.4k| case JANET_TUPLE: { ------------------ | Branch (37374:13): [True: 44.4k, False: 2.89k] ------------------ 37375| 44.4k| const Janet *t1 = janet_unwrap_tuple(x); ------------------ | | 858| 44.4k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37376| 44.4k| const Janet *t2 = janet_unwrap_tuple(y); ------------------ | | 858| 44.4k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37377| 44.4k| if (t1 == t2) break; ------------------ | Branch (37377:21): [True: 0, False: 44.4k] ------------------ 37378| 44.4k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1798| 44.4k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1806| 44.4k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 44.4k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1806| 44.4k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 44.4k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37378:21): [True: 1.01k, False: 43.4k] ------------------ 37379| 43.4k| if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1803| 43.4k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 43.4k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1803| 43.4k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 43.4k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37379:21): [True: 42.8k, False: 551] ------------------ 37380| 551| if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1802| 551|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 551|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1802| 551|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 551|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37380:21): [True: 0, False: 551] ------------------ 37381| 551| push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1800| 551|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1800| 551|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 37382| 551| break; 37383| 551| } 37384| 1.65k| case JANET_STRUCT: { ------------------ | Branch (37384:13): [True: 1.65k, False: 45.6k] ------------------ 37385| 1.65k| const JanetKV *s1 = janet_unwrap_struct(x); ------------------ | | 857| 1.65k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37386| 1.65k| const JanetKV *s2 = janet_unwrap_struct(y); ------------------ | | 857| 1.65k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37387| 1.65k| if (s1 == s2) break; ------------------ | Branch (37387:21): [True: 0, False: 1.65k] ------------------ 37388| 1.65k| if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1850| 1.65k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 1.65k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1850| 1.65k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 1.65k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37388:21): [True: 1.51k, False: 135] ------------------ 37389| 135| if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1848| 135|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 135|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1848| 135|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 135|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37389:21): [True: 0, False: 135] ------------------ 37390| 135| if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1851| 270|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 135|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 0, False: 135] | | ------------------ ------------------ if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1851| 0|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37390:47): [True: 0, False: 0] ------------------ 37391| 135| if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1851| 270|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 135|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1851| 135|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 135|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 0, False: 135] | | ------------------ ------------------ | Branch (37391:21): [True: 135, False: 0] ------------------ 37392| 135| push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1846| 135|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1846| 135|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 37393| 135| break; 37394| 135| } 37395| 47.3k| } 37396| 47.3k| } while (!traversal_next(&x, &y)); ------------------ | Branch (37396:14): [True: 1.36k, False: 508] ------------------ 37397| 508| return 1; 37398| 45.9k|} janet.c:janet_equals_leaf: 37353| 3.72k|static int janet_equals_leaf(Janet x, Janet y) { 37354| 3.72k| switch (janet_type(x)) { ------------------ | | 795| 3.72k| (isnan((x).number) \ | | 796| 3.72k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 3.72k| : JANET_NUMBER) ------------------ | Branch (37354:13): [True: 3.38k, False: 346] ------------------ 37355| 346| case JANET_NUMBER: ------------------ | Branch (37355:9): [True: 346, False: 3.38k] ------------------ 37356| 346| return janet_unwrap_number(x) == janet_unwrap_number(y); ------------------ | | 839| 346|#define janet_unwrap_number(x) ((x).number) ------------------ return janet_unwrap_number(x) == janet_unwrap_number(y); ------------------ | | 839| 346|#define janet_unwrap_number(x) ((x).number) ------------------ 37357| 2.26k| case JANET_STRING: ------------------ | Branch (37357:9): [True: 2.26k, False: 1.46k] ------------------ 37358| 2.26k| return janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 2.26k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ return janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 2.26k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 37359| 252| case JANET_ABSTRACT: ------------------ | Branch (37359:9): [True: 252, False: 3.47k] ------------------ 37360| 252| return !janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 252|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ return !janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 252|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37361| 865| default: ------------------ | Branch (37361:9): [True: 865, False: 2.86k] ------------------ 37362| 865| return janet_bitwise_same(x, y); ------------------ | | 401| 865|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 865|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 865|#define janet_u64(x) ((x).u64) | | ------------------ ------------------ 37363| 3.72k| } 37364| 3.72k|} janet.c:murmur64: 37406| 17.5M|static uint64_t murmur64(uint64_t h) { 37407| 17.5M| h ^= h >> 33; 37408| 17.5M| h *= 0xff51afd7ed558ccdUL; 37409| 17.5M| h ^= h >> 33; 37410| 17.5M| h *= 0xc4ceb9fe1a85ec53UL; 37411| 17.5M| h ^= h >> 33; 37412| 17.5M| return h; 37413| 17.5M|} janet.c:janet_compare_abstract: 37339| 911|static int janet_compare_abstract(JanetAbstract xx, JanetAbstract yy) { 37340| 911| if (xx == yy) return 0; ------------------ | Branch (37340:9): [True: 0, False: 911] ------------------ 37341| 911| const JanetAbstractType *xt = janet_abstract_type(xx); ------------------ | | 1899| 911|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 911|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37342| 911| const JanetAbstractType *yt = janet_abstract_type(yy); ------------------ | | 1899| 911|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 911|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37343| 911| if (xt != yt) { ------------------ | Branch (37343:9): [True: 131, False: 780] ------------------ 37344| 131| return xt > yt ? 1 : -1; ------------------ | Branch (37344:16): [True: 75, False: 56] ------------------ 37345| 131| } 37346| 780| if (xt->compare == NULL) { ------------------ | Branch (37346:9): [True: 35, False: 745] ------------------ 37347| 35| return xx > yy ? 1 : -1; ------------------ | Branch (37347:16): [True: 4, False: 31] ------------------ 37348| 35| } 37349| 745| return xt->compare(xx, yy); 37350| 780|} janet.c:push_traversal_node: 37137| 4.29k|static void push_traversal_node(void *lhs, void *rhs, int32_t index2) { 37138| 4.29k| JanetTraversalNode node; 37139| 4.29k| node.self = (JanetGCObject *) lhs; 37140| 4.29k| node.other = (JanetGCObject *) rhs; 37141| 4.29k| node.index = 0; 37142| 4.29k| node.index2 = index2; 37143| 4.29k| int is_new = janet_vm.traversal_base == NULL; 37144| 4.29k| if (is_new || (janet_vm.traversal + 1 >= janet_vm.traversal_top)) { ------------------ | Branch (37144:9): [True: 520, False: 3.77k] | Branch (37144:19): [True: 0, False: 3.77k] ------------------ 37145| 520| size_t oldsize = is_new ? 0 : (janet_vm.traversal - janet_vm.traversal_base); ------------------ | Branch (37145:26): [True: 520, False: 0] ------------------ 37146| 520| size_t newsize = 2 * oldsize + 1; 37147| 520| if (newsize < 128) { ------------------ | Branch (37147:13): [True: 520, False: 0] ------------------ 37148| 520| newsize = 128; 37149| 520| } 37150| 520| JanetTraversalNode *tn = janet_realloc(janet_vm.traversal_base, newsize * sizeof(JanetTraversalNode)); ------------------ | | 2409| 520|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 37151| 520| if (tn == NULL) { ------------------ | Branch (37151:13): [True: 0, False: 520] ------------------ 37152| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 37153| 0| } 37154| 520| janet_vm.traversal_base = tn; 37155| 520| janet_vm.traversal_top = janet_vm.traversal_base + newsize; 37156| 520| janet_vm.traversal = janet_vm.traversal_base + oldsize; 37157| 520| } 37158| 4.29k| *(++janet_vm.traversal) = node; 37159| 4.29k|} janet.c:traversal_next: 37169| 10.4k|static int traversal_next(Janet *x, Janet *y) { 37170| 10.4k| JanetTraversalNode *t = janet_vm.traversal; 37171| 11.9k| while (t && t > janet_vm.traversal_base) { ------------------ | Branch (37171:12): [True: 10.9k, False: 956] | Branch (37171:17): [True: 9.51k, False: 1.45k] ------------------ 37172| 9.51k| JanetGCObject *self = t->self; 37173| 9.51k| JanetTupleHead *tself = (JanetTupleHead *)self; 37174| 9.51k| JanetStructHead *sself = (JanetStructHead *)self; 37175| 9.51k| JanetGCObject *other = t->other; 37176| 9.51k| JanetTupleHead *tother = (JanetTupleHead *)other; 37177| 9.51k| JanetStructHead *sother = (JanetStructHead *)other; 37178| 9.51k| if ((self->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_TUPLE) { ------------------ | | 675| 9.51k|#define JANET_MEM_TYPEBITS 0xFF ------------------ | Branch (37178:13): [True: 7.26k, False: 2.25k] ------------------ 37179| | /* Node is a tuple at index t->index */ 37180| 7.26k| if (t->index < tself->length && t->index < tother->length) { ------------------ | Branch (37180:17): [True: 6.48k, False: 775] | Branch (37180:45): [True: 6.47k, False: 14] ------------------ 37181| 6.47k| int32_t index = t->index++; 37182| 6.47k| *x = tself->data[index]; 37183| 6.47k| *y = tother->data[index]; 37184| 6.47k| janet_vm.traversal = t; 37185| 6.47k| return 0; 37186| 6.47k| } 37187| 789| if (t->index2 && tself->length != tother->length) { ------------------ | Branch (37187:17): [True: 339, False: 450] | Branch (37187:30): [True: 20, False: 319] ------------------ 37188| 20| return tself->length > tother->length ? 3 : 1; ------------------ | Branch (37188:24): [True: 14, False: 6] ------------------ 37189| 20| } 37190| 2.25k| } else { 37191| | /* Node is a struct at index t->index: if t->index2 is true, we should return the values. */ 37192| 2.25k| if (t->index2) { ------------------ | Branch (37192:17): [True: 765, False: 1.48k] ------------------ 37193| 765| t->index2 = 0; 37194| 765| int32_t index = t->index++; 37195| 765| *x = sself->data[index].value; 37196| 765| *y = sother->data[index].value; 37197| 765| janet_vm.traversal = t; 37198| 765| return 0; 37199| 765| } 37200| 1.48k| for (int32_t i = t->index; i < sself->capacity; i++) { ------------------ | Branch (37200:40): [True: 765, False: 724] ------------------ 37201| 765| t->index2 = 1; 37202| 765| *x = sself->data[t->index].key; 37203| 765| *y = sother->data[t->index].key; 37204| 765| janet_vm.traversal = t; 37205| 765| return 0; 37206| 765| } 37207| | /* Traverse prototype */ 37208| 724| JanetStruct sproto = sself->proto; 37209| 724| JanetStruct oproto = sother->proto; 37210| 724| if (sproto && !oproto) return 3; ------------------ | Branch (37210:17): [True: 0, False: 724] | Branch (37210:27): [True: 0, False: 0] ------------------ 37211| 724| if (!sproto && oproto) return 1; ------------------ | Branch (37211:17): [True: 724, False: 0] | Branch (37211:28): [True: 0, False: 724] ------------------ 37212| 724| if (oproto && sproto) { ------------------ | Branch (37212:17): [True: 0, False: 724] | Branch (37212:27): [True: 0, False: 0] ------------------ 37213| 0| *x = janet_wrap_struct(sproto); ------------------ | | 842| 0|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37214| 0| *y = janet_wrap_struct(oproto); ------------------ | | 842| 0|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37215| 0| janet_vm.traversal = t - 1; 37216| 0| return 0; 37217| 0| } 37218| 724| } 37219| 1.49k| t--; 37220| 1.49k| } 37221| 2.40k| janet_vm.traversal = t; 37222| 2.40k| return 2; 37223| 10.4k|} LLVMFuzzerTestOneInput: 7| 5.65k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 8| 5.65k| if (size < 2 || size > JANET_PEG_FUZZ_MAX_INPUT) ------------------ | | 5| 5.65k|#define JANET_PEG_FUZZ_MAX_INPUT (1U << 20) ------------------ | Branch (8:9): [True: 1, False: 5.65k] | Branch (8:21): [True: 0, False: 5.65k] ------------------ 9| 1| return 0; 10| | 11| | /* Byte 0 selects the split point for a Janet PEG pattern and subject. */ 12| 5.65k| size_t patlen = (size_t)data[0] % (size - 1); 13| 5.65k| const uint8_t *patsrc = data + 1; 14| 5.65k| const uint8_t *text = data + 1 + patlen; 15| 5.65k| size_t textlen = size - 1 - patlen; 16| | 17| 5.65k| janet_init(); 18| | 19| 5.65k| JanetParser parser; 20| 5.65k| janet_parser_init(&parser); 21| 5.65k| Janet matchfn = janet_resolve_core("peg/match"); 22| 5.65k| if (janet_checktype(matchfn, JANET_CFUNCTION)) { ------------------ | | 806| 5.65k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 5.65k, False: 0] | | | Branch (806:6): [Folded, False: 5.65k] | | ------------------ | | 807| 5.65k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 5.65k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.65k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.65k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.65k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.65k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 23| 5.65k| JanetCFunction cfun = janet_unwrap_cfunction(matchfn); ------------------ | | 869| 5.65k|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 24| | 25| | /* Stop after parser errors: consuming again would panic. */ 26| 257k| for (size_t i = 0; i < patlen; i++) { ------------------ | Branch (26:28): [True: 252k, False: 4.91k] ------------------ 27| 252k| janet_parser_consume(&parser, patsrc[i]); 28| 252k| if (janet_parser_status(&parser) == JANET_PARSE_ERROR) ------------------ | Branch (28:17): [True: 737, False: 252k] ------------------ 29| 737| break; 30| 252k| } 31| 5.65k| if (janet_parser_status(&parser) != JANET_PARSE_ERROR) ------------------ | Branch (31:13): [True: 4.91k, False: 737] ------------------ 32| 4.91k| janet_parser_eof(&parser); 33| | 34| 5.65k| if (janet_parser_status(&parser) != JANET_PARSE_ERROR && ------------------ | Branch (34:13): [True: 3.52k, False: 2.12k] ------------------ 35| 3.52k| janet_parser_has_more(&parser)) { ------------------ | Branch (35:17): [True: 3.43k, False: 95] ------------------ 36| 3.43k| Janet pattern = janet_parser_produce(&parser); 37| 3.43k| JanetTryState tstate; 38| 3.43k| if (janet_try(&tstate) == JANET_SIGNAL_OK) { ------------------ | | 1981| 3.43k|#define janet_try(state) (janet_try_init(state), (JanetSignal) setjmp((state)->buf)) ------------------ | Branch (38:17): [True: 3.43k, False: 0] ------------------ 39| 3.43k| Janet argv[2]; 40| 3.43k| argv[0] = pattern; 41| 3.43k| argv[1] = janet_stringv(text, (int32_t)textlen); ------------------ | | 1827| 3.43k|#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) | | ------------------ | | | | 848| 3.43k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 3.43k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 3.43k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 3.43k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 42| 3.43k| cfun(2, argv); 43| 3.43k| } 44| 3.43k| janet_restore(&tstate); 45| 3.43k| } 46| 5.65k| } 47| | 48| 5.65k| janet_parser_deinit(&parser); 49| 5.65k| janet_deinit(); 50| 5.65k| return 0; 51| 5.65k|}