janet_abstract_begin: 1389| 11.1k|void *janet_abstract_begin(const JanetAbstractType *atype, size_t size) { 1390| 11.1k| JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_NONE, 1391| 11.1k| sizeof(JanetAbstractHead) + size); 1392| 11.1k| header->size = size; 1393| 11.1k| header->type = atype; 1394| 11.1k| return (void *) & (header->data); 1395| 11.1k|} janet_abstract_end: 1397| 11.1k|void *janet_abstract_end(void *x) { 1398| 11.1k| janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_ABSTRACT); ------------------ | | 679| 11.1k|#define janet_gc_settype(m, t) ((janet_gc_header(m)->flags |= (0xFF & (t)))) | | ------------------ | | | | 673| 11.1k|#define janet_gc_header(mem) ((JanetGCObject *)(mem)) | | ------------------ ------------------ 1399| 11.1k| return x; 1400| 11.1k|} janet_abstract: 1402| 11.1k|void *janet_abstract(const JanetAbstractType *atype, size_t size) { 1403| 11.1k| return janet_abstract_end(janet_abstract_begin(atype, size)); 1404| 11.1k|} janet_array: 1621| 89.6k|JanetArray *janet_array(int32_t capacity) { 1622| 89.6k| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); 1623| 89.6k| janet_array_impl(array, capacity); 1624| 89.6k| return array; 1625| 89.6k|} janet_array_weak: 1628| 7.97k|JanetArray *janet_array_weak(int32_t capacity) { 1629| 7.97k| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY_WEAK, sizeof(JanetArray)); 1630| 7.97k| janet_array_impl(array, capacity); 1631| 7.97k| return array; 1632| 7.97k|} janet_lib_array: 1978| 3.70k|void janet_lib_array(JanetTable *env) { 1979| 3.70k| JanetRegExt array_cfuns[] = { 1980| 3.70k| JANET_CORE_REG("array/new", cfun_array_new), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1981| 3.70k| JANET_CORE_REG("array/weak", cfun_array_weak), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1982| 3.70k| JANET_CORE_REG("array/new-filled", cfun_array_new_filled), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1983| 3.70k| JANET_CORE_REG("array/fill", cfun_array_fill), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1984| 3.70k| JANET_CORE_REG("array/pop", cfun_array_pop), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1985| 3.70k| JANET_CORE_REG("array/peek", cfun_array_peek), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1986| 3.70k| JANET_CORE_REG("array/push", cfun_array_push), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1987| 3.70k| JANET_CORE_REG("array/ensure", cfun_array_ensure), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1988| 3.70k| JANET_CORE_REG("array/slice", cfun_array_slice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1989| 3.70k| JANET_CORE_REG("array/concat", cfun_array_concat), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1990| 3.70k| JANET_CORE_REG("array/insert", cfun_array_insert), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1991| 3.70k| JANET_CORE_REG("array/remove", cfun_array_remove), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1992| 3.70k| JANET_CORE_REG("array/trim", cfun_array_trim), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1993| 3.70k| JANET_CORE_REG("array/clear", cfun_array_clear), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1994| 3.70k| JANET_CORE_REG("array/join", cfun_array_join), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1995| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 1996| 3.70k| }; 1997| | janet_core_cfuns_ext(env, NULL, array_cfuns); 1998| 3.70k|} janet_lib_asm: 3143| 3.70k|void janet_lib_asm(JanetTable *env) { 3144| 3.70k| JanetRegExt asm_cfuns[] = { 3145| 3.70k| JANET_CORE_REG("asm", cfun_asm), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3146| 3.70k| JANET_CORE_REG("disasm", cfun_disasm), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3147| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3148| 3.70k| }; 3149| | janet_core_cfuns_ext(env, NULL, asm_cfuns); 3150| 3.70k|} janet_buffer_init: 3211| 1.91k|JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) { 3212| 1.91k| janet_buffer_init_impl(buffer, capacity); 3213| 1.91k| buffer->gc.data.next = NULL; 3214| 1.91k| buffer->gc.flags = JANET_MEM_DISABLED; ------------------ | | 677| 1.91k|#define JANET_MEM_DISABLED 0x200 ------------------ 3215| 1.91k| return buffer; 3216| 1.91k|} janet_buffer_deinit: 3231| 10.3k|void janet_buffer_deinit(JanetBuffer *buffer) { 3232| 10.3k| if (!(buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) { ------------------ | | 1780| 10.3k|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3232:9): [True: 10.3k, False: 0] ------------------ 3233| 10.3k| janet_free(buffer->data); ------------------ | | 2415| 10.3k|#define janet_free(X) free((X)) ------------------ 3234| | buffer->data = NULL; 3235| 10.3k| } 3236| 10.3k|} janet_buffer: 3239| 8.39k|JanetBuffer *janet_buffer(int32_t capacity) { 3240| 8.39k| JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer)); 3241| 8.39k| return janet_buffer_init_impl(buffer, capacity); 3242| 8.39k|} janet_buffer_extra: 3275| 128k|void janet_buffer_extra(JanetBuffer *buffer, int32_t n) { 3276| | /* Check for buffer overflow */ 3277| 128k| if ((int64_t)n + buffer->count > INT32_MAX) { ------------------ | Branch (3277:9): [True: 0, False: 128k] ------------------ 3278| 0| janet_panic("buffer overflow"); 3279| 0| } 3280| 128k| int32_t new_size = buffer->count + n; 3281| 128k| if (new_size > buffer->capacity) { ------------------ | Branch (3281:9): [True: 1.72k, False: 127k] ------------------ 3282| 1.72k| janet_buffer_can_realloc(buffer); 3283| 1.72k| int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2); ------------------ | Branch (3283:32): [True: 0, False: 1.72k] ------------------ 3284| 1.72k| uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t)); ------------------ | | 2409| 1.72k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 3285| 1.72k| janet_gcpressure(new_capacity - buffer->capacity); 3286| 1.72k| if (NULL == new_data) { ------------------ | Branch (3286:13): [True: 0, False: 1.72k] ------------------ 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| 1.72k| buffer->data = new_data; 3290| 1.72k| buffer->capacity = new_capacity; 3291| 1.72k| } 3292| 128k|} janet_buffer_push_cstring: 3295| 395|void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) { 3296| 395| int32_t len = (int32_t) strlen(cstring); 3297| 395| janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len); 3298| 395|} janet_buffer_push_bytes: 3301| 61.5k|void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) { 3302| 61.5k| if (0 == length) return; ------------------ | Branch (3302:9): [True: 0, False: 61.5k] ------------------ 3303| 61.5k| janet_buffer_extra(buffer, length); 3304| 61.5k| memcpy(buffer->data + buffer->count, string, length); 3305| 61.5k| buffer->count += length; 3306| 61.5k|} janet_buffer_push_u8: 3313| 67.1k|void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t byte) { 3314| 67.1k| janet_buffer_extra(buffer, 1); 3315| 67.1k| buffer->data[buffer->count] = byte; 3316| 67.1k| buffer->count++; 3317| 67.1k|} janet_lib_buffer: 3837| 3.70k|void janet_lib_buffer(JanetTable *env) { 3838| 3.70k| JanetRegExt buffer_cfuns[] = { 3839| 3.70k| JANET_CORE_REG("buffer/new", cfun_buffer_new), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3840| 3.70k| JANET_CORE_REG("buffer/new-filled", cfun_buffer_new_filled), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3841| 3.70k| JANET_CORE_REG("buffer/from-bytes", cfun_buffer_frombytes), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3842| 3.70k| JANET_CORE_REG("buffer/fill", cfun_buffer_fill), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3843| 3.70k| JANET_CORE_REG("buffer/trim", cfun_buffer_trim), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3844| 3.70k| JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3845| 3.70k| JANET_CORE_REG("buffer/push-word", cfun_buffer_word), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3846| 3.70k| JANET_CORE_REG("buffer/push-string", cfun_buffer_chars), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3847| 3.70k| JANET_CORE_REG("buffer/push-uint16", cfun_buffer_push_uint16), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3848| 3.70k| JANET_CORE_REG("buffer/push-uint32", cfun_buffer_push_uint32), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3849| 3.70k| JANET_CORE_REG("buffer/push-uint64", cfun_buffer_push_uint64), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3850| 3.70k| JANET_CORE_REG("buffer/push-float32", cfun_buffer_push_float32), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3851| 3.70k| JANET_CORE_REG("buffer/push-float64", cfun_buffer_push_float64), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3852| 3.70k| JANET_CORE_REG("buffer/push", cfun_buffer_push), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3853| 3.70k| JANET_CORE_REG("buffer/push-at", cfun_buffer_push_at), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3854| 3.70k| JANET_CORE_REG("buffer/popn", cfun_buffer_popn), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3855| 3.70k| JANET_CORE_REG("buffer/clear", cfun_buffer_clear), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3856| 3.70k| JANET_CORE_REG("buffer/slice", cfun_buffer_slice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3857| 3.70k| JANET_CORE_REG("buffer/bit-set", cfun_buffer_bitset), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3858| 3.70k| JANET_CORE_REG("buffer/bit-clear", cfun_buffer_bitclear), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3859| 3.70k| JANET_CORE_REG("buffer/bit", cfun_buffer_bitget), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3860| 3.70k| JANET_CORE_REG("buffer/bit-toggle", cfun_buffer_bittoggle), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3861| 3.70k| JANET_CORE_REG("buffer/blit", cfun_buffer_blit), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3862| 3.70k| JANET_CORE_REG("buffer/format", cfun_buffer_format), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3863| 3.70k| JANET_CORE_REG("buffer/format-at", cfun_buffer_format_at), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3864| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3865| 3.70k| }; 3866| | janet_core_cfuns_ext(env, NULL, buffer_cfuns); 3867| 3.70k|} janet_verify: 5644| 2.01M|int janet_verify(JanetFuncDef *def) { 5645| 2.01M| int vargs = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG); ------------------ | | 1097| 2.01M|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ 5646| 2.01M| int32_t i; 5647| 2.01M| int32_t maxslot = def->arity + vargs; 5648| 2.01M| int32_t sc = def->slotcount; 5649| | 5650| 2.01M| if (def->environments_length > 256) return 15; ------------------ | Branch (5650:9): [True: 1, False: 2.01M] ------------------ 5651| 2.01M| if (def->bytecode_length == 0) return 1; ------------------ | Branch (5651:9): [True: 22, False: 2.01M] ------------------ 5652| | 5653| 2.01M| if (maxslot > sc) return 2; ------------------ | Branch (5653:9): [True: 31, False: 2.01M] ------------------ 5654| | 5655| | /* Verify each instruction */ 5656| 56.9M| for (i = 0; i < def->bytecode_length; i++) { ------------------ | Branch (5656:17): [True: 54.8M, False: 2.01M] ------------------ 5657| 54.8M| uint32_t instr = def->bytecode[i]; 5658| | /* Check for invalid instructions */ 5659| 54.8M| if ((instr & 0x7F) >= JOP_INSTRUCTION_COUNT) { ------------------ | Branch (5659:13): [True: 51, False: 54.8M] ------------------ 5660| 51| return 3; 5661| 51| } 5662| 54.8M| enum JanetInstructionType type = janet_instructions[instr & 0x7F]; 5663| 54.8M| switch (type) { ------------------ | Branch (5663:17): [True: 54.8M, False: 0] ------------------ 5664| 359k| case JINT_0: ------------------ | Branch (5664:13): [True: 359k, False: 54.5M] ------------------ 5665| 359k| continue; 5666| 10.5M| case JINT_S: { ------------------ | Branch (5666:13): [True: 10.5M, False: 44.3M] ------------------ 5667| 10.5M| if ((int32_t)(instr >> 8) >= sc) return 4; ------------------ | Branch (5667:21): [True: 26, False: 10.5M] ------------------ 5668| 10.5M| continue; 5669| 10.5M| } 5670| 10.5M| case JINT_SI: ------------------ | Branch (5670:13): [True: 1.25M, False: 53.6M] ------------------ 5671| 1.25M| case JINT_SU: ------------------ | Branch (5671:13): [True: 0, False: 54.8M] ------------------ 5672| 1.25M| case JINT_ST: { ------------------ | Branch (5672:13): [True: 705, False: 54.8M] ------------------ 5673| 1.25M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5673:21): [True: 11, False: 1.25M] ------------------ 5674| 1.25M| continue; 5675| 1.25M| } 5676| 2.31M| case JINT_L: { ------------------ | Branch (5676:13): [True: 2.31M, False: 52.5M] ------------------ 5677| 2.31M| int32_t jumpdest = i + (((int32_t)instr) >> 8); 5678| 2.31M| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (5678:21): [True: 29, False: 2.31M] | Branch (5678:37): [True: 40, False: 2.31M] ------------------ 5679| 2.31M| continue; 5680| 2.31M| } 5681| 14.6M| case JINT_SS: { ------------------ | Branch (5681:13): [True: 14.6M, False: 40.2M] ------------------ 5682| 14.6M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5682:21): [True: 6, False: 14.6M] ------------------ 5683| 14.6M| (int32_t)(instr >> 16) >= sc) return 4; ------------------ | Branch (5683:25): [True: 11, False: 14.6M] ------------------ 5684| 14.6M| continue; 5685| 14.6M| } 5686| 14.6M| case JINT_SSI: ------------------ | Branch (5686:13): [True: 968k, False: 53.9M] ------------------ 5687| 1.54M| case JINT_SSU: { ------------------ | Branch (5687:13): [True: 576k, False: 54.3M] ------------------ 5688| 1.54M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5688:21): [True: 3, False: 1.54M] ------------------ 5689| 1.54M| (int32_t)((instr >> 16) & 0xFF) >= sc) return 4; ------------------ | Branch (5689:25): [True: 13, False: 1.54M] ------------------ 5690| 1.54M| continue; 5691| 1.54M| } 5692| 4.00M| case JINT_SL: { ------------------ | Branch (5692:13): [True: 4.00M, False: 50.8M] ------------------ 5693| 4.00M| int32_t jumpdest = i + (((int32_t)instr) >> 16); 5694| 4.00M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5694:21): [True: 3, False: 4.00M] ------------------ 5695| 4.00M| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (5695:21): [True: 32, False: 4.00M] | Branch (5695:37): [True: 33, False: 4.00M] ------------------ 5696| 4.00M| continue; 5697| 4.00M| } 5698| 7.37M| case JINT_SSS: { ------------------ | Branch (5698:13): [True: 7.37M, False: 47.5M] ------------------ 5699| 7.37M| if (((int32_t)(instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5699:21): [True: 8, False: 7.37M] ------------------ 5700| 7.37M| ((int32_t)(instr >> 16) & 0xFF) >= sc || ------------------ | Branch (5700:25): [True: 9, False: 7.37M] ------------------ 5701| 7.37M| ((int32_t)(instr >> 24) & 0xFF) >= sc) return 4; ------------------ | Branch (5701:25): [True: 12, False: 7.37M] ------------------ 5702| 7.37M| continue; 5703| 7.37M| } 5704| 7.37M| case JINT_SD: { ------------------ | Branch (5704:13): [True: 578k, False: 54.3M] ------------------ 5705| 578k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5705:21): [True: 5, False: 578k] ------------------ 5706| 578k| if ((int32_t)(instr >> 16) >= def->defs_length) return 6; ------------------ | Branch (5706:21): [True: 45, False: 578k] ------------------ 5707| 578k| continue; 5708| 578k| } 5709| 10.0M| case JINT_SC: { ------------------ | Branch (5709:13): [True: 10.0M, False: 44.8M] ------------------ 5710| 10.0M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5710:21): [True: 9, False: 10.0M] ------------------ 5711| 10.0M| if ((int32_t)(instr >> 16) >= def->constants_length) return 7; ------------------ | Branch (5711:21): [True: 43, False: 10.0M] ------------------ 5712| 10.0M| continue; 5713| 10.0M| } 5714| 10.0M| case JINT_SES: { ------------------ | Branch (5714:13): [True: 2.26M, False: 52.6M] ------------------ 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| 2.26M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5718:21): [True: 8, False: 2.26M] ------------------ 5719| 2.26M| if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8; ------------------ | Branch (5719:21): [True: 28, False: 2.26M] ------------------ 5720| 2.26M| continue; 5721| 2.26M| } 5722| 54.8M| } 5723| 54.8M| } 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| 2.01M| { 5730| 2.01M| uint32_t lastop = def->bytecode[def->bytecode_length - 1] & 0xFF; 5731| 2.01M| switch (lastop) { 5732| 119| default: ------------------ | Branch (5732:13): [True: 119, False: 2.01M] ------------------ 5733| 119| return 9; 5734| 1.16M| case JOP_RETURN: ------------------ | Branch (5734:13): [True: 1.16M, False: 846k] ------------------ 5735| 1.33M| case JOP_RETURN_NIL: ------------------ | Branch (5735:13): [True: 171k, False: 1.84M] ------------------ 5736| 1.34M| case JOP_JUMP: ------------------ | Branch (5736:13): [True: 8.55k, False: 2.00M] ------------------ 5737| 1.37M| case JOP_ERROR: ------------------ | Branch (5737:13): [True: 32.5k, False: 1.98M] ------------------ 5738| 2.01M| case JOP_TAILCALL: ------------------ | Branch (5738:13): [True: 633k, False: 1.38M] ------------------ 5739| 2.01M| break; 5740| 2.01M| } 5741| 2.01M| } 5742| | 5743| | /* Verify debug info - slotmapping, etc. */ 5744| 20.8M| for (int32_t i = def->symbolmap_length - 1; i >= 0; i--) { ------------------ | Branch (5744:49): [True: 18.8M, False: 2.01M] ------------------ 5745| 18.8M| JanetSymbolMap jsm = def->symbolmap[i]; 5746| 18.8M| if (jsm.birth_pc == UINT32_MAX) { ------------------ | Branch (5746:13): [True: 9.72M, False: 9.13M] ------------------ 5747| 9.72M| if (jsm.death_pc >= (uint32_t) def->environments_length) { ------------------ | Branch (5747:17): [True: 0, False: 9.72M] ------------------ 5748| 0| return 10; 5749| | /* We should also check jsm.slot_index */ 5750| 0| } 5751| 9.72M| } else { 5752| 9.13M| if (jsm.slot_index >= (uint32_t) def->slotcount) { ------------------ | Branch (5752:17): [True: 0, False: 9.13M] ------------------ 5753| 0| return 11; 5754| 0| } 5755| 9.13M| if (jsm.birth_pc != UINT32_MAX && jsm.birth_pc >= (uint32_t) def->bytecode_length) { ------------------ | Branch (5755:17): [True: 9.13M, False: 0] | Branch (5755:47): [True: 0, False: 9.13M] ------------------ 5756| 0| return 12; 5757| 0| } 5758| 9.13M| if (jsm.death_pc != UINT32_MAX && jsm.death_pc > (uint32_t) def->bytecode_length) { ------------------ | Branch (5758:17): [True: 9.13M, False: 0] | Branch (5758:47): [True: 0, False: 9.13M] ------------------ 5759| 0| return 13; 5760| 0| } 5761| 9.13M| } 5762| 18.8M| if (jsm.symbol == NULL) { ------------------ | Branch (5762:13): [True: 0, False: 18.8M] ------------------ 5763| 0| return 14; 5764| 0| } 5765| 18.8M| } 5766| | 5767| 2.01M| return 0; 5768| 2.01M|} janet_signalv: 5878| 3.44k|void janet_signalv(JanetSignal sig, Janet message) { 5879| 3.44k| if (janet_vm.return_reg != NULL) { ------------------ | Branch (5879:9): [True: 3.44k, False: 0] ------------------ 5880| | /* Should match logic in janet_call for coercing everything not ok to an error (no awaits, yields, etc.) */ 5881| 3.44k| if (janet_vm.coerce_error && sig != JANET_SIGNAL_OK) { ------------------ | Branch (5881:13): [True: 0, False: 3.44k] | 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| 3.44k| *janet_vm.return_reg = message; 5893| 3.44k| if (NULL != janet_vm.fiber) { ------------------ | Branch (5893:13): [True: 0, False: 3.44k] ------------------ 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| 3.44k| longjmp(*janet_vm.signal_buf, sig); 5900| 3.44k|#endif 5901| 3.44k| } 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| 3.44k|} janet_panicv: 5907| 3.44k|void janet_panicv(Janet message) { 5908| 3.44k| janet_signalv(JANET_SIGNAL_ERROR, message); 5909| 3.44k|} janet_panicf: 5911| 1.91k|void janet_panicf(const char *format, ...) { 5912| 1.91k| va_list args; 5913| 1.91k| const uint8_t *ret; 5914| 1.91k| JanetBuffer buffer; 5915| 1.91k| int32_t len = 0; 5916| 61.0k| while (format[len]) len++; ------------------ | Branch (5916:12): [True: 59.1k, False: 1.91k] ------------------ 5917| 1.91k| janet_buffer_init(&buffer, len); 5918| 1.91k| va_start(args, format); 5919| 1.91k| janet_formatbv(&buffer, format, args); 5920| | va_end(args); 5921| 1.91k| ret = janet_string(buffer.data, buffer.count); 5922| 1.91k| janet_buffer_deinit(&buffer); 5923| 1.91k| janet_panics(ret); 5924| 1.91k|} janet_panic: 5926| 1.53k|void janet_panic(const char *message) { 5927| 1.53k| janet_panicv(janet_cstringv(message)); ------------------ | | 1826| 1.53k|#define janet_cstringv(cstr) janet_wrap_string(janet_cstring(cstr)) | | ------------------ | | | | 848| 1.53k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 1.53k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.53k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.53k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5928| 1.53k|} janet_panics: 5930| 1.91k|void janet_panics(const uint8_t *message) { 5931| 1.91k| janet_panicv(janet_wrap_string(message)); ------------------ | | 848| 1.91k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 1.91k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.91k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.91k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5932| 1.91k|} janet_lib_compile: 8256| 3.70k|void janet_lib_compile(JanetTable *env) { 8257| 3.70k| JanetRegExt cfuns[] = { 8258| 3.70k| JANET_CORE_REG("compile", cfun_compile), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8259| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 8260| 3.70k| }; 8261| | janet_core_cfuns_ext(env, NULL, cfuns); 8262| 3.70k|} janet_core_env: 9667| 3.70k|JanetTable *janet_core_env(JanetTable *replacements) { 9668| | /* Memoize core env, ignoring replacements the second time around. */ 9669| 3.70k| if (NULL != janet_vm.core_env) { ------------------ | Branch (9669:9): [True: 0, False: 3.70k] ------------------ 9670| 0| return janet_vm.core_env; 9671| 0| } 9672| | 9673| 3.70k| JanetTable *dict = janet_core_lookup_table(replacements); 9674| | 9675| | /* Unmarshal bytecode */ 9676| 3.70k| Janet marsh_out = janet_unmarshal( 9677| 3.70k| janet_core_image, 9678| 3.70k| janet_core_image_size, 9679| 3.70k| 0, 9680| 3.70k| dict, 9681| 3.70k| NULL); 9682| | 9683| | /* Memoize */ 9684| 3.70k| janet_gcroot(marsh_out); 9685| 3.70k| JanetTable *env = janet_unwrap_table(marsh_out); ------------------ | | 861| 3.70k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9686| 3.70k| janet_vm.core_env = env; 9687| | 9688| | /* Invert image dict manually here. We can't do this in boot.janet as it 9689| | * breaks deterministic builds */ 9690| 3.70k| Janet lidv, midv; 9691| 3.70k| lidv = midv = janet_wrap_nil(); ------------------ | | 831| 3.70k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 3.70k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 3.70k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.70k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9692| 3.70k| janet_resolve(env, janet_csymbol("load-image-dict"), &lidv); 9693| 3.70k| janet_resolve(env, janet_csymbol("make-image-dict"), &midv); 9694| | 9695| | /* Check that we actually got tables - if we are using a smaller corelib, may not exist */ 9696| 3.70k| if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 806| 7.41k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 3.70k, False: 0] | | | Branch (806:6): [Folded, False: 3.70k] | | ------------------ | | 807| 7.41k| ? 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.41k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.70k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.70k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.70k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.70k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 806| 3.70k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 3.70k, False: 0] | | | Branch (806:6): [Folded, False: 3.70k] | | ------------------ | | 807| 3.70k| ? 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.70k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.70k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.70k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.70k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.70k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9697| 3.70k| JanetTable *lid = janet_unwrap_table(lidv); ------------------ | | 861| 3.70k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9698| 3.70k| JanetTable *mid = janet_unwrap_table(midv); ------------------ | | 861| 3.70k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9699| 7.59M| for (int32_t i = 0; i < lid->capacity; i++) { ------------------ | Branch (9699:29): [True: 7.59M, False: 3.70k] ------------------ 9700| 7.59M| const JanetKV *kv = lid->data + i; 9701| 7.59M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 7.59M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 7.59M] | | ------------------ | | 807| 7.59M| ? 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.59M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.59M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.59M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.59M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.59M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (9701:17): [True: 2.44M, False: 5.14M] ------------------ 9702| 2.44M| janet_table_put(mid, kv->value, kv->key); 9703| 2.44M| } 9704| 7.59M| } 9705| 3.70k| } 9706| | 9707| 3.70k| return env; 9708| 3.70k|} janet_core_lookup_table: 9712| 3.70k|JanetTable *janet_core_lookup_table(JanetTable *replacements) { 9713| 3.70k| JanetTable *dict = janet_table(512); 9714| 3.70k| janet_load_libs(dict); 9715| | 9716| | /* Add replacements */ 9717| 3.70k| if (replacements != NULL) { ------------------ | Branch (9717:9): [True: 0, False: 3.70k] ------------------ 9718| 0| for (int32_t i = 0; i < replacements->capacity; i++) { ------------------ | Branch (9718:29): [True: 0, False: 0] ------------------ 9719| 0| JanetKV kv = replacements->data[i]; 9720| 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 (9720:17): [True: 0, False: 0] ------------------ 9721| 0| janet_table_put(dict, kv.key, kv.value); 9722| | /* Add replacement functions to registry? */ 9723| 0| } 9724| 0| } 9725| 0| } 9726| | 9727| 3.70k| return dict; 9728| 3.70k|} janet_lib_debug: 10180| 3.70k|void janet_lib_debug(JanetTable *env) { 10181| 3.70k| JanetRegExt debug_cfuns[] = { 10182| 3.70k| JANET_CORE_REG("debug/break", cfun_debug_break), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10183| 3.70k| JANET_CORE_REG("debug/unbreak", cfun_debug_unbreak), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10184| 3.70k| JANET_CORE_REG("debug/fbreak", cfun_debug_fbreak), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10185| 3.70k| JANET_CORE_REG("debug/unfbreak", cfun_debug_unfbreak), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10186| 3.70k| JANET_CORE_REG("debug/arg-stack", cfun_debug_argstack), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10187| 3.70k| JANET_CORE_REG("debug/stack", cfun_debug_stack), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10188| 3.70k| JANET_CORE_REG("debug/stacktrace", cfun_debug_stacktrace), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10189| 3.70k| JANET_CORE_REG("debug/lineage", cfun_debug_lineage), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10190| 3.70k| JANET_CORE_REG("debug/step", cfun_debug_step), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10191| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 10192| 3.70k| }; 10193| | janet_core_cfuns_ext(env, NULL, debug_cfuns); 10194| 3.70k|} janet_ev_init_common: 11153| 3.70k|void janet_ev_init_common(void) { 11154| 3.70k| janet_q_init(&janet_vm.spawn); 11155| 3.70k| janet_vm.tq = NULL; 11156| 3.70k| janet_vm.tq_count = 0; 11157| 3.70k| janet_vm.tq_capacity = 0; 11158| 3.70k| janet_table_init_raw(&janet_vm.threaded_abstracts, 0); 11159| 3.70k| janet_table_init_raw(&janet_vm.active_tasks, 0); 11160| 3.70k| janet_table_init_raw(&janet_vm.signal_handlers, 0); 11161| 3.70k| janet_rng_seed(&janet_vm.ev_rng, 0); 11162| 3.70k|#ifndef JANET_WINDOWS 11163| 3.70k| pthread_attr_init(&janet_vm.new_thread_attr); 11164| | pthread_attr_setdetachstate(&janet_vm.new_thread_attr, PTHREAD_CREATE_DETACHED); 11165| 3.70k|#endif 11166| 3.70k|} janet_ev_deinit_common: 11199| 3.70k|void janet_ev_deinit_common(void) { 11200| 3.70k| JanetTimeout to; 11201| 3.70k| while (peek_timeout(&to)) { ------------------ | Branch (11201:12): [True: 0, False: 3.70k] ------------------ 11202| 0| handle_timeout_worker(to, 1); 11203| 0| pop_timeout(0); 11204| 0| } 11205| 3.70k| janet_q_deinit(&janet_vm.spawn); 11206| 3.70k| janet_free(janet_vm.tq); ------------------ | | 2415| 3.70k|#define janet_free(X) free((X)) ------------------ 11207| 3.70k| janet_table_deinit(&janet_vm.threaded_abstracts); 11208| 3.70k| janet_table_deinit(&janet_vm.active_tasks); 11209| 3.70k| janet_table_deinit(&janet_vm.signal_handlers); 11210| 3.70k|#ifndef JANET_WINDOWS 11211| 3.70k| pthread_attr_destroy(&janet_vm.new_thread_attr); 11212| 3.70k|#endif 11213| 3.70k|} janet_ev_init: 12490| 3.70k|void janet_ev_init(void) { 12491| 3.70k| janet_ev_init_common(); 12492| 3.70k| janet_ev_setup_selfpipe(); 12493| 3.70k| janet_vm.epoll = epoll_create1(EPOLL_CLOEXEC); 12494| 3.70k| janet_vm.timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); 12495| 3.70k| janet_vm.timer_enabled = 0; 12496| 3.70k| if (janet_vm.epoll == -1 || janet_vm.timerfd == -1) goto error; ------------------ | Branch (12496:9): [True: 0, False: 3.70k] | Branch (12496:33): [True: 0, False: 3.70k] ------------------ 12497| 3.70k| struct epoll_event ev; 12498| 3.70k| ev.events = EPOLLIN | EPOLLET; 12499| 3.70k| ev.data.ptr = &janet_vm.timerfd; 12500| 3.70k| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.timerfd, &ev)) goto error; ------------------ | Branch (12500:9): [True: 0, False: 3.70k] ------------------ 12501| 3.70k| ev.events = EPOLLIN | EPOLLET; 12502| 3.70k| ev.data.ptr = janet_vm.selfpipe; 12503| 3.70k| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.selfpipe[0], &ev)) goto error; ------------------ | Branch (12503:9): [True: 0, False: 3.70k] ------------------ 12504| 3.70k| return; 12505| 3.70k|error: 12506| | 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] | | ------------------ ------------------ 12507| 0|} janet_ev_deinit: 12509| 3.70k|void janet_ev_deinit(void) { 12510| 3.70k| janet_ev_deinit_common(); 12511| 3.70k| close(janet_vm.epoll); 12512| 3.70k| close(janet_vm.timerfd); 12513| 3.70k| janet_ev_cleanup_selfpipe(); 12514| 3.70k| janet_vm.epoll = 0; 12515| 3.70k|} janet_make_pipe: 13612| 3.70k|int janet_make_pipe(JanetHandle handles[2], int mode) { 13613| |#ifdef JANET_WINDOWS 13614| | /* 13615| | * On windows, the built in CreatePipe function doesn't support overlapped IO 13616| | * so we lift from the windows source code and modify for our own version. 13617| | */ 13618| | JanetHandle shandle, chandle; 13619| | CHAR PipeNameBuffer[MAX_PATH]; 13620| | SECURITY_ATTRIBUTES saAttr; 13621| | memset(&saAttr, 0, sizeof(saAttr)); 13622| | saAttr.nLength = sizeof(saAttr); 13623| | saAttr.bInheritHandle = TRUE; 13624| | if (mode == 3) { 13625| | /* No overlapped IO involved, just call CreatePipe */ 13626| | if (!CreatePipe(handles, handles + 1, &saAttr, 0)) return -1; 13627| | return 0; 13628| | } 13629| | snprintf(PipeNameBuffer, 13630| | sizeof(PipeNameBuffer), 13631| | "\\\\.\\Pipe\\JanetPipeFile.%08x.%08x", 13632| | (unsigned int) GetCurrentProcessId(), 13633| | (unsigned int) InterlockedIncrement(&PipeSerialNumber)); 13634| | 13635| | /* server handle goes to subprocess */ 13636| | shandle = CreateNamedPipeA( 13637| | PipeNameBuffer, 13638| | (mode == 2 ? PIPE_ACCESS_INBOUND : PIPE_ACCESS_OUTBOUND) | FILE_FLAG_OVERLAPPED, 13639| | PIPE_TYPE_BYTE | PIPE_WAIT, 13640| | 255, /* Max number of pipes for duplication. */ 13641| | 4096, /* Out buffer size */ 13642| | 4096, /* In buffer size */ 13643| | 120 * 1000, /* Timeout in ms */ 13644| | &saAttr); 13645| | if (shandle == INVALID_HANDLE_VALUE) { 13646| | return -1; 13647| | } 13648| | 13649| | /* we keep client handle */ 13650| | chandle = CreateFileA( 13651| | PipeNameBuffer, 13652| | (mode == 2 ? GENERIC_WRITE : GENERIC_READ), 13653| | 0, 13654| | &saAttr, 13655| | OPEN_EXISTING, 13656| | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 13657| | NULL); 13658| | 13659| | if (chandle == INVALID_HANDLE_VALUE) { 13660| | CloseHandle(shandle); 13661| | return -1; 13662| | } 13663| | if (mode == 2) { 13664| | handles[0] = shandle; 13665| | handles[1] = chandle; 13666| | } else { 13667| | handles[0] = chandle; 13668| | handles[1] = shandle; 13669| | } 13670| | return 0; 13671| |#else 13672| 3.70k| if (pipe(handles)) return -1; ------------------ | Branch (13672:9): [True: 0, False: 3.70k] ------------------ 13673| 3.70k| if (mode != 2 && fcntl(handles[0], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (13673:9): [True: 3.70k, False: 0] | Branch (13673:22): [True: 0, False: 3.70k] ------------------ 13674| 3.70k| if (mode != 1 && fcntl(handles[1], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (13674:9): [True: 0, False: 3.70k] | Branch (13674:22): [True: 0, False: 0] ------------------ 13675| 3.70k| if (mode != 2 && mode != 3 && fcntl(handles[0], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (13675:9): [True: 3.70k, False: 0] | Branch (13675:22): [True: 3.70k, False: 0] | Branch (13675:35): [True: 0, False: 3.70k] ------------------ 13676| 3.70k| if (mode != 1 && mode != 3 && fcntl(handles[1], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (13676:9): [True: 0, False: 3.70k] | Branch (13676:22): [True: 0, False: 0] | Branch (13676:35): [True: 0, False: 0] ------------------ 13677| 3.70k| return 0; 13678| 0|error: 13679| 0| close(handles[0]); 13680| 0| close(handles[1]); 13681| 0| return -1; 13682| 3.70k|#endif 13683| 3.70k|} janet_lib_ev: 14268| 3.70k|void janet_lib_ev(JanetTable *env) { 14269| 3.70k| JanetRegExt ev_cfuns_ext[] = { 14270| 3.70k| JANET_CORE_REG("ev/give", cfun_channel_push), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14271| 3.70k| JANET_CORE_REG("ev/take", cfun_channel_pop), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14272| 3.70k| JANET_CORE_REG("ev/full", cfun_channel_full), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14273| 3.70k| JANET_CORE_REG("ev/capacity", cfun_channel_capacity), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14274| 3.70k| JANET_CORE_REG("ev/count", cfun_channel_count), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14275| 3.70k| JANET_CORE_REG("ev/select", cfun_channel_choice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14276| 3.70k| JANET_CORE_REG("ev/rselect", cfun_channel_rchoice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14277| 3.70k| JANET_CORE_REG("ev/chan", cfun_channel_new), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14278| 3.70k| JANET_CORE_REG("ev/thread-chan", cfun_channel_new_threaded), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14279| 3.70k| JANET_CORE_REG("ev/chan-close", cfun_channel_close), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14280| 3.70k| JANET_CORE_REG("ev/go", cfun_ev_go), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14281| 3.70k| JANET_CORE_REG("ev/thread", cfun_ev_thread), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14282| 3.70k| JANET_CORE_REG("ev/give-supervisor", cfun_ev_give_supervisor), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14283| 3.70k| JANET_CORE_REG("ev/sleep", cfun_ev_sleep), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14284| 3.70k| JANET_CORE_REG("ev/deadline", cfun_ev_deadline), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14285| 3.70k| JANET_CORE_REG("ev/cancel", cfun_ev_cancel), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14286| 3.70k| JANET_CORE_REG("ev/close", janet_cfun_stream_close), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14287| 3.70k| JANET_CORE_REG("ev/read", janet_cfun_stream_read), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14288| 3.70k| JANET_CORE_REG("ev/chunk", janet_cfun_stream_chunk), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14289| 3.70k| JANET_CORE_REG("ev/write", janet_cfun_stream_write), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14290| 3.70k| JANET_CORE_REG("ev/lock", janet_cfun_mutex), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14291| 3.70k| JANET_CORE_REG("ev/acquire-lock", janet_cfun_mutex_acquire), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14292| 3.70k| JANET_CORE_REG("ev/release-lock", janet_cfun_mutex_release), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14293| 3.70k| JANET_CORE_REG("ev/rwlock", janet_cfun_rwlock), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14294| 3.70k| JANET_CORE_REG("ev/acquire-rlock", janet_cfun_rwlock_read_lock), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14295| 3.70k| JANET_CORE_REG("ev/acquire-wlock", janet_cfun_rwlock_write_lock), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14296| 3.70k| JANET_CORE_REG("ev/release-rlock", janet_cfun_rwlock_read_release), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14297| 3.70k| JANET_CORE_REG("ev/release-wlock", janet_cfun_rwlock_write_release), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14298| 3.70k| JANET_CORE_REG("ev/to-file", janet_cfun_to_file), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14299| 3.70k| JANET_CORE_REG("ev/all-tasks", janet_cfun_ev_all_tasks), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14300| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 14301| 3.70k| }; 14302| | 14303| | janet_core_cfuns_ext(env, NULL, ev_cfuns_ext); 14304| 3.70k| janet_register_abstract_type(&janet_stream_type); 14305| 3.70k| janet_register_abstract_type(&janet_channel_type); 14306| 3.70k| janet_register_abstract_type(&janet_mutex_type); 14307| 3.70k| janet_register_abstract_type(&janet_rwlock_type); 14308| 3.70k|} janet_lib_ffi: 16241| 3.70k|void janet_lib_ffi(JanetTable *env) { 16242| 3.70k| JanetRegExt ffi_cfuns[] = { 16243| 3.70k| JANET_CORE_REG("ffi/native", janet_core_raw_native), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16244| 3.70k| JANET_CORE_REG("ffi/lookup", janet_core_native_lookup), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16245| 3.70k| JANET_CORE_REG("ffi/close", janet_core_native_close), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16246| 3.70k| JANET_CORE_REG("ffi/signature", cfun_ffi_signature), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16247| 3.70k| JANET_CORE_REG("ffi/call", cfun_ffi_call), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16248| 3.70k| JANET_CORE_REG("ffi/struct", cfun_ffi_struct), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16249| 3.70k| JANET_CORE_REG("ffi/write", cfun_ffi_buffer_write), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16250| 3.70k| JANET_CORE_REG("ffi/read", cfun_ffi_buffer_read), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16251| 3.70k| JANET_CORE_REG("ffi/size", cfun_ffi_size), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16252| 3.70k| JANET_CORE_REG("ffi/align", cfun_ffi_align), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16253| 3.70k| JANET_CORE_REG("ffi/trampoline", cfun_ffi_get_callback_trampoline), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16254| 3.70k| JANET_CORE_REG("ffi/jitfn", cfun_ffi_jitfn), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16255| 3.70k| JANET_CORE_REG("ffi/malloc", cfun_ffi_malloc), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16256| 3.70k| JANET_CORE_REG("ffi/free", cfun_ffi_free), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16257| 3.70k| JANET_CORE_REG("ffi/pointer-buffer", cfun_ffi_pointer_buffer), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16258| 3.70k| JANET_CORE_REG("ffi/pointer-cfunction", cfun_ffi_pointer_cfunction), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16259| 3.70k| JANET_CORE_REG("ffi/calling-conventions", cfun_ffi_supported_calling_conventions), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16260| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 16261| 3.70k| }; 16262| | janet_core_cfuns_ext(env, NULL, ffi_cfuns); 16263| 3.70k|} janet_fiber_status: 16711| 7.19k|JanetFiberStatus janet_fiber_status(JanetFiber *f) { 16712| 7.19k| return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 830| 7.19k|#define JANET_FIBER_STATUS_MASK 0x3F0000 ------------------ return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 832| 7.19k|#define JANET_FIBER_STATUS_OFFSET 16 ------------------ 16713| 7.19k|} janet_lib_fiber: 16943| 3.70k|void janet_lib_fiber(JanetTable *env) { 16944| 3.70k| JanetRegExt fiber_cfuns[] = { 16945| 3.70k| JANET_CORE_REG("fiber/new", cfun_fiber_new), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16946| 3.70k| JANET_CORE_REG("fiber/status", cfun_fiber_status), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16947| 3.70k| JANET_CORE_REG("fiber/root", cfun_fiber_root), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16948| 3.70k| JANET_CORE_REG("fiber/current", cfun_fiber_current), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16949| 3.70k| JANET_CORE_REG("fiber/maxstack", cfun_fiber_maxstack), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16950| 3.70k| JANET_CORE_REG("fiber/setmaxstack", cfun_fiber_setmaxstack), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16951| 3.70k| JANET_CORE_REG("fiber/getenv", cfun_fiber_getenv), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16952| 3.70k| JANET_CORE_REG("fiber/setenv", cfun_fiber_setenv), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16953| 3.70k| JANET_CORE_REG("fiber/can-resume?", cfun_fiber_can_resume), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16954| 3.70k| JANET_CORE_REG("fiber/last-value", cfun_fiber_last_value), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16955| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 16956| 3.70k| }; 16957| | janet_core_cfuns_ext(env, NULL, fiber_cfuns); 16958| 3.70k|} janet_lib_filewatch: 17953| 3.70k|void janet_lib_filewatch(JanetTable *env) { 17954| 3.70k| JanetRegExt cfuns[] = { 17955| 3.70k| JANET_CORE_REG("filewatch/new", cfun_filewatch_make), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17956| 3.70k| JANET_CORE_REG("filewatch/add", cfun_filewatch_add), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17957| 3.70k| JANET_CORE_REG("filewatch/remove", cfun_filewatch_remove), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17958| 3.70k| JANET_CORE_REG("filewatch/listen", cfun_filewatch_listen), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17959| 3.70k| JANET_CORE_REG("filewatch/unlisten", cfun_filewatch_unlisten), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17960| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 17961| 3.70k| }; 17962| | janet_core_cfuns_ext(env, NULL, cfuns); 17963| 3.70k|} janet_gcpressure: 18023| 12.0k|void janet_gcpressure(size_t s) { 18024| 12.0k| janet_vm.next_collection += s; 18025| 12.0k|} janet_gcalloc: 18497| 22.8M|void *janet_gcalloc(enum JanetMemoryType type, size_t size) { 18498| 22.8M| JanetGCObject *mem; 18499| | 18500| | /* Make sure everything is inited */ 18501| 22.8M| janet_assert(NULL != janet_vm.cache, "please initialize janet before use"); ------------------ | | 389| 22.8M|#define janet_assert(c, m) do { \ | | 390| 22.8M| 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: 22.8M] | | ------------------ | | 391| 22.8M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 22.8M] | | ------------------ ------------------ 18502| 22.8M| mem = janet_malloc(size); ------------------ | | 2406| 22.8M|#define janet_malloc(X) malloc((X)) ------------------ 18503| | 18504| | /* Check for bad malloc */ 18505| 22.8M| if (NULL == mem) { ------------------ | Branch (18505:9): [True: 0, False: 22.8M] ------------------ 18506| 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] | | ------------------ ------------------ 18507| 0| } 18508| | 18509| | /* Configure block */ 18510| 22.8M| mem->flags = type; 18511| | 18512| | /* Prepend block to heap list */ 18513| 22.8M| janet_vm.next_collection += size; 18514| 22.8M| if (type < JANET_MEMORY_TABLE_WEAKK) { ------------------ | Branch (18514:9): [True: 22.7M, False: 76.3k] ------------------ 18515| | /* normal heap */ 18516| 22.7M| mem->data.next = janet_vm.blocks; 18517| 22.7M| janet_vm.blocks = mem; 18518| 22.7M| } else { 18519| | /* weak heap */ 18520| 76.3k| mem->data.next = janet_vm.weak_blocks; 18521| 76.3k| janet_vm.weak_blocks = mem; 18522| 76.3k| } 18523| 22.8M| janet_vm.block_count++; 18524| | 18525| 22.8M| return (void *)mem; 18526| 22.8M|} janet_gcroot: 18587| 7.41k|void janet_gcroot(Janet root) { 18588| 7.41k| size_t newcount = janet_vm.root_count + 1; 18589| 7.41k| if (newcount > janet_vm.root_capacity) { ------------------ | Branch (18589:9): [True: 3.70k, False: 3.70k] ------------------ 18590| 3.70k| size_t newcap = 2 * newcount; 18591| 3.70k| janet_vm.roots = janet_realloc(janet_vm.roots, sizeof(Janet) * newcap); ------------------ | | 2409| 3.70k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18592| 3.70k| if (NULL == janet_vm.roots) { ------------------ | Branch (18592:13): [True: 0, False: 3.70k] ------------------ 18593| 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] | | ------------------ ------------------ 18594| 0| } 18595| 3.70k| janet_vm.root_capacity = newcap; 18596| 3.70k| } 18597| 7.41k| janet_vm.roots[janet_vm.root_count] = root; 18598| 7.41k| janet_vm.root_count = newcount; 18599| 7.41k|} janet_clear_memory: 18645| 3.70k|void janet_clear_memory(void) { 18646| 3.70k|#ifdef JANET_EV 18647| 3.70k| JanetKV *items = janet_vm.threaded_abstracts.data; 18648| 7.41k| for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) { ------------------ | Branch (18648:25): [True: 3.70k, False: 3.70k] ------------------ 18649| 3.70k| if (janet_checktype(items[i].key, JANET_ABSTRACT)) { ------------------ | | 806| 3.70k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 3.70k] | | | Branch (806:6): [Folded, False: 3.70k] | | ------------------ | | 807| 3.70k| ? 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.70k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.70k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.70k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.70k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.70k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18650| 0| void *abst = janet_unwrap_abstract(items[i].key); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 18651| 0| JanetAbstractHead *head = janet_abstract_head(abst); ------------------ | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) ------------------ 18652| 0| if (head->type->gcperthread) { ------------------ | Branch (18652:17): [True: 0, False: 0] ------------------ 18653| 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] | | ------------------ ------------------ 18654| 0| } 18655| 0| janet_abstract_decref_maybe_free(abst); 18656| 0| } 18657| 3.70k| } 18658| 3.70k|#endif 18659| 3.70k| JanetGCObject *current = janet_vm.blocks; 18660| 22.7M| while (NULL != current) { ------------------ | Branch (18660:12): [True: 22.7M, False: 3.70k] ------------------ 18661| 22.7M| janet_deinit_block(current); 18662| 22.7M| JanetGCObject *next = current->data.next; 18663| 22.7M| janet_free(current); ------------------ | | 2415| 22.7M|#define janet_free(X) free((X)) ------------------ 18664| 22.7M| current = next; 18665| 22.7M| } 18666| 3.70k| janet_vm.blocks = NULL; 18667| 3.70k| janet_free_all_scratch(); 18668| 3.70k| janet_free(janet_vm.scratch_mem); ------------------ | | 2415| 3.70k|#define janet_free(X) free((X)) ------------------ 18669| 3.70k|} janet_smalloc: 18683| 16.8k|void *janet_smalloc(size_t size) { 18684| 16.8k| JanetScratch *s = janet_malloc(sizeof(JanetScratch) + size); ------------------ | | 2406| 16.8k|#define janet_malloc(X) malloc((X)) ------------------ 18685| 16.8k| if (NULL == s) { ------------------ | Branch (18685:9): [True: 0, False: 16.8k] ------------------ 18686| 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] | | ------------------ ------------------ 18687| 0| } 18688| 16.8k| s->finalize = NULL; 18689| 16.8k| if (janet_vm.scratch_len == janet_vm.scratch_cap) { ------------------ | Branch (18689:9): [True: 7.41k, False: 9.44k] ------------------ 18690| 7.41k| size_t newcap = 2 * janet_vm.scratch_cap + 2; 18691| 7.41k| JanetScratch **newmem = (JanetScratch **) janet_realloc(janet_vm.scratch_mem, newcap * sizeof(JanetScratch)); ------------------ | | 2409| 7.41k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18692| 7.41k| if (NULL == newmem) { ------------------ | Branch (18692:13): [True: 0, False: 7.41k] ------------------ 18693| 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] | | ------------------ ------------------ 18694| 0| } 18695| 7.41k| janet_vm.scratch_cap = newcap; 18696| 7.41k| janet_vm.scratch_mem = newmem; 18697| 7.41k| } 18698| 16.8k| janet_vm.scratch_mem[janet_vm.scratch_len++] = s; 18699| 16.8k| return (char *)(s->mem); 18700| 16.8k|} janet_srealloc: 18712| 131k|void *janet_srealloc(void *mem, size_t size) { 18713| 131k| if (NULL == mem) return janet_smalloc(size); ------------------ | Branch (18713:9): [True: 16.8k, False: 114k] ------------------ 18714| 114k| JanetScratch *s = janet_mem2scratch(mem); 18715| 114k| if (janet_vm.scratch_len) { ------------------ | Branch (18715:9): [True: 114k, False: 0] ------------------ 18716| 188k| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 18717| 188k| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (18717:17): [True: 114k, False: 74.1k] ------------------ 18718| 114k| JanetScratch *news = janet_realloc(s, size + sizeof(JanetScratch)); ------------------ | | 2409| 114k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18719| 114k| if (NULL == news) { ------------------ | Branch (18719:21): [True: 0, False: 114k] ------------------ 18720| 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] | | ------------------ ------------------ 18721| 0| } 18722| 114k| janet_vm.scratch_mem[i] = news; 18723| 114k| return (char *)(news->mem); 18724| 114k| } 18725| 74.1k| if (i == 0) break; ------------------ | Branch (18725:17): [True: 0, False: 74.1k] ------------------ 18726| 74.1k| } 18727| 114k| } 18728| 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] | | ------------------ ------------------ 18729| 0|} janet_sfree: 18736| 11.4k|void janet_sfree(void *mem) { 18737| 11.4k| if (NULL == mem) return; ------------------ | Branch (18737:9): [True: 0, False: 11.4k] ------------------ 18738| 11.4k| JanetScratch *s = janet_mem2scratch(mem); 18739| 11.4k| if (janet_vm.scratch_len) { ------------------ | Branch (18739:9): [True: 11.4k, False: 0] ------------------ 18740| 15.1k| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 18741| 15.1k| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (18741:17): [True: 11.4k, False: 3.71k] ------------------ 18742| 11.4k| janet_vm.scratch_mem[i] = janet_vm.scratch_mem[--janet_vm.scratch_len]; 18743| 11.4k| free_one_scratch(s); 18744| 11.4k| return; 18745| 11.4k| } 18746| 3.71k| if (i == 0) break; ------------------ | Branch (18746:17): [True: 0, False: 3.71k] ------------------ 18747| 3.71k| } 18748| 11.4k| } 18749| 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] | | ------------------ ------------------ 18750| 0|} janet_lib_inttypes: 19427| 3.70k|void janet_lib_inttypes(JanetTable *env) { 19428| 3.70k| JanetRegExt it_cfuns[] = { 19429| 3.70k| JANET_CORE_REG("int/s64", cfun_it_s64_new), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19430| 3.70k| JANET_CORE_REG("int/u64", cfun_it_u64_new), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19431| 3.70k| JANET_CORE_REG("int/to-number", cfun_to_number), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19432| 3.70k| JANET_CORE_REG("int/to-bytes", cfun_to_bytes), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19433| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 19434| 3.70k| }; 19435| | janet_core_cfuns_ext(env, NULL, it_cfuns); 19436| 3.70k| janet_register_abstract_type(&janet_s64_type); 19437| 3.70k| janet_register_abstract_type(&janet_u64_type); 19438| 3.70k|} janet_file_close: 19754| 11.1k|int janet_file_close(JanetFile *file) { 19755| 11.1k| int ret = 0; 19756| 11.1k| if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2278| 11.1k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2279| 11.1k|#define JANET_FILE_CLOSED 32 ------------------ | Branch (19756:9): [True: 0, False: 11.1k] ------------------ 19757| 0| ret = fclose(file->file); 19758| 0| file->flags |= JANET_FILE_CLOSED; ------------------ | | 2279| 0|#define JANET_FILE_CLOSED 32 ------------------ 19759| 0| file->file = NULL; /* NULL dereference is easier to debug then other problems */ 19760| 0| return ret; 19761| 0| } 19762| 11.1k| return 0; 19763| 11.1k|} janet_makefile: 20262| 11.1k|Janet janet_makefile(FILE *f, int32_t flags) { 20263| 11.1k| return janet_wrap_abstract(makef(f, flags, BUFSIZ)); ------------------ | | 851| 11.1k|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 11.1k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 11.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 11.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20264| 11.1k|} janet_lib_io: 20277| 3.70k|void janet_lib_io(JanetTable *env) { 20278| 3.70k| JanetRegExt io_cfuns[] = { 20279| 3.70k| JANET_CORE_REG("print", cfun_io_print), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20280| 3.70k| JANET_CORE_REG("prin", cfun_io_prin), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20281| 3.70k| JANET_CORE_REG("printf", cfun_io_printf), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20282| 3.70k| JANET_CORE_REG("prinf", cfun_io_prinf), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20283| 3.70k| JANET_CORE_REG("eprin", cfun_io_eprin), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20284| 3.70k| JANET_CORE_REG("eprint", cfun_io_eprint), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20285| 3.70k| JANET_CORE_REG("eprintf", cfun_io_eprintf), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20286| 3.70k| JANET_CORE_REG("eprinf", cfun_io_eprinf), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20287| 3.70k| JANET_CORE_REG("xprint", cfun_io_xprint), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20288| 3.70k| JANET_CORE_REG("xprin", cfun_io_xprin), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20289| 3.70k| JANET_CORE_REG("xprintf", cfun_io_xprintf), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20290| 3.70k| JANET_CORE_REG("xprinf", cfun_io_xprinf), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20291| 3.70k| JANET_CORE_REG("flush", cfun_io_flush), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20292| 3.70k| JANET_CORE_REG("eflush", cfun_io_eflush), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20293| 3.70k| JANET_CORE_REG("file/temp", cfun_io_temp), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20294| 3.70k| JANET_CORE_REG("file/open", cfun_io_fopen), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20295| 3.70k| JANET_CORE_REG("file/close", cfun_io_fclose), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20296| 3.70k| JANET_CORE_REG("file/read", cfun_io_fread), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20297| 3.70k| JANET_CORE_REG("file/write", cfun_io_fwrite), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20298| 3.70k| JANET_CORE_REG("file/flush", cfun_io_fflush), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20299| 3.70k| JANET_CORE_REG("file/seek", cfun_io_fseek), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20300| 3.70k| JANET_CORE_REG("file/tell", cfun_io_ftell), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20301| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 20302| 3.70k| }; 20303| 3.70k| janet_core_cfuns_ext(env, NULL, io_cfuns); 20304| 3.70k| janet_register_abstract_type(&janet_file_type); 20305| 3.70k| int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2278| 3.70k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2281| 3.70k|#define JANET_FILE_SERIALIZABLE 128 ------------------ 20306| | /* stdout */ 20307| 3.70k| JANET_CORE_DEF(env, "stdout", ------------------ | | 520| 3.70k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20308| 3.70k| janet_makefile(stdout, JANET_FILE_APPEND | default_flags), 20309| 3.70k| "The standard output file."); 20310| | /* stderr */ 20311| 3.70k| JANET_CORE_DEF(env, "stderr", ------------------ | | 520| 3.70k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20312| 3.70k| janet_makefile(stderr, JANET_FILE_APPEND | default_flags), 20313| 3.70k| "The standard error file."); 20314| | /* stdin */ 20315| 3.70k| JANET_CORE_DEF(env, "stdin", ------------------ | | 520| 3.70k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20316| 3.70k| janet_makefile(stdin, JANET_FILE_READ | default_flags), 20317| 3.70k| "The standard input file."); 20318| | 20319| 3.70k|} janet_env_lookup_into: 20428| 3.70k|void janet_env_lookup_into(JanetTable *renv, JanetTable *env, const char *prefix, int recurse) { 20429| 7.41k| while (env) { ------------------ | Branch (20429:12): [True: 3.70k, False: 3.70k] ------------------ 20430| 7.59M| for (int32_t i = 0; i < env->capacity; i++) { ------------------ | Branch (20430:29): [True: 7.59M, False: 3.70k] ------------------ 20431| 7.59M| if (janet_checktype(env->data[i].key, JANET_SYMBOL)) { ------------------ | | 806| 7.59M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.60M, False: 4.98M] | | | Branch (806:6): [Folded, False: 7.59M] | | ------------------ | | 807| 7.59M| ? 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.59M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.59M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.59M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.59M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.59M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20432| 2.60M| if (prefix) { ------------------ | Branch (20432:21): [True: 0, False: 2.60M] ------------------ 20433| 0| int32_t prelen = (int32_t) strlen(prefix); 20434| 0| const uint8_t *oldsym = janet_unwrap_symbol(env->data[i].key); ------------------ | | 864| 0|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 20435| 0| int32_t oldlen = janet_string_length(oldsym); ------------------ | | 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))) | | ------------------ ------------------ 20436| 0| uint8_t *symbuf = janet_smalloc(prelen + oldlen); 20437| 0| safe_memcpy(symbuf, prefix, prelen); 20438| 0| safe_memcpy(symbuf + prelen, oldsym, oldlen); 20439| 0| Janet s = janet_symbolv(symbuf, prelen + oldlen); ------------------ | | 1836| 0|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 0|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 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) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20440| 0| janet_sfree(symbuf); 20441| 0| janet_table_put(renv, s, entry_getval(env->data[i].value)); 20442| 2.60M| } else { 20443| 2.60M| janet_table_put(renv, 20444| 2.60M| env->data[i].key, 20445| 2.60M| entry_getval(env->data[i].value)); 20446| 2.60M| } 20447| 2.60M| } 20448| 7.59M| } 20449| 3.70k| env = recurse ? env->proto : NULL; ------------------ | Branch (20449:15): [True: 3.70k, False: 0] ------------------ 20450| 3.70k| } 20451| 3.70k|} janet_env_lookup: 20454| 3.70k|JanetTable *janet_env_lookup(JanetTable *env) { 20455| 3.70k| JanetTable *renv = janet_table(env->count); 20456| | janet_env_lookup_into(renv, env, NULL, 1); 20457| 3.70k| return renv; 20458| 3.70k|} janet_unmarshal: 21978| 7.41k| const uint8_t **next) { 21979| 7.41k| UnmarshalState st; 21980| 7.41k| st.start = bytes; 21981| 7.41k| st.end = bytes + len; 21982| 7.41k| st.lookup_defs = NULL; 21983| 7.41k| st.lookup_envs = NULL; 21984| 7.41k| st.lookup = NULL; 21985| 7.41k| st.reg = reg; 21986| 7.41k| Janet out; 21987| 7.41k| const uint8_t *nextbytes = unmarshal_one(&st, bytes, &out, flags); 21988| 7.41k| if (next) *next = nextbytes; ------------------ | Branch (21988:9): [True: 266, False: 7.14k] ------------------ 21989| 7.41k| janet_v_free(st.lookup_defs); ------------------ | | 756| 7.41k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 3.71k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 3.71k, False: 3.69k] | | ------------------ ------------------ 21990| 7.41k| janet_v_free(st.lookup_envs); ------------------ | | 756| 7.41k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 3.71k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 3.71k, False: 3.70k] | | ------------------ ------------------ 21991| | janet_v_free(st.lookup); ------------------ | | 756| 7.41k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 3.97k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 3.97k, False: 3.44k] | | ------------------ ------------------ 21992| 7.41k| return out; 21993| 7.41k|} janet_lib_marsh: 22054| 3.70k|void janet_lib_marsh(JanetTable *env) { 22055| 3.70k| JanetRegExt marsh_cfuns[] = { 22056| 3.70k| JANET_CORE_REG("marshal", cfun_marshal), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22057| 3.70k| JANET_CORE_REG("unmarshal", cfun_unmarshal), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22058| 3.70k| JANET_CORE_REG("env-lookup", cfun_env_lookup), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22059| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 22060| 3.70k| }; 22061| | janet_core_cfuns_ext(env, NULL, marsh_cfuns); 22062| 3.70k|} janet_default_rng: 22137| 3.70k|JanetRNG *janet_default_rng(void) { 22138| 3.70k| return &janet_vm.rng; 22139| 3.70k|} janet_rng_seed: 22141| 7.41k|void janet_rng_seed(JanetRNG *rng, uint32_t seed) { 22142| 7.41k| rng->a = seed; 22143| 7.41k| rng->b = 0x97654321u; 22144| 7.41k| rng->c = 123871873u; 22145| 7.41k| rng->d = 0xf23f56c8u; 22146| 7.41k| rng->counter = 0u; 22147| | /* First several numbers aren't that random. */ 22148| 126k| for (int i = 0; i < 16; i++) janet_rng_u32(rng); ------------------ | Branch (22148:21): [True: 118k, False: 7.41k] ------------------ 22149| 7.41k|} janet_rng_u32: 22165| 118k|uint32_t janet_rng_u32(JanetRNG *rng) { 22166| | /* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */ 22167| 118k| uint32_t t = rng->d; 22168| 118k| uint32_t const s = rng->a; 22169| 118k| rng->d = rng->c; 22170| 118k| rng->c = rng->b; 22171| 118k| rng->b = s; 22172| 118k| t ^= t >> 2; 22173| 118k| t ^= t << 1; 22174| 118k| t ^= s ^ (s << 4); 22175| 118k| rng->a = t; 22176| 118k| rng->counter += 362437; 22177| 118k| return t + rng->counter; 22178| 118k|} janet_lib_math: 22445| 3.70k|void janet_lib_math(JanetTable *env) { 22446| 3.70k| JanetRegExt math_cfuns[] = { 22447| 3.70k| JANET_CORE_REG("not", janet_not), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22448| 3.70k| JANET_CORE_REG("math/random", janet_rand), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22449| 3.70k| JANET_CORE_REG("math/seedrandom", janet_srand), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22450| 3.70k| JANET_CORE_REG("math/cos", janet_cos), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22451| 3.70k| JANET_CORE_REG("math/sin", janet_sin), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22452| 3.70k| JANET_CORE_REG("math/tan", janet_tan), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22453| 3.70k| JANET_CORE_REG("math/acos", janet_acos), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22454| 3.70k| JANET_CORE_REG("math/asin", janet_asin), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22455| 3.70k| JANET_CORE_REG("math/atan", janet_atan), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22456| 3.70k| JANET_CORE_REG("math/exp", janet_exp), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22457| 3.70k| JANET_CORE_REG("math/log", janet_log), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22458| 3.70k| JANET_CORE_REG("math/log10", janet_log10), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22459| 3.70k| JANET_CORE_REG("math/log2", janet_log2), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22460| 3.70k| JANET_CORE_REG("math/sqrt", janet_sqrt), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22461| 3.70k|#ifndef JANET_PLAN9 22462| 3.70k| JANET_CORE_REG("math/cbrt", janet_cbrt), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22463| 3.70k| JANET_CORE_REG("math/gamma", janet_tgamma), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22464| 3.70k| JANET_CORE_REG("math/log-gamma", janet_lgamma), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22465| 3.70k| JANET_CORE_REG("math/erfc", janet_erfc), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22466| 3.70k| JANET_CORE_REG("math/erf", janet_erf), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22467| 3.70k| JANET_CORE_REG("math/expm1", janet_expm1), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22468| 3.70k| JANET_CORE_REG("math/atanh", janet_atanh), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22469| 3.70k| JANET_CORE_REG("math/asinh", janet_asinh), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22470| 3.70k| JANET_CORE_REG("math/next", janet_nextafter), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22471| 3.70k|#endif 22472| 3.70k| JANET_CORE_REG("math/floor", janet_floor), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22473| 3.70k| JANET_CORE_REG("math/ceil", janet_ceil), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22474| 3.70k| JANET_CORE_REG("math/pow", janet_pow), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22475| 3.70k| JANET_CORE_REG("math/abs", janet_fabs), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22476| 3.70k| JANET_CORE_REG("math/sinh", janet_sinh), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22477| 3.70k| JANET_CORE_REG("math/cosh", janet_cosh), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22478| 3.70k| JANET_CORE_REG("math/tanh", janet_tanh), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22479| 3.70k| JANET_CORE_REG("math/acosh", janet_acosh), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22480| 3.70k| JANET_CORE_REG("math/atan2", janet_atan2), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22481| 3.70k| JANET_CORE_REG("math/rng", cfun_rng_make), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22482| 3.70k| JANET_CORE_REG("math/rng-uniform", cfun_rng_uniform), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22483| 3.70k| JANET_CORE_REG("math/rng-int", cfun_rng_int), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22484| 3.70k| JANET_CORE_REG("math/rng-buffer", cfun_rng_buffer), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22485| 3.70k| JANET_CORE_REG("math/hypot", janet_hypot), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22486| 3.70k| JANET_CORE_REG("math/exp2", janet_exp2), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22487| 3.70k| JANET_CORE_REG("math/log1p", janet_log1p), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22488| 3.70k| JANET_CORE_REG("math/trunc", janet_trunc), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22489| 3.70k| JANET_CORE_REG("math/round", janet_round), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22490| 3.70k| JANET_CORE_REG("math/gcd", janet_cfun_gcd), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22491| 3.70k| JANET_CORE_REG("math/lcm", janet_cfun_lcm), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22492| 3.70k| JANET_CORE_REG("math/frexp", janet_cfun_frexp), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22493| 3.70k| JANET_CORE_REG("math/ldexp", janet_cfun_ldexp), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22494| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 22495| 3.70k| }; 22496| 3.70k| janet_core_cfuns_ext(env, NULL, math_cfuns); 22497| 3.70k| janet_register_abstract_type(&janet_rng_type); 22498| |#ifdef JANET_BOOTSTRAP 22499| | JANET_CORE_DEF(env, "math/pi", janet_wrap_number(3.1415926535897931), 22500| | "The value pi."); 22501| | JANET_CORE_DEF(env, "math/e", janet_wrap_number(2.7182818284590451), 22502| | "The base of the natural log."); 22503| | JANET_CORE_DEF(env, "math/inf", janet_wrap_number(INFINITY), 22504| | "The number representing positive infinity"); 22505| | JANET_CORE_DEF(env, "math/-inf", janet_wrap_number(-INFINITY), 22506| | "The number representing negative infinity"); 22507| | JANET_CORE_DEF(env, "math/int32-min", janet_wrap_number(INT32_MIN), 22508| | "The minimum contiguous integer representable by a 32 bit signed integer"); 22509| | JANET_CORE_DEF(env, "math/int32-max", janet_wrap_number(INT32_MAX), 22510| | "The maximum contiguous integer representable by a 32 bit signed integer"); 22511| | JANET_CORE_DEF(env, "math/int-min", janet_wrap_number(JANET_INTMIN_DOUBLE), 22512| | "The minimum contiguous integer representable by a double (-(2^53))"); 22513| | JANET_CORE_DEF(env, "math/int-max", janet_wrap_number(JANET_INTMAX_DOUBLE), 22514| | "The maximum contiguous integer representable by a double (2^53)"); 22515| |#ifdef NAN 22516| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(NAN), "Not a number (IEEE-754 NaN)"); 22517| |#else 22518| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(0.0 / 0.0), "Not a number (IEEE-754 NaN)"); 22519| |#endif 22520| |#endif 22521| 3.70k|} janet_lib_net: 23792| 3.70k|void janet_lib_net(JanetTable *env) { 23793| 3.70k| JanetRegExt net_cfuns[] = { 23794| 3.70k| JANET_CORE_REG("net/address", cfun_net_sockaddr), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23795| 3.70k| JANET_CORE_REG("net/listen", cfun_net_listen), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23796| 3.70k| JANET_CORE_REG("net/socket", cfun_net_socket), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23797| 3.70k| JANET_CORE_REG("net/accept", cfun_stream_accept), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23798| 3.70k| JANET_CORE_REG("net/accept-loop", cfun_stream_accept_loop), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23799| 3.70k| JANET_CORE_REG("net/read", cfun_stream_read), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23800| 3.70k| JANET_CORE_REG("net/chunk", cfun_stream_chunk), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23801| 3.70k| JANET_CORE_REG("net/write", cfun_stream_write), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23802| 3.70k| JANET_CORE_REG("net/send-to", cfun_stream_send_to), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23803| 3.70k| JANET_CORE_REG("net/recv-from", cfun_stream_recv_from), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23804| 3.70k| JANET_CORE_REG("net/flush", cfun_stream_flush), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23805| 3.70k| JANET_CORE_REG("net/connect", cfun_net_connect), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23806| 3.70k| JANET_CORE_REG("net/shutdown", cfun_net_shutdown), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23807| 3.70k| JANET_CORE_REG("net/peername", cfun_net_getpeername), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23808| 3.70k| JANET_CORE_REG("net/localname", cfun_net_getsockname), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23809| 3.70k| JANET_CORE_REG("net/address-unpack", cfun_net_address_unpack), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23810| 3.70k| JANET_CORE_REG("net/setsockopt", cfun_net_setsockopt), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23811| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 23812| 3.70k| }; 23813| | janet_core_cfuns_ext(env, NULL, net_cfuns); 23814| 3.70k|} janet_net_init: 23816| 3.70k|void janet_net_init(void) { 23817| |#ifdef JANET_WINDOWS 23818| | WSADATA wsaData; 23819| | janet_assert(!WSAStartup(MAKEWORD(2, 2), &wsaData), "could not start winsock"); 23820| | janet_vm.connect_ex_loaded = 0; 23821| | janet_vm.connect_ex = NULL; 23822| |#endif 23823| 3.70k|} janet_net_deinit: 23825| 3.70k|void janet_net_deinit(void) { 23826| |#ifdef JANET_WINDOWS 23827| | WSACleanup(); 23828| |#endif 23829| 3.70k|} janet_lib_os: 26841| 3.70k|void janet_lib_os(JanetTable *env) { 26842| |#if !defined(JANET_REDUCED_OS) && defined(JANET_WINDOWS) && defined(JANET_THREADS) 26843| | /* During start up, the top-most abstract machine (thread) 26844| | * in the thread tree sets up the critical section. */ 26845| | static volatile long env_lock_initializing = 0; 26846| | static volatile long env_lock_initialized = 0; 26847| | if (!InterlockedExchange(&env_lock_initializing, 1)) { 26848| | InitializeCriticalSection(&env_lock); 26849| | InterlockedOr(&env_lock_initialized, 1); 26850| | } else { 26851| | while (!InterlockedOr(&env_lock_initialized, 0)) { 26852| | Sleep(0); 26853| | } 26854| | } 26855| | 26856| |#endif 26857| 3.70k|#ifndef JANET_NO_PROCESSES 26858| 3.70k|#endif 26859| 3.70k| JanetRegExt os_cfuns[] = { 26860| 3.70k| JANET_CORE_REG("os/exit", os_exit), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26861| 3.70k| JANET_CORE_REG("os/which", os_which), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26862| 3.70k| JANET_CORE_REG("os/arch", os_arch), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26863| 3.70k| JANET_CORE_REG("os/compiler", os_compiler), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26864| 3.70k|#ifndef JANET_REDUCED_OS 26865| | 26866| | /* misc (un-sandboxed) */ 26867| 3.70k| JANET_CORE_REG("os/cpu-count", os_cpu_count), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26868| 3.70k| JANET_CORE_REG("os/cwd", os_cwd), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26869| 3.70k| JANET_CORE_REG("os/cryptorand", os_cryptorand), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26870| 3.70k| JANET_CORE_REG("os/perm-string", os_permission_string), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26871| 3.70k| JANET_CORE_REG("os/perm-int", os_permission_int), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26872| 3.70k| JANET_CORE_REG("os/mktime", os_mktime), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26873| 3.70k| JANET_CORE_REG("os/time", os_time), /* not high resolution */ ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26874| 3.70k| JANET_CORE_REG("os/date", os_date), /* not high resolution */ ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26875| 3.70k| JANET_CORE_REG("os/strftime", os_strftime), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26876| 3.70k| JANET_CORE_REG("os/sleep", os_sleep), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26877| 3.70k| JANET_CORE_REG("os/isatty", os_isatty), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26878| 3.70k|#ifndef JANET_NO_LOCALES 26879| 3.70k| JANET_CORE_REG("os/setlocale", os_setlocale), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26880| 3.70k|#endif 26881| | 26882| | /* env functions */ 26883| 3.70k|#ifndef JANET_PLAN9 26884| 3.70k| JANET_CORE_REG("os/environ", os_environ), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26885| 3.70k|#endif 26886| 3.70k| JANET_CORE_REG("os/getenv", os_getenv), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26887| 3.70k| JANET_CORE_REG("os/setenv", os_setenv), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26888| | 26889| | /* fs read */ 26890| 3.70k| JANET_CORE_REG("os/dir", os_dir), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26891| 3.70k| JANET_CORE_REG("os/stat", os_stat), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26892| 3.70k| JANET_CORE_REG("os/lstat", os_lstat), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26893| 3.70k| JANET_CORE_REG("os/realpath", os_realpath), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26894| 3.70k| JANET_CORE_REG("os/cd", os_cd), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26895| 3.70k|#ifndef JANET_NO_UMASK 26896| 3.70k| JANET_CORE_REG("os/umask", os_umask), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26897| 3.70k|#endif 26898| 3.70k|#ifndef JANET_NO_SYMLINKS 26899| 3.70k| JANET_CORE_REG("os/readlink", os_readlink), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26900| 3.70k|#endif 26901| | 26902| | /* fs write */ 26903| 3.70k| JANET_CORE_REG("os/mkdir", os_mkdir), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26904| 3.70k| JANET_CORE_REG("os/rmdir", os_rmdir), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26905| 3.70k| JANET_CORE_REG("os/rm", os_remove), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26906| 3.70k| JANET_CORE_REG("os/link", os_link), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26907| 3.70k| JANET_CORE_REG("os/rename", os_rename), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26908| 3.70k| JANET_CORE_REG("os/chmod", os_chmod), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26909| 3.70k| JANET_CORE_REG("os/touch", os_touch), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26910| 3.70k|#ifndef JANET_NO_SYMLINKS 26911| 3.70k| JANET_CORE_REG("os/symlink", os_symlink), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26912| 3.70k|#endif 26913| | 26914| | /* processes */ 26915| 3.70k|#ifndef JANET_NO_PROCESSES 26916| 3.70k| JANET_CORE_REG("os/execute", os_execute), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26917| 3.70k| JANET_CORE_REG("os/spawn", os_spawn), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26918| 3.70k| JANET_CORE_REG("os/shell", os_shell), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26919| 3.70k| JANET_CORE_REG("os/posix-fork", os_posix_fork), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26920| 3.70k| JANET_CORE_REG("os/posix-exec", os_posix_exec), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26921| 3.70k| JANET_CORE_REG("os/posix-chroot", os_posix_chroot), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26922| | /* no need to sandbox process management if you can't create processes 26923| | * (allows for limited functionality if use exposes C-functions to create specific processes) */ 26924| 3.70k| JANET_CORE_REG("os/proc-wait", os_proc_wait), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26925| 3.70k| JANET_CORE_REG("os/proc-kill", os_proc_kill), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26926| 3.70k| JANET_CORE_REG("os/proc-close", os_proc_close), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26927| 3.70k| JANET_CORE_REG("os/getpid", os_proc_getpid), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26928| 3.70k|#ifdef JANET_EV 26929| 3.70k| JANET_CORE_REG("os/sigaction", os_sigaction), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26930| 3.70k|#endif 26931| 3.70k|#endif 26932| | 26933| | /* high resolution timers */ 26934| 3.70k| JANET_CORE_REG("os/clock", os_clock), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26935| | 26936| 3.70k|#ifdef JANET_EV 26937| 3.70k| JANET_CORE_REG("os/open", os_open), /* fs read and write */ ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26938| 3.70k| JANET_CORE_REG("os/pipe", os_pipe), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26939| 3.70k|#endif 26940| 3.70k|#endif 26941| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 26942| 3.70k| }; 26943| | janet_core_cfuns_ext(env, NULL, os_cfuns); 26944| 3.70k|} janet_lib_parse: 28258| 3.70k|void janet_lib_parse(JanetTable *env) { 28259| 3.70k| JanetRegExt parse_cfuns[] = { 28260| 3.70k| JANET_CORE_REG("parser/new", cfun_parse_parser), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28261| 3.70k| JANET_CORE_REG("parser/clone", cfun_parse_clone), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28262| 3.70k| JANET_CORE_REG("parser/has-more", cfun_parse_has_more), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28263| 3.70k| JANET_CORE_REG("parser/produce", cfun_parse_produce), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28264| 3.70k| JANET_CORE_REG("parser/consume", cfun_parse_consume), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28265| 3.70k| JANET_CORE_REG("parser/byte", cfun_parse_byte), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28266| 3.70k| JANET_CORE_REG("parser/error", cfun_parse_error), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28267| 3.70k| JANET_CORE_REG("parser/status", cfun_parse_status), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28268| 3.70k| JANET_CORE_REG("parser/flush", cfun_parse_flush), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28269| 3.70k| JANET_CORE_REG("parser/state", cfun_parse_state), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28270| 3.70k| JANET_CORE_REG("parser/where", cfun_parse_where), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28271| 3.70k| JANET_CORE_REG("parser/eof", cfun_parse_eof), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28272| 3.70k| JANET_CORE_REG("parser/insert", cfun_parse_insert), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28273| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 28274| 3.70k| }; 28275| | janet_core_cfuns_ext(env, NULL, parse_cfuns); 28276| 3.70k|} janet_lib_peg: 30383| 3.70k|void janet_lib_peg(JanetTable *env) { 30384| 3.70k| JanetRegExt cfuns[] = { 30385| 3.70k| JANET_CORE_REG("peg/compile", cfun_peg_compile), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30386| 3.70k| JANET_CORE_REG("peg/match", cfun_peg_match), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30387| 3.70k| JANET_CORE_REG("peg/find", cfun_peg_find), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30388| 3.70k| JANET_CORE_REG("peg/find-all", cfun_peg_find_all), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30389| 3.70k| JANET_CORE_REG("peg/replace", cfun_peg_replace), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30390| 3.70k| JANET_CORE_REG("peg/replace-all", cfun_peg_replace_all), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30391| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 30392| 3.70k| }; 30393| | janet_core_cfuns_ext(env, NULL, cfuns); 30394| 3.70k| janet_register_abstract_type(&janet_peg_type); 30395| 3.70k|} janet_to_string_b: 30625| 284|void janet_to_string_b(JanetBuffer *buffer, Janet x) { 30626| 284| switch (janet_type(x)) { ------------------ | | 795| 284| (isnan((x).number) \ | | 796| 284| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 284| : JANET_NUMBER) ------------------ | Branch (30626:13): [True: 40, False: 244] ------------------ 30627| 0| case JANET_NIL: ------------------ | Branch (30627:9): [True: 0, False: 284] ------------------ 30628| 0| janet_buffer_push_cstring(buffer, ""); 30629| 0| break; 30630| 4| case JANET_BOOLEAN: ------------------ | Branch (30630:9): [True: 4, False: 280] ------------------ 30631| 4| janet_buffer_push_cstring(buffer, 30632| 4| janet_unwrap_boolean(x) ? "true" : "false"); ------------------ | | 838| 4|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) | | ------------------ | | | Branch (838:33): [True: 0, False: 4] | | ------------------ ------------------ 30633| 4| break; 30634| 245| case JANET_NUMBER: ------------------ | Branch (30634:9): [True: 245, False: 39] ------------------ 30635| 245| number_to_string_b(buffer, janet_unwrap_number(x)); ------------------ | | 839| 245|#define janet_unwrap_number(x) ((x).number) ------------------ 30636| 245| break; 30637| 0| case JANET_STRING: ------------------ | Branch (30637:9): [True: 0, False: 284] ------------------ 30638| 6| case JANET_SYMBOL: ------------------ | Branch (30638:9): [True: 6, False: 278] ------------------ 30639| 8| case JANET_KEYWORD: ------------------ | Branch (30639:9): [True: 2, False: 282] ------------------ 30640| 8| janet_buffer_push_bytes(buffer, 30641| 8| janet_unwrap_string(x), ------------------ | | 863| 8|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 30642| 8| janet_string_length(janet_unwrap_string(x))); ------------------ | | 1813| 8|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 8|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30643| 8| break; 30644| 0| case JANET_BUFFER: { ------------------ | Branch (30644:9): [True: 0, False: 284] ------------------ 30645| 0| JanetBuffer *to = janet_unwrap_buffer(x); ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 30646| | /* Prevent resizing buffer while appending */ 30647| 0| if (buffer == to) janet_buffer_extra(buffer, to->count); ------------------ | Branch (30647:17): [True: 0, False: 0] ------------------ 30648| 0| janet_buffer_push_bytes(buffer, to->data, to->count); 30649| 0| break; 30650| 6| } 30651| 0| case JANET_ABSTRACT: { ------------------ | Branch (30651:9): [True: 0, False: 284] ------------------ 30652| 0| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 30653| 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))) | | ------------------ ------------------ 30654| 0| if (t->tostring != NULL) { ------------------ | Branch (30654:17): [True: 0, False: 0] ------------------ 30655| 0| t->tostring(p, buffer); 30656| 0| } else { 30657| 0| string_description_b(buffer, t->name, p); 30658| 0| } 30659| 0| } 30660| 0| return; 30661| 2| case JANET_CFUNCTION: { ------------------ | Branch (30661:9): [True: 2, False: 282] ------------------ 30662| 2| JanetCFunRegistry *reg = janet_registry_get(janet_unwrap_cfunction(x)); ------------------ | | 869| 2|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 30663| 2| if (NULL != reg) { ------------------ | Branch (30663:17): [True: 2, False: 0] ------------------ 30664| 2| janet_buffer_push_cstring(buffer, "name_prefix) { ------------------ | Branch (30665:21): [True: 0, False: 2] ------------------ 30666| 0| janet_buffer_push_cstring(buffer, reg->name_prefix); 30667| 0| janet_buffer_push_u8(buffer, '/'); 30668| 0| } 30669| 2| janet_buffer_push_cstring(buffer, reg->name); 30670| 2| janet_buffer_push_u8(buffer, '>'); 30671| 2| break; 30672| 2| } 30673| 0| goto fallthrough; 30674| 2| } 30675| 6| case JANET_FUNCTION: { ------------------ | Branch (30675:9): [True: 6, False: 278] ------------------ 30676| 6| JanetFunction *fun = janet_unwrap_function(x); ------------------ | | 868| 6|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 30677| 6| JanetFuncDef *def = fun->def; 30678| 6| if (def == NULL) { ------------------ | Branch (30678:17): [True: 3, False: 3] ------------------ 30679| 3| janet_buffer_push_cstring(buffer, ""); 30680| 3| break; 30681| 3| } 30682| 3| if (def->name) { ------------------ | Branch (30682:17): [True: 0, False: 3] ------------------ 30683| 0| const uint8_t *n = def->name; 30684| 0| janet_buffer_push_cstring(buffer, "length) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30686| 0| janet_buffer_push_u8(buffer, '>'); 30687| 0| break; 30688| 0| } 30689| 3| goto fallthrough; 30690| 3| } 30691| 3| fallthrough: 30692| 22| default: ------------------ | Branch (30692:9): [True: 19, False: 265] ------------------ 30693| 22| string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 795| 22| (isnan((x).number) \ | | 796| 22| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 22| : JANET_NUMBER) ------------------ string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 867| 22|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (30693:59): [True: 22, False: 0] ------------------ 30694| 22| break; 30695| 284| } 30696| 284|} janet_description_b: 30711| 415|void janet_description_b(JanetBuffer *buffer, Janet x) { 30712| 415| switch (janet_type(x)) { ------------------ | | 795| 415| (isnan((x).number) \ | | 796| 415| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 415| : JANET_NUMBER) ------------------ | Branch (30712:13): [True: 171, False: 244] ------------------ 30713| 282| default: ------------------ | Branch (30713:9): [True: 282, False: 133] ------------------ 30714| 282| break; 30715| 282| case JANET_NIL: ------------------ | Branch (30715:9): [True: 5, False: 410] ------------------ 30716| 5| janet_buffer_push_cstring(buffer, "nil"); 30717| 5| return; 30718| 2| case JANET_KEYWORD: ------------------ | Branch (30718:9): [True: 2, False: 413] ------------------ 30719| 2| janet_buffer_push_u8(buffer, ':'); 30720| 2| break; 30721| 100| case JANET_STRING: ------------------ | Branch (30721:9): [True: 100, False: 315] ------------------ 30722| 100| janet_escape_string_b(buffer, janet_unwrap_string(x)); ------------------ | | 863| 100|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 30723| 100| return; 30724| 26| case JANET_BUFFER: { ------------------ | Branch (30724:9): [True: 26, False: 389] ------------------ 30725| 26| JanetBuffer *b = janet_unwrap_buffer(x); ------------------ | | 862| 26|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 30726| 26| janet_escape_buffer_b(buffer, b); 30727| 26| return; 30728| 0| } 30729| 0| case JANET_ABSTRACT: { ------------------ | Branch (30729:9): [True: 0, False: 415] ------------------ 30730| 0| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 30731| 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))) | | ------------------ ------------------ 30732| 0| if (t->tostring != NULL) { ------------------ | Branch (30732:17): [True: 0, False: 0] ------------------ 30733| 0| janet_buffer_push_cstring(buffer, "<"); 30734| 0| janet_buffer_push_cstring(buffer, t->name); 30735| 0| janet_buffer_push_cstring(buffer, " "); 30736| 0| t->tostring(p, buffer); 30737| 0| janet_buffer_push_cstring(buffer, ">"); 30738| 0| } else { 30739| 0| string_description_b(buffer, t->name, p); 30740| 0| } 30741| 0| return; 30742| 0| } 30743| 415| } 30744| 284| janet_to_string_b(buffer, x); 30745| 284|} janet_formatbv: 31398| 1.91k|void janet_formatbv(JanetBuffer *b, const char *format, va_list args) { 31399| 1.91k| const char *format_end = format + strlen(format); 31400| 1.91k| const char *c = format; 31401| 1.91k| int32_t startlen = b->count; 31402| 58.2k| while (c < format_end) { ------------------ | Branch (31402:12): [True: 56.3k, False: 1.91k] ------------------ 31403| 56.3k| if (*c != '%') { ------------------ | Branch (31403:13): [True: 53.5k, False: 2.79k] ------------------ 31404| 53.5k| janet_buffer_push_u8(b, (uint8_t) *c++); 31405| 53.5k| } else if (*++c == '%') { ------------------ | Branch (31405:20): [True: 0, False: 2.79k] ------------------ 31406| 0| janet_buffer_push_u8(b, (uint8_t) *c++); 31407| 2.79k| } else { 31408| 2.79k| char form[MAX_FORMAT], item[MAX_ITEM]; 31409| 2.79k| char width[3], precision[3]; 31410| 2.79k| int nb = 0; /* number of bytes in added item */ 31411| 2.79k| c = scanformat(c, form, width, precision); 31412| 2.79k| switch (*c++) { 31413| 0| case 'c': { ------------------ | Branch (31413:17): [True: 0, False: 2.79k] ------------------ 31414| 0| int n = va_arg(args, int); 31415| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31416| 0| break; 31417| 0| } 31418| 1.49k| case 'd': ------------------ | Branch (31418:17): [True: 1.49k, False: 1.29k] ------------------ 31419| 1.49k| case 'i': { ------------------ | Branch (31419:17): [True: 0, False: 2.79k] ------------------ 31420| 1.49k| int64_t n = (int64_t) va_arg(args, int32_t); 31421| 1.49k| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 1.49k|#define MAX_ITEM 256 ------------------ 31422| 1.49k| break; 31423| 1.49k| } 31424| 0| case 'D': ------------------ | Branch (31424:17): [True: 0, False: 2.79k] ------------------ 31425| 0| case 'I': { ------------------ | Branch (31425:17): [True: 0, False: 2.79k] ------------------ 31426| 0| int64_t n = va_arg(args, int64_t); 31427| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31428| 0| break; 31429| 0| } 31430| 504| case 'x': ------------------ | Branch (31430:17): [True: 504, False: 2.29k] ------------------ 31431| 504| case 'X': ------------------ | Branch (31431:17): [True: 0, False: 2.79k] ------------------ 31432| 504| case 'o': ------------------ | Branch (31432:17): [True: 0, False: 2.79k] ------------------ 31433| 504| case 'u': { ------------------ | Branch (31433:17): [True: 0, False: 2.79k] ------------------ 31434| 504| uint64_t n = va_arg(args, uint64_t); 31435| 504| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 504|#define MAX_ITEM 256 ------------------ 31436| 504| break; 31437| 504| } 31438| 0| case 'a': ------------------ | Branch (31438:17): [True: 0, False: 2.79k] ------------------ 31439| 0| case 'A': ------------------ | Branch (31439:17): [True: 0, False: 2.79k] ------------------ 31440| 0| case 'e': ------------------ | Branch (31440:17): [True: 0, False: 2.79k] ------------------ 31441| 0| case 'E': ------------------ | Branch (31441:17): [True: 0, False: 2.79k] ------------------ 31442| 0| case 'f': ------------------ | Branch (31442:17): [True: 0, False: 2.79k] ------------------ 31443| 0| case 'g': ------------------ | Branch (31443:17): [True: 0, False: 2.79k] ------------------ 31444| 0| case 'G': { ------------------ | Branch (31444:17): [True: 0, False: 2.79k] ------------------ 31445| 0| double d = va_arg(args, double); 31446| 0| nb = snprintf(item, MAX_ITEM, form, d); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31447| 0| break; 31448| 0| } 31449| 0| case 's': ------------------ | Branch (31449:17): [True: 0, False: 2.79k] ------------------ 31450| 0| case 'S': { ------------------ | Branch (31450:17): [True: 0, False: 2.79k] ------------------ 31451| 0| const char *str = va_arg(args, const char *); 31452| 0| int32_t len = (c[-1] == 's') ------------------ | Branch (31452:35): [True: 0, False: 0] ------------------ 31453| 0| ? (int32_t) strlen(str) 31454| 0| : janet_string_length((JanetString) 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))) | | ------------------ ------------------ 31455| 0| if (form[2] == '\0') ------------------ | Branch (31455:25): [True: 0, False: 0] ------------------ 31456| 0| janet_buffer_push_bytes(b, (const uint8_t *) str, len); 31457| 0| else { 31458| 0| if (len != (int32_t) strlen((const char *) str)) ------------------ | Branch (31458:29): [True: 0, False: 0] ------------------ 31459| 0| janet_panic("string contains zeros"); 31460| 0| if (!strchr(form, '.') && len >= 100) { ------------------ | Branch (31460:29): [True: 0, False: 0] | Branch (31460:51): [True: 0, False: 0] ------------------ 31461| 0| janet_panic("no precision and string is too long to be formatted"); 31462| 0| } else { 31463| 0| nb = snprintf(item, MAX_ITEM, form, str); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31464| 0| } 31465| 0| } 31466| 0| break; 31467| 0| } 31468| 0| case 'V': ------------------ | Branch (31468:17): [True: 0, False: 2.79k] ------------------ 31469| 0| janet_to_string_b(b, va_arg(args, Janet)); 31470| 0| break; 31471| 415| case 'v': ------------------ | Branch (31471:17): [True: 415, False: 2.37k] ------------------ 31472| 415| janet_description_b(b, va_arg(args, Janet)); 31473| 415| break; 31474| 0| case 't': ------------------ | Branch (31474:17): [True: 0, False: 2.79k] ------------------ 31475| 0| janet_buffer_push_cstring(b, typestr(va_arg(args, Janet))); 31476| 0| break; 31477| 379| case 'T': { ------------------ | Branch (31477:17): [True: 379, False: 2.41k] ------------------ 31478| 379| int types = va_arg(args, int); 31479| 379| pushtypes(b, types); 31480| 379| break; 31481| 0| } 31482| 0| case 'M': ------------------ | Branch (31482:17): [True: 0, False: 2.79k] ------------------ 31483| 0| case 'm': ------------------ | Branch (31483:17): [True: 0, False: 2.79k] ------------------ 31484| 0| case 'N': ------------------ | Branch (31484:17): [True: 0, False: 2.79k] ------------------ 31485| 0| case 'n': ------------------ | Branch (31485:17): [True: 0, False: 2.79k] ------------------ 31486| 0| case 'Q': ------------------ | Branch (31486:17): [True: 0, False: 2.79k] ------------------ 31487| 0| case 'q': ------------------ | Branch (31487:17): [True: 0, False: 2.79k] ------------------ 31488| 0| case 'P': ------------------ | Branch (31488:17): [True: 0, False: 2.79k] ------------------ 31489| 0| case 'p': { /* janet pretty , precision = depth */ ------------------ | Branch (31489:17): [True: 0, False: 2.79k] ------------------ 31490| 0| int depth = atoi(precision); 31491| 0| if (depth < 1) depth = JANET_RECURSION_GUARD; ------------------ | | 296| 0|#define JANET_RECURSION_GUARD 1024 ------------------ | Branch (31491:25): [True: 0, False: 0] ------------------ 31492| 0| char d = c[-1]; 31493| 0| int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N'); ------------------ | Branch (31493:37): [True: 0, False: 0] | Branch (31493:51): [True: 0, False: 0] | Branch (31493:65): [True: 0, False: 0] | Branch (31493:79): [True: 0, False: 0] ------------------ 31494| 0| int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n'); ------------------ | Branch (31494:39): [True: 0, False: 0] | Branch (31494:53): [True: 0, False: 0] | Branch (31494:67): [True: 0, False: 0] | Branch (31494:81): [True: 0, False: 0] ------------------ 31495| 0| int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n'); ------------------ | Branch (31495:39): [True: 0, False: 0] | Branch (31495:53): [True: 0, False: 0] | Branch (31495:67): [True: 0, False: 0] | Branch (31495:81): [True: 0, False: 0] ------------------ 31496| 0| int columns = atoi(width); 31497| 0| if (columns == 0) { ------------------ | Branch (31497:25): [True: 0, False: 0] ------------------ 31498| 0| columns = JANET_COLUMNS; ------------------ | |31234| 0|#define JANET_COLUMNS 80 ------------------ 31499| 0| } else if (columns < 0) { ------------------ | Branch (31499:32): [True: 0, False: 0] ------------------ 31500| 0| has_oneline = 1; 31501| 0| } 31502| 0| int flags = 0; 31503| 0| flags |= has_color ? JANET_PRETTY_COLOR : 0; ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31503:30): [True: 0, False: 0] ------------------ 31504| 0| flags |= has_oneline ? JANET_PRETTY_ONELINE : 0; ------------------ | | 1968| 0|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (31504:30): [True: 0, False: 0] ------------------ 31505| 0| flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0; ------------------ | | 1969| 0|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (31505:30): [True: 0, False: 0] ------------------ 31506| 0| janet_pretty_(b, depth, columns, flags, 31507| 0| va_arg(args, Janet), startlen, b->count); 31508| 0| break; 31509| 0| } 31510| 0| case 'j': { ------------------ | Branch (31510:17): [True: 0, False: 2.79k] ------------------ 31511| 0| int depth = atoi(precision); 31512| 0| if (depth < 1) { ------------------ | Branch (31512:25): [True: 0, False: 0] ------------------ 31513| 0| depth = JANET_RECURSION_GUARD; ------------------ | | 296| 0|#define JANET_RECURSION_GUARD 1024 ------------------ 31514| 0| } 31515| 0| janet_jdn_(b, depth, va_arg(args, Janet), startlen, b->count); 31516| 0| break; 31517| 0| } 31518| 0| default: { ------------------ | Branch (31518:17): [True: 0, False: 2.79k] ------------------ 31519| | /* also treat cases 'nLlh' */ 31520| 0| janet_panicf("invalid conversion '%s' to 'format'", 31521| 0| form); 31522| 0| } 31523| 2.79k| } 31524| 2.79k| if (nb >= MAX_ITEM) ------------------ | |31321| 2.79k|#define MAX_ITEM 256 ------------------ | Branch (31524:17): [True: 0, False: 2.79k] ------------------ 31525| 0| janet_panic("format buffer overflow"); 31526| 2.79k| if (nb > 0) ------------------ | Branch (31526:17): [True: 2.00k, False: 794] ------------------ 31527| 2.00k| janet_buffer_push_bytes(b, (uint8_t *) item, nb); 31528| 2.79k| } 31529| | 31530| 56.3k| } 31531| 1.91k|} janet_string: 33466| 5.49M|const uint8_t *janet_string(const uint8_t *buf, int32_t len) { 33467| 5.49M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1); 33468| 5.49M| head->length = len; 33469| 5.49M| head->hash = janet_string_calchash(buf, len); 33470| 5.49M| uint8_t *data = (uint8_t *)head->data; 33471| 5.49M| safe_memcpy(data, buf, len); 33472| 5.49M| data[len] = 0; 33473| 5.49M| return data; 33474| 5.49M|} janet_string_compare: 33477| 5.45k|int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) { 33478| 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))) | | ------------------ ------------------ 33479| 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))) | | ------------------ ------------------ 33480| 5.45k| int32_t len = xlen > ylen ? ylen : xlen; ------------------ | Branch (33480:19): [True: 0, False: 5.45k] ------------------ 33481| 5.45k| int res = memcmp(lhs, rhs, len); 33482| 5.45k| if (res) return res > 0 ? 1 : -1; ------------------ | Branch (33482:9): [True: 333, False: 5.12k] | Branch (33482:21): [True: 30, False: 303] ------------------ 33483| 5.12k| if (xlen == ylen) return 0; ------------------ | Branch (33483:9): [True: 5.12k, False: 0] ------------------ 33484| 0| return xlen < ylen ? -1 : 1; ------------------ | Branch (33484:12): [True: 0, False: 0] ------------------ 33485| 5.12k|} janet_string_equalconst: 33488| 26.2M|int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) { 33489| 26.2M| int32_t lhash = janet_string_hash(lhs); ------------------ | | 1814| 26.2M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 26.2M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33490| 26.2M| int32_t llen = janet_string_length(lhs); ------------------ | | 1813| 26.2M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 26.2M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33491| 26.2M| if (lhash != rhash || llen != rlen) ------------------ | Branch (33491:9): [True: 10.5M, False: 15.7M] | Branch (33491:27): [True: 452, False: 15.7M] ------------------ 33492| 10.5M| return 0; 33493| 15.7M| if (lhs == rhs) ------------------ | Branch (33493:9): [True: 7.41M, False: 8.30M] ------------------ 33494| 7.41M| return 1; 33495| 8.30M| return !memcmp(lhs, rhs, rlen); 33496| 15.7M|} janet_string_equal: 33499| 3.45k|int janet_string_equal(const uint8_t *lhs, const uint8_t *rhs) { 33500| 3.45k| return janet_string_equalconst(lhs, rhs, 33501| 3.45k| janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1813| 3.45k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 3.45k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1814| 3.45k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 3.45k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33502| 3.45k|} janet_cstring: 33505| 1.53k|const uint8_t *janet_cstring(const char *str) { 33506| 1.53k| return janet_string((const uint8_t *)str, (int32_t)strlen(str)); 33507| 1.53k|} janet_lib_string: 34074| 3.70k|void janet_lib_string(JanetTable *env) { 34075| 3.70k| JanetRegExt string_cfuns[] = { 34076| 3.70k| JANET_CORE_REG("string/slice", cfun_string_slice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34077| 3.70k| JANET_CORE_REG("keyword/slice", cfun_keyword_slice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34078| 3.70k| JANET_CORE_REG("symbol/slice", cfun_symbol_slice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34079| 3.70k| JANET_CORE_REG("string/repeat", cfun_string_repeat), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34080| 3.70k| JANET_CORE_REG("string/bytes", cfun_string_bytes), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34081| 3.70k| JANET_CORE_REG("string/from-bytes", cfun_string_frombytes), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34082| 3.70k| JANET_CORE_REG("string/ascii-lower", cfun_string_asciilower), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34083| 3.70k| JANET_CORE_REG("string/ascii-upper", cfun_string_asciiupper), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34084| 3.70k| JANET_CORE_REG("string/reverse", cfun_string_reverse), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34085| 3.70k| JANET_CORE_REG("string/find", cfun_string_find), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34086| 3.70k| JANET_CORE_REG("string/find-all", cfun_string_findall), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34087| 3.70k| JANET_CORE_REG("string/has-prefix?", cfun_string_hasprefix), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34088| 3.70k| JANET_CORE_REG("string/has-suffix?", cfun_string_hassuffix), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34089| 3.70k| JANET_CORE_REG("string/replace", cfun_string_replace), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34090| 3.70k| JANET_CORE_REG("string/replace-all", cfun_string_replaceall), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34091| 3.70k| JANET_CORE_REG("string/split", cfun_string_split), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34092| 3.70k| JANET_CORE_REG("string/check-set", cfun_string_checkset), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34093| 3.70k| JANET_CORE_REG("string/join", cfun_string_join), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34094| 3.70k| JANET_CORE_REG("string/format", cfun_string_format), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34095| 3.70k| JANET_CORE_REG("string/trim", cfun_string_trim), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34096| 3.70k| JANET_CORE_REG("string/triml", cfun_string_triml), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34097| 3.70k| JANET_CORE_REG("string/trimr", cfun_string_trimr), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34098| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 34099| 3.70k| }; 34100| | janet_core_cfuns_ext(env, NULL, string_cfuns); 34101| 3.70k|} janet_struct_begin: 34690| 326k|JanetKV *janet_struct_begin(int32_t count) { 34691| | /* Calculate capacity as power of 2 after 2 * count. */ 34692| 326k| int32_t capacity = janet_tablen(2 * count); 34693| 326k| if (capacity < 0) capacity = janet_tablen(count + 1); ------------------ | Branch (34693:9): [True: 0, False: 326k] ------------------ 34694| | 34695| 326k| size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV); 34696| 326k| JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size); 34697| 326k| head->length = count; 34698| 326k| head->capacity = capacity; 34699| 326k| head->hash = 0; 34700| 326k| head->proto = NULL; 34701| | 34702| 326k| JanetKV *st = (JanetKV *)(head->data); 34703| 326k| janet_memempty(st, capacity); 34704| 326k| return st; 34705| 326k|} janet_struct_put_ext: 34720| 1.23M|void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) { 34721| 1.23M| int32_t cap = janet_struct_capacity(st); ------------------ | | 1849| 1.23M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 1.23M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34722| 1.23M| int32_t hash = janet_hash(key); 34723| 1.23M| int32_t index = janet_maphash(cap, hash); ------------------ | | 396| 1.23M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34724| 1.23M| int32_t i, j, dist; 34725| 1.23M| int32_t bounds[4] = {index, cap, 0, index}; 34726| 1.23M| if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 806| 2.46M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 37.1k, False: 1.19M] | | | Branch (806:6): [Folded, False: 1.23M] | | ------------------ | | 807| 2.46M| ? 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.46M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.23M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.23M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.23M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.23M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 806| 1.19M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 10.9k, False: 1.18M] | | | Branch (806:6): [Folded, False: 1.19M] | | ------------------ | | 807| 1.19M| ? 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| 1.19M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.19M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.19M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.19M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.19M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34727| 1.18M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 806| 2.37M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 710k, False: 475k] | | | Branch (806:6): [True: 1.18M, Folded] | | ------------------ | | 807| 2.37M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 1.18M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 709k, False: 475k] | | | | | Branch (803:28): [True: 646, False: 475k] | | | | ------------------ | | ------------------ | | 808| 2.37M| : 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 (34727:47): [True: 646, False: 709k] ------------------ 34728| | /* Avoid extra items */ 34729| 1.18M| if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1850| 1.18M|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 1.18M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1848| 1.18M|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 1.18M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34729:9): [True: 0, False: 1.18M] ------------------ 34730| 1.19M| for (dist = 0, j = 0; j < 4; j += 2) ------------------ | Branch (34730:27): [True: 1.19M, False: 0] ------------------ 34731| 1.40M| for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) { ------------------ | Branch (34731:29): [True: 1.39M, False: 10.3k] ------------------ 34732| 1.39M| int status; 34733| 1.39M| int32_t otherhash; 34734| 1.39M| int32_t otherindex, otherdist; 34735| 1.39M| JanetKV *kv = st + i; 34736| | /* We found an empty slot, so just add key and value */ 34737| 1.39M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 1.39M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 732k, False: 661k] | | | Branch (806:6): [Folded, False: 1.39M] | | ------------------ | | 807| 1.39M| ? 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| 1.39M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.39M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.39M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.39M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.39M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34738| 732k| kv->key = key; 34739| 732k| kv->value = value; 34740| | /* Update the temporary count */ 34741| 732k| janet_struct_hash(st)++; ------------------ | | 1850| 732k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 732k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34742| 732k| return; 34743| 732k| } 34744| | /* Robinhood hashing - check if colliding kv pair 34745| | * is closer to their source than current. We use robinhood 34746| | * hashing to ensure that equivalent structs that are constructed 34747| | * with different order have the same internal layout, and therefor 34748| | * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}. 34749| | * Collisions are resolved via an insertion sort insertion. */ 34750| 661k| otherhash = janet_hash(kv->key); 34751| 661k| otherindex = janet_maphash(cap, otherhash); ------------------ | | 396| 661k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34752| 661k| otherdist = (i + cap - otherindex) & (cap - 1); 34753| 661k| if (dist < otherdist) ------------------ | Branch (34753:17): [True: 62.1k, False: 599k] ------------------ 34754| 62.1k| status = -1; 34755| 599k| else if (otherdist < dist) ------------------ | Branch (34755:22): [True: 19.5k, False: 579k] ------------------ 34756| 19.5k| status = 1; 34757| 579k| else if (hash < otherhash) ------------------ | Branch (34757:22): [True: 82.5k, False: 497k] ------------------ 34758| 82.5k| status = -1; 34759| 497k| else if (otherhash < hash) ------------------ | Branch (34759:22): [True: 19.4k, False: 477k] ------------------ 34760| 19.4k| status = 1; 34761| 477k| else 34762| 477k| status = janet_compare(key, kv->key); 34763| | /* If other is closer to their ideal slot */ 34764| 661k| if (status == 1) { ------------------ | Branch (34764:17): [True: 44.6k, False: 616k] ------------------ 34765| | /* Swap current kv pair with pair in slot */ 34766| 44.6k| JanetKV temp = *kv; 34767| 44.6k| kv->key = key; 34768| 44.6k| kv->value = value; 34769| 44.6k| key = temp.key; 34770| 44.6k| value = temp.value; 34771| | /* Save dist and hash of new kv pair */ 34772| 44.6k| dist = otherdist; 34773| 44.6k| hash = otherhash; 34774| 616k| } else if (status == 0) { ------------------ | Branch (34774:24): [True: 452k, False: 163k] ------------------ 34775| 452k| if (replace) { ------------------ | Branch (34775:21): [True: 452k, False: 0] ------------------ 34776| | /* A key was added to the struct more than once - replace old value */ 34777| 452k| kv->value = value; 34778| 452k| } 34779| 452k| return; 34780| 452k| } 34781| 661k| } 34782| 1.18M|} janet_struct_put: 34784| 1.23M|void janet_struct_put(JanetKV *st, Janet key, Janet value) { 34785| 1.23M| janet_struct_put_ext(st, key, value, 1); 34786| 1.23M|} janet_struct_end: 34789| 255k|const JanetKV *janet_struct_end(JanetKV *st) { 34790| 255k| if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1850| 255k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 255k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1848| 255k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 255k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34790:9): [True: 39.9k, False: 215k] ------------------ 34791| | /* Error building struct, probably duplicate values. We need to rebuild 34792| | * the struct using only the values that went in. The second creation should always 34793| | * succeed. */ 34794| 39.9k| JanetKV *newst = janet_struct_begin(janet_struct_hash(st)); ------------------ | | 1850| 39.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 39.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34795| 2.31M| for (int32_t i = 0; i < janet_struct_capacity(st); i++) { ------------------ | | 1849| 2.31M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 2.31M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34795:29): [True: 2.27M, False: 39.9k] ------------------ 34796| 2.27M| JanetKV *kv = st + i; 34797| 2.27M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 2.27M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.27M] | | ------------------ | | 807| 2.27M| ? 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.27M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.27M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.27M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.27M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.27M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34797:17): [True: 251k, False: 2.01M] ------------------ 34798| 251k| janet_struct_put(newst, kv->key, kv->value); 34799| 251k| } 34800| 2.27M| } 34801| 39.9k| janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1851| 39.9k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 39.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1851| 39.9k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 39.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34802| 39.9k| st = newst; 34803| 39.9k| } 34804| 255k| janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1850| 255k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 255k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1849| 255k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 255k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34805| 255k| if (janet_struct_proto(st)) { ------------------ | | 1851| 255k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 255k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 10.8k, False: 244k] | | ------------------ ------------------ 34806| 10.8k| janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1850| 10.8k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1850| 10.8k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34807| 10.8k| } 34808| 255k| return (const JanetKV *)st; 34809| 255k|} janet_lib_struct: 34956| 3.70k|void janet_lib_struct(JanetTable *env) { 34957| 3.70k| JanetRegExt struct_cfuns[] = { 34958| 3.70k| JANET_CORE_REG("struct/with-proto", cfun_struct_with_proto), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34959| 3.70k| JANET_CORE_REG("struct/getproto", cfun_struct_getproto), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34960| 3.70k| JANET_CORE_REG("struct/proto-flatten", cfun_struct_flatten), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34961| 3.70k| JANET_CORE_REG("struct/to-table", cfun_struct_to_table), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34962| 3.70k| JANET_CORE_REG("struct/rawget", cfun_struct_rawget), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34963| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 34964| 3.70k| }; 34965| | janet_core_cfuns_ext(env, NULL, struct_cfuns); 34966| 3.70k|} janet_symcache_init: 35011| 3.70k|void janet_symcache_init() { 35012| 3.70k| janet_vm.cache_capacity = 1024; 35013| 3.70k| janet_vm.cache = janet_calloc(1, (size_t) janet_vm.cache_capacity * sizeof(const uint8_t *)); ------------------ | | 2412| 3.70k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 35014| 3.70k| if (NULL == janet_vm.cache) { ------------------ | Branch (35014:9): [True: 0, False: 3.70k] ------------------ 35015| 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] | | ------------------ ------------------ 35016| 0| } 35017| 3.70k| memset(&janet_vm.gensym_counter, '0', sizeof(janet_vm.gensym_counter)); 35018| 3.70k| janet_vm.gensym_counter[0] = '_'; 35019| 3.70k| janet_vm.cache_count = 0; 35020| 3.70k| janet_vm.cache_deleted = 0; 35021| 3.70k|} janet_symcache_deinit: 35024| 3.70k|void janet_symcache_deinit() { 35025| 3.70k| janet_free((void *)janet_vm.cache); ------------------ | | 2415| 3.70k|#define janet_free(X) free((X)) ------------------ 35026| | janet_vm.cache = NULL; 35027| 3.70k| janet_vm.cache_capacity = 0; 35028| 3.70k| janet_vm.cache_count = 0; 35029| 3.70k| janet_vm.cache_deleted = 0; 35030| 3.70k|} janet_symbol_deinit: 35132| 7.41M|void janet_symbol_deinit(const uint8_t *sym) { 35133| 7.41M| int status = 0; 35134| 7.41M| const uint8_t **bucket = janet_symcache_find(sym, &status); ------------------ | |35087| 7.41M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 7.41M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 7.41M|#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| 7.41M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 7.41M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35135| 7.41M| if (status) { ------------------ | Branch (35135:9): [True: 7.41M, False: 0] ------------------ 35136| 7.41M| janet_vm.cache_count--; 35137| 7.41M| janet_vm.cache_deleted++; 35138| 7.41M| *bucket = JANET_SYMCACHE_DELETED; 35139| 7.41M| } 35140| 7.41M|} janet_symbol: 35143| 13.1M|const uint8_t *janet_symbol(const uint8_t *str, int32_t len) { 35144| 13.1M| int32_t hash = janet_string_calchash(str, len); 35145| 13.1M| uint8_t *newstr; 35146| 13.1M| int success = 0; 35147| 13.1M| const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success); 35148| 13.1M| if (success) ------------------ | Branch (35148:9): [True: 5.73M, False: 7.41M] ------------------ 35149| 5.73M| return *bucket; 35150| 7.41M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1); 35151| 7.41M| head->hash = hash; 35152| 7.41M| head->length = len; 35153| 7.41M| newstr = (uint8_t *)(head->data); 35154| 7.41M| safe_memcpy(newstr, str, len); 35155| 7.41M| newstr[len] = 0; 35156| 7.41M| janet_symcache_put((const uint8_t *)newstr, bucket); 35157| 7.41M| return newstr; 35158| 13.1M|} janet_csymbol: 35161| 3.96M|const uint8_t *janet_csymbol(const char *cstr) { 35162| 3.96M| return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr)); 35163| 3.96M|} janet_table_init_raw: 35292| 11.1k|JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity) { 35293| 11.1k| return janet_table_init_impl(table, capacity, 0); 35294| 11.1k|} janet_table_deinit: 35297| 11.1k|void janet_table_deinit(JanetTable *table) { 35298| 11.1k| if (table->gc.flags & JANET_TABLE_FLAG_STACK) { ------------------ | |35247| 11.1k|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (35298:9): [True: 0, False: 11.1k] ------------------ 35299| 0| janet_sfree(table->data); 35300| 11.1k| } else { 35301| 11.1k| janet_free(table->data); ------------------ | | 2415| 11.1k|#define janet_free(X) free((X)) ------------------ 35302| 11.1k| } 35303| 11.1k|} janet_table: 35307| 2.72M|JanetTable *janet_table(int32_t capacity) { 35308| 2.72M| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); 35309| 2.72M| return janet_table_init_impl(table, capacity, 0); 35310| 2.72M|} janet_table_weakk: 35312| 9.24k|JanetTable *janet_table_weakk(int32_t capacity) { 35313| 9.24k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKK, sizeof(JanetTable)); 35314| 9.24k| return janet_table_init_impl(table, capacity, 0); 35315| 9.24k|} janet_table_weakv: 35317| 2.55k|JanetTable *janet_table_weakv(int32_t capacity) { 35318| 2.55k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKV, sizeof(JanetTable)); 35319| 2.55k| return janet_table_init_impl(table, capacity, 0); 35320| 2.55k|} janet_table_weakkv: 35322| 56.5k|JanetTable *janet_table_weakkv(int32_t capacity) { 35323| 56.5k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKKV, sizeof(JanetTable)); 35324| 56.5k| return janet_table_init_impl(table, capacity, 0); 35325| 56.5k|} janet_table_find: 35329| 40.7M|JanetKV *janet_table_find(JanetTable *t, Janet key) { 35330| 40.7M| return (JanetKV *) janet_dict_find(t->data, t->capacity, key); 35331| 40.7M|} janet_table_get: 35365| 4.01M|Janet janet_table_get(JanetTable *t, Janet key) { 35366| 4.09M| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 4.01M|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (35366:41): [True: 4.01M, False: 82.5k] | Branch (35366:46): [True: 4.01M, False: 0] ------------------ 35367| 4.01M| JanetKV *bucket = janet_table_find(t, key); 35368| 4.01M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 4.01M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 4.01M] | | ------------------ | | 807| 4.01M| ? 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.01M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 4.01M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 4.01M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 4.01M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.01M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35368:13): [True: 4.01M, False: 0] | Branch (35368:31): [True: 3.93M, False: 82.5k] ------------------ 35369| 3.93M| return bucket->value; 35370| 4.01M| } 35371| 82.5k| return janet_wrap_nil(); ------------------ | | 831| 82.5k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 82.5k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 82.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 82.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35372| 4.01M|} janet_table_get_keyword: 35375| 29.6k|Janet janet_table_get_keyword(JanetTable *t, const char *keyword) { 35376| 29.6k| int32_t keyword_len = (int32_t) strlen(keyword); 35377| 51.8k| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 29.6k|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (35377:41): [True: 29.6k, False: 22.2k] | Branch (35377:46): [True: 29.6k, False: 0] ------------------ 35378| 29.6k| JanetKV *bucket = (JanetKV *) janet_dict_find_keyword(t->data, t->capacity, (const uint8_t *) keyword, keyword_len); 35379| 29.6k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 29.6k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 29.6k] | | ------------------ | | 807| 29.6k| ? 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| 29.6k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 29.6k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 29.6k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 29.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 29.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35379:13): [True: 29.6k, False: 0] | Branch (35379:31): [True: 7.41k, False: 22.2k] ------------------ 35380| 7.41k| return bucket->value; 35381| 29.6k| } 35382| 22.2k| return janet_wrap_nil(); ------------------ | | 831| 22.2k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 22.2k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 22.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 22.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35383| 29.6k|} janet_table_remove: 35408| 5.11k|Janet janet_table_remove(JanetTable *t, Janet key) { 35409| 5.11k| JanetKV *bucket = janet_table_find(t, key); 35410| 5.11k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 5.11k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 5.11k] | | ------------------ | | 807| 5.11k| ? 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.11k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.11k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.11k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.11k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.11k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35410:9): [True: 5.11k, False: 0] | Branch (35410:27): [True: 3.13k, False: 1.98k] ------------------ 35411| 3.13k| Janet ret = bucket->value; 35412| 3.13k| t->count--; 35413| 3.13k| t->deleted++; 35414| 3.13k| bucket->key = janet_wrap_nil(); ------------------ | | 831| 3.13k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 3.13k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 3.13k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.13k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35415| 3.13k| bucket->value = janet_wrap_false(); ------------------ | | 833| 3.13k|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 3.13k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 3.13k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.13k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35416| 3.13k| return ret; 35417| 3.13k| } else { 35418| 1.98k| return janet_wrap_nil(); ------------------ | | 831| 1.98k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.98k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.98k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.98k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35419| 1.98k| } 35420| 5.11k|} janet_table_put: 35423| 20.4M|void janet_table_put(JanetTable *t, Janet key, Janet value) { 35424| 20.4M| if (janet_checktype(key, JANET_NIL)) return; ------------------ | | 806| 20.4M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 9.91k, False: 20.4M] | | | Branch (806:6): [Folded, False: 20.4M] | | ------------------ | | 807| 20.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| 20.4M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 20.4M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 20.4M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 20.4M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 20.4M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35425| 20.4M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 806| 40.9M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 274k, False: 20.2M] | | | Branch (806:6): [True: 20.4M, Folded] | | ------------------ | | 807| 40.9M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 20.4M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 273k, False: 20.2M] | | | | | Branch (803:28): [True: 405, False: 20.2M] | | | | ------------------ | | ------------------ | | 808| 40.9M| : 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 (35425:47): [True: 405, False: 273k] ------------------ 35426| 20.4M| if (janet_checktype(value, JANET_NIL)) { ------------------ | | 806| 20.4M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 5.11k, False: 20.4M] | | | Branch (806:6): [Folded, False: 20.4M] | | ------------------ | | 807| 20.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| 20.4M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 20.4M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 20.4M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 20.4M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 20.4M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35427| 5.11k| janet_table_remove(t, key); 35428| 20.4M| } else { 35429| 20.4M| JanetKV *bucket = janet_table_find(t, key); 35430| 20.4M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 20.4M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 20.4M] | | ------------------ | | 807| 20.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| 20.4M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 20.4M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 20.4M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 20.4M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 20.4M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35430:13): [True: 20.4M, False: 0] | Branch (35430:31): [True: 173k, False: 20.2M] ------------------ 35431| 173k| bucket->value = value; 35432| 20.2M| } else { 35433| 20.2M| if (NULL == bucket || 2 * (t->count + t->deleted + 1) > t->capacity) { ------------------ | Branch (35433:17): [True: 0, False: 20.2M] | Branch (35433:35): [True: 2.21M, False: 18.0M] ------------------ 35434| 2.21M| janet_table_rehash(t, janet_tablen(2 * t->count + 2)); 35435| 2.21M| bucket = janet_table_find(t, key); 35436| 2.21M| } 35437| 20.2M| if (janet_checktype(bucket->value, JANET_BOOLEAN)) ------------------ | | 806| 20.2M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 20.2M] | | | Branch (806:6): [Folded, False: 20.2M] | | ------------------ | | 807| 20.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| 20.2M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 20.2M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 20.2M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 20.2M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 20.2M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35438| 0| --t->deleted; 35439| 20.2M| bucket->key = key; 35440| 20.2M| bucket->value = value; 35441| 20.2M| ++t->count; 35442| 20.2M| } 35443| 20.4M| } 35444| 20.4M|} janet_lib_table: 35653| 3.70k|void janet_lib_table(JanetTable *env) { 35654| 3.70k| JanetRegExt table_cfuns[] = { 35655| 3.70k| JANET_CORE_REG("table/new", cfun_table_new), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35656| 3.70k| JANET_CORE_REG("table/weak", cfun_table_weak), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35657| 3.70k| JANET_CORE_REG("table/weak-keys", cfun_table_weak_keys), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35658| 3.70k| JANET_CORE_REG("table/weak-values", cfun_table_weak_values), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35659| 3.70k| JANET_CORE_REG("table/to-struct", cfun_table_tostruct), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35660| 3.70k| JANET_CORE_REG("table/getproto", cfun_table_getproto), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35661| 3.70k| JANET_CORE_REG("table/setproto", cfun_table_setproto), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35662| 3.70k| JANET_CORE_REG("table/rawget", cfun_table_rawget), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35663| 3.70k| JANET_CORE_REG("table/clone", cfun_table_clone), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35664| 3.70k| JANET_CORE_REG("table/clear", cfun_table_clear), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35665| 3.70k| JANET_CORE_REG("table/proto-flatten", cfun_table_proto_flatten), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35666| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 35667| 3.70k| }; 35668| | janet_core_cfuns_ext(env, NULL, table_cfuns); 35669| 3.70k|} janet_tuple_begin: 35708| 3.13M|Janet *janet_tuple_begin(int32_t length) { 35709| 3.13M| size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet)); 35710| 3.13M| JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size); 35711| 3.13M| head->sm_line = -1; 35712| 3.13M| head->sm_column = -1; 35713| 3.13M| head->length = length; 35714| 3.13M| return (Janet *)(head->data); 35715| 3.13M|} janet_tuple_end: 35718| 3.12M|const Janet *janet_tuple_end(Janet *tuple) { 35719| 3.12M| janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1803| 3.12M|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 3.12M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1802| 3.12M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 3.12M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 35720| 3.12M| return (const Janet *)tuple; 35721| 3.12M|} janet_lib_tuple: 35828| 3.70k|void janet_lib_tuple(JanetTable *env) { 35829| 3.70k| JanetRegExt tuple_cfuns[] = { 35830| 3.70k| JANET_CORE_REG("tuple/brackets", cfun_tuple_brackets), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35831| 3.70k| JANET_CORE_REG("tuple/slice", cfun_tuple_slice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35832| 3.70k| JANET_CORE_REG("tuple/type", cfun_tuple_type), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35833| 3.70k| JANET_CORE_REG("tuple/sourcemap", cfun_tuple_sourcemap), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35834| 3.70k| JANET_CORE_REG("tuple/setmap", cfun_tuple_setmap), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35835| 3.70k| JANET_CORE_REG("tuple/join", cfun_tuple_join), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35836| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 35837| 3.70k| }; 35838| | janet_core_cfuns_ext(env, NULL, tuple_cfuns); 35839| 3.70k|} janet_hash_mix: 35965| 29.9M|uint32_t janet_hash_mix(uint32_t input, uint32_t more) { 35966| 29.9M| uint32_t mix1 = (more + 0x9e3779b9 + (input << 6) + (input >> 2)); 35967| 29.9M| return input ^ (0x9e3779b9 + (mix1 << 6) + (mix1 >> 2)); 35968| 29.9M|} janet_string_calchash: 35972| 18.6M|int32_t janet_string_calchash(const uint8_t *str, int32_t len) { 35973| 18.6M| if (NULL == str || len == 0) return 5381; ------------------ | Branch (35973:9): [True: 0, False: 18.6M] | Branch (35973:24): [True: 60.2k, False: 18.6M] ------------------ 35974| 18.6M| const uint8_t *end = str + len; 35975| 18.6M| uint32_t hash = 5381; 35976| 665M| while (str < end) ------------------ | Branch (35976:12): [True: 647M, False: 18.6M] ------------------ 35977| 647M| hash = (hash << 5) + hash + *str++; 35978| 18.6M| hash = janet_hash_mix(hash, (uint32_t) len); 35979| 18.6M| return (int32_t) hash; 35980| 18.6M|} janet_array_calchash: 36095| 3.12M|int32_t janet_array_calchash(const Janet *array, int32_t len) { 36096| 3.12M| const Janet *end = array + len; 36097| 3.12M| uint32_t hash = 33; 36098| 11.4M| while (array < end) { ------------------ | Branch (36098:12): [True: 8.37M, False: 3.12M] ------------------ 36099| 8.37M| hash = janet_hash_mix(hash, janet_hash(*array++)); 36100| 8.37M| } 36101| 3.12M| return (int32_t) hash; 36102| 3.12M|} janet_kv_calchash: 36105| 255k|int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) { 36106| 255k| const JanetKV *end = kvs + len; 36107| 255k| uint32_t hash = 33; 36108| 1.76M| while (kvs < end) { ------------------ | Branch (36108:12): [True: 1.50M, False: 255k] ------------------ 36109| 1.50M| hash = janet_hash_mix(hash, janet_hash(kvs->key)); 36110| 1.50M| hash = janet_hash_mix(hash, janet_hash(kvs->value)); 36111| 1.50M| kvs++; 36112| 1.50M| } 36113| 255k| return (int32_t) hash; 36114| 255k|} janet_tablen: 36118| 5.34M|int32_t janet_tablen(int32_t n) { 36119| 5.34M| if (n < 0) return 0; ------------------ | Branch (36119:9): [True: 0, False: 5.34M] ------------------ 36120| 5.34M| n |= n >> 1; 36121| 5.34M| n |= n >> 2; 36122| 5.34M| n |= n >> 4; 36123| 5.34M| n |= n >> 8; 36124| 5.34M| n |= n >> 16; 36125| 5.34M| return n == INT32_MAX ? INT32_MAX : n + 1; ------------------ | Branch (36125:12): [True: 0, False: 5.34M] ------------------ 36126| 5.34M|} safe_memcpy: 36129| 12.9M|void safe_memcpy(void *dest, const void *src, size_t len) { 36130| 12.9M| if (!len) return; ------------------ | Branch (36130:9): [True: 20.0k, False: 12.8M] ------------------ 36131| 12.8M| memcpy(dest, src, len); 36132| 12.8M|} janet_dict_find_deep: 36136| 216k|const JanetKV *janet_dict_find_deep(const JanetKV *buckets, int32_t cap, Janet key) { 36137| 216k| int32_t index = janet_maphash(cap, janet_hash(key)); ------------------ | | 396| 216k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 36138| 216k| int32_t i; 36139| 216k| const JanetKV *first_bucket = NULL; 36140| | /* Higher half */ 36141| 344k| for (i = index; i < cap; i++) { ------------------ | Branch (36141:21): [True: 341k, False: 3.01k] ------------------ 36142| 341k| const JanetKV *kv = buckets + i; 36143| 341k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 341k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 147k, False: 193k] | | | Branch (806:6): [Folded, False: 341k] | | ------------------ | | 807| 341k| ? 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| 341k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 341k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 341k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 341k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 341k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36144| 147k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 147k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 117k, False: 30.3k] | | | Branch (806:6): [Folded, False: 147k] | | ------------------ | | 807| 147k| ? 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| 147k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 147k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 147k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 147k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 147k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36145| 117k| return kv; 36146| 117k| } else if (NULL == first_bucket) { ------------------ | Branch (36146:24): [True: 15.6k, False: 14.6k] ------------------ 36147| 15.6k| first_bucket = kv; 36148| 15.6k| } 36149| 193k| } else if (janet_bitwise_same(kv->key, key) || janet_equals(kv->key, key)) { ------------------ | | 401| 386k|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 193k|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 193k|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 62.5k, False: 130k] | | ------------------ ------------------ | Branch (36149:56): [True: 33.5k, False: 97.3k] ------------------ 36150| 96.0k| return buckets + i; 36151| 96.0k| } 36152| 341k| } 36153| | /* Lower half */ 36154| 10.3k| for (i = 0; i < index; i++) { ------------------ | Branch (36154:17): [True: 10.3k, False: 0] ------------------ 36155| 10.3k| const JanetKV *kv = buckets + i; 36156| 10.3k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 10.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.34k, False: 7.96k] | | | Branch (806:6): [Folded, False: 10.3k] | | ------------------ | | 807| 10.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| 10.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 10.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 10.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 10.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 10.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36157| 2.34k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 2.34k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.74k, False: 599] | | | Branch (806:6): [Folded, False: 2.34k] | | ------------------ | | 807| 2.34k| ? 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.34k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.34k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.34k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.34k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.34k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36158| 1.74k| return kv; 36159| 1.74k| } else if (NULL == first_bucket) { ------------------ | Branch (36159:24): [True: 226, False: 373] ------------------ 36160| 226| first_bucket = kv; 36161| 226| } 36162| 7.96k| } else if (janet_bitwise_same(kv->key, key) || janet_equals(kv->key, key)) { ------------------ | | 401| 15.9k|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 7.96k|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 7.96k|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 669, False: 7.29k] | | ------------------ ------------------ | Branch (36162:56): [True: 599, False: 6.69k] ------------------ 36163| 1.26k| return buckets + i; 36164| 1.26k| } 36165| 10.3k| } 36166| 0| return first_bucket; 36167| 3.01k|} janet_dict_find_keyword: 36173| 29.6k| const uint8_t *cstr, int32_t cstr_len) { 36174| 29.6k| int32_t hash = janet_string_calchash(cstr, cstr_len); 36175| 29.6k| int32_t index = janet_maphash(cap, hash); ------------------ | | 396| 29.6k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 36176| 29.6k| int32_t i; 36177| 29.6k| const JanetKV *first_bucket = NULL; 36178| | /* Higher half */ 36179| 44.4k| for (i = index; i < cap; i++) { ------------------ | Branch (36179:21): [True: 44.4k, False: 0] ------------------ 36180| 44.4k| const JanetKV *kv = buckets + i; 36181| 44.4k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 44.4k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 22.2k, False: 22.2k] | | | Branch (806:6): [Folded, False: 44.4k] | | ------------------ | | 807| 44.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| 44.4k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 44.4k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 44.4k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 44.4k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 44.4k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36182| 22.2k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 22.2k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 22.2k, False: 0] | | | Branch (806:6): [Folded, False: 22.2k] | | ------------------ | | 807| 22.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| 22.2k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 22.2k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 22.2k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 22.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 22.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36183| 22.2k| return kv; 36184| 22.2k| } else if (NULL == first_bucket) { ------------------ | Branch (36184:24): [True: 0, False: 0] ------------------ 36185| 0| first_bucket = kv; 36186| 0| } 36187| 22.2k| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 806| 22.2k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 22.2k, False: 0] | | | Branch (806:6): [Folded, False: 22.2k] | | ------------------ | | 807| 22.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| 22.2k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 22.2k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 22.2k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 22.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 22.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36188| | /* Works for symbol and keyword, too */ 36189| 22.2k| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 863| 22.2k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 36190| 22.2k| int32_t len = janet_string_length(str); ------------------ | | 1813| 22.2k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 22.2k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36191| 22.2k| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1814| 44.4k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 22.2k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (36191:17): [True: 7.41k, False: 14.8k] | Branch (36191:51): [True: 7.41k, False: 0] | Branch (36191:70): [True: 7.41k, False: 0] ------------------ 36192| 7.41k| return buckets + i; 36193| 7.41k| } 36194| 22.2k| } 36195| 44.4k| } 36196| | /* Lower half */ 36197| 0| for (i = 0; i < index; i++) { ------------------ | Branch (36197:17): [True: 0, False: 0] ------------------ 36198| 0| const JanetKV *kv = buckets + i; 36199| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36200| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36201| 0| return kv; 36202| 0| } else if (NULL == first_bucket) { ------------------ | Branch (36202:24): [True: 0, False: 0] ------------------ 36203| 0| first_bucket = kv; 36204| 0| } 36205| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36206| | /* Works for symbol and keyword, too */ 36207| 0| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 863| 0|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 36208| 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))) | | ------------------ ------------------ 36209| 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 (36209:17): [True: 0, False: 0] | Branch (36209:51): [True: 0, False: 0] | Branch (36209:70): [True: 0, False: 0] ------------------ 36210| 0| return buckets + i; 36211| 0| } 36212| 0| } 36213| 0| } 36214| 0| return first_bucket; 36215| 0|} janet_registry_put: 36340| 1.30M| int32_t source_line) { 36341| 1.30M| if (janet_vm.registry_count == janet_vm.registry_cap) { ------------------ | Branch (36341:9): [True: 3.70k, False: 1.30M] ------------------ 36342| 3.70k| size_t newcap = (janet_vm.registry_count + 1) * 2; 36343| | /* Size it nicely with core by default */ 36344| 3.70k| if (newcap < 512) { ------------------ | Branch (36344:13): [True: 3.70k, False: 0] ------------------ 36345| 3.70k| newcap = 512; 36346| 3.70k| } 36347| 3.70k| void *newmem = janet_realloc(janet_vm.registry, newcap * sizeof(JanetCFunRegistry)); ------------------ | | 2409| 3.70k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 36348| 3.70k| if (NULL == newmem) { ------------------ | Branch (36348:13): [True: 0, False: 3.70k] ------------------ 36349| 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] | | ------------------ ------------------ 36350| 0| } 36351| 3.70k| janet_vm.registry = newmem; 36352| 3.70k| janet_vm.registry_cap = newcap; 36353| 3.70k| } 36354| 1.30M| JanetCFunRegistry value = { 36355| 1.30M| key, 36356| 1.30M| name, 36357| 1.30M| name_prefix, 36358| 1.30M| source_file, 36359| 1.30M| source_line 36360| 1.30M| }; 36361| 1.30M| janet_vm.registry[janet_vm.registry_count++] = value; 36362| 1.30M| janet_vm.registry_dirty = 1; 36363| 1.30M|} janet_registry_get: 36365| 2|JanetCFunRegistry *janet_registry_get(JanetCFunction key) { 36366| 2| if (janet_vm.registry_dirty) { ------------------ | Branch (36366:9): [True: 2, False: 0] ------------------ 36367| 2| janet_registry_sort(); 36368| 2| } 36369| 407| for (size_t i = 0; i < janet_vm.registry_count; i++) { ------------------ | Branch (36369:24): [True: 407, False: 0] ------------------ 36370| 407| if (janet_vm.registry[i].cfun == key) { ------------------ | Branch (36370:13): [True: 2, False: 405] ------------------ 36371| 2| return janet_vm.registry + i; 36372| 2| } 36373| 407| } 36374| 0| JanetCFunRegistry *lo = janet_vm.registry; 36375| 0| JanetCFunRegistry *hi = lo + janet_vm.registry_count; 36376| 0| while (lo < hi) { ------------------ | Branch (36376:12): [True: 0, False: 0] ------------------ 36377| 0| JanetCFunRegistry *mid = lo + (hi - lo) / 2; 36378| 0| if (mid->cfun == key) { ------------------ | Branch (36378:13): [True: 0, False: 0] ------------------ 36379| 0| return mid; 36380| 0| } 36381| 0| if ((void *)(mid->cfun) > (void *)(key)) { ------------------ | Branch (36381:13): [True: 0, False: 0] ------------------ 36382| 0| hi = mid; 36383| 0| } else { 36384| 0| lo = mid + 1; 36385| 0| } 36386| 0| } 36387| 0| return NULL; 36388| 0|} janet_register_abstract_type: 36489| 33.3k|void janet_register_abstract_type(const JanetAbstractType *at) { 36490| 33.3k| janet_check_pointer_align((void *) at); 36491| 33.3k| Janet sym = janet_csymbolv(at->name); ------------------ | | 1837| 33.3k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 33.3k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 33.3k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 33.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 33.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36492| 33.3k| Janet check = janet_table_get(janet_vm.abstract_registry, sym); 36493| 33.3k| if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 806| 66.7k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 33.3k] | | ------------------ | | 807| 66.7k| ? 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| 66.7k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 33.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 33.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 33.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 33.3k|#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 (36493:9): [True: 0, False: 33.3k] | Branch (36493:47): [True: 0, False: 0] ------------------ 36494| 0| janet_panicf("cannot register abstract type %s, " 36495| 0| "a type with the same name exists", at->name); 36496| 0| } 36497| 33.3k| janet_table_put(janet_vm.abstract_registry, sym, janet_wrap_pointer((void *) at)); ------------------ | | 854| 33.3k|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 825| 33.3k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 33.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 33.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36498| 33.3k|} janet_get_abstract_type: 36500| 65|const JanetAbstractType *janet_get_abstract_type(Janet key) { 36501| 65| Janet wrapped = janet_table_get(janet_vm.abstract_registry, key); 36502| 65| if (janet_checktype(wrapped, JANET_NIL)) { ------------------ | | 806| 65| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 65, False: 0] | | | Branch (806:6): [Folded, False: 65] | | ------------------ | | 807| 65| ? 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| 65| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 65| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 65|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 65|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 65|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36503| 65| return NULL; 36504| 65| } 36505| 0| return (JanetAbstractType *)(janet_unwrap_pointer(wrapped)); ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ 36506| 65|} janet_core_def_sm: 36509| 11.1k|void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl) { 36510| 11.1k| (void) sf; 36511| 11.1k| (void) sl; 36512| 11.1k| (void) p; 36513| 11.1k| Janet key = janet_csymbolv(name); ------------------ | | 1837| 11.1k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 11.1k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 11.1k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 11.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 11.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36514| 11.1k| janet_table_put(env, key, x); 36515| 11.1k| if (janet_checktype(x, JANET_CFUNCTION)) { ------------------ | | 806| 11.1k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 11.1k] | | | Branch (806:6): [Folded, False: 11.1k] | | ------------------ | | 807| 11.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| 11.1k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 11.1k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 11.1k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 11.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 11.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36516| 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)) ------------------ 36517| 0| } 36518| 11.1k|} janet_core_cfuns_ext: 36520| 81.5k|void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) { 36521| 81.5k| (void) regprefix; 36522| 1.38M| while (cfuns->name) { ------------------ | Branch (36522:12): [True: 1.30M, False: 81.5k] ------------------ 36523| 1.30M| janet_check_pointer_align(cfuns->cfun); 36524| 1.30M| Janet fun = janet_wrap_cfunction(cfuns->cfun); ------------------ | | 853| 1.30M|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 825| 1.30M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.30M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.30M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36525| 1.30M| janet_table_put(env, janet_csymbolv(cfuns->name), fun); ------------------ | | 1837| 1.30M|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 1.30M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 1.30M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.30M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.30M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36526| 1.30M| janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line); 36527| 1.30M| cfuns++; 36528| 1.30M| } 36529| 81.5k|} janet_binding_from_entry: 36532| 7.41k|JanetBinding janet_binding_from_entry(Janet entry) { 36533| 7.41k| JanetTable *entry_table; 36534| 7.41k| JanetBinding binding = { 36535| 7.41k| JANET_BINDING_NONE, 36536| 7.41k| janet_wrap_nil(), ------------------ | | 831| 7.41k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 7.41k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 7.41k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.41k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36537| 7.41k| JANET_BINDING_DEP_NONE 36538| 7.41k| }; 36539| | 36540| | /* Check environment for entry */ 36541| 7.41k| if (!janet_checktype(entry, JANET_TABLE)) ------------------ | | 806| 7.41k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 7.41k] | | ------------------ | | 807| 7.41k| ? 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.41k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.41k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.41k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.41k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.41k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36541:9): [True: 0, False: 7.41k] ------------------ 36542| 0| return binding; 36543| 7.41k| entry_table = janet_unwrap_table(entry); ------------------ | | 861| 7.41k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36544| | 36545| 7.41k| Janet deprecate = janet_table_get_keyword(entry_table, "deprecated"); 36546| 7.41k| int macro = janet_truthy(janet_table_get_keyword(entry_table, "macro")); ------------------ | | 818| 7.41k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 14.8k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 7.41k] | | | | ------------------ | | | | 807| 14.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| 14.8k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 7.41k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 7.41k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 7.41k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 7.41k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 7.41k] | | ------------------ | | 819| 7.41k| (!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] | | ------------------ ------------------ 36547| 7.41k| Janet value = janet_table_get_keyword(entry_table, "value"); 36548| 7.41k| Janet ref = janet_table_get_keyword(entry_table, "ref"); 36549| | 36550| 7.41k| if (janet_checktype(deprecate, JANET_KEYWORD)) { ------------------ | | 806| 7.41k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 7.41k] | | | Branch (806:6): [Folded, False: 7.41k] | | ------------------ | | 807| 7.41k| ? 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.41k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.41k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.41k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.41k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.41k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36551| 0| JanetKeyword depkw = janet_unwrap_keyword(deprecate); ------------------ | | 865| 0|#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) ------------------ 36552| 0| if (!janet_cstrcmp(depkw, "relaxed")) { ------------------ | Branch (36552:13): [True: 0, False: 0] ------------------ 36553| 0| binding.deprecation = JANET_BINDING_DEP_RELAXED; 36554| 0| } else if (!janet_cstrcmp(depkw, "normal")) { ------------------ | Branch (36554:20): [True: 0, False: 0] ------------------ 36555| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 36556| 0| } else if (!janet_cstrcmp(depkw, "strict")) { ------------------ | Branch (36556:20): [True: 0, False: 0] ------------------ 36557| 0| binding.deprecation = JANET_BINDING_DEP_STRICT; 36558| 0| } 36559| 7.41k| } else if (!janet_checktype(deprecate, JANET_NIL)) { ------------------ | | 806| 7.41k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 7.41k] | | ------------------ | | 807| 7.41k| ? 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.41k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.41k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.41k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.41k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.41k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36559:16): [True: 0, False: 7.41k] ------------------ 36560| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 36561| 0| } 36562| | 36563| 7.41k| int ref_is_valid = janet_checktype(ref, JANET_ARRAY); ------------------ | | 806| 7.41k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 7.41k] | | ------------------ | | 807| 7.41k| ? 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.41k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.41k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.41k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.41k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.41k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36564| 7.41k| int redef = ref_is_valid && janet_truthy(janet_table_get_keyword(entry_table, "redef")); ------------------ | | 818| 7.41k| (!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| 7.41k| (!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 (36564:17): [True: 0, False: 7.41k] ------------------ 36565| | 36566| 7.41k| if (macro) { ------------------ | Branch (36566:9): [True: 0, False: 7.41k] ------------------ 36567| 0| binding.value = redef ? ref : value; ------------------ | Branch (36567:25): [True: 0, False: 0] ------------------ 36568| 0| binding.type = redef ? JANET_BINDING_DYNAMIC_MACRO : JANET_BINDING_MACRO; ------------------ | Branch (36568:24): [True: 0, False: 0] ------------------ 36569| 0| return binding; 36570| 0| } 36571| | 36572| 7.41k| if (ref_is_valid) { ------------------ | Branch (36572:9): [True: 0, False: 7.41k] ------------------ 36573| 0| binding.value = ref; 36574| 0| binding.type = redef ? JANET_BINDING_DYNAMIC_DEF : JANET_BINDING_VAR; ------------------ | Branch (36574:24): [True: 0, False: 0] ------------------ 36575| 7.41k| } else { 36576| 7.41k| binding.value = value; 36577| 7.41k| binding.type = JANET_BINDING_DEF; 36578| 7.41k| } 36579| | 36580| 7.41k| return binding; 36581| 7.41k|} janet_resolve_ext: 36636| 7.41k|JanetBinding janet_resolve_ext(JanetTable *env, const uint8_t *sym) { 36637| 7.41k| Janet entry = janet_table_get(env, janet_wrap_symbol(sym)); ------------------ | | 849| 7.41k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 7.41k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 7.41k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.41k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36638| 7.41k| return janet_binding_from_entry(entry); 36639| 7.41k|} janet_resolve: 36641| 7.41k|JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out) { 36642| 7.41k| JanetBinding binding = janet_resolve_ext(env, sym); 36643| 7.41k| if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) { ------------------ | Branch (36643:9): [True: 0, False: 7.41k] | Branch (36643:54): [True: 0, False: 7.41k] ------------------ 36644| 0| *out = janet_array_peek(janet_unwrap_array(binding.value)); ------------------ | | 860| 0|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 36645| 7.41k| } else { 36646| 7.41k| *out = binding.value; 36647| 7.41k| } 36648| 7.41k| return binding.type; 36649| 7.41k|} array_allocate: 37062| 12.5M|void *array_allocate(size_t element_size, int32_t count) { 37063| 12.5M| if (count < 0) return NULL; ------------------ | Branch (37063:9): [True: 0, False: 12.5M] ------------------ 37064| 12.5M| if ((size_t) count > (SIZE_MAX / element_size)) return NULL; ------------------ | Branch (37064:9): [True: 0, False: 12.5M] ------------------ 37065| 12.5M| return janet_malloc(element_size * count); ------------------ | | 2406| 12.5M|#define janet_malloc(X) malloc((X)) ------------------ 37066| 12.5M|} janet_equals: 37368| 138k|int janet_equals(Janet x, Janet y) { 37369| 138k| if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 138k| (isnan((x).number) \ | | 796| 138k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 138k| : JANET_NUMBER) ------------------ if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 138k| (isnan((x).number) \ | | 796| 138k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 138k| : JANET_NUMBER) ------------------ | Branch (37369:9): [True: 96.5k, False: 41.6k] | Branch (37369:9): [True: 69.7k, False: 68.4k] | Branch (37369:26): [True: 71.2k, False: 66.9k] ------------------ 37370| 68.4k| if (janet_checktypes(x, JANET_TFLAG_TUPLE | JANET_TFLAG_STRUCT)) return janet_equals_containers(x, y); ------------------ | | 969| 68.4k|#define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps)) | | ------------------ | | | | 795| 68.4k| (isnan((x).number) \ | | | | 796| 68.4k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | | | 797| 68.4k| : JANET_NUMBER) | | ------------------ | | | Branch (969:34): [True: 38.9k, False: 29.5k] | | ------------------ ------------------ | Branch (37370:9): [True: 41.6k, False: 26.8k] ------------------ 37371| 29.5k| return janet_equals_leaf(x, y); 37372| 68.4k|} janet_hash: 37384| 20.0M|int32_t janet_hash(Janet x) { 37385| 20.0M| int32_t hash = 0; 37386| 20.0M| switch (janet_type(x)) { ------------------ | | 795| 20.0M| (isnan((x).number) \ | | 796| 20.0M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 20.0M| : JANET_NUMBER) ------------------ | Branch (37386:13): [True: 13.0M, False: 6.99M] ------------------ 37387| 2.17M| case JANET_NIL: ------------------ | Branch (37387:9): [True: 2.17M, False: 17.8M] ------------------ 37388| 2.17M| hash = 0; 37389| 2.17M| break; 37390| 158k| case JANET_BOOLEAN: ------------------ | Branch (37390:9): [True: 158k, False: 19.8M] ------------------ 37391| 158k| hash = janet_unwrap_boolean(x); ------------------ | | 838| 158k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 37392| 158k| break; 37393| 3.08M| case JANET_STRING: ------------------ | Branch (37393:9): [True: 3.08M, False: 16.9M] ------------------ 37394| 3.26M| case JANET_SYMBOL: ------------------ | Branch (37394:9): [True: 174k, False: 19.8M] ------------------ 37395| 3.60M| case JANET_KEYWORD: ------------------ | Branch (37395:9): [True: 340k, False: 19.6M] ------------------ 37396| 3.60M| hash = janet_string_hash(janet_unwrap_string(x)); ------------------ | | 1814| 3.60M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 3.60M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 37397| 3.60M| break; 37398| 341k| case JANET_TUPLE: ------------------ | Branch (37398:9): [True: 341k, False: 19.6M] ------------------ 37399| 341k| hash = janet_tuple_hash(janet_unwrap_tuple(x)); ------------------ | | 1803| 341k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 341k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 37400| 341k| uint32_t inc = (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0; ------------------ | | 1806| 341k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 341k|#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| 341k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (37400:28): [True: 302k, False: 39.5k] ------------------ 37401| 341k| hash = (int32_t)((uint32_t)hash + inc); /* avoid overflow undefined behavior */ 37402| 341k| break; 37403| 249k| case JANET_STRUCT: ------------------ | Branch (37403:9): [True: 249k, False: 19.7M] ------------------ 37404| 249k| hash = janet_struct_hash(janet_unwrap_struct(x)); ------------------ | | 1850| 249k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 249k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37405| 249k| break; 37406| 6.99M| case JANET_NUMBER: { ------------------ | Branch (37406:9): [True: 6.99M, False: 13.0M] ------------------ 37407| 6.99M| union { 37408| 6.99M| double d; 37409| 6.99M| uint64_t u; 37410| 6.99M| } as; 37411| 6.99M| as.d = janet_unwrap_number(x); ------------------ | | 839| 6.99M|#define janet_unwrap_number(x) ((x).number) ------------------ 37412| 6.99M| as.d += 0.0; /* normalize negative 0 */ 37413| 6.99M| as.u = murmur64(as.u); 37414| 6.99M| uint32_t hi = (uint32_t)(as.u >> 32); 37415| 6.99M| hash = (int32_t)hi; 37416| 6.99M| break; 37417| 3.26M| } 37418| 22.2k| case JANET_ABSTRACT: { ------------------ | Branch (37418:9): [True: 22.2k, False: 19.9M] ------------------ 37419| 22.2k| JanetAbstract xx = janet_unwrap_abstract(x); ------------------ | | 866| 22.2k|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37420| 22.2k| const JanetAbstractType *at = janet_abstract_type(xx); ------------------ | | 1899| 22.2k|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 22.2k|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37421| 22.2k| if (at->hash != NULL) { ------------------ | Branch (37421:17): [True: 0, False: 22.2k] ------------------ 37422| 0| hash = at->hash(xx, janet_abstract_size(xx)); ------------------ | | 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))) | | ------------------ ------------------ 37423| 0| break; 37424| 0| } 37425| 22.2k| } 37426| | /* fallthrough */ 37427| 6.49M| default: ------------------ | Branch (37427:9): [True: 6.47M, False: 13.5M] ------------------ 37428| 6.49M| if (sizeof(double) == sizeof(void *)) { ------------------ | Branch (37428:17): [True: 6.49M, Folded] ------------------ 37429| | /* Assuming 8 byte pointer (8 byte aligned) */ 37430| 6.49M| uint64_t i = murmur64(janet_u64(x)); ------------------ | | 788| 6.49M|#define janet_u64(x) ((x).u64) ------------------ 37431| 6.49M| hash = (int32_t)(i >> 32); 37432| 6.49M| } else { 37433| | /* Assuming 4 byte pointer (or smaller) */ 37434| 0| uintptr_t diff = (uintptr_t) janet_unwrap_pointer(x); ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ 37435| 0| uint32_t hilo = (uint32_t) diff * 2654435769u; 37436| 0| hash = (int32_t)((hilo << 16) | (hilo >> 16)); 37437| 0| } 37438| 6.49M| break; 37439| 20.0M| } 37440| 20.0M| return hash; 37441| 20.0M|} janet_compare: 37446| 477k|int janet_compare(Janet x, Janet y) { 37447| 477k| janet_vm.traversal = janet_vm.traversal_base; 37448| 477k| int status; 37449| 610k| do { 37450| 610k| JanetType tx = janet_type(x); ------------------ | | 795| 610k| (isnan((x).number) \ | | 796| 610k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 610k| : JANET_NUMBER) ------------------ | Branch (37450:24): [True: 248k, False: 362k] ------------------ 37451| 610k| JanetType ty = janet_type(y); ------------------ | | 795| 610k| (isnan((x).number) \ | | 796| 610k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 610k| : JANET_NUMBER) ------------------ | Branch (37451:24): [True: 262k, False: 348k] ------------------ 37452| 610k| if (tx != ty) return tx < ty ? -1 : 1; ------------------ | Branch (37452:13): [True: 24.1k, False: 586k] | Branch (37452:30): [True: 18.9k, False: 5.13k] ------------------ 37453| 586k| switch (tx) { 37454| 115k| case JANET_NIL: ------------------ | Branch (37454:13): [True: 115k, False: 470k] ------------------ 37455| 115k| break; 37456| 13.0k| case JANET_BOOLEAN: { ------------------ | Branch (37456:13): [True: 13.0k, False: 573k] ------------------ 37457| 13.0k| int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 838| 13.0k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 838| 13.0k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 37458| 13.0k| if (diff) return diff; ------------------ | Branch (37458:21): [True: 0, False: 13.0k] ------------------ 37459| 13.0k| break; 37460| 13.0k| } 37461| 343k| case JANET_NUMBER: { ------------------ | Branch (37461:13): [True: 343k, False: 242k] ------------------ 37462| 343k| double xx = janet_unwrap_number(x); ------------------ | | 839| 343k|#define janet_unwrap_number(x) ((x).number) ------------------ 37463| 343k| double yy = janet_unwrap_number(y); ------------------ | | 839| 343k|#define janet_unwrap_number(x) ((x).number) ------------------ 37464| 343k| if (xx == yy) { ------------------ | Branch (37464:21): [True: 343k, False: 519] ------------------ 37465| 343k| break; 37466| 343k| } else { 37467| 519| return (xx < yy) ? -1 : 1; ------------------ | Branch (37467:28): [True: 0, False: 519] ------------------ 37468| 519| } 37469| 343k| } 37470| 1.32k| case JANET_STRING: ------------------ | Branch (37470:13): [True: 1.32k, False: 585k] ------------------ 37471| 4.55k| case JANET_SYMBOL: ------------------ | Branch (37471:13): [True: 3.23k, False: 583k] ------------------ 37472| 5.45k| case JANET_KEYWORD: { ------------------ | Branch (37472:13): [True: 902, False: 585k] ------------------ 37473| 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)) ------------------ 37474| 5.45k| if (diff) return diff; ------------------ | Branch (37474:21): [True: 333, False: 5.12k] ------------------ 37475| 5.12k| break; 37476| 5.45k| } 37477| 5.12k| case JANET_ABSTRACT: { ------------------ | Branch (37477:13): [True: 0, False: 586k] ------------------ 37478| 0| int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37479| 0| if (diff) return diff; ------------------ | Branch (37479:21): [True: 0, False: 0] ------------------ 37480| 0| break; 37481| 0| } 37482| 1.19k| default: { ------------------ | Branch (37482:13): [True: 1.19k, False: 585k] ------------------ 37483| 1.19k| if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 867| 1.19k|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 867| 1.19k|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (37483:21): [True: 1.19k, False: 0] ------------------ 37484| 1.19k| break; 37485| 1.19k| } else { 37486| 0| return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (37486:28): [True: 0, False: 0] ------------------ 37487| 0| } 37488| 1.19k| } 37489| 58.3k| case JANET_TUPLE: { ------------------ | Branch (37489:13): [True: 58.3k, False: 528k] ------------------ 37490| 58.3k| const Janet *lhs = janet_unwrap_tuple(x); ------------------ | | 858| 58.3k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37491| 58.3k| const Janet *rhs = janet_unwrap_tuple(y); ------------------ | | 858| 58.3k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37492| 58.3k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1798| 58.3k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1806| 58.3k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 58.3k|#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| 58.3k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 58.3k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37492:21): [True: 0, False: 58.3k] ------------------ 37493| 0| return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1806| 0|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 0|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1798| 0|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (37493:28): [True: 0, False: 0] ------------------ 37494| 0| } 37495| 58.3k| push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1800| 58.3k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1800| 58.3k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 37496| 58.3k| break; 37497| 58.3k| } 37498| 49.0k| case JANET_STRUCT: { ------------------ | Branch (37498:13): [True: 49.0k, False: 537k] ------------------ 37499| 49.0k| const JanetKV *lhs = janet_unwrap_struct(x); ------------------ | | 857| 49.0k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37500| 49.0k| const JanetKV *rhs = janet_unwrap_struct(y); ------------------ | | 857| 49.0k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37501| 49.0k| int32_t llen = janet_struct_capacity(lhs); ------------------ | | 1849| 49.0k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 49.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37502| 49.0k| int32_t rlen = janet_struct_capacity(rhs); ------------------ | | 1849| 49.0k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 49.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37503| 49.0k| int32_t lhash = janet_struct_hash(lhs); ------------------ | | 1850| 49.0k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 49.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37504| 49.0k| int32_t rhash = janet_struct_hash(rhs); ------------------ | | 1850| 49.0k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 49.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37505| 49.0k| if (llen < rlen) return -1; ------------------ | Branch (37505:21): [True: 0, False: 49.0k] ------------------ 37506| 49.0k| if (llen > rlen) return 1; ------------------ | Branch (37506:21): [True: 0, False: 49.0k] ------------------ 37507| 49.0k| if (lhash < rhash) return -1; ------------------ | Branch (37507:21): [True: 0, False: 49.0k] ------------------ 37508| 49.0k| if (lhash > rhash) return 1; ------------------ | Branch (37508:21): [True: 0, False: 49.0k] ------------------ 37509| 49.0k| push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1846| 49.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1846| 49.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 37510| 49.0k| break; 37511| 49.0k| } 37512| 586k| } 37513| 586k| } while (!(status = traversal_next(&x, &y))); ------------------ | Branch (37513:14): [True: 133k, False: 452k] ------------------ 37514| 452k| return status - 2; 37515| 477k|} janet_v_grow: 37919| 131k|void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) { 37920| 131k| int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0; ------------------ | | 765| 114k|#define janet_v__cap(v) janet_v__raw(v)[0] | | ------------------ | | | | 764| 114k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ | Branch (37920:23): [True: 114k, False: 16.8k] ------------------ 37921| 131k| int32_t min_needed = janet_v_count(v) + increment; ------------------ | | 759| 131k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 114k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 114k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 114k, False: 16.8k] | | ------------------ ------------------ 37922| 131k| int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed; ------------------ | Branch (37922:17): [True: 100k, False: 30.9k] ------------------ 37923| 131k| size_t newsize = ((size_t) itemsize) * m + sizeof(int32_t) * 2; 37924| 131k| int32_t *p = (int32_t *) janet_srealloc(v ? janet_v__raw(v) : 0, newsize); ------------------ | | 764| 114k|#define janet_v__raw(v) ((int32_t *)(v) - 2) ------------------ | Branch (37924:45): [True: 114k, False: 16.8k] ------------------ 37925| 131k| if (!v) p[1] = 0; ------------------ | Branch (37925:9): [True: 16.8k, False: 114k] ------------------ 37926| 131k| p[0] = m; 37927| 131k| return p + 2; 37928| 131k|} janet_try_init: 39435| 3.70k|void janet_try_init(JanetTryState *state) { 39436| 3.70k| state->stackn = janet_vm.stackn++; 39437| 3.70k| state->gc_handle = janet_vm.gc_suspend; 39438| 3.70k| state->vm_fiber = janet_vm.fiber; 39439| 3.70k| state->vm_jmp_buf = janet_vm.signal_buf; 39440| 3.70k| state->vm_return_reg = janet_vm.return_reg; 39441| 3.70k| state->coerce_error = janet_vm.coerce_error; 39442| 3.70k| janet_vm.return_reg = &(state->payload); 39443| 3.70k| janet_vm.signal_buf = &(state->buf); 39444| 3.70k| janet_vm.coerce_error = 0; 39445| 3.70k|} janet_restore: 39447| 3.70k|void janet_restore(JanetTryState *state) { 39448| 3.70k| janet_vm.stackn = state->stackn; 39449| 3.70k| janet_vm.gc_suspend = state->gc_handle; 39450| 3.70k| janet_vm.fiber = state->vm_fiber; 39451| 3.70k| janet_vm.signal_buf = state->vm_jmp_buf; 39452| 3.70k| janet_vm.return_reg = state->vm_return_reg; 39453| 3.70k| janet_vm.coerce_error = state->coerce_error; 39454| 3.70k|} janet_init: 39609| 3.70k|int janet_init(void) { 39610| | 39611| | /* Garbage collection */ 39612| 3.70k| janet_vm.blocks = NULL; 39613| 3.70k| janet_vm.weak_blocks = NULL; 39614| 3.70k| janet_vm.next_collection = 0; 39615| 3.70k| janet_vm.gc_interval = 0x400000; 39616| 3.70k| janet_vm.block_count = 0; 39617| 3.70k| janet_vm.gc_mark_phase = 0; 39618| | 39619| 3.70k| janet_symcache_init(); 39620| | 39621| | /* Initialize gc roots */ 39622| 3.70k| janet_vm.roots = NULL; 39623| 3.70k| janet_vm.root_count = 0; 39624| 3.70k| janet_vm.root_capacity = 0; 39625| | 39626| | /* Scratch memory */ 39627| 3.70k| janet_vm.user = NULL; 39628| 3.70k| janet_vm.scratch_mem = NULL; 39629| 3.70k| janet_vm.scratch_len = 0; 39630| 3.70k| janet_vm.scratch_cap = 0; 39631| | 39632| | /* Sandbox flags */ 39633| 3.70k| janet_vm.sandbox_flags = 0; 39634| | 39635| | /* Initialize registry */ 39636| 3.70k| janet_vm.registry = NULL; 39637| 3.70k| janet_vm.registry_cap = 0; 39638| 3.70k| janet_vm.registry_count = 0; 39639| 3.70k| janet_vm.registry_dirty = 0; 39640| | 39641| | /* Initialize abstract registry */ 39642| 3.70k| janet_vm.abstract_registry = janet_table(0); 39643| 3.70k| janet_gcroot(janet_wrap_table(janet_vm.abstract_registry)); ------------------ | | 846| 3.70k|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 3.70k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 3.70k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.70k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39644| | 39645| | /* Traversal */ 39646| 3.70k| janet_vm.traversal = NULL; 39647| 3.70k| janet_vm.traversal_base = NULL; 39648| 3.70k| janet_vm.traversal_top = NULL; 39649| | 39650| | /* Core env */ 39651| 3.70k| janet_vm.core_env = NULL; 39652| | 39653| | /* Auto suspension */ 39654| 3.70k| janet_vm.auto_suspend = 0; 39655| | 39656| | /* Dynamic bindings */ 39657| 3.70k| janet_vm.top_dyns = NULL; 39658| | 39659| | /* Seed RNG */ 39660| 3.70k| janet_rng_seed(janet_default_rng(), 0); 39661| | 39662| | /* Fibers */ 39663| 3.70k| janet_vm.fiber = NULL; 39664| 3.70k| janet_vm.root_fiber = NULL; 39665| 3.70k| janet_vm.stackn = 0; 39666| | 39667| 3.70k|#ifdef JANET_EV 39668| 3.70k| janet_ev_init(); 39669| 3.70k|#endif 39670| 3.70k|#ifdef JANET_NET 39671| 3.70k| janet_net_init(); 39672| 3.70k|#endif 39673| 3.70k| return 0; 39674| 3.70k|} janet_deinit: 39689| 3.70k|void janet_deinit(void) { 39690| 3.70k| janet_clear_memory(); 39691| 3.70k| janet_symcache_deinit(); 39692| 3.70k| janet_free(janet_vm.roots); ------------------ | | 2415| 3.70k|#define janet_free(X) free((X)) ------------------ 39693| 3.70k| janet_vm.roots = NULL; 39694| 3.70k| janet_vm.root_count = 0; 39695| 3.70k| janet_vm.root_capacity = 0; 39696| 3.70k| janet_vm.abstract_registry = NULL; 39697| 3.70k| janet_vm.core_env = NULL; 39698| 3.70k| janet_vm.top_dyns = NULL; 39699| 3.70k| janet_vm.user = NULL; 39700| 3.70k| janet_free(janet_vm.traversal_base); ------------------ | | 2415| 3.70k|#define janet_free(X) free((X)) ------------------ 39701| 3.70k| janet_vm.fiber = NULL; 39702| 3.70k| janet_vm.root_fiber = NULL; 39703| 3.70k| janet_free(janet_vm.registry); ------------------ | | 2415| 3.70k|#define janet_free(X) free((X)) ------------------ 39704| | janet_vm.registry = NULL; 39705| 3.70k|#ifdef JANET_EV 39706| 3.70k| janet_ev_deinit(); 39707| 3.70k|#endif 39708| 3.70k|#ifdef JANET_NET 39709| 3.70k| janet_net_deinit(); 39710| 3.70k|#endif 39711| 3.70k|} janet_memalloc_empty: 39879| 5.01M|void *janet_memalloc_empty(int32_t count) { 39880| 5.01M| int32_t i; 39881| 5.01M| void *mem = array_allocate(sizeof(JanetKV), count); 39882| 5.01M| janet_vm.next_collection += (size_t) count * sizeof(JanetKV); 39883| 5.01M| if (NULL == mem) { ------------------ | Branch (39883:9): [True: 0, False: 5.01M] ------------------ 39884| 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] | | ------------------ ------------------ 39885| 0| } 39886| 5.01M| JanetKV *mmem = (JanetKV *)mem; 39887| 90.5M| for (i = 0; i < count; i++) { ------------------ | Branch (39887:17): [True: 85.5M, False: 5.01M] ------------------ 39888| 85.5M| JanetKV *kv = mmem + i; 39889| 85.5M| kv->key = janet_wrap_nil(); ------------------ | | 831| 85.5M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 85.5M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 85.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 85.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39890| 85.5M| kv->value = janet_wrap_nil(); ------------------ | | 831| 85.5M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 85.5M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 85.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 85.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39891| 85.5M| } 39892| 5.01M| return mem; 39893| 5.01M|} janet_memempty: 39895| 326k|void janet_memempty(JanetKV *mem, int32_t count) { 39896| 326k| int32_t i; 39897| 5.75M| for (i = 0; i < count; i++) { ------------------ | Branch (39897:17): [True: 5.42M, False: 326k] ------------------ 39898| 5.42M| mem[i].key = janet_wrap_nil(); ------------------ | | 831| 5.42M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 5.42M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 5.42M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.42M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39899| 5.42M| mem[i].value = janet_wrap_nil(); ------------------ | | 831| 5.42M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 5.42M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 5.42M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.42M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39900| 5.42M| } 39901| 326k|} janet_wrap_number_safe: 39905| 34.2k|Janet janet_wrap_number_safe(double d) { 39906| 34.2k| Janet ret; 39907| 34.2k| ret.number = isnan(d) ? NAN : d; ------------------ | Branch (39907:18): [True: 4.39k, False: 29.8k] ------------------ 39908| 34.2k| return ret; 39909| 34.2k|} janet_nanbox_to_pointer: 39911| 64.1M|void *janet_nanbox_to_pointer(Janet x) { 39912| 64.1M| x.i64 &= JANET_NANBOX_PAYLOADBITS; ------------------ | | 791| 64.1M|#define JANET_NANBOX_PAYLOADBITS 0x00007FFFFFFFFFFFllu ------------------ 39913| 64.1M| x.u64 <<= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 64.1M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39914| 64.1M| return x.pointer; 39915| 64.1M|} janet_nanbox_from_pointer: 39917| 5.71M|Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask) { 39918| 5.71M| Janet ret; 39919| 5.71M| ret.pointer = p; 39920| | /* Should be noop when pointer shift is 0 */ 39921| | /* 39922| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 39923| | */ 39924| 5.71M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 5.71M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39925| 5.71M| ret.u64 |= tagmask; 39926| 5.71M| return ret; 39927| 5.71M|} janet_nanbox_from_cpointer: 39929| 22.0M|Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask) { 39930| 22.0M| Janet ret; 39931| 22.0M| ret.pointer = (void *)p; 39932| | /* Should be noop when pointer shift is 0 */ 39933| | /* 39934| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 39935| | */ 39936| 22.0M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 22.0M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39937| 22.0M| ret.u64 |= tagmask; 39938| 22.0M| return ret; 39939| 22.0M|} janet_nanbox_from_double: 39941| 7.34M|Janet janet_nanbox_from_double(double d) { 39942| 7.34M| Janet ret; 39943| 7.34M| ret.number = d; 39944| 7.34M| return ret; 39945| 7.34M|} janet_nanbox_from_bits: 39947| 1.60G|Janet janet_nanbox_from_bits(uint64_t bits) { 39948| 1.60G| Janet ret; 39949| 1.60G| ret.u64 = bits; 39950| 1.60G| return ret; 39951| 1.60G|} janet.c:janet_array_impl: 1606| 97.6k|static void janet_array_impl(JanetArray *array, int32_t capacity) { 1607| 97.6k| Janet *data = NULL; 1608| 97.6k| if (capacity > 0) { ------------------ | Branch (1608:9): [True: 19.0k, False: 78.6k] ------------------ 1609| 19.0k| janet_vm.next_collection += capacity * sizeof(Janet); 1610| 19.0k| data = (Janet *) array_allocate(sizeof(Janet), capacity); 1611| 19.0k| if (NULL == data) { ------------------ | Branch (1611:13): [True: 0, False: 19.0k] ------------------ 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| 19.0k| } 1615| 97.6k| array->count = 0; 1616| 97.6k| array->capacity = capacity; 1617| 97.6k| array->data = data; 1618| 97.6k|} janet.c:janet_buffer_init_impl: 3196| 10.3k|static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) { 3197| 10.3k| uint8_t *data = NULL; 3198| 10.3k| if (capacity < 4) capacity = 4; ------------------ | Branch (3198:9): [True: 5.93k, False: 4.37k] ------------------ 3199| 10.3k| janet_gcpressure(capacity); 3200| 10.3k| data = array_allocate(sizeof(uint8_t), capacity); 3201| 10.3k| if (NULL == data) { ------------------ | Branch (3201:9): [True: 0, False: 10.3k] ------------------ 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| 10.3k| buffer->count = 0; 3205| 10.3k| buffer->capacity = capacity; 3206| 10.3k| buffer->data = data; 3207| 10.3k| return buffer; 3208| 10.3k|} janet.c:janet_buffer_can_realloc: 3189| 1.72k|static void janet_buffer_can_realloc(JanetBuffer *buffer) { 3190| 1.72k| if (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) { ------------------ | | 1780| 1.72k|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3190:9): [True: 0, False: 1.72k] ------------------ 3191| 0| janet_panic("buffer cannot reallocate foreign memory"); 3192| 0| } 3193| 1.72k|} janet.c:janet_load_libs: 9373| 3.70k|static void janet_load_libs(JanetTable *env) { 9374| 3.70k| JanetRegExt corelib_cfuns[] = { 9375| 3.70k| JANET_CORE_REG("native", janet_core_native), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9376| 3.70k| JANET_CORE_REG("describe", janet_core_describe), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9377| 3.70k| JANET_CORE_REG("string", janet_core_string), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9378| 3.70k| JANET_CORE_REG("symbol", janet_core_symbol), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9379| 3.70k| JANET_CORE_REG("keyword", janet_core_keyword), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9380| 3.70k| JANET_CORE_REG("buffer", janet_core_buffer), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9381| 3.70k| JANET_CORE_REG("abstract?", janet_core_is_abstract), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9382| 3.70k| JANET_CORE_REG("table", janet_core_table), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9383| 3.70k| JANET_CORE_REG("array", janet_core_array), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9384| 3.70k| JANET_CORE_REG("scan-number", janet_core_scannumber), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9385| 3.70k| JANET_CORE_REG("tuple", janet_core_tuple), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9386| 3.70k| JANET_CORE_REG("struct", janet_core_struct), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9387| 3.70k| JANET_CORE_REG("gensym", janet_core_gensym), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9388| 3.70k| JANET_CORE_REG("gccollect", janet_core_gccollect), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9389| 3.70k| JANET_CORE_REG("gcsetinterval", janet_core_gcsetinterval), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9390| 3.70k| JANET_CORE_REG("gcinterval", janet_core_gcinterval), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9391| 3.70k| JANET_CORE_REG("type", janet_core_type), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9392| 3.70k| JANET_CORE_REG("hash", janet_core_hash), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9393| 3.70k| JANET_CORE_REG("getline", janet_core_getline), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9394| 3.70k| JANET_CORE_REG("dyn", janet_core_dyn), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9395| 3.70k| JANET_CORE_REG("setdyn", janet_core_setdyn), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9396| 3.70k| JANET_CORE_REG("trace", janet_core_trace), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9397| 3.70k| JANET_CORE_REG("untrace", janet_core_untrace), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9398| 3.70k| JANET_CORE_REG("module/expand-path", janet_core_expand_path), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9399| 3.70k| JANET_CORE_REG("int?", janet_core_check_int), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9400| 3.70k| JANET_CORE_REG("nat?", janet_core_check_nat), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9401| 3.70k| JANET_CORE_REG("bytes?", janet_core_is_bytes), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9402| 3.70k| JANET_CORE_REG("indexed?", janet_core_is_indexed), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9403| 3.70k| JANET_CORE_REG("dictionary?", janet_core_is_dictionary), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9404| 3.70k| JANET_CORE_REG("lengthable?", janet_core_is_lengthable), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9405| 3.70k| JANET_CORE_REG("slice", janet_core_slice), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9406| 3.70k| JANET_CORE_REG("range", janet_core_range), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9407| 3.70k| JANET_CORE_REG("signal", janet_core_signal), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9408| 3.70k| JANET_CORE_REG("memcmp", janet_core_memcmp), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9409| 3.70k| JANET_CORE_REG("getproto", janet_core_getproto), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9410| 3.70k| JANET_CORE_REG("sandbox", janet_core_sandbox), ------------------ | | 518| 3.70k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 3.70k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9411| 3.70k| JANET_REG_END ------------------ | | 2110| 3.70k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 9412| 3.70k| }; 9413| | janet_core_cfuns_ext(env, NULL, corelib_cfuns); 9414| 3.70k| janet_lib_io(env); 9415| 3.70k| janet_lib_math(env); 9416| 3.70k| janet_lib_array(env); 9417| 3.70k| janet_lib_tuple(env); 9418| 3.70k| janet_lib_buffer(env); 9419| 3.70k| janet_lib_table(env); 9420| 3.70k| janet_lib_struct(env); 9421| 3.70k| janet_lib_fiber(env); 9422| 3.70k| janet_lib_os(env); 9423| 3.70k| janet_lib_parse(env); 9424| 3.70k| janet_lib_compile(env); 9425| 3.70k| janet_lib_debug(env); 9426| 3.70k| janet_lib_string(env); 9427| 3.70k| janet_lib_marsh(env); 9428| 3.70k|#ifdef JANET_PEG 9429| 3.70k| janet_lib_peg(env); 9430| 3.70k|#endif 9431| 3.70k|#ifdef JANET_ASSEMBLER 9432| 3.70k| janet_lib_asm(env); 9433| 3.70k|#endif 9434| 3.70k|#ifdef JANET_INT_TYPES 9435| 3.70k| janet_lib_inttypes(env); 9436| 3.70k|#endif 9437| 3.70k|#ifdef JANET_EV 9438| 3.70k| janet_lib_ev(env); 9439| 3.70k|#ifdef JANET_FILEWATCH 9440| 3.70k| janet_lib_filewatch(env); 9441| 3.70k|#endif 9442| 3.70k|#endif 9443| 3.70k|#ifdef JANET_NET 9444| 3.70k| janet_lib_net(env); 9445| 3.70k|#endif 9446| 3.70k|#ifdef JANET_FFI 9447| 3.70k| janet_lib_ffi(env); 9448| 3.70k|#endif 9449| 3.70k|} janet.c:janet_q_init: 10684| 3.70k|static void janet_q_init(JanetQueue *q) { 10685| | q->data = NULL; 10686| 3.70k| q->head = 0; 10687| 3.70k| q->tail = 0; 10688| 3.70k| q->capacity = 0; 10689| 3.70k|} janet.c:peek_timeout: 10766| 3.70k|static int peek_timeout(JanetTimeout *out) { 10767| 3.70k| if (janet_vm.tq_count == 0) return 0; ------------------ | Branch (10767:9): [True: 3.70k, False: 0] ------------------ 10768| 0| *out = janet_vm.tq[0]; 10769| 0| return 1; 10770| 3.70k|} janet.c:janet_q_deinit: 10691| 3.70k|static void janet_q_deinit(JanetQueue *q) { 10692| 3.70k| janet_free(q->data); ------------------ | | 2415| 3.70k|#define janet_free(X) free((X)) ------------------ 10693| 3.70k|} janet.c:janet_ev_setup_selfpipe: 12253| 3.70k|static void janet_ev_setup_selfpipe(void) { 12254| 3.70k| if (janet_make_pipe(janet_vm.selfpipe, 1)) { ------------------ | Branch (12254:9): [True: 0, False: 3.70k] ------------------ 12255| | 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] | | ------------------ ------------------ 12256| 0| } 12257| 3.70k|} janet.c:janet_ev_cleanup_selfpipe: 12276| 3.70k|static void janet_ev_cleanup_selfpipe(void) { 12277| 3.70k| close(janet_vm.selfpipe[0]); 12278| 3.70k| close(janet_vm.selfpipe[1]); 12279| 3.70k|} janet.c:janet_deinit_block: 18286| 22.7M|static void janet_deinit_block(JanetGCObject *mem) { 18287| 22.7M| switch (mem->flags & JANET_MEM_TYPEBITS) { ------------------ | | 675| 22.7M|#define JANET_MEM_TYPEBITS 0xFF ------------------ 18288| 8.95M| default: ------------------ | Branch (18288:9): [True: 8.95M, False: 13.7M] ------------------ 18289| 10.4M| case JANET_MEMORY_FUNCTION: ------------------ | Branch (18289:9): [True: 1.45M, False: 21.2M] ------------------ 18290| 10.4M| break; /* Do nothing for non gc types */ 18291| 7.41M| case JANET_MEMORY_SYMBOL: ------------------ | Branch (18291:9): [True: 7.41M, False: 15.3M] ------------------ 18292| 7.41M| janet_symbol_deinit(((JanetStringHead *) mem)->data); 18293| 7.41M| break; 18294| 89.6k| case JANET_MEMORY_ARRAY: ------------------ | Branch (18294:9): [True: 89.6k, False: 22.6M] ------------------ 18295| 89.6k| case JANET_MEMORY_ARRAY_WEAK: ------------------ | Branch (18295:9): [True: 0, False: 22.7M] ------------------ 18296| 89.6k| janet_free(((JanetArray *) mem)->data); ------------------ | | 2415| 89.6k|#define janet_free(X) free((X)) ------------------ 18297| 89.6k| break; 18298| 2.72M| case JANET_MEMORY_TABLE: ------------------ | Branch (18298:9): [True: 2.72M, False: 20.0M] ------------------ 18299| 2.72M| case JANET_MEMORY_TABLE_WEAKK: ------------------ | Branch (18299:9): [True: 0, False: 22.7M] ------------------ 18300| 2.72M| case JANET_MEMORY_TABLE_WEAKV: ------------------ | Branch (18300:9): [True: 0, False: 22.7M] ------------------ 18301| 2.72M| case JANET_MEMORY_TABLE_WEAKKV: ------------------ | Branch (18301:9): [True: 0, False: 22.7M] ------------------ 18302| 2.72M| janet_free(((JanetTable *) mem)->data); ------------------ | | 2415| 2.72M|#define janet_free(X) free((X)) ------------------ 18303| 2.72M| break; 18304| 11.8k| case JANET_MEMORY_FIBER: { ------------------ | Branch (18304:9): [True: 11.8k, False: 22.7M] ------------------ 18305| 11.8k| JanetFiber *f = (JanetFiber *)mem; 18306| 11.8k|#ifdef JANET_EV 18307| 11.8k| if (f->ev_state && !(f->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) { ------------------ | | 847| 0|#define JANET_FIBER_EV_FLAG_IN_FLIGHT 0x1 ------------------ | Branch (18307:17): [True: 0, False: 11.8k] | Branch (18307:32): [True: 0, False: 0] ------------------ 18308| 0| janet_ev_dec_refcount(); 18309| 0| janet_free(f->ev_state); ------------------ | | 2415| 0|#define janet_free(X) free((X)) ------------------ 18310| 11.8k| } else if (f->gc.flags & JANET_FIBER_EV_GCFLAG_SUSPENDED) { ------------------ | | 843| 11.8k|#define JANET_FIBER_EV_GCFLAG_SUSPENDED 0x2000000 ------------------ | Branch (18310:24): [True: 0, False: 11.8k] ------------------ 18311| 0| janet_ev_dec_refcount(); 18312| 0| } 18313| 11.8k|#endif 18314| 11.8k| janet_free(f->data); ------------------ | | 2415| 11.8k|#define janet_free(X) free((X)) ------------------ 18315| 11.8k| } 18316| 11.8k| break; 18317| 8.39k| case JANET_MEMORY_BUFFER: ------------------ | Branch (18317:9): [True: 8.39k, False: 22.7M] ------------------ 18318| 8.39k| janet_buffer_deinit((JanetBuffer *) mem); 18319| 8.39k| break; 18320| 11.1k| case JANET_MEMORY_ABSTRACT: { ------------------ | Branch (18320:9): [True: 11.1k, False: 22.7M] ------------------ 18321| 11.1k| JanetAbstractHead *head = (JanetAbstractHead *)mem; 18322| 11.1k| if (head->type->gcperthread) { ------------------ | Branch (18322:17): [True: 0, False: 11.1k] ------------------ 18323| 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] | | ------------------ ------------------ 18324| 0| } 18325| 11.1k| if (head->type->gc) { ------------------ | Branch (18325:17): [True: 11.1k, False: 0] ------------------ 18326| 11.1k| janet_assert(!head->type->gc(head->data, head->size), "finalizer failed"); ------------------ | | 389| 11.1k|#define janet_assert(c, m) do { \ | | 390| 11.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: 11.1k] | | ------------------ | | 391| 11.1k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 11.1k] | | ------------------ ------------------ 18327| 11.1k| } 18328| 11.1k| } 18329| 11.1k| break; 18330| 50.9k| case JANET_MEMORY_FUNCENV: { ------------------ | Branch (18330:9): [True: 50.9k, False: 22.7M] ------------------ 18331| 50.9k| JanetFuncEnv *env = (JanetFuncEnv *)mem; 18332| 50.9k| if (0 == env->offset) ------------------ | Branch (18332:17): [True: 49.1k, False: 1.76k] ------------------ 18333| 49.1k| janet_free(env->as.values); ------------------ | | 2415| 49.1k|#define janet_free(X) free((X)) ------------------ 18334| 50.9k| } 18335| 50.9k| break; 18336| 2.03M| case JANET_MEMORY_FUNCDEF: { ------------------ | Branch (18336:9): [True: 2.03M, False: 20.7M] ------------------ 18337| 2.03M| JanetFuncDef *def = (JanetFuncDef *)mem; 18338| | /* TODO - get this all with one alloc and one free */ 18339| 2.03M| janet_free(def->defs); ------------------ | | 2415| 2.03M|#define janet_free(X) free((X)) ------------------ 18340| 2.03M| janet_free(def->environments); ------------------ | | 2415| 2.03M|#define janet_free(X) free((X)) ------------------ 18341| 2.03M| janet_free(def->constants); ------------------ | | 2415| 2.03M|#define janet_free(X) free((X)) ------------------ 18342| 2.03M| janet_free(def->bytecode); ------------------ | | 2415| 2.03M|#define janet_free(X) free((X)) ------------------ 18343| 2.03M| janet_free(def->sourcemap); ------------------ | | 2415| 2.03M|#define janet_free(X) free((X)) ------------------ 18344| 2.03M| janet_free(def->closure_bitset); ------------------ | | 2415| 2.03M|#define janet_free(X) free((X)) ------------------ 18345| 2.03M| janet_free(def->symbolmap); ------------------ | | 2415| 2.03M|#define janet_free(X) free((X)) ------------------ 18346| 2.03M| } 18347| 2.03M| break; 18348| 22.7M| } 18349| 22.7M|} janet.c:janet_free_all_scratch: 18536| 3.70k|static void janet_free_all_scratch(void) { 18537| 9.16k| for (size_t i = 0; i < janet_vm.scratch_len; i++) { ------------------ | Branch (18537:24): [True: 5.45k, False: 3.70k] ------------------ 18538| 5.45k| free_one_scratch(janet_vm.scratch_mem[i]); 18539| 5.45k| } 18540| 3.70k| janet_vm.scratch_len = 0; 18541| 3.70k|} janet.c:janet_mem2scratch: 18543| 125k|static JanetScratch *janet_mem2scratch(void *mem) { 18544| 125k| JanetScratch *s = (JanetScratch *)mem; 18545| 125k| return s - 1; 18546| 125k|} janet.c:free_one_scratch: 18528| 16.8k|static void free_one_scratch(JanetScratch *s) { 18529| 16.8k| if (NULL != s->finalize) { ------------------ | Branch (18529:9): [True: 0, False: 16.8k] ------------------ 18530| 0| s->finalize((char *) s->mem); 18531| 0| } 18532| 16.8k| janet_free(s); ------------------ | | 2415| 16.8k|#define janet_free(X) free((X)) ------------------ 18533| 16.8k|} janet.c:makef: 19558| 11.1k|static void *makef(FILE *f, int32_t flags, size_t bufsize) { 19559| 11.1k| JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile)); 19560| 11.1k| iof->file = f; 19561| 11.1k| iof->flags = flags; 19562| 11.1k| iof->vbufsize = bufsize; 19563| 11.1k|#if !(defined(JANET_WINDOWS) || defined(JANET_PLAN9)) 19564| | /* While we would like fopen to set cloexec by default (like O_CLOEXEC) with the e flag, that is 19565| | * not standard. */ 19566| 11.1k| if (!(flags & JANET_FILE_NOT_CLOSEABLE)) ------------------ | | 2278| 11.1k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ | Branch (19566:9): [True: 0, False: 11.1k] ------------------ 19567| 0| fcntl(fileno(f), F_SETFD, FD_CLOEXEC); 19568| 11.1k|#endif 19569| 11.1k| return iof; 19570| 11.1k|} janet.c:cfun_io_gc: 19766| 11.1k|static int cfun_io_gc(void *p, size_t len) { 19767| 11.1k| (void) len; 19768| 11.1k| JanetFile *iof = (JanetFile *)p; 19769| 11.1k| janet_file_close(iof); 19770| 11.1k| return 0; 19771| 11.1k|} janet.c:entry_getval: 20407| 2.60M|static Janet entry_getval(Janet env_entry) { 20408| 2.60M| if (janet_checktype(env_entry, JANET_TABLE)) { ------------------ | | 806| 2.60M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.60M, False: 0] | | | Branch (806:6): [Folded, False: 2.60M] | | ------------------ | | 807| 2.60M| ? 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.60M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.60M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.60M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.60M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.60M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20409| 2.60M| JanetTable *entry = janet_unwrap_table(env_entry); ------------------ | | 861| 2.60M|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 20410| 2.60M| Janet checkval = janet_table_get(entry, janet_ckeywordv("value")); ------------------ | | 1843| 2.60M|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 2.60M|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 2.60M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 2.60M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 2.60M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20411| 2.60M| if (janet_checktype(checkval, JANET_NIL)) { ------------------ | | 806| 2.60M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 2.60M] | | | Branch (806:6): [Folded, False: 2.60M] | | ------------------ | | 807| 2.60M| ? 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.60M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.60M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.60M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.60M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.60M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20412| 0| checkval = janet_table_get(entry, janet_ckeywordv("ref")); ------------------ | | 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) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20413| 0| } 20414| 2.60M| return checkval; 20415| 2.60M| } else if (janet_checktype(env_entry, JANET_STRUCT)) { ------------------ | | 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20416| 0| const JanetKV *entry = janet_unwrap_struct(env_entry); ------------------ | | 857| 0|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 20417| 0| Janet checkval = janet_struct_get(entry, janet_ckeywordv("value")); ------------------ | | 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) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20418| 0| if (janet_checktype(checkval, 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20419| 0| checkval = janet_struct_get(entry, janet_ckeywordv("ref")); ------------------ | | 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) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20420| 0| } 20421| 0| return checkval; 20422| 0| } else { 20423| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20424| 0| } 20425| 2.60M|} janet.c:readint: 21050| 255M|static int32_t readint(UnmarshalState *st, const uint8_t **atdata) { 21051| 255M| const uint8_t *data = *atdata; 21052| 255M| int32_t ret; 21053| 255M| MARSH_EOS(st, data); ------------------ | |21045| 255M|#define MARSH_EOS(st, data) do { \ | |21046| 255M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 152, False: 255M] | | ------------------ | |21047| 255M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 255M] | | ------------------ ------------------ 21054| 255M| if (*data < 128) { ------------------ | Branch (21054:9): [True: 208M, False: 46.7M] ------------------ 21055| 208M| ret = *data++; 21056| 208M| } else if (*data < 192) { ------------------ | Branch (21056:16): [True: 44.1M, False: 2.62M] ------------------ 21057| 44.1M| MARSH_EOS(st, data + 1); ------------------ | |21045| 44.1M|#define MARSH_EOS(st, data) do { \ | |21046| 44.1M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 58, False: 44.1M] | | ------------------ | |21047| 44.1M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 44.1M] | | ------------------ ------------------ 21058| 44.1M| uint32_t uret = ((data[0] & 0x3F) << 8) + data[1]; 21059| | /* Sign extend 18 MSBs */ 21060| 44.1M| uret |= (uret >> 13) ? 0xFFFFC000 : 0; ------------------ | Branch (21060:17): [True: 12.3M, False: 31.8M] ------------------ 21061| 44.1M| ret = (int32_t)uret; 21062| 44.1M| data += 2; 21063| 44.1M| } else if (*data == LB_INTEGER) { ------------------ | Branch (21063:16): [True: 2.62M, False: 303] ------------------ 21064| 2.62M| MARSH_EOS(st, data + 4); ------------------ | |21045| 2.62M|#define MARSH_EOS(st, data) do { \ | |21046| 2.62M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 17, False: 2.62M] | | ------------------ | |21047| 2.62M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 2.62M] | | ------------------ ------------------ 21065| 2.62M| uint32_t ui = ((uint32_t)(data[1]) << 24) | 21066| 2.62M| ((uint32_t)(data[2]) << 16) | 21067| 2.62M| ((uint32_t)(data[3]) << 8) | 21068| 2.62M| (uint32_t)(data[4]); 21069| 2.62M| ret = (int32_t)ui; 21070| 2.62M| data += 5; 21071| 2.62M| } else { 21072| 303| janet_panicf("expected integer, got byte %x at index %d", 21073| 303| *data, 21074| 303| data - st->start); 21075| 0| ret = 0; 21076| 0| } 21077| 255M| *atdata = data; 21078| 255M| return ret; 21079| 255M|} janet.c:unmarshal_one: 21659| 70.6M| int flags) { 21660| 70.6M| uint8_t lead; 21661| 70.6M| MARSH_STACKCHECK; ------------------ | |20517| 70.6M|#define MARSH_STACKCHECK if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) janet_panic("stack overflow") | | ------------------ | | | | 296| 70.6M|#define JANET_RECURSION_GUARD 1024 | | ------------------ | | | Branch (20517:30): [True: 8, False: 70.6M] | | ------------------ ------------------ 21662| 70.6M| MARSH_EOS(st, data); ------------------ | |21045| 70.6M|#define MARSH_EOS(st, data) do { \ | |21046| 70.6M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 740, False: 70.6M] | | ------------------ | |21047| 70.6M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 70.6M] | | ------------------ ------------------ 21663| 70.6M| lead = data[0]; 21664| 70.6M| if (lead < LB_REAL) { ------------------ | Branch (21664:9): [True: 7.32M, False: 63.3M] ------------------ 21665| 7.32M| *out = janet_wrap_integer(readint(st, &data)); ------------------ | | 967| 7.32M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 7.32M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 21666| 7.32M| return data; 21667| 7.32M| } 21668| 63.3M| switch (lead) { 21669| 224k| case LB_NIL: ------------------ | Branch (21669:9): [True: 224k, False: 63.1M] ------------------ 21670| 224k| *out = janet_wrap_nil(); ------------------ | | 831| 224k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 224k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 224k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 224k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21671| 224k| return data + 1; 21672| 101k| case LB_FALSE: ------------------ | Branch (21672:9): [True: 101k, False: 63.2M] ------------------ 21673| 101k| *out = janet_wrap_false(); ------------------ | | 833| 101k|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 101k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 101k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 101k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21674| 101k| return data + 1; 21675| 539k| case LB_TRUE: ------------------ | Branch (21675:9): [True: 539k, False: 62.8M] ------------------ 21676| 539k| *out = janet_wrap_true(); ------------------ | | 832| 539k|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 539k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 539k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 539k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21677| 539k| return data + 1; 21678| 16.8k| case LB_INTEGER: ------------------ | Branch (21678:9): [True: 16.8k, False: 63.3M] ------------------ 21679| | /* Long integer */ 21680| 16.8k| MARSH_EOS(st, data + 4); ------------------ | |21045| 16.8k|#define MARSH_EOS(st, data) do { \ | |21046| 16.8k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 9, False: 16.8k] | | ------------------ | |21047| 16.8k|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 16.8k] | | ------------------ ------------------ 21681| 16.8k| uint32_t ui = ((uint32_t)(data[4])) | 21682| 16.8k| ((uint32_t)(data[3]) << 8) | 21683| 16.8k| ((uint32_t)(data[2]) << 16) | 21684| 16.8k| ((uint32_t)(data[1]) << 24); 21685| 16.8k| int32_t si = (int32_t)ui; 21686| 16.8k| *out = janet_wrap_integer(si); ------------------ | | 967| 16.8k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 16.8k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 21687| 16.8k| return data + 5; 21688| 34.3k| case LB_REAL: ------------------ | Branch (21688:9): [True: 34.3k, False: 63.3M] ------------------ 21689| | /* Real */ 21690| 34.3k| { 21691| 34.3k| union { 21692| 34.3k| double d; 21693| 34.3k| uint8_t bytes[8]; 21694| 34.3k| } u; 21695| 34.3k| MARSH_EOS(st, data + 8); ------------------ | |21045| 34.3k|#define MARSH_EOS(st, data) do { \ | |21046| 34.3k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 23, False: 34.2k] | | ------------------ | |21047| 34.3k|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 34.2k] | | ------------------ ------------------ 21696| |#ifdef JANET_BIG_ENDIAN 21697| | u.bytes[0] = data[8]; 21698| | u.bytes[1] = data[7]; 21699| | u.bytes[2] = data[6]; 21700| | u.bytes[3] = data[5]; 21701| | u.bytes[4] = data[4]; 21702| | u.bytes[5] = data[3]; 21703| | u.bytes[6] = data[2]; 21704| | u.bytes[7] = data[1]; 21705| |#else 21706| 34.2k| memcpy(&u.bytes, data + 1, sizeof(double)); 21707| 34.2k|#endif 21708| 34.2k| *out = janet_wrap_number_safe(u.d); 21709| 34.2k| janet_v_push(st->lookup, *out); ------------------ | | 757| 34.2k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 34.2k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 34.2k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 34.1k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 34.1k|#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| 34.1k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 34.1k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 98, False: 34.1k] | | | | | | | Branch (768:50): [True: 638, False: 33.5k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 736|#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| 34.2k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 34.2k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21710| 34.2k| return data + 9; 21711| 34.3k| } 21712| 5.49M| case LB_STRING: ------------------ | Branch (21712:9): [True: 5.49M, False: 57.8M] ------------------ 21713| 12.4M| case LB_SYMBOL: ------------------ | Branch (21713:9): [True: 6.93M, False: 56.4M] ------------------ 21714| 12.4M| case LB_BUFFER: ------------------ | Branch (21714:9): [True: 8.40k, False: 63.3M] ------------------ 21715| 13.3M| case LB_KEYWORD: ------------------ | Branch (21715:9): [True: 882k, False: 62.4M] ------------------ 21716| 14.6M| case LB_REGISTRY: { ------------------ | Branch (21716:9): [True: 1.36M, False: 61.9M] ------------------ 21717| 14.6M| data++; 21718| 14.6M| int32_t len = readnat(st, &data); 21719| 14.6M| MARSH_EOS(st, data - 1 + len); ------------------ | |21045| 14.6M|#define MARSH_EOS(st, data) do { \ | |21046| 14.6M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 68, False: 14.6M] | | ------------------ | |21047| 14.6M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 14.6M] | | ------------------ ------------------ 21720| 14.6M| if (lead == LB_STRING) { ------------------ | Branch (21720:17): [True: 5.49M, False: 9.19M] ------------------ 21721| 5.49M| const uint8_t *str = janet_string(data, len); 21722| 5.49M| *out = janet_wrap_string(str); ------------------ | | 848| 5.49M|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 5.49M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 5.49M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.49M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21723| 9.19M| } else if (lead == LB_SYMBOL) { ------------------ | Branch (21723:24): [True: 6.93M, False: 2.25M] ------------------ 21724| 6.93M| const uint8_t *str = janet_symbol(data, len); 21725| 6.93M| *out = janet_wrap_symbol(str); ------------------ | | 849| 6.93M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 6.93M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 6.93M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.93M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21726| 6.93M| } else if (lead == LB_KEYWORD) { ------------------ | Branch (21726:24): [True: 882k, False: 1.37M] ------------------ 21727| 882k| const uint8_t *str = janet_keyword(data, len); ------------------ | | 1840| 882k|#define janet_keyword janet_symbol ------------------ 21728| 882k| *out = janet_wrap_keyword(str); ------------------ | | 850| 882k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | ------------------ | | | | 828| 882k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 882k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 882k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21729| 1.37M| } else if (lead == LB_REGISTRY) { ------------------ | Branch (21729:24): [True: 1.36M, False: 8.43k] ------------------ 21730| 1.36M| if (st->reg) { ------------------ | Branch (21730:21): [True: 1.36M, False: 0] ------------------ 21731| 1.36M| Janet regkey = janet_symbolv(data, len); ------------------ | | 1836| 1.36M|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 1.36M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 1.36M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.36M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.36M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21732| 1.36M| *out = janet_table_get(st->reg, regkey); 21733| 1.36M| } else { 21734| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21735| 0| } 21736| 1.36M| } else { /* (lead == LB_BUFFER) */ 21737| 8.43k| JanetBuffer *buffer = janet_buffer(len); 21738| 8.43k| buffer->count = len; 21739| 8.43k| safe_memcpy(buffer->data, data, len); 21740| 8.43k| *out = janet_wrap_buffer(buffer); ------------------ | | 847| 8.43k|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 8.43k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 8.43k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.43k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21741| 8.43k| } 21742| 14.6M| janet_v_push(st->lookup, *out); ------------------ | | 757| 14.6M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 14.6M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 14.6M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 14.6M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 14.6M|#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| 14.6M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 14.6M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 222, False: 14.6M] | | | | | | | Branch (768:50): [True: 46.7k, False: 14.6M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 46.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| 14.6M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 14.6M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21743| 14.6M| return data + len; 21744| 14.6M| } 21745| 11.8k| case LB_FIBER: { ------------------ | Branch (21745:9): [True: 11.8k, False: 63.3M] ------------------ 21746| 11.8k| JanetFiber *fiber; 21747| 11.8k| data = unmarshal_one_fiber(st, data + 1, &fiber, flags + 1); 21748| 11.8k| *out = janet_wrap_fiber(fiber); ------------------ | | 844| 11.8k|#define janet_wrap_fiber(s) janet_nanbox_wrap_((s), JANET_FIBER) | | ------------------ | | | | 825| 11.8k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 11.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 11.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21749| 11.8k| return data; 21750| 14.6M| } 21751| 1.45M| case LB_FUNCTION: { ------------------ | Branch (21751:9): [True: 1.45M, False: 61.8M] ------------------ 21752| 1.45M| JanetFunction *func; 21753| 1.45M| JanetFuncDef *def; 21754| 1.45M| data++; 21755| 1.45M| int32_t len = readnat(st, &data); 21756| 1.45M| if (len > 255) { ------------------ | Branch (21756:17): [True: 2, False: 1.45M] ------------------ 21757| 2| janet_panicf("invalid function - too many environments (%d)", len); 21758| 2| } 21759| 1.45M| func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + 21760| 1.45M| len * sizeof(JanetFuncEnv)); 21761| 1.45M| func->def = NULL; 21762| 1.84M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21762:33): [True: 392k, False: 1.45M] ------------------ 21763| 392k| func->envs[i] = NULL; 21764| 392k| } 21765| 1.45M| *out = janet_wrap_function(func); ------------------ | | 852| 1.45M|#define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION) | | ------------------ | | | | 825| 1.45M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.45M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.45M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21766| 1.45M| janet_v_push(st->lookup, *out); ------------------ | | 757| 1.45M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.45M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.45M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.45M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.45M|#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.45M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.45M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 1.39k, False: 1.45M] | | | | | | | Branch (768:50): [True: 1.29k, False: 1.45M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 2.68k|#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.45M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.45M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21767| 1.45M| data = unmarshal_one_def(st, data, &def, flags + 1); 21768| 1.45M| func->def = def; 21769| 1.63M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21769:33): [True: 180k, False: 1.45M] ------------------ 21770| 180k| data = unmarshal_one_env(st, data, &(func->envs[i]), flags + 1); 21771| 180k| } 21772| 1.45M| return data; 21773| 1.45M| } 21774| 23.4k| case LB_ABSTRACT: { ------------------ | Branch (21774:9): [True: 23.4k, False: 63.3M] ------------------ 21775| 23.4k| data++; 21776| 23.4k| return unmarshal_one_abstract(st, data, out, flags); 21777| 1.45M| } 21778| 39.9M| case LB_REFERENCE: ------------------ | Branch (21778:9): [True: 39.9M, False: 23.3M] ------------------ 21779| 40.0M| case LB_ARRAY: ------------------ | Branch (21779:9): [True: 89.7k, False: 63.2M] ------------------ 21780| 40.0M| case LB_ARRAY_WEAK: ------------------ | Branch (21780:9): [True: 7.99k, False: 63.3M] ------------------ 21781| 43.1M| case LB_TUPLE: ------------------ | Branch (21781:9): [True: 3.13M, False: 60.2M] ------------------ 21782| 43.4M| case LB_STRUCT: ------------------ | Branch (21782:9): [True: 275k, False: 63.0M] ------------------ 21783| 43.4M| case LB_STRUCT_PROTO: ------------------ | Branch (21783:9): [True: 11.5k, False: 63.3M] ------------------ 21784| 46.1M| case LB_TABLE: ------------------ | Branch (21784:9): [True: 2.71M, False: 60.6M] ------------------ 21785| 46.1M| case LB_TABLE_PROTO: ------------------ | Branch (21785:9): [True: 1.52k, False: 63.3M] ------------------ 21786| 46.1M| case LB_TABLE_WEAKK: ------------------ | Branch (21786:9): [True: 8.26k, False: 63.3M] ------------------ 21787| 46.1M| case LB_TABLE_WEAKV: ------------------ | Branch (21787:9): [True: 1.45k, False: 63.3M] ------------------ 21788| 46.2M| case LB_TABLE_WEAKKV: ------------------ | Branch (21788:9): [True: 54.2k, False: 63.2M] ------------------ 21789| 46.2M| case LB_TABLE_WEAKK_PROTO: ------------------ | Branch (21789:9): [True: 1.02k, False: 63.3M] ------------------ 21790| 46.2M| case LB_TABLE_WEAKV_PROTO: ------------------ | Branch (21790:9): [True: 1.11k, False: 63.3M] ------------------ 21791| 46.2M| case LB_TABLE_WEAKKV_PROTO: ------------------ | Branch (21791:9): [True: 2.35k, False: 63.3M] ------------------ 21792| | /* Things that open with integers */ 21793| 46.2M| { 21794| 46.2M| data++; 21795| 46.2M| int32_t len = readnat(st, &data); 21796| | /* DOS check */ 21797| 46.2M| if (lead != LB_REFERENCE) { ------------------ | Branch (21797:17): [True: 6.29M, False: 39.9M] ------------------ 21798| 6.29M| MARSH_EOS(st, data - 1 + len); ------------------ | |21045| 6.29M|#define MARSH_EOS(st, data) do { \ | |21046| 6.29M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 208, False: 6.29M] | | ------------------ | |21047| 6.29M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 6.29M] | | ------------------ ------------------ 21799| 6.29M| } 21800| 46.2M| if (lead == LB_ARRAY || lead == LB_ARRAY_WEAK) { ------------------ | Branch (21800:17): [True: 89.8k, False: 46.1M] | Branch (21800:37): [True: 7.97k, False: 46.1M] ------------------ 21801| | /* Array */ 21802| 97.6k| JanetArray *array = (lead == LB_ARRAY_WEAK) ? janet_array_weak(len) : janet_array(len); ------------------ | Branch (21802:37): [True: 7.97k, False: 89.6k] ------------------ 21803| 97.6k| array->count = len; 21804| 97.6k| *out = janet_wrap_array(array); ------------------ | | 845| 97.6k|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 97.6k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 97.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 97.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21805| 97.6k| janet_v_push(st->lookup, *out); ------------------ | | 757| 97.6k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 97.6k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 97.6k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 97.5k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 97.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| 97.5k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 97.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 77, False: 97.5k] | | | | | | | Branch (768:50): [True: 526, False: 97.0k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 603|#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| 97.6k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 97.6k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21806| 225k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21806:37): [True: 128k, False: 97.6k] ------------------ 21807| 128k| data = unmarshal_one(st, data, array->data + i, flags + 1); 21808| 128k| } 21809| 46.1M| } else if (lead == LB_TUPLE) { ------------------ | Branch (21809:24): [True: 3.13M, False: 43.0M] ------------------ 21810| | /* Tuple */ 21811| 3.13M| Janet *tup = janet_tuple_begin(len); 21812| 3.13M| int32_t flag = readint(st, &data); 21813| 3.13M| janet_tuple_flag(tup) |= (int32_t)(((uint32_t) flag) << 16); /* Avoid left shift of negative value */ ------------------ | | 1806| 3.13M|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 3.13M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 21814| 11.6M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21814:37): [True: 8.48M, False: 3.13M] ------------------ 21815| 8.48M| data = unmarshal_one(st, data, tup + i, flags + 1); 21816| 8.48M| } 21817| 3.13M| *out = janet_wrap_tuple(janet_tuple_end(tup)); ------------------ | | 843| 3.13M|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 3.13M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 3.13M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.13M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21818| 3.13M| janet_v_push(st->lookup, *out); ------------------ | | 757| 3.13M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 3.13M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 3.13M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 3.12M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 3.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| 3.12M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 3.12M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 4.34k, False: 3.12M] | | | | | | | Branch (768:50): [True: 1.30k, False: 3.12M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 1.36k|#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.13M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.13M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21819| 43.0M| } else if (lead == LB_STRUCT || lead == LB_STRUCT_PROTO) { ------------------ | Branch (21819:24): [True: 275k, False: 42.7M] | Branch (21819:45): [True: 11.5k, False: 42.7M] ------------------ 21820| | /* Struct */ 21821| 286k| JanetKV *struct_ = janet_struct_begin(len); 21822| 286k| if (lead == LB_STRUCT_PROTO) { ------------------ | Branch (21822:21): [True: 11.5k, False: 275k] ------------------ 21823| 11.5k| Janet proto; 21824| 11.5k| data = unmarshal_one(st, data, &proto, flags + 1); 21825| 11.5k| janet_asserttype(proto, JANET_STRUCT, st); 21826| 11.5k| janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 1851| 11.5k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 11.5k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 857| 11.5k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 21827| 11.5k| } 21828| 1.30M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21828:37): [True: 1.01M, False: 286k] ------------------ 21829| 1.01M| Janet key, value; 21830| 1.01M| data = unmarshal_one(st, data, &key, flags + 1); 21831| 1.01M| data = unmarshal_one(st, data, &value, flags + 1); 21832| 1.01M| janet_struct_put(struct_, key, value); 21833| 1.01M| } 21834| 286k| *out = janet_wrap_struct(janet_struct_end(struct_)); ------------------ | | 842| 286k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 286k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 286k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 286k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21835| 286k| janet_v_push(st->lookup, *out); ------------------ | | 757| 286k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 286k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 286k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 255k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 255k|#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| 255k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 255k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 31.4k, False: 255k] | | | | | | | Branch (768:50): [True: 2.09k, False: 253k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 2.26k|#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| 286k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 286k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21836| 42.7M| } else if (lead == LB_REFERENCE) { ------------------ | Branch (21836:24): [True: 39.9M, False: 2.78M] ------------------ 21837| 39.9M| if (len >= janet_v_count(st->lookup)) ------------------ | | 759| 39.9M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 39.9M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 39.9M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 39.9M, False: 0] | | ------------------ ------------------ | Branch (21837:21): [True: 59, False: 39.9M] ------------------ 21838| 59| janet_panicf("invalid reference %d", len); 21839| 39.9M| *out = st->lookup[len]; 21840| 39.9M| } else { 21841| | /* Table */ 21842| 2.78M| JanetTable *t; 21843| 2.78M| if (lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKK) { ------------------ | Branch (21843:21): [True: 1.19k, False: 2.78M] | Branch (21843:53): [True: 8.23k, False: 2.77M] ------------------ 21844| 9.24k| t = janet_table_weakk(len); 21845| 2.77M| } else if (lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKV) { ------------------ | Branch (21845:28): [True: 1.28k, False: 2.77M] | Branch (21845:60): [True: 1.44k, False: 2.76M] ------------------ 21846| 2.55k| t = janet_table_weakv(len); 21847| 2.76M| } else if (lead == LB_TABLE_WEAKKV_PROTO || lead == LB_TABLE_WEAKKV) { ------------------ | Branch (21847:28): [True: 2.52k, False: 2.76M] | Branch (21847:61): [True: 54.2k, False: 2.71M] ------------------ 21848| 56.5k| t = janet_table_weakkv(len); 21849| 2.71M| } else { 21850| 2.71M| t = janet_table(len); 21851| 2.71M| } 21852| 2.78M| *out = janet_wrap_table(t); ------------------ | | 846| 2.78M|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 2.78M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.78M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.78M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21853| 2.78M| janet_v_push(st->lookup, *out); ------------------ | | 757| 2.78M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 2.78M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 2.78M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 2.77M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 2.77M|#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.77M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 2.77M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 5.31k, False: 2.77M] | | | | | | | Branch (768:50): [True: 6.30k, False: 2.76M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 11.4k|#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.78M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.78M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21854| 2.78M| if (lead == LB_TABLE_PROTO || lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKKV_PROTO) { ------------------ | Branch (21854:21): [True: 1.67k, False: 2.77M] | Branch (21854:47): [True: 1.01k, False: 2.77M] | Branch (21854:79): [True: 1.10k, False: 2.77M] | Branch (21854:111): [True: 2.34k, False: 2.77M] ------------------ 21855| 5.97k| Janet proto; 21856| 5.97k| data = unmarshal_one(st, data, &proto, flags + 1); 21857| 5.97k| janet_asserttype(proto, JANET_TABLE, st); 21858| 5.97k| t->proto = janet_unwrap_table(proto); ------------------ | | 861| 5.97k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 21859| 5.97k| } 21860| 16.8M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21860:37): [True: 14.1M, False: 2.78M] ------------------ 21861| 14.1M| Janet key, value; 21862| 14.1M| data = unmarshal_one(st, data, &key, flags + 1); 21863| 14.1M| data = unmarshal_one(st, data, &value, flags + 1); 21864| 14.1M| janet_table_put(t, key, value); 21865| 14.1M| } 21866| 2.78M| } 21867| 46.2M| return data; 21868| 46.2M| } 21869| 3| case LB_UNSAFE_POINTER: { ------------------ | Branch (21869:9): [True: 3, False: 63.3M] ------------------ 21870| 3| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21045| 3|#define MARSH_EOS(st, data) do { \ | |21046| 3| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 1, False: 2] | | ------------------ | |21047| 3|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 2] | | ------------------ ------------------ 21871| 2| data++; 21872| 2| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 2|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21872:17): [True: 2, False: 0] ------------------ 21873| 2| janet_panicf("unsafe flag not given, " 21874| 2| "will not unmarshal raw pointer at index %d", 21875| 2| (int)(data - st->start)); 21876| 2| } 21877| 0| union { 21878| 0| void *ptr; 21879| 0| uint8_t bytes[sizeof(void *)]; 21880| 0| } u; 21881| 0| memcpy(u.bytes, data, sizeof(void *)); 21882| 0| data += sizeof(void *); 21883| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21884| 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) | | | | ------------------ | | ------------------ ------------------ 21885| 0| return data; 21886| 2| } 21887| 0|#ifdef JANET_EV 21888| 3| case LB_POINTER_BUFFER: { ------------------ | Branch (21888:9): [True: 3, False: 63.3M] ------------------ 21889| 3| data++; 21890| 3| int32_t count = readnat(st, &data); 21891| 3| int32_t capacity = readnat(st, &data); 21892| 3| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21045| 3|#define MARSH_EOS(st, data) do { \ | |21046| 3| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 1, False: 2] | | ------------------ | |21047| 3|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 2] | | ------------------ ------------------ 21893| 2| union { 21894| 2| void *ptr; 21895| 2| uint8_t bytes[sizeof(void *)]; 21896| 2| } u; 21897| 2| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 2|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21897:17): [True: 1, False: 1] ------------------ 21898| 1| janet_panicf("unsafe flag not given, " 21899| 1| "will not unmarshal raw pointer at index %d", 21900| 1| (int)(data - st->start)); 21901| 1| } 21902| 1| memcpy(u.bytes, data, sizeof(void *)); 21903| 1| data += sizeof(void *); 21904| 1| JanetBuffer *buffer = janet_pointer_buffer_unsafe(u.ptr, capacity, count); 21905| 1| *out = janet_wrap_buffer(buffer); ------------------ | | 847| 1|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 1| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21906| 1| janet_v_push(st->lookup, *out); ------------------ | | 757| 1|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1|#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: 1, 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| 1|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21907| 1| return data; 21908| 2| } 21909| 0|#endif 21910| 3| case LB_UNSAFE_CFUNCTION: { ------------------ | Branch (21910:9): [True: 3, False: 63.3M] ------------------ 21911| 3| MARSH_EOS(st, data + sizeof(JanetCFunction)); ------------------ | |21045| 3|#define MARSH_EOS(st, data) do { \ | |21046| 3| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 1, False: 2] | | ------------------ | |21047| 3|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 2] | | ------------------ ------------------ 21912| 2| data++; 21913| 2| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 2|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21913:17): [True: 2, False: 0] ------------------ 21914| 2| janet_panicf("unsafe flag not given, " 21915| 2| "will not unmarshal function pointer at index %d", 21916| 2| (int)(data - st->start)); 21917| 2| } 21918| 0| union { 21919| 0| JanetCFunction ptr; 21920| 0| uint8_t bytes[sizeof(JanetCFunction)]; 21921| 0| } u; 21922| 0| memcpy(u.bytes, data, sizeof(JanetCFunction)); 21923| 0| data += sizeof(JanetCFunction); 21924| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21925| 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) | | | | ------------------ | | ------------------ ------------------ 21926| 0| return data; 21927| 2| } 21928| 0|#ifdef JANET_EV 21929| 4| case LB_THREADED_ABSTRACT: { ------------------ | Branch (21929:9): [True: 4, False: 63.3M] ------------------ 21930| 4| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21045| 4|#define MARSH_EOS(st, data) do { \ | |21046| 4| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 3, False: 1] | | ------------------ | |21047| 4|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 1] | | ------------------ ------------------ 21931| 1| data++; 21932| 1| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 1|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21932:17): [True: 1, False: 0] ------------------ 21933| 1| janet_panicf("unsafe flag not given, " 21934| 1| "will not unmarshal threaded abstract pointer at index %d", 21935| 1| (int)(data - st->start)); 21936| 1| } 21937| 0| union { 21938| 0| void *ptr; 21939| 0| uint8_t bytes[sizeof(void *)]; 21940| 0| } u; 21941| 0| memcpy(u.bytes, data, sizeof(void *)); 21942| 0| data += sizeof(void *); 21943| | 21944| 0| if (flags & JANET_MARSHAL_DECREF) { ------------------ | | 387| 0|#define JANET_MARSHAL_DECREF 0x40000 ------------------ | Branch (21944:17): [True: 0, False: 0] ------------------ 21945| | /* Decrement immediately and don't bother putting into heap */ 21946| 0| janet_abstract_decref(u.ptr); 21947| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21948| 0| } else { 21949| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21950| 0| Janet check = janet_table_get(&janet_vm.threaded_abstracts, *out); 21951| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21952| | /* Transfers reference from threaded channel buffer to current heap */ 21953| 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21954| 0| } else { 21955| | /* Heap reference already accounted for, remove threaded channel reference. */ 21956| 0| janet_abstract_decref(u.ptr); 21957| 0| } 21958| 0| } 21959| | 21960| 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) | | | | ------------------ | | ------------------ ------------------ 21961| 0| return data; 21962| 1| } 21963| 0|#endif 21964| 201| default: { ------------------ | Branch (21964:9): [True: 201, False: 63.3M] ------------------ 21965| 201| janet_panicf("unknown byte %x at index %d", 21966| 201| *data, 21967| 201| (int)(data - st->start)); 21968| 0| return NULL; 21969| 1| } 21970| 63.3M| } 21971| 63.3M|} janet.c:readnat: 21082| 78.7M|static int32_t readnat(UnmarshalState *st, const uint8_t **atdata) { 21083| 78.7M| int32_t ret = readint(st, atdata); 21084| 78.7M| if (ret < 0) { ------------------ | Branch (21084:9): [True: 196, False: 78.7M] ------------------ 21085| 196| janet_panicf("expected integer >= 0, got %d", ret); 21086| 196| } 21087| 78.7M| return ret; 21088| 78.7M|} janet.c:unmarshal_one_fiber: 21402| 11.8k| int flags) { 21403| | 21404| | /* Initialize a new fiber with gc friendly defaults */ 21405| 11.8k| JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber)); 21406| 11.8k| fiber->flags = 0; 21407| 11.8k| fiber->frame = 0; 21408| 11.8k| fiber->stackstart = 0; 21409| 11.8k| fiber->stacktop = 0; 21410| 11.8k| fiber->capacity = 0; 21411| 11.8k| fiber->maxstack = 0; 21412| 11.8k| fiber->data = NULL; 21413| 11.8k| fiber->child = NULL; 21414| 11.8k| fiber->env = NULL; 21415| 11.8k| fiber->last_value = janet_wrap_nil(); ------------------ | | 831| 11.8k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 11.8k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 11.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 11.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21416| 11.8k|#ifdef JANET_EV 21417| 11.8k| fiber->sched_id = 0; 21418| 11.8k| fiber->supervisor_channel = NULL; 21419| 11.8k| fiber->ev_state = NULL; 21420| 11.8k| fiber->ev_callback = NULL; 21421| 11.8k| fiber->ev_stream = NULL; 21422| 11.8k|#endif 21423| | 21424| | /* Push fiber to seen stack */ 21425| 11.8k| janet_v_push(st->lookup, janet_wrap_fiber(fiber)); ------------------ | | 757| 11.8k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 11.8k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 11.8k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 11.6k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 11.6k|#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| 11.6k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 11.6k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 201, False: 11.6k] | | | | | | | Branch (768:50): [True: 415, False: 11.2k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 616|#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| 11.8k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 11.8k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21426| | 21427| | /* Read ints */ 21428| 11.8k| int32_t fiber_flags = readint(st, &data); 21429| 11.8k| int32_t frame = readnat(st, &data); 21430| 11.8k| int32_t fiber_stackstart = readnat(st, &data); 21431| 11.8k| int32_t fiber_stacktop = readnat(st, &data); 21432| 11.8k| int32_t fiber_maxstack = readnat(st, &data); 21433| 11.8k| JanetTable *fiber_env = NULL; 21434| | 21435| | /* Check for bad flags and ints */ 21436| 11.8k| if ((int32_t)(frame + JANET_FRAME_SIZE) > fiber_stackstart || ------------------ | | 1026| 11.8k|#define JANET_FRAME_SIZE 4 ------------------ | Branch (21436:9): [True: 54, False: 11.8k] ------------------ 21437| 11.8k| fiber_stackstart > fiber_stacktop || ------------------ | Branch (21437:13): [True: 3, False: 11.8k] ------------------ 21438| 11.8k| fiber_stacktop > fiber_maxstack) { ------------------ | Branch (21438:13): [True: 11, False: 11.7k] ------------------ 21439| 21| janet_panic("fiber has incorrect stack setup"); 21440| 21| } 21441| | 21442| | /* Allocate stack memory */ 21443| 11.8k| if (fiber_stacktop < INT32_MAX - 10) { ------------------ | Branch (21443:9): [True: 11.7k, False: 47] ------------------ 21444| 11.7k| fiber->capacity = fiber_stacktop + 10; 21445| 11.7k| } else { 21446| | /* Extra capacity is usually nice to avoid immediately reallocing on pushed arguments, but not needed */ 21447| 47| fiber->capacity = INT32_MAX; 21448| 47| } 21449| 11.8k| fiber->data = array_allocate(sizeof(Janet), fiber->capacity); 21450| 11.8k| if (!fiber->data) { ------------------ | Branch (21450:9): [True: 0, False: 11.8k] ------------------ 21451| 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] | | ------------------ ------------------ 21452| 0| } 21453| 1.42G| for (int32_t i = 0; i < fiber->capacity; i++) { ------------------ | Branch (21453:25): [True: 1.42G, False: 11.8k] ------------------ 21454| 1.42G| fiber->data[i] = janet_wrap_nil(); ------------------ | | 831| 1.42G|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.42G| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.42G|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.42G|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21455| 1.42G| } 21456| | 21457| | /* get frames */ 21458| 11.8k| int32_t stack = frame; 21459| 11.8k| int32_t stacktop = fiber_stackstart - JANET_FRAME_SIZE; ------------------ | | 1026| 11.8k|#define JANET_FRAME_SIZE 4 ------------------ 21460| 18.0k| while (stack > 0) { ------------------ | Branch (21460:12): [True: 6.21k, False: 11.7k] ------------------ 21461| 6.21k| JanetFunction *func = NULL; 21462| 6.21k| JanetFuncDef *def = NULL; 21463| 6.21k| JanetFuncEnv *env = NULL; 21464| 6.21k| int32_t frameflags = readint(st, &data); 21465| 6.21k| int32_t prevframe = readnat(st, &data); 21466| 6.21k| int32_t pcdiff = readnat(st, &data); 21467| | 21468| | /* Get frame items */ 21469| 6.21k| Janet *framestack = fiber->data + stack; 21470| 6.21k| JanetStackFrame *framep = janet_stack_frame(framestack); ------------------ | | 854| 6.21k|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 6.21k|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ 21471| | 21472| | /* Get function */ 21473| 6.21k| Janet funcv; 21474| 6.21k| data = unmarshal_one(st, data, &funcv, flags + 1); 21475| 6.21k| janet_asserttype(funcv, JANET_FUNCTION, st); 21476| 6.21k| func = janet_unwrap_function(funcv); ------------------ | | 868| 6.21k|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 21477| 6.21k| def = func->def; 21478| | 21479| | /* Check env */ 21480| 6.21k| if (frameflags & JANET_STACKFRAME_HASENV) { ------------------ | |20658| 6.21k|#define JANET_STACKFRAME_HASENV (INT32_MIN) ------------------ | Branch (21480:13): [True: 308, False: 5.90k] ------------------ 21481| 308| frameflags &= ~JANET_STACKFRAME_HASENV; ------------------ | |20658| 308|#define JANET_STACKFRAME_HASENV (INT32_MIN) ------------------ 21482| 308| data = unmarshal_one_env(st, data, &env, flags + 1); 21483| 308| } 21484| | 21485| | /* Error checking */ 21486| 6.21k| int32_t expected_framesize = def->slotcount; 21487| 6.21k| if (expected_framesize != stacktop - stack) { ------------------ | Branch (21487:13): [True: 21, False: 6.19k] ------------------ 21488| 21| janet_panic("fiber stackframe size mismatch"); 21489| 21| } 21490| 6.19k| if (pcdiff >= def->bytecode_length) { ------------------ | Branch (21490:13): [True: 20, False: 6.17k] ------------------ 21491| 20| janet_panic("fiber stackframe has invalid pc"); 21492| 20| } 21493| 6.17k| if ((int32_t)(prevframe + JANET_FRAME_SIZE) > stack) { ------------------ | | 1026| 6.17k|#define JANET_FRAME_SIZE 4 ------------------ | Branch (21493:13): [True: 5, False: 6.16k] ------------------ 21494| 5| janet_panic("fiber stackframe does not align with previous frame"); 21495| 5| } 21496| | 21497| | /* Get stack items */ 21498| 46.6k| for (int32_t i = stack; i < stacktop; i++) ------------------ | Branch (21498:33): [True: 40.5k, False: 6.16k] ------------------ 21499| 40.5k| data = unmarshal_one(st, data, fiber->data + i, flags + 1); 21500| | 21501| | /* Set frame */ 21502| 6.16k| framep->env = env; 21503| 6.16k| framep->pc = def->bytecode + pcdiff; 21504| 6.16k| framep->prevframe = prevframe; 21505| 6.16k| framep->flags = frameflags; 21506| 6.16k| framep->func = func; 21507| | 21508| | /* Goto previous frame */ 21509| 6.16k| stacktop = stack - JANET_FRAME_SIZE; ------------------ | | 1026| 6.16k|#define JANET_FRAME_SIZE 4 ------------------ 21510| 6.16k| stack = prevframe; 21511| 6.16k| } 21512| 11.7k| if (stack < 0) { ------------------ | Branch (21512:9): [True: 0, False: 11.7k] ------------------ 21513| 0| janet_panic("fiber has too many stackframes"); 21514| 0| } 21515| | 21516| | /* Check for fiber env */ 21517| 11.7k| if (fiber_flags & JANET_FIBER_FLAG_HASENV) { ------------------ | |20657| 11.7k|#define JANET_FIBER_FLAG_HASENV (1 << 30) ------------------ | Branch (21517:9): [True: 1.62k, False: 10.1k] ------------------ 21518| 1.62k| Janet envv; 21519| 1.62k| fiber_flags &= ~JANET_FIBER_FLAG_HASENV; ------------------ | |20657| 1.62k|#define JANET_FIBER_FLAG_HASENV (1 << 30) ------------------ 21520| 1.62k| data = unmarshal_one(st, data, &envv, flags + 1); 21521| 1.62k| janet_asserttype(envv, JANET_TABLE, st); 21522| 1.62k| fiber_env = janet_unwrap_table(envv); ------------------ | | 861| 1.62k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 21523| 1.62k| } 21524| | 21525| | /* Check for child fiber */ 21526| 11.7k| if (fiber_flags & JANET_FIBER_FLAG_HASCHILD) { ------------------ | |20656| 11.7k|#define JANET_FIBER_FLAG_HASCHILD (1 << 29) ------------------ | Branch (21526:9): [True: 1.57k, False: 10.2k] ------------------ 21527| 1.57k| Janet fiberv; 21528| 1.57k| fiber_flags &= ~JANET_FIBER_FLAG_HASCHILD; ------------------ | |20656| 1.57k|#define JANET_FIBER_FLAG_HASCHILD (1 << 29) ------------------ 21529| 1.57k| data = unmarshal_one(st, data, &fiberv, flags + 1); 21530| 1.57k| janet_asserttype(fiberv, JANET_FIBER, st); 21531| 1.57k| fiber->child = janet_unwrap_fiber(fiberv); ------------------ | | 859| 1.57k|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 21532| 1.57k| } 21533| | 21534| | /* Get the fiber last value */ 21535| 11.7k| data = unmarshal_one(st, data, &fiber->last_value, flags + 1); 21536| | 21537| | /* We have valid fiber, finally construct remaining fields. */ 21538| 11.7k| fiber->frame = frame; 21539| 11.7k| fiber->flags = fiber_flags; 21540| 11.7k| fiber->stackstart = fiber_stackstart; 21541| 11.7k| fiber->stacktop = fiber_stacktop; 21542| 11.7k| fiber->maxstack = fiber_maxstack; 21543| 11.7k| fiber->env = fiber_env; 21544| | 21545| 11.7k| int status = janet_fiber_status(fiber); 21546| 11.7k| if (status < 0 || status > JANET_STATUS_ALIVE) { ------------------ | Branch (21546:9): [True: 4.59k, False: 7.19k] | Branch (21546:23): [True: 7, False: 7.19k] ------------------ 21547| 7| janet_panic("invalid fiber status"); 21548| 7| } 21549| | 21550| | /* Return data */ 21551| 11.7k| *out = fiber; 21552| 11.7k| return data; 21553| 11.7k|} janet.c:unmarshal_one_def: 21221| 2.04M| int flags) { 21222| 2.04M| MARSH_EOS(st, data); ------------------ | |21045| 2.04M|#define MARSH_EOS(st, data) do { \ | |21046| 2.04M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 20, False: 2.04M] | | ------------------ | |21047| 2.04M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 2.04M] | | ------------------ ------------------ 21223| 2.04M| if (*data == LB_FUNCDEF_REF) { ------------------ | Branch (21223:9): [True: 15.0k, False: 2.03M] ------------------ 21224| 15.0k| data++; 21225| 15.0k| int32_t index = readint(st, &data); 21226| 15.0k| if (index < 0 || index >= janet_v_count(st->lookup_defs)) ------------------ | | 759| 15.0k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 15.0k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 15.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 15.0k, False: 0] | | ------------------ ------------------ | Branch (21226:13): [True: 1, False: 15.0k] | Branch (21226:26): [True: 33, False: 15.0k] ------------------ 21227| 34| janet_panicf("invalid funcdef reference %d", index); 21228| 15.0k| *out = st->lookup_defs[index]; 21229| 2.03M| } else { 21230| | /* Initialize with values that will not break garbage collection 21231| | * if unmarshalling fails. */ 21232| 2.03M| JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); 21233| 2.03M| def->environments_length = 0; 21234| 2.03M| def->defs_length = 0; 21235| 2.03M| def->constants_length = 0; 21236| 2.03M| def->bytecode_length = 0; 21237| 2.03M| def->name = NULL; 21238| 2.03M| def->source = NULL; 21239| 2.03M| def->closure_bitset = NULL; 21240| 2.03M| def->defs = NULL; 21241| 2.03M| def->environments = NULL; 21242| 2.03M| def->constants = NULL; 21243| 2.03M| def->bytecode = NULL; 21244| 2.03M| def->sourcemap = NULL; 21245| 2.03M| def->symbolmap = NULL; 21246| 2.03M| def->symbolmap_length = 0; 21247| 2.03M| def->named_args_count = 0; 21248| 2.03M| janet_v_push(st->lookup_defs, def); ------------------ | | 757| 2.03M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 2.03M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 2.03M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 2.02M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 2.02M|#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.02M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 2.02M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 5.39k, False: 2.02M] | | | | | | | Branch (768:50): [True: 39.3k, False: 1.98M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 44.7k|#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.03M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.03M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21249| | 21250| | /* Set default lengths to zero */ 21251| 2.03M| int32_t bytecode_length = 0; 21252| 2.03M| int32_t constants_length = 0; 21253| 2.03M| int32_t environments_length = 0; 21254| 2.03M| int32_t defs_length = 0; 21255| 2.03M| int32_t symbolmap_length = 0; 21256| | 21257| | /* Read flags and other fixed values */ 21258| 2.03M| def->flags = readint(st, &data); 21259| 2.03M| def->slotcount = readnat(st, &data); 21260| 2.03M| def->arity = readnat(st, &data); 21261| 2.03M| def->min_arity = readnat(st, &data); 21262| 2.03M| def->max_arity = readnat(st, &data); 21263| | 21264| | /* Read some lengths */ 21265| 2.03M| constants_length = readnat(st, &data); 21266| 2.03M| bytecode_length = readnat(st, &data); 21267| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS) ------------------ | | 1107| 2.03M|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (21267:13): [True: 14.9k, False: 2.01M] ------------------ 21268| 14.9k| def->named_args_count = readnat(st, &data); 21269| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) ------------------ | | 1103| 2.03M|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (21269:13): [True: 1.86M, False: 171k] ------------------ 21270| 1.86M| environments_length = readnat(st, &data); 21271| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) ------------------ | | 1102| 2.03M|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (21271:13): [True: 265k, False: 1.76M] ------------------ 21272| 265k| defs_length = readnat(st, &data); 21273| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) ------------------ | | 1099| 2.03M|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (21273:13): [True: 1.84M, False: 193k] ------------------ 21274| 1.84M| symbolmap_length = readnat(st, &data); 21275| | 21276| | /* Check name and source (optional) */ 21277| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) { ------------------ | | 1100| 2.03M|#define JANET_FUNCDEF_FLAG_HASNAME 0x80000 ------------------ | Branch (21277:13): [True: 1.85M, False: 175k] ------------------ 21278| 1.85M| Janet x; 21279| 1.85M| data = unmarshal_one(st, data, &x, flags + 1); 21280| 1.85M| janet_asserttype(x, JANET_STRING, st); 21281| 1.85M| def->name = janet_unwrap_string(x); ------------------ | | 863| 1.85M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 21282| 1.85M| } 21283| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) { ------------------ | | 1101| 2.03M|#define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000 ------------------ | Branch (21283:13): [True: 1.86M, False: 172k] ------------------ 21284| 1.86M| Janet x; 21285| 1.86M| data = unmarshal_one(st, data, &x, flags + 1); 21286| 1.86M| janet_asserttype(x, JANET_STRING, st); 21287| 1.86M| def->source = janet_unwrap_string(x); ------------------ | | 863| 1.86M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 21288| 1.86M| } 21289| | 21290| | /* Unmarshal constants */ 21291| 2.03M| if (constants_length) { ------------------ | Branch (21291:13): [True: 1.54M, False: 491k] ------------------ 21292| 1.54M| def->constants = array_allocate(sizeof(Janet), constants_length); 21293| 1.54M| if (!def->constants) { ------------------ | Branch (21293:17): [True: 0, False: 1.54M] ------------------ 21294| 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] | | ------------------ ------------------ 21295| 0| } 21296| 10.1M| for (int32_t i = 0; i < constants_length; i++) ------------------ | Branch (21296:33): [True: 8.60M, False: 1.54M] ------------------ 21297| 8.60M| data = unmarshal_one(st, data, def->constants + i, flags + 1); 21298| 1.54M| } else { 21299| 491k| def->constants = NULL; 21300| 491k| } 21301| 2.03M| def->constants_length = constants_length; 21302| | 21303| | /* Unmarshal symbol map, if needed */ 21304| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) { ------------------ | | 1099| 2.03M|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (21304:13): [True: 1.83M, False: 193k] ------------------ 21305| 1.83M| def->symbolmap = array_allocate(sizeof(JanetSymbolMap), symbolmap_length); 21306| 1.83M| if (def->symbolmap == NULL) { ------------------ | Branch (21306:17): [True: 0, False: 1.83M] ------------------ 21307| 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] | | ------------------ ------------------ 21308| 0| } 21309| 20.7M| for (int32_t i = 0; i < symbolmap_length; i++) { ------------------ | Branch (21309:33): [True: 18.8M, False: 1.83M] ------------------ 21310| 18.8M| def->symbolmap[i].birth_pc = (uint32_t) readint(st, &data); 21311| 18.8M| def->symbolmap[i].death_pc = (uint32_t) readint(st, &data); 21312| 18.8M| def->symbolmap[i].slot_index = (uint32_t) readint(st, &data); 21313| 18.8M| Janet value; 21314| 18.8M| data = unmarshal_one(st, data, &value, flags + 1); 21315| 18.8M| if (!janet_checktype(value, JANET_SYMBOL)) { ------------------ | | 806| 18.8M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 18.8M] | | ------------------ | | 807| 18.8M| ? 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.8M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 18.8M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 18.8M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 18.8M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 18.8M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (21315:21): [True: 36, False: 18.8M] ------------------ 21316| 36| janet_panicf("corrupted symbolmap when unmarshalling debug info, got %v", value); 21317| 36| } 21318| 18.8M| def->symbolmap[i].symbol = janet_unwrap_symbol(value); ------------------ | | 864| 18.8M|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 21319| 18.8M| } 21320| 1.83M| def->symbolmap_length = (uint32_t) symbolmap_length; 21321| 1.83M| } 21322| | 21323| | /* Unmarshal bytecode */ 21324| 2.03M| def->bytecode = array_allocate(sizeof(uint32_t), bytecode_length); 21325| 2.03M| if (!def->bytecode) { ------------------ | Branch (21325:13): [True: 0, False: 2.03M] ------------------ 21326| 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] | | ------------------ ------------------ 21327| 0| } 21328| 2.03M| data = janet_unmarshal_u32s(st, data, def->bytecode, bytecode_length); 21329| 2.03M| def->bytecode_length = bytecode_length; 21330| | 21331| | /* Unmarshal environments */ 21332| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) { ------------------ | | 1103| 2.03M|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (21332:13): [True: 1.86M, False: 171k] ------------------ 21333| 1.86M| def->environments = janet_calloc(1, sizeof(int32_t) * (size_t) environments_length); ------------------ | | 2412| 1.86M|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 21334| 1.86M| if (!def->environments) { ------------------ | Branch (21334:17): [True: 0, False: 1.86M] ------------------ 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| 2.60M| for (int32_t i = 0; i < environments_length; i++) { ------------------ | Branch (21337:33): [True: 740k, False: 1.86M] ------------------ 21338| 740k| def->environments[i] = readint(st, &data); 21339| 740k| } 21340| 1.86M| } else { 21341| 171k| def->environments = NULL; 21342| 171k| } 21343| 2.03M| def->environments_length = environments_length; 21344| | 21345| | /* Unmarshal sub funcdefs */ 21346| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) { ------------------ | | 1102| 2.03M|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (21346:13): [True: 264k, False: 1.76M] ------------------ 21347| 264k| def->defs = janet_calloc(1, sizeof(JanetFuncDef *) * (size_t) defs_length); ------------------ | | 2412| 264k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 21348| 264k| if (!def->defs) { ------------------ | Branch (21348:17): [True: 0, False: 264k] ------------------ 21349| 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] | | ------------------ ------------------ 21350| 0| } 21351| 857k| for (int32_t i = 0; i < defs_length; i++) { ------------------ | Branch (21351:33): [True: 592k, False: 264k] ------------------ 21352| 592k| data = unmarshal_one_def(st, data, def->defs + i, flags + 1); 21353| 592k| } 21354| 1.76M| } else { 21355| 1.76M| def->defs = NULL; 21356| 1.76M| } 21357| 2.03M| def->defs_length = defs_length; 21358| | 21359| | /* Unmarshal source maps if needed */ 21360| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCEMAP) { ------------------ | | 1104| 2.03M|#define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000 ------------------ | Branch (21360:13): [True: 1.86M, False: 172k] ------------------ 21361| 1.86M| int32_t current = 0; 21362| 1.86M| def->sourcemap = array_allocate(sizeof(JanetSourceMapping), bytecode_length); 21363| 1.86M| if (!def->sourcemap) { ------------------ | Branch (21363:17): [True: 0, False: 1.86M] ------------------ 21364| 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] | | ------------------ ------------------ 21365| 0| } 21366| 55.2M| for (int32_t i = 0; i < bytecode_length; i++) { ------------------ | Branch (21366:33): [True: 53.3M, False: 1.86M] ------------------ 21367| 53.3M| current += readint(st, &data); 21368| 53.3M| def->sourcemap[i].line = current; 21369| 53.3M| def->sourcemap[i].column = readint(st, &data); 21370| 53.3M| } 21371| 1.86M| } else { 21372| 172k| def->sourcemap = NULL; 21373| 172k| } 21374| | 21375| | /* Unmarshal closure bitset if needed */ 21376| 2.03M| if (def->flags & JANET_FUNCDEF_FLAG_HASCLOBITSET) { ------------------ | | 1106| 2.03M|#define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000 ------------------ | Branch (21376:13): [True: 220k, False: 1.81M] ------------------ 21377| 220k| int32_t n = ((def->slotcount - 1) >> 5) + 1; 21378| 220k| def->closure_bitset = array_allocate(sizeof(uint32_t), n); 21379| 220k| if (NULL == def->closure_bitset) { ------------------ | Branch (21379:17): [True: 0, False: 220k] ------------------ 21380| 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] | | ------------------ ------------------ 21381| 0| } 21382| 220k| data = janet_unmarshal_u32s(st, data, def->closure_bitset, n); 21383| 220k| } 21384| | 21385| | /* Validate */ 21386| 2.03M| int status; 21387| 2.03M| if ((status = janet_verify(def))) { ------------------ | Branch (21387:13): [True: 598, False: 2.03M] ------------------ 21388| 598| janet_panicf("funcdef has invalid bytecode: %d", status); 21389| 598| } 21390| | 21391| | /* Set def */ 21392| 2.03M| *out = def; 21393| 2.03M| } 21394| 2.04M| return data; 21395| 2.04M|} janet.c:janet_unmarshal_u32s: 21203| 2.24M|static const uint8_t *janet_unmarshal_u32s(UnmarshalState *st, const uint8_t *data, uint32_t *into, int32_t n) { 21204| 57.4M| for (int32_t i = 0; i < n; i++) { ------------------ | Branch (21204:25): [True: 55.2M, False: 2.24M] ------------------ 21205| 55.2M| MARSH_EOS(st, data + 3); ------------------ | |21045| 55.2M|#define MARSH_EOS(st, data) do { \ | |21046| 55.2M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 60, False: 55.2M] | | ------------------ | |21047| 55.2M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 55.2M] | | ------------------ ------------------ 21206| 55.2M| into[i] = 21207| 55.2M| (uint32_t)(data[0]) | 21208| 55.2M| ((uint32_t)(data[1]) << 8) | 21209| 55.2M| ((uint32_t)(data[2]) << 16) | 21210| 55.2M| ((uint32_t)(data[3]) << 24); 21211| 55.2M| data += 4; 21212| 55.2M| } 21213| 2.24M| return data; 21214| 2.24M|} janet.c:unmarshal_one_env: 21159| 180k| int flags) { 21160| 180k| MARSH_EOS(st, data); ------------------ | |21045| 180k|#define MARSH_EOS(st, data) do { \ | |21046| 180k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 14, False: 180k] | | ------------------ | |21047| 180k|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 180k] | | ------------------ ------------------ 21161| 180k| if (*data == LB_FUNCENV_REF) { ------------------ | Branch (21161:9): [True: 129k, False: 50.9k] ------------------ 21162| 129k| data++; 21163| 129k| int32_t index = readint(st, &data); 21164| 129k| if (index < 0 || index >= janet_v_count(st->lookup_envs)) ------------------ | | 759| 129k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 129k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 129k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 129k, False: 7] | | ------------------ ------------------ | Branch (21164:13): [True: 41, False: 129k] | Branch (21164:26): [True: 56, False: 129k] ------------------ 21165| 97| janet_panicf("invalid funcenv reference %d", index); 21166| 129k| *out = st->lookup_envs[index]; 21167| 129k| } else { 21168| 50.9k| JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); 21169| 50.9k| env->length = 0; 21170| 50.9k| env->offset = 0; 21171| 50.9k| env->as.values = NULL; 21172| 50.9k| janet_v_push(st->lookup_envs, env); ------------------ | | 757| 50.9k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 50.9k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 50.9k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 46.8k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 46.8k|#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| 46.8k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 46.8k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 4.13k, False: 46.8k] | | | | | | | Branch (768:50): [True: 15.7k, False: 31.0k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 19.9k|#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| 50.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 50.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21173| 50.9k| int32_t offset = readnat(st, &data); 21174| 50.9k| int32_t length = readnat(st, &data); 21175| 50.9k| if (offset > 0) { ------------------ | Branch (21175:13): [True: 1.91k, False: 49.0k] ------------------ 21176| 1.91k| Janet fiberv; 21177| | /* On stack variant */ 21178| 1.91k| data = unmarshal_one(st, data, &fiberv, flags); 21179| 1.91k| janet_asserttype(fiberv, JANET_FIBER, st); 21180| 1.91k| env->as.fiber = janet_unwrap_fiber(fiberv); ------------------ | | 859| 1.91k|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 21181| | /* Negative offset indicates untrusted input */ 21182| 1.91k| env->offset = -offset; 21183| 49.0k| } else { 21184| | /* Off stack variant */ 21185| 49.0k| if (length == 0) { ------------------ | Branch (21185:17): [True: 8, False: 49.0k] ------------------ 21186| 8| janet_panic("invalid funcenv length"); 21187| 8| } 21188| 49.0k| env->as.values = array_allocate(sizeof(Janet), length); 21189| 49.0k| if (!env->as.values) { ------------------ | Branch (21189:17): [True: 0, False: 49.0k] ------------------ 21190| 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] | | ------------------ ------------------ 21191| 0| } 21192| 49.0k| env->offset = 0; 21193| 590k| for (int32_t i = 0; i < length; i++) ------------------ | Branch (21193:33): [True: 541k, False: 49.0k] ------------------ 21194| 541k| data = unmarshal_one(st, data, env->as.values + i, flags); 21195| 49.0k| } 21196| 50.9k| env->length = length; 21197| 50.9k| *out = env; 21198| 50.9k| } 21199| 180k| return data; 21200| 180k|} janet.c:unmarshal_one_abstract: 21637| 23.4k|static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *data, Janet *out, int flags) { 21638| 23.4k| Janet key; 21639| 23.4k| data = unmarshal_one(st, data, &key, flags + 1); 21640| 23.4k| const JanetAbstractType *at = janet_get_abstract_type(key); 21641| 23.4k| if (at == NULL) janet_panic("unknown abstract type"); ------------------ | Branch (21641:9): [True: 65, False: 23.3k] ------------------ 21642| 23.3k| if (at->unmarshal) { ------------------ | Branch (21642:9): [True: 0, False: 23.3k] ------------------ 21643| 0| JanetMarshalContext context = {NULL, st, flags, data, at}; 21644| 0| void *abst = at->unmarshal(&context); 21645| 0| janet_assert(abst != NULL, "null pointer abstract"); ------------------ | | 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] | | ------------------ ------------------ 21646| 0| *out = janet_wrap_abstract(abst); ------------------ | | 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) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21647| 0| if (context.at != NULL) { ------------------ | Branch (21647:13): [True: 0, False: 0] ------------------ 21648| 0| janet_panic("janet_unmarshal_abstract not called"); 21649| 0| } 21650| 0| return context.data; 21651| 0| } 21652| 23.3k| janet_panic("invalid abstract type - no unmarshal function pointer"); 21653| 23.3k|} janet.c:janet_asserttype: 21121| 3.74M|static void janet_asserttype(Janet x, JanetType t, UnmarshalState *st) { 21122| 3.74M| if (!janet_checktype(x, t)) { ------------------ | | 806| 3.74M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [True: 0, False: 3.74M] | | ------------------ | | 807| 3.74M| ? 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.74M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.74M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.74M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.74M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.74M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (21122:9): [True: 379, False: 3.74M] ------------------ 21123| |#ifdef JANET_MARSHAL_DEBUG 21124| | dump_reference_table(st); 21125| |#else 21126| 379| (void) st; 21127| 379|#endif 21128| 379| janet_panicf("expected type %T, got %v", 1 << t, x); 21129| 379| } 21130| 3.74M|} janet.c:number_to_string_b: 30448| 245|static void number_to_string_b(JanetBuffer *buffer, double x) { 30449| 245| janet_buffer_extra(buffer, BUFSIZE); ------------------ | |30442| 245|#define BUFSIZE 64 ------------------ 30450| 245| const char *fmt = (x == floor(x) && ------------------ | Branch (30450:24): [True: 225, False: 20] ------------------ 30451| 225| x <= JANET_INTMAX_DOUBLE && ------------------ | | 165| 470|#define JANET_INTMAX_DOUBLE 9007199254740992.0 ------------------ | Branch (30451:24): [True: 222, False: 3] ------------------ 30452| 222| x >= JANET_INTMIN_DOUBLE) ? "%.0f" : ("%." STR(DBL_DIG) "g"); ------------------ | | 166| 222|#define JANET_INTMIN_DOUBLE (-9007199254740992.0) ------------------ | Branch (30452:24): [True: 144, False: 78] ------------------ 30453| 245| int count; 30454| 245| if (x == 0.0) { ------------------ | Branch (30454:9): [True: 28, False: 217] ------------------ 30455| | /* Prevent printing of '-0' */ 30456| 28| count = 1; 30457| 28| buffer->data[buffer->count] = '0'; 30458| 217| } else { 30459| 217| count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, fmt, x); ------------------ | |30442| 217|#define BUFSIZE 64 ------------------ 30460| 217| } 30461| 245| buffer->count += count; 30462| 245|} janet.c:string_description_b: 30508| 22|static void string_description_b(JanetBuffer *buffer, const char *title, void *pointer) { 30509| 22| janet_buffer_extra(buffer, BUFSIZE); ------------------ | |30442| 22|#define BUFSIZE 64 ------------------ 30510| 22| uint8_t *c = buffer->data + buffer->count; 30511| 22| int32_t i; 30512| 22| union { 30513| 22| uint8_t bytes[sizeof(void *)]; 30514| 22| void *p; 30515| 22| } pbuf; 30516| | 30517| 22| pbuf.p = pointer; 30518| 22| *c++ = '<'; 30519| | /* Maximum of 32 bytes for abstract type name */ 30520| 145| for (i = 0; i < 32 && title[i]; ++i) ------------------ | Branch (30520:17): [True: 145, False: 0] | Branch (30520:27): [True: 123, False: 22] ------------------ 30521| 123| *c++ = ((uint8_t *)title) [i]; 30522| 22| *c++ = ' '; 30523| 22| *c++ = '0'; 30524| 22| *c++ = 'x'; 30525| 22|#if defined(JANET_NANBOX_64) 30526| 22|#define POINTSIZE 6 30527| |#else 30528| |#define POINTSIZE (sizeof(void *)) 30529| |#endif 30530| 154| for (i = POINTSIZE; i > 0; --i) { ------------------ | |30526| 22|#define POINTSIZE 6 ------------------ | Branch (30530:25): [True: 132, False: 22] ------------------ 30531| 132| uint8_t byte = pbuf.bytes[i - 1]; 30532| 132| *c++ = HEX(byte >> 4); ------------------ | |30504| 132|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 30533| 132| *c++ = HEX(byte & 0xF); ------------------ | |30504| 132|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 30534| 132| } 30535| 22| *c++ = '>'; 30536| 22| buffer->count = (int32_t)(c - buffer->data); 30537| 22|#undef POINTSIZE 30538| 22|} janet.c:janet_escape_string_b: 30610| 100|static void janet_escape_string_b(JanetBuffer *buffer, const uint8_t *str) { 30611| | janet_escape_string_impl(buffer, str, janet_string_length(str)); ------------------ | | 1813| 100|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 100|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30612| 100|} janet.c:janet_escape_string_impl: 30540| 126|static int janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) { 30541| 126| janet_buffer_push_u8(buffer, '"'); 30542| 126| int align = 1; 30543| 72.5k| for (int32_t i = 0; i < len; ++i) { ------------------ | Branch (30543:25): [True: 72.4k, False: 126] ------------------ 30544| 72.4k| uint8_t c = str[i]; 30545| 72.4k| switch (c) { 30546| 355| case '"': ------------------ | Branch (30546:13): [True: 355, False: 72.0k] ------------------ 30547| 355| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\"", 2); 30548| 355| align += 2; 30549| 355| break; 30550| 486| case '\n': ------------------ | Branch (30550:13): [True: 486, False: 71.9k] ------------------ 30551| 486| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\n", 2); 30552| 486| align += 2; 30553| 486| break; 30554| 376| case '\r': ------------------ | Branch (30554:13): [True: 376, False: 72.0k] ------------------ 30555| 376| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\r", 2); 30556| 376| align += 2; 30557| 376| break; 30558| 7.19k| case '\0': ------------------ | Branch (30558:13): [True: 7.19k, False: 65.2k] ------------------ 30559| 7.19k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2); 30560| 7.19k| align += 2; 30561| 7.19k| break; 30562| 306| case '\f': ------------------ | Branch (30562:13): [True: 306, False: 72.1k] ------------------ 30563| 306| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2); 30564| 306| align += 2; 30565| 306| break; 30566| 854| case '\v': ------------------ | Branch (30566:13): [True: 854, False: 71.5k] ------------------ 30567| 854| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2); 30568| 854| align += 2; 30569| 854| break; 30570| 338| case '\a': ------------------ | Branch (30570:13): [True: 338, False: 72.0k] ------------------ 30571| 338| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2); 30572| 338| align += 2; 30573| 338| break; 30574| 1.14k| case '\b': ------------------ | Branch (30574:13): [True: 1.14k, False: 71.2k] ------------------ 30575| 1.14k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2); 30576| 1.14k| align += 2; 30577| 1.14k| break; 30578| 554| case 27: ------------------ | Branch (30578:13): [True: 554, False: 71.8k] ------------------ 30579| 554| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2); 30580| 554| align += 2; 30581| 554| break; 30582| 442| case '\\': ------------------ | Branch (30582:13): [True: 442, False: 71.9k] ------------------ 30583| 442| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2); 30584| 442| align += 2; 30585| 442| break; 30586| 282| case '\t': ------------------ | Branch (30586:13): [True: 282, False: 72.1k] ------------------ 30587| 282| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\t", 2); 30588| 282| align += 2; 30589| 282| break; 30590| 60.0k| default: ------------------ | Branch (30590:13): [True: 60.0k, False: 12.3k] ------------------ 30591| 60.0k| if (c < 32 || c > 126) { ------------------ | Branch (30591:21): [True: 4.04k, False: 56.0k] | Branch (30591:31): [True: 42.7k, False: 13.2k] ------------------ 30592| 46.8k| uint8_t buf[4]; 30593| 46.8k| buf[0] = '\\'; 30594| 46.8k| buf[1] = 'x'; 30595| 46.8k| buf[2] = janet_base64[(c >> 4) & 0xF]; 30596| 46.8k| buf[3] = janet_base64[c & 0xF]; 30597| 46.8k| janet_buffer_push_bytes(buffer, buf, 4); 30598| 46.8k| align += 4; 30599| 46.8k| } else { 30600| 13.2k| janet_buffer_push_u8(buffer, c); 30601| 13.2k| align++; 30602| 13.2k| } 30603| 60.0k| break; 30604| 72.4k| } 30605| 72.4k| } 30606| 126| janet_buffer_push_u8(buffer, '"'); 30607| 126| return align + 1; 30608| 126|} janet.c:janet_escape_buffer_b: 30614| 26|static void janet_escape_buffer_b(JanetBuffer *buffer, JanetBuffer *bx) { 30615| 26| if (bx == buffer) { ------------------ | Branch (30615:9): [True: 0, False: 26] ------------------ 30616| | /* Ensures buffer won't resize while escaping */ 30617| 0| int64_t new_size = 6 * (int64_t) bx->count + 3; 30618| 0| if (new_size > INT32_MAX) janet_panic("buffer overflow"); ------------------ | Branch (30618:13): [True: 0, False: 0] ------------------ 30619| 0| janet_buffer_ensure(bx, (int32_t) new_size, 1); 30620| 0| } 30621| 26| janet_buffer_push_u8(buffer, '@'); 30622| 26| janet_escape_string_impl(buffer, bx->data, bx->count); 30623| 26|} janet.c:scanformat: 31356| 2.79k| char precision[3]) { 31357| 2.79k| const char *p = strfrmt; 31358| | 31359| | /* Parse strfrmt */ 31360| 2.79k| memset(width, '\0', 3); 31361| 2.79k| memset(precision, '\0', 3); 31362| 2.79k| while (*p != '\0' && strchr(FMT_FLAGS, *p) != NULL) ------------------ | |31322| 2.79k|#define FMT_FLAGS "-+ #0" ------------------ | Branch (31362:12): [True: 2.79k, False: 0] | Branch (31362:26): [True: 0, False: 2.79k] ------------------ 31363| 0| p++; /* skip flags */ 31364| 2.79k| if ((size_t)(p - strfrmt) >= sizeof(FMT_FLAGS)) janet_panic("invalid format (repeated flags)"); ------------------ | |31322| 2.79k|#define FMT_FLAGS "-+ #0" ------------------ | Branch (31364:9): [True: 0, False: 2.79k] ------------------ 31365| 2.79k| if (isdigit((int)(*p))) ------------------ | Branch (31365:9): [True: 0, False: 2.79k] ------------------ 31366| 0| width[0] = *p++; /* skip width */ 31367| 2.79k| if (isdigit((int)(*p))) ------------------ | Branch (31367:9): [True: 0, False: 2.79k] ------------------ 31368| 0| width[1] = *p++; /* (2 digits at most) */ 31369| 2.79k| if (*p == '.') { ------------------ | Branch (31369:9): [True: 0, False: 2.79k] ------------------ 31370| 0| p++; 31371| 0| if (isdigit((int)(*p))) ------------------ | Branch (31371:13): [True: 0, False: 0] ------------------ 31372| 0| precision[0] = *p++; /* skip precision */ 31373| 0| if (isdigit((int)(*p))) ------------------ | Branch (31373:13): [True: 0, False: 0] ------------------ 31374| 0| precision[1] = *p++; /* (2 digits at most) */ 31375| 0| } 31376| 2.79k| if (isdigit((int)(*p))) ------------------ | Branch (31376:9): [True: 0, False: 2.79k] ------------------ 31377| 0| janet_panic("invalid format (width or precision too long)"); 31378| | 31379| | /* Write to form - replace characters with fixed size stuff */ 31380| 2.79k| *(form++) = '%'; 31381| 2.79k| const char *p2 = strfrmt; 31382| 5.58k| while (p2 <= p) { ------------------ | Branch (31382:12): [True: 2.79k, False: 2.79k] ------------------ 31383| 2.79k| char *loc = strchr(FMT_REPLACE_INTTYPES, *p2); ------------------ | |31323| 2.79k|#define FMT_REPLACE_INTTYPES "diouxX" ------------------ 31384| 2.79k| if (loc != NULL && *loc != '\0') { ------------------ | Branch (31384:13): [True: 2.00k, False: 794] | Branch (31384:28): [True: 2.00k, False: 0] ------------------ 31385| 2.00k| const char *mapping = get_fmt_mapping(*p2++); 31386| 2.00k| size_t len = strlen(mapping); 31387| 2.00k| memcpy(form, mapping, len); 31388| 2.00k| form += len; 31389| 2.00k| } else { 31390| 794| *(form++) = *(p2++); 31391| 794| } 31392| 2.79k| } 31393| 2.79k| *form = '\0'; 31394| | 31395| 2.79k| return p; 31396| 2.79k|} janet.c:get_fmt_mapping: 31344| 2.00k|static const char *get_fmt_mapping(char c) { 31345| 8.01k| for (size_t i = 0; i < (sizeof(format_mappings) / sizeof(struct FmtMapping)); i++) { ------------------ | Branch (31345:24): [True: 8.01k, False: 0] ------------------ 31346| 8.01k| if (format_mappings[i].c == c) ------------------ | Branch (31346:13): [True: 2.00k, False: 6.01k] ------------------ 31347| 2.00k| return format_mappings[i].mapping; 31348| 8.01k| } 31349| 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] | | ------------------ ------------------ 31350| 0|} janet.c:pushtypes: 31300| 379|static void pushtypes(JanetBuffer *buffer, int types) { 31301| 379| int first = 1; 31302| 379| int i = 0; 31303| 3.33k| while (types) { ------------------ | Branch (31303:12): [True: 2.95k, False: 379] ------------------ 31304| 2.95k| if (1 & types) { ------------------ | Branch (31304:13): [True: 379, False: 2.57k] ------------------ 31305| 379| if (first) { ------------------ | Branch (31305:17): [True: 379, False: 0] ------------------ 31306| 379| first = 0; 31307| 379| } else { 31308| 0| janet_buffer_push_cstring(buffer, (types == 1) ? " or " : ", "); ------------------ | Branch (31308:51): [True: 0, False: 0] ------------------ 31309| 0| } 31310| 379| janet_buffer_push_cstring(buffer, janet_type_names[i]); 31311| 379| } 31312| 2.95k| i++; 31313| 2.95k| types >>= 1; 31314| 2.95k| } 31315| 379|} janet.c:janet_dict_find: 433| 40.7M|static inline const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) { 434| 40.7M| int32_t hash; 435| 40.7M| if (janet_checktype(key, JANET_KEYWORD) || janet_checktype(key, JANET_SYMBOL)) { ------------------ | | 806| 81.5M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 17.6M, False: 23.0M] | | | Branch (806:6): [Folded, False: 40.7M] | | ------------------ | | 807| 81.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| 81.5M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 40.7M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 40.7M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 40.7M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 40.7M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(key, JANET_KEYWORD) || janet_checktype(key, JANET_SYMBOL)) { ------------------ | | 806| 23.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 16.3M, False: 6.73M] | | | Branch (806:6): [Folded, False: 23.0M] | | ------------------ | | 807| 23.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| 23.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 23.0M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 23.0M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 23.0M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 23.0M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 436| 34.0M| hash = janet_string_hash(janet_unwrap_string(key)); ------------------ | | 1814| 34.0M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 34.0M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 437| 34.0M| } else if (janet_checktypes(key, JANET_TFLAG_NIL | JANET_TFLAG_STRING | JANET_TFLAG_TUPLE | JANET_TFLAG_STRUCT | JANET_TFLAG_ABSTRACT) || ------------------ | | 969| 13.4M|#define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps)) | | ------------------ | | | | 795| 6.73M| (isnan((x).number) \ | | | | 796| 6.73M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | | | 797| 6.73M| : JANET_NUMBER) | | ------------------ | | | Branch (969:34): [True: 124k, False: 6.60M] | | ------------------ ------------------ | Branch (437:16): [True: 6.43M, False: 302k] ------------------ 438| 6.60M| (janet_checktype(key, JANET_NUMBER) && janet_unwrap_number(key) == 0)) { ------------------ | | 806| 13.2M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 302k, False: 6.30M] | | | Branch (806:6): [True: 6.60M, Folded] | | ------------------ | | 807| 13.2M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 6.60M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 302k, False: 6.30M] | | | | | Branch (803:28): [True: 1, False: 6.30M] | | | | ------------------ | | ------------------ | | 808| 13.2M| : 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| 302k|#define janet_unwrap_number(x) ((x).number) ------------------ | Branch (438:55): [True: 92.2k, False: 209k] ------------------ 439| 216k| return janet_dict_find_deep(buckets, cap, key); 440| 6.51M| } else { 441| 6.51M| hash = janet_hash(key); 442| 6.51M| } 443| 40.5M| uint32_t mask = (uint32_t) cap - 1; 444| 40.5M| uint32_t i = (uint32_t) hash & mask; 445| 40.5M| const JanetKV *first_bucket = NULL; 446| 52.5M| for (int32_t n = 0; n < cap; n++, i = (i + 1) & mask) { ------------------ | Branch (446:25): [True: 52.5M, False: 0] ------------------ 447| 52.5M| const JanetKV *kv = buckets + i; 448| 52.5M| if (janet_bitwise_same(kv->key, key)) return kv; ------------------ | | 401| 52.5M|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 52.5M|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 52.5M|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 4.01M, False: 48.5M] | | ------------------ ------------------ 449| 48.5M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 48.5M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 36.5M, False: 11.9M] | | | Branch (806:6): [Folded, False: 48.5M] | | ------------------ | | 807| 48.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| 48.5M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 48.5M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 48.5M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 48.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 48.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 450| 36.5M| if (janet_checktype(kv->value, JANET_NIL)) return kv; ------------------ | | 806| 36.5M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 36.5M, False: 13.2k] | | | Branch (806:6): [Folded, False: 36.5M] | | ------------------ | | 807| 36.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| 36.5M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 36.5M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 36.5M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 36.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 36.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 451| 13.2k| if (NULL == first_bucket) first_bucket = kv; ------------------ | Branch (451:17): [True: 7.67k, False: 5.53k] ------------------ 452| 13.2k| } 453| 48.5M| } 454| 0| return first_bucket; 455| 40.5M|} janet.c:janet_symcache_findmem: 35042| 26.3M| int *success) { 35043| 26.3M| uint32_t bounds[4]; 35044| 26.3M| uint32_t i, j, index; 35045| 26.3M| const uint8_t **firstEmpty = NULL; 35046| | 35047| | /* We will search two ranges - index to the end, 35048| | * and 0 to the index. */ 35049| 26.3M| index = (uint32_t)hash & (janet_vm.cache_capacity - 1); 35050| 26.3M| bounds[0] = index; 35051| 26.3M| bounds[1] = janet_vm.cache_capacity; 35052| 26.3M| bounds[2] = 0; 35053| 26.3M| bounds[3] = index; 35054| 26.3M| for (j = 0; j < 4; j += 2) ------------------ | Branch (35054:17): [True: 26.3M, False: 0] ------------------ 35055| 39.4M| for (i = bounds[j]; i < bounds[j + 1]; ++i) { ------------------ | Branch (35055:29): [True: 39.4M, False: 7.98k] ------------------ 35056| 39.4M| const uint8_t *test = janet_vm.cache[i]; 35057| | /* Check empty spots */ 35058| 39.4M| if (NULL == test) { ------------------ | Branch (35058:17): [True: 13.1M, False: 26.2M] ------------------ 35059| 13.1M| if (NULL == firstEmpty) ------------------ | Branch (35059:21): [True: 13.1M, False: 0] ------------------ 35060| 13.1M| firstEmpty = janet_vm.cache + i; 35061| 13.1M| goto notfound; 35062| 13.1M| } 35063| | /* Check for marked deleted */ 35064| 26.2M| if (JANET_SYMCACHE_DELETED == test) { ------------------ | Branch (35064:17): [True: 3.76k, False: 26.2M] ------------------ 35065| 3.76k| if (firstEmpty == NULL) ------------------ | Branch (35065:21): [True: 3.71k, False: 49] ------------------ 35066| 3.71k| firstEmpty = janet_vm.cache + i; 35067| 3.76k| continue; 35068| 3.76k| } 35069| 26.2M| if (janet_string_equalconst(test, str, len, hash)) { ------------------ | Branch (35069:17): [True: 13.1M, False: 13.1M] ------------------ 35070| | /* Replace first deleted */ 35071| 13.1M| *success = 1; 35072| 13.1M| if (firstEmpty != NULL) { ------------------ | Branch (35072:21): [True: 3.71k, False: 13.1M] ------------------ 35073| 3.71k| *firstEmpty = test; 35074| 3.71k| janet_vm.cache[i] = JANET_SYMCACHE_DELETED; 35075| 3.71k| return firstEmpty; 35076| 3.71k| } 35077| 13.1M| return janet_vm.cache + i; 35078| 13.1M| } 35079| 26.2M| } 35080| 13.1M|notfound: 35081| 13.1M| *success = 0; 35082| 13.1M| janet_assert(firstEmpty != NULL, "symcache failed to get memory"); ------------------ | | 389| 13.1M|#define janet_assert(c, m) do { \ | | 390| 13.1M| 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: 13.1M] | | ------------------ | | 391| 13.1M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 13.1M] | | ------------------ ------------------ 35083| 13.1M| return firstEmpty; 35084| 13.1M|} janet.c:janet_symcache_put: 35120| 7.41M|static void janet_symcache_put(const uint8_t *x, const uint8_t **bucket) { 35121| 7.41M| if ((janet_vm.cache_count + janet_vm.cache_deleted) * 2 > janet_vm.cache_capacity) { ------------------ | Branch (35121:9): [True: 7.43k, False: 7.40M] ------------------ 35122| 7.43k| int status; 35123| 7.43k| janet_cache_resize(janet_tablen((2 * janet_vm.cache_count + 1))); 35124| 7.43k| bucket = janet_symcache_find(x, &status); ------------------ | |35087| 7.43k| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 7.43k|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 7.43k|#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| 7.43k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 7.43k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35125| 7.43k| } 35126| | /* Add x to the cache */ 35127| 7.41M| janet_vm.cache_count++; 35128| 7.41M| *bucket = x; 35129| 7.41M|} janet.c:janet_cache_resize: 35090| 7.43k|static void janet_cache_resize(uint32_t newCapacity) { 35091| 7.43k| uint32_t i, oldCapacity; 35092| 7.43k| const uint8_t **oldCache = janet_vm.cache; 35093| 7.43k| const uint8_t **newCache = janet_calloc(1, (size_t) newCapacity * sizeof(const uint8_t *)); ------------------ | | 2412| 7.43k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 35094| 7.43k| if (newCache == NULL) { ------------------ | Branch (35094:9): [True: 0, False: 7.43k] ------------------ 35095| 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] | | ------------------ ------------------ 35096| 0| } 35097| 7.43k| oldCapacity = janet_vm.cache_capacity; 35098| 7.43k| janet_vm.cache = newCache; 35099| 7.43k| janet_vm.cache_capacity = newCapacity; 35100| 7.43k| janet_vm.cache_deleted = 0; 35101| | /* Add all of the old cache entries back */ 35102| 11.4M| for (i = 0; i < oldCapacity; ++i) { ------------------ | Branch (35102:17): [True: 11.4M, False: 7.43k] ------------------ 35103| 11.4M| int status; 35104| 11.4M| const uint8_t **bucket; 35105| 11.4M| const uint8_t *x = oldCache[i]; 35106| 11.4M| if (x != NULL && x != JANET_SYMCACHE_DELETED) { ------------------ | Branch (35106:13): [True: 5.75M, False: 5.73M] | Branch (35106:26): [True: 5.75M, False: 0] ------------------ 35107| 5.75M| bucket = janet_symcache_find(x, &status); ------------------ | |35087| 5.75M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 5.75M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 5.75M|#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| 5.75M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 5.75M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35108| 5.75M| if (status || bucket == NULL) { ------------------ | Branch (35108:17): [True: 0, False: 5.75M] | Branch (35108:27): [True: 0, False: 5.75M] ------------------ 35109| | /* there was a problem with the algorithm. */ 35110| 0| break; 35111| 0| } 35112| 5.75M| *bucket = x; 35113| 5.75M| } 35114| 11.4M| } 35115| | /* Free the old cache */ 35116| 7.43k| janet_free((void *)oldCache); ------------------ | | 2415| 7.43k|#define janet_free(X) free((X)) ------------------ 35117| 7.43k|} janet.c:janet_table_init_impl: 35261| 2.80M|static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) { 35262| 2.80M| JanetKV *data; 35263| 2.80M| capacity = janet_tablen(capacity); 35264| 2.80M| if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK; ------------------ | |35247| 0|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (35264:9): [True: 0, False: 2.80M] ------------------ 35265| 2.80M| if (capacity) { ------------------ | Branch (35265:9): [True: 2.80M, False: 0] ------------------ 35266| 2.80M| if (stackalloc) { ------------------ | Branch (35266:13): [True: 0, False: 2.80M] ------------------ 35267| 0| data = janet_memalloc_empty_local(capacity); 35268| 2.80M| } else { 35269| 2.80M| data = (JanetKV *) janet_memalloc_empty(capacity); 35270| 2.80M| if (NULL == data) { ------------------ | Branch (35270:17): [True: 0, False: 2.80M] ------------------ 35271| 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] | | ------------------ ------------------ 35272| 0| } 35273| 2.80M| } 35274| 2.80M| table->data = data; 35275| 2.80M| table->capacity = capacity; 35276| 2.80M| } else { 35277| 0| table->data = NULL; 35278| 0| table->capacity = 0; 35279| 0| } 35280| 2.80M| table->count = 0; 35281| 2.80M| table->deleted = 0; 35282| | table->proto = NULL; 35283| 2.80M| return table; 35284| 2.80M|} janet.c:janet_table_rehash: 35334| 2.21M|static void janet_table_rehash(JanetTable *t, int32_t size) { 35335| 2.21M| JanetKV *olddata = t->data; 35336| 2.21M| JanetKV *newdata; 35337| 2.21M| int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK; ------------------ | |35247| 2.21M|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ 35338| 2.21M| if (islocal) { ------------------ | Branch (35338:9): [True: 0, False: 2.21M] ------------------ 35339| 0| newdata = (JanetKV *) janet_memalloc_empty_local(size); 35340| 2.21M| } else { 35341| 2.21M| newdata = (JanetKV *) janet_memalloc_empty(size); 35342| 2.21M| if (NULL == newdata) { ------------------ | Branch (35342:13): [True: 0, False: 2.21M] ------------------ 35343| 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] | | ------------------ ------------------ 35344| 0| } 35345| 2.21M| } 35346| 2.21M| int32_t oldcapacity = t->capacity; 35347| 2.21M| t->data = newdata; 35348| 2.21M| t->capacity = size; 35349| 2.21M| t->deleted = 0; 35350| 30.3M| for (int32_t i = 0; i < oldcapacity; i++) { ------------------ | Branch (35350:25): [True: 28.1M, False: 2.21M] ------------------ 35351| 28.1M| JanetKV *kv = olddata + i; 35352| 28.1M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 28.1M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 28.1M] | | ------------------ | | 807| 28.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| 28.1M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 28.1M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 28.1M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 28.1M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 28.1M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35352:13): [True: 14.0M, False: 14.0M] ------------------ 35353| 14.0M| JanetKV *newkv = janet_table_find(t, kv->key); 35354| 14.0M| *newkv = *kv; 35355| 14.0M| } 35356| 28.1M| } 35357| 2.21M| if (islocal) { ------------------ | Branch (35357:9): [True: 0, False: 2.21M] ------------------ 35358| 0| janet_sfree(olddata); 35359| 2.21M| } else { 35360| 2.21M| janet_free(olddata); ------------------ | | 2415| 2.21M|#define janet_free(X) free((X)) ------------------ 35361| 2.21M| } 35362| 2.21M|} janet.c:janet_registry_sort: 36322| 2|static void janet_registry_sort(void) { 36323| 704| for (size_t i = 1; i < janet_vm.registry_count; i++) { ------------------ | Branch (36323:24): [True: 702, False: 2] ------------------ 36324| 702| JanetCFunRegistry reg = janet_vm.registry[i]; 36325| 702| size_t j; 36326| 49.4k| for (j = i; j > 0; j--) { ------------------ | Branch (36326:21): [True: 49.4k, False: 6] ------------------ 36327| 49.4k| if ((void *)(janet_vm.registry[j - 1].cfun) < (void *)(reg.cfun)) break; ------------------ | Branch (36327:17): [True: 696, False: 48.7k] ------------------ 36328| 48.7k| janet_vm.registry[j] = janet_vm.registry[j - 1]; 36329| 48.7k| } 36330| 702| janet_vm.registry[j] = reg; 36331| 702| } 36332| 2| janet_vm.registry_dirty = 0; 36333| 2|} janet.c:janet_check_pointer_align: 36423| 1.33M|static void janet_check_pointer_align(void *p) { 36424| 1.33M| (void) p; 36425| |#if defined(JANET_NANBOX_64) && JANET_NANBOX_64_POINTER_SHIFT != 0 36426| | union { 36427| | void *p; 36428| | uintptr_t u; 36429| | } un; 36430| | un.p = p; 36431| | janet_assert(!(un.u & (uintptr_t)((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), 36432| | "unaligned pointer wrap - cfunction pointers and abstract types must be aligned with this nanboxing configuration."); 36433| |#endif 36434| 1.33M|} janet.c:janet_equals_containers: 37334| 38.9k|static int janet_equals_containers(Janet x, Janet y) { 37335| 38.9k| janet_vm.traversal = janet_vm.traversal_base; 37336| 106k| do { 37337| 106k| if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 106k| (isnan((x).number) \ | | 796| 106k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 106k| : JANET_NUMBER) ------------------ if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 106k| (isnan((x).number) \ | | 796| 106k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 106k| : JANET_NUMBER) ------------------ | Branch (37337:13): [True: 89.4k, False: 17.5k] | Branch (37337:13): [True: 702, False: 106k] | Branch (37337:30): [True: 90.0k, False: 16.9k] ------------------ 37338| 106k| switch (janet_type(x)) { ------------------ | | 795| 106k| (isnan((x).number) \ | | 796| 106k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 106k| : JANET_NUMBER) ------------------ | Branch (37338:17): [True: 89.3k, False: 16.9k] ------------------ 37339| 64.0k| default: ------------------ | Branch (37339:13): [True: 64.0k, False: 42.1k] ------------------ 37340| 64.0k| if (!janet_equals_leaf(x, y)) return 0; ------------------ | Branch (37340:21): [True: 86, False: 63.9k] ------------------ 37341| 63.9k| break; 37342| 63.9k| case JANET_TUPLE: { ------------------ | Branch (37342:13): [True: 33.1k, False: 73.0k] ------------------ 37343| 33.1k| const Janet *t1 = janet_unwrap_tuple(x); ------------------ | | 858| 33.1k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37344| 33.1k| const Janet *t2 = janet_unwrap_tuple(y); ------------------ | | 858| 33.1k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37345| 33.1k| if (t1 == t2) break; ------------------ | Branch (37345:21): [True: 214, False: 32.9k] ------------------ 37346| 32.9k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1798| 32.9k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1806| 32.9k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 32.9k|#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| 32.9k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 32.9k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37346:21): [True: 993, False: 31.9k] ------------------ 37347| 31.9k| if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1803| 31.9k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 31.9k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1803| 31.9k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 31.9k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37347:21): [True: 4.14k, False: 27.8k] ------------------ 37348| 27.8k| if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1802| 27.8k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 27.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1802| 27.8k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 27.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37348:21): [True: 0, False: 27.8k] ------------------ 37349| 27.8k| push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1800| 27.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1800| 27.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 37350| 27.8k| break; 37351| 27.8k| } 37352| 9.00k| case JANET_STRUCT: { ------------------ | Branch (37352:13): [True: 9.00k, False: 97.2k] ------------------ 37353| 9.00k| const JanetKV *s1 = janet_unwrap_struct(x); ------------------ | | 857| 9.00k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37354| 9.00k| const JanetKV *s2 = janet_unwrap_struct(y); ------------------ | | 857| 9.00k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37355| 9.00k| if (s1 == s2) break; ------------------ | Branch (37355:21): [True: 207, False: 8.79k] ------------------ 37356| 8.79k| if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1850| 8.79k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 8.79k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1850| 8.79k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 8.79k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37356:21): [True: 1.05k, False: 7.74k] ------------------ 37357| 7.74k| if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1848| 7.74k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 7.74k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1848| 7.74k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 7.74k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37357:21): [True: 238, False: 7.50k] ------------------ 37358| 7.50k| if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1851| 15.0k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 7.50k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 925, False: 6.57k] | | ------------------ ------------------ if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1851| 925|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 925|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37358:47): [True: 0, False: 925] ------------------ 37359| 7.50k| if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1851| 15.0k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 7.50k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1851| 6.57k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 6.57k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 0, False: 6.57k] | | ------------------ ------------------ | Branch (37359:21): [True: 6.57k, False: 925] ------------------ 37360| 7.50k| push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1846| 7.50k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1846| 7.50k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 37361| 7.50k| break; 37362| 7.50k| } 37363| 106k| } 37364| 106k| } while (!traversal_next(&x, &y)); ------------------ | Branch (37364:14): [True: 68.0k, False: 31.7k] ------------------ 37365| 31.7k| return 1; 37366| 38.9k|} janet.c:janet_equals_leaf: 37321| 93.6k|static int janet_equals_leaf(Janet x, Janet y) { 37322| 93.6k| switch (janet_type(x)) { ------------------ | | 795| 93.6k| (isnan((x).number) \ | | 796| 93.6k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 93.6k| : JANET_NUMBER) ------------------ | Branch (37322:13): [True: 49.8k, False: 43.8k] ------------------ 37323| 43.8k| case JANET_NUMBER: ------------------ | Branch (37323:9): [True: 43.8k, False: 49.7k] ------------------ 37324| 43.8k| return janet_unwrap_number(x) == janet_unwrap_number(y); ------------------ | | 839| 43.8k|#define janet_unwrap_number(x) ((x).number) ------------------ return janet_unwrap_number(x) == janet_unwrap_number(y); ------------------ | | 839| 43.8k|#define janet_unwrap_number(x) ((x).number) ------------------ 37325| 3.45k| case JANET_STRING: ------------------ | Branch (37325:9): [True: 3.45k, False: 90.1k] ------------------ 37326| 3.45k| return janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 3.45k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ return janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 3.45k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 37327| 27| case JANET_ABSTRACT: ------------------ | Branch (37327:9): [True: 27, False: 93.6k] ------------------ 37328| 27| return !janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 27|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ return !janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 27|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37329| 46.2k| default: ------------------ | Branch (37329:9): [True: 46.2k, False: 47.3k] ------------------ 37330| 46.2k| return janet_bitwise_same(x, y); ------------------ | | 401| 46.2k|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 46.2k|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 46.2k|#define janet_u64(x) ((x).u64) | | ------------------ ------------------ 37331| 93.6k| } 37332| 93.6k|} janet.c:murmur64: 37374| 13.4M|static uint64_t murmur64(uint64_t h) { 37375| 13.4M| h ^= h >> 33; 37376| 13.4M| h *= 0xff51afd7ed558ccdUL; 37377| 13.4M| h ^= h >> 33; 37378| 13.4M| h *= 0xc4ceb9fe1a85ec53UL; 37379| 13.4M| h ^= h >> 33; 37380| 13.4M| return h; 37381| 13.4M|} janet.c:janet_compare_abstract: 37307| 27|static int janet_compare_abstract(JanetAbstract xx, JanetAbstract yy) { 37308| 27| if (xx == yy) return 0; ------------------ | Branch (37308:9): [True: 0, False: 27] ------------------ 37309| 27| const JanetAbstractType *xt = janet_abstract_type(xx); ------------------ | | 1899| 27|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 27|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37310| 27| const JanetAbstractType *yt = janet_abstract_type(yy); ------------------ | | 1899| 27|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 27|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37311| 27| if (xt != yt) { ------------------ | Branch (37311:9): [True: 0, False: 27] ------------------ 37312| 0| return xt > yt ? 1 : -1; ------------------ | Branch (37312:16): [True: 0, False: 0] ------------------ 37313| 0| } 37314| 27| if (xt->compare == NULL) { ------------------ | Branch (37314:9): [True: 27, False: 0] ------------------ 37315| 27| return xx > yy ? 1 : -1; ------------------ | Branch (37315:16): [True: 2, False: 25] ------------------ 37316| 27| } 37317| 0| return xt->compare(xx, yy); 37318| 27|} janet.c:push_traversal_node: 37105| 142k|static void push_traversal_node(void *lhs, void *rhs, int32_t index2) { 37106| 142k| JanetTraversalNode node; 37107| 142k| node.self = (JanetGCObject *) lhs; 37108| 142k| node.other = (JanetGCObject *) rhs; 37109| 142k| node.index = 0; 37110| 142k| node.index2 = index2; 37111| 142k| int is_new = janet_vm.traversal_base == NULL; 37112| 142k| if (is_new || (janet_vm.traversal + 1 >= janet_vm.traversal_top)) { ------------------ | Branch (37112:9): [True: 520, False: 142k] | Branch (37112:19): [True: 0, False: 142k] ------------------ 37113| 520| size_t oldsize = is_new ? 0 : (janet_vm.traversal - janet_vm.traversal_base); ------------------ | Branch (37113:26): [True: 520, False: 0] ------------------ 37114| 520| size_t newsize = 2 * oldsize + 1; 37115| 520| if (newsize < 128) { ------------------ | Branch (37115:13): [True: 520, False: 0] ------------------ 37116| 520| newsize = 128; 37117| 520| } 37118| 520| JanetTraversalNode *tn = janet_realloc(janet_vm.traversal_base, newsize * sizeof(JanetTraversalNode)); ------------------ | | 2409| 520|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 37119| 520| if (tn == NULL) { ------------------ | Branch (37119:13): [True: 0, False: 520] ------------------ 37120| 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] | | ------------------ ------------------ 37121| 0| } 37122| 520| janet_vm.traversal_base = tn; 37123| 520| janet_vm.traversal_top = janet_vm.traversal_base + newsize; 37124| 520| janet_vm.traversal = janet_vm.traversal_base + oldsize; 37125| 520| } 37126| 142k| *(++janet_vm.traversal) = node; 37127| 142k|} janet.c:traversal_next: 37137| 685k|static int traversal_next(Janet *x, Janet *y) { 37138| 685k| JanetTraversalNode *t = janet_vm.traversal; 37139| 824k| while (t && t > janet_vm.traversal_base) { ------------------ | Branch (37139:12): [True: 736k, False: 88.6k] | Branch (37139:17): [True: 340k, False: 395k] ------------------ 37140| 340k| JanetGCObject *self = t->self; 37141| 340k| JanetTupleHead *tself = (JanetTupleHead *)self; 37142| 340k| JanetStructHead *sself = (JanetStructHead *)self; 37143| 340k| JanetGCObject *other = t->other; 37144| 340k| JanetTupleHead *tother = (JanetTupleHead *)other; 37145| 340k| JanetStructHead *sother = (JanetStructHead *)other; 37146| 340k| if ((self->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_TUPLE) { ------------------ | | 675| 340k|#define JANET_MEM_TYPEBITS 0xFF ------------------ | Branch (37146:13): [True: 101k, False: 238k] ------------------ 37147| | /* Node is a tuple at index t->index */ 37148| 101k| if (t->index < tself->length && t->index < tother->length) { ------------------ | Branch (37148:17): [True: 15.9k, False: 85.4k] | Branch (37148:45): [True: 15.9k, False: 0] ------------------ 37149| 15.9k| int32_t index = t->index++; 37150| 15.9k| *x = tself->data[index]; 37151| 15.9k| *y = tother->data[index]; 37152| 15.9k| janet_vm.traversal = t; 37153| 15.9k| return 0; 37154| 15.9k| } 37155| 85.4k| if (t->index2 && tself->length != tother->length) { ------------------ | Branch (37155:17): [True: 58.3k, False: 27.1k] | Branch (37155:30): [True: 0, False: 58.3k] ------------------ 37156| 0| return tself->length > tother->length ? 3 : 1; ------------------ | Branch (37156:24): [True: 0, False: 0] ------------------ 37157| 0| } 37158| 238k| } else { 37159| | /* Node is a struct at index t->index: if t->index2 is true, we should return the values. */ 37160| 238k| if (t->index2) { ------------------ | Branch (37160:17): [True: 91.4k, False: 147k] ------------------ 37161| 91.4k| t->index2 = 0; 37162| 91.4k| int32_t index = t->index++; 37163| 91.4k| *x = sself->data[index].value; 37164| 91.4k| *y = sother->data[index].value; 37165| 91.4k| janet_vm.traversal = t; 37166| 91.4k| return 0; 37167| 91.4k| } 37168| 147k| for (int32_t i = t->index; i < sself->capacity; i++) { ------------------ | Branch (37168:40): [True: 91.8k, False: 55.6k] ------------------ 37169| 91.8k| t->index2 = 1; 37170| 91.8k| *x = sself->data[t->index].key; 37171| 91.8k| *y = sother->data[t->index].key; 37172| 91.8k| janet_vm.traversal = t; 37173| 91.8k| return 0; 37174| 91.8k| } 37175| | /* Traverse prototype */ 37176| 55.6k| JanetStruct sproto = sself->proto; 37177| 55.6k| JanetStruct oproto = sother->proto; 37178| 55.6k| if (sproto && !oproto) return 3; ------------------ | Branch (37178:17): [True: 1.85k, False: 53.8k] | Branch (37178:27): [True: 0, False: 1.85k] ------------------ 37179| 55.6k| if (!sproto && oproto) return 1; ------------------ | Branch (37179:17): [True: 53.8k, False: 1.85k] | Branch (37179:28): [True: 0, False: 53.8k] ------------------ 37180| 55.6k| if (oproto && sproto) { ------------------ | Branch (37180:17): [True: 1.85k, False: 53.8k] | Branch (37180:27): [True: 1.85k, False: 0] ------------------ 37181| 1.85k| *x = janet_wrap_struct(sproto); ------------------ | | 842| 1.85k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 1.85k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.85k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.85k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37182| 1.85k| *y = janet_wrap_struct(oproto); ------------------ | | 842| 1.85k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 1.85k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.85k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.85k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37183| 1.85k| janet_vm.traversal = t - 1; 37184| 1.85k| return 0; 37185| 1.85k| } 37186| 55.6k| } 37187| 139k| t--; 37188| 139k| } 37189| 484k| janet_vm.traversal = t; 37190| 484k| return 2; 37191| 685k|} LLVMFuzzerTestOneInput: 9| 3.70k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 10| | 11| | /* init Janet */ 12| 3.70k| janet_init(); 13| | 14| | /* fuzz the binary unmarshal (deserialization) path in src/core/marsh.c */ 15| 3.70k| JanetTable *reg = janet_env_lookup(janet_core_env(NULL)); 16| 3.70k| JanetTryState tstate; 17| 3.70k| if (janet_try(&tstate) == JANET_SIGNAL_OK) { ------------------ | | 1981| 3.70k|#define janet_try(state) (janet_try_init(state), (JanetSignal) setjmp((state)->buf)) ------------------ | Branch (17:9): [True: 3.70k, False: 0] ------------------ 18| 3.70k| const uint8_t *next = NULL; 19| 3.70k| janet_unmarshal(data, size, 0, reg, &next); 20| 3.70k| } 21| 3.70k| janet_restore(&tstate); 22| | 23| | /* cleanup Janet */ 24| 3.70k| janet_deinit(); 25| | 26| 3.70k| return 0; 27| 3.70k|}