janet_abstract_begin: 1330| 9.68k|void *janet_abstract_begin(const JanetAbstractType *atype, size_t size) { 1331| 9.68k| JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_NONE, 1332| 9.68k| sizeof(JanetAbstractHead) + size); 1333| 9.68k| header->size = size; 1334| 9.68k| header->type = atype; 1335| 9.68k| return (void *) & (header->data); 1336| 9.68k|} janet_abstract_end: 1338| 9.68k|void *janet_abstract_end(void *x) { 1339| 9.68k| janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_ABSTRACT); ------------------ | | 628| 9.68k|#define janet_gc_settype(m, t) ((janet_gc_header(m)->flags |= (0xFF & (t)))) | | ------------------ | | | | 622| 9.68k|#define janet_gc_header(mem) ((JanetGCObject *)(mem)) | | ------------------ ------------------ 1340| 9.68k| return x; 1341| 9.68k|} janet_abstract: 1343| 9.68k|void *janet_abstract(const JanetAbstractType *atype, size_t size) { 1344| 9.68k| return janet_abstract_end(janet_abstract_begin(atype, size)); 1345| 9.68k|} janet_array: 1562| 19.3k|JanetArray *janet_array(int32_t capacity) { 1563| 19.3k| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); 1564| 19.3k| janet_array_impl(array, capacity); 1565| 19.3k| return array; 1566| 19.3k|} janet_array_weak: 1569| 13.8k|JanetArray *janet_array_weak(int32_t capacity) { 1570| 13.8k| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY_WEAK, sizeof(JanetArray)); 1571| 13.8k| janet_array_impl(array, capacity); 1572| 13.8k| return array; 1573| 13.8k|} janet_lib_array: 1911| 3.22k|void janet_lib_array(JanetTable *env) { 1912| 3.22k| JanetRegExt array_cfuns[] = { 1913| 3.22k| JANET_CORE_REG("array/new", cfun_array_new), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1914| 3.22k| JANET_CORE_REG("array/weak", cfun_array_weak), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1915| 3.22k| JANET_CORE_REG("array/new-filled", cfun_array_new_filled), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1916| 3.22k| JANET_CORE_REG("array/fill", cfun_array_fill), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1917| 3.22k| JANET_CORE_REG("array/pop", cfun_array_pop), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1918| 3.22k| JANET_CORE_REG("array/peek", cfun_array_peek), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1919| 3.22k| JANET_CORE_REG("array/push", cfun_array_push), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1920| 3.22k| JANET_CORE_REG("array/ensure", cfun_array_ensure), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1921| 3.22k| JANET_CORE_REG("array/slice", cfun_array_slice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1922| 3.22k| JANET_CORE_REG("array/concat", cfun_array_concat), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1923| 3.22k| JANET_CORE_REG("array/insert", cfun_array_insert), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1924| 3.22k| JANET_CORE_REG("array/remove", cfun_array_remove), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1925| 3.22k| JANET_CORE_REG("array/trim", cfun_array_trim), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1926| 3.22k| JANET_CORE_REG("array/clear", cfun_array_clear), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1927| 3.22k| JANET_CORE_REG("array/join", cfun_array_join), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1928| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 1929| 3.22k| }; 1930| | janet_core_cfuns_ext(env, NULL, array_cfuns); 1931| 3.22k|} janet_lib_asm: 3061| 3.22k|void janet_lib_asm(JanetTable *env) { 3062| 3.22k| JanetRegExt asm_cfuns[] = { 3063| 3.22k| JANET_CORE_REG("asm", cfun_asm), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3064| 3.22k| JANET_CORE_REG("disasm", cfun_disasm), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3065| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3066| 3.22k| }; 3067| | janet_core_cfuns_ext(env, NULL, asm_cfuns); 3068| 3.22k|} janet_buffer_init: 3129| 1.27k|JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) { 3130| 1.27k| janet_buffer_init_impl(buffer, capacity); 3131| 1.27k| buffer->gc.data.next = NULL; 3132| 1.27k| buffer->gc.flags = JANET_MEM_DISABLED; ------------------ | | 626| 1.27k|#define JANET_MEM_DISABLED 0x200 ------------------ 3133| 1.27k| return buffer; 3134| 1.27k|} janet_buffer_deinit: 3149| 6.03k|void janet_buffer_deinit(JanetBuffer *buffer) { 3150| 6.03k| if (!(buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) { ------------------ | | 1770| 6.03k|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3150:9): [True: 6.03k, False: 0] ------------------ 3151| 6.03k| janet_free(buffer->data); ------------------ | | 2402| 6.03k|#define janet_free(X) free((X)) ------------------ 3152| | buffer->data = NULL; 3153| 6.03k| } 3154| 6.03k|} janet_buffer: 3157| 4.76k|JanetBuffer *janet_buffer(int32_t capacity) { 3158| 4.76k| JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer)); 3159| 4.76k| return janet_buffer_init_impl(buffer, capacity); 3160| 4.76k|} janet_buffer_ensure: 3163| 262|void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth) { 3164| 262| uint8_t *new_data; 3165| 262| uint8_t *old = buffer->data; 3166| 262| if (capacity <= buffer->capacity) return; ------------------ | Branch (3166:9): [True: 0, False: 262] ------------------ 3167| 262| janet_buffer_can_realloc(buffer); 3168| 262| int64_t big_capacity = ((int64_t) capacity) * growth; 3169| 262| capacity = big_capacity > INT32_MAX ? INT32_MAX : (int32_t) big_capacity; ------------------ | Branch (3169:16): [True: 0, False: 262] ------------------ 3170| 262| janet_gcpressure(capacity - buffer->capacity); 3171| 262| new_data = janet_realloc(old, (size_t) capacity * sizeof(uint8_t)); ------------------ | | 2396| 262|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 3172| 262| if (NULL == new_data) { ------------------ | Branch (3172:9): [True: 0, False: 262] ------------------ 3173| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 3174| 0| } 3175| 262| buffer->data = new_data; 3176| 262| buffer->capacity = capacity; 3177| 262|} janet_buffer_extra: 3193| 127k|void janet_buffer_extra(JanetBuffer *buffer, int32_t n) { 3194| | /* Check for buffer overflow */ 3195| 127k| if ((int64_t)n + buffer->count > INT32_MAX) { ------------------ | Branch (3195:9): [True: 0, False: 127k] ------------------ 3196| 0| janet_panic("buffer overflow"); 3197| 0| } 3198| 127k| int32_t new_size = buffer->count + n; 3199| 127k| if (new_size > buffer->capacity) { ------------------ | Branch (3199:9): [True: 1.52k, False: 125k] ------------------ 3200| 1.52k| janet_buffer_can_realloc(buffer); 3201| 1.52k| int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2); ------------------ | Branch (3201:32): [True: 0, False: 1.52k] ------------------ 3202| 1.52k| uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t)); ------------------ | | 2396| 1.52k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 3203| 1.52k| janet_gcpressure(new_capacity - buffer->capacity); 3204| 1.52k| if (NULL == new_data) { ------------------ | Branch (3204:13): [True: 0, False: 1.52k] ------------------ 3205| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 3206| 0| } 3207| 1.52k| buffer->data = new_data; 3208| 1.52k| buffer->capacity = new_capacity; 3209| 1.52k| } 3210| 127k|} janet_buffer_push_cstring: 3213| 421|void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) { 3214| 421| int32_t len = (int32_t) strlen(cstring); 3215| 421| janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len); 3216| 421|} janet_buffer_push_bytes: 3219| 70.3k|void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) { 3220| 70.3k| if (0 == length) return; ------------------ | Branch (3220:9): [True: 0, False: 70.3k] ------------------ 3221| 70.3k| janet_buffer_extra(buffer, length); 3222| 70.3k| memcpy(buffer->data + buffer->count, string, length); 3223| 70.3k| buffer->count += length; 3224| 70.3k|} janet_buffer_push_u8: 3231| 57.1k|void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t byte) { 3232| 57.1k| janet_buffer_extra(buffer, 1); 3233| 57.1k| buffer->data[buffer->count] = byte; 3234| 57.1k| buffer->count++; 3235| 57.1k|} janet_lib_buffer: 3750| 3.22k|void janet_lib_buffer(JanetTable *env) { 3751| 3.22k| JanetRegExt buffer_cfuns[] = { 3752| 3.22k| JANET_CORE_REG("buffer/new", cfun_buffer_new), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3753| 3.22k| JANET_CORE_REG("buffer/new-filled", cfun_buffer_new_filled), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3754| 3.22k| JANET_CORE_REG("buffer/from-bytes", cfun_buffer_frombytes), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3755| 3.22k| JANET_CORE_REG("buffer/fill", cfun_buffer_fill), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3756| 3.22k| JANET_CORE_REG("buffer/trim", cfun_buffer_trim), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3757| 3.22k| JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3758| 3.22k| JANET_CORE_REG("buffer/push-word", cfun_buffer_word), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3759| 3.22k| JANET_CORE_REG("buffer/push-string", cfun_buffer_chars), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3760| 3.22k| JANET_CORE_REG("buffer/push-uint16", cfun_buffer_push_uint16), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3761| 3.22k| JANET_CORE_REG("buffer/push-uint32", cfun_buffer_push_uint32), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3762| 3.22k| JANET_CORE_REG("buffer/push-uint64", cfun_buffer_push_uint64), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3763| 3.22k| JANET_CORE_REG("buffer/push-float32", cfun_buffer_push_float32), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3764| 3.22k| JANET_CORE_REG("buffer/push-float64", cfun_buffer_push_float64), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3765| 3.22k| JANET_CORE_REG("buffer/push", cfun_buffer_push), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3766| 3.22k| JANET_CORE_REG("buffer/push-at", cfun_buffer_push_at), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3767| 3.22k| JANET_CORE_REG("buffer/popn", cfun_buffer_popn), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3768| 3.22k| JANET_CORE_REG("buffer/clear", cfun_buffer_clear), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3769| 3.22k| JANET_CORE_REG("buffer/slice", cfun_buffer_slice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3770| 3.22k| JANET_CORE_REG("buffer/bit-set", cfun_buffer_bitset), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3771| 3.22k| JANET_CORE_REG("buffer/bit-clear", cfun_buffer_bitclear), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3772| 3.22k| JANET_CORE_REG("buffer/bit", cfun_buffer_bitget), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3773| 3.22k| JANET_CORE_REG("buffer/bit-toggle", cfun_buffer_bittoggle), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3774| 3.22k| JANET_CORE_REG("buffer/blit", cfun_buffer_blit), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3775| 3.22k| JANET_CORE_REG("buffer/format", cfun_buffer_format), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3776| 3.22k| JANET_CORE_REG("buffer/format-at", cfun_buffer_format_at), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3777| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3778| 3.22k| }; 3779| | janet_core_cfuns_ext(env, NULL, buffer_cfuns); 3780| 3.22k|} janet_verify: 4190| 1.74M|int janet_verify(JanetFuncDef *def) { 4191| 1.74M| int vargs = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG); ------------------ | | 1088| 1.74M|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ 4192| 1.74M| int32_t i; 4193| 1.74M| int32_t maxslot = def->arity + vargs; 4194| 1.74M| int32_t sc = def->slotcount; 4195| | 4196| 1.74M| if (def->bytecode_length == 0) return 1; ------------------ | Branch (4196:9): [True: 16, False: 1.74M] ------------------ 4197| | 4198| 1.74M| if (maxslot > sc) return 2; ------------------ | Branch (4198:9): [True: 32, False: 1.74M] ------------------ 4199| | 4200| | /* Verify each instruction */ 4201| 50.0M| for (i = 0; i < def->bytecode_length; i++) { ------------------ | Branch (4201:17): [True: 48.2M, False: 1.74M] ------------------ 4202| 48.2M| uint32_t instr = def->bytecode[i]; 4203| | /* Check for invalid instructions */ 4204| 48.2M| if ((instr & 0x7F) >= JOP_INSTRUCTION_COUNT) { ------------------ | Branch (4204:13): [True: 52, False: 48.2M] ------------------ 4205| 52| return 3; 4206| 52| } 4207| 48.2M| enum JanetInstructionType type = janet_instructions[instr & 0x7F]; 4208| 48.2M| switch (type) { ------------------ | Branch (4208:17): [True: 48.2M, False: 0] ------------------ 4209| 321k| case JINT_0: ------------------ | Branch (4209:13): [True: 321k, False: 47.9M] ------------------ 4210| 321k| continue; 4211| 9.24M| case JINT_S: { ------------------ | Branch (4211:13): [True: 9.24M, False: 39.0M] ------------------ 4212| 9.24M| if ((int32_t)(instr >> 8) >= sc) return 4; ------------------ | Branch (4212:21): [True: 47, False: 9.24M] ------------------ 4213| 9.24M| continue; 4214| 9.24M| } 4215| 9.24M| case JINT_SI: ------------------ | Branch (4215:13): [True: 1.09M, False: 47.1M] ------------------ 4216| 1.09M| case JINT_SU: ------------------ | Branch (4216:13): [True: 0, False: 48.2M] ------------------ 4217| 1.09M| case JINT_ST: { ------------------ | Branch (4217:13): [True: 4.75k, False: 48.2M] ------------------ 4218| 1.09M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4218:21): [True: 3, False: 1.09M] ------------------ 4219| 1.09M| continue; 4220| 1.09M| } 4221| 2.21M| case JINT_L: { ------------------ | Branch (4221:13): [True: 2.21M, False: 46.0M] ------------------ 4222| 2.21M| int32_t jumpdest = i + (((int32_t)instr) >> 8); 4223| 2.21M| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (4223:21): [True: 10, False: 2.21M] | Branch (4223:37): [True: 5, False: 2.21M] ------------------ 4224| 2.21M| continue; 4225| 2.21M| } 4226| 13.1M| case JINT_SS: { ------------------ | Branch (4226:13): [True: 13.1M, False: 35.1M] ------------------ 4227| 13.1M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (4227:21): [True: 8, False: 13.1M] ------------------ 4228| 13.1M| (int32_t)(instr >> 16) >= sc) return 4; ------------------ | Branch (4228:25): [True: 21, False: 13.1M] ------------------ 4229| 13.1M| continue; 4230| 13.1M| } 4231| 13.1M| case JINT_SSI: ------------------ | Branch (4231:13): [True: 830k, False: 47.4M] ------------------ 4232| 1.33M| case JINT_SSU: { ------------------ | Branch (4232:13): [True: 504k, False: 47.7M] ------------------ 4233| 1.33M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (4233:21): [True: 10, False: 1.33M] ------------------ 4234| 1.33M| (int32_t)((instr >> 16) & 0xFF) >= sc) return 4; ------------------ | Branch (4234:25): [True: 10, False: 1.33M] ------------------ 4235| 1.33M| continue; 4236| 1.33M| } 4237| 3.48M| case JINT_SL: { ------------------ | Branch (4237:13): [True: 3.48M, False: 44.8M] ------------------ 4238| 3.48M| int32_t jumpdest = i + (((int32_t)instr) >> 16); 4239| 3.48M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4239:21): [True: 7, False: 3.48M] ------------------ 4240| 3.48M| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (4240:21): [True: 29, False: 3.48M] | Branch (4240:37): [True: 37, False: 3.48M] ------------------ 4241| 3.48M| continue; 4242| 3.48M| } 4243| 6.40M| case JINT_SSS: { ------------------ | Branch (4243:13): [True: 6.40M, False: 41.8M] ------------------ 4244| 6.40M| if (((int32_t)(instr >> 8) & 0xFF) >= sc || ------------------ | Branch (4244:21): [True: 11, False: 6.40M] ------------------ 4245| 6.40M| ((int32_t)(instr >> 16) & 0xFF) >= sc || ------------------ | Branch (4245:25): [True: 8, False: 6.40M] ------------------ 4246| 6.40M| ((int32_t)(instr >> 24) & 0xFF) >= sc) return 4; ------------------ | Branch (4246:25): [True: 11, False: 6.40M] ------------------ 4247| 6.40M| continue; 4248| 6.40M| } 4249| 6.40M| case JINT_SD: { ------------------ | Branch (4249:13): [True: 497k, False: 47.7M] ------------------ 4250| 497k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4250:21): [True: 8, False: 497k] ------------------ 4251| 497k| if ((int32_t)(instr >> 16) >= def->defs_length) return 6; ------------------ | Branch (4251:21): [True: 73, False: 496k] ------------------ 4252| 496k| continue; 4253| 497k| } 4254| 8.60M| case JINT_SC: { ------------------ | Branch (4254:13): [True: 8.60M, False: 39.6M] ------------------ 4255| 8.60M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4255:21): [True: 5, False: 8.60M] ------------------ 4256| 8.60M| if ((int32_t)(instr >> 16) >= def->constants_length) return 7; ------------------ | Branch (4256:21): [True: 36, False: 8.60M] ------------------ 4257| 8.60M| continue; 4258| 8.60M| } 4259| 8.60M| case JINT_SES: { ------------------ | Branch (4259:13): [True: 1.96M, False: 46.3M] ------------------ 4260| | /* How can we check the last slot index? We need info parent funcdefs. Resort 4261| | * to runtime checks for now. Maybe invalid upvalue references could be defaulted 4262| | * to nil? (don't commit to this in the long term, though) */ 4263| 1.96M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4263:21): [True: 10, False: 1.96M] ------------------ 4264| 1.96M| if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8; ------------------ | Branch (4264:21): [True: 34, False: 1.96M] ------------------ 4265| 1.96M| continue; 4266| 1.96M| } 4267| 48.2M| } 4268| 48.2M| } 4269| | 4270| | /* Verify last instruction is either a jump, return, return-nil, or tailcall. Eventually, 4271| | * some real flow analysis would be ideal, but this should be very effective. Will completely 4272| | * prevent running over the end of bytecode. However, valid functions with dead code will 4273| | * be rejected. */ 4274| 1.74M| { 4275| 1.74M| uint32_t lastop = def->bytecode[def->bytecode_length - 1] & 0xFF; 4276| 1.74M| switch (lastop) { 4277| 73| default: ------------------ | Branch (4277:13): [True: 73, False: 1.74M] ------------------ 4278| 73| return 9; 4279| 1.01M| case JOP_RETURN: ------------------ | Branch (4279:13): [True: 1.01M, False: 731k] ------------------ 4280| 1.17M| case JOP_RETURN_NIL: ------------------ | Branch (4280:13): [True: 164k, False: 1.58M] ------------------ 4281| 1.18M| case JOP_JUMP: ------------------ | Branch (4281:13): [True: 3.17k, False: 1.74M] ------------------ 4282| 1.18M| case JOP_ERROR: ------------------ | Branch (4282:13): [True: 8.60k, False: 1.73M] ------------------ 4283| 1.74M| case JOP_TAILCALL: ------------------ | Branch (4283:13): [True: 555k, False: 1.18M] ------------------ 4284| 1.74M| break; 4285| 1.74M| } 4286| 1.74M| } 4287| | 4288| | /* Verify debug info - slotmapping, etc. */ 4289| 19.5M| for (int32_t i = def->symbolmap_length - 1; i >= 0; i--) { ------------------ | Branch (4289:49): [True: 17.7M, False: 1.74M] ------------------ 4290| 17.7M| JanetSymbolMap jsm = def->symbolmap[i]; 4291| 17.7M| if (jsm.birth_pc == UINT32_MAX) { ------------------ | Branch (4291:13): [True: 8.47M, False: 9.31M] ------------------ 4292| 8.47M| if (jsm.death_pc >= (uint32_t) def->environments_length) { ------------------ | Branch (4292:17): [True: 0, False: 8.47M] ------------------ 4293| 0| return 10; 4294| | /* We should also check jsm.slot_index */ 4295| 0| } 4296| 9.31M| } else { 4297| 9.31M| if (jsm.slot_index >= (uint32_t) def->slotcount) { ------------------ | Branch (4297:17): [True: 0, False: 9.31M] ------------------ 4298| 0| return 11; 4299| 0| } 4300| 9.31M| if (jsm.birth_pc != UINT32_MAX && jsm.birth_pc >= (uint32_t) def->bytecode_length) { ------------------ | Branch (4300:17): [True: 9.31M, False: 0] | Branch (4300:47): [True: 0, False: 9.31M] ------------------ 4301| 0| return 12; 4302| 0| } 4303| 9.31M| if (jsm.death_pc != UINT32_MAX && jsm.death_pc > (uint32_t) def->bytecode_length) { ------------------ | Branch (4303:17): [True: 9.31M, False: 0] | Branch (4303:47): [True: 0, False: 9.31M] ------------------ 4304| 0| return 13; 4305| 0| } 4306| 9.31M| } 4307| 17.7M| if (jsm.symbol == NULL) { ------------------ | Branch (4307:13): [True: 0, False: 17.7M] ------------------ 4308| 0| return 14; 4309| 0| } 4310| 17.7M| } 4311| | 4312| 1.74M| return 0; 4313| 1.74M|} janet_signalv: 4423| 2.99k|void janet_signalv(JanetSignal sig, Janet message) { 4424| 2.99k| if (janet_vm.return_reg != NULL) { ------------------ | Branch (4424:9): [True: 2.99k, False: 0] ------------------ 4425| | /* Should match logic in janet_call for coercing everything not ok to an error (no awaits, yields, etc.) */ 4426| 2.99k| if (janet_vm.coerce_error && sig != JANET_SIGNAL_OK) { ------------------ | Branch (4426:13): [True: 0, False: 2.99k] | Branch (4426:38): [True: 0, False: 0] ------------------ 4427| 0|#ifdef JANET_EV 4428| 0| if (NULL != janet_vm.root_fiber && sig == JANET_SIGNAL_EVENT) { ------------------ | Branch (4428:17): [True: 0, False: 0] | Branch (4428:48): [True: 0, False: 0] ------------------ 4429| 0| janet_vm.root_fiber->sched_id++; 4430| 0| } 4431| 0|#endif 4432| 0| if (sig != JANET_SIGNAL_ERROR) { ------------------ | Branch (4432:17): [True: 0, False: 0] ------------------ 4433| 0| message = janet_wrap_string(janet_formatc("%v coerced from %s to error", message, janet_signal_names[sig])); ------------------ | | 843| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 823| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4434| 0| } 4435| 0| sig = JANET_SIGNAL_ERROR; 4436| 0| } 4437| 2.99k| *janet_vm.return_reg = message; 4438| 2.99k| if (NULL != janet_vm.fiber) { ------------------ | Branch (4438:13): [True: 0, False: 2.99k] ------------------ 4439| 0| janet_vm.fiber->flags |= JANET_FIBER_DID_LONGJUMP; ------------------ | | 786| 0|#define JANET_FIBER_DID_LONGJUMP 0x8000000 ------------------ 4440| 0| } 4441| |#if defined(JANET_BSD) || defined(JANET_APPLE) 4442| | _longjmp(*janet_vm.signal_buf, sig); 4443| |#else 4444| 2.99k| longjmp(*janet_vm.signal_buf, sig); 4445| 2.99k|#endif 4446| 2.99k| } else { 4447| 0| const char *str = (const char *)janet_formatc("janet top level signal - %v\n", message); 4448| 0| janet_top_level_signal(str); 4449| 0| } 4450| 2.99k|} janet_panicv: 4452| 2.99k|void janet_panicv(Janet message) { 4453| 2.99k| janet_signalv(JANET_SIGNAL_ERROR, message); 4454| 2.99k|} janet_panicf: 4456| 1.27k|void janet_panicf(const char *format, ...) { 4457| 1.27k| va_list args; 4458| 1.27k| const uint8_t *ret; 4459| 1.27k| JanetBuffer buffer; 4460| 1.27k| int32_t len = 0; 4461| 38.9k| while (format[len]) len++; ------------------ | Branch (4461:12): [True: 37.6k, False: 1.27k] ------------------ 4462| 1.27k| janet_buffer_init(&buffer, len); 4463| 1.27k| va_start(args, format); 4464| 1.27k| janet_formatbv(&buffer, format, args); 4465| | va_end(args); 4466| 1.27k| ret = janet_string(buffer.data, buffer.count); 4467| 1.27k| janet_buffer_deinit(&buffer); 4468| 1.27k| janet_panics(ret); 4469| 1.27k|} janet_panic: 4471| 1.71k|void janet_panic(const char *message) { 4472| 1.71k| janet_panicv(janet_cstringv(message)); ------------------ | | 1816| 1.71k|#define janet_cstringv(cstr) janet_wrap_string(janet_cstring(cstr)) | | ------------------ | | | | 843| 1.71k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 823| 1.71k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 1.71k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 1.71k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4473| 1.71k|} janet_panics: 4475| 1.27k|void janet_panics(const uint8_t *message) { 4476| 1.27k| janet_panicv(janet_wrap_string(message)); ------------------ | | 843| 1.27k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 823| 1.27k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 1.27k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 1.27k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4477| 1.27k|} janet_lib_compile: 6683| 3.22k|void janet_lib_compile(JanetTable *env) { 6684| 3.22k| JanetRegExt cfuns[] = { 6685| 3.22k| JANET_CORE_REG("compile", cfun_compile), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 6686| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 6687| 3.22k| }; 6688| | janet_core_cfuns_ext(env, NULL, cfuns); 6689| 3.22k|} janet_core_env: 8041| 3.22k|JanetTable *janet_core_env(JanetTable *replacements) { 8042| | /* Memoize core env, ignoring replacements the second time around. */ 8043| 3.22k| if (NULL != janet_vm.core_env) { ------------------ | Branch (8043:9): [True: 0, False: 3.22k] ------------------ 8044| 0| return janet_vm.core_env; 8045| 0| } 8046| | 8047| 3.22k| JanetTable *dict = janet_core_lookup_table(replacements); 8048| | 8049| | /* Unmarshal bytecode */ 8050| 3.22k| Janet marsh_out = janet_unmarshal( 8051| 3.22k| janet_core_image, 8052| 3.22k| janet_core_image_size, 8053| 3.22k| 0, 8054| 3.22k| dict, 8055| 3.22k| NULL); 8056| | 8057| | /* Memoize */ 8058| 3.22k| janet_gcroot(marsh_out); 8059| 3.22k| JanetTable *env = janet_unwrap_table(marsh_out); ------------------ | | 856| 3.22k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 8060| 3.22k| janet_vm.core_env = env; 8061| | 8062| | /* Invert image dict manually here. We can't do this in boot.janet as it 8063| | * breaks deterministic builds */ 8064| 3.22k| Janet lidv, midv; 8065| 3.22k| lidv = midv = janet_wrap_nil(); ------------------ | | 826| 3.22k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 3.22k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8066| 3.22k| janet_resolve(env, janet_csymbol("load-image-dict"), &lidv); 8067| 3.22k| janet_resolve(env, janet_csymbol("make-image-dict"), &midv); 8068| | 8069| | /* Check that we actually got tables - if we are using a smaller corelib, may not exist */ 8070| 3.22k| if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 801| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 3.22k, False: 0] | | | Branch (801:6): [Folded, False: 3.22k] | | ------------------ | | 802| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 3.22k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 3.22k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 801| 3.22k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 3.22k, False: 0] | | | Branch (801:6): [Folded, False: 3.22k] | | ------------------ | | 802| 3.22k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 3.22k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 3.22k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 3.22k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8071| 3.22k| JanetTable *lid = janet_unwrap_table(lidv); ------------------ | | 856| 3.22k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 8072| 3.22k| JanetTable *mid = janet_unwrap_table(midv); ------------------ | | 856| 3.22k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 8073| 6.61M| for (int32_t i = 0; i < lid->capacity; i++) { ------------------ | Branch (8073:29): [True: 6.60M, False: 3.22k] ------------------ 8074| 6.60M| const JanetKV *kv = lid->data + i; 8075| 6.60M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 801| 6.60M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 6.60M] | | ------------------ | | 802| 6.60M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 6.60M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 6.60M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 6.60M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 6.60M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.60M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (8075:17): [True: 2.12M, False: 4.48M] ------------------ 8076| 2.12M| janet_table_put(mid, kv->value, kv->key); 8077| 2.12M| } 8078| 6.60M| } 8079| 3.22k| } 8080| | 8081| 3.22k| return env; 8082| 3.22k|} janet_core_lookup_table: 8086| 3.22k|JanetTable *janet_core_lookup_table(JanetTable *replacements) { 8087| 3.22k| JanetTable *dict = janet_table(512); 8088| 3.22k| janet_load_libs(dict); 8089| | 8090| | /* Add replacements */ 8091| 3.22k| if (replacements != NULL) { ------------------ | Branch (8091:9): [True: 0, False: 3.22k] ------------------ 8092| 0| for (int32_t i = 0; i < replacements->capacity; i++) { ------------------ | Branch (8092:29): [True: 0, False: 0] ------------------ 8093| 0| JanetKV kv = replacements->data[i]; 8094| 0| if (!janet_checktype(kv.key, JANET_NIL)) { ------------------ | | 801| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 0] | | ------------------ | | 802| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (8094:17): [True: 0, False: 0] ------------------ 8095| 0| janet_table_put(dict, kv.key, kv.value); 8096| | /* Add replacement functions to registry? */ 8097| 0| } 8098| 0| } 8099| 0| } 8100| | 8101| 3.22k| return dict; 8102| 3.22k|} janet_lib_debug: 8550| 3.22k|void janet_lib_debug(JanetTable *env) { 8551| 3.22k| JanetRegExt debug_cfuns[] = { 8552| 3.22k| JANET_CORE_REG("debug/break", cfun_debug_break), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8553| 3.22k| JANET_CORE_REG("debug/unbreak", cfun_debug_unbreak), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8554| 3.22k| JANET_CORE_REG("debug/fbreak", cfun_debug_fbreak), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8555| 3.22k| JANET_CORE_REG("debug/unfbreak", cfun_debug_unfbreak), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8556| 3.22k| JANET_CORE_REG("debug/arg-stack", cfun_debug_argstack), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8557| 3.22k| JANET_CORE_REG("debug/stack", cfun_debug_stack), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8558| 3.22k| JANET_CORE_REG("debug/stacktrace", cfun_debug_stacktrace), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8559| 3.22k| JANET_CORE_REG("debug/lineage", cfun_debug_lineage), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8560| 3.22k| JANET_CORE_REG("debug/step", cfun_debug_step), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8561| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 8562| 3.22k| }; 8563| | janet_core_cfuns_ext(env, NULL, debug_cfuns); 8564| 3.22k|} janet_ev_init_common: 9523| 3.22k|void janet_ev_init_common(void) { 9524| 3.22k| janet_q_init(&janet_vm.spawn); 9525| 3.22k| janet_vm.tq = NULL; 9526| 3.22k| janet_vm.tq_count = 0; 9527| 3.22k| janet_vm.tq_capacity = 0; 9528| 3.22k| janet_table_init_raw(&janet_vm.threaded_abstracts, 0); 9529| 3.22k| janet_table_init_raw(&janet_vm.active_tasks, 0); 9530| 3.22k| janet_table_init_raw(&janet_vm.signal_handlers, 0); 9531| 3.22k| janet_rng_seed(&janet_vm.ev_rng, 0); 9532| 3.22k|#ifndef JANET_WINDOWS 9533| 3.22k| pthread_attr_init(&janet_vm.new_thread_attr); 9534| | pthread_attr_setdetachstate(&janet_vm.new_thread_attr, PTHREAD_CREATE_DETACHED); 9535| 3.22k|#endif 9536| 3.22k|} janet_ev_deinit_common: 9569| 3.22k|void janet_ev_deinit_common(void) { 9570| 3.22k| JanetTimeout to; 9571| 3.22k| while (peek_timeout(&to)) { ------------------ | Branch (9571:12): [True: 0, False: 3.22k] ------------------ 9572| 0| handle_timeout_worker(to, 1); 9573| 0| pop_timeout(0); 9574| 0| } 9575| 3.22k| janet_q_deinit(&janet_vm.spawn); 9576| 3.22k| janet_free(janet_vm.tq); ------------------ | | 2402| 3.22k|#define janet_free(X) free((X)) ------------------ 9577| 3.22k| janet_table_deinit(&janet_vm.threaded_abstracts); 9578| 3.22k| janet_table_deinit(&janet_vm.active_tasks); 9579| 3.22k| janet_table_deinit(&janet_vm.signal_handlers); 9580| 3.22k|#ifndef JANET_WINDOWS 9581| 3.22k| pthread_attr_destroy(&janet_vm.new_thread_attr); 9582| 3.22k|#endif 9583| 3.22k|} janet_ev_init: 10791| 3.22k|void janet_ev_init(void) { 10792| 3.22k| janet_ev_init_common(); 10793| 3.22k| janet_ev_setup_selfpipe(); 10794| 3.22k| janet_vm.epoll = epoll_create1(EPOLL_CLOEXEC); 10795| 3.22k| janet_vm.timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); 10796| 3.22k| janet_vm.timer_enabled = 0; 10797| 3.22k| if (janet_vm.epoll == -1 || janet_vm.timerfd == -1) goto error; ------------------ | Branch (10797:9): [True: 0, False: 3.22k] | Branch (10797:33): [True: 0, False: 3.22k] ------------------ 10798| 3.22k| struct epoll_event ev; 10799| 3.22k| ev.events = EPOLLIN | EPOLLET; 10800| 3.22k| ev.data.ptr = &janet_vm.timerfd; 10801| 3.22k| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.timerfd, &ev)) goto error; ------------------ | Branch (10801:9): [True: 0, False: 3.22k] ------------------ 10802| 3.22k| ev.events = EPOLLIN | EPOLLET; 10803| 3.22k| ev.data.ptr = janet_vm.selfpipe; 10804| 3.22k| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.selfpipe[0], &ev)) goto error; ------------------ | Branch (10804:9): [True: 0, False: 3.22k] ------------------ 10805| 3.22k| return; 10806| 3.22k|error: 10807| | JANET_EXIT("failed to initialize event loop"); ------------------ | | 375| 0|#define JANET_EXIT(m) do { \ | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 377| 0| __FILE__,\ | | 378| 0| __LINE__,\ | | 379| 0| (m));\ | | 380| 0| abort();\ | | 381| 0|} while (0) | | ------------------ | | | Branch (381:10): [Folded, False: 0] | | ------------------ ------------------ 10808| 0|} janet_ev_deinit: 10810| 3.22k|void janet_ev_deinit(void) { 10811| 3.22k| janet_ev_deinit_common(); 10812| 3.22k| close(janet_vm.epoll); 10813| 3.22k| close(janet_vm.timerfd); 10814| 3.22k| janet_ev_cleanup_selfpipe(); 10815| 3.22k| janet_vm.epoll = 0; 10816| 3.22k|} janet_make_pipe: 11910| 3.22k|int janet_make_pipe(JanetHandle handles[2], int mode) { 11911| |#ifdef JANET_WINDOWS 11912| | /* 11913| | * On windows, the built in CreatePipe function doesn't support overlapped IO 11914| | * so we lift from the windows source code and modify for our own version. 11915| | */ 11916| | JanetHandle shandle, chandle; 11917| | CHAR PipeNameBuffer[MAX_PATH]; 11918| | SECURITY_ATTRIBUTES saAttr; 11919| | memset(&saAttr, 0, sizeof(saAttr)); 11920| | saAttr.nLength = sizeof(saAttr); 11921| | saAttr.bInheritHandle = TRUE; 11922| | if (mode == 3) { 11923| | /* No overlapped IO involved, just call CreatePipe */ 11924| | if (!CreatePipe(handles, handles + 1, &saAttr, 0)) return -1; 11925| | return 0; 11926| | } 11927| | snprintf(PipeNameBuffer, 11928| | sizeof(PipeNameBuffer), 11929| | "\\\\.\\Pipe\\JanetPipeFile.%08x.%08x", 11930| | (unsigned int) GetCurrentProcessId(), 11931| | (unsigned int) InterlockedIncrement(&PipeSerialNumber)); 11932| | 11933| | /* server handle goes to subprocess */ 11934| | shandle = CreateNamedPipeA( 11935| | PipeNameBuffer, 11936| | (mode == 2 ? PIPE_ACCESS_INBOUND : PIPE_ACCESS_OUTBOUND) | FILE_FLAG_OVERLAPPED, 11937| | PIPE_TYPE_BYTE | PIPE_WAIT, 11938| | 255, /* Max number of pipes for duplication. */ 11939| | 4096, /* Out buffer size */ 11940| | 4096, /* In buffer size */ 11941| | 120 * 1000, /* Timeout in ms */ 11942| | &saAttr); 11943| | if (shandle == INVALID_HANDLE_VALUE) { 11944| | return -1; 11945| | } 11946| | 11947| | /* we keep client handle */ 11948| | chandle = CreateFileA( 11949| | PipeNameBuffer, 11950| | (mode == 2 ? GENERIC_WRITE : GENERIC_READ), 11951| | 0, 11952| | &saAttr, 11953| | OPEN_EXISTING, 11954| | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 11955| | NULL); 11956| | 11957| | if (chandle == INVALID_HANDLE_VALUE) { 11958| | CloseHandle(shandle); 11959| | return -1; 11960| | } 11961| | if (mode == 2) { 11962| | handles[0] = shandle; 11963| | handles[1] = chandle; 11964| | } else { 11965| | handles[0] = chandle; 11966| | handles[1] = shandle; 11967| | } 11968| | return 0; 11969| |#else 11970| 3.22k| if (pipe(handles)) return -1; ------------------ | Branch (11970:9): [True: 0, False: 3.22k] ------------------ 11971| 3.22k| if (mode != 2 && fcntl(handles[0], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (11971:9): [True: 3.22k, False: 0] | Branch (11971:22): [True: 0, False: 3.22k] ------------------ 11972| 3.22k| if (mode != 1 && fcntl(handles[1], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (11972:9): [True: 0, False: 3.22k] | Branch (11972:22): [True: 0, False: 0] ------------------ 11973| 3.22k| if (mode != 2 && mode != 3 && fcntl(handles[0], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (11973:9): [True: 3.22k, False: 0] | Branch (11973:22): [True: 3.22k, False: 0] | Branch (11973:35): [True: 0, False: 3.22k] ------------------ 11974| 3.22k| if (mode != 1 && mode != 3 && fcntl(handles[1], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (11974:9): [True: 0, False: 3.22k] | Branch (11974:22): [True: 0, False: 0] | Branch (11974:35): [True: 0, False: 0] ------------------ 11975| 3.22k| return 0; 11976| 0|error: 11977| 0| close(handles[0]); 11978| 0| close(handles[1]); 11979| 0| return -1; 11980| 3.22k|#endif 11981| 3.22k|} janet_lib_ev: 12562| 3.22k|void janet_lib_ev(JanetTable *env) { 12563| 3.22k| JanetRegExt ev_cfuns_ext[] = { 12564| 3.22k| JANET_CORE_REG("ev/give", cfun_channel_push), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12565| 3.22k| JANET_CORE_REG("ev/take", cfun_channel_pop), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12566| 3.22k| JANET_CORE_REG("ev/full", cfun_channel_full), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12567| 3.22k| JANET_CORE_REG("ev/capacity", cfun_channel_capacity), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12568| 3.22k| JANET_CORE_REG("ev/count", cfun_channel_count), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12569| 3.22k| JANET_CORE_REG("ev/select", cfun_channel_choice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12570| 3.22k| JANET_CORE_REG("ev/rselect", cfun_channel_rchoice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12571| 3.22k| JANET_CORE_REG("ev/chan", cfun_channel_new), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12572| 3.22k| JANET_CORE_REG("ev/thread-chan", cfun_channel_new_threaded), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12573| 3.22k| JANET_CORE_REG("ev/chan-close", cfun_channel_close), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12574| 3.22k| JANET_CORE_REG("ev/go", cfun_ev_go), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12575| 3.22k| JANET_CORE_REG("ev/thread", cfun_ev_thread), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12576| 3.22k| JANET_CORE_REG("ev/give-supervisor", cfun_ev_give_supervisor), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12577| 3.22k| JANET_CORE_REG("ev/sleep", cfun_ev_sleep), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12578| 3.22k| JANET_CORE_REG("ev/deadline", cfun_ev_deadline), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12579| 3.22k| JANET_CORE_REG("ev/cancel", cfun_ev_cancel), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12580| 3.22k| JANET_CORE_REG("ev/close", janet_cfun_stream_close), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12581| 3.22k| JANET_CORE_REG("ev/read", janet_cfun_stream_read), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12582| 3.22k| JANET_CORE_REG("ev/chunk", janet_cfun_stream_chunk), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12583| 3.22k| JANET_CORE_REG("ev/write", janet_cfun_stream_write), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12584| 3.22k| JANET_CORE_REG("ev/lock", janet_cfun_mutex), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12585| 3.22k| JANET_CORE_REG("ev/acquire-lock", janet_cfun_mutex_acquire), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12586| 3.22k| JANET_CORE_REG("ev/release-lock", janet_cfun_mutex_release), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12587| 3.22k| JANET_CORE_REG("ev/rwlock", janet_cfun_rwlock), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12588| 3.22k| JANET_CORE_REG("ev/acquire-rlock", janet_cfun_rwlock_read_lock), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12589| 3.22k| JANET_CORE_REG("ev/acquire-wlock", janet_cfun_rwlock_write_lock), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12590| 3.22k| JANET_CORE_REG("ev/release-rlock", janet_cfun_rwlock_read_release), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12591| 3.22k| JANET_CORE_REG("ev/release-wlock", janet_cfun_rwlock_write_release), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12592| 3.22k| JANET_CORE_REG("ev/to-file", janet_cfun_to_file), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12593| 3.22k| JANET_CORE_REG("ev/all-tasks", janet_cfun_ev_all_tasks), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12594| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 12595| 3.22k| }; 12596| | 12597| | janet_core_cfuns_ext(env, NULL, ev_cfuns_ext); 12598| 3.22k| janet_register_abstract_type(&janet_stream_type); 12599| 3.22k| janet_register_abstract_type(&janet_channel_type); 12600| 3.22k| janet_register_abstract_type(&janet_mutex_type); 12601| 3.22k| janet_register_abstract_type(&janet_rwlock_type); 12602| 3.22k|} janet_lib_ffi: 14502| 3.22k|void janet_lib_ffi(JanetTable *env) { 14503| 3.22k| JanetRegExt ffi_cfuns[] = { 14504| 3.22k| JANET_CORE_REG("ffi/native", janet_core_raw_native), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14505| 3.22k| JANET_CORE_REG("ffi/lookup", janet_core_native_lookup), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14506| 3.22k| JANET_CORE_REG("ffi/close", janet_core_native_close), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14507| 3.22k| JANET_CORE_REG("ffi/signature", cfun_ffi_signature), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14508| 3.22k| JANET_CORE_REG("ffi/call", cfun_ffi_call), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14509| 3.22k| JANET_CORE_REG("ffi/struct", cfun_ffi_struct), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14510| 3.22k| JANET_CORE_REG("ffi/write", cfun_ffi_buffer_write), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14511| 3.22k| JANET_CORE_REG("ffi/read", cfun_ffi_buffer_read), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14512| 3.22k| JANET_CORE_REG("ffi/size", cfun_ffi_size), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14513| 3.22k| JANET_CORE_REG("ffi/align", cfun_ffi_align), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14514| 3.22k| JANET_CORE_REG("ffi/trampoline", cfun_ffi_get_callback_trampoline), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14515| 3.22k| JANET_CORE_REG("ffi/jitfn", cfun_ffi_jitfn), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14516| 3.22k| JANET_CORE_REG("ffi/malloc", cfun_ffi_malloc), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14517| 3.22k| JANET_CORE_REG("ffi/free", cfun_ffi_free), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14518| 3.22k| JANET_CORE_REG("ffi/pointer-buffer", cfun_ffi_pointer_buffer), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14519| 3.22k| JANET_CORE_REG("ffi/pointer-cfunction", cfun_ffi_pointer_cfunction), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14520| 3.22k| JANET_CORE_REG("ffi/calling-conventions", cfun_ffi_supported_calling_conventions), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14521| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 14522| 3.22k| }; 14523| | janet_core_cfuns_ext(env, NULL, ffi_cfuns); 14524| 3.22k|} janet_fiber_status: 14970| 971|JanetFiberStatus janet_fiber_status(JanetFiber *f) { 14971| 971| return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 779| 971|#define JANET_FIBER_STATUS_MASK 0x3F0000 ------------------ return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 781| 971|#define JANET_FIBER_STATUS_OFFSET 16 ------------------ 14972| 971|} janet_lib_fiber: 15202| 3.22k|void janet_lib_fiber(JanetTable *env) { 15203| 3.22k| JanetRegExt fiber_cfuns[] = { 15204| 3.22k| JANET_CORE_REG("fiber/new", cfun_fiber_new), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15205| 3.22k| JANET_CORE_REG("fiber/status", cfun_fiber_status), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15206| 3.22k| JANET_CORE_REG("fiber/root", cfun_fiber_root), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15207| 3.22k| JANET_CORE_REG("fiber/current", cfun_fiber_current), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15208| 3.22k| JANET_CORE_REG("fiber/maxstack", cfun_fiber_maxstack), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15209| 3.22k| JANET_CORE_REG("fiber/setmaxstack", cfun_fiber_setmaxstack), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15210| 3.22k| JANET_CORE_REG("fiber/getenv", cfun_fiber_getenv), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15211| 3.22k| JANET_CORE_REG("fiber/setenv", cfun_fiber_setenv), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15212| 3.22k| JANET_CORE_REG("fiber/can-resume?", cfun_fiber_can_resume), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15213| 3.22k| JANET_CORE_REG("fiber/last-value", cfun_fiber_last_value), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15214| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 15215| 3.22k| }; 15216| | janet_core_cfuns_ext(env, NULL, fiber_cfuns); 15217| 3.22k|} janet_lib_filewatch: 16177| 3.22k|void janet_lib_filewatch(JanetTable *env) { 16178| 3.22k| JanetRegExt cfuns[] = { 16179| 3.22k| JANET_CORE_REG("filewatch/new", cfun_filewatch_make), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16180| 3.22k| JANET_CORE_REG("filewatch/add", cfun_filewatch_add), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16181| 3.22k| JANET_CORE_REG("filewatch/remove", cfun_filewatch_remove), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16182| 3.22k| JANET_CORE_REG("filewatch/listen", cfun_filewatch_listen), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16183| 3.22k| JANET_CORE_REG("filewatch/unlisten", cfun_filewatch_unlisten), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16184| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 16185| 3.22k| }; 16186| | janet_core_cfuns_ext(env, NULL, cfuns); 16187| 3.22k|} janet_gcpressure: 16247| 7.82k|void janet_gcpressure(size_t s) { 16248| 7.82k| janet_vm.next_collection += s; 16249| 7.82k|} janet_gcalloc: 16721| 19.9M|void *janet_gcalloc(enum JanetMemoryType type, size_t size) { 16722| 19.9M| JanetGCObject *mem; 16723| | 16724| | /* Make sure everything is inited */ 16725| 19.9M| janet_assert(NULL != janet_vm.cache, "please initialize janet before use"); ------------------ | | 386| 19.9M|#define janet_assert(c, m) do { \ | | 387| 19.9M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 375| 0|#define JANET_EXIT(m) do { \ | | | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 377| 0| __FILE__,\ | | | | 378| 0| __LINE__,\ | | | | 379| 0| (m));\ | | | | 380| 0| abort();\ | | | | 381| 0|} while (0) | | | | ------------------ | | | | | Branch (381:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (387:9): [True: 0, False: 19.9M] | | ------------------ | | 388| 19.9M|} while (0) | | ------------------ | | | Branch (388:10): [Folded, False: 19.9M] | | ------------------ ------------------ 16726| 19.9M| mem = janet_malloc(size); ------------------ | | 2393| 19.9M|#define janet_malloc(X) malloc((X)) ------------------ 16727| | 16728| | /* Check for bad malloc */ 16729| 19.9M| if (NULL == mem) { ------------------ | Branch (16729:9): [True: 0, False: 19.9M] ------------------ 16730| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 16731| 0| } 16732| | 16733| | /* Configure block */ 16734| 19.9M| mem->flags = type; 16735| | 16736| | /* Prepend block to heap list */ 16737| 19.9M| janet_vm.next_collection += size; 16738| 19.9M| if (type < JANET_MEMORY_TABLE_WEAKK) { ------------------ | Branch (16738:9): [True: 19.7M, False: 193k] ------------------ 16739| | /* normal heap */ 16740| 19.7M| mem->data.next = janet_vm.blocks; 16741| 19.7M| janet_vm.blocks = mem; 16742| 19.7M| } else { 16743| | /* weak heap */ 16744| 193k| mem->data.next = janet_vm.weak_blocks; 16745| 193k| janet_vm.weak_blocks = mem; 16746| 193k| } 16747| 19.9M| janet_vm.block_count++; 16748| | 16749| 19.9M| return (void *)mem; 16750| 19.9M|} janet_gcroot: 16806| 6.45k|void janet_gcroot(Janet root) { 16807| 6.45k| size_t newcount = janet_vm.root_count + 1; 16808| 6.45k| if (newcount > janet_vm.root_capacity) { ------------------ | Branch (16808:9): [True: 3.22k, False: 3.22k] ------------------ 16809| 3.22k| size_t newcap = 2 * newcount; 16810| 3.22k| janet_vm.roots = janet_realloc(janet_vm.roots, sizeof(Janet) * newcap); ------------------ | | 2396| 3.22k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 16811| 3.22k| if (NULL == janet_vm.roots) { ------------------ | Branch (16811:13): [True: 0, False: 3.22k] ------------------ 16812| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 16813| 0| } 16814| 3.22k| janet_vm.root_capacity = newcap; 16815| 3.22k| } 16816| 6.45k| janet_vm.roots[janet_vm.root_count] = root; 16817| 6.45k| janet_vm.root_count = newcount; 16818| 6.45k|} janet_clear_memory: 16865| 3.22k|void janet_clear_memory(void) { 16866| 3.22k|#ifdef JANET_EV 16867| 3.22k| JanetKV *items = janet_vm.threaded_abstracts.data; 16868| 6.45k| for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) { ------------------ | Branch (16868:25): [True: 3.22k, False: 3.22k] ------------------ 16869| 3.22k| if (janet_checktype(items[i].key, JANET_ABSTRACT)) { ------------------ | | 801| 3.22k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 3.22k] | | | Branch (801:6): [Folded, False: 3.22k] | | ------------------ | | 802| 3.22k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 3.22k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 3.22k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 3.22k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16870| 0| void *abst = janet_unwrap_abstract(items[i].key); ------------------ | | 861| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 16871| 0| JanetAbstractHead *head = janet_abstract_head(abst); ------------------ | | 1887| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) ------------------ 16872| 0| if (head->type->gcperthread) { ------------------ | Branch (16872:17): [True: 0, False: 0] ------------------ 16873| 0| janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed"); ------------------ | | 386| 0|#define janet_assert(c, m) do { \ | | 387| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 375| 0|#define JANET_EXIT(m) do { \ | | | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 377| 0| __FILE__,\ | | | | 378| 0| __LINE__,\ | | | | 379| 0| (m));\ | | | | 380| 0| abort();\ | | | | 381| 0|} while (0) | | | | ------------------ | | | | | Branch (381:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (387:9): [True: 0, False: 0] | | ------------------ | | 388| 0|} while (0) | | ------------------ | | | Branch (388:10): [Folded, False: 0] | | ------------------ ------------------ 16874| 0| } 16875| 0| janet_abstract_decref_maybe_free(abst); 16876| 0| } 16877| 3.22k| } 16878| 3.22k|#endif 16879| 3.22k| JanetGCObject *current = janet_vm.blocks; 16880| 19.7M| while (NULL != current) { ------------------ | Branch (16880:12): [True: 19.7M, False: 3.22k] ------------------ 16881| 19.7M| janet_deinit_block(current); 16882| 19.7M| JanetGCObject *next = current->data.next; 16883| 19.7M| janet_free(current); ------------------ | | 2402| 19.7M|#define janet_free(X) free((X)) ------------------ 16884| 19.7M| current = next; 16885| 19.7M| } 16886| 3.22k| janet_vm.blocks = NULL; 16887| 3.22k| janet_free_all_scratch(); 16888| 3.22k| janet_free(janet_vm.scratch_mem); ------------------ | | 2402| 3.22k|#define janet_free(X) free((X)) ------------------ 16889| 3.22k|} janet_smalloc: 16903| 14.6k|void *janet_smalloc(size_t size) { 16904| 14.6k| JanetScratch *s = janet_malloc(sizeof(JanetScratch) + size); ------------------ | | 2393| 14.6k|#define janet_malloc(X) malloc((X)) ------------------ 16905| 14.6k| if (NULL == s) { ------------------ | Branch (16905:9): [True: 0, False: 14.6k] ------------------ 16906| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 16907| 0| } 16908| 14.6k| s->finalize = NULL; 16909| 14.6k| if (janet_vm.scratch_len == janet_vm.scratch_cap) { ------------------ | Branch (16909:9): [True: 6.45k, False: 8.16k] ------------------ 16910| 6.45k| size_t newcap = 2 * janet_vm.scratch_cap + 2; 16911| 6.45k| JanetScratch **newmem = (JanetScratch **) janet_realloc(janet_vm.scratch_mem, newcap * sizeof(JanetScratch)); ------------------ | | 2396| 6.45k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 16912| 6.45k| if (NULL == newmem) { ------------------ | Branch (16912:13): [True: 0, False: 6.45k] ------------------ 16913| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 16914| 0| } 16915| 6.45k| janet_vm.scratch_cap = newcap; 16916| 6.45k| janet_vm.scratch_mem = newmem; 16917| 6.45k| } 16918| 14.6k| janet_vm.scratch_mem[janet_vm.scratch_len++] = s; 16919| 14.6k| return (char *)(s->mem); 16920| 14.6k|} janet_srealloc: 16932| 114k|void *janet_srealloc(void *mem, size_t size) { 16933| 114k| if (NULL == mem) return janet_smalloc(size); ------------------ | Branch (16933:9): [True: 14.6k, False: 99.9k] ------------------ 16934| 99.9k| JanetScratch *s = janet_mem2scratch(mem); 16935| 99.9k| if (janet_vm.scratch_len) { ------------------ | Branch (16935:9): [True: 99.9k, False: 0] ------------------ 16936| 165k| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 16937| 165k| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (16937:17): [True: 99.9k, False: 65.4k] ------------------ 16938| 99.9k| JanetScratch *news = janet_realloc(s, size + sizeof(JanetScratch)); ------------------ | | 2396| 99.9k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 16939| 99.9k| if (NULL == news) { ------------------ | Branch (16939:21): [True: 0, False: 99.9k] ------------------ 16940| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 16941| 0| } 16942| 99.9k| janet_vm.scratch_mem[i] = news; 16943| 99.9k| return (char *)(news->mem); 16944| 99.9k| } 16945| 65.4k| if (i == 0) break; ------------------ | Branch (16945:17): [True: 0, False: 65.4k] ------------------ 16946| 65.4k| } 16947| 99.9k| } 16948| 0| JANET_EXIT("invalid janet_srealloc"); ------------------ | | 375| 0|#define JANET_EXIT(m) do { \ | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 377| 0| __FILE__,\ | | 378| 0| __LINE__,\ | | 379| 0| (m));\ | | 380| 0| abort();\ | | 381| 0|} while (0) | | ------------------ | | | Branch (381:10): [Folded, False: 0] | | ------------------ ------------------ 16949| 0|} janet_sfree: 16956| 9.91k|void janet_sfree(void *mem) { 16957| 9.91k| if (NULL == mem) return; ------------------ | Branch (16957:9): [True: 0, False: 9.91k] ------------------ 16958| 9.91k| JanetScratch *s = janet_mem2scratch(mem); 16959| 9.91k| if (janet_vm.scratch_len) { ------------------ | Branch (16959:9): [True: 9.91k, False: 0] ------------------ 16960| 13.1k| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 16961| 13.1k| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (16961:17): [True: 9.91k, False: 3.22k] ------------------ 16962| 9.91k| janet_vm.scratch_mem[i] = janet_vm.scratch_mem[--janet_vm.scratch_len]; 16963| 9.91k| free_one_scratch(s); 16964| 9.91k| return; 16965| 9.91k| } 16966| 3.22k| if (i == 0) break; ------------------ | Branch (16966:17): [True: 0, False: 3.22k] ------------------ 16967| 3.22k| } 16968| 9.91k| } 16969| 0| JANET_EXIT("invalid janet_sfree"); ------------------ | | 375| 0|#define JANET_EXIT(m) do { \ | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 377| 0| __FILE__,\ | | 378| 0| __LINE__,\ | | 379| 0| (m));\ | | 380| 0| abort();\ | | 381| 0|} while (0) | | ------------------ | | | Branch (381:10): [Folded, False: 0] | | ------------------ ------------------ 16970| 0|} janet_lib_inttypes: 17644| 3.22k|void janet_lib_inttypes(JanetTable *env) { 17645| 3.22k| JanetRegExt it_cfuns[] = { 17646| 3.22k| JANET_CORE_REG("int/s64", cfun_it_s64_new), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17647| 3.22k| JANET_CORE_REG("int/u64", cfun_it_u64_new), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17648| 3.22k| JANET_CORE_REG("int/to-number", cfun_to_number), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17649| 3.22k| JANET_CORE_REG("int/to-bytes", cfun_to_bytes), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17650| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 17651| 3.22k| }; 17652| | janet_core_cfuns_ext(env, NULL, it_cfuns); 17653| 3.22k| janet_register_abstract_type(&janet_s64_type); 17654| 3.22k| janet_register_abstract_type(&janet_u64_type); 17655| 3.22k|} janet_file_close: 17966| 9.68k|int janet_file_close(JanetFile *file) { 17967| 9.68k| int ret = 0; 17968| 9.68k| if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2265| 9.68k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2266| 9.68k|#define JANET_FILE_CLOSED 32 ------------------ | Branch (17968:9): [True: 0, False: 9.68k] ------------------ 17969| 0| ret = fclose(file->file); 17970| 0| file->flags |= JANET_FILE_CLOSED; ------------------ | | 2266| 0|#define JANET_FILE_CLOSED 32 ------------------ 17971| 0| file->file = NULL; /* NULL dereference is easier to debug then other problems */ 17972| 0| return ret; 17973| 0| } 17974| 9.68k| return 0; 17975| 9.68k|} janet_makefile: 18476| 9.68k|Janet janet_makefile(FILE *f, int32_t flags) { 18477| 9.68k| return janet_wrap_abstract(makef(f, flags, BUFSIZ)); ------------------ | | 846| 9.68k|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 820| 9.68k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 9.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 9.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18478| 9.68k|} janet_lib_io: 18491| 3.22k|void janet_lib_io(JanetTable *env) { 18492| 3.22k| JanetRegExt io_cfuns[] = { 18493| 3.22k| JANET_CORE_REG("print", cfun_io_print), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18494| 3.22k| JANET_CORE_REG("prin", cfun_io_prin), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18495| 3.22k| JANET_CORE_REG("printf", cfun_io_printf), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18496| 3.22k| JANET_CORE_REG("prinf", cfun_io_prinf), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18497| 3.22k| JANET_CORE_REG("eprin", cfun_io_eprin), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18498| 3.22k| JANET_CORE_REG("eprint", cfun_io_eprint), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18499| 3.22k| JANET_CORE_REG("eprintf", cfun_io_eprintf), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18500| 3.22k| JANET_CORE_REG("eprinf", cfun_io_eprinf), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18501| 3.22k| JANET_CORE_REG("xprint", cfun_io_xprint), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18502| 3.22k| JANET_CORE_REG("xprin", cfun_io_xprin), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18503| 3.22k| JANET_CORE_REG("xprintf", cfun_io_xprintf), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18504| 3.22k| JANET_CORE_REG("xprinf", cfun_io_xprinf), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18505| 3.22k| JANET_CORE_REG("flush", cfun_io_flush), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18506| 3.22k| JANET_CORE_REG("eflush", cfun_io_eflush), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18507| 3.22k| JANET_CORE_REG("file/temp", cfun_io_temp), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18508| 3.22k| JANET_CORE_REG("file/open", cfun_io_fopen), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18509| 3.22k| JANET_CORE_REG("file/close", cfun_io_fclose), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18510| 3.22k| JANET_CORE_REG("file/read", cfun_io_fread), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18511| 3.22k| JANET_CORE_REG("file/write", cfun_io_fwrite), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18512| 3.22k| JANET_CORE_REG("file/flush", cfun_io_fflush), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18513| 3.22k| JANET_CORE_REG("file/seek", cfun_io_fseek), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18514| 3.22k| JANET_CORE_REG("file/tell", cfun_io_ftell), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18515| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 18516| 3.22k| }; 18517| 3.22k| janet_core_cfuns_ext(env, NULL, io_cfuns); 18518| 3.22k| janet_register_abstract_type(&janet_file_type); 18519| 3.22k| int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2265| 3.22k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2268| 3.22k|#define JANET_FILE_SERIALIZABLE 128 ------------------ 18520| | /* stdout */ 18521| 3.22k| JANET_CORE_DEF(env, "stdout", ------------------ | | 478| 3.22k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 18522| 3.22k| janet_makefile(stdout, JANET_FILE_APPEND | default_flags), 18523| 3.22k| "The standard output file."); 18524| | /* stderr */ 18525| 3.22k| JANET_CORE_DEF(env, "stderr", ------------------ | | 478| 3.22k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 18526| 3.22k| janet_makefile(stderr, JANET_FILE_APPEND | default_flags), 18527| 3.22k| "The standard error file."); 18528| | /* stdin */ 18529| 3.22k| JANET_CORE_DEF(env, "stdin", ------------------ | | 478| 3.22k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 18530| 3.22k| janet_makefile(stdin, JANET_FILE_READ | default_flags), 18531| 3.22k| "The standard input file."); 18532| | 18533| 3.22k|} janet_env_lookup_into: 18643| 3.22k|void janet_env_lookup_into(JanetTable *renv, JanetTable *env, const char *prefix, int recurse) { 18644| 6.45k| while (env) { ------------------ | Branch (18644:12): [True: 3.22k, False: 3.22k] ------------------ 18645| 6.61M| for (int32_t i = 0; i < env->capacity; i++) { ------------------ | Branch (18645:29): [True: 6.60M, False: 3.22k] ------------------ 18646| 6.60M| if (janet_checktype(env->data[i].key, JANET_SYMBOL)) { ------------------ | | 801| 6.60M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 2.26M, False: 4.34M] | | | Branch (801:6): [Folded, False: 6.60M] | | ------------------ | | 802| 6.60M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 6.60M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 6.60M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 6.60M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 6.60M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.60M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18647| 2.26M| if (prefix) { ------------------ | Branch (18647:21): [True: 0, False: 2.26M] ------------------ 18648| 0| int32_t prelen = (int32_t) strlen(prefix); 18649| 0| const uint8_t *oldsym = janet_unwrap_symbol(env->data[i].key); ------------------ | | 859| 0|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 18650| 0| int32_t oldlen = janet_string_length(oldsym); ------------------ | | 1803| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 18651| 0| uint8_t *symbuf = janet_smalloc(prelen + oldlen); 18652| 0| safe_memcpy(symbuf, prefix, prelen); 18653| 0| safe_memcpy(symbuf + prelen, oldsym, oldlen); 18654| 0| Janet s = janet_symbolv(symbuf, prelen + oldlen); ------------------ | | 1826| 0|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 844| 0|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 823| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18655| 0| janet_sfree(symbuf); 18656| 0| janet_table_put(renv, s, entry_getval(env->data[i].value)); 18657| 2.26M| } else { 18658| 2.26M| janet_table_put(renv, 18659| 2.26M| env->data[i].key, 18660| 2.26M| entry_getval(env->data[i].value)); 18661| 2.26M| } 18662| 2.26M| } 18663| 6.60M| } 18664| 3.22k| env = recurse ? env->proto : NULL; ------------------ | Branch (18664:15): [True: 3.22k, False: 0] ------------------ 18665| 3.22k| } 18666| 3.22k|} janet_env_lookup: 18669| 3.22k|JanetTable *janet_env_lookup(JanetTable *env) { 18670| 3.22k| JanetTable *renv = janet_table(env->count); 18671| | janet_env_lookup_into(renv, env, NULL, 1); 18672| 3.22k| return renv; 18673| 3.22k|} janet_unmarshal: 20192| 6.45k| const uint8_t **next) { 20193| 6.45k| UnmarshalState st; 20194| 6.45k| st.start = bytes; 20195| 6.45k| st.end = bytes + len; 20196| 6.45k| st.lookup_defs = NULL; 20197| 6.45k| st.lookup_envs = NULL; 20198| 6.45k| st.lookup = NULL; 20199| 6.45k| st.reg = reg; 20200| 6.45k| Janet out; 20201| 6.45k| const uint8_t *nextbytes = unmarshal_one(&st, bytes, &out, flags); 20202| 6.45k| if (next) *next = nextbytes; ------------------ | Branch (20202:9): [True: 234, False: 6.22k] ------------------ 20203| 6.45k| janet_v_free(st.lookup_defs); ------------------ | | 705| 6.45k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 713| 3.22k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (705:34): [True: 3.22k, False: 3.22k] | | ------------------ ------------------ 20204| 6.45k| janet_v_free(st.lookup_envs); ------------------ | | 705| 6.45k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 713| 3.22k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (705:34): [True: 3.22k, False: 3.22k] | | ------------------ ------------------ 20205| | janet_v_free(st.lookup); ------------------ | | 705| 6.45k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 713| 3.46k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (705:34): [True: 3.46k, False: 2.99k] | | ------------------ ------------------ 20206| 6.45k| return out; 20207| 6.45k|} janet_lib_marsh: 20264| 3.22k|void janet_lib_marsh(JanetTable *env) { 20265| 3.22k| JanetRegExt marsh_cfuns[] = { 20266| 3.22k| JANET_CORE_REG("marshal", cfun_marshal), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20267| 3.22k| JANET_CORE_REG("unmarshal", cfun_unmarshal), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20268| 3.22k| JANET_CORE_REG("env-lookup", cfun_env_lookup), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20269| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 20270| 3.22k| }; 20271| | janet_core_cfuns_ext(env, NULL, marsh_cfuns); 20272| 3.22k|} janet_default_rng: 20347| 3.22k|JanetRNG *janet_default_rng(void) { 20348| 3.22k| return &janet_vm.rng; 20349| 3.22k|} janet_rng_seed: 20351| 6.45k|void janet_rng_seed(JanetRNG *rng, uint32_t seed) { 20352| 6.45k| rng->a = seed; 20353| 6.45k| rng->b = 0x97654321u; 20354| 6.45k| rng->c = 123871873u; 20355| 6.45k| rng->d = 0xf23f56c8u; 20356| 6.45k| rng->counter = 0u; 20357| | /* First several numbers aren't that random. */ 20358| 109k| for (int i = 0; i < 16; i++) janet_rng_u32(rng); ------------------ | Branch (20358:21): [True: 103k, False: 6.45k] ------------------ 20359| 6.45k|} janet_rng_u32: 20375| 103k|uint32_t janet_rng_u32(JanetRNG *rng) { 20376| | /* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */ 20377| 103k| uint32_t t = rng->d; 20378| 103k| uint32_t const s = rng->a; 20379| 103k| rng->d = rng->c; 20380| 103k| rng->c = rng->b; 20381| 103k| rng->b = s; 20382| 103k| t ^= t >> 2; 20383| 103k| t ^= t << 1; 20384| 103k| t ^= s ^ (s << 4); 20385| 103k| rng->a = t; 20386| 103k| rng->counter += 362437; 20387| 103k| return t + rng->counter; 20388| 103k|} janet_lib_math: 20654| 3.22k|void janet_lib_math(JanetTable *env) { 20655| 3.22k| JanetRegExt math_cfuns[] = { 20656| 3.22k| JANET_CORE_REG("not", janet_not), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20657| 3.22k| JANET_CORE_REG("math/random", janet_rand), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20658| 3.22k| JANET_CORE_REG("math/seedrandom", janet_srand), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20659| 3.22k| JANET_CORE_REG("math/cos", janet_cos), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20660| 3.22k| JANET_CORE_REG("math/sin", janet_sin), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20661| 3.22k| JANET_CORE_REG("math/tan", janet_tan), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20662| 3.22k| JANET_CORE_REG("math/acos", janet_acos), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20663| 3.22k| JANET_CORE_REG("math/asin", janet_asin), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20664| 3.22k| JANET_CORE_REG("math/atan", janet_atan), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20665| 3.22k| JANET_CORE_REG("math/exp", janet_exp), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20666| 3.22k| JANET_CORE_REG("math/log", janet_log), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20667| 3.22k| JANET_CORE_REG("math/log10", janet_log10), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20668| 3.22k| JANET_CORE_REG("math/log2", janet_log2), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20669| 3.22k| JANET_CORE_REG("math/sqrt", janet_sqrt), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20670| 3.22k|#ifndef JANET_PLAN9 20671| 3.22k| JANET_CORE_REG("math/cbrt", janet_cbrt), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20672| 3.22k| JANET_CORE_REG("math/gamma", janet_tgamma), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20673| 3.22k| JANET_CORE_REG("math/log-gamma", janet_lgamma), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20674| 3.22k| JANET_CORE_REG("math/erfc", janet_erfc), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20675| 3.22k| JANET_CORE_REG("math/erf", janet_erf), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20676| 3.22k| JANET_CORE_REG("math/expm1", janet_expm1), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20677| 3.22k| JANET_CORE_REG("math/atanh", janet_atanh), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20678| 3.22k| JANET_CORE_REG("math/asinh", janet_asinh), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20679| 3.22k| JANET_CORE_REG("math/next", janet_nextafter), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20680| 3.22k|#endif 20681| 3.22k| JANET_CORE_REG("math/floor", janet_floor), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20682| 3.22k| JANET_CORE_REG("math/ceil", janet_ceil), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20683| 3.22k| JANET_CORE_REG("math/pow", janet_pow), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20684| 3.22k| JANET_CORE_REG("math/abs", janet_fabs), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20685| 3.22k| JANET_CORE_REG("math/sinh", janet_sinh), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20686| 3.22k| JANET_CORE_REG("math/cosh", janet_cosh), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20687| 3.22k| JANET_CORE_REG("math/tanh", janet_tanh), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20688| 3.22k| JANET_CORE_REG("math/acosh", janet_acosh), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20689| 3.22k| JANET_CORE_REG("math/atan2", janet_atan2), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20690| 3.22k| JANET_CORE_REG("math/rng", cfun_rng_make), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20691| 3.22k| JANET_CORE_REG("math/rng-uniform", cfun_rng_uniform), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20692| 3.22k| JANET_CORE_REG("math/rng-int", cfun_rng_int), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20693| 3.22k| JANET_CORE_REG("math/rng-buffer", cfun_rng_buffer), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20694| 3.22k| JANET_CORE_REG("math/hypot", janet_hypot), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20695| 3.22k| JANET_CORE_REG("math/exp2", janet_exp2), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20696| 3.22k| JANET_CORE_REG("math/log1p", janet_log1p), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20697| 3.22k| JANET_CORE_REG("math/trunc", janet_trunc), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20698| 3.22k| JANET_CORE_REG("math/round", janet_round), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20699| 3.22k| JANET_CORE_REG("math/gcd", janet_cfun_gcd), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20700| 3.22k| JANET_CORE_REG("math/lcm", janet_cfun_lcm), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20701| 3.22k| JANET_CORE_REG("math/frexp", janet_cfun_frexp), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20702| 3.22k| JANET_CORE_REG("math/ldexp", janet_cfun_ldexp), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20703| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 20704| 3.22k| }; 20705| 3.22k| janet_core_cfuns_ext(env, NULL, math_cfuns); 20706| 3.22k| janet_register_abstract_type(&janet_rng_type); 20707| |#ifdef JANET_BOOTSTRAP 20708| | JANET_CORE_DEF(env, "math/pi", janet_wrap_number(3.1415926535897931), 20709| | "The value pi."); 20710| | JANET_CORE_DEF(env, "math/e", janet_wrap_number(2.7182818284590451), 20711| | "The base of the natural log."); 20712| | JANET_CORE_DEF(env, "math/inf", janet_wrap_number(INFINITY), 20713| | "The number representing positive infinity"); 20714| | JANET_CORE_DEF(env, "math/-inf", janet_wrap_number(-INFINITY), 20715| | "The number representing negative infinity"); 20716| | JANET_CORE_DEF(env, "math/int32-min", janet_wrap_number(INT32_MIN), 20717| | "The minimum contiguous integer representable by a 32 bit signed integer"); 20718| | JANET_CORE_DEF(env, "math/int32-max", janet_wrap_number(INT32_MAX), 20719| | "The maximum contiguous integer representable by a 32 bit signed integer"); 20720| | JANET_CORE_DEF(env, "math/int-min", janet_wrap_number(JANET_INTMIN_DOUBLE), 20721| | "The minimum contiguous integer representable by a double (-(2^53))"); 20722| | JANET_CORE_DEF(env, "math/int-max", janet_wrap_number(JANET_INTMAX_DOUBLE), 20723| | "The maximum contiguous integer representable by a double (2^53)"); 20724| |#ifdef NAN 20725| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(NAN), "Not a number (IEEE-754 NaN)"); 20726| |#else 20727| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(0.0 / 0.0), "Not a number (IEEE-754 NaN)"); 20728| |#endif 20729| |#endif 20730| 3.22k|} janet_lib_net: 21986| 3.22k|void janet_lib_net(JanetTable *env) { 21987| 3.22k| JanetRegExt net_cfuns[] = { 21988| 3.22k| JANET_CORE_REG("net/address", cfun_net_sockaddr), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21989| 3.22k| JANET_CORE_REG("net/listen", cfun_net_listen), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21990| 3.22k| JANET_CORE_REG("net/socket", cfun_net_socket), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21991| 3.22k| JANET_CORE_REG("net/accept", cfun_stream_accept), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21992| 3.22k| JANET_CORE_REG("net/accept-loop", cfun_stream_accept_loop), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21993| 3.22k| JANET_CORE_REG("net/read", cfun_stream_read), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21994| 3.22k| JANET_CORE_REG("net/chunk", cfun_stream_chunk), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21995| 3.22k| JANET_CORE_REG("net/write", cfun_stream_write), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21996| 3.22k| JANET_CORE_REG("net/send-to", cfun_stream_send_to), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21997| 3.22k| JANET_CORE_REG("net/recv-from", cfun_stream_recv_from), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21998| 3.22k| JANET_CORE_REG("net/flush", cfun_stream_flush), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 21999| 3.22k| JANET_CORE_REG("net/connect", cfun_net_connect), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22000| 3.22k| JANET_CORE_REG("net/shutdown", cfun_net_shutdown), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22001| 3.22k| JANET_CORE_REG("net/peername", cfun_net_getpeername), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22002| 3.22k| JANET_CORE_REG("net/localname", cfun_net_getsockname), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22003| 3.22k| JANET_CORE_REG("net/address-unpack", cfun_net_address_unpack), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22004| 3.22k| JANET_CORE_REG("net/setsockopt", cfun_net_setsockopt), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22005| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 22006| 3.22k| }; 22007| | janet_core_cfuns_ext(env, NULL, net_cfuns); 22008| 3.22k|} janet_net_init: 22010| 3.22k|void janet_net_init(void) { 22011| |#ifdef JANET_WINDOWS 22012| | WSADATA wsaData; 22013| | janet_assert(!WSAStartup(MAKEWORD(2, 2), &wsaData), "could not start winsock"); 22014| | janet_vm.connect_ex_loaded = 0; 22015| | janet_vm.connect_ex = NULL; 22016| |#endif 22017| 3.22k|} janet_net_deinit: 22019| 3.22k|void janet_net_deinit(void) { 22020| |#ifdef JANET_WINDOWS 22021| | WSACleanup(); 22022| |#endif 22023| 3.22k|} janet_lib_os: 24974| 3.22k|void janet_lib_os(JanetTable *env) { 24975| |#if !defined(JANET_REDUCED_OS) && defined(JANET_WINDOWS) && defined(JANET_THREADS) 24976| | /* During start up, the top-most abstract machine (thread) 24977| | * in the thread tree sets up the critical section. */ 24978| | static volatile long env_lock_initializing = 0; 24979| | static volatile long env_lock_initialized = 0; 24980| | if (!InterlockedExchange(&env_lock_initializing, 1)) { 24981| | InitializeCriticalSection(&env_lock); 24982| | InterlockedOr(&env_lock_initialized, 1); 24983| | } else { 24984| | while (!InterlockedOr(&env_lock_initialized, 0)) { 24985| | Sleep(0); 24986| | } 24987| | } 24988| | 24989| |#endif 24990| 3.22k|#ifndef JANET_NO_PROCESSES 24991| 3.22k|#endif 24992| 3.22k| JanetRegExt os_cfuns[] = { 24993| 3.22k| JANET_CORE_REG("os/exit", os_exit), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 24994| 3.22k| JANET_CORE_REG("os/which", os_which), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 24995| 3.22k| JANET_CORE_REG("os/arch", os_arch), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 24996| 3.22k| JANET_CORE_REG("os/compiler", os_compiler), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 24997| 3.22k|#ifndef JANET_REDUCED_OS 24998| | 24999| | /* misc (un-sandboxed) */ 25000| 3.22k| JANET_CORE_REG("os/cpu-count", os_cpu_count), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25001| 3.22k| JANET_CORE_REG("os/cwd", os_cwd), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25002| 3.22k| JANET_CORE_REG("os/cryptorand", os_cryptorand), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25003| 3.22k| JANET_CORE_REG("os/perm-string", os_permission_string), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25004| 3.22k| JANET_CORE_REG("os/perm-int", os_permission_int), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25005| 3.22k| JANET_CORE_REG("os/mktime", os_mktime), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25006| 3.22k| JANET_CORE_REG("os/time", os_time), /* not high resolution */ ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25007| 3.22k| JANET_CORE_REG("os/date", os_date), /* not high resolution */ ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25008| 3.22k| JANET_CORE_REG("os/strftime", os_strftime), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25009| 3.22k| JANET_CORE_REG("os/sleep", os_sleep), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25010| 3.22k| JANET_CORE_REG("os/isatty", os_isatty), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25011| 3.22k|#ifndef JANET_NO_LOCALES 25012| 3.22k| JANET_CORE_REG("os/setlocale", os_setlocale), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25013| 3.22k|#endif 25014| | 25015| | /* env functions */ 25016| 3.22k|#ifndef JANET_PLAN9 25017| 3.22k| JANET_CORE_REG("os/environ", os_environ), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25018| 3.22k|#endif 25019| 3.22k| JANET_CORE_REG("os/getenv", os_getenv), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25020| 3.22k| JANET_CORE_REG("os/setenv", os_setenv), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25021| | 25022| | /* fs read */ 25023| 3.22k| JANET_CORE_REG("os/dir", os_dir), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25024| 3.22k| JANET_CORE_REG("os/stat", os_stat), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25025| 3.22k| JANET_CORE_REG("os/lstat", os_lstat), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25026| 3.22k| JANET_CORE_REG("os/chmod", os_chmod), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25027| 3.22k| JANET_CORE_REG("os/touch", os_touch), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25028| 3.22k| JANET_CORE_REG("os/realpath", os_realpath), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25029| 3.22k| JANET_CORE_REG("os/cd", os_cd), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25030| 3.22k|#ifndef JANET_NO_UMASK 25031| 3.22k| JANET_CORE_REG("os/umask", os_umask), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25032| 3.22k|#endif 25033| 3.22k|#ifndef JANET_NO_SYMLINKS 25034| 3.22k| JANET_CORE_REG("os/readlink", os_readlink), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25035| 3.22k|#endif 25036| | 25037| | /* fs write */ 25038| 3.22k| JANET_CORE_REG("os/mkdir", os_mkdir), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25039| 3.22k| JANET_CORE_REG("os/rmdir", os_rmdir), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25040| 3.22k| JANET_CORE_REG("os/rm", os_remove), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25041| 3.22k| JANET_CORE_REG("os/link", os_link), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25042| 3.22k| JANET_CORE_REG("os/rename", os_rename), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25043| 3.22k|#ifndef JANET_NO_SYMLINKS 25044| 3.22k| JANET_CORE_REG("os/symlink", os_symlink), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25045| 3.22k|#endif 25046| | 25047| | /* processes */ 25048| 3.22k|#ifndef JANET_NO_PROCESSES 25049| 3.22k| JANET_CORE_REG("os/execute", os_execute), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25050| 3.22k| JANET_CORE_REG("os/spawn", os_spawn), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25051| 3.22k| JANET_CORE_REG("os/shell", os_shell), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25052| 3.22k| JANET_CORE_REG("os/posix-fork", os_posix_fork), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25053| 3.22k| JANET_CORE_REG("os/posix-exec", os_posix_exec), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25054| 3.22k| JANET_CORE_REG("os/posix-chroot", os_posix_chroot), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25055| | /* no need to sandbox process management if you can't create processes 25056| | * (allows for limited functionality if use exposes C-functions to create specific processes) */ 25057| 3.22k| JANET_CORE_REG("os/proc-wait", os_proc_wait), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25058| 3.22k| JANET_CORE_REG("os/proc-kill", os_proc_kill), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25059| 3.22k| JANET_CORE_REG("os/proc-close", os_proc_close), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25060| 3.22k| JANET_CORE_REG("os/getpid", os_proc_getpid), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25061| 3.22k|#ifdef JANET_EV 25062| 3.22k| JANET_CORE_REG("os/sigaction", os_sigaction), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25063| 3.22k|#endif 25064| 3.22k|#endif 25065| | 25066| | /* high resolution timers */ 25067| 3.22k| JANET_CORE_REG("os/clock", os_clock), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25068| | 25069| 3.22k|#ifdef JANET_EV 25070| 3.22k| JANET_CORE_REG("os/open", os_open), /* fs read and write */ ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25071| 3.22k| JANET_CORE_REG("os/pipe", os_pipe), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25072| 3.22k|#endif 25073| 3.22k|#endif 25074| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 25075| 3.22k| }; 25076| | janet_core_cfuns_ext(env, NULL, os_cfuns); 25077| 3.22k|} janet_lib_parse: 26391| 3.22k|void janet_lib_parse(JanetTable *env) { 26392| 3.22k| JanetRegExt parse_cfuns[] = { 26393| 3.22k| JANET_CORE_REG("parser/new", cfun_parse_parser), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26394| 3.22k| JANET_CORE_REG("parser/clone", cfun_parse_clone), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26395| 3.22k| JANET_CORE_REG("parser/has-more", cfun_parse_has_more), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26396| 3.22k| JANET_CORE_REG("parser/produce", cfun_parse_produce), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26397| 3.22k| JANET_CORE_REG("parser/consume", cfun_parse_consume), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26398| 3.22k| JANET_CORE_REG("parser/byte", cfun_parse_byte), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26399| 3.22k| JANET_CORE_REG("parser/error", cfun_parse_error), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26400| 3.22k| JANET_CORE_REG("parser/status", cfun_parse_status), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26401| 3.22k| JANET_CORE_REG("parser/flush", cfun_parse_flush), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26402| 3.22k| JANET_CORE_REG("parser/state", cfun_parse_state), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26403| 3.22k| JANET_CORE_REG("parser/where", cfun_parse_where), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26404| 3.22k| JANET_CORE_REG("parser/eof", cfun_parse_eof), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26405| 3.22k| JANET_CORE_REG("parser/insert", cfun_parse_insert), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26406| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 26407| 3.22k| }; 26408| | janet_core_cfuns_ext(env, NULL, parse_cfuns); 26409| 3.22k|} janet_lib_peg: 28509| 3.22k|void janet_lib_peg(JanetTable *env) { 28510| 3.22k| JanetRegExt cfuns[] = { 28511| 3.22k| JANET_CORE_REG("peg/compile", cfun_peg_compile), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28512| 3.22k| JANET_CORE_REG("peg/match", cfun_peg_match), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28513| 3.22k| JANET_CORE_REG("peg/find", cfun_peg_find), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28514| 3.22k| JANET_CORE_REG("peg/find-all", cfun_peg_find_all), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28515| 3.22k| JANET_CORE_REG("peg/replace", cfun_peg_replace), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28516| 3.22k| JANET_CORE_REG("peg/replace-all", cfun_peg_replace_all), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28517| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 28518| 3.22k| }; 28519| | janet_core_cfuns_ext(env, NULL, cfuns); 28520| 3.22k| janet_register_abstract_type(&janet_peg_type); 28521| 3.22k|} janet_to_string_b: 28749| 282|void janet_to_string_b(JanetBuffer *buffer, Janet x) { 28750| 282| switch (janet_type(x)) { ------------------ | | 790| 282| (isnan((x).number) \ | | 791| 282| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 282| : JANET_NUMBER) ------------------ | Branch (28750:13): [True: 44, False: 238] ------------------ 28751| 0| case JANET_NIL: ------------------ | Branch (28751:9): [True: 0, False: 282] ------------------ 28752| 0| janet_buffer_push_cstring(buffer, ""); 28753| 0| break; 28754| 5| case JANET_BOOLEAN: ------------------ | Branch (28754:9): [True: 5, False: 277] ------------------ 28755| 5| janet_buffer_push_cstring(buffer, 28756| 5| janet_unwrap_boolean(x) ? "true" : "false"); ------------------ | | 833| 5|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) | | ------------------ | | | Branch (833:33): [True: 3, False: 2] | | ------------------ ------------------ 28757| 5| break; 28758| 238| case JANET_NUMBER: ------------------ | Branch (28758:9): [True: 238, False: 44] ------------------ 28759| 238| number_to_string_b(buffer, janet_unwrap_number(x)); ------------------ | | 834| 238|#define janet_unwrap_number(x) ((x).number) ------------------ 28760| 238| break; 28761| 0| case JANET_STRING: ------------------ | Branch (28761:9): [True: 0, False: 282] ------------------ 28762| 7| case JANET_SYMBOL: ------------------ | Branch (28762:9): [True: 7, False: 275] ------------------ 28763| 10| case JANET_KEYWORD: ------------------ | Branch (28763:9): [True: 3, False: 279] ------------------ 28764| 10| janet_buffer_push_bytes(buffer, 28765| 10| janet_unwrap_string(x), ------------------ | | 858| 10|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 28766| 10| janet_string_length(janet_unwrap_string(x))); ------------------ | | 1803| 10|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 10|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 28767| 10| break; 28768| 0| case JANET_BUFFER: { ------------------ | Branch (28768:9): [True: 0, False: 282] ------------------ 28769| 0| JanetBuffer *to = janet_unwrap_buffer(x); ------------------ | | 857| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 28770| | /* Prevent resizing buffer while appending */ 28771| 0| if (buffer == to) janet_buffer_extra(buffer, to->count); ------------------ | Branch (28771:17): [True: 0, False: 0] ------------------ 28772| 0| janet_buffer_push_bytes(buffer, to->data, to->count); 28773| 0| break; 28774| 7| } 28775| 0| case JANET_ABSTRACT: { ------------------ | Branch (28775:9): [True: 0, False: 282] ------------------ 28776| 0| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 861| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 28777| 0| const JanetAbstractType *t = janet_abstract_type(p); ------------------ | | 1889| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1887| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 28778| 0| if (t->tostring != NULL) { ------------------ | Branch (28778:17): [True: 0, False: 0] ------------------ 28779| 0| t->tostring(p, buffer); 28780| 0| } else { 28781| 0| string_description_b(buffer, t->name, p); 28782| 0| } 28783| 0| } 28784| 0| return; 28785| 2| case JANET_CFUNCTION: { ------------------ | Branch (28785:9): [True: 2, False: 280] ------------------ 28786| 2| JanetCFunRegistry *reg = janet_registry_get(janet_unwrap_cfunction(x)); ------------------ | | 864| 2|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 28787| 2| if (NULL != reg) { ------------------ | Branch (28787:17): [True: 2, False: 0] ------------------ 28788| 2| janet_buffer_push_cstring(buffer, "name_prefix) { ------------------ | Branch (28789:21): [True: 0, False: 2] ------------------ 28790| 0| janet_buffer_push_cstring(buffer, reg->name_prefix); 28791| 0| janet_buffer_push_u8(buffer, '/'); 28792| 0| } 28793| 2| janet_buffer_push_cstring(buffer, reg->name); 28794| 2| janet_buffer_push_u8(buffer, '>'); 28795| 2| break; 28796| 2| } 28797| 0| goto fallthrough; 28798| 2| } 28799| 7| case JANET_FUNCTION: { ------------------ | Branch (28799:9): [True: 7, False: 275] ------------------ 28800| 7| JanetFunction *fun = janet_unwrap_function(x); ------------------ | | 863| 7|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 28801| 7| JanetFuncDef *def = fun->def; 28802| 7| if (def == NULL) { ------------------ | Branch (28802:17): [True: 2, False: 5] ------------------ 28803| 2| janet_buffer_push_cstring(buffer, ""); 28804| 2| break; 28805| 2| } 28806| 5| if (def->name) { ------------------ | Branch (28806:17): [True: 1, False: 4] ------------------ 28807| 1| const uint8_t *n = def->name; 28808| 1| janet_buffer_push_cstring(buffer, "length) | | ------------------ | | | | 1802| 1|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 28810| 1| janet_buffer_push_u8(buffer, '>'); 28811| 1| break; 28812| 1| } 28813| 4| goto fallthrough; 28814| 5| } 28815| 4| fallthrough: 28816| 24| default: ------------------ | Branch (28816:9): [True: 20, False: 262] ------------------ 28817| 24| string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 790| 24| (isnan((x).number) \ | | 791| 24| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 24| : JANET_NUMBER) ------------------ string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 862| 24|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (28817:59): [True: 24, False: 0] ------------------ 28818| 24| break; 28819| 282| } 28820| 282|} janet_description_b: 28835| 425|void janet_description_b(JanetBuffer *buffer, Janet x) { 28836| 425| switch (janet_type(x)) { ------------------ | | 790| 425| (isnan((x).number) \ | | 791| 425| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 425| : JANET_NUMBER) ------------------ | Branch (28836:13): [True: 187, False: 238] ------------------ 28837| 279| default: ------------------ | Branch (28837:9): [True: 279, False: 146] ------------------ 28838| 279| break; 28839| 279| case JANET_NIL: ------------------ | Branch (28839:9): [True: 4, False: 421] ------------------ 28840| 4| janet_buffer_push_cstring(buffer, "nil"); 28841| 4| return; 28842| 3| case JANET_KEYWORD: ------------------ | Branch (28842:9): [True: 3, False: 422] ------------------ 28843| 3| janet_buffer_push_u8(buffer, ':'); 28844| 3| break; 28845| 92| case JANET_STRING: ------------------ | Branch (28845:9): [True: 92, False: 333] ------------------ 28846| 92| janet_escape_string_b(buffer, janet_unwrap_string(x)); ------------------ | | 858| 92|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 28847| 92| return; 28848| 47| case JANET_BUFFER: { ------------------ | Branch (28848:9): [True: 47, False: 378] ------------------ 28849| 47| JanetBuffer *b = janet_unwrap_buffer(x); ------------------ | | 857| 47|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 28850| 47| janet_escape_buffer_b(buffer, b); 28851| 47| return; 28852| 0| } 28853| 0| case JANET_ABSTRACT: { ------------------ | Branch (28853:9): [True: 0, False: 425] ------------------ 28854| 0| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 861| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 28855| 0| const JanetAbstractType *t = janet_abstract_type(p); ------------------ | | 1889| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1887| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 28856| 0| if (t->tostring != NULL) { ------------------ | Branch (28856:17): [True: 0, False: 0] ------------------ 28857| 0| janet_buffer_push_cstring(buffer, "<"); 28858| 0| janet_buffer_push_cstring(buffer, t->name); 28859| 0| janet_buffer_push_cstring(buffer, " "); 28860| 0| t->tostring(p, buffer); 28861| 0| janet_buffer_push_cstring(buffer, ">"); 28862| 0| } else { 28863| 0| string_description_b(buffer, t->name, p); 28864| 0| } 28865| 0| return; 28866| 0| } 28867| 425| } 28868| 282| janet_to_string_b(buffer, x); 28869| 282|} janet_formatbv: 29493| 1.27k|void janet_formatbv(JanetBuffer *b, const char *format, va_list args) { 29494| 1.27k| const char *format_end = format + strlen(format); 29495| 1.27k| const char *c = format; 29496| 1.27k| int32_t startlen = b->count; 29497| 36.7k| while (c < format_end) { ------------------ | Branch (29497:12): [True: 35.5k, False: 1.27k] ------------------ 29498| 35.5k| if (*c != '%') { ------------------ | Branch (29498:13): [True: 33.3k, False: 2.17k] ------------------ 29499| 33.3k| janet_buffer_push_u8(b, (uint8_t) *c++); 29500| 33.3k| } else if (*++c == '%') { ------------------ | Branch (29500:20): [True: 0, False: 2.17k] ------------------ 29501| 0| janet_buffer_push_u8(b, (uint8_t) *c++); 29502| 2.17k| } else { 29503| 2.17k| char form[MAX_FORMAT], item[MAX_ITEM]; 29504| 2.17k| char width[3], precision[3]; 29505| 2.17k| int nb = 0; /* number of bytes in added item */ 29506| 2.17k| c = scanformat(c, form, width, precision); 29507| 2.17k| switch (*c++) { 29508| 0| case 'c': { ------------------ | Branch (29508:17): [True: 0, False: 2.17k] ------------------ 29509| 0| int n = va_arg(args, int); 29510| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |29416| 0|#define MAX_ITEM 256 ------------------ 29511| 0| break; 29512| 0| } 29513| 852| case 'd': ------------------ | Branch (29513:17): [True: 852, False: 1.32k] ------------------ 29514| 852| case 'i': { ------------------ | Branch (29514:17): [True: 0, False: 2.17k] ------------------ 29515| 852| int64_t n = (int64_t) va_arg(args, int32_t); 29516| 852| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |29416| 852|#define MAX_ITEM 256 ------------------ 29517| 852| break; 29518| 852| } 29519| 0| case 'D': ------------------ | Branch (29519:17): [True: 0, False: 2.17k] ------------------ 29520| 0| case 'I': { ------------------ | Branch (29520:17): [True: 0, False: 2.17k] ------------------ 29521| 0| int64_t n = va_arg(args, int64_t); 29522| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |29416| 0|#define MAX_ITEM 256 ------------------ 29523| 0| break; 29524| 0| } 29525| 490| case 'x': ------------------ | Branch (29525:17): [True: 490, False: 1.68k] ------------------ 29526| 490| case 'X': ------------------ | Branch (29526:17): [True: 0, False: 2.17k] ------------------ 29527| 490| case 'o': ------------------ | Branch (29527:17): [True: 0, False: 2.17k] ------------------ 29528| 490| case 'u': { ------------------ | Branch (29528:17): [True: 0, False: 2.17k] ------------------ 29529| 490| uint64_t n = va_arg(args, uint64_t); 29530| 490| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |29416| 490|#define MAX_ITEM 256 ------------------ 29531| 490| break; 29532| 490| } 29533| 0| case 'a': ------------------ | Branch (29533:17): [True: 0, False: 2.17k] ------------------ 29534| 0| case 'A': ------------------ | Branch (29534:17): [True: 0, False: 2.17k] ------------------ 29535| 0| case 'e': ------------------ | Branch (29535:17): [True: 0, False: 2.17k] ------------------ 29536| 0| case 'E': ------------------ | Branch (29536:17): [True: 0, False: 2.17k] ------------------ 29537| 0| case 'f': ------------------ | Branch (29537:17): [True: 0, False: 2.17k] ------------------ 29538| 0| case 'g': ------------------ | Branch (29538:17): [True: 0, False: 2.17k] ------------------ 29539| 0| case 'G': { ------------------ | Branch (29539:17): [True: 0, False: 2.17k] ------------------ 29540| 0| double d = va_arg(args, double); 29541| 0| nb = snprintf(item, MAX_ITEM, form, d); ------------------ | |29416| 0|#define MAX_ITEM 256 ------------------ 29542| 0| break; 29543| 0| } 29544| 0| case 's': ------------------ | Branch (29544:17): [True: 0, False: 2.17k] ------------------ 29545| 0| case 'S': { ------------------ | Branch (29545:17): [True: 0, False: 2.17k] ------------------ 29546| 0| const char *str = va_arg(args, const char *); 29547| 0| int32_t len = (c[-1] == 's') ------------------ | Branch (29547:35): [True: 0, False: 0] ------------------ 29548| 0| ? (int32_t) strlen(str) 29549| 0| : janet_string_length((JanetString) str); ------------------ | | 1803| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 29550| 0| if (form[2] == '\0') ------------------ | Branch (29550:25): [True: 0, False: 0] ------------------ 29551| 0| janet_buffer_push_bytes(b, (const uint8_t *) str, len); 29552| 0| else { 29553| 0| if (len != (int32_t) strlen((const char *) str)) ------------------ | Branch (29553:29): [True: 0, False: 0] ------------------ 29554| 0| janet_panic("string contains zeros"); 29555| 0| if (!strchr(form, '.') && len >= 100) { ------------------ | Branch (29555:29): [True: 0, False: 0] | Branch (29555:51): [True: 0, False: 0] ------------------ 29556| 0| janet_panic("no precision and string is too long to be formatted"); 29557| 0| } else { 29558| 0| nb = snprintf(item, MAX_ITEM, form, str); ------------------ | |29416| 0|#define MAX_ITEM 256 ------------------ 29559| 0| } 29560| 0| } 29561| 0| break; 29562| 0| } 29563| 0| case 'V': ------------------ | Branch (29563:17): [True: 0, False: 2.17k] ------------------ 29564| 0| janet_to_string_b(b, va_arg(args, Janet)); 29565| 0| break; 29566| 425| case 'v': ------------------ | Branch (29566:17): [True: 425, False: 1.74k] ------------------ 29567| 425| janet_description_b(b, va_arg(args, Janet)); 29568| 425| break; 29569| 0| case 't': ------------------ | Branch (29569:17): [True: 0, False: 2.17k] ------------------ 29570| 0| janet_buffer_push_cstring(b, typestr(va_arg(args, Janet))); 29571| 0| break; 29572| 405| case 'T': { ------------------ | Branch (29572:17): [True: 405, False: 1.76k] ------------------ 29573| 405| int types = va_arg(args, int); 29574| 405| pushtypes(b, types); 29575| 405| break; 29576| 0| } 29577| 0| case 'M': ------------------ | Branch (29577:17): [True: 0, False: 2.17k] ------------------ 29578| 0| case 'm': ------------------ | Branch (29578:17): [True: 0, False: 2.17k] ------------------ 29579| 0| case 'N': ------------------ | Branch (29579:17): [True: 0, False: 2.17k] ------------------ 29580| 0| case 'n': ------------------ | Branch (29580:17): [True: 0, False: 2.17k] ------------------ 29581| 0| case 'Q': ------------------ | Branch (29581:17): [True: 0, False: 2.17k] ------------------ 29582| 0| case 'q': ------------------ | Branch (29582:17): [True: 0, False: 2.17k] ------------------ 29583| 0| case 'P': ------------------ | Branch (29583:17): [True: 0, False: 2.17k] ------------------ 29584| 0| case 'p': { /* janet pretty , precision = depth */ ------------------ | Branch (29584:17): [True: 0, False: 2.17k] ------------------ 29585| 0| int depth = atoi(precision); 29586| 0| if (depth < 1) depth = JANET_RECURSION_GUARD; ------------------ | | 291| 0|#define JANET_RECURSION_GUARD 1024 ------------------ | Branch (29586:25): [True: 0, False: 0] ------------------ 29587| 0| char d = c[-1]; 29588| 0| int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N'); ------------------ | Branch (29588:37): [True: 0, False: 0] | Branch (29588:51): [True: 0, False: 0] | Branch (29588:65): [True: 0, False: 0] | Branch (29588:79): [True: 0, False: 0] ------------------ 29589| 0| int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n'); ------------------ | Branch (29589:39): [True: 0, False: 0] | Branch (29589:53): [True: 0, False: 0] | Branch (29589:67): [True: 0, False: 0] | Branch (29589:81): [True: 0, False: 0] ------------------ 29590| 0| int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n'); ------------------ | Branch (29590:39): [True: 0, False: 0] | Branch (29590:53): [True: 0, False: 0] | Branch (29590:67): [True: 0, False: 0] | Branch (29590:81): [True: 0, False: 0] ------------------ 29591| 0| int columns = atoi(width); 29592| 0| if (columns == 0) { ------------------ | Branch (29592:25): [True: 0, False: 0] ------------------ 29593| 0| columns = JANET_COLUMNS; ------------------ | |29329| 0|#define JANET_COLUMNS 80 ------------------ 29594| 0| } else if (columns < 0) { ------------------ | Branch (29594:32): [True: 0, False: 0] ------------------ 29595| 0| has_oneline = 1; 29596| 0| } 29597| 0| int flags = 0; 29598| 0| flags |= has_color ? JANET_PRETTY_COLOR : 0; ------------------ | | 1957| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (29598:30): [True: 0, False: 0] ------------------ 29599| 0| flags |= has_oneline ? JANET_PRETTY_ONELINE : 0; ------------------ | | 1958| 0|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (29599:30): [True: 0, False: 0] ------------------ 29600| 0| flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0; ------------------ | | 1959| 0|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (29600:30): [True: 0, False: 0] ------------------ 29601| 0| janet_pretty_(b, depth, columns, flags, 29602| 0| va_arg(args, Janet), startlen, b->count); 29603| 0| break; 29604| 0| } 29605| 0| case 'j': { ------------------ | Branch (29605:17): [True: 0, False: 2.17k] ------------------ 29606| 0| int depth = atoi(precision); 29607| 0| if (depth < 1) { ------------------ | Branch (29607:25): [True: 0, False: 0] ------------------ 29608| 0| depth = JANET_RECURSION_GUARD; ------------------ | | 291| 0|#define JANET_RECURSION_GUARD 1024 ------------------ 29609| 0| } 29610| 0| janet_jdn_(b, depth, va_arg(args, Janet), startlen, b->count); 29611| 0| break; 29612| 0| } 29613| 0| default: { ------------------ | Branch (29613:17): [True: 0, False: 2.17k] ------------------ 29614| | /* also treat cases 'nLlh' */ 29615| 0| janet_panicf("invalid conversion '%s' to 'format'", 29616| 0| form); 29617| 0| } 29618| 2.17k| } 29619| 2.17k| if (nb >= MAX_ITEM) ------------------ | |29416| 2.17k|#define MAX_ITEM 256 ------------------ | Branch (29619:17): [True: 0, False: 2.17k] ------------------ 29620| 0| janet_panic("format buffer overflow"); 29621| 2.17k| if (nb > 0) ------------------ | Branch (29621:17): [True: 1.34k, False: 830] ------------------ 29622| 1.34k| janet_buffer_push_bytes(b, (uint8_t *) item, nb); 29623| 2.17k| } 29624| | 29625| 35.5k| } 29626| 1.27k|} janet_string: 31515| 4.74M|const uint8_t *janet_string(const uint8_t *buf, int32_t len) { 31516| 4.74M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1); 31517| 4.74M| head->length = len; 31518| 4.74M| head->hash = janet_string_calchash(buf, len); 31519| 4.74M| uint8_t *data = (uint8_t *)head->data; 31520| 4.74M| safe_memcpy(data, buf, len); 31521| 4.74M| data[len] = 0; 31522| 4.74M| return data; 31523| 4.74M|} janet_string_compare: 31526| 3.40k|int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) { 31527| 3.40k| int32_t xlen = janet_string_length(lhs); ------------------ | | 1803| 3.40k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 3.40k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31528| 3.40k| int32_t ylen = janet_string_length(rhs); ------------------ | | 1803| 3.40k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 3.40k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31529| 3.40k| int32_t len = xlen > ylen ? ylen : xlen; ------------------ | Branch (31529:19): [True: 0, False: 3.40k] ------------------ 31530| 3.40k| int res = memcmp(lhs, rhs, len); 31531| 3.40k| if (res) return res > 0 ? 1 : -1; ------------------ | Branch (31531:9): [True: 228, False: 3.17k] | Branch (31531:21): [True: 63, False: 165] ------------------ 31532| 3.17k| if (xlen == ylen) return 0; ------------------ | Branch (31532:9): [True: 3.17k, False: 0] ------------------ 31533| 0| return xlen < ylen ? -1 : 1; ------------------ | Branch (31533:12): [True: 0, False: 0] ------------------ 31534| 3.17k|} janet_string_equalconst: 31537| 23.1M|int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) { 31538| 23.1M| int32_t lhash = janet_string_hash(lhs); ------------------ | | 1804| 23.1M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1802| 23.1M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31539| 23.1M| int32_t llen = janet_string_length(lhs); ------------------ | | 1803| 23.1M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 23.1M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31540| 23.1M| if (lhash != rhash || llen != rlen) ------------------ | Branch (31540:9): [True: 9.45M, False: 13.7M] | Branch (31540:27): [True: 72, False: 13.7M] ------------------ 31541| 9.45M| return 0; 31542| 13.7M| if (lhs == rhs) ------------------ | Branch (31542:9): [True: 6.57M, False: 7.16M] ------------------ 31543| 6.57M| return 1; 31544| 7.16M| return !memcmp(lhs, rhs, rlen); 31545| 13.7M|} janet_string_equal: 31548| 1.44k|int janet_string_equal(const uint8_t *lhs, const uint8_t *rhs) { 31549| 1.44k| return janet_string_equalconst(lhs, rhs, 31550| 1.44k| janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1803| 1.44k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 1.44k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1804| 1.44k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1802| 1.44k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31551| 1.44k|} janet_cstring: 31554| 1.71k|const uint8_t *janet_cstring(const char *str) { 31555| 1.71k| return janet_string((const uint8_t *)str, (int32_t)strlen(str)); 31556| 1.71k|} janet_lib_string: 32104| 3.22k|void janet_lib_string(JanetTable *env) { 32105| 3.22k| JanetRegExt string_cfuns[] = { 32106| 3.22k| JANET_CORE_REG("string/slice", cfun_string_slice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32107| 3.22k| JANET_CORE_REG("keyword/slice", cfun_keyword_slice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32108| 3.22k| JANET_CORE_REG("symbol/slice", cfun_symbol_slice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32109| 3.22k| JANET_CORE_REG("string/repeat", cfun_string_repeat), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32110| 3.22k| JANET_CORE_REG("string/bytes", cfun_string_bytes), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32111| 3.22k| JANET_CORE_REG("string/from-bytes", cfun_string_frombytes), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32112| 3.22k| JANET_CORE_REG("string/ascii-lower", cfun_string_asciilower), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32113| 3.22k| JANET_CORE_REG("string/ascii-upper", cfun_string_asciiupper), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32114| 3.22k| JANET_CORE_REG("string/reverse", cfun_string_reverse), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32115| 3.22k| JANET_CORE_REG("string/find", cfun_string_find), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32116| 3.22k| JANET_CORE_REG("string/find-all", cfun_string_findall), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32117| 3.22k| JANET_CORE_REG("string/has-prefix?", cfun_string_hasprefix), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32118| 3.22k| JANET_CORE_REG("string/has-suffix?", cfun_string_hassuffix), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32119| 3.22k| JANET_CORE_REG("string/replace", cfun_string_replace), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32120| 3.22k| JANET_CORE_REG("string/replace-all", cfun_string_replaceall), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32121| 3.22k| JANET_CORE_REG("string/split", cfun_string_split), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32122| 3.22k| JANET_CORE_REG("string/check-set", cfun_string_checkset), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32123| 3.22k| JANET_CORE_REG("string/join", cfun_string_join), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32124| 3.22k| JANET_CORE_REG("string/format", cfun_string_format), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32125| 3.22k| JANET_CORE_REG("string/trim", cfun_string_trim), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32126| 3.22k| JANET_CORE_REG("string/triml", cfun_string_triml), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32127| 3.22k| JANET_CORE_REG("string/trimr", cfun_string_trimr), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32128| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 32129| 3.22k| }; 32130| | janet_core_cfuns_ext(env, NULL, string_cfuns); 32131| 3.22k|} janet_struct_begin: 32720| 441k|JanetKV *janet_struct_begin(int32_t count) { 32721| | /* Calculate capacity as power of 2 after 2 * count. */ 32722| 441k| int32_t capacity = janet_tablen(2 * count); 32723| 441k| if (capacity < 0) capacity = janet_tablen(count + 1); ------------------ | Branch (32723:9): [True: 0, False: 441k] ------------------ 32724| | 32725| 441k| size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV); 32726| 441k| JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size); 32727| 441k| head->length = count; 32728| 441k| head->capacity = capacity; 32729| 441k| head->hash = 0; 32730| 441k| head->proto = NULL; 32731| | 32732| 441k| JanetKV *st = (JanetKV *)(head->data); 32733| 441k| janet_memempty(st, capacity); 32734| 441k| return st; 32735| 441k|} janet_struct_put_ext: 32760| 1.30M|void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) { 32761| 1.30M| int32_t cap = janet_struct_capacity(st); ------------------ | | 1839| 1.30M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1836| 1.30M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32762| 1.30M| int32_t hash = janet_hash(key); 32763| 1.30M| int32_t index = janet_maphash(cap, hash); ------------------ | | 393| 1.30M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 32764| 1.30M| int32_t i, j, dist; 32765| 1.30M| int32_t bounds[4] = {index, cap, 0, index}; 32766| 1.30M| if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 801| 2.60M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 63.5k, False: 1.24M] | | | Branch (801:6): [Folded, False: 1.30M] | | ------------------ | | 802| 2.60M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 2.60M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 1.30M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 1.30M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 1.30M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 1.30M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 801| 1.24M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 28.8k, False: 1.21M] | | | Branch (801:6): [Folded, False: 1.24M] | | ------------------ | | 802| 1.24M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 1.24M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 1.24M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 1.24M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 1.24M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 1.24M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32767| 1.21M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 801| 2.42M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 806k, False: 405k] | | | Branch (801:6): [True: 1.21M, Folded] | | ------------------ | | 802| 2.42M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 1.21M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 805k, False: 406k] | | | | | Branch (798:28): [True: 639, False: 405k] | | | | ------------------ | | ------------------ | | 803| 2.42M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32767:47): [True: 639, False: 805k] ------------------ 32768| | /* Avoid extra items */ 32769| 1.21M| if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1840| 1.21M|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 1.21M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1838| 1.21M|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1836| 1.21M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (32769:9): [True: 0, False: 1.21M] ------------------ 32770| 1.23M| for (dist = 0, j = 0; j < 4; j += 2) ------------------ | Branch (32770:27): [True: 1.23M, False: 0] ------------------ 32771| 1.52M| for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) { ------------------ | Branch (32771:29): [True: 1.49M, False: 26.5k] ------------------ 32772| 1.49M| int status; 32773| 1.49M| int32_t otherhash; 32774| 1.49M| int32_t otherindex, otherdist; 32775| 1.49M| JanetKV *kv = st + i; 32776| | /* We found an empty slot, so just add key and value */ 32777| 1.49M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 801| 1.49M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 839k, False: 660k] | | | Branch (801:6): [Folded, False: 1.49M] | | ------------------ | | 802| 1.49M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 1.49M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 1.49M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 1.49M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 1.49M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 1.49M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32778| 839k| kv->key = key; 32779| 839k| kv->value = value; 32780| | /* Update the temporary count */ 32781| 839k| janet_struct_hash(st)++; ------------------ | | 1840| 839k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 839k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32782| 839k| return; 32783| 839k| } 32784| | /* Robinhood hashing - check if colliding kv pair 32785| | * is closer to their source than current. We use robinhood 32786| | * hashing to ensure that equivalent structs that are constructed 32787| | * with different order have the same internal layout, and therefor 32788| | * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}. 32789| | * Collisions are resolved via an insertion sort insertion. */ 32790| 660k| otherhash = janet_hash(kv->key); 32791| 660k| otherindex = janet_maphash(cap, otherhash); ------------------ | | 393| 660k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 32792| 660k| otherdist = (i + cap - otherindex) & (cap - 1); 32793| 660k| if (dist < otherdist) ------------------ | Branch (32793:17): [True: 86.0k, False: 574k] ------------------ 32794| 86.0k| status = -1; 32795| 574k| else if (otherdist < dist) ------------------ | Branch (32795:22): [True: 40.8k, False: 533k] ------------------ 32796| 40.8k| status = 1; 32797| 533k| else if (hash < otherhash) ------------------ | Branch (32797:22): [True: 82.3k, False: 451k] ------------------ 32798| 82.3k| status = -1; 32799| 451k| else if (otherhash < hash) ------------------ | Branch (32799:22): [True: 28.3k, False: 422k] ------------------ 32800| 28.3k| status = 1; 32801| 422k| else 32802| 422k| status = janet_compare(key, kv->key); 32803| | /* If other is closer to their ideal slot */ 32804| 660k| if (status == 1) { ------------------ | Branch (32804:17): [True: 84.4k, False: 575k] ------------------ 32805| | /* Swap current kv pair with pair in slot */ 32806| 84.4k| JanetKV temp = *kv; 32807| 84.4k| kv->key = key; 32808| 84.4k| kv->value = value; 32809| 84.4k| key = temp.key; 32810| 84.4k| value = temp.value; 32811| | /* Save dist and hash of new kv pair */ 32812| 84.4k| dist = otherdist; 32813| 84.4k| hash = otherhash; 32814| 575k| } else if (status == 0) { ------------------ | Branch (32814:24): [True: 371k, False: 203k] ------------------ 32815| 371k| if (replace) { ------------------ | Branch (32815:21): [True: 371k, False: 0] ------------------ 32816| | /* A key was added to the struct more than once - replace old value */ 32817| 371k| kv->value = value; 32818| 371k| } 32819| 371k| return; 32820| 371k| } 32821| 660k| } 32822| 1.21M|} janet_struct_put: 32824| 1.30M|void janet_struct_put(JanetKV *st, Janet key, Janet value) { 32825| 1.30M| janet_struct_put_ext(st, key, value, 1); 32826| 1.30M|} janet_struct_end: 32829| 328k|const JanetKV *janet_struct_end(JanetKV *st) { 32830| 328k| if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1840| 328k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1838| 328k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1836| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (32830:9): [True: 52.6k, False: 275k] ------------------ 32831| | /* Error building struct, probably duplicate values. We need to rebuild 32832| | * the struct using only the values that went in. The second creation should always 32833| | * succeed. */ 32834| 52.6k| JanetKV *newst = janet_struct_begin(janet_struct_hash(st)); ------------------ | | 1840| 52.6k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 52.6k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32835| 2.69M| for (int32_t i = 0; i < janet_struct_capacity(st); i++) { ------------------ | | 1839| 2.69M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1836| 2.69M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (32835:29): [True: 2.64M, False: 52.6k] ------------------ 32836| 2.64M| JanetKV *kv = st + i; 32837| 2.64M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 801| 2.64M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 2.64M] | | ------------------ | | 802| 2.64M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 2.64M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 2.64M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 2.64M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 2.64M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 2.64M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32837:17): [True: 303k, False: 2.34M] ------------------ 32838| 303k| janet_struct_put(newst, kv->key, kv->value); 32839| 303k| } 32840| 2.64M| } 32841| 52.6k| janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1841| 52.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1836| 52.6k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1841| 52.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1836| 52.6k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32842| 52.6k| st = newst; 32843| 52.6k| } 32844| 328k| janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1840| 328k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1839| 328k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1836| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32845| 328k| if (janet_struct_proto(st)) { ------------------ | | 1841| 328k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1836| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1841:31): [True: 18.9k, False: 309k] | | ------------------ ------------------ 32846| 18.9k| janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1840| 18.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 18.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1840| 18.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 18.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32847| 18.9k| } 32848| 328k| return (const JanetKV *)st; 32849| 328k|} janet_lib_struct: 32996| 3.22k|void janet_lib_struct(JanetTable *env) { 32997| 3.22k| JanetRegExt struct_cfuns[] = { 32998| 3.22k| JANET_CORE_REG("struct/with-proto", cfun_struct_with_proto), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32999| 3.22k| JANET_CORE_REG("struct/getproto", cfun_struct_getproto), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33000| 3.22k| JANET_CORE_REG("struct/proto-flatten", cfun_struct_flatten), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33001| 3.22k| JANET_CORE_REG("struct/to-table", cfun_struct_to_table), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33002| 3.22k| JANET_CORE_REG("struct/rawget", cfun_struct_rawget), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33003| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 33004| 3.22k| }; 33005| | janet_core_cfuns_ext(env, NULL, struct_cfuns); 33006| 3.22k|} janet_symcache_init: 33051| 3.22k|void janet_symcache_init() { 33052| 3.22k| janet_vm.cache_capacity = 1024; 33053| 3.22k| janet_vm.cache = janet_calloc(1, (size_t) janet_vm.cache_capacity * sizeof(const uint8_t *)); ------------------ | | 2399| 3.22k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 33054| 3.22k| if (NULL == janet_vm.cache) { ------------------ | Branch (33054:9): [True: 0, False: 3.22k] ------------------ 33055| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 33056| 0| } 33057| 3.22k| memset(&janet_vm.gensym_counter, '0', sizeof(janet_vm.gensym_counter)); 33058| 3.22k| janet_vm.gensym_counter[0] = '_'; 33059| 3.22k| janet_vm.cache_count = 0; 33060| 3.22k| janet_vm.cache_deleted = 0; 33061| 3.22k|} janet_symcache_deinit: 33064| 3.22k|void janet_symcache_deinit() { 33065| 3.22k| janet_free((void *)janet_vm.cache); ------------------ | | 2402| 3.22k|#define janet_free(X) free((X)) ------------------ 33066| | janet_vm.cache = NULL; 33067| 3.22k| janet_vm.cache_capacity = 0; 33068| 3.22k| janet_vm.cache_count = 0; 33069| 3.22k| janet_vm.cache_deleted = 0; 33070| 3.22k|} janet_symbol_deinit: 33172| 6.57M|void janet_symbol_deinit(const uint8_t *sym) { 33173| 6.57M| int status = 0; 33174| 6.57M| const uint8_t **bucket = janet_symcache_find(sym, &status); ------------------ | |33127| 6.57M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1803| 6.57M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1802| 6.57M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1804| 6.57M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1802| 6.57M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 33175| 6.57M| if (status) { ------------------ | Branch (33175:9): [True: 6.57M, False: 0] ------------------ 33176| 6.57M| janet_vm.cache_count--; 33177| 6.57M| janet_vm.cache_deleted++; 33178| 6.57M| *bucket = JANET_SYMCACHE_DELETED; 33179| 6.57M| } 33180| 6.57M|} janet_symbol: 33183| 11.5M|const uint8_t *janet_symbol(const uint8_t *str, int32_t len) { 33184| 11.5M| int32_t hash = janet_string_calchash(str, len); 33185| 11.5M| uint8_t *newstr; 33186| 11.5M| int success = 0; 33187| 11.5M| const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success); 33188| 11.5M| if (success) ------------------ | Branch (33188:9): [True: 5.01M, False: 6.57M] ------------------ 33189| 5.01M| return *bucket; 33190| 6.57M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1); 33191| 6.57M| head->hash = hash; 33192| 6.57M| head->length = len; 33193| 6.57M| newstr = (uint8_t *)(head->data); 33194| 6.57M| safe_memcpy(newstr, str, len); 33195| 6.57M| newstr[len] = 0; 33196| 6.57M| janet_symcache_put((const uint8_t *)newstr, bucket); 33197| 6.57M| return newstr; 33198| 11.5M|} janet_csymbol: 33201| 3.44M|const uint8_t *janet_csymbol(const char *cstr) { 33202| 3.44M| return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr)); 33203| 3.44M|} janet_table_init_raw: 33332| 9.68k|JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity) { 33333| 9.68k| return janet_table_init_impl(table, capacity, 0); 33334| 9.68k|} janet_table_deinit: 33337| 9.68k|void janet_table_deinit(JanetTable *table) { 33338| 9.68k| if (table->gc.flags & JANET_TABLE_FLAG_STACK) { ------------------ | |33287| 9.68k|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (33338:9): [True: 0, False: 9.68k] ------------------ 33339| 0| janet_sfree(table->data); 33340| 9.68k| } else { 33341| 9.68k| janet_free(table->data); ------------------ | | 2402| 9.68k|#define janet_free(X) free((X)) ------------------ 33342| 9.68k| } 33343| 9.68k|} janet_table: 33347| 2.36M|JanetTable *janet_table(int32_t capacity) { 33348| 2.36M| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); 33349| 2.36M| return janet_table_init_impl(table, capacity, 0); 33350| 2.36M|} janet_table_weakk: 33352| 21.1k|JanetTable *janet_table_weakk(int32_t capacity) { 33353| 21.1k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKK, sizeof(JanetTable)); 33354| 21.1k| return janet_table_init_impl(table, capacity, 0); 33355| 21.1k|} janet_table_weakv: 33357| 5.70k|JanetTable *janet_table_weakv(int32_t capacity) { 33358| 5.70k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKV, sizeof(JanetTable)); 33359| 5.70k| return janet_table_init_impl(table, capacity, 0); 33360| 5.70k|} janet_table_weakkv: 33362| 152k|JanetTable *janet_table_weakkv(int32_t capacity) { 33363| 152k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKKV, sizeof(JanetTable)); 33364| 152k| return janet_table_init_impl(table, capacity, 0); 33365| 152k|} janet_table_find: 33369| 52.0M|JanetKV *janet_table_find(JanetTable *t, Janet key) { 33370| 52.0M| return (JanetKV *) janet_dict_find(t->data, t->capacity, key); 33371| 52.0M|} janet_table_get: 33405| 3.51M|Janet janet_table_get(JanetTable *t, Janet key) { 33406| 3.60M| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 294| 3.51M|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (33406:41): [True: 3.51M, False: 94.7k] | Branch (33406:46): [True: 3.51M, False: 0] ------------------ 33407| 3.51M| JanetKV *bucket = janet_table_find(t, key); 33408| 3.51M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 801| 3.51M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 3.51M] | | ------------------ | | 802| 3.51M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 3.51M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 3.51M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 3.51M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 3.51M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.51M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33408:13): [True: 3.51M, False: 0] | Branch (33408:31): [True: 3.41M, False: 94.7k] ------------------ 33409| 3.41M| return bucket->value; 33410| 3.51M| } 33411| 94.7k| return janet_wrap_nil(); ------------------ | | 826| 94.7k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 94.7k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 94.7k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 94.7k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33412| 3.51M|} janet_table_get_keyword: 33415| 25.8k|Janet janet_table_get_keyword(JanetTable *t, const char *keyword) { 33416| 25.8k| int32_t keyword_len = (int32_t) strlen(keyword); 33417| 45.1k| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 294| 25.8k|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (33417:41): [True: 25.8k, False: 19.3k] | Branch (33417:46): [True: 25.8k, False: 0] ------------------ 33418| 25.8k| JanetKV *bucket = (JanetKV *) janet_dict_find_keyword(t->data, t->capacity, (const uint8_t *) keyword, keyword_len); 33419| 25.8k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 801| 25.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 25.8k] | | ------------------ | | 802| 25.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 25.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 25.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 25.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 25.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 25.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33419:13): [True: 25.8k, False: 0] | Branch (33419:31): [True: 6.45k, False: 19.3k] ------------------ 33420| 6.45k| return bucket->value; 33421| 25.8k| } 33422| 19.3k| return janet_wrap_nil(); ------------------ | | 826| 19.3k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 19.3k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 19.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 19.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33423| 25.8k|} janet_table_remove: 33448| 18.7k|Janet janet_table_remove(JanetTable *t, Janet key) { 33449| 18.7k| JanetKV *bucket = janet_table_find(t, key); 33450| 18.7k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 801| 18.7k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 18.7k] | | ------------------ | | 802| 18.7k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 18.7k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 18.7k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 18.7k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 18.7k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 18.7k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33450:9): [True: 18.7k, False: 0] | Branch (33450:27): [True: 12.8k, False: 5.88k] ------------------ 33451| 12.8k| Janet ret = bucket->value; 33452| 12.8k| t->count--; 33453| 12.8k| t->deleted++; 33454| 12.8k| bucket->key = janet_wrap_nil(); ------------------ | | 826| 12.8k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 12.8k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 12.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 12.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33455| 12.8k| bucket->value = janet_wrap_false(); ------------------ | | 828| 12.8k|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 817| 12.8k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 12.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 12.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33456| 12.8k| return ret; 33457| 12.8k| } else { 33458| 5.88k| return janet_wrap_nil(); ------------------ | | 826| 5.88k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 5.88k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 5.88k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 5.88k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33459| 5.88k| } 33460| 18.7k|} janet_table_put: 33463| 18.3M|void janet_table_put(JanetTable *t, Janet key, Janet value) { 33464| 18.3M| if (janet_checktype(key, JANET_NIL)) return; ------------------ | | 801| 18.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 11.2k, False: 18.3M] | | | Branch (801:6): [Folded, False: 18.3M] | | ------------------ | | 802| 18.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 18.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 18.3M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 18.3M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 18.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 18.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33465| 18.3M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 801| 36.6M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 705k, False: 17.6M] | | | Branch (801:6): [True: 18.3M, Folded] | | ------------------ | | 802| 36.6M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 18.3M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 704k, False: 17.6M] | | | | | Branch (798:28): [True: 285, False: 17.6M] | | | | ------------------ | | ------------------ | | 803| 36.6M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33465:47): [True: 285, False: 704k] ------------------ 33466| 18.3M| if (janet_checktype(value, JANET_NIL)) { ------------------ | | 801| 18.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 18.7k, False: 18.3M] | | | Branch (801:6): [Folded, False: 18.3M] | | ------------------ | | 802| 18.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 18.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 18.3M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 18.3M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 18.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 18.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33467| 18.7k| janet_table_remove(t, key); 33468| 18.3M| } else { 33469| 18.3M| JanetKV *bucket = janet_table_find(t, key); 33470| 18.3M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 801| 18.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 18.3M] | | ------------------ | | 802| 18.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 18.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 18.3M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 18.3M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 18.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 18.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33470:13): [True: 18.3M, False: 0] | Branch (33470:31): [True: 388k, False: 17.9M] ------------------ 33471| 388k| bucket->value = value; 33472| 17.9M| } else { 33473| 17.9M| if (NULL == bucket || 2 * (t->count + t->deleted + 1) > t->capacity) { ------------------ | Branch (33473:17): [True: 0, False: 17.9M] | Branch (33473:35): [True: 1.97M, False: 15.9M] ------------------ 33474| 1.97M| janet_table_rehash(t, janet_tablen(2 * t->count + 2)); 33475| 1.97M| } 33476| 17.9M| bucket = janet_table_find(t, key); 33477| 17.9M| if (janet_checktype(bucket->value, JANET_BOOLEAN)) ------------------ | | 801| 17.9M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 17.9M] | | | Branch (801:6): [Folded, False: 17.9M] | | ------------------ | | 802| 17.9M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 17.9M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 17.9M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 17.9M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 17.9M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 17.9M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33478| 0| --t->deleted; 33479| 17.9M| bucket->key = key; 33480| 17.9M| bucket->value = value; 33481| 17.9M| ++t->count; 33482| 17.9M| } 33483| 18.3M| } 33484| 18.3M|} janet_lib_table: 33689| 3.22k|void janet_lib_table(JanetTable *env) { 33690| 3.22k| JanetRegExt table_cfuns[] = { 33691| 3.22k| JANET_CORE_REG("table/new", cfun_table_new), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33692| 3.22k| JANET_CORE_REG("table/weak", cfun_table_weak), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33693| 3.22k| JANET_CORE_REG("table/weak-keys", cfun_table_weak_keys), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33694| 3.22k| JANET_CORE_REG("table/weak-values", cfun_table_weak_values), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33695| 3.22k| JANET_CORE_REG("table/to-struct", cfun_table_tostruct), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33696| 3.22k| JANET_CORE_REG("table/getproto", cfun_table_getproto), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33697| 3.22k| JANET_CORE_REG("table/setproto", cfun_table_setproto), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33698| 3.22k| JANET_CORE_REG("table/rawget", cfun_table_rawget), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33699| 3.22k| JANET_CORE_REG("table/clone", cfun_table_clone), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33700| 3.22k| JANET_CORE_REG("table/clear", cfun_table_clear), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33701| 3.22k| JANET_CORE_REG("table/proto-flatten", cfun_table_proto_flatten), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33702| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 33703| 3.22k| }; 33704| | janet_core_cfuns_ext(env, NULL, table_cfuns); 33705| 3.22k|} janet_tuple_begin: 33744| 2.52M|Janet *janet_tuple_begin(int32_t length) { 33745| 2.52M| size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet)); 33746| 2.52M| JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size); 33747| 2.52M| head->sm_line = -1; 33748| 2.52M| head->sm_column = -1; 33749| 2.52M| head->length = length; 33750| 2.52M| return (Janet *)(head->data); 33751| 2.52M|} janet_tuple_end: 33754| 2.52M|const Janet *janet_tuple_end(Janet *tuple) { 33755| 2.52M| janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1793| 2.52M|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1790| 2.52M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1792| 2.52M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1790| 2.52M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 33756| 2.52M| return (const Janet *)tuple; 33757| 2.52M|} janet_lib_tuple: 33858| 3.22k|void janet_lib_tuple(JanetTable *env) { 33859| 3.22k| JanetRegExt tuple_cfuns[] = { 33860| 3.22k| JANET_CORE_REG("tuple/brackets", cfun_tuple_brackets), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33861| 3.22k| JANET_CORE_REG("tuple/slice", cfun_tuple_slice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33862| 3.22k| JANET_CORE_REG("tuple/type", cfun_tuple_type), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33863| 3.22k| JANET_CORE_REG("tuple/sourcemap", cfun_tuple_sourcemap), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33864| 3.22k| JANET_CORE_REG("tuple/setmap", cfun_tuple_setmap), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33865| 3.22k| JANET_CORE_REG("tuple/join", cfun_tuple_join), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33866| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 33867| 3.22k| }; 33868| | janet_core_cfuns_ext(env, NULL, tuple_cfuns); 33869| 3.22k|} janet_hash_mix: 33994| 26.6M|uint32_t janet_hash_mix(uint32_t input, uint32_t more) { 33995| 26.6M| uint32_t mix1 = (more + 0x9e3779b9 + (input << 6) + (input >> 2)); 33996| 26.6M| return input ^ (0x9e3779b9 + (mix1 << 6) + (mix1 >> 2)); 33997| 26.6M|} janet_string_calchash: 34001| 16.3M|int32_t janet_string_calchash(const uint8_t *str, int32_t len) { 34002| 16.3M| if (NULL == str || len == 0) return 5381; ------------------ | Branch (34002:9): [True: 0, False: 16.3M] | Branch (34002:24): [True: 75.1k, False: 16.2M] ------------------ 34003| 16.2M| const uint8_t *end = str + len; 34004| 16.2M| uint32_t hash = 5381; 34005| 558M| while (str < end) ------------------ | Branch (34005:12): [True: 542M, False: 16.2M] ------------------ 34006| 542M| hash = (hash << 5) + hash + *str++; 34007| 16.2M| hash = janet_hash_mix(hash, (uint32_t) len); 34008| 16.2M| return (int32_t) hash; 34009| 16.3M|} janet_array_calchash: 34124| 2.52M|int32_t janet_array_calchash(const Janet *array, int32_t len) { 34125| 2.52M| const Janet *end = array + len; 34126| 2.52M| uint32_t hash = 33; 34127| 9.76M| while (array < end) { ------------------ | Branch (34127:12): [True: 7.24M, False: 2.52M] ------------------ 34128| 7.24M| hash = janet_hash_mix(hash, janet_hash(*array++)); 34129| 7.24M| } 34130| 2.52M| return (int32_t) hash; 34131| 2.52M|} janet_kv_calchash: 34134| 328k|int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) { 34135| 328k| const JanetKV *end = kvs + len; 34136| 328k| uint32_t hash = 33; 34137| 1.90M| while (kvs < end) { ------------------ | Branch (34137:12): [True: 1.57M, False: 328k] ------------------ 34138| 1.57M| hash = janet_hash_mix(hash, janet_hash(kvs->key)); 34139| 1.57M| hash = janet_hash_mix(hash, janet_hash(kvs->value)); 34140| 1.57M| kvs++; 34141| 1.57M| } 34142| 328k| return (int32_t) hash; 34143| 328k|} janet_tablen: 34147| 4.97M|int32_t janet_tablen(int32_t n) { 34148| 4.97M| if (n < 0) return 0; ------------------ | Branch (34148:9): [True: 0, False: 4.97M] ------------------ 34149| 4.97M| n |= n >> 1; 34150| 4.97M| n |= n >> 2; 34151| 4.97M| n |= n >> 4; 34152| 4.97M| n |= n >> 8; 34153| 4.97M| n |= n >> 16; 34154| 4.97M| return n == INT32_MAX ? INT32_MAX : n + 1; ------------------ | Branch (34154:12): [True: 0, False: 4.97M] ------------------ 34155| 4.97M|} safe_memcpy: 34158| 11.3M|void safe_memcpy(void *dest, const void *src, size_t len) { 34159| 11.3M| if (!len) return; ------------------ | Branch (34159:9): [True: 14.3k, False: 11.3M] ------------------ 34160| 11.3M| memcpy(dest, src, len); 34161| 11.3M|} janet_dict_find: 34165| 52.0M|const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) { 34166| 52.0M| int32_t index = janet_maphash(cap, janet_hash(key)); ------------------ | | 393| 52.0M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34167| 52.0M| int32_t i; 34168| 52.0M| const JanetKV *first_bucket = NULL; 34169| | /* Higher half */ 34170| 69.1M| for (i = index; i < cap; i++) { ------------------ | Branch (34170:21): [True: 69.0M, False: 34.8k] ------------------ 34171| 69.0M| const JanetKV *kv = buckets + i; 34172| 69.0M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 801| 69.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 48.4M, False: 20.6M] | | | Branch (801:6): [Folded, False: 69.0M] | | ------------------ | | 802| 69.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 69.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 69.0M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 69.0M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 69.0M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 69.0M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34173| 48.4M| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 801| 48.4M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 48.2M, False: 252k] | | | Branch (801:6): [Folded, False: 48.4M] | | ------------------ | | 802| 48.4M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 48.4M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 48.4M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 48.4M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 48.4M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 48.4M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34174| 48.2M| return kv; 34175| 48.2M| } else if (NULL == first_bucket) { ------------------ | Branch (34175:24): [True: 90.2k, False: 162k] ------------------ 34176| 90.2k| first_bucket = kv; 34177| 90.2k| } 34178| 48.4M| } else if (janet_equals(kv->key, key)) { ------------------ | Branch (34178:20): [True: 3.81M, False: 16.7M] ------------------ 34179| 3.81M| return buckets + i; 34180| 3.81M| } 34181| 69.0M| } 34182| | /* Lower half */ 34183| 77.3k| for (i = 0; i < index; i++) { ------------------ | Branch (34183:17): [True: 77.3k, False: 0] ------------------ 34184| 77.3k| const JanetKV *kv = buckets + i; 34185| 77.3k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 801| 77.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 42.8k, False: 34.5k] | | | Branch (801:6): [Folded, False: 77.3k] | | ------------------ | | 802| 77.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 77.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 77.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 77.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 77.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 77.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34186| 42.8k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 801| 42.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 31.7k, False: 11.0k] | | | Branch (801:6): [Folded, False: 42.8k] | | ------------------ | | 802| 42.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 42.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 42.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 42.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 42.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 42.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34187| 31.7k| return kv; 34188| 31.7k| } else if (NULL == first_bucket) { ------------------ | Branch (34188:24): [True: 5.52k, False: 5.55k] ------------------ 34189| 5.52k| first_bucket = kv; 34190| 5.52k| } 34191| 42.8k| } else if (janet_equals(kv->key, key)) { ------------------ | Branch (34191:20): [True: 3.09k, False: 31.4k] ------------------ 34192| 3.09k| return buckets + i; 34193| 3.09k| } 34194| 77.3k| } 34195| 0| return first_bucket; 34196| 34.8k|} janet_dict_find_keyword: 34202| 25.8k| const uint8_t *cstr, int32_t cstr_len) { 34203| 25.8k| int32_t hash = janet_string_calchash(cstr, cstr_len); 34204| 25.8k| int32_t index = janet_maphash(cap, hash); ------------------ | | 393| 25.8k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34205| 25.8k| int32_t i; 34206| 25.8k| const JanetKV *first_bucket = NULL; 34207| | /* Higher half */ 34208| 38.7k| for (i = index; i < cap; i++) { ------------------ | Branch (34208:21): [True: 38.7k, False: 0] ------------------ 34209| 38.7k| const JanetKV *kv = buckets + i; 34210| 38.7k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 801| 38.7k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 19.3k, False: 19.3k] | | | Branch (801:6): [Folded, False: 38.7k] | | ------------------ | | 802| 38.7k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 38.7k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 38.7k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 38.7k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 38.7k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 38.7k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34211| 19.3k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 801| 19.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 19.3k, False: 0] | | | Branch (801:6): [Folded, False: 19.3k] | | ------------------ | | 802| 19.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 19.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 19.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 19.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 19.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 19.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34212| 19.3k| return kv; 34213| 19.3k| } else if (NULL == first_bucket) { ------------------ | Branch (34213:24): [True: 0, False: 0] ------------------ 34214| 0| first_bucket = kv; 34215| 0| } 34216| 19.3k| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 801| 19.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 19.3k, False: 0] | | | Branch (801:6): [Folded, False: 19.3k] | | ------------------ | | 802| 19.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 19.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 19.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 19.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 19.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 19.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34217| | /* Works for symbol and keyword, too */ 34218| 19.3k| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 858| 19.3k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 34219| 19.3k| int32_t len = janet_string_length(str); ------------------ | | 1803| 19.3k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 19.3k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 34220| 19.3k| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1804| 38.7k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1802| 19.3k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (34220:17): [True: 6.45k, False: 12.9k] | Branch (34220:51): [True: 6.45k, False: 0] | Branch (34220:70): [True: 6.45k, False: 0] ------------------ 34221| 6.45k| return buckets + i; 34222| 6.45k| } 34223| 19.3k| } 34224| 38.7k| } 34225| | /* Lower half */ 34226| 0| for (i = 0; i < index; i++) { ------------------ | Branch (34226:17): [True: 0, False: 0] ------------------ 34227| 0| const JanetKV *kv = buckets + i; 34228| 0| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 801| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 0] | | | Branch (801:6): [Folded, False: 0] | | ------------------ | | 802| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34229| 0| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 801| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 0] | | | Branch (801:6): [Folded, False: 0] | | ------------------ | | 802| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34230| 0| return kv; 34231| 0| } else if (NULL == first_bucket) { ------------------ | Branch (34231:24): [True: 0, False: 0] ------------------ 34232| 0| first_bucket = kv; 34233| 0| } 34234| 0| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 801| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 0] | | | Branch (801:6): [Folded, False: 0] | | ------------------ | | 802| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34235| | /* Works for symbol and keyword, too */ 34236| 0| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 858| 0|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 34237| 0| int32_t len = janet_string_length(str); ------------------ | | 1803| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 34238| 0| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1804| 0|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1802| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (34238:17): [True: 0, False: 0] | Branch (34238:51): [True: 0, False: 0] | Branch (34238:70): [True: 0, False: 0] ------------------ 34239| 0| return buckets + i; 34240| 0| } 34241| 0| } 34242| 0| } 34243| 0| return first_bucket; 34244| 0|} janet_registry_put: 34369| 1.13M| int32_t source_line) { 34370| 1.13M| if (janet_vm.registry_count == janet_vm.registry_cap) { ------------------ | Branch (34370:9): [True: 3.22k, False: 1.13M] ------------------ 34371| 3.22k| size_t newcap = (janet_vm.registry_count + 1) * 2; 34372| | /* Size it nicely with core by default */ 34373| 3.22k| if (newcap < 512) { ------------------ | Branch (34373:13): [True: 3.22k, False: 0] ------------------ 34374| 3.22k| newcap = 512; 34375| 3.22k| } 34376| 3.22k| void *newmem = janet_realloc(janet_vm.registry, newcap * sizeof(JanetCFunRegistry)); ------------------ | | 2396| 3.22k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 34377| 3.22k| if (NULL == newmem) { ------------------ | Branch (34377:13): [True: 0, False: 3.22k] ------------------ 34378| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 34379| 0| } 34380| 3.22k| janet_vm.registry = newmem; 34381| 3.22k| janet_vm.registry_cap = newcap; 34382| 3.22k| } 34383| 1.13M| JanetCFunRegistry value = { 34384| 1.13M| key, 34385| 1.13M| name, 34386| 1.13M| name_prefix, 34387| 1.13M| source_file, 34388| 1.13M| source_line 34389| 1.13M| }; 34390| 1.13M| janet_vm.registry[janet_vm.registry_count++] = value; 34391| 1.13M| janet_vm.registry_dirty = 1; 34392| 1.13M|} janet_registry_get: 34394| 2|JanetCFunRegistry *janet_registry_get(JanetCFunction key) { 34395| 2| if (janet_vm.registry_dirty) { ------------------ | Branch (34395:9): [True: 2, False: 0] ------------------ 34396| 2| janet_registry_sort(); 34397| 2| } 34398| 407| for (size_t i = 0; i < janet_vm.registry_count; i++) { ------------------ | Branch (34398:24): [True: 407, False: 0] ------------------ 34399| 407| if (janet_vm.registry[i].cfun == key) { ------------------ | Branch (34399:13): [True: 2, False: 405] ------------------ 34400| 2| return janet_vm.registry + i; 34401| 2| } 34402| 407| } 34403| 0| JanetCFunRegistry *lo = janet_vm.registry; 34404| 0| JanetCFunRegistry *hi = lo + janet_vm.registry_count; 34405| 0| while (lo < hi) { ------------------ | Branch (34405:12): [True: 0, False: 0] ------------------ 34406| 0| JanetCFunRegistry *mid = lo + (hi - lo) / 2; 34407| 0| if (mid->cfun == key) { ------------------ | Branch (34407:13): [True: 0, False: 0] ------------------ 34408| 0| return mid; 34409| 0| } 34410| 0| if ((void *)(mid->cfun) > (void *)(key)) { ------------------ | Branch (34410:13): [True: 0, False: 0] ------------------ 34411| 0| hi = mid; 34412| 0| } else { 34413| 0| lo = mid + 1; 34414| 0| } 34415| 0| } 34416| 0| return NULL; 34417| 0|} janet_register_abstract_type: 34518| 29.0k|void janet_register_abstract_type(const JanetAbstractType *at) { 34519| 29.0k| janet_check_pointer_align((void *) at); 34520| 29.0k| Janet sym = janet_csymbolv(at->name); ------------------ | | 1827| 29.0k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 844| 29.0k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 823| 29.0k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 29.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 29.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34521| 29.0k| Janet check = janet_table_get(janet_vm.abstract_registry, sym); 34522| 29.0k| if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 801| 58.0k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 29.0k] | | ------------------ | | 802| 58.0k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 58.0k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 29.0k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 29.0k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 29.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 29.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 862| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (34522:9): [True: 0, False: 29.0k] | Branch (34522:47): [True: 0, False: 0] ------------------ 34523| 0| janet_panicf("cannot register abstract type %s, " 34524| 0| "a type with the same name exists", at->name); 34525| 0| } 34526| 29.0k| janet_table_put(janet_vm.abstract_registry, sym, janet_wrap_pointer((void *) at)); ------------------ | | 849| 29.0k|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 820| 29.0k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 29.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 29.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34527| 29.0k|} janet_get_abstract_type: 34529| 15|const JanetAbstractType *janet_get_abstract_type(Janet key) { 34530| 15| Janet wrapped = janet_table_get(janet_vm.abstract_registry, key); 34531| 15| if (janet_checktype(wrapped, JANET_NIL)) { ------------------ | | 801| 15| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 15, False: 0] | | | Branch (801:6): [Folded, False: 15] | | ------------------ | | 802| 15| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 15| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 15| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 15|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 15|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 15|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34532| 15| return NULL; 34533| 15| } 34534| 0| return (JanetAbstractType *)(janet_unwrap_pointer(wrapped)); ------------------ | | 862| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ 34535| 15|} janet_core_def_sm: 34538| 9.68k|void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl) { 34539| 9.68k| (void) sf; 34540| 9.68k| (void) sl; 34541| 9.68k| (void) p; 34542| 9.68k| Janet key = janet_csymbolv(name); ------------------ | | 1827| 9.68k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 844| 9.68k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 823| 9.68k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 9.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 9.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34543| 9.68k| janet_table_put(env, key, x); 34544| 9.68k| if (janet_checktype(x, JANET_CFUNCTION)) { ------------------ | | 801| 9.68k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 9.68k] | | | Branch (801:6): [Folded, False: 9.68k] | | ------------------ | | 802| 9.68k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 9.68k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 9.68k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 9.68k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 9.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 9.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34545| 0| janet_registry_put(janet_unwrap_cfunction(x), name, NULL, NULL, 0); ------------------ | | 864| 0|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 34546| 0| } 34547| 9.68k|} janet_core_cfuns_ext: 34549| 70.9k|void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) { 34550| 70.9k| (void) regprefix; 34551| 1.20M| while (cfuns->name) { ------------------ | Branch (34551:12): [True: 1.13M, False: 70.9k] ------------------ 34552| 1.13M| janet_check_pointer_align(cfuns->cfun); 34553| 1.13M| Janet fun = janet_wrap_cfunction(cfuns->cfun); ------------------ | | 848| 1.13M|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 820| 1.13M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 1.13M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 1.13M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34554| 1.13M| janet_table_put(env, janet_csymbolv(cfuns->name), fun); ------------------ | | 1827| 1.13M|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 844| 1.13M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 823| 1.13M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 1.13M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 1.13M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34555| 1.13M| janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line); 34556| 1.13M| cfuns++; 34557| 1.13M| } 34558| 70.9k|} janet_binding_from_entry: 34561| 6.45k|JanetBinding janet_binding_from_entry(Janet entry) { 34562| 6.45k| JanetTable *entry_table; 34563| 6.45k| JanetBinding binding = { 34564| 6.45k| JANET_BINDING_NONE, 34565| 6.45k| janet_wrap_nil(), ------------------ | | 826| 6.45k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 6.45k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34566| 6.45k| JANET_BINDING_DEP_NONE 34567| 6.45k| }; 34568| | 34569| | /* Check environment for entry */ 34570| 6.45k| if (!janet_checktype(entry, JANET_TABLE)) ------------------ | | 801| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 6.45k] | | ------------------ | | 802| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34570:9): [True: 0, False: 6.45k] ------------------ 34571| 0| return binding; 34572| 6.45k| entry_table = janet_unwrap_table(entry); ------------------ | | 856| 6.45k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 34573| | 34574| 6.45k| Janet deprecate = janet_table_get_keyword(entry_table, "deprecated"); 34575| 6.45k| int macro = janet_truthy(janet_table_get_keyword(entry_table, "macro")); ------------------ | | 813| 6.45k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 801| 12.9k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (801:6): [Folded, False: 6.45k] | | | | ------------------ | | | | 802| 12.9k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (798:6): [True: 0, False: 0] | | | | | | | Branch (798:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 803| 12.9k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 795| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 785| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 788| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (813:6): [True: 0, False: 6.45k] | | ------------------ | | 814| 6.45k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 801| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (801:6): [Folded, False: 0] | | | | ------------------ | | | | 802| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (798:6): [True: 0, False: 0] | | | | | | | Branch (798:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (814:7): [True: 0, False: 0] | | | Branch (814:47): [True: 0, False: 0] | | ------------------ ------------------ 34576| 6.45k| Janet value = janet_table_get_keyword(entry_table, "value"); 34577| 6.45k| Janet ref = janet_table_get_keyword(entry_table, "ref"); 34578| | 34579| 6.45k| if (janet_checktype(deprecate, JANET_KEYWORD)) { ------------------ | | 801| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 6.45k] | | | Branch (801:6): [Folded, False: 6.45k] | | ------------------ | | 802| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34580| 0| JanetKeyword depkw = janet_unwrap_keyword(deprecate); ------------------ | | 860| 0|#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) ------------------ 34581| 0| if (!janet_cstrcmp(depkw, "relaxed")) { ------------------ | Branch (34581:13): [True: 0, False: 0] ------------------ 34582| 0| binding.deprecation = JANET_BINDING_DEP_RELAXED; 34583| 0| } else if (!janet_cstrcmp(depkw, "normal")) { ------------------ | Branch (34583:20): [True: 0, False: 0] ------------------ 34584| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 34585| 0| } else if (!janet_cstrcmp(depkw, "strict")) { ------------------ | Branch (34585:20): [True: 0, False: 0] ------------------ 34586| 0| binding.deprecation = JANET_BINDING_DEP_STRICT; 34587| 0| } 34588| 6.45k| } else if (!janet_checktype(deprecate, JANET_NIL)) { ------------------ | | 801| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 6.45k] | | ------------------ | | 802| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34588:16): [True: 0, False: 6.45k] ------------------ 34589| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 34590| 0| } 34591| | 34592| 6.45k| int ref_is_valid = janet_checktype(ref, JANET_ARRAY); ------------------ | | 801| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 6.45k] | | ------------------ | | 802| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34593| 6.45k| int redef = ref_is_valid && janet_truthy(janet_table_get_keyword(entry_table, "redef")); ------------------ | | 813| 6.45k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 801| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (801:6): [Folded, False: 0] | | | | ------------------ | | | | 802| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (798:6): [True: 0, False: 0] | | | | | | | Branch (798:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (813:6): [True: 0, False: 0] | | ------------------ | | 814| 6.45k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 801| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (801:6): [Folded, False: 0] | | | | ------------------ | | | | 802| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (798:6): [True: 0, False: 0] | | | | | | | Branch (798:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (814:7): [True: 0, False: 0] | | | Branch (814:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (34593:17): [True: 0, False: 6.45k] ------------------ 34594| | 34595| 6.45k| if (macro) { ------------------ | Branch (34595:9): [True: 0, False: 6.45k] ------------------ 34596| 0| binding.value = redef ? ref : value; ------------------ | Branch (34596:25): [True: 0, False: 0] ------------------ 34597| 0| binding.type = redef ? JANET_BINDING_DYNAMIC_MACRO : JANET_BINDING_MACRO; ------------------ | Branch (34597:24): [True: 0, False: 0] ------------------ 34598| 0| return binding; 34599| 0| } 34600| | 34601| 6.45k| if (ref_is_valid) { ------------------ | Branch (34601:9): [True: 0, False: 6.45k] ------------------ 34602| 0| binding.value = ref; 34603| 0| binding.type = redef ? JANET_BINDING_DYNAMIC_DEF : JANET_BINDING_VAR; ------------------ | Branch (34603:24): [True: 0, False: 0] ------------------ 34604| 6.45k| } else { 34605| 6.45k| binding.value = value; 34606| 6.45k| binding.type = JANET_BINDING_DEF; 34607| 6.45k| } 34608| | 34609| 6.45k| return binding; 34610| 6.45k|} janet_resolve_ext: 34665| 6.45k|JanetBinding janet_resolve_ext(JanetTable *env, const uint8_t *sym) { 34666| 6.45k| Janet entry = janet_table_get(env, janet_wrap_symbol(sym)); ------------------ | | 844| 6.45k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 823| 6.45k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34667| 6.45k| return janet_binding_from_entry(entry); 34668| 6.45k|} janet_resolve: 34670| 6.45k|JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out) { 34671| 6.45k| JanetBinding binding = janet_resolve_ext(env, sym); 34672| 6.45k| if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) { ------------------ | Branch (34672:9): [True: 0, False: 6.45k] | Branch (34672:54): [True: 0, False: 6.45k] ------------------ 34673| 0| *out = janet_array_peek(janet_unwrap_array(binding.value)); ------------------ | | 855| 0|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 34674| 6.45k| } else { 34675| 6.45k| *out = binding.value; 34676| 6.45k| } 34677| 6.45k| return binding.type; 34678| 6.45k|} janet_equals: 35328| 20.6M|int janet_equals(Janet x, Janet y) { 35329| 20.6M| janet_vm.traversal = janet_vm.traversal_base; 35330| 20.6M| do { 35331| 20.6M| if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 790| 20.6M| (isnan((x).number) \ | | 791| 20.6M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 20.6M| : JANET_NUMBER) ------------------ if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 790| 20.6M| (isnan((x).number) \ | | 791| 20.6M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 20.6M| : JANET_NUMBER) ------------------ | Branch (35331:13): [True: 20.1M, False: 565k] | Branch (35331:13): [True: 2.07M, False: 18.6M] | Branch (35331:30): [True: 20.0M, False: 656k] ------------------ 35332| 18.6M| switch (janet_type(x)) { ------------------ | | 790| 18.6M| (isnan((x).number) \ | | 791| 18.6M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 18.6M| : JANET_NUMBER) ------------------ | Branch (35332:17): [True: 18.1M, False: 510k] ------------------ 35333| 39.6k| case JANET_NIL: ------------------ | Branch (35333:13): [True: 39.6k, False: 18.5M] ------------------ 35334| 39.6k| break; 35335| 22.5k| case JANET_BOOLEAN: ------------------ | Branch (35335:13): [True: 22.5k, False: 18.6M] ------------------ 35336| 22.5k| if (janet_unwrap_boolean(x) != janet_unwrap_boolean(y)) return 0; ------------------ | | 833| 22.5k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ if (janet_unwrap_boolean(x) != janet_unwrap_boolean(y)) return 0; ------------------ | | 833| 22.5k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ | Branch (35336:21): [True: 2.52k, False: 19.9k] ------------------ 35337| 19.9k| break; 35338| 510k| case JANET_NUMBER: ------------------ | Branch (35338:13): [True: 510k, False: 18.1M] ------------------ 35339| 510k| if (janet_unwrap_number(x) != janet_unwrap_number(y)) return 0; ------------------ | | 834| 510k|#define janet_unwrap_number(x) ((x).number) ------------------ if (janet_unwrap_number(x) != janet_unwrap_number(y)) return 0; ------------------ | | 834| 510k|#define janet_unwrap_number(x) ((x).number) ------------------ | Branch (35339:21): [True: 136k, False: 373k] ------------------ 35340| 373k| break; 35341| 373k| case JANET_STRING: ------------------ | Branch (35341:13): [True: 1.44k, False: 18.6M] ------------------ 35342| 1.44k| if (!janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y))) return 0; ------------------ | | 858| 1.44k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ if (!janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y))) return 0; ------------------ | | 858| 1.44k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ | Branch (35342:21): [True: 110, False: 1.33k] ------------------ 35343| 1.33k| break; 35344| 1.33k| case JANET_ABSTRACT: ------------------ | Branch (35344:13): [True: 46, False: 18.6M] ------------------ 35345| 46| if (janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y))) return 0; ------------------ | | 861| 46|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y))) return 0; ------------------ | | 861| 46|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (35345:21): [True: 46, False: 0] ------------------ 35346| 0| break; 35347| 18.0M| default: ------------------ | Branch (35347:13): [True: 18.0M, False: 594k] ------------------ 35348| 18.0M| if (janet_unwrap_pointer(x) != janet_unwrap_pointer(y)) return 0; ------------------ | | 862| 18.0M|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_unwrap_pointer(x) != janet_unwrap_pointer(y)) return 0; ------------------ | | 862| 18.0M|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (35348:21): [True: 14.6M, False: 3.41M] ------------------ 35349| 3.41M| break; 35350| 3.41M| case JANET_TUPLE: { ------------------ | Branch (35350:13): [True: 7.66k, False: 18.6M] ------------------ 35351| 7.66k| const Janet *t1 = janet_unwrap_tuple(x); ------------------ | | 853| 7.66k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 35352| 7.66k| const Janet *t2 = janet_unwrap_tuple(y); ------------------ | | 853| 7.66k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 35353| 7.66k| if (t1 == t2) break; ------------------ | Branch (35353:21): [True: 524, False: 7.14k] ------------------ 35354| 7.14k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1788| 7.14k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1796| 7.14k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1790| 7.14k|#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; ------------------ | | 1796| 7.14k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1790| 7.14k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (35354:21): [True: 1.21k, False: 5.92k] ------------------ 35355| 5.92k| if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1793| 5.92k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1790| 5.92k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1793| 5.92k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1790| 5.92k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (35355:21): [True: 1.53k, False: 4.38k] ------------------ 35356| 4.38k| if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1792| 4.38k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1790| 4.38k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1792| 4.38k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1790| 4.38k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (35356:21): [True: 0, False: 4.38k] ------------------ 35357| 4.38k| push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1790| 4.38k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1790| 4.38k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 35358| 4.38k| break; 35359| 4.38k| } 35360| 0| break; 35361| 12.5k| case JANET_STRUCT: { ------------------ | Branch (35361:13): [True: 12.5k, False: 18.6M] ------------------ 35362| 12.5k| const JanetKV *s1 = janet_unwrap_struct(x); ------------------ | | 852| 12.5k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 35363| 12.5k| const JanetKV *s2 = janet_unwrap_struct(y); ------------------ | | 852| 12.5k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 35364| 12.5k| if (s1 == s2) break; ------------------ | Branch (35364:21): [True: 608, False: 11.9k] ------------------ 35365| 11.9k| if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1840| 11.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 11.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1840| 11.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 11.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (35365:21): [True: 959, False: 11.0k] ------------------ 35366| 11.0k| if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1838| 11.0k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1836| 11.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1838| 11.0k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1836| 11.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (35366:21): [True: 210, False: 10.8k] ------------------ 35367| 10.8k| if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1841| 21.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1836| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1841:31): [True: 1.92k, False: 8.88k] | | ------------------ ------------------ if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1841| 1.92k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1836| 1.92k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (35367:47): [True: 0, False: 1.92k] ------------------ 35368| 10.8k| if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1841| 21.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1836| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1841| 8.88k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1836| 8.88k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1841:31): [True: 0, False: 8.88k] | | ------------------ ------------------ | Branch (35368:21): [True: 8.88k, False: 1.92k] ------------------ 35369| 10.8k| push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1836| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1836| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 35370| 10.8k| break; 35371| 10.8k| } 35372| 0| break; 35373| 18.6M| } 35374| 18.6M| } while (!traversal_next(&x, &y)); ------------------ | Branch (35374:14): [True: 52.0k, False: 3.81M] ------------------ 35375| 3.81M| return 1; 35376| 20.6M|} janet_hash: 35388| 64.4M|int32_t janet_hash(Janet x) { 35389| 64.4M| int32_t hash = 0; 35390| 64.4M| switch (janet_type(x)) { ------------------ | | 790| 64.4M| (isnan((x).number) \ | | 791| 64.4M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 64.4M| : JANET_NUMBER) ------------------ | Branch (35390:13): [True: 57.0M, False: 7.38M] ------------------ 35391| 2.30M| case JANET_NIL: ------------------ | Branch (35391:9): [True: 2.30M, False: 62.1M] ------------------ 35392| 2.30M| hash = 0; 35393| 2.30M| break; 35394| 285k| case JANET_BOOLEAN: ------------------ | Branch (35394:9): [True: 285k, False: 64.1M] ------------------ 35395| 285k| hash = janet_unwrap_boolean(x); ------------------ | | 833| 285k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 35396| 285k| break; 35397| 2.65M| case JANET_STRING: ------------------ | Branch (35397:9): [True: 2.65M, False: 61.7M] ------------------ 35398| 24.8M| case JANET_SYMBOL: ------------------ | Branch (35398:9): [True: 22.2M, False: 42.1M] ------------------ 35399| 46.1M| case JANET_KEYWORD: ------------------ | Branch (35399:9): [True: 21.2M, False: 43.1M] ------------------ 35400| 46.1M| hash = janet_string_hash(janet_unwrap_string(x)); ------------------ | | 1804| 46.1M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1802| 46.1M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 35401| 46.1M| break; 35402| 92.4k| case JANET_TUPLE: ------------------ | Branch (35402:9): [True: 92.4k, False: 64.3M] ------------------ 35403| 92.4k| hash = janet_tuple_hash(janet_unwrap_tuple(x)); ------------------ | | 1793| 92.4k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1790| 92.4k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 35404| 92.4k| uint32_t inc = (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0; ------------------ | | 1796| 92.4k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1790| 92.4k|#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; ------------------ | | 1788| 92.4k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (35404:28): [True: 62.5k, False: 29.9k] ------------------ 35405| 92.4k| hash = (int32_t)((uint32_t)hash + inc); /* avoid overflow undefined behavior */ 35406| 92.4k| break; 35407| 343k| case JANET_STRUCT: ------------------ | Branch (35407:9): [True: 343k, False: 64.0M] ------------------ 35408| 343k| hash = janet_struct_hash(janet_unwrap_struct(x)); ------------------ | | 1840| 343k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 343k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35409| 343k| break; 35410| 7.38M| case JANET_NUMBER: { ------------------ | Branch (35410:9): [True: 7.38M, False: 57.0M] ------------------ 35411| 7.38M| union { 35412| 7.38M| double d; 35413| 7.38M| uint64_t u; 35414| 7.38M| } as; 35415| 7.38M| as.d = janet_unwrap_number(x); ------------------ | | 834| 7.38M|#define janet_unwrap_number(x) ((x).number) ------------------ 35416| 7.38M| as.d += 0.0; /* normalize negative 0 */ 35417| 7.38M| as.u = murmur64(as.u); 35418| 7.38M| uint32_t hi = (uint32_t)(as.u >> 32); 35419| 7.38M| hash = (int32_t)hi; 35420| 7.38M| break; 35421| 24.8M| } 35422| 29.0k| case JANET_ABSTRACT: { ------------------ | Branch (35422:9): [True: 29.0k, False: 64.4M] ------------------ 35423| 29.0k| JanetAbstract xx = janet_unwrap_abstract(x); ------------------ | | 861| 29.0k|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 35424| 29.0k| const JanetAbstractType *at = janet_abstract_type(xx); ------------------ | | 1889| 29.0k|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1887| 29.0k|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 35425| 29.0k| if (at->hash != NULL) { ------------------ | Branch (35425:17): [True: 0, False: 29.0k] ------------------ 35426| 0| hash = at->hash(xx, janet_abstract_size(xx)); ------------------ | | 1890| 0|#define janet_abstract_size(u) (janet_abstract_head(u)->size) | | ------------------ | | | | 1887| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 35427| 0| break; 35428| 0| } 35429| 29.0k| } 35430| | /* fallthrough */ 35431| 7.87M| default: ------------------ | Branch (35431:9): [True: 7.85M, False: 56.5M] ------------------ 35432| 7.87M| if (sizeof(double) == sizeof(void *)) { ------------------ | Branch (35432:17): [True: 7.87M, Folded] ------------------ 35433| | /* Assuming 8 byte pointer (8 byte aligned) */ 35434| 7.87M| uint64_t i = murmur64(janet_u64(x)); ------------------ | | 783| 7.87M|#define janet_u64(x) ((x).u64) ------------------ 35435| 7.87M| hash = (int32_t)(i >> 32); 35436| 7.87M| } else { 35437| | /* Assuming 4 byte pointer (or smaller) */ 35438| 0| uintptr_t diff = (uintptr_t) janet_unwrap_pointer(x); ------------------ | | 862| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ 35439| 0| uint32_t hilo = (uint32_t) diff * 2654435769u; 35440| 0| hash = (int32_t)((hilo << 16) | (hilo >> 16)); 35441| 0| } 35442| 7.87M| break; 35443| 64.4M| } 35444| 64.4M| return hash; 35445| 64.4M|} janet_compare: 35450| 422k|int janet_compare(Janet x, Janet y) { 35451| 422k| janet_vm.traversal = janet_vm.traversal_base; 35452| 422k| int status; 35453| 536k| do { 35454| 536k| JanetType tx = janet_type(x); ------------------ | | 790| 536k| (isnan((x).number) \ | | 791| 536k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 536k| : JANET_NUMBER) ------------------ | Branch (35454:24): [True: 197k, False: 339k] ------------------ 35455| 536k| JanetType ty = janet_type(y); ------------------ | | 790| 536k| (isnan((x).number) \ | | 791| 536k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 792| 536k| : JANET_NUMBER) ------------------ | Branch (35455:24): [True: 217k, False: 319k] ------------------ 35456| 536k| if (tx != ty) return tx < ty ? -1 : 1; ------------------ | Branch (35456:13): [True: 50.3k, False: 486k] | Branch (35456:30): [True: 35.3k, False: 14.9k] ------------------ 35457| 486k| switch (tx) { 35458| 107k| case JANET_NIL: ------------------ | Branch (35458:13): [True: 107k, False: 379k] ------------------ 35459| 107k| break; 35460| 11.8k| case JANET_BOOLEAN: { ------------------ | Branch (35460:13): [True: 11.8k, False: 474k] ------------------ 35461| 11.8k| int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 833| 11.8k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 833| 11.8k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 35462| 11.8k| if (diff) return diff; ------------------ | Branch (35462:21): [True: 0, False: 11.8k] ------------------ 35463| 11.8k| break; 35464| 11.8k| } 35465| 304k| case JANET_NUMBER: { ------------------ | Branch (35465:13): [True: 304k, False: 181k] ------------------ 35466| 304k| double xx = janet_unwrap_number(x); ------------------ | | 834| 304k|#define janet_unwrap_number(x) ((x).number) ------------------ 35467| 304k| double yy = janet_unwrap_number(y); ------------------ | | 834| 304k|#define janet_unwrap_number(x) ((x).number) ------------------ 35468| 304k| if (xx == yy) { ------------------ | Branch (35468:21): [True: 304k, False: 233] ------------------ 35469| 304k| break; 35470| 304k| } else { 35471| 233| return (xx < yy) ? -1 : 1; ------------------ | Branch (35471:28): [True: 0, False: 233] ------------------ 35472| 233| } 35473| 304k| } 35474| 1.10k| case JANET_STRING: ------------------ | Branch (35474:13): [True: 1.10k, False: 485k] ------------------ 35475| 2.98k| case JANET_SYMBOL: ------------------ | Branch (35475:13): [True: 1.87k, False: 484k] ------------------ 35476| 3.40k| case JANET_KEYWORD: { ------------------ | Branch (35476:13): [True: 422, False: 486k] ------------------ 35477| 3.40k| int diff = janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 858| 3.40k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ int diff = janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 858| 3.40k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 35478| 3.40k| if (diff) return diff; ------------------ | Branch (35478:21): [True: 228, False: 3.17k] ------------------ 35479| 3.17k| break; 35480| 3.40k| } 35481| 3.17k| case JANET_ABSTRACT: { ------------------ | Branch (35481:13): [True: 0, False: 486k] ------------------ 35482| 0| int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 861| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 861| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 35483| 0| if (diff) return diff; ------------------ | Branch (35483:21): [True: 0, False: 0] ------------------ 35484| 0| break; 35485| 0| } 35486| 464| default: { ------------------ | Branch (35486:13): [True: 464, False: 486k] ------------------ 35487| 464| if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 862| 464|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 862| 464|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (35487:21): [True: 464, False: 0] ------------------ 35488| 464| break; 35489| 464| } else { 35490| 0| return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 862| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 862| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (35490:28): [True: 0, False: 0] ------------------ 35491| 0| } 35492| 464| } 35493| 7.70k| case JANET_TUPLE: { ------------------ | Branch (35493:13): [True: 7.70k, False: 478k] ------------------ 35494| 7.70k| const Janet *lhs = janet_unwrap_tuple(x); ------------------ | | 853| 7.70k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 35495| 7.70k| const Janet *rhs = janet_unwrap_tuple(y); ------------------ | | 853| 7.70k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 35496| 7.70k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1788| 7.70k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1796| 7.70k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1790| 7.70k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1796| 7.70k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1790| 7.70k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (35496:21): [True: 0, False: 7.70k] ------------------ 35497| 0| return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1796| 0|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1790| 0|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1788| 0|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (35497:28): [True: 0, False: 0] ------------------ 35498| 0| } 35499| 7.70k| push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1790| 7.70k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1790| 7.70k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 35500| 7.70k| break; 35501| 7.70k| } 35502| 50.8k| case JANET_STRUCT: { ------------------ | Branch (35502:13): [True: 50.8k, False: 435k] ------------------ 35503| 50.8k| const JanetKV *lhs = janet_unwrap_struct(x); ------------------ | | 852| 50.8k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 35504| 50.8k| const JanetKV *rhs = janet_unwrap_struct(y); ------------------ | | 852| 50.8k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 35505| 50.8k| int32_t llen = janet_struct_capacity(lhs); ------------------ | | 1839| 50.8k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1836| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35506| 50.8k| int32_t rlen = janet_struct_capacity(rhs); ------------------ | | 1839| 50.8k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1836| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35507| 50.8k| int32_t lhash = janet_struct_hash(lhs); ------------------ | | 1840| 50.8k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35508| 50.8k| int32_t rhash = janet_struct_hash(rhs); ------------------ | | 1840| 50.8k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1836| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35509| 50.8k| if (llen < rlen) return -1; ------------------ | Branch (35509:21): [True: 0, False: 50.8k] ------------------ 35510| 50.8k| if (llen > rlen) return 1; ------------------ | Branch (35510:21): [True: 0, False: 50.8k] ------------------ 35511| 50.8k| if (lhash < rhash) return -1; ------------------ | Branch (35511:21): [True: 0, False: 50.8k] ------------------ 35512| 50.8k| if (lhash > rhash) return 1; ------------------ | Branch (35512:21): [True: 0, False: 50.8k] ------------------ 35513| 50.8k| push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1836| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1836| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 35514| 50.8k| break; 35515| 50.8k| } 35516| 486k| } 35517| 486k| } while (!(status = traversal_next(&x, &y))); ------------------ | Branch (35517:14): [True: 114k, False: 371k] ------------------ 35518| 371k| return status - 2; 35519| 422k|} janet_v_grow: 35923| 114k|void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) { 35924| 114k| int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0; ------------------ | | 714| 99.9k|#define janet_v__cap(v) janet_v__raw(v)[0] | | ------------------ | | | | 713| 99.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ | Branch (35924:23): [True: 99.9k, False: 14.6k] ------------------ 35925| 114k| int32_t min_needed = janet_v_count(v) + increment; ------------------ | | 708| 114k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 715| 99.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 99.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (708:34): [True: 99.9k, False: 14.6k] | | ------------------ ------------------ 35926| 114k| int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed; ------------------ | Branch (35926:17): [True: 87.7k, False: 26.8k] ------------------ 35927| 114k| size_t newsize = ((size_t) itemsize) * m + sizeof(int32_t) * 2; 35928| 114k| int32_t *p = (int32_t *) janet_srealloc(v ? janet_v__raw(v) : 0, newsize); ------------------ | | 713| 99.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) ------------------ | Branch (35928:45): [True: 99.9k, False: 14.6k] ------------------ 35929| 114k| if (!v) p[1] = 0; ------------------ | Branch (35929:9): [True: 14.6k, False: 99.9k] ------------------ 35930| 114k| p[0] = m; 35931| 114k| return p + 2; 35932| 114k|} janet_try_init: 37436| 3.22k|void janet_try_init(JanetTryState *state) { 37437| 3.22k| state->stackn = janet_vm.stackn++; 37438| 3.22k| state->gc_handle = janet_vm.gc_suspend; 37439| 3.22k| state->vm_fiber = janet_vm.fiber; 37440| 3.22k| state->vm_jmp_buf = janet_vm.signal_buf; 37441| 3.22k| state->vm_return_reg = janet_vm.return_reg; 37442| 3.22k| state->coerce_error = janet_vm.coerce_error; 37443| 3.22k| janet_vm.return_reg = &(state->payload); 37444| 3.22k| janet_vm.signal_buf = &(state->buf); 37445| 3.22k| janet_vm.coerce_error = 0; 37446| 3.22k|} janet_restore: 37448| 3.22k|void janet_restore(JanetTryState *state) { 37449| 3.22k| janet_vm.stackn = state->stackn; 37450| 3.22k| janet_vm.gc_suspend = state->gc_handle; 37451| 3.22k| janet_vm.fiber = state->vm_fiber; 37452| 3.22k| janet_vm.signal_buf = state->vm_jmp_buf; 37453| 3.22k| janet_vm.return_reg = state->vm_return_reg; 37454| 3.22k| janet_vm.coerce_error = state->coerce_error; 37455| 3.22k|} janet_init: 37608| 3.22k|int janet_init(void) { 37609| | 37610| | /* Garbage collection */ 37611| 3.22k| janet_vm.blocks = NULL; 37612| 3.22k| janet_vm.weak_blocks = NULL; 37613| 3.22k| janet_vm.next_collection = 0; 37614| 3.22k| janet_vm.gc_interval = 0x400000; 37615| 3.22k| janet_vm.block_count = 0; 37616| 3.22k| janet_vm.gc_mark_phase = 0; 37617| | 37618| 3.22k| janet_symcache_init(); 37619| | 37620| | /* Initialize gc roots */ 37621| 3.22k| janet_vm.roots = NULL; 37622| 3.22k| janet_vm.root_count = 0; 37623| 3.22k| janet_vm.root_capacity = 0; 37624| | 37625| | /* Scratch memory */ 37626| 3.22k| janet_vm.user = NULL; 37627| 3.22k| janet_vm.scratch_mem = NULL; 37628| 3.22k| janet_vm.scratch_len = 0; 37629| 3.22k| janet_vm.scratch_cap = 0; 37630| | 37631| | /* Sandbox flags */ 37632| 3.22k| janet_vm.sandbox_flags = 0; 37633| | 37634| | /* Initialize registry */ 37635| 3.22k| janet_vm.registry = NULL; 37636| 3.22k| janet_vm.registry_cap = 0; 37637| 3.22k| janet_vm.registry_count = 0; 37638| 3.22k| janet_vm.registry_dirty = 0; 37639| | 37640| | /* Initialize abstract registry */ 37641| 3.22k| janet_vm.abstract_registry = janet_table(0); 37642| 3.22k| janet_gcroot(janet_wrap_table(janet_vm.abstract_registry)); ------------------ | | 841| 3.22k|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 820| 3.22k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37643| | 37644| | /* Traversal */ 37645| 3.22k| janet_vm.traversal = NULL; 37646| 3.22k| janet_vm.traversal_base = NULL; 37647| 3.22k| janet_vm.traversal_top = NULL; 37648| | 37649| | /* Core env */ 37650| 3.22k| janet_vm.core_env = NULL; 37651| | 37652| | /* Auto suspension */ 37653| 3.22k| janet_vm.auto_suspend = 0; 37654| | 37655| | /* Dynamic bindings */ 37656| 3.22k| janet_vm.top_dyns = NULL; 37657| | 37658| | /* Seed RNG */ 37659| 3.22k| janet_rng_seed(janet_default_rng(), 0); 37660| | 37661| | /* Fibers */ 37662| 3.22k| janet_vm.fiber = NULL; 37663| 3.22k| janet_vm.root_fiber = NULL; 37664| 3.22k| janet_vm.stackn = 0; 37665| | 37666| 3.22k|#ifdef JANET_EV 37667| 3.22k| janet_ev_init(); 37668| 3.22k|#endif 37669| 3.22k|#ifdef JANET_NET 37670| 3.22k| janet_net_init(); 37671| 3.22k|#endif 37672| 3.22k| return 0; 37673| 3.22k|} janet_deinit: 37688| 3.22k|void janet_deinit(void) { 37689| 3.22k| janet_clear_memory(); 37690| 3.22k| janet_symcache_deinit(); 37691| 3.22k| janet_free(janet_vm.roots); ------------------ | | 2402| 3.22k|#define janet_free(X) free((X)) ------------------ 37692| 3.22k| janet_vm.roots = NULL; 37693| 3.22k| janet_vm.root_count = 0; 37694| 3.22k| janet_vm.root_capacity = 0; 37695| 3.22k| janet_vm.abstract_registry = NULL; 37696| 3.22k| janet_vm.core_env = NULL; 37697| 3.22k| janet_vm.top_dyns = NULL; 37698| 3.22k| janet_vm.user = NULL; 37699| 3.22k| janet_free(janet_vm.traversal_base); ------------------ | | 2402| 3.22k|#define janet_free(X) free((X)) ------------------ 37700| 3.22k| janet_vm.fiber = NULL; 37701| 3.22k| janet_vm.root_fiber = NULL; 37702| 3.22k| janet_free(janet_vm.registry); ------------------ | | 2402| 3.22k|#define janet_free(X) free((X)) ------------------ 37703| | janet_vm.registry = NULL; 37704| 3.22k|#ifdef JANET_EV 37705| 3.22k| janet_ev_deinit(); 37706| 3.22k|#endif 37707| 3.22k|#ifdef JANET_NET 37708| 3.22k| janet_net_deinit(); 37709| 3.22k|#endif 37710| 3.22k|} janet_memalloc_empty: 37878| 4.52M|void *janet_memalloc_empty(int32_t count) { 37879| 4.52M| int32_t i; 37880| 4.52M| void *mem = janet_malloc((size_t) count * sizeof(JanetKV)); ------------------ | | 2393| 4.52M|#define janet_malloc(X) malloc((X)) ------------------ 37881| 4.52M| janet_vm.next_collection += (size_t) count * sizeof(JanetKV); 37882| 4.52M| if (NULL == mem) { ------------------ | Branch (37882:9): [True: 0, False: 4.52M] ------------------ 37883| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 37884| 0| } 37885| 4.52M| JanetKV *mmem = (JanetKV *)mem; 37886| 80.0M| for (i = 0; i < count; i++) { ------------------ | Branch (37886:17): [True: 75.5M, False: 4.52M] ------------------ 37887| 75.5M| JanetKV *kv = mmem + i; 37888| 75.5M| kv->key = janet_wrap_nil(); ------------------ | | 826| 75.5M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 75.5M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 75.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 75.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37889| 75.5M| kv->value = janet_wrap_nil(); ------------------ | | 826| 75.5M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 75.5M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 75.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 75.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37890| 75.5M| } 37891| 4.52M| return mem; 37892| 4.52M|} janet_memempty: 37894| 441k|void janet_memempty(JanetKV *mem, int32_t count) { 37895| 441k| int32_t i; 37896| 7.35M| for (i = 0; i < count; i++) { ------------------ | Branch (37896:17): [True: 6.91M, False: 441k] ------------------ 37897| 6.91M| mem[i].key = janet_wrap_nil(); ------------------ | | 826| 6.91M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 6.91M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 6.91M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.91M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37898| 6.91M| mem[i].value = janet_wrap_nil(); ------------------ | | 826| 6.91M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 6.91M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 6.91M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.91M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37899| 6.91M| } 37900| 441k|} janet_wrap_number_safe: 37904| 28.0k|Janet janet_wrap_number_safe(double d) { 37905| 28.0k| Janet ret; 37906| 28.0k| ret.number = isnan(d) ? NAN : d; ------------------ | Branch (37906:18): [True: 4.30k, False: 23.7k] ------------------ 37907| 28.0k| return ret; 37908| 28.0k|} janet_nanbox_to_pointer: 37910| 106M|void *janet_nanbox_to_pointer(Janet x) { 37911| 106M| x.i64 &= JANET_NANBOX_PAYLOADBITS; ------------------ | | 786| 106M|#define JANET_NANBOX_PAYLOADBITS 0x00007FFFFFFFFFFFllu ------------------ 37912| 106M| x.u64 <<= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 336| 106M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 37913| 106M| return x.pointer; 37914| 106M|} janet_nanbox_from_pointer: 37916| 5.02M|Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask) { 37917| 5.02M| Janet ret; 37918| 5.02M| ret.pointer = p; 37919| | /* Should be noop when pointer shift is 0 */ 37920| | /* 37921| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 37922| | */ 37923| 5.02M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 336| 5.02M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 37924| 5.02M| ret.u64 |= tagmask; 37925| 5.02M| return ret; 37926| 5.02M|} janet_nanbox_from_cpointer: 37928| 19.1M|Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask) { 37929| 19.1M| Janet ret; 37930| 19.1M| ret.pointer = (void *)p; 37931| | /* Should be noop when pointer shift is 0 */ 37932| | /* 37933| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 37934| | */ 37935| 19.1M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 336| 19.1M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 37936| 19.1M| ret.u64 |= tagmask; 37937| 19.1M| return ret; 37938| 19.1M|} janet_nanbox_from_double: 37940| 7.78M|Janet janet_nanbox_from_double(double d) { 37941| 7.78M| Janet ret; 37942| 7.78M| ret.number = d; 37943| 7.78M| return ret; 37944| 7.78M|} janet_nanbox_from_bits: 37946| 624M|Janet janet_nanbox_from_bits(uint64_t bits) { 37947| 624M| Janet ret; 37948| 624M| ret.u64 = bits; 37949| 624M| return ret; 37950| 624M|} janet.c:janet_array_impl: 1547| 33.2k|static void janet_array_impl(JanetArray *array, int32_t capacity) { 1548| 33.2k| Janet *data = NULL; 1549| 33.2k| if (capacity > 0) { ------------------ | Branch (1549:9): [True: 19.5k, False: 13.7k] ------------------ 1550| 19.5k| janet_vm.next_collection += capacity * sizeof(Janet); 1551| 19.5k| data = (Janet *) janet_malloc(sizeof(Janet) * (size_t) capacity); ------------------ | | 2393| 19.5k|#define janet_malloc(X) malloc((X)) ------------------ 1552| 19.5k| if (NULL == data) { ------------------ | Branch (1552:13): [True: 0, False: 19.5k] ------------------ 1553| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 1554| 0| } 1555| 19.5k| } 1556| 33.2k| array->count = 0; 1557| 33.2k| array->capacity = capacity; 1558| 33.2k| array->data = data; 1559| 33.2k|} janet.c:janet_buffer_init_impl: 3114| 6.03k|static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) { 3115| 6.03k| uint8_t *data = NULL; 3116| 6.03k| if (capacity < 4) capacity = 4; ------------------ | Branch (3116:9): [True: 4.16k, False: 1.87k] ------------------ 3117| 6.03k| janet_gcpressure(capacity); 3118| 6.03k| data = janet_malloc(sizeof(uint8_t) * (size_t) capacity); ------------------ | | 2393| 6.03k|#define janet_malloc(X) malloc((X)) ------------------ 3119| 6.03k| if (NULL == data) { ------------------ | Branch (3119:9): [True: 0, False: 6.03k] ------------------ 3120| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 3121| 0| } 3122| 6.03k| buffer->count = 0; 3123| 6.03k| buffer->capacity = capacity; 3124| 6.03k| buffer->data = data; 3125| 6.03k| return buffer; 3126| 6.03k|} janet.c:janet_buffer_can_realloc: 3107| 1.78k|static void janet_buffer_can_realloc(JanetBuffer *buffer) { 3108| 1.78k| if (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) { ------------------ | | 1770| 1.78k|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3108:9): [True: 0, False: 1.78k] ------------------ 3109| 0| janet_panic("buffer cannot reallocate foreign memory"); 3110| 0| } 3111| 1.78k|} janet.c:janet_load_libs: 7783| 3.22k|static void janet_load_libs(JanetTable *env) { 7784| 3.22k| JanetRegExt corelib_cfuns[] = { 7785| 3.22k| JANET_CORE_REG("native", janet_core_native), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7786| 3.22k| JANET_CORE_REG("describe", janet_core_describe), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7787| 3.22k| JANET_CORE_REG("string", janet_core_string), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7788| 3.22k| JANET_CORE_REG("symbol", janet_core_symbol), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7789| 3.22k| JANET_CORE_REG("keyword", janet_core_keyword), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7790| 3.22k| JANET_CORE_REG("buffer", janet_core_buffer), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7791| 3.22k| JANET_CORE_REG("abstract?", janet_core_is_abstract), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7792| 3.22k| JANET_CORE_REG("table", janet_core_table), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7793| 3.22k| JANET_CORE_REG("array", janet_core_array), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7794| 3.22k| JANET_CORE_REG("scan-number", janet_core_scannumber), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7795| 3.22k| JANET_CORE_REG("tuple", janet_core_tuple), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7796| 3.22k| JANET_CORE_REG("struct", janet_core_struct), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7797| 3.22k| JANET_CORE_REG("gensym", janet_core_gensym), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7798| 3.22k| JANET_CORE_REG("gccollect", janet_core_gccollect), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7799| 3.22k| JANET_CORE_REG("gcsetinterval", janet_core_gcsetinterval), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7800| 3.22k| JANET_CORE_REG("gcinterval", janet_core_gcinterval), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7801| 3.22k| JANET_CORE_REG("type", janet_core_type), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7802| 3.22k| JANET_CORE_REG("hash", janet_core_hash), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7803| 3.22k| JANET_CORE_REG("getline", janet_core_getline), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7804| 3.22k| JANET_CORE_REG("dyn", janet_core_dyn), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7805| 3.22k| JANET_CORE_REG("setdyn", janet_core_setdyn), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7806| 3.22k| JANET_CORE_REG("trace", janet_core_trace), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7807| 3.22k| JANET_CORE_REG("untrace", janet_core_untrace), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7808| 3.22k| JANET_CORE_REG("module/expand-path", janet_core_expand_path), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7809| 3.22k| JANET_CORE_REG("int?", janet_core_check_int), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7810| 3.22k| JANET_CORE_REG("nat?", janet_core_check_nat), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7811| 3.22k| JANET_CORE_REG("bytes?", janet_core_is_bytes), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7812| 3.22k| JANET_CORE_REG("indexed?", janet_core_is_indexed), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7813| 3.22k| JANET_CORE_REG("dictionary?", janet_core_is_dictionary), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7814| 3.22k| JANET_CORE_REG("lengthable?", janet_core_is_lengthable), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7815| 3.22k| JANET_CORE_REG("slice", janet_core_slice), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7816| 3.22k| JANET_CORE_REG("range", janet_core_range), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7817| 3.22k| JANET_CORE_REG("signal", janet_core_signal), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7818| 3.22k| JANET_CORE_REG("memcmp", janet_core_memcmp), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7819| 3.22k| JANET_CORE_REG("getproto", janet_core_getproto), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7820| 3.22k| JANET_CORE_REG("sandbox", janet_core_sandbox), ------------------ | | 476| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2109| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7821| 3.22k| JANET_REG_END ------------------ | | 2099| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 7822| 3.22k| }; 7823| | janet_core_cfuns_ext(env, NULL, corelib_cfuns); 7824| 3.22k| janet_lib_io(env); 7825| 3.22k| janet_lib_math(env); 7826| 3.22k| janet_lib_array(env); 7827| 3.22k| janet_lib_tuple(env); 7828| 3.22k| janet_lib_buffer(env); 7829| 3.22k| janet_lib_table(env); 7830| 3.22k| janet_lib_struct(env); 7831| 3.22k| janet_lib_fiber(env); 7832| 3.22k| janet_lib_os(env); 7833| 3.22k| janet_lib_parse(env); 7834| 3.22k| janet_lib_compile(env); 7835| 3.22k| janet_lib_debug(env); 7836| 3.22k| janet_lib_string(env); 7837| 3.22k| janet_lib_marsh(env); 7838| 3.22k|#ifdef JANET_PEG 7839| 3.22k| janet_lib_peg(env); 7840| 3.22k|#endif 7841| 3.22k|#ifdef JANET_ASSEMBLER 7842| 3.22k| janet_lib_asm(env); 7843| 3.22k|#endif 7844| 3.22k|#ifdef JANET_INT_TYPES 7845| 3.22k| janet_lib_inttypes(env); 7846| 3.22k|#endif 7847| 3.22k|#ifdef JANET_EV 7848| 3.22k| janet_lib_ev(env); 7849| 3.22k|#ifdef JANET_FILEWATCH 7850| 3.22k| janet_lib_filewatch(env); 7851| 3.22k|#endif 7852| 3.22k|#endif 7853| 3.22k|#ifdef JANET_NET 7854| 3.22k| janet_lib_net(env); 7855| 3.22k|#endif 7856| 3.22k|#ifdef JANET_FFI 7857| 3.22k| janet_lib_ffi(env); 7858| 3.22k|#endif 7859| 3.22k|} janet.c:janet_q_init: 9054| 3.22k|static void janet_q_init(JanetQueue *q) { 9055| | q->data = NULL; 9056| 3.22k| q->head = 0; 9057| 3.22k| q->tail = 0; 9058| 3.22k| q->capacity = 0; 9059| 3.22k|} janet.c:peek_timeout: 9136| 3.22k|static int peek_timeout(JanetTimeout *out) { 9137| 3.22k| if (janet_vm.tq_count == 0) return 0; ------------------ | Branch (9137:9): [True: 3.22k, False: 0] ------------------ 9138| 0| *out = janet_vm.tq[0]; 9139| 0| return 1; 9140| 3.22k|} janet.c:janet_q_deinit: 9061| 3.22k|static void janet_q_deinit(JanetQueue *q) { 9062| 3.22k| janet_free(q->data); ------------------ | | 2402| 3.22k|#define janet_free(X) free((X)) ------------------ 9063| 3.22k|} janet.c:janet_ev_setup_selfpipe: 10554| 3.22k|static void janet_ev_setup_selfpipe(void) { 10555| 3.22k| if (janet_make_pipe(janet_vm.selfpipe, 1)) { ------------------ | Branch (10555:9): [True: 0, False: 3.22k] ------------------ 10556| | JANET_EXIT("failed to initialize self pipe in event loop"); ------------------ | | 375| 0|#define JANET_EXIT(m) do { \ | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 377| 0| __FILE__,\ | | 378| 0| __LINE__,\ | | 379| 0| (m));\ | | 380| 0| abort();\ | | 381| 0|} while (0) | | ------------------ | | | Branch (381:10): [Folded, False: 0] | | ------------------ ------------------ 10557| 0| } 10558| 3.22k|} janet.c:janet_ev_cleanup_selfpipe: 10577| 3.22k|static void janet_ev_cleanup_selfpipe(void) { 10578| 3.22k| close(janet_vm.selfpipe[0]); 10579| 3.22k| close(janet_vm.selfpipe[1]); 10580| 3.22k|} janet.c:janet_deinit_block: 16510| 19.7M|static void janet_deinit_block(JanetGCObject *mem) { 16511| 19.7M| switch (mem->flags & JANET_MEM_TYPEBITS) { ------------------ | | 624| 19.7M|#define JANET_MEM_TYPEBITS 0xFF ------------------ 16512| 7.70M| default: ------------------ | Branch (16512:9): [True: 7.70M, False: 12.0M] ------------------ 16513| 8.97M| case JANET_MEMORY_FUNCTION: ------------------ | Branch (16513:9): [True: 1.26M, False: 18.4M] ------------------ 16514| 8.97M| break; /* Do nothing for non gc types */ 16515| 6.57M| case JANET_MEMORY_SYMBOL: ------------------ | Branch (16515:9): [True: 6.57M, False: 13.1M] ------------------ 16516| 6.57M| janet_symbol_deinit(((JanetStringHead *) mem)->data); 16517| 6.57M| break; 16518| 19.3k| case JANET_MEMORY_ARRAY: ------------------ | Branch (16518:9): [True: 19.3k, False: 19.7M] ------------------ 16519| 19.3k| case JANET_MEMORY_ARRAY_WEAK: ------------------ | Branch (16519:9): [True: 0, False: 19.7M] ------------------ 16520| 19.3k| janet_free(((JanetArray *) mem)->data); ------------------ | | 2402| 19.3k|#define janet_free(X) free((X)) ------------------ 16521| 19.3k| break; 16522| 2.36M| case JANET_MEMORY_TABLE: ------------------ | Branch (16522:9): [True: 2.36M, False: 17.3M] ------------------ 16523| 2.36M| case JANET_MEMORY_TABLE_WEAKK: ------------------ | Branch (16523:9): [True: 0, False: 19.7M] ------------------ 16524| 2.36M| case JANET_MEMORY_TABLE_WEAKV: ------------------ | Branch (16524:9): [True: 0, False: 19.7M] ------------------ 16525| 2.36M| case JANET_MEMORY_TABLE_WEAKKV: ------------------ | Branch (16525:9): [True: 0, False: 19.7M] ------------------ 16526| 2.36M| janet_free(((JanetTable *) mem)->data); ------------------ | | 2402| 2.36M|#define janet_free(X) free((X)) ------------------ 16527| 2.36M| break; 16528| 3.39k| case JANET_MEMORY_FIBER: { ------------------ | Branch (16528:9): [True: 3.39k, False: 19.7M] ------------------ 16529| 3.39k| JanetFiber *f = (JanetFiber *)mem; 16530| 3.39k|#ifdef JANET_EV 16531| 3.39k| if (f->ev_state && !(f->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) { ------------------ | | 792| 0|#define JANET_FIBER_EV_FLAG_IN_FLIGHT 0x1 ------------------ | Branch (16531:17): [True: 0, False: 3.39k] | Branch (16531:32): [True: 0, False: 0] ------------------ 16532| 0| janet_ev_dec_refcount(); 16533| 0| janet_free(f->ev_state); ------------------ | | 2402| 0|#define janet_free(X) free((X)) ------------------ 16534| 3.39k| } else if (f->gc.flags & JANET_FIBER_EV_FLAG_SUSPENDED) { ------------------ | | 790| 3.39k|#define JANET_FIBER_EV_FLAG_SUSPENDED 0x20000 ------------------ | Branch (16534:24): [True: 0, False: 3.39k] ------------------ 16535| 0| janet_ev_dec_refcount(); 16536| 0| } 16537| 3.39k|#endif 16538| 3.39k| janet_free(f->data); ------------------ | | 2402| 3.39k|#define janet_free(X) free((X)) ------------------ 16539| 3.39k| } 16540| 3.39k| break; 16541| 4.76k| case JANET_MEMORY_BUFFER: ------------------ | Branch (16541:9): [True: 4.76k, False: 19.7M] ------------------ 16542| 4.76k| janet_buffer_deinit((JanetBuffer *) mem); 16543| 4.76k| break; 16544| 9.68k| case JANET_MEMORY_ABSTRACT: { ------------------ | Branch (16544:9): [True: 9.68k, False: 19.7M] ------------------ 16545| 9.68k| JanetAbstractHead *head = (JanetAbstractHead *)mem; 16546| 9.68k| if (head->type->gcperthread) { ------------------ | Branch (16546:17): [True: 0, False: 9.68k] ------------------ 16547| 0| janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed"); ------------------ | | 386| 0|#define janet_assert(c, m) do { \ | | 387| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 375| 0|#define JANET_EXIT(m) do { \ | | | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 377| 0| __FILE__,\ | | | | 378| 0| __LINE__,\ | | | | 379| 0| (m));\ | | | | 380| 0| abort();\ | | | | 381| 0|} while (0) | | | | ------------------ | | | | | Branch (381:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (387:9): [True: 0, False: 0] | | ------------------ | | 388| 0|} while (0) | | ------------------ | | | Branch (388:10): [Folded, False: 0] | | ------------------ ------------------ 16548| 0| } 16549| 9.68k| if (head->type->gc) { ------------------ | Branch (16549:17): [True: 9.68k, False: 0] ------------------ 16550| 9.68k| janet_assert(!head->type->gc(head->data, head->size), "finalizer failed"); ------------------ | | 386| 9.68k|#define janet_assert(c, m) do { \ | | 387| 9.68k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 375| 0|#define JANET_EXIT(m) do { \ | | | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 377| 0| __FILE__,\ | | | | 378| 0| __LINE__,\ | | | | 379| 0| (m));\ | | | | 380| 0| abort();\ | | | | 381| 0|} while (0) | | | | ------------------ | | | | | Branch (381:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (387:9): [True: 0, False: 9.68k] | | ------------------ | | 388| 9.68k|} while (0) | | ------------------ | | | Branch (388:10): [Folded, False: 9.68k] | | ------------------ ------------------ 16551| 9.68k| } 16552| 9.68k| } 16553| 9.68k| break; 16554| 45.0k| case JANET_MEMORY_FUNCENV: { ------------------ | Branch (16554:9): [True: 45.0k, False: 19.7M] ------------------ 16555| 45.0k| JanetFuncEnv *env = (JanetFuncEnv *)mem; 16556| 45.0k| if (0 == env->offset) ------------------ | Branch (16556:17): [True: 44.8k, False: 198] ------------------ 16557| 44.8k| janet_free(env->as.values); ------------------ | | 2402| 44.8k|#define janet_free(X) free((X)) ------------------ 16558| 45.0k| } 16559| 45.0k| break; 16560| 1.76M| case JANET_MEMORY_FUNCDEF: { ------------------ | Branch (16560:9): [True: 1.76M, False: 18.0M] ------------------ 16561| 1.76M| JanetFuncDef *def = (JanetFuncDef *)mem; 16562| | /* TODO - get this all with one alloc and one free */ 16563| 1.76M| janet_free(def->defs); ------------------ | | 2402| 1.76M|#define janet_free(X) free((X)) ------------------ 16564| 1.76M| janet_free(def->environments); ------------------ | | 2402| 1.76M|#define janet_free(X) free((X)) ------------------ 16565| 1.76M| janet_free(def->constants); ------------------ | | 2402| 1.76M|#define janet_free(X) free((X)) ------------------ 16566| 1.76M| janet_free(def->bytecode); ------------------ | | 2402| 1.76M|#define janet_free(X) free((X)) ------------------ 16567| 1.76M| janet_free(def->sourcemap); ------------------ | | 2402| 1.76M|#define janet_free(X) free((X)) ------------------ 16568| 1.76M| janet_free(def->closure_bitset); ------------------ | | 2402| 1.76M|#define janet_free(X) free((X)) ------------------ 16569| 1.76M| janet_free(def->symbolmap); ------------------ | | 2402| 1.76M|#define janet_free(X) free((X)) ------------------ 16570| 1.76M| } 16571| 1.76M| break; 16572| 19.7M| } 16573| 19.7M|} janet.c:janet_free_all_scratch: 16760| 3.22k|static void janet_free_all_scratch(void) { 16761| 7.92k| for (size_t i = 0; i < janet_vm.scratch_len; i++) { ------------------ | Branch (16761:24): [True: 4.69k, False: 3.22k] ------------------ 16762| 4.69k| free_one_scratch(janet_vm.scratch_mem[i]); 16763| 4.69k| } 16764| 3.22k| janet_vm.scratch_len = 0; 16765| 3.22k|} janet.c:janet_mem2scratch: 16767| 109k|static JanetScratch *janet_mem2scratch(void *mem) { 16768| 109k| JanetScratch *s = (JanetScratch *)mem; 16769| 109k| return s - 1; 16770| 109k|} janet.c:free_one_scratch: 16752| 14.6k|static void free_one_scratch(JanetScratch *s) { 16753| 14.6k| if (NULL != s->finalize) { ------------------ | Branch (16753:9): [True: 0, False: 14.6k] ------------------ 16754| 0| s->finalize((char *) s->mem); 16755| 0| } 16756| 14.6k| janet_free(s); ------------------ | | 2402| 14.6k|#define janet_free(X) free((X)) ------------------ 16757| 14.6k|} janet.c:makef: 17775| 9.68k|static void *makef(FILE *f, int32_t flags, size_t bufsize) { 17776| 9.68k| JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile)); 17777| 9.68k| iof->file = f; 17778| 9.68k| iof->flags = flags; 17779| 9.68k| iof->vbufsize = bufsize; 17780| 9.68k|#if !(defined(JANET_WINDOWS) || defined(JANET_PLAN9)) 17781| | /* While we would like fopen to set cloexec by default (like O_CLOEXEC) with the e flag, that is 17782| | * not standard. */ 17783| 9.68k| if (!(flags & JANET_FILE_NOT_CLOSEABLE)) ------------------ | | 2265| 9.68k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ | Branch (17783:9): [True: 0, False: 9.68k] ------------------ 17784| 0| fcntl(fileno(f), F_SETFD, FD_CLOEXEC); 17785| 9.68k|#endif 17786| 9.68k| return iof; 17787| 9.68k|} janet.c:cfun_io_gc: 17978| 9.68k|static int cfun_io_gc(void *p, size_t len) { 17979| 9.68k| (void) len; 17980| 9.68k| JanetFile *iof = (JanetFile *)p; 17981| 9.68k| janet_file_close(iof); 17982| 9.68k| return 0; 17983| 9.68k|} janet.c:entry_getval: 18622| 2.26M|static Janet entry_getval(Janet env_entry) { 18623| 2.26M| if (janet_checktype(env_entry, JANET_TABLE)) { ------------------ | | 801| 2.26M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 2.26M, False: 0] | | | Branch (801:6): [Folded, False: 2.26M] | | ------------------ | | 802| 2.26M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 2.26M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 2.26M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 2.26M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 2.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 2.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18624| 2.26M| JanetTable *entry = janet_unwrap_table(env_entry); ------------------ | | 856| 2.26M|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 18625| 2.26M| Janet checkval = janet_table_get(entry, janet_ckeywordv("value")); ------------------ | | 1833| 2.26M|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 845| 2.26M|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 823| 2.26M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 2.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 2.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18626| 2.26M| if (janet_checktype(checkval, JANET_NIL)) { ------------------ | | 801| 2.26M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 2.26M] | | | Branch (801:6): [Folded, False: 2.26M] | | ------------------ | | 802| 2.26M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 2.26M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 2.26M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 2.26M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 2.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 2.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18627| 0| checkval = janet_table_get(entry, janet_ckeywordv("ref")); ------------------ | | 1833| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 845| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 823| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18628| 0| } 18629| 2.26M| return checkval; 18630| 2.26M| } else if (janet_checktype(env_entry, JANET_STRUCT)) { ------------------ | | 801| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 0] | | | Branch (801:6): [Folded, False: 0] | | ------------------ | | 802| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18631| 0| const JanetKV *entry = janet_unwrap_struct(env_entry); ------------------ | | 852| 0|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 18632| 0| Janet checkval = janet_struct_get(entry, janet_ckeywordv("value")); ------------------ | | 1833| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 845| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 823| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18633| 0| if (janet_checktype(checkval, JANET_NIL)) { ------------------ | | 801| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 0] | | | Branch (801:6): [Folded, False: 0] | | ------------------ | | 802| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18634| 0| checkval = janet_struct_get(entry, janet_ckeywordv("ref")); ------------------ | | 1833| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 845| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 823| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18635| 0| } 18636| 0| return checkval; 18637| 0| } else { 18638| 0| return janet_wrap_nil(); ------------------ | | 826| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18639| 0| } 18640| 2.26M|} janet.c:readint: 19265| 229M|static int32_t readint(UnmarshalState *st, const uint8_t **atdata) { 19266| 229M| const uint8_t *data = *atdata; 19267| 229M| int32_t ret; 19268| 229M| MARSH_EOS(st, data); ------------------ | |19260| 229M|#define MARSH_EOS(st, data) do { \ | |19261| 229M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 108, False: 229M] | | ------------------ | |19262| 229M|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 229M] | | ------------------ ------------------ 19269| 229M| if (*data < 128) { ------------------ | Branch (19269:9): [True: 187M, False: 42.1M] ------------------ 19270| 187M| ret = *data++; 19271| 187M| } else if (*data < 192) { ------------------ | Branch (19271:16): [True: 39.9M, False: 2.27M] ------------------ 19272| 39.9M| MARSH_EOS(st, data + 1); ------------------ | |19260| 39.9M|#define MARSH_EOS(st, data) do { \ | |19261| 39.9M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 34, False: 39.9M] | | ------------------ | |19262| 39.9M|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 39.9M] | | ------------------ ------------------ 19273| 39.9M| uint32_t uret = ((data[0] & 0x3F) << 8) + data[1]; 19274| | /* Sign extend 18 MSBs */ 19275| 39.9M| uret |= (uret >> 13) ? 0xFFFFC000 : 0; ------------------ | Branch (19275:17): [True: 10.8M, False: 29.0M] ------------------ 19276| 39.9M| ret = (int32_t)uret; 19277| 39.9M| data += 2; 19278| 39.9M| } else if (*data == LB_INTEGER) { ------------------ | Branch (19278:16): [True: 2.27M, False: 241] ------------------ 19279| 2.27M| MARSH_EOS(st, data + 4); ------------------ | |19260| 2.27M|#define MARSH_EOS(st, data) do { \ | |19261| 2.27M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 7, False: 2.27M] | | ------------------ | |19262| 2.27M|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 2.27M] | | ------------------ ------------------ 19280| 2.27M| uint32_t ui = ((uint32_t)(data[1]) << 24) | 19281| 2.27M| ((uint32_t)(data[2]) << 16) | 19282| 2.27M| ((uint32_t)(data[3]) << 8) | 19283| 2.27M| (uint32_t)(data[4]); 19284| 2.27M| ret = (int32_t)ui; 19285| 2.27M| data += 5; 19286| 2.27M| } else { 19287| 241| janet_panicf("expected integer, got byte %x at index %d", 19288| 241| *data, 19289| 241| data - st->start); 19290| 0| ret = 0; 19291| 0| } 19292| 229M| *atdata = data; 19293| 229M| return ret; 19294| 229M|} janet.c:unmarshal_one: 19873| 64.2M| int flags) { 19874| 64.2M| uint8_t lead; 19875| 64.2M| MARSH_STACKCHECK; ------------------ | |18732| 64.2M|#define MARSH_STACKCHECK if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) janet_panic("stack overflow") | | ------------------ | | | | 291| 64.2M|#define JANET_RECURSION_GUARD 1024 | | ------------------ | | | Branch (18732:30): [True: 10, False: 64.2M] | | ------------------ ------------------ 19876| 64.2M| MARSH_EOS(st, data); ------------------ | |19260| 64.2M|#define MARSH_EOS(st, data) do { \ | |19261| 64.2M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 560, False: 64.2M] | | ------------------ | |19262| 64.2M|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 64.2M] | | ------------------ ------------------ 19877| 64.2M| lead = data[0]; 19878| 64.2M| if (lead < LB_REAL) { ------------------ | Branch (19878:9): [True: 7.76M, False: 56.5M] ------------------ 19879| 7.76M| *out = janet_wrap_integer(readint(st, &data)); ------------------ | | 958| 7.76M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 830| 7.76M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 19880| 7.76M| return data; 19881| 7.76M| } 19882| 56.5M| switch (lead) { 19883| 244k| case LB_NIL: ------------------ | Branch (19883:9): [True: 244k, False: 56.2M] ------------------ 19884| 244k| *out = janet_wrap_nil(); ------------------ | | 826| 244k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 244k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 244k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 244k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19885| 244k| return data + 1; 19886| 131k| case LB_FALSE: ------------------ | Branch (19886:9): [True: 131k, False: 56.3M] ------------------ 19887| 131k| *out = janet_wrap_false(); ------------------ | | 828| 131k|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 817| 131k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 131k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 131k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19888| 131k| return data + 1; 19889| 477k| case LB_TRUE: ------------------ | Branch (19889:9): [True: 477k, False: 56.0M] ------------------ 19890| 477k| *out = janet_wrap_true(); ------------------ | | 827| 477k|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 817| 477k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 477k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 477k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19891| 477k| return data + 1; 19892| 24.8k| case LB_INTEGER: ------------------ | Branch (19892:9): [True: 24.8k, False: 56.4M] ------------------ 19893| | /* Long integer */ 19894| 24.8k| MARSH_EOS(st, data + 4); ------------------ | |19260| 24.8k|#define MARSH_EOS(st, data) do { \ | |19261| 24.8k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 7, False: 24.8k] | | ------------------ | |19262| 24.8k|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 24.8k] | | ------------------ ------------------ 19895| 24.8k| uint32_t ui = ((uint32_t)(data[4])) | 19896| 24.8k| ((uint32_t)(data[3]) << 8) | 19897| 24.8k| ((uint32_t)(data[2]) << 16) | 19898| 24.8k| ((uint32_t)(data[1]) << 24); 19899| 24.8k| int32_t si = (int32_t)ui; 19900| 24.8k| *out = janet_wrap_integer(si); ------------------ | | 958| 24.8k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 830| 24.8k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 19901| 24.8k| return data + 5; 19902| 28.0k| case LB_REAL: ------------------ | Branch (19902:9): [True: 28.0k, False: 56.4M] ------------------ 19903| | /* Real */ 19904| 28.0k| { 19905| 28.0k| union { 19906| 28.0k| double d; 19907| 28.0k| uint8_t bytes[8]; 19908| 28.0k| } u; 19909| 28.0k| MARSH_EOS(st, data + 8); ------------------ | |19260| 28.0k|#define MARSH_EOS(st, data) do { \ | |19261| 28.0k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 17, False: 28.0k] | | ------------------ | |19262| 28.0k|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 28.0k] | | ------------------ ------------------ 19910| |#ifdef JANET_BIG_ENDIAN 19911| | u.bytes[0] = data[8]; 19912| | u.bytes[1] = data[7]; 19913| | u.bytes[2] = data[6]; 19914| | u.bytes[3] = data[5]; 19915| | u.bytes[4] = data[4]; 19916| | u.bytes[5] = data[3]; 19917| | u.bytes[6] = data[2]; 19918| | u.bytes[7] = data[1]; 19919| |#else 19920| 28.0k| memcpy(&u.bytes, data + 1, sizeof(double)); 19921| 28.0k|#endif 19922| 28.0k| *out = janet_wrap_number_safe(u.d); 19923| 28.0k| janet_v_push(st->lookup, *out); ------------------ | | 706| 28.0k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 28.0k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 28.0k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 27.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 27.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 714| 27.9k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 27.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 55, False: 27.9k] | | | | | | | Branch (717:50): [True: 405, False: 27.5k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 460|#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)) | | ------------------ | | | | 715| 28.0k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 28.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19924| 28.0k| return data + 9; 19925| 28.0k| } 19926| 4.74M| case LB_STRING: ------------------ | Branch (19926:9): [True: 4.74M, False: 51.7M] ------------------ 19927| 10.9M| case LB_SYMBOL: ------------------ | Branch (19927:9): [True: 6.16M, False: 50.3M] ------------------ 19928| 10.9M| case LB_BUFFER: ------------------ | Branch (19928:9): [True: 4.76k, False: 56.5M] ------------------ 19929| 11.6M| case LB_KEYWORD: ------------------ | Branch (19929:9): [True: 765k, False: 55.7M] ------------------ 19930| 12.8M| case LB_REGISTRY: { ------------------ | Branch (19930:9): [True: 1.21M, False: 55.2M] ------------------ 19931| 12.8M| data++; 19932| 12.8M| int32_t len = readnat(st, &data); 19933| 12.8M| MARSH_EOS(st, data - 1 + len); ------------------ | |19260| 12.8M|#define MARSH_EOS(st, data) do { \ | |19261| 12.8M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 31, False: 12.8M] | | ------------------ | |19262| 12.8M|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 12.8M] | | ------------------ ------------------ 19934| 12.8M| if (lead == LB_STRING) { ------------------ | Branch (19934:17): [True: 4.74M, False: 8.14M] ------------------ 19935| 4.74M| const uint8_t *str = janet_string(data, len); 19936| 4.74M| *out = janet_wrap_string(str); ------------------ | | 843| 4.74M|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 823| 4.74M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 4.74M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 4.74M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19937| 8.14M| } else if (lead == LB_SYMBOL) { ------------------ | Branch (19937:24): [True: 6.16M, False: 1.98M] ------------------ 19938| 6.16M| const uint8_t *str = janet_symbol(data, len); 19939| 6.16M| *out = janet_wrap_symbol(str); ------------------ | | 844| 6.16M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 823| 6.16M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 6.16M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 6.16M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19940| 6.16M| } else if (lead == LB_KEYWORD) { ------------------ | Branch (19940:24): [True: 765k, False: 1.21M] ------------------ 19941| 765k| const uint8_t *str = janet_keyword(data, len); ------------------ | | 1830| 765k|#define janet_keyword janet_symbol ------------------ 19942| 765k| *out = janet_wrap_keyword(str); ------------------ | | 845| 765k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | ------------------ | | | | 823| 765k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 765k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 765k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19943| 1.21M| } else if (lead == LB_REGISTRY) { ------------------ | Branch (19943:24): [True: 1.21M, False: 4.79k] ------------------ 19944| 1.21M| if (st->reg) { ------------------ | Branch (19944:21): [True: 1.21M, False: 0] ------------------ 19945| 1.21M| Janet regkey = janet_symbolv(data, len); ------------------ | | 1826| 1.21M|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 844| 1.21M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 823| 1.21M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 788| 1.21M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 787| 1.21M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19946| 1.21M| *out = janet_table_get(st->reg, regkey); 19947| 1.21M| } else { 19948| 0| *out = janet_wrap_nil(); ------------------ | | 826| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19949| 0| } 19950| 1.21M| } else { /* (lead == LB_BUFFER) */ 19951| 4.79k| JanetBuffer *buffer = janet_buffer(len); 19952| 4.79k| buffer->count = len; 19953| 4.79k| safe_memcpy(buffer->data, data, len); 19954| 4.79k| *out = janet_wrap_buffer(buffer); ------------------ | | 842| 4.79k|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 820| 4.79k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 4.79k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 4.79k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19955| 4.79k| } 19956| 12.8M| janet_v_push(st->lookup, *out); ------------------ | | 706| 12.8M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 12.8M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 12.8M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 12.8M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 12.8M|#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)) | | | | | | ------------------ | | | | | | | | 714| 12.8M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 12.8M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 249, False: 12.8M] | | | | | | | Branch (717:50): [True: 40.4k, False: 12.8M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 40.6k|#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)) | | ------------------ | | | | 715| 12.8M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 12.8M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19957| 12.8M| return data + len; 19958| 12.8M| } 19959| 3.39k| case LB_FIBER: { ------------------ | Branch (19959:9): [True: 3.39k, False: 56.5M] ------------------ 19960| 3.39k| JanetFiber *fiber; 19961| 3.39k| data = unmarshal_one_fiber(st, data + 1, &fiber, flags + 1); 19962| 3.39k| *out = janet_wrap_fiber(fiber); ------------------ | | 839| 3.39k|#define janet_wrap_fiber(s) janet_nanbox_wrap_((s), JANET_FIBER) | | ------------------ | | | | 820| 3.39k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 3.39k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.39k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19963| 3.39k| return data; 19964| 12.8M| } 19965| 1.26M| case LB_FUNCTION: { ------------------ | Branch (19965:9): [True: 1.26M, False: 55.2M] ------------------ 19966| 1.26M| JanetFunction *func; 19967| 1.26M| JanetFuncDef *def; 19968| 1.26M| data++; 19969| 1.26M| int32_t len = readnat(st, &data); 19970| 1.26M| if (len > 255) { ------------------ | Branch (19970:17): [True: 0, False: 1.26M] ------------------ 19971| 0| janet_panicf("invalid function - too many environments (%d)", len); 19972| 0| } 19973| 1.26M| func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + 19974| 1.26M| len * sizeof(JanetFuncEnv)); 19975| 1.26M| func->def = NULL; 19976| 1.88M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (19976:33): [True: 614k, False: 1.26M] ------------------ 19977| 614k| func->envs[i] = NULL; 19978| 614k| } 19979| 1.26M| *out = janet_wrap_function(func); ------------------ | | 847| 1.26M|#define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION) | | ------------------ | | | | 820| 1.26M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 1.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 1.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19980| 1.26M| janet_v_push(st->lookup, *out); ------------------ | | 706| 1.26M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 1.26M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 1.26M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 1.26M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 1.26M|#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)) | | | | | | ------------------ | | | | | | | | 714| 1.26M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 1.26M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 1.27k, False: 1.26M] | | | | | | | Branch (717:50): [True: 1.14k, False: 1.26M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 2.41k|#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)) | | ------------------ | | | | 715| 1.26M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 1.26M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19981| 1.26M| data = unmarshal_one_def(st, data, &def, flags + 1); 19982| 1.26M| func->def = def; 19983| 1.42M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (19983:33): [True: 157k, False: 1.26M] ------------------ 19984| 157k| data = unmarshal_one_env(st, data, &(func->envs[i]), flags + 1); 19985| 157k| } 19986| 1.26M| return data; 19987| 1.26M| } 19988| 15.2k| case LB_ABSTRACT: { ------------------ | Branch (19988:9): [True: 15.2k, False: 56.4M] ------------------ 19989| 15.2k| data++; 19990| 15.2k| return unmarshal_one_abstract(st, data, out, flags); 19991| 1.26M| } 19992| 35.9M| case LB_REFERENCE: ------------------ | Branch (19992:9): [True: 35.9M, False: 20.5M] ------------------ 19993| 35.9M| case LB_ARRAY: ------------------ | Branch (19993:9): [True: 19.3k, False: 56.4M] ------------------ 19994| 35.9M| case LB_ARRAY_WEAK: ------------------ | Branch (19994:9): [True: 13.8k, False: 56.4M] ------------------ 19995| 38.4M| case LB_TUPLE: ------------------ | Branch (19995:9): [True: 2.52M, False: 53.9M] ------------------ 19996| 38.8M| case LB_STRUCT: ------------------ | Branch (19996:9): [True: 369k, False: 56.1M] ------------------ 19997| 38.8M| case LB_STRUCT_PROTO: ------------------ | Branch (19997:9): [True: 19.6k, False: 56.4M] ------------------ 19998| 41.2M| case LB_TABLE: ------------------ | Branch (19998:9): [True: 2.35M, False: 54.1M] ------------------ 19999| 41.2M| case LB_TABLE_PROTO: ------------------ | Branch (19999:9): [True: 1.02k, False: 56.5M] ------------------ 20000| 41.2M| case LB_TABLE_WEAKK: ------------------ | Branch (20000:9): [True: 20.3k, False: 56.4M] ------------------ 20001| 41.2M| case LB_TABLE_WEAKV: ------------------ | Branch (20001:9): [True: 366, False: 56.5M] ------------------ 20002| 41.4M| case LB_TABLE_WEAKKV: ------------------ | Branch (20002:9): [True: 152k, False: 56.3M] ------------------ 20003| 41.4M| case LB_TABLE_WEAKK_PROTO: ------------------ | Branch (20003:9): [True: 897, False: 56.5M] ------------------ 20004| 41.4M| case LB_TABLE_WEAKV_PROTO: ------------------ | Branch (20004:9): [True: 5.35k, False: 56.5M] ------------------ 20005| 41.4M| case LB_TABLE_WEAKKV_PROTO: ------------------ | Branch (20005:9): [True: 593, False: 56.5M] ------------------ 20006| | /* Things that open with integers */ 20007| 41.4M| { 20008| 41.4M| data++; 20009| 41.4M| int32_t len = readnat(st, &data); 20010| | /* DOS check */ 20011| 41.4M| if (lead != LB_REFERENCE) { ------------------ | Branch (20011:17): [True: 5.48M, False: 35.9M] ------------------ 20012| 5.48M| MARSH_EOS(st, data - 1 + len); ------------------ | |19260| 5.48M|#define MARSH_EOS(st, data) do { \ | |19261| 5.48M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 249, False: 5.48M] | | ------------------ | |19262| 5.48M|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 5.48M] | | ------------------ ------------------ 20013| 5.48M| } 20014| 41.4M| if (lead == LB_ARRAY || lead == LB_ARRAY_WEAK) { ------------------ | Branch (20014:17): [True: 19.5k, False: 41.4M] | Branch (20014:37): [True: 13.8k, False: 41.3M] ------------------ 20015| | /* Array */ 20016| 33.2k| JanetArray *array = (lead == LB_ARRAY_WEAK) ? janet_array_weak(len) : janet_array(len); ------------------ | Branch (20016:37): [True: 13.8k, False: 19.3k] ------------------ 20017| 33.2k| array->count = len; 20018| 33.2k| *out = janet_wrap_array(array); ------------------ | | 840| 33.2k|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 820| 33.2k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 33.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 33.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20019| 33.2k| janet_v_push(st->lookup, *out); ------------------ | | 706| 33.2k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 33.2k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 33.2k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 33.1k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 33.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)) | | | | | | ------------------ | | | | | | | | 714| 33.1k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 33.1k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 116, False: 33.1k] | | | | | | | Branch (717:50): [True: 520, False: 32.6k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 636|#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)) | | ------------------ | | | | 715| 33.2k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 33.2k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20020| 210k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20020:37): [True: 177k, False: 33.2k] ------------------ 20021| 177k| data = unmarshal_one(st, data, array->data + i, flags + 1); 20022| 177k| } 20023| 41.3M| } else if (lead == LB_TUPLE) { ------------------ | Branch (20023:24): [True: 2.52M, False: 38.8M] ------------------ 20024| | /* Tuple */ 20025| 2.52M| Janet *tup = janet_tuple_begin(len); 20026| 2.52M| int32_t flag = readint(st, &data); 20027| 2.52M| janet_tuple_flag(tup) |= (int32_t) (((uint32_t) flag) << 16); /* Avoid left shift of negative value */ ------------------ | | 1796| 2.52M|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1790| 2.52M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 20028| 9.78M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20028:37): [True: 7.26M, False: 2.52M] ------------------ 20029| 7.26M| data = unmarshal_one(st, data, tup + i, flags + 1); 20030| 7.26M| } 20031| 2.52M| *out = janet_wrap_tuple(janet_tuple_end(tup)); ------------------ | | 838| 2.52M|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 823| 2.52M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 2.52M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 2.52M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20032| 2.52M| janet_v_push(st->lookup, *out); ------------------ | | 706| 2.52M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 2.52M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 2.52M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 2.52M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 2.52M|#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)) | | | | | | ------------------ | | | | | | | | 714| 2.52M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 2.52M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 943, False: 2.52M] | | | | | | | Branch (717:50): [True: 1.11k, False: 2.51M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 1.16k|#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)) | | ------------------ | | | | 715| 2.52M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 2.52M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20033| 38.8M| } else if (lead == LB_STRUCT || lead == LB_STRUCT_PROTO) { ------------------ | Branch (20033:24): [True: 369k, False: 38.5M] | Branch (20033:45): [True: 19.6k, False: 38.4M] ------------------ 20034| | /* Struct */ 20035| 388k| JanetKV *struct_ = janet_struct_begin(len); 20036| 388k| if (lead == LB_STRUCT_PROTO) { ------------------ | Branch (20036:21): [True: 19.6k, False: 368k] ------------------ 20037| 19.6k| Janet proto; 20038| 19.6k| data = unmarshal_one(st, data, &proto, flags + 1); 20039| 19.6k| janet_asserttype(proto, JANET_STRUCT, st); 20040| 19.6k| janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 1841| 19.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1836| 19.6k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 852| 19.6k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 20041| 19.6k| } 20042| 1.44M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20042:37): [True: 1.06M, False: 388k] ------------------ 20043| 1.06M| Janet key, value; 20044| 1.06M| data = unmarshal_one(st, data, &key, flags + 1); 20045| 1.06M| data = unmarshal_one(st, data, &value, flags + 1); 20046| 1.06M| janet_struct_put(struct_, key, value); 20047| 1.06M| } 20048| 388k| *out = janet_wrap_struct(janet_struct_end(struct_)); ------------------ | | 837| 388k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 823| 388k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 388k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 388k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20049| 388k| janet_v_push(st->lookup, *out); ------------------ | | 706| 388k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 388k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 388k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 328k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 328k|#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)) | | | | | | ------------------ | | | | | | | | 714| 328k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 328k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 60.4k, False: 328k] | | | | | | | Branch (717:50): [True: 1.87k, False: 326k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 1.97k|#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)) | | ------------------ | | | | 715| 388k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 388k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20050| 38.4M| } else if (lead == LB_REFERENCE) { ------------------ | Branch (20050:24): [True: 35.9M, False: 2.53M] ------------------ 20051| 35.9M| if (len >= janet_v_count(st->lookup)) ------------------ | | 708| 35.9M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 715| 35.9M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 35.9M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (708:34): [True: 35.9M, False: 0] | | ------------------ ------------------ | Branch (20051:21): [True: 51, False: 35.9M] ------------------ 20052| 51| janet_panicf("invalid reference %d", len); 20053| 35.9M| *out = st->lookup[len]; 20054| 35.9M| } else { 20055| | /* Table */ 20056| 2.53M| JanetTable *t; 20057| 2.53M| if (lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKK) { ------------------ | Branch (20057:21): [True: 1.02k, False: 2.53M] | Branch (20057:53): [True: 20.3k, False: 2.51M] ------------------ 20058| 21.1k| t = janet_table_weakk(len); 20059| 2.51M| } else if (lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKV) { ------------------ | Branch (20059:28): [True: 5.48k, False: 2.51M] | Branch (20059:60): [True: 357, False: 2.51M] ------------------ 20060| 5.70k| t = janet_table_weakv(len); 20061| 2.51M| } else if (lead == LB_TABLE_WEAKKV_PROTO || lead == LB_TABLE_WEAKKV) { ------------------ | Branch (20061:28): [True: 722, False: 2.51M] | Branch (20061:61): [True: 152k, False: 2.35M] ------------------ 20062| 152k| t = janet_table_weakkv(len); 20063| 2.35M| } else { 20064| 2.35M| t = janet_table(len); 20065| 2.35M| } 20066| 2.53M| *out = janet_wrap_table(t); ------------------ | | 841| 2.53M|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 820| 2.53M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 2.53M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 2.53M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20067| 2.53M| janet_v_push(st->lookup, *out); ------------------ | | 706| 2.53M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 2.53M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 2.53M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 2.53M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 2.53M|#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)) | | | | | | ------------------ | | | | | | | | 714| 2.53M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 2.53M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 4.45k, False: 2.53M] | | | | | | | Branch (717:50): [True: 6.36k, False: 2.52M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 10.6k|#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)) | | ------------------ | | | | 715| 2.53M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 2.53M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20068| 2.53M| if (lead == LB_TABLE_PROTO || lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKKV_PROTO) { ------------------ | Branch (20068:21): [True: 1.14k, False: 2.53M] | Branch (20068:47): [True: 891, False: 2.53M] | Branch (20068:79): [True: 5.35k, False: 2.53M] | Branch (20068:111): [True: 588, False: 2.53M] ------------------ 20069| 7.84k| Janet proto; 20070| 7.84k| data = unmarshal_one(st, data, &proto, flags + 1); 20071| 7.84k| janet_asserttype(proto, JANET_TABLE, st); 20072| 7.84k| t->proto = janet_unwrap_table(proto); ------------------ | | 856| 7.84k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 20073| 7.84k| } 20074| 15.3M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20074:37): [True: 12.8M, False: 2.53M] ------------------ 20075| 12.8M| Janet key, value; 20076| 12.8M| data = unmarshal_one(st, data, &key, flags + 1); 20077| 12.8M| data = unmarshal_one(st, data, &value, flags + 1); 20078| 12.8M| janet_table_put(t, key, value); 20079| 12.8M| } 20080| 2.53M| } 20081| 41.4M| return data; 20082| 41.4M| } 20083| 0| case LB_UNSAFE_POINTER: { ------------------ | Branch (20083:9): [True: 0, False: 56.5M] ------------------ 20084| 0| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |19260| 0|#define MARSH_EOS(st, data) do { \ | |19261| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 0, False: 0] | | ------------------ | |19262| 0|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 0] | | ------------------ ------------------ 20085| 0| data++; 20086| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1901| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (20086:17): [True: 0, False: 0] ------------------ 20087| 0| janet_panicf("unsafe flag not given, " 20088| 0| "will not unmarshal raw pointer at index %d", 20089| 0| (int)(data - st->start)); 20090| 0| } 20091| 0| union { 20092| 0| void *ptr; 20093| 0| uint8_t bytes[sizeof(void *)]; 20094| 0| } u; 20095| 0| memcpy(u.bytes, data, sizeof(void *)); 20096| 0| data += sizeof(void *); 20097| 0| *out = janet_wrap_pointer(u.ptr); ------------------ | | 849| 0|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 820| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20098| 0| janet_v_push(st->lookup, *out); ------------------ | | 706| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 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)) | | | | | | ------------------ | | | | | | | | 714| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 0, False: 0] | | | | | | | Branch (717:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 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)) | | ------------------ | | | | 715| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20099| 0| return data; 20100| 0| } 20101| 0|#ifdef JANET_EV 20102| 17| case LB_POINTER_BUFFER: { ------------------ | Branch (20102:9): [True: 17, False: 56.5M] ------------------ 20103| 17| data++; 20104| 17| int32_t count = readnat(st, &data); 20105| 17| int32_t capacity = readnat(st, &data); 20106| 17| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |19260| 17|#define MARSH_EOS(st, data) do { \ | |19261| 17| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 2, False: 15] | | ------------------ | |19262| 17|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 15] | | ------------------ ------------------ 20107| 15| union { 20108| 15| void *ptr; 20109| 15| uint8_t bytes[sizeof(void *)]; 20110| 15| } u; 20111| 15| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1901| 15|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (20111:17): [True: 5, False: 10] ------------------ 20112| 5| janet_panicf("unsafe flag not given, " 20113| 5| "will not unmarshal raw pointer at index %d", 20114| 5| (int)(data - st->start)); 20115| 5| } 20116| 10| memcpy(u.bytes, data, sizeof(void *)); 20117| 10| data += sizeof(void *); 20118| 10| JanetBuffer *buffer = janet_pointer_buffer_unsafe(u.ptr, capacity, count); 20119| 10| *out = janet_wrap_buffer(buffer); ------------------ | | 842| 10|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 820| 10| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 10|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 10|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20120| 10| janet_v_push(st->lookup, *out); ------------------ | | 706| 10|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 10|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 10|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 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)) | | | | | | ------------------ | | | | | | | | 714| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 10, False: 0] | | | | | | | Branch (717:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 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)) | | ------------------ | | | | 715| 10|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 10|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20121| 10| return data; 20122| 15| } 20123| 0|#endif 20124| 1| case LB_UNSAFE_CFUNCTION: { ------------------ | Branch (20124:9): [True: 1, False: 56.5M] ------------------ 20125| 1| MARSH_EOS(st, data + sizeof(JanetCFunction)); ------------------ | |19260| 1|#define MARSH_EOS(st, data) do { \ | |19261| 1| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 0, False: 1] | | ------------------ | |19262| 1|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 1] | | ------------------ ------------------ 20126| 1| data++; 20127| 1| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1901| 1|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (20127:17): [True: 1, False: 0] ------------------ 20128| 1| janet_panicf("unsafe flag not given, " 20129| 1| "will not unmarshal function pointer at index %d", 20130| 1| (int)(data - st->start)); 20131| 1| } 20132| 0| union { 20133| 0| JanetCFunction ptr; 20134| 0| uint8_t bytes[sizeof(JanetCFunction)]; 20135| 0| } u; 20136| 0| memcpy(u.bytes, data, sizeof(JanetCFunction)); 20137| 0| data += sizeof(JanetCFunction); 20138| 0| *out = janet_wrap_cfunction(u.ptr); ------------------ | | 848| 0|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 820| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20139| 0| janet_v_push(st->lookup, *out); ------------------ | | 706| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 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)) | | | | | | ------------------ | | | | | | | | 714| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 0, False: 0] | | | | | | | Branch (717:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 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)) | | ------------------ | | | | 715| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20140| 0| return data; 20141| 1| } 20142| 0|#ifdef JANET_EV 20143| 1| case LB_THREADED_ABSTRACT: { ------------------ | Branch (20143:9): [True: 1, False: 56.5M] ------------------ 20144| 1| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |19260| 1|#define MARSH_EOS(st, data) do { \ | |19261| 1| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 0, False: 1] | | ------------------ | |19262| 1|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 1] | | ------------------ ------------------ 20145| 1| data++; 20146| 1| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1901| 1|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (20146:17): [True: 1, False: 0] ------------------ 20147| 1| janet_panicf("unsafe flag not given, " 20148| 1| "will not unmarshal threaded abstract pointer at index %d", 20149| 1| (int)(data - st->start)); 20150| 1| } 20151| 0| union { 20152| 0| void *ptr; 20153| 0| uint8_t bytes[sizeof(void *)]; 20154| 0| } u; 20155| 0| memcpy(u.bytes, data, sizeof(void *)); 20156| 0| data += sizeof(void *); 20157| | 20158| 0| if (flags & JANET_MARSHAL_DECREF) { ------------------ | | 384| 0|#define JANET_MARSHAL_DECREF 0x40000 ------------------ | Branch (20158:17): [True: 0, False: 0] ------------------ 20159| | /* Decrement immediately and don't bother putting into heap */ 20160| 0| janet_abstract_decref(u.ptr); 20161| 0| *out = janet_wrap_nil(); ------------------ | | 826| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20162| 0| } else { 20163| 0| *out = janet_wrap_abstract(u.ptr); ------------------ | | 846| 0|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 820| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20164| 0| Janet check = janet_table_get(&janet_vm.threaded_abstracts, *out); 20165| 0| if (janet_checktype(check, JANET_NIL)) { ------------------ | | 801| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:5): [True: 0, False: 0] | | | Branch (801:6): [Folded, False: 0] | | ------------------ | | 802| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20166| | /* Transfers reference from threaded channel buffer to current heap */ 20167| 0| janet_table_put(&janet_vm.threaded_abstracts, *out, janet_wrap_false()); ------------------ | | 828| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 817| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20168| 0| } else { 20169| | /* Heap reference already accounted for, remove threaded channel reference. */ 20170| 0| janet_abstract_decref(u.ptr); 20171| 0| } 20172| 0| } 20173| | 20174| 0| janet_v_push(st->lookup, *out); ------------------ | | 706| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 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)) | | | | | | ------------------ | | | | | | | | 714| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 0, False: 0] | | | | | | | Branch (717:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 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)) | | ------------------ | | | | 715| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20175| 0| return data; 20176| 1| } 20177| 0|#endif 20178| 249| default: { ------------------ | Branch (20178:9): [True: 249, False: 56.5M] ------------------ 20179| 249| janet_panicf("unknown byte %x at index %d", 20180| 249| *data, 20181| 249| (int)(data - st->start)); 20182| 0| return NULL; 20183| 1| } 20184| 56.5M| } 20185| 56.5M|} janet.c:readnat: 19297| 69.7M|static int32_t readnat(UnmarshalState *st, const uint8_t **atdata) { 19298| 69.7M| int32_t ret = readint(st, atdata); 19299| 69.7M| if (ret < 0) { ------------------ | Branch (19299:9): [True: 211, False: 69.7M] ------------------ 19300| 211| janet_panicf("expected integer >= 0, got %d", ret); 19301| 211| } 19302| 69.7M| return ret; 19303| 69.7M|} janet.c:unmarshal_one_fiber: 19616| 3.39k| int flags) { 19617| | 19618| | /* Initialize a new fiber with gc friendly defaults */ 19619| 3.39k| JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber)); 19620| 3.39k| fiber->flags = 0; 19621| 3.39k| fiber->frame = 0; 19622| 3.39k| fiber->stackstart = 0; 19623| 3.39k| fiber->stacktop = 0; 19624| 3.39k| fiber->capacity = 0; 19625| 3.39k| fiber->maxstack = 0; 19626| 3.39k| fiber->data = NULL; 19627| 3.39k| fiber->child = NULL; 19628| 3.39k| fiber->env = NULL; 19629| 3.39k| fiber->last_value = janet_wrap_nil(); ------------------ | | 826| 3.39k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 3.39k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 3.39k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.39k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19630| 3.39k|#ifdef JANET_EV 19631| 3.39k| fiber->sched_id = 0; 19632| 3.39k| fiber->supervisor_channel = NULL; 19633| 3.39k| fiber->ev_state = NULL; 19634| 3.39k| fiber->ev_callback = NULL; 19635| 3.39k| fiber->ev_stream = NULL; 19636| 3.39k|#endif 19637| | 19638| | /* Push fiber to seen stack */ 19639| 3.39k| janet_v_push(st->lookup, janet_wrap_fiber(fiber)); ------------------ | | 706| 3.39k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 3.39k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 3.39k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 3.13k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 3.13k|#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)) | | | | | | ------------------ | | | | | | | | 714| 3.13k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 3.13k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 259, False: 3.13k] | | | | | | | Branch (717:50): [True: 204, False: 2.92k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 463|#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)) | | ------------------ | | | | 715| 3.39k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 3.39k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19640| | 19641| | /* Read ints */ 19642| 3.39k| int32_t fiber_flags = readint(st, &data); 19643| 3.39k| int32_t frame = readnat(st, &data); 19644| 3.39k| int32_t fiber_stackstart = readnat(st, &data); 19645| 3.39k| int32_t fiber_stacktop = readnat(st, &data); 19646| 3.39k| int32_t fiber_maxstack = readnat(st, &data); 19647| 3.39k| JanetTable *fiber_env = NULL; 19648| | 19649| | /* Check for bad flags and ints */ 19650| 3.39k| if ((int32_t)(frame + JANET_FRAME_SIZE) > fiber_stackstart || ------------------ | | 1017| 3.39k|#define JANET_FRAME_SIZE 4 ------------------ | Branch (19650:9): [True: 41, False: 3.35k] ------------------ 19651| 3.35k| fiber_stackstart > fiber_stacktop || ------------------ | Branch (19651:13): [True: 4, False: 3.34k] ------------------ 19652| 3.34k| fiber_stacktop > fiber_maxstack) { ------------------ | Branch (19652:13): [True: 6, False: 3.34k] ------------------ 19653| 18| janet_panic("fiber has incorrect stack setup"); 19654| 18| } 19655| | 19656| | /* Allocate stack memory */ 19657| 3.37k| if (fiber_stacktop < INT32_MAX - 10) { ------------------ | Branch (19657:9): [True: 3.34k, False: 33] ------------------ 19658| 3.34k| fiber->capacity = fiber_stacktop + 10; 19659| 3.34k| } else { 19660| | /* Extra capacity is usually nice to avoid immediately reallocing on pushed arguments, but not needed */ 19661| 33| fiber->capacity = INT32_MAX; 19662| 33| } 19663| 3.37k| fiber->data = janet_malloc(sizeof(Janet) * fiber->capacity); ------------------ | | 2393| 3.37k|#define janet_malloc(X) malloc((X)) ------------------ 19664| 3.37k| if (!fiber->data) { ------------------ | Branch (19664:9): [True: 0, False: 3.37k] ------------------ 19665| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19666| 0| } 19667| 458M| for (int32_t i = 0; i < fiber->capacity; i++) { ------------------ | Branch (19667:25): [True: 458M, False: 3.37k] ------------------ 19668| 458M| fiber->data[i] = janet_wrap_nil(); ------------------ | | 826| 458M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 817| 458M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 788| 458M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 458M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19669| 458M| } 19670| | 19671| | /* get frames */ 19672| 3.37k| int32_t stack = frame; 19673| 3.37k| int32_t stacktop = fiber_stackstart - JANET_FRAME_SIZE; ------------------ | | 1017| 3.37k|#define JANET_FRAME_SIZE 4 ------------------ 19674| 3.56k| while (stack > 0) { ------------------ | Branch (19674:12): [True: 200, False: 3.36k] ------------------ 19675| 200| JanetFunction *func = NULL; 19676| 200| JanetFuncDef *def = NULL; 19677| 200| JanetFuncEnv *env = NULL; 19678| 200| int32_t frameflags = readint(st, &data); 19679| 200| int32_t prevframe = readnat(st, &data); 19680| 200| int32_t pcdiff = readnat(st, &data); 19681| | 19682| | /* Get frame items */ 19683| 200| Janet *framestack = fiber->data + stack; 19684| 200| JanetStackFrame *framep = janet_stack_frame(framestack); ------------------ | | 801| 200|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1017| 200|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ 19685| | 19686| | /* Get function */ 19687| 200| Janet funcv; 19688| 200| data = unmarshal_one(st, data, &funcv, flags + 1); 19689| 200| janet_asserttype(funcv, JANET_FUNCTION, st); 19690| 200| func = janet_unwrap_function(funcv); ------------------ | | 863| 200|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 19691| 200| def = func->def; 19692| | 19693| | /* Check env */ 19694| 200| if (frameflags & JANET_STACKFRAME_HASENV) { ------------------ | |18873| 200|#define JANET_STACKFRAME_HASENV (INT32_MIN) ------------------ | Branch (19694:13): [True: 135, False: 65] ------------------ 19695| 135| frameflags &= ~JANET_STACKFRAME_HASENV; ------------------ | |18873| 135|#define JANET_STACKFRAME_HASENV (INT32_MIN) ------------------ 19696| 135| data = unmarshal_one_env(st, data, &env, flags + 1); 19697| 135| } 19698| | 19699| | /* Error checking */ 19700| 200| int32_t expected_framesize = def->slotcount; 19701| 200| if (expected_framesize != stacktop - stack) { ------------------ | Branch (19701:13): [True: 11, False: 189] ------------------ 19702| 11| janet_panic("fiber stackframe size mismatch"); 19703| 11| } 19704| 189| if (pcdiff >= def->bytecode_length) { ------------------ | Branch (19704:13): [True: 1, False: 188] ------------------ 19705| 1| janet_panic("fiber stackframe has invalid pc"); 19706| 1| } 19707| 188| if ((int32_t)(prevframe + JANET_FRAME_SIZE) > stack) { ------------------ | | 1017| 188|#define JANET_FRAME_SIZE 4 ------------------ | Branch (19707:13): [True: 2, False: 186] ------------------ 19708| 2| janet_panic("fiber stackframe does not align with previous frame"); 19709| 2| } 19710| | 19711| | /* Get stack items */ 19712| 186| for (int32_t i = stack; i < stacktop; i++) ------------------ | Branch (19712:33): [True: 0, False: 186] ------------------ 19713| 0| data = unmarshal_one(st, data, fiber->data + i, flags + 1); 19714| | 19715| | /* Set frame */ 19716| 186| framep->env = env; 19717| 186| framep->pc = def->bytecode + pcdiff; 19718| 186| framep->prevframe = prevframe; 19719| 186| framep->flags = frameflags; 19720| 186| framep->func = func; 19721| | 19722| | /* Goto previous frame */ 19723| 186| stacktop = stack - JANET_FRAME_SIZE; ------------------ | | 1017| 186|#define JANET_FRAME_SIZE 4 ------------------ 19724| 186| stack = prevframe; 19725| 186| } 19726| 3.36k| if (stack < 0) { ------------------ | Branch (19726:9): [True: 0, False: 3.36k] ------------------ 19727| 0| janet_panic("fiber has too many stackframes"); 19728| 0| } 19729| | 19730| | /* Check for fiber env */ 19731| 3.36k| if (fiber_flags & JANET_FIBER_FLAG_HASENV) { ------------------ | |18872| 3.36k|#define JANET_FIBER_FLAG_HASENV (1 << 30) ------------------ | Branch (19731:9): [True: 970, False: 2.39k] ------------------ 19732| 970| Janet envv; 19733| 970| fiber_flags &= ~JANET_FIBER_FLAG_HASENV; ------------------ | |18872| 970|#define JANET_FIBER_FLAG_HASENV (1 << 30) ------------------ 19734| 970| data = unmarshal_one(st, data, &envv, flags + 1); 19735| 970| janet_asserttype(envv, JANET_TABLE, st); 19736| 970| fiber_env = janet_unwrap_table(envv); ------------------ | | 856| 970|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 19737| 970| } 19738| | 19739| | /* Check for child fiber */ 19740| 3.36k| if (fiber_flags & JANET_FIBER_FLAG_HASCHILD) { ------------------ | |18871| 3.36k|#define JANET_FIBER_FLAG_HASCHILD (1 << 29) ------------------ | Branch (19740:9): [True: 905, False: 2.45k] ------------------ 19741| 905| Janet fiberv; 19742| 905| fiber_flags &= ~JANET_FIBER_FLAG_HASCHILD; ------------------ | |18871| 905|#define JANET_FIBER_FLAG_HASCHILD (1 << 29) ------------------ 19743| 905| data = unmarshal_one(st, data, &fiberv, flags + 1); 19744| 905| janet_asserttype(fiberv, JANET_FIBER, st); 19745| 905| fiber->child = janet_unwrap_fiber(fiberv); ------------------ | | 854| 905|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 19746| 905| } 19747| | 19748| | /* Get the fiber last value */ 19749| 3.36k| data = unmarshal_one(st, data, &fiber->last_value, flags + 1); 19750| | 19751| | /* We have valid fiber, finally construct remaining fields. */ 19752| 3.36k| fiber->frame = frame; 19753| 3.36k| fiber->flags = fiber_flags; 19754| 3.36k| fiber->stackstart = fiber_stackstart; 19755| 3.36k| fiber->stacktop = fiber_stacktop; 19756| 3.36k| fiber->maxstack = fiber_maxstack; 19757| 3.36k| fiber->env = fiber_env; 19758| | 19759| 3.36k| int status = janet_fiber_status(fiber); 19760| 3.36k| if (status < 0 || status > JANET_STATUS_ALIVE) { ------------------ | Branch (19760:9): [True: 2.38k, False: 971] | Branch (19760:23): [True: 3, False: 968] ------------------ 19761| 3| janet_panic("invalid fiber status"); 19762| 3| } 19763| | 19764| | /* Return data */ 19765| 3.35k| *out = fiber; 19766| 3.35k| return data; 19767| 3.36k|} janet.c:unmarshal_one_def: 19436| 1.77M| int flags) { 19437| 1.77M| MARSH_EOS(st, data); ------------------ | |19260| 1.77M|#define MARSH_EOS(st, data) do { \ | |19261| 1.77M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 10, False: 1.77M] | | ------------------ | |19262| 1.77M|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 1.77M] | | ------------------ ------------------ 19438| 1.77M| if (*data == LB_FUNCDEF_REF) { ------------------ | Branch (19438:9): [True: 12.9k, False: 1.76M] ------------------ 19439| 12.9k| data++; 19440| 12.9k| int32_t index = readint(st, &data); 19441| 12.9k| if (index < 0 || index >= janet_v_count(st->lookup_defs)) ------------------ | | 708| 12.9k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 715| 12.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 12.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (708:34): [True: 12.9k, False: 0] | | ------------------ ------------------ | Branch (19441:13): [True: 11, False: 12.9k] | Branch (19441:26): [True: 50, False: 12.9k] ------------------ 19442| 61| janet_panicf("invalid funcdef reference %d", index); 19443| 12.9k| *out = st->lookup_defs[index]; 19444| 1.76M| } else { 19445| | /* Initialize with values that will not break garbage collection 19446| | * if unmarshalling fails. */ 19447| 1.76M| JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); 19448| 1.76M| def->environments_length = 0; 19449| 1.76M| def->defs_length = 0; 19450| 1.76M| def->constants_length = 0; 19451| 1.76M| def->bytecode_length = 0; 19452| 1.76M| def->name = NULL; 19453| 1.76M| def->source = NULL; 19454| 1.76M| def->closure_bitset = NULL; 19455| 1.76M| def->defs = NULL; 19456| 1.76M| def->environments = NULL; 19457| 1.76M| def->constants = NULL; 19458| 1.76M| def->bytecode = NULL; 19459| 1.76M| def->sourcemap = NULL; 19460| 1.76M| def->symbolmap = NULL; 19461| 1.76M| def->symbolmap_length = 0; 19462| 1.76M| def->named_args_count = 0; 19463| 1.76M| janet_v_push(st->lookup_defs, def); ------------------ | | 706| 1.76M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 1.76M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 1.76M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 1.75M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 1.75M|#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)) | | | | | | ------------------ | | | | | | | | 714| 1.75M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 1.75M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 4.65k, False: 1.75M] | | | | | | | Branch (717:50): [True: 34.0k, False: 1.72M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 38.6k|#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)) | | ------------------ | | | | 715| 1.76M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 1.76M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19464| | 19465| | /* Set default lengths to zero */ 19466| 1.76M| int32_t bytecode_length = 0; 19467| 1.76M| int32_t constants_length = 0; 19468| 1.76M| int32_t environments_length = 0; 19469| 1.76M| int32_t defs_length = 0; 19470| 1.76M| int32_t symbolmap_length = 0; 19471| | 19472| | /* Read flags and other fixed values */ 19473| 1.76M| def->flags = readint(st, &data); 19474| 1.76M| def->slotcount = readnat(st, &data); 19475| 1.76M| def->arity = readnat(st, &data); 19476| 1.76M| def->min_arity = readnat(st, &data); 19477| 1.76M| def->max_arity = readnat(st, &data); 19478| | 19479| | /* Read some lengths */ 19480| 1.76M| constants_length = readnat(st, &data); 19481| 1.76M| bytecode_length = readnat(st, &data); 19482| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS) ------------------ | | 1098| 1.76M|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (19482:13): [True: 9.18k, False: 1.75M] ------------------ 19483| 9.18k| def->named_args_count = readnat(st, &data); 19484| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) ------------------ | | 1094| 1.76M|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (19484:13): [True: 1.62M, False: 134k] ------------------ 19485| 1.62M| environments_length = readnat(st, &data); 19486| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) ------------------ | | 1093| 1.76M|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (19486:13): [True: 228k, False: 1.53M] ------------------ 19487| 228k| defs_length = readnat(st, &data); 19488| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) ------------------ | | 1090| 1.76M|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (19488:13): [True: 1.60M, False: 156k] ------------------ 19489| 1.60M| symbolmap_length = readnat(st, &data); 19490| | 19491| | /* Check name and source (optional) */ 19492| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) { ------------------ | | 1091| 1.76M|#define JANET_FUNCDEF_FLAG_HASNAME 0x80000 ------------------ | Branch (19492:13): [True: 1.61M, False: 146k] ------------------ 19493| 1.61M| Janet x; 19494| 1.61M| data = unmarshal_one(st, data, &x, flags + 1); 19495| 1.61M| janet_asserttype(x, JANET_STRING, st); 19496| 1.61M| def->name = janet_unwrap_string(x); ------------------ | | 858| 1.61M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 19497| 1.61M| } 19498| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) { ------------------ | | 1092| 1.76M|#define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000 ------------------ | Branch (19498:13): [True: 1.62M, False: 134k] ------------------ 19499| 1.62M| Janet x; 19500| 1.62M| data = unmarshal_one(st, data, &x, flags + 1); 19501| 1.62M| janet_asserttype(x, JANET_STRING, st); 19502| 1.62M| def->source = janet_unwrap_string(x); ------------------ | | 858| 1.62M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 19503| 1.62M| } 19504| | 19505| | /* Unmarshal constants */ 19506| 1.76M| if (constants_length) { ------------------ | Branch (19506:13): [True: 1.33M, False: 421k] ------------------ 19507| 1.33M| def->constants = janet_malloc(sizeof(Janet) * constants_length); ------------------ | | 2393| 1.33M|#define janet_malloc(X) malloc((X)) ------------------ 19508| 1.33M| if (!def->constants) { ------------------ | Branch (19508:17): [True: 0, False: 1.33M] ------------------ 19509| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19510| 0| } 19511| 8.67M| for (int32_t i = 0; i < constants_length; i++) ------------------ | Branch (19511:33): [True: 7.33M, False: 1.33M] ------------------ 19512| 7.33M| data = unmarshal_one(st, data, def->constants + i, flags + 1); 19513| 1.33M| } else { 19514| 421k| def->constants = NULL; 19515| 421k| } 19516| 1.76M| def->constants_length = constants_length; 19517| | 19518| | /* Unmarshal symbol map, if needed */ 19519| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) { ------------------ | | 1090| 1.76M|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (19519:13): [True: 1.60M, False: 159k] ------------------ 19520| 1.60M| size_t size = sizeof(JanetSymbolMap) * symbolmap_length; 19521| 1.60M| def->symbolmap = janet_malloc(size); ------------------ | | 2393| 1.60M|#define janet_malloc(X) malloc((X)) ------------------ 19522| 1.60M| if (def->symbolmap == NULL) { ------------------ | Branch (19522:17): [True: 0, False: 1.60M] ------------------ 19523| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19524| 0| } 19525| 19.3M| for (int32_t i = 0; i < symbolmap_length; i++) { ------------------ | Branch (19525:33): [True: 17.7M, False: 1.60M] ------------------ 19526| 17.7M| def->symbolmap[i].birth_pc = (uint32_t) readint(st, &data); 19527| 17.7M| def->symbolmap[i].death_pc = (uint32_t) readint(st, &data); 19528| 17.7M| def->symbolmap[i].slot_index = (uint32_t) readint(st, &data); 19529| 17.7M| Janet value; 19530| 17.7M| data = unmarshal_one(st, data, &value, flags + 1); 19531| 17.7M| if (!janet_checktype(value, JANET_SYMBOL)) { ------------------ | | 801| 17.7M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 17.7M] | | ------------------ | | 802| 17.7M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 17.7M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 17.7M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 17.7M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 17.7M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 17.7M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (19531:21): [True: 20, False: 17.7M] ------------------ 19532| 20| janet_panicf("corrupted symbolmap when unmarshalling debug info, got %v", value); 19533| 20| } 19534| 17.7M| def->symbolmap[i].symbol = janet_unwrap_symbol(value); ------------------ | | 859| 17.7M|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 19535| 17.7M| } 19536| 1.60M| def->symbolmap_length = (uint32_t) symbolmap_length; 19537| 1.60M| } 19538| | 19539| | /* Unmarshal bytecode */ 19540| 1.76M| def->bytecode = janet_malloc(sizeof(uint32_t) * bytecode_length); ------------------ | | 2393| 1.76M|#define janet_malloc(X) malloc((X)) ------------------ 19541| 1.76M| if (!def->bytecode) { ------------------ | Branch (19541:13): [True: 0, False: 1.76M] ------------------ 19542| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19543| 0| } 19544| 1.76M| data = janet_unmarshal_u32s(st, data, def->bytecode, bytecode_length); 19545| 1.76M| def->bytecode_length = bytecode_length; 19546| | 19547| | /* Unmarshal environments */ 19548| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) { ------------------ | | 1094| 1.76M|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (19548:13): [True: 1.62M, False: 136k] ------------------ 19549| 1.62M| def->environments = janet_calloc(1, sizeof(int32_t) * (size_t) environments_length); ------------------ | | 2399| 1.62M|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 19550| 1.62M| if (!def->environments) { ------------------ | Branch (19550:17): [True: 0, False: 1.62M] ------------------ 19551| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19552| 0| } 19553| 2.26M| for (int32_t i = 0; i < environments_length; i++) { ------------------ | Branch (19553:33): [True: 637k, False: 1.62M] ------------------ 19554| 637k| def->environments[i] = readint(st, &data); 19555| 637k| } 19556| 1.62M| } else { 19557| 136k| def->environments = NULL; 19558| 136k| } 19559| 1.76M| def->environments_length = environments_length; 19560| | 19561| | /* Unmarshal sub funcdefs */ 19562| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) { ------------------ | | 1093| 1.76M|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (19562:13): [True: 225k, False: 1.53M] ------------------ 19563| 225k| def->defs = janet_calloc(1, sizeof(JanetFuncDef *) * (size_t) defs_length); ------------------ | | 2399| 225k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 19564| 225k| if (!def->defs) { ------------------ | Branch (19564:17): [True: 0, False: 225k] ------------------ 19565| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19566| 0| } 19567| 730k| for (int32_t i = 0; i < defs_length; i++) { ------------------ | Branch (19567:33): [True: 504k, False: 225k] ------------------ 19568| 504k| data = unmarshal_one_def(st, data, def->defs + i, flags + 1); 19569| 504k| } 19570| 1.53M| } else { 19571| 1.53M| def->defs = NULL; 19572| 1.53M| } 19573| 1.76M| def->defs_length = defs_length; 19574| | 19575| | /* Unmarshal source maps if needed */ 19576| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCEMAP) { ------------------ | | 1095| 1.76M|#define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000 ------------------ | Branch (19576:13): [True: 1.62M, False: 136k] ------------------ 19577| 1.62M| int32_t current = 0; 19578| 1.62M| def->sourcemap = janet_malloc(sizeof(JanetSourceMapping) * (size_t) bytecode_length); ------------------ | | 2393| 1.62M|#define janet_malloc(X) malloc((X)) ------------------ 19579| 1.62M| if (!def->sourcemap) { ------------------ | Branch (19579:17): [True: 0, False: 1.62M] ------------------ 19580| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19581| 0| } 19582| 48.5M| for (int32_t i = 0; i < bytecode_length; i++) { ------------------ | Branch (19582:33): [True: 46.9M, False: 1.62M] ------------------ 19583| 46.9M| current += readint(st, &data); 19584| 46.9M| def->sourcemap[i].line = current; 19585| 46.9M| def->sourcemap[i].column = readint(st, &data); 19586| 46.9M| } 19587| 1.62M| } else { 19588| 136k| def->sourcemap = NULL; 19589| 136k| } 19590| | 19591| | /* Unmarshal closure bitset if needed */ 19592| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASCLOBITSET) { ------------------ | | 1097| 1.76M|#define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000 ------------------ | Branch (19592:13): [True: 190k, False: 1.56M] ------------------ 19593| 190k| int32_t n = (def->slotcount + 31) >> 5; 19594| 190k| def->closure_bitset = janet_malloc(sizeof(uint32_t) * (size_t) n); ------------------ | | 2393| 190k|#define janet_malloc(X) malloc((X)) ------------------ 19595| 190k| if (NULL == def->closure_bitset) { ------------------ | Branch (19595:17): [True: 0, False: 190k] ------------------ 19596| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19597| 0| } 19598| 190k| data = janet_unmarshal_u32s(st, data, def->closure_bitset, n); 19599| 190k| } 19600| | 19601| | /* Validate */ 19602| 1.76M| if (janet_verify(def)) ------------------ | Branch (19602:13): [True: 556, False: 1.75M] ------------------ 19603| 556| janet_panic("funcdef has invalid bytecode"); 19604| | 19605| | /* Set def */ 19606| 1.75M| *out = def; 19607| 1.75M| } 19608| 1.77M| return data; 19609| 1.77M|} janet.c:janet_unmarshal_u32s: 19418| 1.93M|static const uint8_t *janet_unmarshal_u32s(UnmarshalState *st, const uint8_t *data, uint32_t *into, int32_t n) { 19419| 50.5M| for (int32_t i = 0; i < n; i++) { ------------------ | Branch (19419:25): [True: 48.5M, False: 1.93M] ------------------ 19420| 48.5M| MARSH_EOS(st, data + 3); ------------------ | |19260| 48.5M|#define MARSH_EOS(st, data) do { \ | |19261| 48.5M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 58, False: 48.5M] | | ------------------ | |19262| 48.5M|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 48.5M] | | ------------------ ------------------ 19421| 48.5M| into[i] = 19422| 48.5M| (uint32_t)(data[0]) | 19423| 48.5M| ((uint32_t)(data[1]) << 8) | 19424| 48.5M| ((uint32_t)(data[2]) << 16) | 19425| 48.5M| ((uint32_t)(data[3]) << 24); 19426| 48.5M| data += 4; 19427| 48.5M| } 19428| 1.93M| return data; 19429| 1.93M|} janet.c:unmarshal_one_env: 19374| 158k| int flags) { 19375| 158k| MARSH_EOS(st, data); ------------------ | |19260| 158k|#define MARSH_EOS(st, data) do { \ | |19261| 158k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19261:9): [True: 9, False: 158k] | | ------------------ | |19262| 158k|} while (0) | | ------------------ | | | Branch (19262:10): [Folded, False: 158k] | | ------------------ ------------------ 19376| 158k| if (*data == LB_FUNCENV_REF) { ------------------ | Branch (19376:9): [True: 112k, False: 45.0k] ------------------ 19377| 112k| data++; 19378| 112k| int32_t index = readint(st, &data); 19379| 112k| if (index < 0 || index >= janet_v_count(st->lookup_envs)) ------------------ | | 708| 112k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 715| 112k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 112k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (708:34): [True: 112k, False: 6] | | ------------------ ------------------ | Branch (19379:13): [True: 15, False: 112k] | Branch (19379:26): [True: 17, False: 112k] ------------------ 19380| 32| janet_panicf("invalid funcenv reference %d", index); 19381| 112k| *out = st->lookup_envs[index]; 19382| 112k| } else { 19383| 45.0k| JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); 19384| 45.0k| env->length = 0; 19385| 45.0k| env->offset = 0; 19386| 45.0k| env->as.values = NULL; 19387| 45.0k| janet_v_push(st->lookup_envs, env); ------------------ | | 706| 45.0k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 718| 45.0k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 717| 45.0k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 715| 41.4k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 713| 41.4k|#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)) | | | | | | ------------------ | | | | | | | | 714| 41.4k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 713| 41.4k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (717:35): [True: 3.58k, False: 41.4k] | | | | | | | Branch (717:50): [True: 13.8k, False: 27.6k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 719| 17.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)) | | ------------------ | | | | 715| 45.0k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 713| 45.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19388| 45.0k| int32_t offset = readnat(st, &data); 19389| 45.0k| int32_t length = readnat(st, &data); 19390| 45.0k| if (offset > 0) { ------------------ | Branch (19390:13): [True: 304, False: 44.7k] ------------------ 19391| 304| Janet fiberv; 19392| | /* On stack variant */ 19393| 304| data = unmarshal_one(st, data, &fiberv, flags); 19394| 304| janet_asserttype(fiberv, JANET_FIBER, st); 19395| 304| env->as.fiber = janet_unwrap_fiber(fiberv); ------------------ | | 854| 304|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 19396| | /* Negative offset indicates untrusted input */ 19397| 304| env->offset = -offset; 19398| 44.7k| } else { 19399| | /* Off stack variant */ 19400| 44.7k| if (length == 0) { ------------------ | Branch (19400:17): [True: 8, False: 44.7k] ------------------ 19401| 8| janet_panic("invalid funcenv length"); 19402| 8| } 19403| 44.7k| env->as.values = janet_malloc(sizeof(Janet) * (size_t) length); ------------------ | | 2393| 44.7k|#define janet_malloc(X) malloc((X)) ------------------ 19404| 44.7k| if (!env->as.values) { ------------------ | Branch (19404:17): [True: 0, False: 44.7k] ------------------ 19405| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 19406| 0| } 19407| 44.7k| env->offset = 0; 19408| 768k| for (int32_t i = 0; i < length; i++) ------------------ | Branch (19408:33): [True: 723k, False: 44.7k] ------------------ 19409| 723k| data = unmarshal_one(st, data, env->as.values + i, flags); 19410| 44.7k| } 19411| 45.0k| env->length = length; 19412| 45.0k| *out = env; 19413| 45.0k| } 19414| 158k| return data; 19415| 158k|} janet.c:unmarshal_one_abstract: 19851| 15.2k|static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *data, Janet *out, int flags) { 19852| 15.2k| Janet key; 19853| 15.2k| data = unmarshal_one(st, data, &key, flags + 1); 19854| 15.2k| const JanetAbstractType *at = janet_get_abstract_type(key); 19855| 15.2k| if (at == NULL) janet_panic("unknown abstract type"); ------------------ | Branch (19855:9): [True: 15, False: 15.2k] ------------------ 19856| 15.2k| if (at->unmarshal) { ------------------ | Branch (19856:9): [True: 0, False: 15.2k] ------------------ 19857| 0| JanetMarshalContext context = {NULL, st, flags, data, at}; 19858| 0| void *abst = at->unmarshal(&context); 19859| 0| janet_assert(abst != NULL, "null pointer abstract"); ------------------ | | 386| 0|#define janet_assert(c, m) do { \ | | 387| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 375| 0|#define JANET_EXIT(m) do { \ | | | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 377| 0| __FILE__,\ | | | | 378| 0| __LINE__,\ | | | | 379| 0| (m));\ | | | | 380| 0| abort();\ | | | | 381| 0|} while (0) | | | | ------------------ | | | | | Branch (381:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (387:9): [True: 0, False: 0] | | ------------------ | | 388| 0|} while (0) | | ------------------ | | | Branch (388:10): [Folded, False: 0] | | ------------------ ------------------ 19860| 0| *out = janet_wrap_abstract(abst); ------------------ | | 846| 0|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 820| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19861| 0| if (context.at != NULL) { ------------------ | Branch (19861:13): [True: 0, False: 0] ------------------ 19862| 0| janet_panic("janet_unmarshal_abstract not called"); 19863| 0| } 19864| 0| return context.data; 19865| 0| } 19866| 15.2k| janet_panic("invalid abstract type - no unmarshal function pointer"); 19867| 15.2k|} janet.c:janet_asserttype: 19336| 3.26M|static void janet_asserttype(Janet x, JanetType t, UnmarshalState *st) { 19337| 3.26M| if (!janet_checktype(x, t)) { ------------------ | | 801| 3.26M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [True: 0, False: 3.26M] | | ------------------ | | 802| 3.26M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 3.26M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 3.26M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 3.26M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 3.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 3.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (19337:9): [True: 405, False: 3.26M] ------------------ 19338| |#ifdef JANET_MARSHAL_DEBUG 19339| | dump_reference_table(st); 19340| |#else 19341| 405| (void) st; 19342| 405|#endif 19343| 405| janet_panicf("expected type %T, got %v", 1 << t, x); 19344| 405| } 19345| 3.26M|} janet.c:number_to_string_b: 28574| 238|static void number_to_string_b(JanetBuffer *buffer, double x) { 28575| 238| janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2); ------------------ | |28568| 238|#define BUFSIZE 64 ------------------ 28576| 238| const char *fmt = (x == floor(x) && ------------------ | Branch (28576:24): [True: 222, False: 16] ------------------ 28577| 222| x <= JANET_INTMAX_DOUBLE && ------------------ | | 160| 460|#define JANET_INTMAX_DOUBLE 9007199254740992.0 ------------------ | Branch (28577:24): [True: 218, False: 4] ------------------ 28578| 218| x >= JANET_INTMIN_DOUBLE) ? "%.0f" : ("%." STR(DBL_DIG) "g"); ------------------ | | 161| 218|#define JANET_INTMIN_DOUBLE (-9007199254740992.0) ------------------ | Branch (28578:24): [True: 155, False: 63] ------------------ 28579| 238| int count; 28580| 238| if (x == 0.0) { ------------------ | Branch (28580:9): [True: 40, False: 198] ------------------ 28581| | /* Prevent printing of '-0' */ 28582| 40| count = 1; 28583| 40| buffer->data[buffer->count] = '0'; 28584| 198| } else { 28585| 198| count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, fmt, x); ------------------ | |28568| 198|#define BUFSIZE 64 ------------------ 28586| 198| } 28587| 238| buffer->count += count; 28588| 238|} janet.c:string_description_b: 28634| 24|static void string_description_b(JanetBuffer *buffer, const char *title, void *pointer) { 28635| 24| janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2); ------------------ | |28568| 24|#define BUFSIZE 64 ------------------ 28636| 24| uint8_t *c = buffer->data + buffer->count; 28637| 24| int32_t i; 28638| 24| union { 28639| 24| uint8_t bytes[sizeof(void *)]; 28640| 24| void *p; 28641| 24| } pbuf; 28642| | 28643| 24| pbuf.p = pointer; 28644| 24| *c++ = '<'; 28645| | /* Maximum of 32 bytes for abstract type name */ 28646| 159| for (i = 0; i < 32 && title[i]; ++i) ------------------ | Branch (28646:17): [True: 159, False: 0] | Branch (28646:27): [True: 135, False: 24] ------------------ 28647| 135| *c++ = ((uint8_t *)title) [i]; 28648| 24| *c++ = ' '; 28649| 24| *c++ = '0'; 28650| 24| *c++ = 'x'; 28651| 24|#if defined(JANET_64) 28652| 24|#define POINTSIZE 6 28653| |#else 28654| |#define POINTSIZE (sizeof(void *)) 28655| |#endif 28656| 168| for (i = POINTSIZE; i > 0; --i) { ------------------ | |28652| 24|#define POINTSIZE 6 ------------------ | Branch (28656:25): [True: 144, False: 24] ------------------ 28657| 144| uint8_t byte = pbuf.bytes[i - 1]; 28658| 144| *c++ = HEX(byte >> 4); ------------------ | |28630| 144|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 28659| 144| *c++ = HEX(byte & 0xF); ------------------ | |28630| 144|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 28660| 144| } 28661| 24| *c++ = '>'; 28662| 24| buffer->count = (int32_t)(c - buffer->data); 28663| 24|#undef POINTSIZE 28664| 24|} janet.c:janet_escape_string_b: 28736| 92|static void janet_escape_string_b(JanetBuffer *buffer, const uint8_t *str) { 28737| | janet_escape_string_impl(buffer, str, janet_string_length(str)); ------------------ | | 1803| 92|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1802| 92|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 28738| 92|} janet.c:janet_escape_string_impl: 28666| 139|static int janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) { 28667| 139| janet_buffer_push_u8(buffer, '"'); 28668| 139| int align = 1; 28669| 92.1k| for (int32_t i = 0; i < len; ++i) { ------------------ | Branch (28669:25): [True: 91.9k, False: 139] ------------------ 28670| 91.9k| uint8_t c = str[i]; 28671| 91.9k| switch (c) { 28672| 594| case '"': ------------------ | Branch (28672:13): [True: 594, False: 91.3k] ------------------ 28673| 594| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\"", 2); 28674| 594| align += 2; 28675| 594| break; 28676| 551| case '\n': ------------------ | Branch (28676:13): [True: 551, False: 91.4k] ------------------ 28677| 551| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\n", 2); 28678| 551| align += 2; 28679| 551| break; 28680| 492| case '\r': ------------------ | Branch (28680:13): [True: 492, False: 91.4k] ------------------ 28681| 492| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\r", 2); 28682| 492| align += 2; 28683| 492| break; 28684| 14.3k| case '\0': ------------------ | Branch (28684:13): [True: 14.3k, False: 77.5k] ------------------ 28685| 14.3k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2); 28686| 14.3k| align += 2; 28687| 14.3k| break; 28688| 399| case '\f': ------------------ | Branch (28688:13): [True: 399, False: 91.5k] ------------------ 28689| 399| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2); 28690| 399| align += 2; 28691| 399| break; 28692| 756| case '\v': ------------------ | Branch (28692:13): [True: 756, False: 91.2k] ------------------ 28693| 756| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2); 28694| 756| align += 2; 28695| 756| break; 28696| 478| case '\a': ------------------ | Branch (28696:13): [True: 478, False: 91.4k] ------------------ 28697| 478| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2); 28698| 478| align += 2; 28699| 478| break; 28700| 2.67k| case '\b': ------------------ | Branch (28700:13): [True: 2.67k, False: 89.2k] ------------------ 28701| 2.67k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2); 28702| 2.67k| align += 2; 28703| 2.67k| break; 28704| 586| case 27: ------------------ | Branch (28704:13): [True: 586, False: 91.3k] ------------------ 28705| 586| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2); 28706| 586| align += 2; 28707| 586| break; 28708| 532| case '\\': ------------------ | Branch (28708:13): [True: 532, False: 91.4k] ------------------ 28709| 532| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2); 28710| 532| align += 2; 28711| 532| break; 28712| 495| case '\t': ------------------ | Branch (28712:13): [True: 495, False: 91.4k] ------------------ 28713| 495| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\t", 2); 28714| 495| align += 2; 28715| 495| break; 28716| 70.0k| default: ------------------ | Branch (28716:13): [True: 70.0k, False: 21.9k] ------------------ 28717| 70.0k| if (c < 32 || c > 126) { ------------------ | Branch (28717:21): [True: 6.06k, False: 63.9k] | Branch (28717:31): [True: 40.5k, False: 23.4k] ------------------ 28718| 46.5k| uint8_t buf[4]; 28719| 46.5k| buf[0] = '\\'; 28720| 46.5k| buf[1] = 'x'; 28721| 46.5k| buf[2] = janet_base64[(c >> 4) & 0xF]; 28722| 46.5k| buf[3] = janet_base64[c & 0xF]; 28723| 46.5k| janet_buffer_push_bytes(buffer, buf, 4); 28724| 46.5k| align += 4; 28725| 46.5k| } else { 28726| 23.4k| janet_buffer_push_u8(buffer, c); 28727| 23.4k| align++; 28728| 23.4k| } 28729| 70.0k| break; 28730| 91.9k| } 28731| 91.9k| } 28732| 139| janet_buffer_push_u8(buffer, '"'); 28733| 139| return align + 1; 28734| 139|} janet.c:janet_escape_buffer_b: 28740| 47|static void janet_escape_buffer_b(JanetBuffer *buffer, JanetBuffer *bx) { 28741| 47| if (bx == buffer) { ------------------ | Branch (28741:9): [True: 0, False: 47] ------------------ 28742| | /* Ensures buffer won't resize while escaping */ 28743| 0| janet_buffer_ensure(bx, bx->count + 5 * bx->count + 3, 1); 28744| 0| } 28745| 47| janet_buffer_push_u8(buffer, '@'); 28746| 47| janet_escape_string_impl(buffer, bx->data, bx->count); 28747| 47|} janet.c:scanformat: 29451| 2.17k| char precision[3]) { 29452| 2.17k| const char *p = strfrmt; 29453| | 29454| | /* Parse strfrmt */ 29455| 2.17k| memset(width, '\0', 3); 29456| 2.17k| memset(precision, '\0', 3); 29457| 2.17k| while (*p != '\0' && strchr(FMT_FLAGS, *p) != NULL) ------------------ | |29417| 2.17k|#define FMT_FLAGS "-+ #0" ------------------ | Branch (29457:12): [True: 2.17k, False: 0] | Branch (29457:26): [True: 0, False: 2.17k] ------------------ 29458| 0| p++; /* skip flags */ 29459| 2.17k| if ((size_t)(p - strfrmt) >= sizeof(FMT_FLAGS)) janet_panic("invalid format (repeated flags)"); ------------------ | |29417| 2.17k|#define FMT_FLAGS "-+ #0" ------------------ | Branch (29459:9): [True: 0, False: 2.17k] ------------------ 29460| 2.17k| if (isdigit((int)(*p))) ------------------ | Branch (29460:9): [True: 0, False: 2.17k] ------------------ 29461| 0| width[0] = *p++; /* skip width */ 29462| 2.17k| if (isdigit((int)(*p))) ------------------ | Branch (29462:9): [True: 0, False: 2.17k] ------------------ 29463| 0| width[1] = *p++; /* (2 digits at most) */ 29464| 2.17k| if (*p == '.') { ------------------ | Branch (29464:9): [True: 0, False: 2.17k] ------------------ 29465| 0| p++; 29466| 0| if (isdigit((int)(*p))) ------------------ | Branch (29466:13): [True: 0, False: 0] ------------------ 29467| 0| precision[0] = *p++; /* skip precision */ 29468| 0| if (isdigit((int)(*p))) ------------------ | Branch (29468:13): [True: 0, False: 0] ------------------ 29469| 0| precision[1] = *p++; /* (2 digits at most) */ 29470| 0| } 29471| 2.17k| if (isdigit((int)(*p))) ------------------ | Branch (29471:9): [True: 0, False: 2.17k] ------------------ 29472| 0| janet_panic("invalid format (width or precision too long)"); 29473| | 29474| | /* Write to form - replace characters with fixed size stuff */ 29475| 2.17k| *(form++) = '%'; 29476| 2.17k| const char *p2 = strfrmt; 29477| 4.34k| while (p2 <= p) { ------------------ | Branch (29477:12): [True: 2.17k, False: 2.17k] ------------------ 29478| 2.17k| char *loc = strchr(FMT_REPLACE_INTTYPES, *p2); ------------------ | |29418| 2.17k|#define FMT_REPLACE_INTTYPES "diouxX" ------------------ 29479| 2.17k| if (loc != NULL && *loc != '\0') { ------------------ | Branch (29479:13): [True: 1.34k, False: 830] | Branch (29479:28): [True: 1.34k, False: 0] ------------------ 29480| 1.34k| const char *mapping = get_fmt_mapping(*p2++); 29481| 1.34k| size_t len = strlen(mapping); 29482| 1.34k| memcpy(form, mapping, len); 29483| 1.34k| form += len; 29484| 1.34k| } else { 29485| 830| *(form++) = *(p2++); 29486| 830| } 29487| 2.17k| } 29488| 2.17k| *form = '\0'; 29489| | 29490| 2.17k| return p; 29491| 2.17k|} janet.c:get_fmt_mapping: 29439| 1.34k|static const char *get_fmt_mapping(char c) { 29440| 5.98k| for (size_t i = 0; i < (sizeof(format_mappings) / sizeof(struct FmtMapping)); i++) { ------------------ | Branch (29440:24): [True: 5.98k, False: 0] ------------------ 29441| 5.98k| if (format_mappings[i].c == c) ------------------ | Branch (29441:13): [True: 1.34k, False: 4.64k] ------------------ 29442| 1.34k| return format_mappings[i].mapping; 29443| 5.98k| } 29444| 0| janet_assert(0, "bad format mapping"); ------------------ | | 386| 0|#define janet_assert(c, m) do { \ | | 387| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 375| 0|#define JANET_EXIT(m) do { \ | | | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 377| 0| __FILE__,\ | | | | 378| 0| __LINE__,\ | | | | 379| 0| (m));\ | | | | 380| 0| abort();\ | | | | 381| 0|} while (0) | | | | ------------------ | | | | | Branch (381:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (387:9): [True: 0, Folded] | | ------------------ | | 388| 0|} while (0) | | ------------------ | | | Branch (388:10): [Folded, False: 0] | | ------------------ ------------------ 29445| 0|} janet.c:pushtypes: 29395| 405|static void pushtypes(JanetBuffer *buffer, int types) { 29396| 405| int first = 1; 29397| 405| int i = 0; 29398| 3.64k| while (types) { ------------------ | Branch (29398:12): [True: 3.24k, False: 405] ------------------ 29399| 3.24k| if (1 & types) { ------------------ | Branch (29399:13): [True: 405, False: 2.83k] ------------------ 29400| 405| if (first) { ------------------ | Branch (29400:17): [True: 405, False: 0] ------------------ 29401| 405| first = 0; 29402| 405| } else { 29403| 0| janet_buffer_push_cstring(buffer, (types == 1) ? " or " : ", "); ------------------ | Branch (29403:51): [True: 0, False: 0] ------------------ 29404| 0| } 29405| 405| janet_buffer_push_cstring(buffer, janet_type_names[i]); 29406| 405| } 29407| 3.24k| i++; 29408| 3.24k| types >>= 1; 29409| 3.24k| } 29410| 405|} janet.c:janet_symcache_findmem: 33082| 23.2M| int *success) { 33083| 23.2M| uint32_t bounds[4]; 33084| 23.2M| uint32_t i, j, index; 33085| 23.2M| const uint8_t **firstEmpty = NULL; 33086| | 33087| | /* We will search two ranges - index to the end, 33088| | * and 0 to the index. */ 33089| 23.2M| index = (uint32_t)hash & (janet_vm.cache_capacity - 1); 33090| 23.2M| bounds[0] = index; 33091| 23.2M| bounds[1] = janet_vm.cache_capacity; 33092| 23.2M| bounds[2] = 0; 33093| 23.2M| bounds[3] = index; 33094| 23.2M| for (j = 0; j < 4; j += 2) ------------------ | Branch (33094:17): [True: 23.2M, False: 0] ------------------ 33095| 34.8M| for (i = bounds[j]; i < bounds[j + 1]; ++i) { ------------------ | Branch (33095:29): [True: 34.8M, False: 3.33k] ------------------ 33096| 34.8M| const uint8_t *test = janet_vm.cache[i]; 33097| | /* Check empty spots */ 33098| 34.8M| if (NULL == test) { ------------------ | Branch (33098:17): [True: 11.6M, False: 23.1M] ------------------ 33099| 11.6M| if (NULL == firstEmpty) ------------------ | Branch (33099:21): [True: 11.6M, False: 0] ------------------ 33100| 11.6M| firstEmpty = janet_vm.cache + i; 33101| 11.6M| goto notfound; 33102| 11.6M| } 33103| | /* Check for marked deleted */ 33104| 23.1M| if (JANET_SYMCACHE_DELETED == test) { ------------------ | Branch (33104:17): [True: 3.21k, False: 23.1M] ------------------ 33105| 3.21k| if (firstEmpty == NULL) ------------------ | Branch (33105:21): [True: 3.19k, False: 22] ------------------ 33106| 3.19k| firstEmpty = janet_vm.cache + i; 33107| 3.21k| continue; 33108| 3.21k| } 33109| 23.1M| if (janet_string_equalconst(test, str, len, hash)) { ------------------ | Branch (33109:17): [True: 11.5M, False: 11.6M] ------------------ 33110| | /* Replace first deleted */ 33111| 11.5M| *success = 1; 33112| 11.5M| if (firstEmpty != NULL) { ------------------ | Branch (33112:21): [True: 3.19k, False: 11.5M] ------------------ 33113| 3.19k| *firstEmpty = test; 33114| 3.19k| janet_vm.cache[i] = JANET_SYMCACHE_DELETED; 33115| 3.19k| return firstEmpty; 33116| 3.19k| } 33117| 11.5M| return janet_vm.cache + i; 33118| 11.5M| } 33119| 23.1M| } 33120| 11.6M|notfound: 33121| 11.6M| *success = 0; 33122| 11.6M| janet_assert(firstEmpty != NULL, "symcache failed to get memory"); ------------------ | | 386| 11.6M|#define janet_assert(c, m) do { \ | | 387| 11.6M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 375| 0|#define JANET_EXIT(m) do { \ | | | | 376| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 377| 0| __FILE__,\ | | | | 378| 0| __LINE__,\ | | | | 379| 0| (m));\ | | | | 380| 0| abort();\ | | | | 381| 0|} while (0) | | | | ------------------ | | | | | Branch (381:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (387:9): [True: 0, False: 11.6M] | | ------------------ | | 388| 11.6M|} while (0) | | ------------------ | | | Branch (388:10): [Folded, False: 11.6M] | | ------------------ ------------------ 33123| 11.6M| return firstEmpty; 33124| 11.6M|} janet.c:janet_symcache_put: 33160| 6.57M|static void janet_symcache_put(const uint8_t *x, const uint8_t **bucket) { 33161| 6.57M| if ((janet_vm.cache_count + janet_vm.cache_deleted) * 2 > janet_vm.cache_capacity) { ------------------ | Branch (33161:9): [True: 6.49k, False: 6.57M] ------------------ 33162| 6.49k| int status; 33163| 6.49k| janet_cache_resize(janet_tablen((2 * janet_vm.cache_count + 1))); 33164| 6.49k| bucket = janet_symcache_find(x, &status); ------------------ | |33127| 6.49k| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1803| 6.49k|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1802| 6.49k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1804| 6.49k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1802| 6.49k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 33165| 6.49k| } 33166| | /* Add x to the cache */ 33167| 6.57M| janet_vm.cache_count++; 33168| 6.57M| *bucket = x; 33169| 6.57M|} janet.c:janet_cache_resize: 33130| 6.49k|static void janet_cache_resize(uint32_t newCapacity) { 33131| 6.49k| uint32_t i, oldCapacity; 33132| 6.49k| const uint8_t **oldCache = janet_vm.cache; 33133| 6.49k| const uint8_t **newCache = janet_calloc(1, (size_t) newCapacity * sizeof(const uint8_t *)); ------------------ | | 2399| 6.49k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 33134| 6.49k| if (newCache == NULL) { ------------------ | Branch (33134:9): [True: 0, False: 6.49k] ------------------ 33135| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 33136| 0| } 33137| 6.49k| oldCapacity = janet_vm.cache_capacity; 33138| 6.49k| janet_vm.cache = newCache; 33139| 6.49k| janet_vm.cache_capacity = newCapacity; 33140| 6.49k| janet_vm.cache_deleted = 0; 33141| | /* Add all of the old cache entries back */ 33142| 10.0M| for (i = 0; i < oldCapacity; ++i) { ------------------ | Branch (33142:17): [True: 10.0M, False: 6.49k] ------------------ 33143| 10.0M| int status; 33144| 10.0M| const uint8_t **bucket; 33145| 10.0M| const uint8_t *x = oldCache[i]; 33146| 10.0M| if (x != NULL && x != JANET_SYMCACHE_DELETED) { ------------------ | Branch (33146:13): [True: 5.05M, False: 5.03M] | Branch (33146:26): [True: 5.05M, False: 0] ------------------ 33147| 5.05M| bucket = janet_symcache_find(x, &status); ------------------ | |33127| 5.05M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1803| 5.05M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1802| 5.05M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1804| 5.05M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1802| 5.05M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 33148| 5.05M| if (status || bucket == NULL) { ------------------ | Branch (33148:17): [True: 0, False: 5.05M] | Branch (33148:27): [True: 0, False: 5.05M] ------------------ 33149| | /* there was a problem with the algorithm. */ 33150| 0| break; 33151| 0| } 33152| 5.05M| *bucket = x; 33153| 5.05M| } 33154| 10.0M| } 33155| | /* Free the old cache */ 33156| 6.49k| janet_free((void *)oldCache); ------------------ | | 2402| 6.49k|#define janet_free(X) free((X)) ------------------ 33157| 6.49k|} janet.c:janet_table_init_impl: 33301| 2.55M|static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) { 33302| 2.55M| JanetKV *data; 33303| 2.55M| capacity = janet_tablen(capacity); 33304| 2.55M| if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK; ------------------ | |33287| 0|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (33304:9): [True: 0, False: 2.55M] ------------------ 33305| 2.55M| if (capacity) { ------------------ | Branch (33305:9): [True: 2.55M, False: 0] ------------------ 33306| 2.55M| if (stackalloc) { ------------------ | Branch (33306:13): [True: 0, False: 2.55M] ------------------ 33307| 0| data = janet_memalloc_empty_local(capacity); 33308| 2.55M| } else { 33309| 2.55M| data = (JanetKV *) janet_memalloc_empty(capacity); 33310| 2.55M| if (NULL == data) { ------------------ | Branch (33310:17): [True: 0, False: 2.55M] ------------------ 33311| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 33312| 0| } 33313| 2.55M| } 33314| 2.55M| table->data = data; 33315| 2.55M| table->capacity = capacity; 33316| 2.55M| } else { 33317| 0| table->data = NULL; 33318| 0| table->capacity = 0; 33319| 0| } 33320| 2.55M| table->count = 0; 33321| 2.55M| table->deleted = 0; 33322| | table->proto = NULL; 33323| 2.55M| return table; 33324| 2.55M|} janet.c:janet_table_rehash: 33374| 1.97M|static void janet_table_rehash(JanetTable *t, int32_t size) { 33375| 1.97M| JanetKV *olddata = t->data; 33376| 1.97M| JanetKV *newdata; 33377| 1.97M| int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK; ------------------ | |33287| 1.97M|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ 33378| 1.97M| if (islocal) { ------------------ | Branch (33378:9): [True: 0, False: 1.97M] ------------------ 33379| 0| newdata = (JanetKV *) janet_memalloc_empty_local(size); 33380| 1.97M| } else { 33381| 1.97M| newdata = (JanetKV *) janet_memalloc_empty(size); 33382| 1.97M| if (NULL == newdata) { ------------------ | Branch (33382:13): [True: 0, False: 1.97M] ------------------ 33383| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 33384| 0| } 33385| 1.97M| } 33386| 1.97M| int32_t oldcapacity = t->capacity; 33387| 1.97M| t->data = newdata; 33388| 1.97M| t->capacity = size; 33389| 1.97M| t->deleted = 0; 33390| 26.5M| for (int32_t i = 0; i < oldcapacity; i++) { ------------------ | Branch (33390:25): [True: 24.6M, False: 1.97M] ------------------ 33391| 24.6M| JanetKV *kv = olddata + i; 33392| 24.6M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 801| 24.6M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (801:6): [Folded, False: 24.6M] | | ------------------ | | 802| 24.6M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 798| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (798:6): [True: 0, False: 0] | | | | | Branch (798:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 803| 24.6M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 795| 24.6M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 785| 24.6M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 788| 24.6M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 24.6M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33392:13): [True: 12.3M, False: 12.3M] ------------------ 33393| 12.3M| JanetKV *newkv = janet_table_find(t, kv->key); 33394| 12.3M| *newkv = *kv; 33395| 12.3M| } 33396| 24.6M| } 33397| 1.97M| if (islocal) { ------------------ | Branch (33397:9): [True: 0, False: 1.97M] ------------------ 33398| 0| janet_sfree(olddata); 33399| 1.97M| } else { 33400| 1.97M| janet_free(olddata); ------------------ | | 2402| 1.97M|#define janet_free(X) free((X)) ------------------ 33401| 1.97M| } 33402| 1.97M|} janet.c:janet_registry_sort: 34351| 2|static void janet_registry_sort(void) { 34352| 704| for (size_t i = 1; i < janet_vm.registry_count; i++) { ------------------ | Branch (34352:24): [True: 702, False: 2] ------------------ 34353| 702| JanetCFunRegistry reg = janet_vm.registry[i]; 34354| 702| size_t j; 34355| 49.4k| for (j = i; j > 0; j--) { ------------------ | Branch (34355:21): [True: 49.4k, False: 6] ------------------ 34356| 49.4k| if ((void *)(janet_vm.registry[j - 1].cfun) < (void *)(reg.cfun)) break; ------------------ | Branch (34356:17): [True: 696, False: 48.7k] ------------------ 34357| 48.7k| janet_vm.registry[j] = janet_vm.registry[j - 1]; 34358| 48.7k| } 34359| 702| janet_vm.registry[j] = reg; 34360| 702| } 34361| 2| janet_vm.registry_dirty = 0; 34362| 2|} janet.c:janet_check_pointer_align: 34452| 1.16M|static void janet_check_pointer_align(void *p) { 34453| 1.16M| (void) p; 34454| |#if defined(JANET_NANBOX_64) && JANET_NANBOX_64_POINTER_SHIFT != 0 34455| | union { 34456| | void *p; 34457| | uintptr_t u; 34458| | } un; 34459| | un.p = p; 34460| | janet_assert(!(un.u & (uintptr_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), 34461| | "unaligned pointer wrap - cfunction pointers and abstract types must be aligned with this nanboxing configuration."); 34462| |#endif 34463| 1.16M|} janet.c:janet_compare_abstract: 35315| 46|static int janet_compare_abstract(JanetAbstract xx, JanetAbstract yy) { 35316| 46| if (xx == yy) return 0; ------------------ | Branch (35316:9): [True: 0, False: 46] ------------------ 35317| 46| const JanetAbstractType *xt = janet_abstract_type(xx); ------------------ | | 1889| 46|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1887| 46|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 35318| 46| const JanetAbstractType *yt = janet_abstract_type(yy); ------------------ | | 1889| 46|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1887| 46|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 35319| 46| if (xt != yt) { ------------------ | Branch (35319:9): [True: 0, False: 46] ------------------ 35320| 0| return xt > yt ? 1 : -1; ------------------ | Branch (35320:16): [True: 0, False: 0] ------------------ 35321| 0| } 35322| 46| if (xt->compare == NULL) { ------------------ | Branch (35322:9): [True: 46, False: 0] ------------------ 35323| 46| return xx > yy ? 1 : -1; ------------------ | Branch (35323:16): [True: 11, False: 35] ------------------ 35324| 46| } 35325| 0| return xt->compare(xx, yy); 35326| 46|} janet.c:push_traversal_node: 35113| 73.7k|static void push_traversal_node(void *lhs, void *rhs, int32_t index2) { 35114| 73.7k| JanetTraversalNode node; 35115| 73.7k| node.self = (JanetGCObject *) lhs; 35116| 73.7k| node.other = (JanetGCObject *) rhs; 35117| 73.7k| node.index = 0; 35118| 73.7k| node.index2 = index2; 35119| 73.7k| int is_new = janet_vm.traversal_base == NULL; 35120| 73.7k| if (is_new || (janet_vm.traversal + 1 >= janet_vm.traversal_top)) { ------------------ | Branch (35120:9): [True: 479, False: 73.2k] | Branch (35120:19): [True: 0, False: 73.2k] ------------------ 35121| 479| size_t oldsize = is_new ? 0 : (janet_vm.traversal - janet_vm.traversal_base); ------------------ | Branch (35121:26): [True: 479, False: 0] ------------------ 35122| 479| size_t newsize = 2 * oldsize + 1; 35123| 479| if (newsize < 128) { ------------------ | Branch (35123:13): [True: 479, False: 0] ------------------ 35124| 479| newsize = 128; 35125| 479| } 35126| 479| JanetTraversalNode *tn = janet_realloc(janet_vm.traversal_base, newsize * sizeof(JanetTraversalNode)); ------------------ | | 2396| 479|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 35127| 479| if (tn == NULL) { ------------------ | Branch (35127:13): [True: 0, False: 479] ------------------ 35128| 0| JANET_OUT_OF_MEMORY; ------------------ | | 414| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (414:122): [Folded, False: 0] | | ------------------ ------------------ 35129| 0| } 35130| 479| janet_vm.traversal_base = tn; 35131| 479| janet_vm.traversal_top = janet_vm.traversal_base + newsize; 35132| 479| janet_vm.traversal = janet_vm.traversal_base + oldsize; 35133| 479| } 35134| 73.7k| *(++janet_vm.traversal) = node; 35135| 73.7k|} janet.c:traversal_next: 35145| 4.35M|static int traversal_next(Janet *x, Janet *y) { 35146| 4.35M| JanetTraversalNode *t = janet_vm.traversal; 35147| 4.42M| while (t && t > janet_vm.traversal_base) { ------------------ | Branch (35147:12): [True: 710k, False: 3.71M] | Branch (35147:17): [True: 237k, False: 473k] ------------------ 35148| 237k| JanetGCObject *self = t->self; 35149| 237k| JanetTupleHead *tself = (JanetTupleHead *)self; 35150| 237k| JanetStructHead *sself = (JanetStructHead *)self; 35151| 237k| JanetGCObject *other = t->other; 35152| 237k| JanetTupleHead *tother = (JanetTupleHead *)other; 35153| 237k| JanetStructHead *sother = (JanetStructHead *)other; 35154| 237k| if ((self->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_TUPLE) { ------------------ | | 624| 237k|#define JANET_MEM_TYPEBITS 0xFF ------------------ | Branch (35154:13): [True: 14.8k, False: 222k] ------------------ 35155| | /* Node is a tuple at index t->index */ 35156| 14.8k| if (t->index < tself->length && t->index < tother->length) { ------------------ | Branch (35156:17): [True: 2.72k, False: 12.0k] | Branch (35156:45): [True: 2.72k, False: 0] ------------------ 35157| 2.72k| int32_t index = t->index++; 35158| 2.72k| *x = tself->data[index]; 35159| 2.72k| *y = tother->data[index]; 35160| 2.72k| janet_vm.traversal = t; 35161| 2.72k| return 0; 35162| 2.72k| } 35163| 12.0k| if (t->index2 && tself->length != tother->length) { ------------------ | Branch (35163:17): [True: 7.69k, False: 4.38k] | Branch (35163:30): [True: 0, False: 7.69k] ------------------ 35164| 0| return tself->length > tother->length ? 3 : 1; ------------------ | Branch (35164:24): [True: 0, False: 0] ------------------ 35165| 0| } 35166| 222k| } else { 35167| | /* Node is a struct at index t->index: if t->index2 is true, we should return the values. */ 35168| 222k| if (t->index2) { ------------------ | Branch (35168:17): [True: 80.4k, False: 141k] ------------------ 35169| 80.4k| t->index2 = 0; 35170| 80.4k| int32_t index = t->index++; 35171| 80.4k| *x = sself->data[index].value; 35172| 80.4k| *y = sother->data[index].value; 35173| 80.4k| janet_vm.traversal = t; 35174| 80.4k| return 0; 35175| 80.4k| } 35176| 141k| for (int32_t i = t->index; i < sself->capacity; i++) { ------------------ | Branch (35176:40): [True: 80.4k, False: 61.4k] ------------------ 35177| 80.4k| t->index2 = 1; 35178| 80.4k| *x = sself->data[t->index].key; 35179| 80.4k| *y = sother->data[t->index].key; 35180| 80.4k| janet_vm.traversal = t; 35181| 80.4k| return 0; 35182| 80.4k| } 35183| | /* Traverse prototype */ 35184| 61.4k| JanetStruct sproto = sself->proto; 35185| 61.4k| JanetStruct oproto = sother->proto; 35186| 61.4k| if (sproto && !oproto) return 3; ------------------ | Branch (35186:17): [True: 2.68k, False: 58.7k] | Branch (35186:27): [True: 0, False: 2.68k] ------------------ 35187| 61.4k| if (!sproto && oproto) return 1; ------------------ | Branch (35187:17): [True: 58.7k, False: 2.68k] | Branch (35187:28): [True: 0, False: 58.7k] ------------------ 35188| 61.4k| if (oproto && sproto) { ------------------ | Branch (35188:17): [True: 2.68k, False: 58.7k] | Branch (35188:27): [True: 2.68k, False: 0] ------------------ 35189| 2.68k| *x = janet_wrap_struct(sproto); ------------------ | | 837| 2.68k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 823| 2.68k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 2.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 2.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35190| 2.68k| *y = janet_wrap_struct(oproto); ------------------ | | 837| 2.68k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 823| 2.68k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 788| 2.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 787| 2.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35191| 2.68k| janet_vm.traversal = t - 1; 35192| 2.68k| return 0; 35193| 2.68k| } 35194| 61.4k| } 35195| 70.8k| t--; 35196| 70.8k| } 35197| 4.19M| janet_vm.traversal = t; 35198| 4.19M| return 2; 35199| 4.35M|} janet.c:murmur64: 35378| 15.2M|static uint64_t murmur64(uint64_t h) { 35379| 15.2M| h ^= h >> 33; 35380| 15.2M| h *= 0xff51afd7ed558ccdUL; 35381| 15.2M| h ^= h >> 33; 35382| 15.2M| h *= 0xc4ceb9fe1a85ec53UL; 35383| 15.2M| h ^= h >> 33; 35384| 15.2M| return h; 35385| 15.2M|} LLVMFuzzerTestOneInput: 9| 3.22k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 10| | 11| | /* init Janet */ 12| 3.22k| janet_init(); 13| | 14| | /* fuzz the binary unmarshal (deserialization) path in src/core/marsh.c */ 15| 3.22k| JanetTable *reg = janet_env_lookup(janet_core_env(NULL)); 16| 3.22k| JanetTryState tstate; 17| 3.22k| if (janet_try(&tstate) == JANET_SIGNAL_OK) { ------------------ | | 1971| 3.22k|#define janet_try(state) (janet_try_init(state), (JanetSignal) setjmp((state)->buf)) ------------------ | Branch (17:9): [True: 3.22k, False: 0] ------------------ 18| 3.22k| const uint8_t *next = NULL; 19| 3.22k| janet_unmarshal(data, size, 0, reg, &next); 20| 3.22k| } 21| 3.22k| janet_restore(&tstate); 22| | 23| | /* cleanup Janet */ 24| 3.22k| janet_deinit(); 25| | 26| 3.22k| return 0; 27| 3.22k|}