janet_abstract_begin: 1338| 9.68k|void *janet_abstract_begin(const JanetAbstractType *atype, size_t size) { 1339| 9.68k| JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_NONE, 1340| 9.68k| sizeof(JanetAbstractHead) + size); 1341| 9.68k| header->size = size; 1342| 9.68k| header->type = atype; 1343| 9.68k| return (void *) & (header->data); 1344| 9.68k|} janet_abstract_end: 1346| 9.68k|void *janet_abstract_end(void *x) { 1347| 9.68k| janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_ABSTRACT); ------------------ | | 634| 9.68k|#define janet_gc_settype(m, t) ((janet_gc_header(m)->flags |= (0xFF & (t)))) | | ------------------ | | | | 628| 9.68k|#define janet_gc_header(mem) ((JanetGCObject *)(mem)) | | ------------------ ------------------ 1348| 9.68k| return x; 1349| 9.68k|} janet_abstract: 1351| 9.68k|void *janet_abstract(const JanetAbstractType *atype, size_t size) { 1352| 9.68k| return janet_abstract_end(janet_abstract_begin(atype, size)); 1353| 9.68k|} janet_array: 1570| 19.3k|JanetArray *janet_array(int32_t capacity) { 1571| 19.3k| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); 1572| 19.3k| janet_array_impl(array, capacity); 1573| 19.3k| return array; 1574| 19.3k|} janet_array_weak: 1577| 13.8k|JanetArray *janet_array_weak(int32_t capacity) { 1578| 13.8k| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY_WEAK, sizeof(JanetArray)); 1579| 13.8k| janet_array_impl(array, capacity); 1580| 13.8k| return array; 1581| 13.8k|} janet_lib_array: 1919| 3.22k|void janet_lib_array(JanetTable *env) { 1920| 3.22k| JanetRegExt array_cfuns[] = { 1921| 3.22k| JANET_CORE_REG("array/new", cfun_array_new), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1922| 3.22k| JANET_CORE_REG("array/weak", cfun_array_weak), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1923| 3.22k| JANET_CORE_REG("array/new-filled", cfun_array_new_filled), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1924| 3.22k| JANET_CORE_REG("array/fill", cfun_array_fill), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1925| 3.22k| JANET_CORE_REG("array/pop", cfun_array_pop), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1926| 3.22k| JANET_CORE_REG("array/peek", cfun_array_peek), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1927| 3.22k| JANET_CORE_REG("array/push", cfun_array_push), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1928| 3.22k| JANET_CORE_REG("array/ensure", cfun_array_ensure), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1929| 3.22k| JANET_CORE_REG("array/slice", cfun_array_slice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1930| 3.22k| JANET_CORE_REG("array/concat", cfun_array_concat), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1931| 3.22k| JANET_CORE_REG("array/insert", cfun_array_insert), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1932| 3.22k| JANET_CORE_REG("array/remove", cfun_array_remove), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1933| 3.22k| JANET_CORE_REG("array/trim", cfun_array_trim), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1934| 3.22k| JANET_CORE_REG("array/clear", cfun_array_clear), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1935| 3.22k| JANET_CORE_REG("array/join", cfun_array_join), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1936| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 1937| 3.22k| }; 1938| | janet_core_cfuns_ext(env, NULL, array_cfuns); 1939| 3.22k|} janet_lib_asm: 3069| 3.22k|void janet_lib_asm(JanetTable *env) { 3070| 3.22k| JanetRegExt asm_cfuns[] = { 3071| 3.22k| JANET_CORE_REG("asm", cfun_asm), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3072| 3.22k| JANET_CORE_REG("disasm", cfun_disasm), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3073| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3074| 3.22k| }; 3075| | janet_core_cfuns_ext(env, NULL, asm_cfuns); 3076| 3.22k|} janet_buffer_init: 3137| 1.27k|JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) { 3138| 1.27k| janet_buffer_init_impl(buffer, capacity); 3139| 1.27k| buffer->gc.data.next = NULL; 3140| 1.27k| buffer->gc.flags = JANET_MEM_DISABLED; ------------------ | | 632| 1.27k|#define JANET_MEM_DISABLED 0x200 ------------------ 3141| 1.27k| return buffer; 3142| 1.27k|} janet_buffer_deinit: 3157| 6.03k|void janet_buffer_deinit(JanetBuffer *buffer) { 3158| 6.03k| if (!(buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) { ------------------ | | 1779| 6.03k|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3158:9): [True: 6.03k, False: 0] ------------------ 3159| 6.03k| janet_free(buffer->data); ------------------ | | 2415| 6.03k|#define janet_free(X) free((X)) ------------------ 3160| | buffer->data = NULL; 3161| 6.03k| } 3162| 6.03k|} janet_buffer: 3165| 4.76k|JanetBuffer *janet_buffer(int32_t capacity) { 3166| 4.76k| JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer)); 3167| 4.76k| return janet_buffer_init_impl(buffer, capacity); 3168| 4.76k|} janet_buffer_ensure: 3171| 262|void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth) { 3172| 262| uint8_t *new_data; 3173| 262| uint8_t *old = buffer->data; 3174| 262| if (capacity <= buffer->capacity) return; ------------------ | Branch (3174:9): [True: 0, False: 262] ------------------ 3175| 262| janet_buffer_can_realloc(buffer); 3176| 262| int64_t big_capacity = ((int64_t) capacity) * growth; 3177| 262| capacity = big_capacity > INT32_MAX ? INT32_MAX : (int32_t) big_capacity; ------------------ | Branch (3177:16): [True: 0, False: 262] ------------------ 3178| 262| janet_gcpressure(capacity - buffer->capacity); 3179| 262| new_data = janet_realloc(old, (size_t) capacity * sizeof(uint8_t)); ------------------ | | 2409| 262|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 3180| 262| if (NULL == new_data) { ------------------ | Branch (3180:9): [True: 0, False: 262] ------------------ 3181| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 3182| 0| } 3183| 262| buffer->data = new_data; 3184| 262| buffer->capacity = capacity; 3185| 262|} janet_buffer_extra: 3201| 127k|void janet_buffer_extra(JanetBuffer *buffer, int32_t n) { 3202| | /* Check for buffer overflow */ 3203| 127k| if ((int64_t)n + buffer->count > INT32_MAX) { ------------------ | Branch (3203:9): [True: 0, False: 127k] ------------------ 3204| 0| janet_panic("buffer overflow"); 3205| 0| } 3206| 127k| int32_t new_size = buffer->count + n; 3207| 127k| if (new_size > buffer->capacity) { ------------------ | Branch (3207:9): [True: 1.52k, False: 125k] ------------------ 3208| 1.52k| janet_buffer_can_realloc(buffer); 3209| 1.52k| int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2); ------------------ | Branch (3209:32): [True: 0, False: 1.52k] ------------------ 3210| 1.52k| uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t)); ------------------ | | 2409| 1.52k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 3211| 1.52k| janet_gcpressure(new_capacity - buffer->capacity); 3212| 1.52k| if (NULL == new_data) { ------------------ | Branch (3212:13): [True: 0, False: 1.52k] ------------------ 3213| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 3214| 0| } 3215| 1.52k| buffer->data = new_data; 3216| 1.52k| buffer->capacity = new_capacity; 3217| 1.52k| } 3218| 127k|} janet_buffer_push_cstring: 3221| 421|void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) { 3222| 421| int32_t len = (int32_t) strlen(cstring); 3223| 421| janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len); 3224| 421|} janet_buffer_push_bytes: 3227| 70.3k|void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) { 3228| 70.3k| if (0 == length) return; ------------------ | Branch (3228:9): [True: 0, False: 70.3k] ------------------ 3229| 70.3k| janet_buffer_extra(buffer, length); 3230| 70.3k| memcpy(buffer->data + buffer->count, string, length); 3231| 70.3k| buffer->count += length; 3232| 70.3k|} janet_buffer_push_u8: 3239| 57.1k|void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t byte) { 3240| 57.1k| janet_buffer_extra(buffer, 1); 3241| 57.1k| buffer->data[buffer->count] = byte; 3242| 57.1k| buffer->count++; 3243| 57.1k|} janet_lib_buffer: 3758| 3.22k|void janet_lib_buffer(JanetTable *env) { 3759| 3.22k| JanetRegExt buffer_cfuns[] = { 3760| 3.22k| JANET_CORE_REG("buffer/new", cfun_buffer_new), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3761| 3.22k| JANET_CORE_REG("buffer/new-filled", cfun_buffer_new_filled), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3762| 3.22k| JANET_CORE_REG("buffer/from-bytes", cfun_buffer_frombytes), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3763| 3.22k| JANET_CORE_REG("buffer/fill", cfun_buffer_fill), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3764| 3.22k| JANET_CORE_REG("buffer/trim", cfun_buffer_trim), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3765| 3.22k| JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3766| 3.22k| JANET_CORE_REG("buffer/push-word", cfun_buffer_word), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3767| 3.22k| JANET_CORE_REG("buffer/push-string", cfun_buffer_chars), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3768| 3.22k| JANET_CORE_REG("buffer/push-uint16", cfun_buffer_push_uint16), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3769| 3.22k| JANET_CORE_REG("buffer/push-uint32", cfun_buffer_push_uint32), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3770| 3.22k| JANET_CORE_REG("buffer/push-uint64", cfun_buffer_push_uint64), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3771| 3.22k| JANET_CORE_REG("buffer/push-float32", cfun_buffer_push_float32), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3772| 3.22k| JANET_CORE_REG("buffer/push-float64", cfun_buffer_push_float64), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3773| 3.22k| JANET_CORE_REG("buffer/push", cfun_buffer_push), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3774| 3.22k| JANET_CORE_REG("buffer/push-at", cfun_buffer_push_at), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3775| 3.22k| JANET_CORE_REG("buffer/popn", cfun_buffer_popn), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3776| 3.22k| JANET_CORE_REG("buffer/clear", cfun_buffer_clear), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3777| 3.22k| JANET_CORE_REG("buffer/slice", cfun_buffer_slice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3778| 3.22k| JANET_CORE_REG("buffer/bit-set", cfun_buffer_bitset), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3779| 3.22k| JANET_CORE_REG("buffer/bit-clear", cfun_buffer_bitclear), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3780| 3.22k| JANET_CORE_REG("buffer/bit", cfun_buffer_bitget), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3781| 3.22k| JANET_CORE_REG("buffer/bit-toggle", cfun_buffer_bittoggle), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3782| 3.22k| JANET_CORE_REG("buffer/blit", cfun_buffer_blit), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3783| 3.22k| JANET_CORE_REG("buffer/format", cfun_buffer_format), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3784| 3.22k| JANET_CORE_REG("buffer/format-at", cfun_buffer_format_at), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3785| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3786| 3.22k| }; 3787| | janet_core_cfuns_ext(env, NULL, buffer_cfuns); 3788| 3.22k|} janet_verify: 4198| 1.74M|int janet_verify(JanetFuncDef *def) { 4199| 1.74M| int vargs = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG); ------------------ | | 1097| 1.74M|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ 4200| 1.74M| int32_t i; 4201| 1.74M| int32_t maxslot = def->arity + vargs; 4202| 1.74M| int32_t sc = def->slotcount; 4203| | 4204| 1.74M| if (def->environments_length > 256) return 15; ------------------ | Branch (4204:9): [True: 0, False: 1.74M] ------------------ 4205| 1.74M| if (def->bytecode_length == 0) return 1; ------------------ | Branch (4205:9): [True: 16, False: 1.74M] ------------------ 4206| | 4207| 1.74M| if (maxslot > sc) return 2; ------------------ | Branch (4207:9): [True: 32, False: 1.74M] ------------------ 4208| | 4209| | /* Verify each instruction */ 4210| 50.1M| for (i = 0; i < def->bytecode_length; i++) { ------------------ | Branch (4210:17): [True: 48.4M, False: 1.74M] ------------------ 4211| 48.4M| uint32_t instr = def->bytecode[i]; 4212| | /* Check for invalid instructions */ 4213| 48.4M| if ((instr & 0x7F) >= JOP_INSTRUCTION_COUNT) { ------------------ | Branch (4213:13): [True: 52, False: 48.4M] ------------------ 4214| 52| return 3; 4215| 52| } 4216| 48.4M| enum JanetInstructionType type = janet_instructions[instr & 0x7F]; 4217| 48.4M| switch (type) { ------------------ | Branch (4217:17): [True: 48.4M, False: 0] ------------------ 4218| 315k| case JINT_0: ------------------ | Branch (4218:13): [True: 315k, False: 48.1M] ------------------ 4219| 315k| continue; 4220| 9.25M| case JINT_S: { ------------------ | Branch (4220:13): [True: 9.25M, False: 39.1M] ------------------ 4221| 9.25M| if ((int32_t)(instr >> 8) >= sc) return 4; ------------------ | Branch (4221:21): [True: 47, False: 9.25M] ------------------ 4222| 9.25M| continue; 4223| 9.25M| } 4224| 9.25M| case JINT_SI: ------------------ | Branch (4224:13): [True: 1.09M, False: 47.3M] ------------------ 4225| 1.09M| case JINT_SU: ------------------ | Branch (4225:13): [True: 0, False: 48.4M] ------------------ 4226| 1.09M| case JINT_ST: { ------------------ | Branch (4226:13): [True: 4.75k, False: 48.4M] ------------------ 4227| 1.09M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4227:21): [True: 3, False: 1.09M] ------------------ 4228| 1.09M| continue; 4229| 1.09M| } 4230| 2.21M| case JINT_L: { ------------------ | Branch (4230:13): [True: 2.21M, False: 46.2M] ------------------ 4231| 2.21M| int32_t jumpdest = i + (((int32_t)instr) >> 8); 4232| 2.21M| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (4232:21): [True: 10, False: 2.21M] | Branch (4232:37): [True: 5, False: 2.21M] ------------------ 4233| 2.21M| continue; 4234| 2.21M| } 4235| 13.1M| case JINT_SS: { ------------------ | Branch (4235:13): [True: 13.1M, False: 35.2M] ------------------ 4236| 13.1M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (4236:21): [True: 8, False: 13.1M] ------------------ 4237| 13.1M| (int32_t)(instr >> 16) >= sc) return 4; ------------------ | Branch (4237:25): [True: 21, False: 13.1M] ------------------ 4238| 13.1M| continue; 4239| 13.1M| } 4240| 13.1M| case JINT_SSI: ------------------ | Branch (4240:13): [True: 840k, False: 47.6M] ------------------ 4241| 1.34M| case JINT_SSU: { ------------------ | Branch (4241:13): [True: 504k, False: 47.9M] ------------------ 4242| 1.34M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (4242:21): [True: 10, False: 1.34M] ------------------ 4243| 1.34M| (int32_t)((instr >> 16) & 0xFF) >= sc) return 4; ------------------ | Branch (4243:25): [True: 10, False: 1.34M] ------------------ 4244| 1.34M| continue; 4245| 1.34M| } 4246| 3.48M| case JINT_SL: { ------------------ | Branch (4246:13): [True: 3.48M, False: 44.9M] ------------------ 4247| 3.48M| int32_t jumpdest = i + (((int32_t)instr) >> 16); 4248| 3.48M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4248:21): [True: 7, False: 3.48M] ------------------ 4249| 3.48M| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (4249:21): [True: 29, False: 3.48M] | Branch (4249:37): [True: 37, False: 3.48M] ------------------ 4250| 3.48M| continue; 4251| 3.48M| } 4252| 6.41M| case JINT_SSS: { ------------------ | Branch (4252:13): [True: 6.41M, False: 42.0M] ------------------ 4253| 6.41M| if (((int32_t)(instr >> 8) & 0xFF) >= sc || ------------------ | Branch (4253:21): [True: 11, False: 6.41M] ------------------ 4254| 6.41M| ((int32_t)(instr >> 16) & 0xFF) >= sc || ------------------ | Branch (4254:25): [True: 8, False: 6.41M] ------------------ 4255| 6.41M| ((int32_t)(instr >> 24) & 0xFF) >= sc) return 4; ------------------ | Branch (4255:25): [True: 11, False: 6.41M] ------------------ 4256| 6.41M| continue; 4257| 6.41M| } 4258| 6.41M| case JINT_SD: { ------------------ | Branch (4258:13): [True: 500k, False: 47.9M] ------------------ 4259| 500k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4259:21): [True: 8, False: 500k] ------------------ 4260| 500k| if ((int32_t)(instr >> 16) >= def->defs_length) return 6; ------------------ | Branch (4260:21): [True: 73, False: 500k] ------------------ 4261| 500k| continue; 4262| 500k| } 4263| 8.67M| case JINT_SC: { ------------------ | Branch (4263:13): [True: 8.67M, False: 39.7M] ------------------ 4264| 8.67M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4264:21): [True: 5, False: 8.67M] ------------------ 4265| 8.67M| if ((int32_t)(instr >> 16) >= def->constants_length) return 7; ------------------ | Branch (4265:21): [True: 36, False: 8.67M] ------------------ 4266| 8.67M| continue; 4267| 8.67M| } 4268| 8.67M| case JINT_SES: { ------------------ | Branch (4268:13): [True: 1.96M, False: 46.4M] ------------------ 4269| | /* How can we check the last slot index? We need info parent funcdefs. Resort 4270| | * to runtime checks for now. Maybe invalid upvalue references could be defaulted 4271| | * to nil? (don't commit to this in the long term, though) */ 4272| 1.96M| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (4272:21): [True: 10, False: 1.96M] ------------------ 4273| 1.96M| if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8; ------------------ | Branch (4273:21): [True: 34, False: 1.96M] ------------------ 4274| 1.96M| continue; 4275| 1.96M| } 4276| 48.4M| } 4277| 48.4M| } 4278| | 4279| | /* Verify last instruction is either a jump, return, return-nil, or tailcall. Eventually, 4280| | * some real flow analysis would be ideal, but this should be very effective. Will completely 4281| | * prevent running over the end of bytecode. However, valid functions with dead code will 4282| | * be rejected. */ 4283| 1.74M| { 4284| 1.74M| uint32_t lastop = def->bytecode[def->bytecode_length - 1] & 0xFF; 4285| 1.74M| switch (lastop) { 4286| 73| default: ------------------ | Branch (4286:13): [True: 73, False: 1.74M] ------------------ 4287| 73| return 9; 4288| 1.01M| case JOP_RETURN: ------------------ | Branch (4288:13): [True: 1.01M, False: 725k] ------------------ 4289| 1.18M| case JOP_RETURN_NIL: ------------------ | Branch (4289:13): [True: 161k, False: 1.58M] ------------------ 4290| 1.18M| case JOP_JUMP: ------------------ | Branch (4290:13): [True: 3.17k, False: 1.74M] ------------------ 4291| 1.19M| case JOP_ERROR: ------------------ | Branch (4291:13): [True: 8.60k, False: 1.73M] ------------------ 4292| 1.74M| case JOP_TAILCALL: ------------------ | Branch (4292:13): [True: 551k, False: 1.19M] ------------------ 4293| 1.74M| break; 4294| 1.74M| } 4295| 1.74M| } 4296| | 4297| | /* Verify debug info - slotmapping, etc. */ 4298| 19.4M| for (int32_t i = def->symbolmap_length - 1; i >= 0; i--) { ------------------ | Branch (4298:49): [True: 17.7M, False: 1.74M] ------------------ 4299| 17.7M| JanetSymbolMap jsm = def->symbolmap[i]; 4300| 17.7M| if (jsm.birth_pc == UINT32_MAX) { ------------------ | Branch (4300:13): [True: 8.43M, False: 9.31M] ------------------ 4301| 8.43M| if (jsm.death_pc >= (uint32_t) def->environments_length) { ------------------ | Branch (4301:17): [True: 0, False: 8.43M] ------------------ 4302| 0| return 10; 4303| | /* We should also check jsm.slot_index */ 4304| 0| } 4305| 9.31M| } else { 4306| 9.31M| if (jsm.slot_index >= (uint32_t) def->slotcount) { ------------------ | Branch (4306:17): [True: 0, False: 9.31M] ------------------ 4307| 0| return 11; 4308| 0| } 4309| 9.31M| if (jsm.birth_pc != UINT32_MAX && jsm.birth_pc >= (uint32_t) def->bytecode_length) { ------------------ | Branch (4309:17): [True: 9.31M, False: 0] | Branch (4309:47): [True: 0, False: 9.31M] ------------------ 4310| 0| return 12; 4311| 0| } 4312| 9.31M| if (jsm.death_pc != UINT32_MAX && jsm.death_pc > (uint32_t) def->bytecode_length) { ------------------ | Branch (4312:17): [True: 9.31M, False: 0] | Branch (4312:47): [True: 0, False: 9.31M] ------------------ 4313| 0| return 13; 4314| 0| } 4315| 9.31M| } 4316| 17.7M| if (jsm.symbol == NULL) { ------------------ | Branch (4316:13): [True: 0, False: 17.7M] ------------------ 4317| 0| return 14; 4318| 0| } 4319| 17.7M| } 4320| | 4321| 1.74M| return 0; 4322| 1.74M|} janet_signalv: 4432| 2.99k|void janet_signalv(JanetSignal sig, Janet message) { 4433| 2.99k| if (janet_vm.return_reg != NULL) { ------------------ | Branch (4433:9): [True: 2.99k, False: 0] ------------------ 4434| | /* Should match logic in janet_call for coercing everything not ok to an error (no awaits, yields, etc.) */ 4435| 2.99k| if (janet_vm.coerce_error && sig != JANET_SIGNAL_OK) { ------------------ | Branch (4435:13): [True: 0, False: 2.99k] | Branch (4435:38): [True: 0, False: 0] ------------------ 4436| 0|#ifdef JANET_EV 4437| 0| if (NULL != janet_vm.root_fiber && sig == JANET_SIGNAL_EVENT) { ------------------ | Branch (4437:17): [True: 0, False: 0] | Branch (4437:48): [True: 0, False: 0] ------------------ 4438| 0| janet_vm.root_fiber->sched_id++; 4439| 0| } 4440| 0|#endif 4441| 0| if (sig != JANET_SIGNAL_ERROR) { ------------------ | Branch (4441:17): [True: 0, False: 0] ------------------ 4442| 0| message = janet_wrap_string(janet_formatc("%v coerced from %s to error", message, janet_signal_names[sig])); ------------------ | | 848| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4443| 0| } 4444| 0| sig = JANET_SIGNAL_ERROR; 4445| 0| } 4446| 2.99k| *janet_vm.return_reg = message; 4447| 2.99k| if (NULL != janet_vm.fiber) { ------------------ | Branch (4447:13): [True: 0, False: 2.99k] ------------------ 4448| 0| janet_vm.fiber->flags |= JANET_FIBER_DID_LONGJUMP; ------------------ | | 792| 0|#define JANET_FIBER_DID_LONGJUMP 0x8000000 ------------------ 4449| 0| } 4450| |#if defined(JANET_BSD) || defined(JANET_APPLE) 4451| | _longjmp(*janet_vm.signal_buf, sig); 4452| |#else 4453| 2.99k| longjmp(*janet_vm.signal_buf, sig); 4454| 2.99k|#endif 4455| 2.99k| } else { 4456| 0| const char *str = (const char *)janet_formatc("janet top level signal - %v\n", message); 4457| 0| janet_top_level_signal(str); 4458| 0| } 4459| 2.99k|} janet_panicv: 4461| 2.99k|void janet_panicv(Janet message) { 4462| 2.99k| janet_signalv(JANET_SIGNAL_ERROR, message); 4463| 2.99k|} janet_panicf: 4465| 1.27k|void janet_panicf(const char *format, ...) { 4466| 1.27k| va_list args; 4467| 1.27k| const uint8_t *ret; 4468| 1.27k| JanetBuffer buffer; 4469| 1.27k| int32_t len = 0; 4470| 38.9k| while (format[len]) len++; ------------------ | Branch (4470:12): [True: 37.6k, False: 1.27k] ------------------ 4471| 1.27k| janet_buffer_init(&buffer, len); 4472| 1.27k| va_start(args, format); 4473| 1.27k| janet_formatbv(&buffer, format, args); 4474| | va_end(args); 4475| 1.27k| ret = janet_string(buffer.data, buffer.count); 4476| 1.27k| janet_buffer_deinit(&buffer); 4477| 1.27k| janet_panics(ret); 4478| 1.27k|} janet_panic: 4480| 1.71k|void janet_panic(const char *message) { 4481| 1.71k| janet_panicv(janet_cstringv(message)); ------------------ | | 1825| 1.71k|#define janet_cstringv(cstr) janet_wrap_string(janet_cstring(cstr)) | | ------------------ | | | | 848| 1.71k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 1.71k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.71k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.71k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4482| 1.71k|} janet_panics: 4484| 1.27k|void janet_panics(const uint8_t *message) { 4485| 1.27k| janet_panicv(janet_wrap_string(message)); ------------------ | | 848| 1.27k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 1.27k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.27k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.27k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4486| 1.27k|} janet_lib_compile: 6707| 3.22k|void janet_lib_compile(JanetTable *env) { 6708| 3.22k| JanetRegExt cfuns[] = { 6709| 3.22k| JANET_CORE_REG("compile", cfun_compile), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 6710| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 6711| 3.22k| }; 6712| | janet_core_cfuns_ext(env, NULL, cfuns); 6713| 3.22k|} janet_core_env: 8092| 3.22k|JanetTable *janet_core_env(JanetTable *replacements) { 8093| | /* Memoize core env, ignoring replacements the second time around. */ 8094| 3.22k| if (NULL != janet_vm.core_env) { ------------------ | Branch (8094:9): [True: 0, False: 3.22k] ------------------ 8095| 0| return janet_vm.core_env; 8096| 0| } 8097| | 8098| 3.22k| JanetTable *dict = janet_core_lookup_table(replacements); 8099| | 8100| | /* Unmarshal bytecode */ 8101| 3.22k| Janet marsh_out = janet_unmarshal( 8102| 3.22k| janet_core_image, 8103| 3.22k| janet_core_image_size, 8104| 3.22k| 0, 8105| 3.22k| dict, 8106| 3.22k| NULL); 8107| | 8108| | /* Memoize */ 8109| 3.22k| janet_gcroot(marsh_out); 8110| 3.22k| JanetTable *env = janet_unwrap_table(marsh_out); ------------------ | | 861| 3.22k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 8111| 3.22k| janet_vm.core_env = env; 8112| | 8113| | /* Invert image dict manually here. We can't do this in boot.janet as it 8114| | * breaks deterministic builds */ 8115| 3.22k| Janet lidv, midv; 8116| 3.22k| lidv = midv = janet_wrap_nil(); ------------------ | | 831| 3.22k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 3.22k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8117| 3.22k| janet_resolve(env, janet_csymbol("load-image-dict"), &lidv); 8118| 3.22k| janet_resolve(env, janet_csymbol("make-image-dict"), &midv); 8119| | 8120| | /* Check that we actually got tables - if we are using a smaller corelib, may not exist */ 8121| 3.22k| if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 806| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 3.22k, False: 0] | | | Branch (806:6): [Folded, False: 3.22k] | | ------------------ | | 807| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.22k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.22k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 806| 3.22k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 3.22k, False: 0] | | | Branch (806:6): [Folded, False: 3.22k] | | ------------------ | | 807| 3.22k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.22k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.22k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.22k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8122| 3.22k| JanetTable *lid = janet_unwrap_table(lidv); ------------------ | | 861| 3.22k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 8123| 3.22k| JanetTable *mid = janet_unwrap_table(midv); ------------------ | | 861| 3.22k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 8124| 6.61M| for (int32_t i = 0; i < lid->capacity; i++) { ------------------ | Branch (8124:29): [True: 6.60M, False: 3.22k] ------------------ 8125| 6.60M| const JanetKV *kv = lid->data + i; 8126| 6.60M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 6.60M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 6.60M] | | ------------------ | | 807| 6.60M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.60M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 6.60M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 6.60M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 6.60M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.60M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (8126:17): [True: 2.12M, False: 4.48M] ------------------ 8127| 2.12M| janet_table_put(mid, kv->value, kv->key); 8128| 2.12M| } 8129| 6.60M| } 8130| 3.22k| } 8131| | 8132| 3.22k| return env; 8133| 3.22k|} janet_core_lookup_table: 8137| 3.22k|JanetTable *janet_core_lookup_table(JanetTable *replacements) { 8138| 3.22k| JanetTable *dict = janet_table(512); 8139| 3.22k| janet_load_libs(dict); 8140| | 8141| | /* Add replacements */ 8142| 3.22k| if (replacements != NULL) { ------------------ | Branch (8142:9): [True: 0, False: 3.22k] ------------------ 8143| 0| for (int32_t i = 0; i < replacements->capacity; i++) { ------------------ | Branch (8143:29): [True: 0, False: 0] ------------------ 8144| 0| JanetKV kv = replacements->data[i]; 8145| 0| if (!janet_checktype(kv.key, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (8145:17): [True: 0, False: 0] ------------------ 8146| 0| janet_table_put(dict, kv.key, kv.value); 8147| | /* Add replacement functions to registry? */ 8148| 0| } 8149| 0| } 8150| 0| } 8151| | 8152| 3.22k| return dict; 8153| 3.22k|} janet_lib_debug: 8603| 3.22k|void janet_lib_debug(JanetTable *env) { 8604| 3.22k| JanetRegExt debug_cfuns[] = { 8605| 3.22k| JANET_CORE_REG("debug/break", cfun_debug_break), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8606| 3.22k| JANET_CORE_REG("debug/unbreak", cfun_debug_unbreak), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8607| 3.22k| JANET_CORE_REG("debug/fbreak", cfun_debug_fbreak), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8608| 3.22k| JANET_CORE_REG("debug/unfbreak", cfun_debug_unfbreak), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8609| 3.22k| JANET_CORE_REG("debug/arg-stack", cfun_debug_argstack), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8610| 3.22k| JANET_CORE_REG("debug/stack", cfun_debug_stack), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8611| 3.22k| JANET_CORE_REG("debug/stacktrace", cfun_debug_stacktrace), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8612| 3.22k| JANET_CORE_REG("debug/lineage", cfun_debug_lineage), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8613| 3.22k| JANET_CORE_REG("debug/step", cfun_debug_step), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8614| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 8615| 3.22k| }; 8616| | janet_core_cfuns_ext(env, NULL, debug_cfuns); 8617| 3.22k|} janet_ev_init_common: 9576| 3.22k|void janet_ev_init_common(void) { 9577| 3.22k| janet_q_init(&janet_vm.spawn); 9578| 3.22k| janet_vm.tq = NULL; 9579| 3.22k| janet_vm.tq_count = 0; 9580| 3.22k| janet_vm.tq_capacity = 0; 9581| 3.22k| janet_table_init_raw(&janet_vm.threaded_abstracts, 0); 9582| 3.22k| janet_table_init_raw(&janet_vm.active_tasks, 0); 9583| 3.22k| janet_table_init_raw(&janet_vm.signal_handlers, 0); 9584| 3.22k| janet_rng_seed(&janet_vm.ev_rng, 0); 9585| 3.22k|#ifndef JANET_WINDOWS 9586| 3.22k| pthread_attr_init(&janet_vm.new_thread_attr); 9587| | pthread_attr_setdetachstate(&janet_vm.new_thread_attr, PTHREAD_CREATE_DETACHED); 9588| 3.22k|#endif 9589| 3.22k|} janet_ev_deinit_common: 9622| 3.22k|void janet_ev_deinit_common(void) { 9623| 3.22k| JanetTimeout to; 9624| 3.22k| while (peek_timeout(&to)) { ------------------ | Branch (9624:12): [True: 0, False: 3.22k] ------------------ 9625| 0| handle_timeout_worker(to, 1); 9626| 0| pop_timeout(0); 9627| 0| } 9628| 3.22k| janet_q_deinit(&janet_vm.spawn); 9629| 3.22k| janet_free(janet_vm.tq); ------------------ | | 2415| 3.22k|#define janet_free(X) free((X)) ------------------ 9630| 3.22k| janet_table_deinit(&janet_vm.threaded_abstracts); 9631| 3.22k| janet_table_deinit(&janet_vm.active_tasks); 9632| 3.22k| janet_table_deinit(&janet_vm.signal_handlers); 9633| 3.22k|#ifndef JANET_WINDOWS 9634| 3.22k| pthread_attr_destroy(&janet_vm.new_thread_attr); 9635| 3.22k|#endif 9636| 3.22k|} janet_ev_init: 10844| 3.22k|void janet_ev_init(void) { 10845| 3.22k| janet_ev_init_common(); 10846| 3.22k| janet_ev_setup_selfpipe(); 10847| 3.22k| janet_vm.epoll = epoll_create1(EPOLL_CLOEXEC); 10848| 3.22k| janet_vm.timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); 10849| 3.22k| janet_vm.timer_enabled = 0; 10850| 3.22k| if (janet_vm.epoll == -1 || janet_vm.timerfd == -1) goto error; ------------------ | Branch (10850:9): [True: 0, False: 3.22k] | Branch (10850:33): [True: 0, False: 3.22k] ------------------ 10851| 3.22k| struct epoll_event ev; 10852| 3.22k| ev.events = EPOLLIN | EPOLLET; 10853| 3.22k| ev.data.ptr = &janet_vm.timerfd; 10854| 3.22k| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.timerfd, &ev)) goto error; ------------------ | Branch (10854:9): [True: 0, False: 3.22k] ------------------ 10855| 3.22k| ev.events = EPOLLIN | EPOLLET; 10856| 3.22k| ev.data.ptr = janet_vm.selfpipe; 10857| 3.22k| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.selfpipe[0], &ev)) goto error; ------------------ | Branch (10857:9): [True: 0, False: 3.22k] ------------------ 10858| 3.22k| return; 10859| 3.22k|error: 10860| | JANET_EXIT("failed to initialize event loop"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 10861| 0|} janet_ev_deinit: 10863| 3.22k|void janet_ev_deinit(void) { 10864| 3.22k| janet_ev_deinit_common(); 10865| 3.22k| close(janet_vm.epoll); 10866| 3.22k| close(janet_vm.timerfd); 10867| 3.22k| janet_ev_cleanup_selfpipe(); 10868| 3.22k| janet_vm.epoll = 0; 10869| 3.22k|} janet_make_pipe: 11966| 3.22k|int janet_make_pipe(JanetHandle handles[2], int mode) { 11967| |#ifdef JANET_WINDOWS 11968| | /* 11969| | * On windows, the built in CreatePipe function doesn't support overlapped IO 11970| | * so we lift from the windows source code and modify for our own version. 11971| | */ 11972| | JanetHandle shandle, chandle; 11973| | CHAR PipeNameBuffer[MAX_PATH]; 11974| | SECURITY_ATTRIBUTES saAttr; 11975| | memset(&saAttr, 0, sizeof(saAttr)); 11976| | saAttr.nLength = sizeof(saAttr); 11977| | saAttr.bInheritHandle = TRUE; 11978| | if (mode == 3) { 11979| | /* No overlapped IO involved, just call CreatePipe */ 11980| | if (!CreatePipe(handles, handles + 1, &saAttr, 0)) return -1; 11981| | return 0; 11982| | } 11983| | snprintf(PipeNameBuffer, 11984| | sizeof(PipeNameBuffer), 11985| | "\\\\.\\Pipe\\JanetPipeFile.%08x.%08x", 11986| | (unsigned int) GetCurrentProcessId(), 11987| | (unsigned int) InterlockedIncrement(&PipeSerialNumber)); 11988| | 11989| | /* server handle goes to subprocess */ 11990| | shandle = CreateNamedPipeA( 11991| | PipeNameBuffer, 11992| | (mode == 2 ? PIPE_ACCESS_INBOUND : PIPE_ACCESS_OUTBOUND) | FILE_FLAG_OVERLAPPED, 11993| | PIPE_TYPE_BYTE | PIPE_WAIT, 11994| | 255, /* Max number of pipes for duplication. */ 11995| | 4096, /* Out buffer size */ 11996| | 4096, /* In buffer size */ 11997| | 120 * 1000, /* Timeout in ms */ 11998| | &saAttr); 11999| | if (shandle == INVALID_HANDLE_VALUE) { 12000| | return -1; 12001| | } 12002| | 12003| | /* we keep client handle */ 12004| | chandle = CreateFileA( 12005| | PipeNameBuffer, 12006| | (mode == 2 ? GENERIC_WRITE : GENERIC_READ), 12007| | 0, 12008| | &saAttr, 12009| | OPEN_EXISTING, 12010| | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 12011| | NULL); 12012| | 12013| | if (chandle == INVALID_HANDLE_VALUE) { 12014| | CloseHandle(shandle); 12015| | return -1; 12016| | } 12017| | if (mode == 2) { 12018| | handles[0] = shandle; 12019| | handles[1] = chandle; 12020| | } else { 12021| | handles[0] = chandle; 12022| | handles[1] = shandle; 12023| | } 12024| | return 0; 12025| |#else 12026| 3.22k| if (pipe(handles)) return -1; ------------------ | Branch (12026:9): [True: 0, False: 3.22k] ------------------ 12027| 3.22k| if (mode != 2 && fcntl(handles[0], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (12027:9): [True: 3.22k, False: 0] | Branch (12027:22): [True: 0, False: 3.22k] ------------------ 12028| 3.22k| if (mode != 1 && fcntl(handles[1], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (12028:9): [True: 0, False: 3.22k] | Branch (12028:22): [True: 0, False: 0] ------------------ 12029| 3.22k| if (mode != 2 && mode != 3 && fcntl(handles[0], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (12029:9): [True: 3.22k, False: 0] | Branch (12029:22): [True: 3.22k, False: 0] | Branch (12029:35): [True: 0, False: 3.22k] ------------------ 12030| 3.22k| if (mode != 1 && mode != 3 && fcntl(handles[1], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (12030:9): [True: 0, False: 3.22k] | Branch (12030:22): [True: 0, False: 0] | Branch (12030:35): [True: 0, False: 0] ------------------ 12031| 3.22k| return 0; 12032| 0|error: 12033| 0| close(handles[0]); 12034| 0| close(handles[1]); 12035| 0| return -1; 12036| 3.22k|#endif 12037| 3.22k|} janet_lib_ev: 12619| 3.22k|void janet_lib_ev(JanetTable *env) { 12620| 3.22k| JanetRegExt ev_cfuns_ext[] = { 12621| 3.22k| JANET_CORE_REG("ev/give", cfun_channel_push), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12622| 3.22k| JANET_CORE_REG("ev/take", cfun_channel_pop), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12623| 3.22k| JANET_CORE_REG("ev/full", cfun_channel_full), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12624| 3.22k| JANET_CORE_REG("ev/capacity", cfun_channel_capacity), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12625| 3.22k| JANET_CORE_REG("ev/count", cfun_channel_count), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12626| 3.22k| JANET_CORE_REG("ev/select", cfun_channel_choice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12627| 3.22k| JANET_CORE_REG("ev/rselect", cfun_channel_rchoice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12628| 3.22k| JANET_CORE_REG("ev/chan", cfun_channel_new), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12629| 3.22k| JANET_CORE_REG("ev/thread-chan", cfun_channel_new_threaded), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12630| 3.22k| JANET_CORE_REG("ev/chan-close", cfun_channel_close), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12631| 3.22k| JANET_CORE_REG("ev/go", cfun_ev_go), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12632| 3.22k| JANET_CORE_REG("ev/thread", cfun_ev_thread), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12633| 3.22k| JANET_CORE_REG("ev/give-supervisor", cfun_ev_give_supervisor), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12634| 3.22k| JANET_CORE_REG("ev/sleep", cfun_ev_sleep), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12635| 3.22k| JANET_CORE_REG("ev/deadline", cfun_ev_deadline), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12636| 3.22k| JANET_CORE_REG("ev/cancel", cfun_ev_cancel), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12637| 3.22k| JANET_CORE_REG("ev/close", janet_cfun_stream_close), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12638| 3.22k| JANET_CORE_REG("ev/read", janet_cfun_stream_read), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12639| 3.22k| JANET_CORE_REG("ev/chunk", janet_cfun_stream_chunk), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12640| 3.22k| JANET_CORE_REG("ev/write", janet_cfun_stream_write), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12641| 3.22k| JANET_CORE_REG("ev/lock", janet_cfun_mutex), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12642| 3.22k| JANET_CORE_REG("ev/acquire-lock", janet_cfun_mutex_acquire), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12643| 3.22k| JANET_CORE_REG("ev/release-lock", janet_cfun_mutex_release), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12644| 3.22k| JANET_CORE_REG("ev/rwlock", janet_cfun_rwlock), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12645| 3.22k| JANET_CORE_REG("ev/acquire-rlock", janet_cfun_rwlock_read_lock), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12646| 3.22k| JANET_CORE_REG("ev/acquire-wlock", janet_cfun_rwlock_write_lock), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12647| 3.22k| JANET_CORE_REG("ev/release-rlock", janet_cfun_rwlock_read_release), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12648| 3.22k| JANET_CORE_REG("ev/release-wlock", janet_cfun_rwlock_write_release), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12649| 3.22k| JANET_CORE_REG("ev/to-file", janet_cfun_to_file), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12650| 3.22k| JANET_CORE_REG("ev/all-tasks", janet_cfun_ev_all_tasks), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 12651| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 12652| 3.22k| }; 12653| | 12654| | janet_core_cfuns_ext(env, NULL, ev_cfuns_ext); 12655| 3.22k| janet_register_abstract_type(&janet_stream_type); 12656| 3.22k| janet_register_abstract_type(&janet_channel_type); 12657| 3.22k| janet_register_abstract_type(&janet_mutex_type); 12658| 3.22k| janet_register_abstract_type(&janet_rwlock_type); 12659| 3.22k|} janet_lib_ffi: 14559| 3.22k|void janet_lib_ffi(JanetTable *env) { 14560| 3.22k| JanetRegExt ffi_cfuns[] = { 14561| 3.22k| JANET_CORE_REG("ffi/native", janet_core_raw_native), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14562| 3.22k| JANET_CORE_REG("ffi/lookup", janet_core_native_lookup), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14563| 3.22k| JANET_CORE_REG("ffi/close", janet_core_native_close), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14564| 3.22k| JANET_CORE_REG("ffi/signature", cfun_ffi_signature), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14565| 3.22k| JANET_CORE_REG("ffi/call", cfun_ffi_call), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14566| 3.22k| JANET_CORE_REG("ffi/struct", cfun_ffi_struct), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14567| 3.22k| JANET_CORE_REG("ffi/write", cfun_ffi_buffer_write), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14568| 3.22k| JANET_CORE_REG("ffi/read", cfun_ffi_buffer_read), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14569| 3.22k| JANET_CORE_REG("ffi/size", cfun_ffi_size), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14570| 3.22k| JANET_CORE_REG("ffi/align", cfun_ffi_align), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14571| 3.22k| JANET_CORE_REG("ffi/trampoline", cfun_ffi_get_callback_trampoline), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14572| 3.22k| JANET_CORE_REG("ffi/jitfn", cfun_ffi_jitfn), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14573| 3.22k| JANET_CORE_REG("ffi/malloc", cfun_ffi_malloc), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14574| 3.22k| JANET_CORE_REG("ffi/free", cfun_ffi_free), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14575| 3.22k| JANET_CORE_REG("ffi/pointer-buffer", cfun_ffi_pointer_buffer), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14576| 3.22k| JANET_CORE_REG("ffi/pointer-cfunction", cfun_ffi_pointer_cfunction), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14577| 3.22k| JANET_CORE_REG("ffi/calling-conventions", cfun_ffi_supported_calling_conventions), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14578| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 14579| 3.22k| }; 14580| | janet_core_cfuns_ext(env, NULL, ffi_cfuns); 14581| 3.22k|} janet_fiber_status: 15029| 971|JanetFiberStatus janet_fiber_status(JanetFiber *f) { 15030| 971| return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 785| 971|#define JANET_FIBER_STATUS_MASK 0x3F0000 ------------------ return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 787| 971|#define JANET_FIBER_STATUS_OFFSET 16 ------------------ 15031| 971|} janet_lib_fiber: 15261| 3.22k|void janet_lib_fiber(JanetTable *env) { 15262| 3.22k| JanetRegExt fiber_cfuns[] = { 15263| 3.22k| JANET_CORE_REG("fiber/new", cfun_fiber_new), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15264| 3.22k| JANET_CORE_REG("fiber/status", cfun_fiber_status), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15265| 3.22k| JANET_CORE_REG("fiber/root", cfun_fiber_root), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15266| 3.22k| JANET_CORE_REG("fiber/current", cfun_fiber_current), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15267| 3.22k| JANET_CORE_REG("fiber/maxstack", cfun_fiber_maxstack), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15268| 3.22k| JANET_CORE_REG("fiber/setmaxstack", cfun_fiber_setmaxstack), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15269| 3.22k| JANET_CORE_REG("fiber/getenv", cfun_fiber_getenv), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15270| 3.22k| JANET_CORE_REG("fiber/setenv", cfun_fiber_setenv), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15271| 3.22k| JANET_CORE_REG("fiber/can-resume?", cfun_fiber_can_resume), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15272| 3.22k| JANET_CORE_REG("fiber/last-value", cfun_fiber_last_value), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 15273| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 15274| 3.22k| }; 15275| | janet_core_cfuns_ext(env, NULL, fiber_cfuns); 15276| 3.22k|} janet_lib_filewatch: 16237| 3.22k|void janet_lib_filewatch(JanetTable *env) { 16238| 3.22k| JanetRegExt cfuns[] = { 16239| 3.22k| JANET_CORE_REG("filewatch/new", cfun_filewatch_make), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16240| 3.22k| JANET_CORE_REG("filewatch/add", cfun_filewatch_add), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16241| 3.22k| JANET_CORE_REG("filewatch/remove", cfun_filewatch_remove), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16242| 3.22k| JANET_CORE_REG("filewatch/listen", cfun_filewatch_listen), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16243| 3.22k| JANET_CORE_REG("filewatch/unlisten", cfun_filewatch_unlisten), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16244| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 16245| 3.22k| }; 16246| | janet_core_cfuns_ext(env, NULL, cfuns); 16247| 3.22k|} janet_gcpressure: 16307| 7.82k|void janet_gcpressure(size_t s) { 16308| 7.82k| janet_vm.next_collection += s; 16309| 7.82k|} janet_gcalloc: 16781| 19.9M|void *janet_gcalloc(enum JanetMemoryType type, size_t size) { 16782| 19.9M| JanetGCObject *mem; 16783| | 16784| | /* Make sure everything is inited */ 16785| 19.9M| janet_assert(NULL != janet_vm.cache, "please initialize janet before use"); ------------------ | | 389| 19.9M|#define janet_assert(c, m) do { \ | | 390| 19.9M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 19.9M] | | ------------------ | | 391| 19.9M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 19.9M] | | ------------------ ------------------ 16786| 19.9M| mem = janet_malloc(size); ------------------ | | 2406| 19.9M|#define janet_malloc(X) malloc((X)) ------------------ 16787| | 16788| | /* Check for bad malloc */ 16789| 19.9M| if (NULL == mem) { ------------------ | Branch (16789:9): [True: 0, False: 19.9M] ------------------ 16790| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 16791| 0| } 16792| | 16793| | /* Configure block */ 16794| 19.9M| mem->flags = type; 16795| | 16796| | /* Prepend block to heap list */ 16797| 19.9M| janet_vm.next_collection += size; 16798| 19.9M| if (type < JANET_MEMORY_TABLE_WEAKK) { ------------------ | Branch (16798:9): [True: 19.7M, False: 193k] ------------------ 16799| | /* normal heap */ 16800| 19.7M| mem->data.next = janet_vm.blocks; 16801| 19.7M| janet_vm.blocks = mem; 16802| 19.7M| } else { 16803| | /* weak heap */ 16804| 193k| mem->data.next = janet_vm.weak_blocks; 16805| 193k| janet_vm.weak_blocks = mem; 16806| 193k| } 16807| 19.9M| janet_vm.block_count++; 16808| | 16809| 19.9M| return (void *)mem; 16810| 19.9M|} janet_gcroot: 16868| 6.45k|void janet_gcroot(Janet root) { 16869| 6.45k| size_t newcount = janet_vm.root_count + 1; 16870| 6.45k| if (newcount > janet_vm.root_capacity) { ------------------ | Branch (16870:9): [True: 3.22k, False: 3.22k] ------------------ 16871| 3.22k| size_t newcap = 2 * newcount; 16872| 3.22k| janet_vm.roots = janet_realloc(janet_vm.roots, sizeof(Janet) * newcap); ------------------ | | 2409| 3.22k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 16873| 3.22k| if (NULL == janet_vm.roots) { ------------------ | Branch (16873:13): [True: 0, False: 3.22k] ------------------ 16874| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 16875| 0| } 16876| 3.22k| janet_vm.root_capacity = newcap; 16877| 3.22k| } 16878| 6.45k| janet_vm.roots[janet_vm.root_count] = root; 16879| 6.45k| janet_vm.root_count = newcount; 16880| 6.45k|} janet_clear_memory: 16927| 3.22k|void janet_clear_memory(void) { 16928| 3.22k|#ifdef JANET_EV 16929| 3.22k| JanetKV *items = janet_vm.threaded_abstracts.data; 16930| 6.45k| for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) { ------------------ | Branch (16930:25): [True: 3.22k, False: 3.22k] ------------------ 16931| 3.22k| if (janet_checktype(items[i].key, JANET_ABSTRACT)) { ------------------ | | 806| 3.22k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 3.22k] | | | Branch (806:6): [Folded, False: 3.22k] | | ------------------ | | 807| 3.22k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.22k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.22k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.22k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16932| 0| void *abst = janet_unwrap_abstract(items[i].key); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 16933| 0| JanetAbstractHead *head = janet_abstract_head(abst); ------------------ | | 1896| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) ------------------ 16934| 0| if (head->type->gcperthread) { ------------------ | Branch (16934:17): [True: 0, False: 0] ------------------ 16935| 0| janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 16936| 0| } 16937| 0| janet_abstract_decref_maybe_free(abst); 16938| 0| } 16939| 3.22k| } 16940| 3.22k|#endif 16941| 3.22k| JanetGCObject *current = janet_vm.blocks; 16942| 19.7M| while (NULL != current) { ------------------ | Branch (16942:12): [True: 19.7M, False: 3.22k] ------------------ 16943| 19.7M| janet_deinit_block(current); 16944| 19.7M| JanetGCObject *next = current->data.next; 16945| 19.7M| janet_free(current); ------------------ | | 2415| 19.7M|#define janet_free(X) free((X)) ------------------ 16946| 19.7M| current = next; 16947| 19.7M| } 16948| 3.22k| janet_vm.blocks = NULL; 16949| 3.22k| janet_free_all_scratch(); 16950| 3.22k| janet_free(janet_vm.scratch_mem); ------------------ | | 2415| 3.22k|#define janet_free(X) free((X)) ------------------ 16951| 3.22k|} janet_smalloc: 16965| 14.6k|void *janet_smalloc(size_t size) { 16966| 14.6k| JanetScratch *s = janet_malloc(sizeof(JanetScratch) + size); ------------------ | | 2406| 14.6k|#define janet_malloc(X) malloc((X)) ------------------ 16967| 14.6k| if (NULL == s) { ------------------ | Branch (16967:9): [True: 0, False: 14.6k] ------------------ 16968| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 16969| 0| } 16970| 14.6k| s->finalize = NULL; 16971| 14.6k| if (janet_vm.scratch_len == janet_vm.scratch_cap) { ------------------ | Branch (16971:9): [True: 6.45k, False: 8.16k] ------------------ 16972| 6.45k| size_t newcap = 2 * janet_vm.scratch_cap + 2; 16973| 6.45k| JanetScratch **newmem = (JanetScratch **) janet_realloc(janet_vm.scratch_mem, newcap * sizeof(JanetScratch)); ------------------ | | 2409| 6.45k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 16974| 6.45k| if (NULL == newmem) { ------------------ | Branch (16974:13): [True: 0, False: 6.45k] ------------------ 16975| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 16976| 0| } 16977| 6.45k| janet_vm.scratch_cap = newcap; 16978| 6.45k| janet_vm.scratch_mem = newmem; 16979| 6.45k| } 16980| 14.6k| janet_vm.scratch_mem[janet_vm.scratch_len++] = s; 16981| 14.6k| return (char *)(s->mem); 16982| 14.6k|} janet_srealloc: 16994| 114k|void *janet_srealloc(void *mem, size_t size) { 16995| 114k| if (NULL == mem) return janet_smalloc(size); ------------------ | Branch (16995:9): [True: 14.6k, False: 99.9k] ------------------ 16996| 99.9k| JanetScratch *s = janet_mem2scratch(mem); 16997| 99.9k| if (janet_vm.scratch_len) { ------------------ | Branch (16997:9): [True: 99.9k, False: 0] ------------------ 16998| 165k| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 16999| 165k| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (16999:17): [True: 99.9k, False: 65.4k] ------------------ 17000| 99.9k| JanetScratch *news = janet_realloc(s, size + sizeof(JanetScratch)); ------------------ | | 2409| 99.9k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 17001| 99.9k| if (NULL == news) { ------------------ | Branch (17001:21): [True: 0, False: 99.9k] ------------------ 17002| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 17003| 0| } 17004| 99.9k| janet_vm.scratch_mem[i] = news; 17005| 99.9k| return (char *)(news->mem); 17006| 99.9k| } 17007| 65.4k| if (i == 0) break; ------------------ | Branch (17007:17): [True: 0, False: 65.4k] ------------------ 17008| 65.4k| } 17009| 99.9k| } 17010| 0| JANET_EXIT("invalid janet_srealloc"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 17011| 0|} janet_sfree: 17018| 9.91k|void janet_sfree(void *mem) { 17019| 9.91k| if (NULL == mem) return; ------------------ | Branch (17019:9): [True: 0, False: 9.91k] ------------------ 17020| 9.91k| JanetScratch *s = janet_mem2scratch(mem); 17021| 9.91k| if (janet_vm.scratch_len) { ------------------ | Branch (17021:9): [True: 9.91k, False: 0] ------------------ 17022| 13.1k| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 17023| 13.1k| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (17023:17): [True: 9.91k, False: 3.22k] ------------------ 17024| 9.91k| janet_vm.scratch_mem[i] = janet_vm.scratch_mem[--janet_vm.scratch_len]; 17025| 9.91k| free_one_scratch(s); 17026| 9.91k| return; 17027| 9.91k| } 17028| 3.22k| if (i == 0) break; ------------------ | Branch (17028:17): [True: 0, False: 3.22k] ------------------ 17029| 3.22k| } 17030| 9.91k| } 17031| 0| JANET_EXIT("invalid janet_sfree"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 17032| 0|} janet_lib_inttypes: 17706| 3.22k|void janet_lib_inttypes(JanetTable *env) { 17707| 3.22k| JanetRegExt it_cfuns[] = { 17708| 3.22k| JANET_CORE_REG("int/s64", cfun_it_s64_new), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17709| 3.22k| JANET_CORE_REG("int/u64", cfun_it_u64_new), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17710| 3.22k| JANET_CORE_REG("int/to-number", cfun_to_number), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17711| 3.22k| JANET_CORE_REG("int/to-bytes", cfun_to_bytes), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17712| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 17713| 3.22k| }; 17714| | janet_core_cfuns_ext(env, NULL, it_cfuns); 17715| 3.22k| janet_register_abstract_type(&janet_s64_type); 17716| 3.22k| janet_register_abstract_type(&janet_u64_type); 17717| 3.22k|} janet_file_close: 18028| 9.68k|int janet_file_close(JanetFile *file) { 18029| 9.68k| int ret = 0; 18030| 9.68k| if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2278| 9.68k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2279| 9.68k|#define JANET_FILE_CLOSED 32 ------------------ | Branch (18030:9): [True: 0, False: 9.68k] ------------------ 18031| 0| ret = fclose(file->file); 18032| 0| file->flags |= JANET_FILE_CLOSED; ------------------ | | 2279| 0|#define JANET_FILE_CLOSED 32 ------------------ 18033| 0| file->file = NULL; /* NULL dereference is easier to debug then other problems */ 18034| 0| return ret; 18035| 0| } 18036| 9.68k| return 0; 18037| 9.68k|} janet_makefile: 18538| 9.68k|Janet janet_makefile(FILE *f, int32_t flags) { 18539| 9.68k| return janet_wrap_abstract(makef(f, flags, BUFSIZ)); ------------------ | | 851| 9.68k|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 9.68k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 9.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18540| 9.68k|} janet_lib_io: 18553| 3.22k|void janet_lib_io(JanetTable *env) { 18554| 3.22k| JanetRegExt io_cfuns[] = { 18555| 3.22k| JANET_CORE_REG("print", cfun_io_print), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18556| 3.22k| JANET_CORE_REG("prin", cfun_io_prin), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18557| 3.22k| JANET_CORE_REG("printf", cfun_io_printf), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18558| 3.22k| JANET_CORE_REG("prinf", cfun_io_prinf), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18559| 3.22k| JANET_CORE_REG("eprin", cfun_io_eprin), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18560| 3.22k| JANET_CORE_REG("eprint", cfun_io_eprint), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18561| 3.22k| JANET_CORE_REG("eprintf", cfun_io_eprintf), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18562| 3.22k| JANET_CORE_REG("eprinf", cfun_io_eprinf), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18563| 3.22k| JANET_CORE_REG("xprint", cfun_io_xprint), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18564| 3.22k| JANET_CORE_REG("xprin", cfun_io_xprin), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18565| 3.22k| JANET_CORE_REG("xprintf", cfun_io_xprintf), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18566| 3.22k| JANET_CORE_REG("xprinf", cfun_io_xprinf), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18567| 3.22k| JANET_CORE_REG("flush", cfun_io_flush), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18568| 3.22k| JANET_CORE_REG("eflush", cfun_io_eflush), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18569| 3.22k| JANET_CORE_REG("file/temp", cfun_io_temp), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18570| 3.22k| JANET_CORE_REG("file/open", cfun_io_fopen), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18571| 3.22k| JANET_CORE_REG("file/close", cfun_io_fclose), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18572| 3.22k| JANET_CORE_REG("file/read", cfun_io_fread), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18573| 3.22k| JANET_CORE_REG("file/write", cfun_io_fwrite), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18574| 3.22k| JANET_CORE_REG("file/flush", cfun_io_fflush), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18575| 3.22k| JANET_CORE_REG("file/seek", cfun_io_fseek), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18576| 3.22k| JANET_CORE_REG("file/tell", cfun_io_ftell), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 18577| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 18578| 3.22k| }; 18579| 3.22k| janet_core_cfuns_ext(env, NULL, io_cfuns); 18580| 3.22k| janet_register_abstract_type(&janet_file_type); 18581| 3.22k| int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2278| 3.22k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2281| 3.22k|#define JANET_FILE_SERIALIZABLE 128 ------------------ 18582| | /* stdout */ 18583| 3.22k| JANET_CORE_DEF(env, "stdout", ------------------ | | 481| 3.22k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 18584| 3.22k| janet_makefile(stdout, JANET_FILE_APPEND | default_flags), 18585| 3.22k| "The standard output file."); 18586| | /* stderr */ 18587| 3.22k| JANET_CORE_DEF(env, "stderr", ------------------ | | 481| 3.22k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 18588| 3.22k| janet_makefile(stderr, JANET_FILE_APPEND | default_flags), 18589| 3.22k| "The standard error file."); 18590| | /* stdin */ 18591| 3.22k| JANET_CORE_DEF(env, "stdin", ------------------ | | 481| 3.22k|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 18592| 3.22k| janet_makefile(stdin, JANET_FILE_READ | default_flags), 18593| 3.22k| "The standard input file."); 18594| | 18595| 3.22k|} janet_env_lookup_into: 18704| 3.22k|void janet_env_lookup_into(JanetTable *renv, JanetTable *env, const char *prefix, int recurse) { 18705| 6.45k| while (env) { ------------------ | Branch (18705:12): [True: 3.22k, False: 3.22k] ------------------ 18706| 6.61M| for (int32_t i = 0; i < env->capacity; i++) { ------------------ | Branch (18706:29): [True: 6.60M, False: 3.22k] ------------------ 18707| 6.60M| if (janet_checktype(env->data[i].key, JANET_SYMBOL)) { ------------------ | | 806| 6.60M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.26M, False: 4.34M] | | | Branch (806:6): [Folded, False: 6.60M] | | ------------------ | | 807| 6.60M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.60M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 6.60M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 6.60M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 6.60M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.60M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18708| 2.26M| if (prefix) { ------------------ | Branch (18708:21): [True: 0, False: 2.26M] ------------------ 18709| 0| int32_t prelen = (int32_t) strlen(prefix); 18710| 0| const uint8_t *oldsym = janet_unwrap_symbol(env->data[i].key); ------------------ | | 864| 0|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 18711| 0| int32_t oldlen = janet_string_length(oldsym); ------------------ | | 1812| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 18712| 0| uint8_t *symbuf = janet_smalloc(prelen + oldlen); 18713| 0| safe_memcpy(symbuf, prefix, prelen); 18714| 0| safe_memcpy(symbuf + prelen, oldsym, oldlen); 18715| 0| Janet s = janet_symbolv(symbuf, prelen + oldlen); ------------------ | | 1835| 0|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 0|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18716| 0| janet_sfree(symbuf); 18717| 0| janet_table_put(renv, s, entry_getval(env->data[i].value)); 18718| 2.26M| } else { 18719| 2.26M| janet_table_put(renv, 18720| 2.26M| env->data[i].key, 18721| 2.26M| entry_getval(env->data[i].value)); 18722| 2.26M| } 18723| 2.26M| } 18724| 6.60M| } 18725| 3.22k| env = recurse ? env->proto : NULL; ------------------ | Branch (18725:15): [True: 3.22k, False: 0] ------------------ 18726| 3.22k| } 18727| 3.22k|} janet_env_lookup: 18730| 3.22k|JanetTable *janet_env_lookup(JanetTable *env) { 18731| 3.22k| JanetTable *renv = janet_table(env->count); 18732| | janet_env_lookup_into(renv, env, NULL, 1); 18733| 3.22k| return renv; 18734| 3.22k|} janet_unmarshal: 20252| 6.45k| const uint8_t **next) { 20253| 6.45k| UnmarshalState st; 20254| 6.45k| st.start = bytes; 20255| 6.45k| st.end = bytes + len; 20256| 6.45k| st.lookup_defs = NULL; 20257| 6.45k| st.lookup_envs = NULL; 20258| 6.45k| st.lookup = NULL; 20259| 6.45k| st.reg = reg; 20260| 6.45k| Janet out; 20261| 6.45k| const uint8_t *nextbytes = unmarshal_one(&st, bytes, &out, flags); 20262| 6.45k| if (next) *next = nextbytes; ------------------ | Branch (20262:9): [True: 234, False: 6.22k] ------------------ 20263| 6.45k| janet_v_free(st.lookup_defs); ------------------ | | 711| 6.45k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 719| 3.22k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (711:34): [True: 3.22k, False: 3.22k] | | ------------------ ------------------ 20264| 6.45k| janet_v_free(st.lookup_envs); ------------------ | | 711| 6.45k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 719| 3.22k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (711:34): [True: 3.22k, False: 3.22k] | | ------------------ ------------------ 20265| | janet_v_free(st.lookup); ------------------ | | 711| 6.45k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 719| 3.46k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (711:34): [True: 3.46k, False: 2.99k] | | ------------------ ------------------ 20266| 6.45k| return out; 20267| 6.45k|} janet_lib_marsh: 20324| 3.22k|void janet_lib_marsh(JanetTable *env) { 20325| 3.22k| JanetRegExt marsh_cfuns[] = { 20326| 3.22k| JANET_CORE_REG("marshal", cfun_marshal), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20327| 3.22k| JANET_CORE_REG("unmarshal", cfun_unmarshal), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20328| 3.22k| JANET_CORE_REG("env-lookup", cfun_env_lookup), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20329| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 20330| 3.22k| }; 20331| | janet_core_cfuns_ext(env, NULL, marsh_cfuns); 20332| 3.22k|} janet_default_rng: 20407| 3.22k|JanetRNG *janet_default_rng(void) { 20408| 3.22k| return &janet_vm.rng; 20409| 3.22k|} janet_rng_seed: 20411| 6.45k|void janet_rng_seed(JanetRNG *rng, uint32_t seed) { 20412| 6.45k| rng->a = seed; 20413| 6.45k| rng->b = 0x97654321u; 20414| 6.45k| rng->c = 123871873u; 20415| 6.45k| rng->d = 0xf23f56c8u; 20416| 6.45k| rng->counter = 0u; 20417| | /* First several numbers aren't that random. */ 20418| 109k| for (int i = 0; i < 16; i++) janet_rng_u32(rng); ------------------ | Branch (20418:21): [True: 103k, False: 6.45k] ------------------ 20419| 6.45k|} janet_rng_u32: 20435| 103k|uint32_t janet_rng_u32(JanetRNG *rng) { 20436| | /* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */ 20437| 103k| uint32_t t = rng->d; 20438| 103k| uint32_t const s = rng->a; 20439| 103k| rng->d = rng->c; 20440| 103k| rng->c = rng->b; 20441| 103k| rng->b = s; 20442| 103k| t ^= t >> 2; 20443| 103k| t ^= t << 1; 20444| 103k| t ^= s ^ (s << 4); 20445| 103k| rng->a = t; 20446| 103k| rng->counter += 362437; 20447| 103k| return t + rng->counter; 20448| 103k|} janet_lib_math: 20714| 3.22k|void janet_lib_math(JanetTable *env) { 20715| 3.22k| JanetRegExt math_cfuns[] = { 20716| 3.22k| JANET_CORE_REG("not", janet_not), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20717| 3.22k| JANET_CORE_REG("math/random", janet_rand), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20718| 3.22k| JANET_CORE_REG("math/seedrandom", janet_srand), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20719| 3.22k| JANET_CORE_REG("math/cos", janet_cos), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20720| 3.22k| JANET_CORE_REG("math/sin", janet_sin), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20721| 3.22k| JANET_CORE_REG("math/tan", janet_tan), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20722| 3.22k| JANET_CORE_REG("math/acos", janet_acos), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20723| 3.22k| JANET_CORE_REG("math/asin", janet_asin), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20724| 3.22k| JANET_CORE_REG("math/atan", janet_atan), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20725| 3.22k| JANET_CORE_REG("math/exp", janet_exp), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20726| 3.22k| JANET_CORE_REG("math/log", janet_log), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20727| 3.22k| JANET_CORE_REG("math/log10", janet_log10), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20728| 3.22k| JANET_CORE_REG("math/log2", janet_log2), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20729| 3.22k| JANET_CORE_REG("math/sqrt", janet_sqrt), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20730| 3.22k|#ifndef JANET_PLAN9 20731| 3.22k| JANET_CORE_REG("math/cbrt", janet_cbrt), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20732| 3.22k| JANET_CORE_REG("math/gamma", janet_tgamma), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20733| 3.22k| JANET_CORE_REG("math/log-gamma", janet_lgamma), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20734| 3.22k| JANET_CORE_REG("math/erfc", janet_erfc), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20735| 3.22k| JANET_CORE_REG("math/erf", janet_erf), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20736| 3.22k| JANET_CORE_REG("math/expm1", janet_expm1), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20737| 3.22k| JANET_CORE_REG("math/atanh", janet_atanh), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20738| 3.22k| JANET_CORE_REG("math/asinh", janet_asinh), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20739| 3.22k| JANET_CORE_REG("math/next", janet_nextafter), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20740| 3.22k|#endif 20741| 3.22k| JANET_CORE_REG("math/floor", janet_floor), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20742| 3.22k| JANET_CORE_REG("math/ceil", janet_ceil), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20743| 3.22k| JANET_CORE_REG("math/pow", janet_pow), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20744| 3.22k| JANET_CORE_REG("math/abs", janet_fabs), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20745| 3.22k| JANET_CORE_REG("math/sinh", janet_sinh), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20746| 3.22k| JANET_CORE_REG("math/cosh", janet_cosh), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20747| 3.22k| JANET_CORE_REG("math/tanh", janet_tanh), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20748| 3.22k| JANET_CORE_REG("math/acosh", janet_acosh), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20749| 3.22k| JANET_CORE_REG("math/atan2", janet_atan2), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20750| 3.22k| JANET_CORE_REG("math/rng", cfun_rng_make), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20751| 3.22k| JANET_CORE_REG("math/rng-uniform", cfun_rng_uniform), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20752| 3.22k| JANET_CORE_REG("math/rng-int", cfun_rng_int), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20753| 3.22k| JANET_CORE_REG("math/rng-buffer", cfun_rng_buffer), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20754| 3.22k| JANET_CORE_REG("math/hypot", janet_hypot), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20755| 3.22k| JANET_CORE_REG("math/exp2", janet_exp2), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20756| 3.22k| JANET_CORE_REG("math/log1p", janet_log1p), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20757| 3.22k| JANET_CORE_REG("math/trunc", janet_trunc), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20758| 3.22k| JANET_CORE_REG("math/round", janet_round), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20759| 3.22k| JANET_CORE_REG("math/gcd", janet_cfun_gcd), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20760| 3.22k| JANET_CORE_REG("math/lcm", janet_cfun_lcm), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20761| 3.22k| JANET_CORE_REG("math/frexp", janet_cfun_frexp), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20762| 3.22k| JANET_CORE_REG("math/ldexp", janet_cfun_ldexp), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20763| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 20764| 3.22k| }; 20765| 3.22k| janet_core_cfuns_ext(env, NULL, math_cfuns); 20766| 3.22k| janet_register_abstract_type(&janet_rng_type); 20767| |#ifdef JANET_BOOTSTRAP 20768| | JANET_CORE_DEF(env, "math/pi", janet_wrap_number(3.1415926535897931), 20769| | "The value pi."); 20770| | JANET_CORE_DEF(env, "math/e", janet_wrap_number(2.7182818284590451), 20771| | "The base of the natural log."); 20772| | JANET_CORE_DEF(env, "math/inf", janet_wrap_number(INFINITY), 20773| | "The number representing positive infinity"); 20774| | JANET_CORE_DEF(env, "math/-inf", janet_wrap_number(-INFINITY), 20775| | "The number representing negative infinity"); 20776| | JANET_CORE_DEF(env, "math/int32-min", janet_wrap_number(INT32_MIN), 20777| | "The minimum contiguous integer representable by a 32 bit signed integer"); 20778| | JANET_CORE_DEF(env, "math/int32-max", janet_wrap_number(INT32_MAX), 20779| | "The maximum contiguous integer representable by a 32 bit signed integer"); 20780| | JANET_CORE_DEF(env, "math/int-min", janet_wrap_number(JANET_INTMIN_DOUBLE), 20781| | "The minimum contiguous integer representable by a double (-(2^53))"); 20782| | JANET_CORE_DEF(env, "math/int-max", janet_wrap_number(JANET_INTMAX_DOUBLE), 20783| | "The maximum contiguous integer representable by a double (2^53)"); 20784| |#ifdef NAN 20785| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(NAN), "Not a number (IEEE-754 NaN)"); 20786| |#else 20787| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(0.0 / 0.0), "Not a number (IEEE-754 NaN)"); 20788| |#endif 20789| |#endif 20790| 3.22k|} janet_lib_net: 22046| 3.22k|void janet_lib_net(JanetTable *env) { 22047| 3.22k| JanetRegExt net_cfuns[] = { 22048| 3.22k| JANET_CORE_REG("net/address", cfun_net_sockaddr), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22049| 3.22k| JANET_CORE_REG("net/listen", cfun_net_listen), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22050| 3.22k| JANET_CORE_REG("net/socket", cfun_net_socket), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22051| 3.22k| JANET_CORE_REG("net/accept", cfun_stream_accept), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22052| 3.22k| JANET_CORE_REG("net/accept-loop", cfun_stream_accept_loop), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22053| 3.22k| JANET_CORE_REG("net/read", cfun_stream_read), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22054| 3.22k| JANET_CORE_REG("net/chunk", cfun_stream_chunk), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22055| 3.22k| JANET_CORE_REG("net/write", cfun_stream_write), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22056| 3.22k| JANET_CORE_REG("net/send-to", cfun_stream_send_to), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22057| 3.22k| JANET_CORE_REG("net/recv-from", cfun_stream_recv_from), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22058| 3.22k| JANET_CORE_REG("net/flush", cfun_stream_flush), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22059| 3.22k| JANET_CORE_REG("net/connect", cfun_net_connect), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22060| 3.22k| JANET_CORE_REG("net/shutdown", cfun_net_shutdown), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22061| 3.22k| JANET_CORE_REG("net/peername", cfun_net_getpeername), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22062| 3.22k| JANET_CORE_REG("net/localname", cfun_net_getsockname), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22063| 3.22k| JANET_CORE_REG("net/address-unpack", cfun_net_address_unpack), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22064| 3.22k| JANET_CORE_REG("net/setsockopt", cfun_net_setsockopt), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22065| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 22066| 3.22k| }; 22067| | janet_core_cfuns_ext(env, NULL, net_cfuns); 22068| 3.22k|} janet_net_init: 22070| 3.22k|void janet_net_init(void) { 22071| |#ifdef JANET_WINDOWS 22072| | WSADATA wsaData; 22073| | janet_assert(!WSAStartup(MAKEWORD(2, 2), &wsaData), "could not start winsock"); 22074| | janet_vm.connect_ex_loaded = 0; 22075| | janet_vm.connect_ex = NULL; 22076| |#endif 22077| 3.22k|} janet_net_deinit: 22079| 3.22k|void janet_net_deinit(void) { 22080| |#ifdef JANET_WINDOWS 22081| | WSACleanup(); 22082| |#endif 22083| 3.22k|} janet_lib_os: 25056| 3.22k|void janet_lib_os(JanetTable *env) { 25057| |#if !defined(JANET_REDUCED_OS) && defined(JANET_WINDOWS) && defined(JANET_THREADS) 25058| | /* During start up, the top-most abstract machine (thread) 25059| | * in the thread tree sets up the critical section. */ 25060| | static volatile long env_lock_initializing = 0; 25061| | static volatile long env_lock_initialized = 0; 25062| | if (!InterlockedExchange(&env_lock_initializing, 1)) { 25063| | InitializeCriticalSection(&env_lock); 25064| | InterlockedOr(&env_lock_initialized, 1); 25065| | } else { 25066| | while (!InterlockedOr(&env_lock_initialized, 0)) { 25067| | Sleep(0); 25068| | } 25069| | } 25070| | 25071| |#endif 25072| 3.22k|#ifndef JANET_NO_PROCESSES 25073| 3.22k|#endif 25074| 3.22k| JanetRegExt os_cfuns[] = { 25075| 3.22k| JANET_CORE_REG("os/exit", os_exit), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25076| 3.22k| JANET_CORE_REG("os/which", os_which), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25077| 3.22k| JANET_CORE_REG("os/arch", os_arch), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25078| 3.22k| JANET_CORE_REG("os/compiler", os_compiler), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25079| 3.22k|#ifndef JANET_REDUCED_OS 25080| | 25081| | /* misc (un-sandboxed) */ 25082| 3.22k| JANET_CORE_REG("os/cpu-count", os_cpu_count), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25083| 3.22k| JANET_CORE_REG("os/cwd", os_cwd), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25084| 3.22k| JANET_CORE_REG("os/cryptorand", os_cryptorand), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25085| 3.22k| JANET_CORE_REG("os/perm-string", os_permission_string), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25086| 3.22k| JANET_CORE_REG("os/perm-int", os_permission_int), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25087| 3.22k| JANET_CORE_REG("os/mktime", os_mktime), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25088| 3.22k| JANET_CORE_REG("os/time", os_time), /* not high resolution */ ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25089| 3.22k| JANET_CORE_REG("os/date", os_date), /* not high resolution */ ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25090| 3.22k| JANET_CORE_REG("os/strftime", os_strftime), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25091| 3.22k| JANET_CORE_REG("os/sleep", os_sleep), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25092| 3.22k| JANET_CORE_REG("os/isatty", os_isatty), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25093| 3.22k|#ifndef JANET_NO_LOCALES 25094| 3.22k| JANET_CORE_REG("os/setlocale", os_setlocale), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25095| 3.22k|#endif 25096| | 25097| | /* env functions */ 25098| 3.22k|#ifndef JANET_PLAN9 25099| 3.22k| JANET_CORE_REG("os/environ", os_environ), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25100| 3.22k|#endif 25101| 3.22k| JANET_CORE_REG("os/getenv", os_getenv), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25102| 3.22k| JANET_CORE_REG("os/setenv", os_setenv), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25103| | 25104| | /* fs read */ 25105| 3.22k| JANET_CORE_REG("os/dir", os_dir), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25106| 3.22k| JANET_CORE_REG("os/stat", os_stat), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25107| 3.22k| JANET_CORE_REG("os/lstat", os_lstat), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25108| 3.22k| JANET_CORE_REG("os/realpath", os_realpath), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25109| 3.22k| JANET_CORE_REG("os/cd", os_cd), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25110| 3.22k|#ifndef JANET_NO_UMASK 25111| 3.22k| JANET_CORE_REG("os/umask", os_umask), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25112| 3.22k|#endif 25113| 3.22k|#ifndef JANET_NO_SYMLINKS 25114| 3.22k| JANET_CORE_REG("os/readlink", os_readlink), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25115| 3.22k|#endif 25116| | 25117| | /* fs write */ 25118| 3.22k| JANET_CORE_REG("os/mkdir", os_mkdir), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25119| 3.22k| JANET_CORE_REG("os/rmdir", os_rmdir), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25120| 3.22k| JANET_CORE_REG("os/rm", os_remove), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25121| 3.22k| JANET_CORE_REG("os/link", os_link), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25122| 3.22k| JANET_CORE_REG("os/rename", os_rename), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25123| 3.22k| JANET_CORE_REG("os/chmod", os_chmod), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25124| 3.22k| JANET_CORE_REG("os/touch", os_touch), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25125| 3.22k|#ifndef JANET_NO_SYMLINKS 25126| 3.22k| JANET_CORE_REG("os/symlink", os_symlink), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25127| 3.22k|#endif 25128| | 25129| | /* processes */ 25130| 3.22k|#ifndef JANET_NO_PROCESSES 25131| 3.22k| JANET_CORE_REG("os/execute", os_execute), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25132| 3.22k| JANET_CORE_REG("os/spawn", os_spawn), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25133| 3.22k| JANET_CORE_REG("os/shell", os_shell), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25134| 3.22k| JANET_CORE_REG("os/posix-fork", os_posix_fork), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25135| 3.22k| JANET_CORE_REG("os/posix-exec", os_posix_exec), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25136| 3.22k| JANET_CORE_REG("os/posix-chroot", os_posix_chroot), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25137| | /* no need to sandbox process management if you can't create processes 25138| | * (allows for limited functionality if use exposes C-functions to create specific processes) */ 25139| 3.22k| JANET_CORE_REG("os/proc-wait", os_proc_wait), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25140| 3.22k| JANET_CORE_REG("os/proc-kill", os_proc_kill), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25141| 3.22k| JANET_CORE_REG("os/proc-close", os_proc_close), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25142| 3.22k| JANET_CORE_REG("os/getpid", os_proc_getpid), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25143| 3.22k|#ifdef JANET_EV 25144| 3.22k| JANET_CORE_REG("os/sigaction", os_sigaction), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25145| 3.22k|#endif 25146| 3.22k|#endif 25147| | 25148| | /* high resolution timers */ 25149| 3.22k| JANET_CORE_REG("os/clock", os_clock), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25150| | 25151| 3.22k|#ifdef JANET_EV 25152| 3.22k| JANET_CORE_REG("os/open", os_open), /* fs read and write */ ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25153| 3.22k| JANET_CORE_REG("os/pipe", os_pipe), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 25154| 3.22k|#endif 25155| 3.22k|#endif 25156| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 25157| 3.22k| }; 25158| | janet_core_cfuns_ext(env, NULL, os_cfuns); 25159| 3.22k|} janet_lib_parse: 26473| 3.22k|void janet_lib_parse(JanetTable *env) { 26474| 3.22k| JanetRegExt parse_cfuns[] = { 26475| 3.22k| JANET_CORE_REG("parser/new", cfun_parse_parser), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26476| 3.22k| JANET_CORE_REG("parser/clone", cfun_parse_clone), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26477| 3.22k| JANET_CORE_REG("parser/has-more", cfun_parse_has_more), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26478| 3.22k| JANET_CORE_REG("parser/produce", cfun_parse_produce), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26479| 3.22k| JANET_CORE_REG("parser/consume", cfun_parse_consume), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26480| 3.22k| JANET_CORE_REG("parser/byte", cfun_parse_byte), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26481| 3.22k| JANET_CORE_REG("parser/error", cfun_parse_error), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26482| 3.22k| JANET_CORE_REG("parser/status", cfun_parse_status), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26483| 3.22k| JANET_CORE_REG("parser/flush", cfun_parse_flush), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26484| 3.22k| JANET_CORE_REG("parser/state", cfun_parse_state), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26485| 3.22k| JANET_CORE_REG("parser/where", cfun_parse_where), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26486| 3.22k| JANET_CORE_REG("parser/eof", cfun_parse_eof), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26487| 3.22k| JANET_CORE_REG("parser/insert", cfun_parse_insert), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26488| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 26489| 3.22k| }; 26490| | janet_core_cfuns_ext(env, NULL, parse_cfuns); 26491| 3.22k|} janet_lib_peg: 28591| 3.22k|void janet_lib_peg(JanetTable *env) { 28592| 3.22k| JanetRegExt cfuns[] = { 28593| 3.22k| JANET_CORE_REG("peg/compile", cfun_peg_compile), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28594| 3.22k| JANET_CORE_REG("peg/match", cfun_peg_match), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28595| 3.22k| JANET_CORE_REG("peg/find", cfun_peg_find), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28596| 3.22k| JANET_CORE_REG("peg/find-all", cfun_peg_find_all), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28597| 3.22k| JANET_CORE_REG("peg/replace", cfun_peg_replace), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28598| 3.22k| JANET_CORE_REG("peg/replace-all", cfun_peg_replace_all), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28599| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 28600| 3.22k| }; 28601| | janet_core_cfuns_ext(env, NULL, cfuns); 28602| 3.22k| janet_register_abstract_type(&janet_peg_type); 28603| 3.22k|} janet_to_string_b: 28831| 282|void janet_to_string_b(JanetBuffer *buffer, Janet x) { 28832| 282| switch (janet_type(x)) { ------------------ | | 795| 282| (isnan((x).number) \ | | 796| 282| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 282| : JANET_NUMBER) ------------------ | Branch (28832:13): [True: 44, False: 238] ------------------ 28833| 0| case JANET_NIL: ------------------ | Branch (28833:9): [True: 0, False: 282] ------------------ 28834| 0| janet_buffer_push_cstring(buffer, ""); 28835| 0| break; 28836| 5| case JANET_BOOLEAN: ------------------ | Branch (28836:9): [True: 5, False: 277] ------------------ 28837| 5| janet_buffer_push_cstring(buffer, 28838| 5| janet_unwrap_boolean(x) ? "true" : "false"); ------------------ | | 838| 5|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) | | ------------------ | | | Branch (838:33): [True: 3, False: 2] | | ------------------ ------------------ 28839| 5| break; 28840| 238| case JANET_NUMBER: ------------------ | Branch (28840:9): [True: 238, False: 44] ------------------ 28841| 238| number_to_string_b(buffer, janet_unwrap_number(x)); ------------------ | | 839| 238|#define janet_unwrap_number(x) ((x).number) ------------------ 28842| 238| break; 28843| 0| case JANET_STRING: ------------------ | Branch (28843:9): [True: 0, False: 282] ------------------ 28844| 7| case JANET_SYMBOL: ------------------ | Branch (28844:9): [True: 7, False: 275] ------------------ 28845| 10| case JANET_KEYWORD: ------------------ | Branch (28845:9): [True: 3, False: 279] ------------------ 28846| 10| janet_buffer_push_bytes(buffer, 28847| 10| janet_unwrap_string(x), ------------------ | | 863| 10|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 28848| 10| janet_string_length(janet_unwrap_string(x))); ------------------ | | 1812| 10|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 10|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 28849| 10| break; 28850| 0| case JANET_BUFFER: { ------------------ | Branch (28850:9): [True: 0, False: 282] ------------------ 28851| 0| JanetBuffer *to = janet_unwrap_buffer(x); ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 28852| | /* Prevent resizing buffer while appending */ 28853| 0| if (buffer == to) janet_buffer_extra(buffer, to->count); ------------------ | Branch (28853:17): [True: 0, False: 0] ------------------ 28854| 0| janet_buffer_push_bytes(buffer, to->data, to->count); 28855| 0| break; 28856| 7| } 28857| 0| case JANET_ABSTRACT: { ------------------ | Branch (28857:9): [True: 0, False: 282] ------------------ 28858| 0| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 28859| 0| const JanetAbstractType *t = janet_abstract_type(p); ------------------ | | 1898| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1896| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 28860| 0| if (t->tostring != NULL) { ------------------ | Branch (28860:17): [True: 0, False: 0] ------------------ 28861| 0| t->tostring(p, buffer); 28862| 0| } else { 28863| 0| string_description_b(buffer, t->name, p); 28864| 0| } 28865| 0| } 28866| 0| return; 28867| 2| case JANET_CFUNCTION: { ------------------ | Branch (28867:9): [True: 2, False: 280] ------------------ 28868| 2| JanetCFunRegistry *reg = janet_registry_get(janet_unwrap_cfunction(x)); ------------------ | | 869| 2|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 28869| 2| if (NULL != reg) { ------------------ | Branch (28869:17): [True: 2, False: 0] ------------------ 28870| 2| janet_buffer_push_cstring(buffer, "name_prefix) { ------------------ | Branch (28871:21): [True: 0, False: 2] ------------------ 28872| 0| janet_buffer_push_cstring(buffer, reg->name_prefix); 28873| 0| janet_buffer_push_u8(buffer, '/'); 28874| 0| } 28875| 2| janet_buffer_push_cstring(buffer, reg->name); 28876| 2| janet_buffer_push_u8(buffer, '>'); 28877| 2| break; 28878| 2| } 28879| 0| goto fallthrough; 28880| 2| } 28881| 7| case JANET_FUNCTION: { ------------------ | Branch (28881:9): [True: 7, False: 275] ------------------ 28882| 7| JanetFunction *fun = janet_unwrap_function(x); ------------------ | | 868| 7|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 28883| 7| JanetFuncDef *def = fun->def; 28884| 7| if (def == NULL) { ------------------ | Branch (28884:17): [True: 2, False: 5] ------------------ 28885| 2| janet_buffer_push_cstring(buffer, ""); 28886| 2| break; 28887| 2| } 28888| 5| if (def->name) { ------------------ | Branch (28888:17): [True: 1, False: 4] ------------------ 28889| 1| const uint8_t *n = def->name; 28890| 1| janet_buffer_push_cstring(buffer, "length) | | ------------------ | | | | 1811| 1|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 28892| 1| janet_buffer_push_u8(buffer, '>'); 28893| 1| break; 28894| 1| } 28895| 4| goto fallthrough; 28896| 5| } 28897| 4| fallthrough: 28898| 24| default: ------------------ | Branch (28898:9): [True: 20, False: 262] ------------------ 28899| 24| string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 795| 24| (isnan((x).number) \ | | 796| 24| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 24| : JANET_NUMBER) ------------------ string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 867| 24|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (28899:59): [True: 24, False: 0] ------------------ 28900| 24| break; 28901| 282| } 28902| 282|} janet_description_b: 28917| 425|void janet_description_b(JanetBuffer *buffer, Janet x) { 28918| 425| switch (janet_type(x)) { ------------------ | | 795| 425| (isnan((x).number) \ | | 796| 425| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 425| : JANET_NUMBER) ------------------ | Branch (28918:13): [True: 187, False: 238] ------------------ 28919| 279| default: ------------------ | Branch (28919:9): [True: 279, False: 146] ------------------ 28920| 279| break; 28921| 279| case JANET_NIL: ------------------ | Branch (28921:9): [True: 4, False: 421] ------------------ 28922| 4| janet_buffer_push_cstring(buffer, "nil"); 28923| 4| return; 28924| 3| case JANET_KEYWORD: ------------------ | Branch (28924:9): [True: 3, False: 422] ------------------ 28925| 3| janet_buffer_push_u8(buffer, ':'); 28926| 3| break; 28927| 92| case JANET_STRING: ------------------ | Branch (28927:9): [True: 92, False: 333] ------------------ 28928| 92| janet_escape_string_b(buffer, janet_unwrap_string(x)); ------------------ | | 863| 92|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 28929| 92| return; 28930| 47| case JANET_BUFFER: { ------------------ | Branch (28930:9): [True: 47, False: 378] ------------------ 28931| 47| JanetBuffer *b = janet_unwrap_buffer(x); ------------------ | | 862| 47|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 28932| 47| janet_escape_buffer_b(buffer, b); 28933| 47| return; 28934| 0| } 28935| 0| case JANET_ABSTRACT: { ------------------ | Branch (28935:9): [True: 0, False: 425] ------------------ 28936| 0| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 28937| 0| const JanetAbstractType *t = janet_abstract_type(p); ------------------ | | 1898| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1896| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 28938| 0| if (t->tostring != NULL) { ------------------ | Branch (28938:17): [True: 0, False: 0] ------------------ 28939| 0| janet_buffer_push_cstring(buffer, "<"); 28940| 0| janet_buffer_push_cstring(buffer, t->name); 28941| 0| janet_buffer_push_cstring(buffer, " "); 28942| 0| t->tostring(p, buffer); 28943| 0| janet_buffer_push_cstring(buffer, ">"); 28944| 0| } else { 28945| 0| string_description_b(buffer, t->name, p); 28946| 0| } 28947| 0| return; 28948| 0| } 28949| 425| } 28950| 282| janet_to_string_b(buffer, x); 28951| 282|} janet_formatbv: 29575| 1.27k|void janet_formatbv(JanetBuffer *b, const char *format, va_list args) { 29576| 1.27k| const char *format_end = format + strlen(format); 29577| 1.27k| const char *c = format; 29578| 1.27k| int32_t startlen = b->count; 29579| 36.7k| while (c < format_end) { ------------------ | Branch (29579:12): [True: 35.5k, False: 1.27k] ------------------ 29580| 35.5k| if (*c != '%') { ------------------ | Branch (29580:13): [True: 33.3k, False: 2.17k] ------------------ 29581| 33.3k| janet_buffer_push_u8(b, (uint8_t) *c++); 29582| 33.3k| } else if (*++c == '%') { ------------------ | Branch (29582:20): [True: 0, False: 2.17k] ------------------ 29583| 0| janet_buffer_push_u8(b, (uint8_t) *c++); 29584| 2.17k| } else { 29585| 2.17k| char form[MAX_FORMAT], item[MAX_ITEM]; 29586| 2.17k| char width[3], precision[3]; 29587| 2.17k| int nb = 0; /* number of bytes in added item */ 29588| 2.17k| c = scanformat(c, form, width, precision); 29589| 2.17k| switch (*c++) { 29590| 0| case 'c': { ------------------ | Branch (29590:17): [True: 0, False: 2.17k] ------------------ 29591| 0| int n = va_arg(args, int); 29592| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |29498| 0|#define MAX_ITEM 256 ------------------ 29593| 0| break; 29594| 0| } 29595| 852| case 'd': ------------------ | Branch (29595:17): [True: 852, False: 1.32k] ------------------ 29596| 852| case 'i': { ------------------ | Branch (29596:17): [True: 0, False: 2.17k] ------------------ 29597| 852| int64_t n = (int64_t) va_arg(args, int32_t); 29598| 852| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |29498| 852|#define MAX_ITEM 256 ------------------ 29599| 852| break; 29600| 852| } 29601| 0| case 'D': ------------------ | Branch (29601:17): [True: 0, False: 2.17k] ------------------ 29602| 0| case 'I': { ------------------ | Branch (29602:17): [True: 0, False: 2.17k] ------------------ 29603| 0| int64_t n = va_arg(args, int64_t); 29604| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |29498| 0|#define MAX_ITEM 256 ------------------ 29605| 0| break; 29606| 0| } 29607| 490| case 'x': ------------------ | Branch (29607:17): [True: 490, False: 1.68k] ------------------ 29608| 490| case 'X': ------------------ | Branch (29608:17): [True: 0, False: 2.17k] ------------------ 29609| 490| case 'o': ------------------ | Branch (29609:17): [True: 0, False: 2.17k] ------------------ 29610| 490| case 'u': { ------------------ | Branch (29610:17): [True: 0, False: 2.17k] ------------------ 29611| 490| uint64_t n = va_arg(args, uint64_t); 29612| 490| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |29498| 490|#define MAX_ITEM 256 ------------------ 29613| 490| break; 29614| 490| } 29615| 0| case 'a': ------------------ | Branch (29615:17): [True: 0, False: 2.17k] ------------------ 29616| 0| case 'A': ------------------ | Branch (29616:17): [True: 0, False: 2.17k] ------------------ 29617| 0| case 'e': ------------------ | Branch (29617:17): [True: 0, False: 2.17k] ------------------ 29618| 0| case 'E': ------------------ | Branch (29618:17): [True: 0, False: 2.17k] ------------------ 29619| 0| case 'f': ------------------ | Branch (29619:17): [True: 0, False: 2.17k] ------------------ 29620| 0| case 'g': ------------------ | Branch (29620:17): [True: 0, False: 2.17k] ------------------ 29621| 0| case 'G': { ------------------ | Branch (29621:17): [True: 0, False: 2.17k] ------------------ 29622| 0| double d = va_arg(args, double); 29623| 0| nb = snprintf(item, MAX_ITEM, form, d); ------------------ | |29498| 0|#define MAX_ITEM 256 ------------------ 29624| 0| break; 29625| 0| } 29626| 0| case 's': ------------------ | Branch (29626:17): [True: 0, False: 2.17k] ------------------ 29627| 0| case 'S': { ------------------ | Branch (29627:17): [True: 0, False: 2.17k] ------------------ 29628| 0| const char *str = va_arg(args, const char *); 29629| 0| int32_t len = (c[-1] == 's') ------------------ | Branch (29629:35): [True: 0, False: 0] ------------------ 29630| 0| ? (int32_t) strlen(str) 29631| 0| : janet_string_length((JanetString) str); ------------------ | | 1812| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 29632| 0| if (form[2] == '\0') ------------------ | Branch (29632:25): [True: 0, False: 0] ------------------ 29633| 0| janet_buffer_push_bytes(b, (const uint8_t *) str, len); 29634| 0| else { 29635| 0| if (len != (int32_t) strlen((const char *) str)) ------------------ | Branch (29635:29): [True: 0, False: 0] ------------------ 29636| 0| janet_panic("string contains zeros"); 29637| 0| if (!strchr(form, '.') && len >= 100) { ------------------ | Branch (29637:29): [True: 0, False: 0] | Branch (29637:51): [True: 0, False: 0] ------------------ 29638| 0| janet_panic("no precision and string is too long to be formatted"); 29639| 0| } else { 29640| 0| nb = snprintf(item, MAX_ITEM, form, str); ------------------ | |29498| 0|#define MAX_ITEM 256 ------------------ 29641| 0| } 29642| 0| } 29643| 0| break; 29644| 0| } 29645| 0| case 'V': ------------------ | Branch (29645:17): [True: 0, False: 2.17k] ------------------ 29646| 0| janet_to_string_b(b, va_arg(args, Janet)); 29647| 0| break; 29648| 425| case 'v': ------------------ | Branch (29648:17): [True: 425, False: 1.74k] ------------------ 29649| 425| janet_description_b(b, va_arg(args, Janet)); 29650| 425| break; 29651| 0| case 't': ------------------ | Branch (29651:17): [True: 0, False: 2.17k] ------------------ 29652| 0| janet_buffer_push_cstring(b, typestr(va_arg(args, Janet))); 29653| 0| break; 29654| 405| case 'T': { ------------------ | Branch (29654:17): [True: 405, False: 1.76k] ------------------ 29655| 405| int types = va_arg(args, int); 29656| 405| pushtypes(b, types); 29657| 405| break; 29658| 0| } 29659| 0| case 'M': ------------------ | Branch (29659:17): [True: 0, False: 2.17k] ------------------ 29660| 0| case 'm': ------------------ | Branch (29660:17): [True: 0, False: 2.17k] ------------------ 29661| 0| case 'N': ------------------ | Branch (29661:17): [True: 0, False: 2.17k] ------------------ 29662| 0| case 'n': ------------------ | Branch (29662:17): [True: 0, False: 2.17k] ------------------ 29663| 0| case 'Q': ------------------ | Branch (29663:17): [True: 0, False: 2.17k] ------------------ 29664| 0| case 'q': ------------------ | Branch (29664:17): [True: 0, False: 2.17k] ------------------ 29665| 0| case 'P': ------------------ | Branch (29665:17): [True: 0, False: 2.17k] ------------------ 29666| 0| case 'p': { /* janet pretty , precision = depth */ ------------------ | Branch (29666:17): [True: 0, False: 2.17k] ------------------ 29667| 0| int depth = atoi(precision); 29668| 0| if (depth < 1) depth = JANET_RECURSION_GUARD; ------------------ | | 296| 0|#define JANET_RECURSION_GUARD 1024 ------------------ | Branch (29668:25): [True: 0, False: 0] ------------------ 29669| 0| char d = c[-1]; 29670| 0| int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N'); ------------------ | Branch (29670:37): [True: 0, False: 0] | Branch (29670:51): [True: 0, False: 0] | Branch (29670:65): [True: 0, False: 0] | Branch (29670:79): [True: 0, False: 0] ------------------ 29671| 0| int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n'); ------------------ | Branch (29671:39): [True: 0, False: 0] | Branch (29671:53): [True: 0, False: 0] | Branch (29671:67): [True: 0, False: 0] | Branch (29671:81): [True: 0, False: 0] ------------------ 29672| 0| int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n'); ------------------ | Branch (29672:39): [True: 0, False: 0] | Branch (29672:53): [True: 0, False: 0] | Branch (29672:67): [True: 0, False: 0] | Branch (29672:81): [True: 0, False: 0] ------------------ 29673| 0| int columns = atoi(width); 29674| 0| if (columns == 0) { ------------------ | Branch (29674:25): [True: 0, False: 0] ------------------ 29675| 0| columns = JANET_COLUMNS; ------------------ | |29411| 0|#define JANET_COLUMNS 80 ------------------ 29676| 0| } else if (columns < 0) { ------------------ | Branch (29676:32): [True: 0, False: 0] ------------------ 29677| 0| has_oneline = 1; 29678| 0| } 29679| 0| int flags = 0; 29680| 0| flags |= has_color ? JANET_PRETTY_COLOR : 0; ------------------ | | 1966| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (29680:30): [True: 0, False: 0] ------------------ 29681| 0| flags |= has_oneline ? JANET_PRETTY_ONELINE : 0; ------------------ | | 1967| 0|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (29681:30): [True: 0, False: 0] ------------------ 29682| 0| flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0; ------------------ | | 1968| 0|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (29682:30): [True: 0, False: 0] ------------------ 29683| 0| janet_pretty_(b, depth, columns, flags, 29684| 0| va_arg(args, Janet), startlen, b->count); 29685| 0| break; 29686| 0| } 29687| 0| case 'j': { ------------------ | Branch (29687:17): [True: 0, False: 2.17k] ------------------ 29688| 0| int depth = atoi(precision); 29689| 0| if (depth < 1) { ------------------ | Branch (29689:25): [True: 0, False: 0] ------------------ 29690| 0| depth = JANET_RECURSION_GUARD; ------------------ | | 296| 0|#define JANET_RECURSION_GUARD 1024 ------------------ 29691| 0| } 29692| 0| janet_jdn_(b, depth, va_arg(args, Janet), startlen, b->count); 29693| 0| break; 29694| 0| } 29695| 0| default: { ------------------ | Branch (29695:17): [True: 0, False: 2.17k] ------------------ 29696| | /* also treat cases 'nLlh' */ 29697| 0| janet_panicf("invalid conversion '%s' to 'format'", 29698| 0| form); 29699| 0| } 29700| 2.17k| } 29701| 2.17k| if (nb >= MAX_ITEM) ------------------ | |29498| 2.17k|#define MAX_ITEM 256 ------------------ | Branch (29701:17): [True: 0, False: 2.17k] ------------------ 29702| 0| janet_panic("format buffer overflow"); 29703| 2.17k| if (nb > 0) ------------------ | Branch (29703:17): [True: 1.34k, False: 830] ------------------ 29704| 1.34k| janet_buffer_push_bytes(b, (uint8_t *) item, nb); 29705| 2.17k| } 29706| | 29707| 35.5k| } 29708| 1.27k|} janet_string: 31608| 4.76M|const uint8_t *janet_string(const uint8_t *buf, int32_t len) { 31609| 4.76M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1); 31610| 4.76M| head->length = len; 31611| 4.76M| head->hash = janet_string_calchash(buf, len); 31612| 4.76M| uint8_t *data = (uint8_t *)head->data; 31613| 4.76M| safe_memcpy(data, buf, len); 31614| 4.76M| data[len] = 0; 31615| 4.76M| return data; 31616| 4.76M|} janet_string_compare: 31619| 3.40k|int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) { 31620| 3.40k| int32_t xlen = janet_string_length(lhs); ------------------ | | 1812| 3.40k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 3.40k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31621| 3.40k| int32_t ylen = janet_string_length(rhs); ------------------ | | 1812| 3.40k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 3.40k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31622| 3.40k| int32_t len = xlen > ylen ? ylen : xlen; ------------------ | Branch (31622:19): [True: 0, False: 3.40k] ------------------ 31623| 3.40k| int res = memcmp(lhs, rhs, len); 31624| 3.40k| if (res) return res > 0 ? 1 : -1; ------------------ | Branch (31624:9): [True: 228, False: 3.17k] | Branch (31624:21): [True: 63, False: 165] ------------------ 31625| 3.17k| if (xlen == ylen) return 0; ------------------ | Branch (31625:9): [True: 3.17k, False: 0] ------------------ 31626| 0| return xlen < ylen ? -1 : 1; ------------------ | Branch (31626:12): [True: 0, False: 0] ------------------ 31627| 3.17k|} janet_string_equalconst: 31630| 23.2M|int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) { 31631| 23.2M| int32_t lhash = janet_string_hash(lhs); ------------------ | | 1813| 23.2M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1811| 23.2M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31632| 23.2M| int32_t llen = janet_string_length(lhs); ------------------ | | 1812| 23.2M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 23.2M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31633| 23.2M| if (lhash != rhash || llen != rlen) ------------------ | Branch (31633:9): [True: 9.50M, False: 13.7M] | Branch (31633:27): [True: 72, False: 13.7M] ------------------ 31634| 9.50M| return 0; 31635| 13.7M| if (lhs == rhs) ------------------ | Branch (31635:9): [True: 6.57M, False: 7.19M] ------------------ 31636| 6.57M| return 1; 31637| 7.19M| return !memcmp(lhs, rhs, rlen); 31638| 13.7M|} janet_string_equal: 31641| 1.44k|int janet_string_equal(const uint8_t *lhs, const uint8_t *rhs) { 31642| 1.44k| return janet_string_equalconst(lhs, rhs, 31643| 1.44k| janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1812| 1.44k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 1.44k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1813| 1.44k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1811| 1.44k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31644| 1.44k|} janet_cstring: 31647| 1.71k|const uint8_t *janet_cstring(const char *str) { 31648| 1.71k| return janet_string((const uint8_t *)str, (int32_t)strlen(str)); 31649| 1.71k|} janet_lib_string: 32197| 3.22k|void janet_lib_string(JanetTable *env) { 32198| 3.22k| JanetRegExt string_cfuns[] = { 32199| 3.22k| JANET_CORE_REG("string/slice", cfun_string_slice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32200| 3.22k| JANET_CORE_REG("keyword/slice", cfun_keyword_slice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32201| 3.22k| JANET_CORE_REG("symbol/slice", cfun_symbol_slice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32202| 3.22k| JANET_CORE_REG("string/repeat", cfun_string_repeat), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32203| 3.22k| JANET_CORE_REG("string/bytes", cfun_string_bytes), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32204| 3.22k| JANET_CORE_REG("string/from-bytes", cfun_string_frombytes), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32205| 3.22k| JANET_CORE_REG("string/ascii-lower", cfun_string_asciilower), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32206| 3.22k| JANET_CORE_REG("string/ascii-upper", cfun_string_asciiupper), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32207| 3.22k| JANET_CORE_REG("string/reverse", cfun_string_reverse), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32208| 3.22k| JANET_CORE_REG("string/find", cfun_string_find), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32209| 3.22k| JANET_CORE_REG("string/find-all", cfun_string_findall), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32210| 3.22k| JANET_CORE_REG("string/has-prefix?", cfun_string_hasprefix), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32211| 3.22k| JANET_CORE_REG("string/has-suffix?", cfun_string_hassuffix), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32212| 3.22k| JANET_CORE_REG("string/replace", cfun_string_replace), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32213| 3.22k| JANET_CORE_REG("string/replace-all", cfun_string_replaceall), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32214| 3.22k| JANET_CORE_REG("string/split", cfun_string_split), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32215| 3.22k| JANET_CORE_REG("string/check-set", cfun_string_checkset), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32216| 3.22k| JANET_CORE_REG("string/join", cfun_string_join), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32217| 3.22k| JANET_CORE_REG("string/format", cfun_string_format), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32218| 3.22k| JANET_CORE_REG("string/trim", cfun_string_trim), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32219| 3.22k| JANET_CORE_REG("string/triml", cfun_string_triml), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32220| 3.22k| JANET_CORE_REG("string/trimr", cfun_string_trimr), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 32221| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 32222| 3.22k| }; 32223| | janet_core_cfuns_ext(env, NULL, string_cfuns); 32224| 3.22k|} janet_struct_begin: 32813| 441k|JanetKV *janet_struct_begin(int32_t count) { 32814| | /* Calculate capacity as power of 2 after 2 * count. */ 32815| 441k| int32_t capacity = janet_tablen(2 * count); 32816| 441k| if (capacity < 0) capacity = janet_tablen(count + 1); ------------------ | Branch (32816:9): [True: 0, False: 441k] ------------------ 32817| | 32818| 441k| size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV); 32819| 441k| JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size); 32820| 441k| head->length = count; 32821| 441k| head->capacity = capacity; 32822| 441k| head->hash = 0; 32823| 441k| head->proto = NULL; 32824| | 32825| 441k| JanetKV *st = (JanetKV *)(head->data); 32826| 441k| janet_memempty(st, capacity); 32827| 441k| return st; 32828| 441k|} janet_struct_put_ext: 32853| 1.30M|void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) { 32854| 1.30M| int32_t cap = janet_struct_capacity(st); ------------------ | | 1848| 1.30M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1845| 1.30M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32855| 1.30M| int32_t hash = janet_hash(key); 32856| 1.30M| int32_t index = janet_maphash(cap, hash); ------------------ | | 396| 1.30M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 32857| 1.30M| int32_t i, j, dist; 32858| 1.30M| int32_t bounds[4] = {index, cap, 0, index}; 32859| 1.30M| if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 806| 2.61M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 63.5k, False: 1.24M] | | | Branch (806:6): [Folded, False: 1.30M] | | ------------------ | | 807| 2.61M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.61M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.30M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.30M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.30M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.30M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 806| 1.24M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 28.8k, False: 1.21M] | | | Branch (806:6): [Folded, False: 1.24M] | | ------------------ | | 807| 1.24M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.24M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.24M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.24M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.24M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.24M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32860| 1.21M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 806| 2.43M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 806k, False: 408k] | | | Branch (806:6): [True: 1.21M, Folded] | | ------------------ | | 807| 2.43M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 1.21M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 805k, False: 409k] | | | | | Branch (803:28): [True: 639, False: 408k] | | | | ------------------ | | ------------------ | | 808| 2.43M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32860:47): [True: 639, False: 805k] ------------------ 32861| | /* Avoid extra items */ 32862| 1.21M| if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1849| 1.21M|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 1.21M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1847| 1.21M|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1845| 1.21M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (32862:9): [True: 0, False: 1.21M] ------------------ 32863| 1.24M| for (dist = 0, j = 0; j < 4; j += 2) ------------------ | Branch (32863:27): [True: 1.24M, False: 0] ------------------ 32864| 1.52M| for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) { ------------------ | Branch (32864:29): [True: 1.50M, False: 26.5k] ------------------ 32865| 1.50M| int status; 32866| 1.50M| int32_t otherhash; 32867| 1.50M| int32_t otherindex, otherdist; 32868| 1.50M| JanetKV *kv = st + i; 32869| | /* We found an empty slot, so just add key and value */ 32870| 1.50M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 1.50M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 842k, False: 660k] | | | Branch (806:6): [Folded, False: 1.50M] | | ------------------ | | 807| 1.50M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.50M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.50M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.50M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.50M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.50M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32871| 842k| kv->key = key; 32872| 842k| kv->value = value; 32873| | /* Update the temporary count */ 32874| 842k| janet_struct_hash(st)++; ------------------ | | 1849| 842k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 842k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32875| 842k| return; 32876| 842k| } 32877| | /* Robinhood hashing - check if colliding kv pair 32878| | * is closer to their source than current. We use robinhood 32879| | * hashing to ensure that equivalent structs that are constructed 32880| | * with different order have the same internal layout, and therefor 32881| | * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}. 32882| | * Collisions are resolved via an insertion sort insertion. */ 32883| 660k| otherhash = janet_hash(kv->key); 32884| 660k| otherindex = janet_maphash(cap, otherhash); ------------------ | | 396| 660k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 32885| 660k| otherdist = (i + cap - otherindex) & (cap - 1); 32886| 660k| if (dist < otherdist) ------------------ | Branch (32886:17): [True: 85.9k, False: 574k] ------------------ 32887| 85.9k| status = -1; 32888| 574k| else if (otherdist < dist) ------------------ | Branch (32888:22): [True: 40.7k, False: 533k] ------------------ 32889| 40.7k| status = 1; 32890| 533k| else if (hash < otherhash) ------------------ | Branch (32890:22): [True: 82.6k, False: 451k] ------------------ 32891| 82.6k| status = -1; 32892| 451k| else if (otherhash < hash) ------------------ | Branch (32892:22): [True: 28.3k, False: 422k] ------------------ 32893| 28.3k| status = 1; 32894| 422k| else 32895| 422k| status = janet_compare(key, kv->key); 32896| | /* If other is closer to their ideal slot */ 32897| 660k| if (status == 1) { ------------------ | Branch (32897:17): [True: 84.4k, False: 576k] ------------------ 32898| | /* Swap current kv pair with pair in slot */ 32899| 84.4k| JanetKV temp = *kv; 32900| 84.4k| kv->key = key; 32901| 84.4k| kv->value = value; 32902| 84.4k| key = temp.key; 32903| 84.4k| value = temp.value; 32904| | /* Save dist and hash of new kv pair */ 32905| 84.4k| dist = otherdist; 32906| 84.4k| hash = otherhash; 32907| 576k| } else if (status == 0) { ------------------ | Branch (32907:24): [True: 371k, False: 204k] ------------------ 32908| 371k| if (replace) { ------------------ | Branch (32908:21): [True: 371k, False: 0] ------------------ 32909| | /* A key was added to the struct more than once - replace old value */ 32910| 371k| kv->value = value; 32911| 371k| } 32912| 371k| return; 32913| 371k| } 32914| 660k| } 32915| 1.21M|} janet_struct_put: 32917| 1.30M|void janet_struct_put(JanetKV *st, Janet key, Janet value) { 32918| 1.30M| janet_struct_put_ext(st, key, value, 1); 32919| 1.30M|} janet_struct_end: 32922| 328k|const JanetKV *janet_struct_end(JanetKV *st) { 32923| 328k| if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1849| 328k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1847| 328k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1845| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (32923:9): [True: 52.6k, False: 275k] ------------------ 32924| | /* Error building struct, probably duplicate values. We need to rebuild 32925| | * the struct using only the values that went in. The second creation should always 32926| | * succeed. */ 32927| 52.6k| JanetKV *newst = janet_struct_begin(janet_struct_hash(st)); ------------------ | | 1849| 52.6k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 52.6k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32928| 2.69M| for (int32_t i = 0; i < janet_struct_capacity(st); i++) { ------------------ | | 1848| 2.69M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1845| 2.69M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (32928:29): [True: 2.64M, False: 52.6k] ------------------ 32929| 2.64M| JanetKV *kv = st + i; 32930| 2.64M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 2.64M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.64M] | | ------------------ | | 807| 2.64M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.64M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.64M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.64M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.64M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.64M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32930:17): [True: 303k, False: 2.34M] ------------------ 32931| 303k| janet_struct_put(newst, kv->key, kv->value); 32932| 303k| } 32933| 2.64M| } 32934| 52.6k| janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1850| 52.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1845| 52.6k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1850| 52.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1845| 52.6k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32935| 52.6k| st = newst; 32936| 52.6k| } 32937| 328k| janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1849| 328k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1848| 328k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1845| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32938| 328k| if (janet_struct_proto(st)) { ------------------ | | 1850| 328k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1845| 328k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1850:31): [True: 18.9k, False: 309k] | | ------------------ ------------------ 32939| 18.9k| janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1849| 18.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 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)); ------------------ | | 1849| 18.9k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 18.9k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 32940| 18.9k| } 32941| 328k| return (const JanetKV *)st; 32942| 328k|} janet_lib_struct: 33089| 3.22k|void janet_lib_struct(JanetTable *env) { 33090| 3.22k| JanetRegExt struct_cfuns[] = { 33091| 3.22k| JANET_CORE_REG("struct/with-proto", cfun_struct_with_proto), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33092| 3.22k| JANET_CORE_REG("struct/getproto", cfun_struct_getproto), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33093| 3.22k| JANET_CORE_REG("struct/proto-flatten", cfun_struct_flatten), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33094| 3.22k| JANET_CORE_REG("struct/to-table", cfun_struct_to_table), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33095| 3.22k| JANET_CORE_REG("struct/rawget", cfun_struct_rawget), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33096| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 33097| 3.22k| }; 33098| | janet_core_cfuns_ext(env, NULL, struct_cfuns); 33099| 3.22k|} janet_symcache_init: 33144| 3.22k|void janet_symcache_init() { 33145| 3.22k| janet_vm.cache_capacity = 1024; 33146| 3.22k| janet_vm.cache = janet_calloc(1, (size_t) janet_vm.cache_capacity * sizeof(const uint8_t *)); ------------------ | | 2412| 3.22k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 33147| 3.22k| if (NULL == janet_vm.cache) { ------------------ | Branch (33147:9): [True: 0, False: 3.22k] ------------------ 33148| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 33149| 0| } 33150| 3.22k| memset(&janet_vm.gensym_counter, '0', sizeof(janet_vm.gensym_counter)); 33151| 3.22k| janet_vm.gensym_counter[0] = '_'; 33152| 3.22k| janet_vm.cache_count = 0; 33153| 3.22k| janet_vm.cache_deleted = 0; 33154| 3.22k|} janet_symcache_deinit: 33157| 3.22k|void janet_symcache_deinit() { 33158| 3.22k| janet_free((void *)janet_vm.cache); ------------------ | | 2415| 3.22k|#define janet_free(X) free((X)) ------------------ 33159| | janet_vm.cache = NULL; 33160| 3.22k| janet_vm.cache_capacity = 0; 33161| 3.22k| janet_vm.cache_count = 0; 33162| 3.22k| janet_vm.cache_deleted = 0; 33163| 3.22k|} janet_symbol_deinit: 33265| 6.57M|void janet_symbol_deinit(const uint8_t *sym) { 33266| 6.57M| int status = 0; 33267| 6.57M| const uint8_t **bucket = janet_symcache_find(sym, &status); ------------------ | |33220| 6.57M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1812| 6.57M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1811| 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)) | | ------------------ | | | | 1813| 6.57M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1811| 6.57M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 33268| 6.57M| if (status) { ------------------ | Branch (33268:9): [True: 6.57M, False: 0] ------------------ 33269| 6.57M| janet_vm.cache_count--; 33270| 6.57M| janet_vm.cache_deleted++; 33271| 6.57M| *bucket = JANET_SYMCACHE_DELETED; 33272| 6.57M| } 33273| 6.57M|} janet_symbol: 33276| 11.5M|const uint8_t *janet_symbol(const uint8_t *str, int32_t len) { 33277| 11.5M| int32_t hash = janet_string_calchash(str, len); 33278| 11.5M| uint8_t *newstr; 33279| 11.5M| int success = 0; 33280| 11.5M| const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success); 33281| 11.5M| if (success) ------------------ | Branch (33281:9): [True: 5.00M, False: 6.57M] ------------------ 33282| 5.00M| return *bucket; 33283| 6.57M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1); 33284| 6.57M| head->hash = hash; 33285| 6.57M| head->length = len; 33286| 6.57M| newstr = (uint8_t *)(head->data); 33287| 6.57M| safe_memcpy(newstr, str, len); 33288| 6.57M| newstr[len] = 0; 33289| 6.57M| janet_symcache_put((const uint8_t *)newstr, bucket); 33290| 6.57M| return newstr; 33291| 11.5M|} janet_csymbol: 33294| 3.44M|const uint8_t *janet_csymbol(const char *cstr) { 33295| 3.44M| return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr)); 33296| 3.44M|} janet_table_init_raw: 33425| 9.68k|JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity) { 33426| 9.68k| return janet_table_init_impl(table, capacity, 0); 33427| 9.68k|} janet_table_deinit: 33430| 9.68k|void janet_table_deinit(JanetTable *table) { 33431| 9.68k| if (table->gc.flags & JANET_TABLE_FLAG_STACK) { ------------------ | |33380| 9.68k|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (33431:9): [True: 0, False: 9.68k] ------------------ 33432| 0| janet_sfree(table->data); 33433| 9.68k| } else { 33434| 9.68k| janet_free(table->data); ------------------ | | 2415| 9.68k|#define janet_free(X) free((X)) ------------------ 33435| 9.68k| } 33436| 9.68k|} janet_table: 33440| 2.36M|JanetTable *janet_table(int32_t capacity) { 33441| 2.36M| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); 33442| 2.36M| return janet_table_init_impl(table, capacity, 0); 33443| 2.36M|} janet_table_weakk: 33445| 21.1k|JanetTable *janet_table_weakk(int32_t capacity) { 33446| 21.1k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKK, sizeof(JanetTable)); 33447| 21.1k| return janet_table_init_impl(table, capacity, 0); 33448| 21.1k|} janet_table_weakv: 33450| 5.70k|JanetTable *janet_table_weakv(int32_t capacity) { 33451| 5.70k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKV, sizeof(JanetTable)); 33452| 5.70k| return janet_table_init_impl(table, capacity, 0); 33453| 5.70k|} janet_table_weakkv: 33455| 152k|JanetTable *janet_table_weakkv(int32_t capacity) { 33456| 152k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKKV, sizeof(JanetTable)); 33457| 152k| return janet_table_init_impl(table, capacity, 0); 33458| 152k|} janet_table_find: 33462| 52.0M|JanetKV *janet_table_find(JanetTable *t, Janet key) { 33463| 52.0M| return (JanetKV *) janet_dict_find(t->data, t->capacity, key); 33464| 52.0M|} janet_table_get: 33498| 3.51M|Janet janet_table_get(JanetTable *t, Janet key) { 33499| 3.60M| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 3.51M|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (33499:41): [True: 3.51M, False: 94.7k] | Branch (33499:46): [True: 3.51M, False: 0] ------------------ 33500| 3.51M| JanetKV *bucket = janet_table_find(t, key); 33501| 3.51M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 3.51M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 3.51M] | | ------------------ | | 807| 3.51M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.51M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.51M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.51M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.51M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.51M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33501:13): [True: 3.51M, False: 0] | Branch (33501:31): [True: 3.41M, False: 94.7k] ------------------ 33502| 3.41M| return bucket->value; 33503| 3.51M| } 33504| 94.7k| return janet_wrap_nil(); ------------------ | | 831| 94.7k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 94.7k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 94.7k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 94.7k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33505| 3.51M|} janet_table_get_keyword: 33508| 25.8k|Janet janet_table_get_keyword(JanetTable *t, const char *keyword) { 33509| 25.8k| int32_t keyword_len = (int32_t) strlen(keyword); 33510| 45.1k| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 25.8k|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (33510:41): [True: 25.8k, False: 19.3k] | Branch (33510:46): [True: 25.8k, False: 0] ------------------ 33511| 25.8k| JanetKV *bucket = (JanetKV *) janet_dict_find_keyword(t->data, t->capacity, (const uint8_t *) keyword, keyword_len); 33512| 25.8k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 25.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 25.8k] | | ------------------ | | 807| 25.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 25.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 25.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 25.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 25.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 25.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33512:13): [True: 25.8k, False: 0] | Branch (33512:31): [True: 6.45k, False: 19.3k] ------------------ 33513| 6.45k| return bucket->value; 33514| 25.8k| } 33515| 19.3k| return janet_wrap_nil(); ------------------ | | 831| 19.3k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 19.3k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 19.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 19.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33516| 25.8k|} janet_table_remove: 33541| 18.7k|Janet janet_table_remove(JanetTable *t, Janet key) { 33542| 18.7k| JanetKV *bucket = janet_table_find(t, key); 33543| 18.7k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 18.7k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 18.7k] | | ------------------ | | 807| 18.7k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 18.7k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 18.7k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 18.7k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 18.7k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 18.7k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33543:9): [True: 18.7k, False: 0] | Branch (33543:27): [True: 12.8k, False: 5.88k] ------------------ 33544| 12.8k| Janet ret = bucket->value; 33545| 12.8k| t->count--; 33546| 12.8k| t->deleted++; 33547| 12.8k| bucket->key = janet_wrap_nil(); ------------------ | | 831| 12.8k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 12.8k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 12.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 12.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33548| 12.8k| bucket->value = janet_wrap_false(); ------------------ | | 833| 12.8k|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 12.8k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 12.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 12.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33549| 12.8k| return ret; 33550| 12.8k| } else { 33551| 5.88k| return janet_wrap_nil(); ------------------ | | 831| 5.88k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 5.88k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 5.88k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.88k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33552| 5.88k| } 33553| 18.7k|} janet_table_put: 33556| 18.3M|void janet_table_put(JanetTable *t, Janet key, Janet value) { 33557| 18.3M| if (janet_checktype(key, JANET_NIL)) return; ------------------ | | 806| 18.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 11.2k, False: 18.3M] | | | Branch (806:6): [Folded, False: 18.3M] | | ------------------ | | 807| 18.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 18.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 18.3M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 18.3M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 18.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 18.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33558| 18.3M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 806| 36.6M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 705k, False: 17.6M] | | | Branch (806:6): [True: 18.3M, Folded] | | ------------------ | | 807| 36.6M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 18.3M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 704k, False: 17.6M] | | | | | Branch (803:28): [True: 285, False: 17.6M] | | | | ------------------ | | ------------------ | | 808| 36.6M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33558:47): [True: 285, False: 704k] ------------------ 33559| 18.3M| if (janet_checktype(value, JANET_NIL)) { ------------------ | | 806| 18.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 18.7k, False: 18.3M] | | | Branch (806:6): [Folded, False: 18.3M] | | ------------------ | | 807| 18.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 18.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 18.3M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 18.3M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 18.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 18.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33560| 18.7k| janet_table_remove(t, key); 33561| 18.3M| } else { 33562| 18.3M| JanetKV *bucket = janet_table_find(t, key); 33563| 18.3M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 18.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 18.3M] | | ------------------ | | 807| 18.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 18.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 18.3M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 18.3M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 18.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 18.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33563:13): [True: 18.3M, False: 0] | Branch (33563:31): [True: 388k, False: 17.9M] ------------------ 33564| 388k| bucket->value = value; 33565| 17.9M| } else { 33566| 17.9M| if (NULL == bucket || 2 * (t->count + t->deleted + 1) > t->capacity) { ------------------ | Branch (33566:17): [True: 0, False: 17.9M] | Branch (33566:35): [True: 1.97M, False: 15.9M] ------------------ 33567| 1.97M| janet_table_rehash(t, janet_tablen(2 * t->count + 2)); 33568| 1.97M| } 33569| 17.9M| bucket = janet_table_find(t, key); 33570| 17.9M| if (janet_checktype(bucket->value, JANET_BOOLEAN)) ------------------ | | 806| 17.9M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 17.9M] | | | Branch (806:6): [Folded, False: 17.9M] | | ------------------ | | 807| 17.9M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 17.9M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 17.9M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 17.9M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 17.9M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 17.9M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33571| 0| --t->deleted; 33572| 17.9M| bucket->key = key; 33573| 17.9M| bucket->value = value; 33574| 17.9M| ++t->count; 33575| 17.9M| } 33576| 18.3M| } 33577| 18.3M|} janet_lib_table: 33786| 3.22k|void janet_lib_table(JanetTable *env) { 33787| 3.22k| JanetRegExt table_cfuns[] = { 33788| 3.22k| JANET_CORE_REG("table/new", cfun_table_new), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33789| 3.22k| JANET_CORE_REG("table/weak", cfun_table_weak), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33790| 3.22k| JANET_CORE_REG("table/weak-keys", cfun_table_weak_keys), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33791| 3.22k| JANET_CORE_REG("table/weak-values", cfun_table_weak_values), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33792| 3.22k| JANET_CORE_REG("table/to-struct", cfun_table_tostruct), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33793| 3.22k| JANET_CORE_REG("table/getproto", cfun_table_getproto), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33794| 3.22k| JANET_CORE_REG("table/setproto", cfun_table_setproto), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33795| 3.22k| JANET_CORE_REG("table/rawget", cfun_table_rawget), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33796| 3.22k| JANET_CORE_REG("table/clone", cfun_table_clone), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33797| 3.22k| JANET_CORE_REG("table/clear", cfun_table_clear), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33798| 3.22k| JANET_CORE_REG("table/proto-flatten", cfun_table_proto_flatten), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33799| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 33800| 3.22k| }; 33801| | janet_core_cfuns_ext(env, NULL, table_cfuns); 33802| 3.22k|} janet_tuple_begin: 33841| 2.52M|Janet *janet_tuple_begin(int32_t length) { 33842| 2.52M| size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet)); 33843| 2.52M| JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size); 33844| 2.52M| head->sm_line = -1; 33845| 2.52M| head->sm_column = -1; 33846| 2.52M| head->length = length; 33847| 2.52M| return (Janet *)(head->data); 33848| 2.52M|} janet_tuple_end: 33851| 2.52M|const Janet *janet_tuple_end(Janet *tuple) { 33852| 2.52M| janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1802| 2.52M|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1799| 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)); ------------------ | | 1801| 2.52M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1799| 2.52M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 33853| 2.52M| return (const Janet *)tuple; 33854| 2.52M|} janet_lib_tuple: 33955| 3.22k|void janet_lib_tuple(JanetTable *env) { 33956| 3.22k| JanetRegExt tuple_cfuns[] = { 33957| 3.22k| JANET_CORE_REG("tuple/brackets", cfun_tuple_brackets), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33958| 3.22k| JANET_CORE_REG("tuple/slice", cfun_tuple_slice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33959| 3.22k| JANET_CORE_REG("tuple/type", cfun_tuple_type), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33960| 3.22k| JANET_CORE_REG("tuple/sourcemap", cfun_tuple_sourcemap), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33961| 3.22k| JANET_CORE_REG("tuple/setmap", cfun_tuple_setmap), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33962| 3.22k| JANET_CORE_REG("tuple/join", cfun_tuple_join), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 33963| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 33964| 3.22k| }; 33965| | janet_core_cfuns_ext(env, NULL, tuple_cfuns); 33966| 3.22k|} janet_hash_mix: 34092| 26.6M|uint32_t janet_hash_mix(uint32_t input, uint32_t more) { 34093| 26.6M| uint32_t mix1 = (more + 0x9e3779b9 + (input << 6) + (input >> 2)); 34094| 26.6M| return input ^ (0x9e3779b9 + (mix1 << 6) + (mix1 >> 2)); 34095| 26.6M|} janet_string_calchash: 34099| 16.3M|int32_t janet_string_calchash(const uint8_t *str, int32_t len) { 34100| 16.3M| if (NULL == str || len == 0) return 5381; ------------------ | Branch (34100:9): [True: 0, False: 16.3M] | Branch (34100:24): [True: 75.1k, False: 16.2M] ------------------ 34101| 16.2M| const uint8_t *end = str + len; 34102| 16.2M| uint32_t hash = 5381; 34103| 578M| while (str < end) ------------------ | Branch (34103:12): [True: 561M, False: 16.2M] ------------------ 34104| 561M| hash = (hash << 5) + hash + *str++; 34105| 16.2M| hash = janet_hash_mix(hash, (uint32_t) len); 34106| 16.2M| return (int32_t) hash; 34107| 16.3M|} janet_array_calchash: 34222| 2.52M|int32_t janet_array_calchash(const Janet *array, int32_t len) { 34223| 2.52M| const Janet *end = array + len; 34224| 2.52M| uint32_t hash = 33; 34225| 9.76M| while (array < end) { ------------------ | Branch (34225:12): [True: 7.24M, False: 2.52M] ------------------ 34226| 7.24M| hash = janet_hash_mix(hash, janet_hash(*array++)); 34227| 7.24M| } 34228| 2.52M| return (int32_t) hash; 34229| 2.52M|} janet_kv_calchash: 34232| 328k|int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) { 34233| 328k| const JanetKV *end = kvs + len; 34234| 328k| uint32_t hash = 33; 34235| 1.90M| while (kvs < end) { ------------------ | Branch (34235:12): [True: 1.57M, False: 328k] ------------------ 34236| 1.57M| hash = janet_hash_mix(hash, janet_hash(kvs->key)); 34237| 1.57M| hash = janet_hash_mix(hash, janet_hash(kvs->value)); 34238| 1.57M| kvs++; 34239| 1.57M| } 34240| 328k| return (int32_t) hash; 34241| 328k|} janet_tablen: 34245| 4.97M|int32_t janet_tablen(int32_t n) { 34246| 4.97M| if (n < 0) return 0; ------------------ | Branch (34246:9): [True: 0, False: 4.97M] ------------------ 34247| 4.97M| n |= n >> 1; 34248| 4.97M| n |= n >> 2; 34249| 4.97M| n |= n >> 4; 34250| 4.97M| n |= n >> 8; 34251| 4.97M| n |= n >> 16; 34252| 4.97M| return n == INT32_MAX ? INT32_MAX : n + 1; ------------------ | Branch (34252:12): [True: 0, False: 4.97M] ------------------ 34253| 4.97M|} safe_memcpy: 34256| 11.3M|void safe_memcpy(void *dest, const void *src, size_t len) { 34257| 11.3M| if (!len) return; ------------------ | Branch (34257:9): [True: 14.3k, False: 11.3M] ------------------ 34258| 11.3M| memcpy(dest, src, len); 34259| 11.3M|} janet_dict_find: 34263| 52.0M|const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) { 34264| 52.0M| int32_t index = janet_maphash(cap, janet_hash(key)); ------------------ | | 396| 52.0M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34265| 52.0M| int32_t i; 34266| 52.0M| const JanetKV *first_bucket = NULL; 34267| | /* Higher half */ 34268| 69.3M| for (i = index; i < cap; i++) { ------------------ | Branch (34268:21): [True: 69.2M, False: 32.5k] ------------------ 34269| 69.2M| const JanetKV *kv = buckets + i; 34270| 69.2M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 69.2M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 48.4M, False: 20.8M] | | | Branch (806:6): [Folded, False: 69.2M] | | ------------------ | | 807| 69.2M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 69.2M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 69.2M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 69.2M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 69.2M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 69.2M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34271| 48.4M| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 48.4M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 48.2M, False: 252k] | | | Branch (806:6): [Folded, False: 48.4M] | | ------------------ | | 807| 48.4M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 48.4M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 48.4M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 48.4M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 48.4M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 48.4M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34272| 48.2M| return kv; 34273| 48.2M| } else if (NULL == first_bucket) { ------------------ | Branch (34273:24): [True: 90.2k, False: 162k] ------------------ 34274| 90.2k| first_bucket = kv; 34275| 90.2k| } 34276| 48.4M| } else if (janet_equals(kv->key, key)) { ------------------ | Branch (34276:20): [True: 3.81M, False: 16.9M] ------------------ 34277| 3.81M| return buckets + i; 34278| 3.81M| } 34279| 69.2M| } 34280| | /* Lower half */ 34281| 73.1k| for (i = 0; i < index; i++) { ------------------ | Branch (34281:17): [True: 73.1k, False: 0] ------------------ 34282| 73.1k| const JanetKV *kv = buckets + i; 34283| 73.1k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 73.1k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 40.4k, False: 32.6k] | | | Branch (806:6): [Folded, False: 73.1k] | | ------------------ | | 807| 73.1k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 73.1k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 73.1k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 73.1k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 73.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 73.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34284| 40.4k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 40.4k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 29.4k, False: 11.0k] | | | Branch (806:6): [Folded, False: 40.4k] | | ------------------ | | 807| 40.4k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 40.4k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 40.4k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 40.4k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 40.4k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 40.4k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34285| 29.4k| return kv; 34286| 29.4k| } else if (NULL == first_bucket) { ------------------ | Branch (34286:24): [True: 5.53k, False: 5.50k] ------------------ 34287| 5.53k| first_bucket = kv; 34288| 5.53k| } 34289| 40.4k| } else if (janet_equals(kv->key, key)) { ------------------ | Branch (34289:20): [True: 3.10k, False: 29.5k] ------------------ 34290| 3.10k| return buckets + i; 34291| 3.10k| } 34292| 73.1k| } 34293| 0| return first_bucket; 34294| 32.5k|} janet_dict_find_keyword: 34300| 25.8k| const uint8_t *cstr, int32_t cstr_len) { 34301| 25.8k| int32_t hash = janet_string_calchash(cstr, cstr_len); 34302| 25.8k| int32_t index = janet_maphash(cap, hash); ------------------ | | 396| 25.8k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34303| 25.8k| int32_t i; 34304| 25.8k| const JanetKV *first_bucket = NULL; 34305| | /* Higher half */ 34306| 38.7k| for (i = index; i < cap; i++) { ------------------ | Branch (34306:21): [True: 38.7k, False: 0] ------------------ 34307| 38.7k| const JanetKV *kv = buckets + i; 34308| 38.7k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 38.7k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 19.3k, False: 19.3k] | | | Branch (806:6): [Folded, False: 38.7k] | | ------------------ | | 807| 38.7k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 38.7k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 38.7k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 38.7k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 38.7k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 38.7k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34309| 19.3k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 19.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 19.3k, False: 0] | | | Branch (806:6): [Folded, False: 19.3k] | | ------------------ | | 807| 19.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 19.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 19.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 19.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 19.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 19.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34310| 19.3k| return kv; 34311| 19.3k| } else if (NULL == first_bucket) { ------------------ | Branch (34311:24): [True: 0, False: 0] ------------------ 34312| 0| first_bucket = kv; 34313| 0| } 34314| 19.3k| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 806| 19.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 19.3k, False: 0] | | | Branch (806:6): [Folded, False: 19.3k] | | ------------------ | | 807| 19.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 19.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 19.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 19.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 19.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 19.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34315| | /* Works for symbol and keyword, too */ 34316| 19.3k| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 863| 19.3k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 34317| 19.3k| int32_t len = janet_string_length(str); ------------------ | | 1812| 19.3k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 19.3k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 34318| 19.3k| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1813| 38.7k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1811| 19.3k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (34318:17): [True: 6.45k, False: 12.9k] | Branch (34318:51): [True: 6.45k, False: 0] | Branch (34318:70): [True: 6.45k, False: 0] ------------------ 34319| 6.45k| return buckets + i; 34320| 6.45k| } 34321| 19.3k| } 34322| 38.7k| } 34323| | /* Lower half */ 34324| 0| for (i = 0; i < index; i++) { ------------------ | Branch (34324:17): [True: 0, False: 0] ------------------ 34325| 0| const JanetKV *kv = buckets + i; 34326| 0| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34327| 0| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34328| 0| return kv; 34329| 0| } else if (NULL == first_bucket) { ------------------ | Branch (34329:24): [True: 0, False: 0] ------------------ 34330| 0| first_bucket = kv; 34331| 0| } 34332| 0| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34333| | /* Works for symbol and keyword, too */ 34334| 0| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 863| 0|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 34335| 0| int32_t len = janet_string_length(str); ------------------ | | 1812| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 34336| 0| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1813| 0|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1811| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (34336:17): [True: 0, False: 0] | Branch (34336:51): [True: 0, False: 0] | Branch (34336:70): [True: 0, False: 0] ------------------ 34337| 0| return buckets + i; 34338| 0| } 34339| 0| } 34340| 0| } 34341| 0| return first_bucket; 34342| 0|} janet_registry_put: 34467| 1.13M| int32_t source_line) { 34468| 1.13M| if (janet_vm.registry_count == janet_vm.registry_cap) { ------------------ | Branch (34468:9): [True: 3.22k, False: 1.13M] ------------------ 34469| 3.22k| size_t newcap = (janet_vm.registry_count + 1) * 2; 34470| | /* Size it nicely with core by default */ 34471| 3.22k| if (newcap < 512) { ------------------ | Branch (34471:13): [True: 3.22k, False: 0] ------------------ 34472| 3.22k| newcap = 512; 34473| 3.22k| } 34474| 3.22k| void *newmem = janet_realloc(janet_vm.registry, newcap * sizeof(JanetCFunRegistry)); ------------------ | | 2409| 3.22k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 34475| 3.22k| if (NULL == newmem) { ------------------ | Branch (34475:13): [True: 0, False: 3.22k] ------------------ 34476| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 34477| 0| } 34478| 3.22k| janet_vm.registry = newmem; 34479| 3.22k| janet_vm.registry_cap = newcap; 34480| 3.22k| } 34481| 1.13M| JanetCFunRegistry value = { 34482| 1.13M| key, 34483| 1.13M| name, 34484| 1.13M| name_prefix, 34485| 1.13M| source_file, 34486| 1.13M| source_line 34487| 1.13M| }; 34488| 1.13M| janet_vm.registry[janet_vm.registry_count++] = value; 34489| 1.13M| janet_vm.registry_dirty = 1; 34490| 1.13M|} janet_registry_get: 34492| 2|JanetCFunRegistry *janet_registry_get(JanetCFunction key) { 34493| 2| if (janet_vm.registry_dirty) { ------------------ | Branch (34493:9): [True: 2, False: 0] ------------------ 34494| 2| janet_registry_sort(); 34495| 2| } 34496| 407| for (size_t i = 0; i < janet_vm.registry_count; i++) { ------------------ | Branch (34496:24): [True: 407, False: 0] ------------------ 34497| 407| if (janet_vm.registry[i].cfun == key) { ------------------ | Branch (34497:13): [True: 2, False: 405] ------------------ 34498| 2| return janet_vm.registry + i; 34499| 2| } 34500| 407| } 34501| 0| JanetCFunRegistry *lo = janet_vm.registry; 34502| 0| JanetCFunRegistry *hi = lo + janet_vm.registry_count; 34503| 0| while (lo < hi) { ------------------ | Branch (34503:12): [True: 0, False: 0] ------------------ 34504| 0| JanetCFunRegistry *mid = lo + (hi - lo) / 2; 34505| 0| if (mid->cfun == key) { ------------------ | Branch (34505:13): [True: 0, False: 0] ------------------ 34506| 0| return mid; 34507| 0| } 34508| 0| if ((void *)(mid->cfun) > (void *)(key)) { ------------------ | Branch (34508:13): [True: 0, False: 0] ------------------ 34509| 0| hi = mid; 34510| 0| } else { 34511| 0| lo = mid + 1; 34512| 0| } 34513| 0| } 34514| 0| return NULL; 34515| 0|} janet_register_abstract_type: 34616| 29.0k|void janet_register_abstract_type(const JanetAbstractType *at) { 34617| 29.0k| janet_check_pointer_align((void *) at); 34618| 29.0k| Janet sym = janet_csymbolv(at->name); ------------------ | | 1836| 29.0k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 29.0k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 29.0k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 29.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 29.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34619| 29.0k| Janet check = janet_table_get(janet_vm.abstract_registry, sym); 34620| 29.0k| if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 806| 58.0k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 29.0k] | | ------------------ | | 807| 58.0k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 58.0k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 29.0k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 29.0k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 29.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 29.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (34620:9): [True: 0, False: 29.0k] | Branch (34620:47): [True: 0, False: 0] ------------------ 34621| 0| janet_panicf("cannot register abstract type %s, " 34622| 0| "a type with the same name exists", at->name); 34623| 0| } 34624| 29.0k| janet_table_put(janet_vm.abstract_registry, sym, janet_wrap_pointer((void *) at)); ------------------ | | 854| 29.0k|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 825| 29.0k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 29.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 29.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34625| 29.0k|} janet_get_abstract_type: 34627| 15|const JanetAbstractType *janet_get_abstract_type(Janet key) { 34628| 15| Janet wrapped = janet_table_get(janet_vm.abstract_registry, key); 34629| 15| if (janet_checktype(wrapped, JANET_NIL)) { ------------------ | | 806| 15| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 15, False: 0] | | | Branch (806:6): [Folded, False: 15] | | ------------------ | | 807| 15| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 15| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 15| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 15|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 15|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 15|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34630| 15| return NULL; 34631| 15| } 34632| 0| return (JanetAbstractType *)(janet_unwrap_pointer(wrapped)); ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ 34633| 15|} janet_core_def_sm: 34636| 9.68k|void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl) { 34637| 9.68k| (void) sf; 34638| 9.68k| (void) sl; 34639| 9.68k| (void) p; 34640| 9.68k| Janet key = janet_csymbolv(name); ------------------ | | 1836| 9.68k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 9.68k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 9.68k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 9.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 9.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34641| 9.68k| janet_table_put(env, key, x); 34642| 9.68k| if (janet_checktype(x, JANET_CFUNCTION)) { ------------------ | | 806| 9.68k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 9.68k] | | | Branch (806:6): [Folded, False: 9.68k] | | ------------------ | | 807| 9.68k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 9.68k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 9.68k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 9.68k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 9.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34643| 0| janet_registry_put(janet_unwrap_cfunction(x), name, NULL, NULL, 0); ------------------ | | 869| 0|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 34644| 0| } 34645| 9.68k|} janet_core_cfuns_ext: 34647| 70.9k|void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) { 34648| 70.9k| (void) regprefix; 34649| 1.20M| while (cfuns->name) { ------------------ | Branch (34649:12): [True: 1.13M, False: 70.9k] ------------------ 34650| 1.13M| janet_check_pointer_align(cfuns->cfun); 34651| 1.13M| Janet fun = janet_wrap_cfunction(cfuns->cfun); ------------------ | | 853| 1.13M|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 825| 1.13M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.13M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.13M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34652| 1.13M| janet_table_put(env, janet_csymbolv(cfuns->name), fun); ------------------ | | 1836| 1.13M|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 1.13M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 1.13M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.13M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.13M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34653| 1.13M| janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line); 34654| 1.13M| cfuns++; 34655| 1.13M| } 34656| 70.9k|} janet_binding_from_entry: 34659| 6.45k|JanetBinding janet_binding_from_entry(Janet entry) { 34660| 6.45k| JanetTable *entry_table; 34661| 6.45k| JanetBinding binding = { 34662| 6.45k| JANET_BINDING_NONE, 34663| 6.45k| janet_wrap_nil(), ------------------ | | 831| 6.45k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 6.45k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34664| 6.45k| JANET_BINDING_DEP_NONE 34665| 6.45k| }; 34666| | 34667| | /* Check environment for entry */ 34668| 6.45k| if (!janet_checktype(entry, JANET_TABLE)) ------------------ | | 806| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 6.45k] | | ------------------ | | 807| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34668:9): [True: 0, False: 6.45k] ------------------ 34669| 0| return binding; 34670| 6.45k| entry_table = janet_unwrap_table(entry); ------------------ | | 861| 6.45k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 34671| | 34672| 6.45k| Janet deprecate = janet_table_get_keyword(entry_table, "deprecated"); 34673| 6.45k| int macro = janet_truthy(janet_table_get_keyword(entry_table, "macro")); ------------------ | | 818| 6.45k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 12.9k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 6.45k] | | | | ------------------ | | | | 807| 12.9k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 12.9k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 6.45k] | | ------------------ | | 819| 6.45k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ 34674| 6.45k| Janet value = janet_table_get_keyword(entry_table, "value"); 34675| 6.45k| Janet ref = janet_table_get_keyword(entry_table, "ref"); 34676| | 34677| 6.45k| if (janet_checktype(deprecate, JANET_KEYWORD)) { ------------------ | | 806| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 6.45k] | | | Branch (806:6): [Folded, False: 6.45k] | | ------------------ | | 807| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34678| 0| JanetKeyword depkw = janet_unwrap_keyword(deprecate); ------------------ | | 865| 0|#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) ------------------ 34679| 0| if (!janet_cstrcmp(depkw, "relaxed")) { ------------------ | Branch (34679:13): [True: 0, False: 0] ------------------ 34680| 0| binding.deprecation = JANET_BINDING_DEP_RELAXED; 34681| 0| } else if (!janet_cstrcmp(depkw, "normal")) { ------------------ | Branch (34681:20): [True: 0, False: 0] ------------------ 34682| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 34683| 0| } else if (!janet_cstrcmp(depkw, "strict")) { ------------------ | Branch (34683:20): [True: 0, False: 0] ------------------ 34684| 0| binding.deprecation = JANET_BINDING_DEP_STRICT; 34685| 0| } 34686| 6.45k| } else if (!janet_checktype(deprecate, JANET_NIL)) { ------------------ | | 806| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 6.45k] | | ------------------ | | 807| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34686:16): [True: 0, False: 6.45k] ------------------ 34687| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 34688| 0| } 34689| | 34690| 6.45k| int ref_is_valid = janet_checktype(ref, JANET_ARRAY); ------------------ | | 806| 6.45k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 6.45k] | | ------------------ | | 807| 6.45k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 6.45k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 6.45k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 6.45k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34691| 6.45k| int redef = ref_is_valid && janet_truthy(janet_table_get_keyword(entry_table, "redef")); ------------------ | | 818| 6.45k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 0] | | ------------------ | | 819| 6.45k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (34691:17): [True: 0, False: 6.45k] ------------------ 34692| | 34693| 6.45k| if (macro) { ------------------ | Branch (34693:9): [True: 0, False: 6.45k] ------------------ 34694| 0| binding.value = redef ? ref : value; ------------------ | Branch (34694:25): [True: 0, False: 0] ------------------ 34695| 0| binding.type = redef ? JANET_BINDING_DYNAMIC_MACRO : JANET_BINDING_MACRO; ------------------ | Branch (34695:24): [True: 0, False: 0] ------------------ 34696| 0| return binding; 34697| 0| } 34698| | 34699| 6.45k| if (ref_is_valid) { ------------------ | Branch (34699:9): [True: 0, False: 6.45k] ------------------ 34700| 0| binding.value = ref; 34701| 0| binding.type = redef ? JANET_BINDING_DYNAMIC_DEF : JANET_BINDING_VAR; ------------------ | Branch (34701:24): [True: 0, False: 0] ------------------ 34702| 6.45k| } else { 34703| 6.45k| binding.value = value; 34704| 6.45k| binding.type = JANET_BINDING_DEF; 34705| 6.45k| } 34706| | 34707| 6.45k| return binding; 34708| 6.45k|} janet_resolve_ext: 34763| 6.45k|JanetBinding janet_resolve_ext(JanetTable *env, const uint8_t *sym) { 34764| 6.45k| Janet entry = janet_table_get(env, janet_wrap_symbol(sym)); ------------------ | | 849| 6.45k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 6.45k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 6.45k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.45k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34765| 6.45k| return janet_binding_from_entry(entry); 34766| 6.45k|} janet_resolve: 34768| 6.45k|JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out) { 34769| 6.45k| JanetBinding binding = janet_resolve_ext(env, sym); 34770| 6.45k| if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) { ------------------ | Branch (34770:9): [True: 0, False: 6.45k] | Branch (34770:54): [True: 0, False: 6.45k] ------------------ 34771| 0| *out = janet_array_peek(janet_unwrap_array(binding.value)); ------------------ | | 860| 0|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 34772| 6.45k| } else { 34773| 6.45k| *out = binding.value; 34774| 6.45k| } 34775| 6.45k| return binding.type; 34776| 6.45k|} array_allocate: 35189| 11.1M|void *array_allocate(size_t element_size, int32_t count) { 35190| 11.1M| if (count < 0) return NULL; ------------------ | Branch (35190:9): [True: 0, False: 11.1M] ------------------ 35191| 11.1M| if ((size_t) count > (SIZE_MAX / element_size)) return NULL; ------------------ | Branch (35191:9): [True: 0, False: 11.1M] ------------------ 35192| 11.1M| return janet_malloc(element_size * count); ------------------ | | 2406| 11.1M|#define janet_malloc(X) malloc((X)) ------------------ 35193| 11.1M|} janet_equals: 35447| 20.8M|int janet_equals(Janet x, Janet y) { 35448| 20.8M| janet_vm.traversal = janet_vm.traversal_base; 35449| 20.8M| do { 35450| 20.8M| if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 20.8M| (isnan((x).number) \ | | 796| 20.8M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 20.8M| : JANET_NUMBER) ------------------ if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 20.8M| (isnan((x).number) \ | | 796| 20.8M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 20.8M| : JANET_NUMBER) ------------------ | Branch (35450:13): [True: 20.3M, False: 564k] | Branch (35450:13): [True: 2.11M, False: 18.7M] | Branch (35450:30): [True: 20.2M, False: 656k] ------------------ 35451| 18.7M| switch (janet_type(x)) { ------------------ | | 795| 18.7M| (isnan((x).number) \ | | 796| 18.7M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 18.7M| : JANET_NUMBER) ------------------ | Branch (35451:17): [True: 18.2M, False: 510k] ------------------ 35452| 39.6k| case JANET_NIL: ------------------ | Branch (35452:13): [True: 39.6k, False: 18.7M] ------------------ 35453| 39.6k| break; 35454| 22.5k| case JANET_BOOLEAN: ------------------ | Branch (35454:13): [True: 22.5k, False: 18.7M] ------------------ 35455| 22.5k| if (janet_unwrap_boolean(x) != janet_unwrap_boolean(y)) return 0; ------------------ | | 838| 22.5k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ if (janet_unwrap_boolean(x) != janet_unwrap_boolean(y)) return 0; ------------------ | | 838| 22.5k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ | Branch (35455:21): [True: 2.52k, False: 19.9k] ------------------ 35456| 19.9k| break; 35457| 510k| case JANET_NUMBER: ------------------ | Branch (35457:13): [True: 510k, False: 18.2M] ------------------ 35458| 510k| if (janet_unwrap_number(x) != janet_unwrap_number(y)) return 0; ------------------ | | 839| 510k|#define janet_unwrap_number(x) ((x).number) ------------------ if (janet_unwrap_number(x) != janet_unwrap_number(y)) return 0; ------------------ | | 839| 510k|#define janet_unwrap_number(x) ((x).number) ------------------ | Branch (35458:21): [True: 136k, False: 373k] ------------------ 35459| 373k| break; 35460| 373k| case JANET_STRING: ------------------ | Branch (35460:13): [True: 1.44k, False: 18.7M] ------------------ 35461| 1.44k| if (!janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y))) return 0; ------------------ | | 863| 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; ------------------ | | 863| 1.44k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ | Branch (35461:21): [True: 110, False: 1.33k] ------------------ 35462| 1.33k| break; 35463| 1.33k| case JANET_ABSTRACT: ------------------ | Branch (35463:13): [True: 54, False: 18.7M] ------------------ 35464| 54| if (janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y))) return 0; ------------------ | | 866| 54|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y))) return 0; ------------------ | | 866| 54|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (35464:21): [True: 54, False: 0] ------------------ 35465| 0| break; 35466| 18.1M| default: ------------------ | Branch (35466:13): [True: 18.1M, False: 594k] ------------------ 35467| 18.1M| if (janet_unwrap_pointer(x) != janet_unwrap_pointer(y)) return 0; ------------------ | | 867| 18.1M|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_unwrap_pointer(x) != janet_unwrap_pointer(y)) return 0; ------------------ | | 867| 18.1M|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (35467:21): [True: 14.7M, False: 3.41M] ------------------ 35468| 3.41M| break; 35469| 3.41M| case JANET_TUPLE: { ------------------ | Branch (35469:13): [True: 7.67k, False: 18.7M] ------------------ 35470| 7.67k| const Janet *t1 = janet_unwrap_tuple(x); ------------------ | | 858| 7.67k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 35471| 7.67k| const Janet *t2 = janet_unwrap_tuple(y); ------------------ | | 858| 7.67k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 35472| 7.67k| if (t1 == t2) break; ------------------ | Branch (35472:21): [True: 524, False: 7.14k] ------------------ 35473| 7.14k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1797| 7.14k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1805| 7.14k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1799| 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; ------------------ | | 1805| 7.14k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1799| 7.14k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (35473:21): [True: 1.21k, False: 5.92k] ------------------ 35474| 5.92k| if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1802| 5.92k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1799| 5.92k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1802| 5.92k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1799| 5.92k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (35474:21): [True: 1.54k, False: 4.38k] ------------------ 35475| 4.38k| if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1801| 4.38k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1799| 4.38k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1801| 4.38k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1799| 4.38k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (35475:21): [True: 0, False: 4.38k] ------------------ 35476| 4.38k| push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1799| 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); ------------------ | | 1799| 4.38k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 35477| 4.38k| break; 35478| 4.38k| } 35479| 0| break; 35480| 12.6k| case JANET_STRUCT: { ------------------ | Branch (35480:13): [True: 12.6k, False: 18.7M] ------------------ 35481| 12.6k| const JanetKV *s1 = janet_unwrap_struct(x); ------------------ | | 857| 12.6k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 35482| 12.6k| const JanetKV *s2 = janet_unwrap_struct(y); ------------------ | | 857| 12.6k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 35483| 12.6k| if (s1 == s2) break; ------------------ | Branch (35483:21): [True: 608, False: 12.0k] ------------------ 35484| 12.0k| if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1849| 12.0k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 12.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1849| 12.0k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 12.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (35484:21): [True: 982, False: 11.0k] ------------------ 35485| 11.0k| if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1847| 11.0k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1845| 11.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1847| 11.0k|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1845| 11.0k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (35485:21): [True: 210, False: 10.8k] ------------------ 35486| 10.8k| if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1850| 21.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1845| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1850:31): [True: 1.92k, False: 8.88k] | | ------------------ ------------------ if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1850| 1.92k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1845| 1.92k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (35486:47): [True: 0, False: 1.92k] ------------------ 35487| 10.8k| if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1850| 21.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1845| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1850| 8.88k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1845| 8.88k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1850:31): [True: 0, False: 8.88k] | | ------------------ ------------------ | Branch (35487:21): [True: 8.88k, False: 1.92k] ------------------ 35488| 10.8k| push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1845| 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); ------------------ | | 1845| 10.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 35489| 10.8k| break; 35490| 10.8k| } 35491| 0| break; 35492| 18.7M| } 35493| 18.7M| } while (!traversal_next(&x, &y)); ------------------ | Branch (35493:14): [True: 52.0k, False: 3.81M] ------------------ 35494| 3.81M| return 1; 35495| 20.8M|} janet_hash: 35507| 64.4M|int32_t janet_hash(Janet x) { 35508| 64.4M| int32_t hash = 0; 35509| 64.4M| switch (janet_type(x)) { ------------------ | | 795| 64.4M| (isnan((x).number) \ | | 796| 64.4M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 64.4M| : JANET_NUMBER) ------------------ | Branch (35509:13): [True: 57.0M, False: 7.38M] ------------------ 35510| 2.30M| case JANET_NIL: ------------------ | Branch (35510:9): [True: 2.30M, False: 62.1M] ------------------ 35511| 2.30M| hash = 0; 35512| 2.30M| break; 35513| 285k| case JANET_BOOLEAN: ------------------ | Branch (35513:9): [True: 285k, False: 64.1M] ------------------ 35514| 285k| hash = janet_unwrap_boolean(x); ------------------ | | 838| 285k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 35515| 285k| break; 35516| 2.66M| case JANET_STRING: ------------------ | Branch (35516:9): [True: 2.66M, False: 61.7M] ------------------ 35517| 24.9M| case JANET_SYMBOL: ------------------ | Branch (35517:9): [True: 22.2M, False: 42.1M] ------------------ 35518| 46.1M| case JANET_KEYWORD: ------------------ | Branch (35518:9): [True: 21.2M, False: 43.1M] ------------------ 35519| 46.1M| hash = janet_string_hash(janet_unwrap_string(x)); ------------------ | | 1813| 46.1M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1811| 46.1M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 35520| 46.1M| break; 35521| 92.5k| case JANET_TUPLE: ------------------ | Branch (35521:9): [True: 92.5k, False: 64.3M] ------------------ 35522| 92.5k| hash = janet_tuple_hash(janet_unwrap_tuple(x)); ------------------ | | 1802| 92.5k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1799| 92.5k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 35523| 92.5k| uint32_t inc = (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0; ------------------ | | 1805| 92.5k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1799| 92.5k|#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; ------------------ | | 1797| 92.5k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (35523:28): [True: 62.6k, False: 29.8k] ------------------ 35524| 92.5k| hash = (int32_t)((uint32_t)hash + inc); /* avoid overflow undefined behavior */ 35525| 92.5k| break; 35526| 343k| case JANET_STRUCT: ------------------ | Branch (35526:9): [True: 343k, False: 64.0M] ------------------ 35527| 343k| hash = janet_struct_hash(janet_unwrap_struct(x)); ------------------ | | 1849| 343k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 343k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35528| 343k| break; 35529| 7.38M| case JANET_NUMBER: { ------------------ | Branch (35529:9): [True: 7.38M, False: 57.0M] ------------------ 35530| 7.38M| union { 35531| 7.38M| double d; 35532| 7.38M| uint64_t u; 35533| 7.38M| } as; 35534| 7.38M| as.d = janet_unwrap_number(x); ------------------ | | 839| 7.38M|#define janet_unwrap_number(x) ((x).number) ------------------ 35535| 7.38M| as.d += 0.0; /* normalize negative 0 */ 35536| 7.38M| as.u = murmur64(as.u); 35537| 7.38M| uint32_t hi = (uint32_t)(as.u >> 32); 35538| 7.38M| hash = (int32_t)hi; 35539| 7.38M| break; 35540| 24.9M| } 35541| 29.0k| case JANET_ABSTRACT: { ------------------ | Branch (35541:9): [True: 29.0k, False: 64.4M] ------------------ 35542| 29.0k| JanetAbstract xx = janet_unwrap_abstract(x); ------------------ | | 866| 29.0k|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 35543| 29.0k| const JanetAbstractType *at = janet_abstract_type(xx); ------------------ | | 1898| 29.0k|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1896| 29.0k|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 35544| 29.0k| if (at->hash != NULL) { ------------------ | Branch (35544:17): [True: 0, False: 29.0k] ------------------ 35545| 0| hash = at->hash(xx, janet_abstract_size(xx)); ------------------ | | 1899| 0|#define janet_abstract_size(u) (janet_abstract_head(u)->size) | | ------------------ | | | | 1896| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 35546| 0| break; 35547| 0| } 35548| 29.0k| } 35549| | /* fallthrough */ 35550| 7.87M| default: ------------------ | Branch (35550:9): [True: 7.85M, False: 56.5M] ------------------ 35551| 7.87M| if (sizeof(double) == sizeof(void *)) { ------------------ | Branch (35551:17): [True: 7.87M, Folded] ------------------ 35552| | /* Assuming 8 byte pointer (8 byte aligned) */ 35553| 7.87M| uint64_t i = murmur64(janet_u64(x)); ------------------ | | 788| 7.87M|#define janet_u64(x) ((x).u64) ------------------ 35554| 7.87M| hash = (int32_t)(i >> 32); 35555| 7.87M| } else { 35556| | /* Assuming 4 byte pointer (or smaller) */ 35557| 0| uintptr_t diff = (uintptr_t) janet_unwrap_pointer(x); ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ 35558| 0| uint32_t hilo = (uint32_t) diff * 2654435769u; 35559| 0| hash = (int32_t)((hilo << 16) | (hilo >> 16)); 35560| 0| } 35561| 7.87M| break; 35562| 64.4M| } 35563| 64.4M| return hash; 35564| 64.4M|} janet_compare: 35569| 422k|int janet_compare(Janet x, Janet y) { 35570| 422k| janet_vm.traversal = janet_vm.traversal_base; 35571| 422k| int status; 35572| 536k| do { 35573| 536k| JanetType tx = janet_type(x); ------------------ | | 795| 536k| (isnan((x).number) \ | | 796| 536k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 536k| : JANET_NUMBER) ------------------ | Branch (35573:24): [True: 197k, False: 339k] ------------------ 35574| 536k| JanetType ty = janet_type(y); ------------------ | | 795| 536k| (isnan((x).number) \ | | 796| 536k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 536k| : JANET_NUMBER) ------------------ | Branch (35574:24): [True: 217k, False: 319k] ------------------ 35575| 536k| if (tx != ty) return tx < ty ? -1 : 1; ------------------ | Branch (35575:13): [True: 50.3k, False: 486k] | Branch (35575:30): [True: 35.3k, False: 14.9k] ------------------ 35576| 486k| switch (tx) { 35577| 107k| case JANET_NIL: ------------------ | Branch (35577:13): [True: 107k, False: 379k] ------------------ 35578| 107k| break; 35579| 11.8k| case JANET_BOOLEAN: { ------------------ | Branch (35579:13): [True: 11.8k, False: 474k] ------------------ 35580| 11.8k| int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 838| 11.8k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 838| 11.8k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 35581| 11.8k| if (diff) return diff; ------------------ | Branch (35581:21): [True: 0, False: 11.8k] ------------------ 35582| 11.8k| break; 35583| 11.8k| } 35584| 304k| case JANET_NUMBER: { ------------------ | Branch (35584:13): [True: 304k, False: 181k] ------------------ 35585| 304k| double xx = janet_unwrap_number(x); ------------------ | | 839| 304k|#define janet_unwrap_number(x) ((x).number) ------------------ 35586| 304k| double yy = janet_unwrap_number(y); ------------------ | | 839| 304k|#define janet_unwrap_number(x) ((x).number) ------------------ 35587| 304k| if (xx == yy) { ------------------ | Branch (35587:21): [True: 304k, False: 234] ------------------ 35588| 304k| break; 35589| 304k| } else { 35590| 234| return (xx < yy) ? -1 : 1; ------------------ | Branch (35590:28): [True: 0, False: 234] ------------------ 35591| 234| } 35592| 304k| } 35593| 1.10k| case JANET_STRING: ------------------ | Branch (35593:13): [True: 1.10k, False: 485k] ------------------ 35594| 2.98k| case JANET_SYMBOL: ------------------ | Branch (35594:13): [True: 1.87k, False: 484k] ------------------ 35595| 3.40k| case JANET_KEYWORD: { ------------------ | Branch (35595:13): [True: 422, False: 486k] ------------------ 35596| 3.40k| int diff = janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 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)); ------------------ | | 863| 3.40k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 35597| 3.40k| if (diff) return diff; ------------------ | Branch (35597:21): [True: 228, False: 3.17k] ------------------ 35598| 3.17k| break; 35599| 3.40k| } 35600| 3.17k| case JANET_ABSTRACT: { ------------------ | Branch (35600:13): [True: 0, False: 486k] ------------------ 35601| 0| int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 35602| 0| if (diff) return diff; ------------------ | Branch (35602:21): [True: 0, False: 0] ------------------ 35603| 0| break; 35604| 0| } 35605| 464| default: { ------------------ | Branch (35605:13): [True: 464, False: 486k] ------------------ 35606| 464| if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 867| 464|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 867| 464|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (35606:21): [True: 464, False: 0] ------------------ 35607| 464| break; 35608| 464| } else { 35609| 0| return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (35609:28): [True: 0, False: 0] ------------------ 35610| 0| } 35611| 464| } 35612| 7.70k| case JANET_TUPLE: { ------------------ | Branch (35612:13): [True: 7.70k, False: 478k] ------------------ 35613| 7.70k| const Janet *lhs = janet_unwrap_tuple(x); ------------------ | | 858| 7.70k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 35614| 7.70k| const Janet *rhs = janet_unwrap_tuple(y); ------------------ | | 858| 7.70k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 35615| 7.70k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1797| 7.70k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1805| 7.70k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1799| 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))) { ------------------ | | 1805| 7.70k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1799| 7.70k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (35615:21): [True: 0, False: 7.70k] ------------------ 35616| 0| return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1805| 0|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1799| 0|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1797| 0|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (35616:28): [True: 0, False: 0] ------------------ 35617| 0| } 35618| 7.70k| push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1799| 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); ------------------ | | 1799| 7.70k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 35619| 7.70k| break; 35620| 7.70k| } 35621| 50.8k| case JANET_STRUCT: { ------------------ | Branch (35621:13): [True: 50.8k, False: 435k] ------------------ 35622| 50.8k| const JanetKV *lhs = janet_unwrap_struct(x); ------------------ | | 857| 50.8k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 35623| 50.8k| const JanetKV *rhs = janet_unwrap_struct(y); ------------------ | | 857| 50.8k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 35624| 50.8k| int32_t llen = janet_struct_capacity(lhs); ------------------ | | 1848| 50.8k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1845| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35625| 50.8k| int32_t rlen = janet_struct_capacity(rhs); ------------------ | | 1848| 50.8k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1845| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35626| 50.8k| int32_t lhash = janet_struct_hash(lhs); ------------------ | | 1849| 50.8k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35627| 50.8k| int32_t rhash = janet_struct_hash(rhs); ------------------ | | 1849| 50.8k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1845| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35628| 50.8k| if (llen < rlen) return -1; ------------------ | Branch (35628:21): [True: 0, False: 50.8k] ------------------ 35629| 50.8k| if (llen > rlen) return 1; ------------------ | Branch (35629:21): [True: 0, False: 50.8k] ------------------ 35630| 50.8k| if (lhash < rhash) return -1; ------------------ | Branch (35630:21): [True: 0, False: 50.8k] ------------------ 35631| 50.8k| if (lhash > rhash) return 1; ------------------ | Branch (35631:21): [True: 0, False: 50.8k] ------------------ 35632| 50.8k| push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1845| 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); ------------------ | | 1845| 50.8k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 35633| 50.8k| break; 35634| 50.8k| } 35635| 486k| } 35636| 486k| } while (!(status = traversal_next(&x, &y))); ------------------ | Branch (35636:14): [True: 114k, False: 371k] ------------------ 35637| 371k| return status - 2; 35638| 422k|} janet_v_grow: 36042| 114k|void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) { 36043| 114k| int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0; ------------------ | | 720| 99.9k|#define janet_v__cap(v) janet_v__raw(v)[0] | | ------------------ | | | | 719| 99.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ | Branch (36043:23): [True: 99.9k, False: 14.6k] ------------------ 36044| 114k| int32_t min_needed = janet_v_count(v) + increment; ------------------ | | 714| 114k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 721| 99.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 99.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (714:34): [True: 99.9k, False: 14.6k] | | ------------------ ------------------ 36045| 114k| int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed; ------------------ | Branch (36045:17): [True: 87.7k, False: 26.8k] ------------------ 36046| 114k| size_t newsize = ((size_t) itemsize) * m + sizeof(int32_t) * 2; 36047| 114k| int32_t *p = (int32_t *) janet_srealloc(v ? janet_v__raw(v) : 0, newsize); ------------------ | | 719| 99.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) ------------------ | Branch (36047:45): [True: 99.9k, False: 14.6k] ------------------ 36048| 114k| if (!v) p[1] = 0; ------------------ | Branch (36048:9): [True: 14.6k, False: 99.9k] ------------------ 36049| 114k| p[0] = m; 36050| 114k| return p + 2; 36051| 114k|} janet_try_init: 37558| 3.22k|void janet_try_init(JanetTryState *state) { 37559| 3.22k| state->stackn = janet_vm.stackn++; 37560| 3.22k| state->gc_handle = janet_vm.gc_suspend; 37561| 3.22k| state->vm_fiber = janet_vm.fiber; 37562| 3.22k| state->vm_jmp_buf = janet_vm.signal_buf; 37563| 3.22k| state->vm_return_reg = janet_vm.return_reg; 37564| 3.22k| state->coerce_error = janet_vm.coerce_error; 37565| 3.22k| janet_vm.return_reg = &(state->payload); 37566| 3.22k| janet_vm.signal_buf = &(state->buf); 37567| 3.22k| janet_vm.coerce_error = 0; 37568| 3.22k|} janet_restore: 37570| 3.22k|void janet_restore(JanetTryState *state) { 37571| 3.22k| janet_vm.stackn = state->stackn; 37572| 3.22k| janet_vm.gc_suspend = state->gc_handle; 37573| 3.22k| janet_vm.fiber = state->vm_fiber; 37574| 3.22k| janet_vm.signal_buf = state->vm_jmp_buf; 37575| 3.22k| janet_vm.return_reg = state->vm_return_reg; 37576| 3.22k| janet_vm.coerce_error = state->coerce_error; 37577| 3.22k|} janet_init: 37732| 3.22k|int janet_init(void) { 37733| | 37734| | /* Garbage collection */ 37735| 3.22k| janet_vm.blocks = NULL; 37736| 3.22k| janet_vm.weak_blocks = NULL; 37737| 3.22k| janet_vm.next_collection = 0; 37738| 3.22k| janet_vm.gc_interval = 0x400000; 37739| 3.22k| janet_vm.block_count = 0; 37740| 3.22k| janet_vm.gc_mark_phase = 0; 37741| | 37742| 3.22k| janet_symcache_init(); 37743| | 37744| | /* Initialize gc roots */ 37745| 3.22k| janet_vm.roots = NULL; 37746| 3.22k| janet_vm.root_count = 0; 37747| 3.22k| janet_vm.root_capacity = 0; 37748| | 37749| | /* Scratch memory */ 37750| 3.22k| janet_vm.user = NULL; 37751| 3.22k| janet_vm.scratch_mem = NULL; 37752| 3.22k| janet_vm.scratch_len = 0; 37753| 3.22k| janet_vm.scratch_cap = 0; 37754| | 37755| | /* Sandbox flags */ 37756| 3.22k| janet_vm.sandbox_flags = 0; 37757| | 37758| | /* Initialize registry */ 37759| 3.22k| janet_vm.registry = NULL; 37760| 3.22k| janet_vm.registry_cap = 0; 37761| 3.22k| janet_vm.registry_count = 0; 37762| 3.22k| janet_vm.registry_dirty = 0; 37763| | 37764| | /* Initialize abstract registry */ 37765| 3.22k| janet_vm.abstract_registry = janet_table(0); 37766| 3.22k| janet_gcroot(janet_wrap_table(janet_vm.abstract_registry)); ------------------ | | 846| 3.22k|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 3.22k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 3.22k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.22k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37767| | 37768| | /* Traversal */ 37769| 3.22k| janet_vm.traversal = NULL; 37770| 3.22k| janet_vm.traversal_base = NULL; 37771| 3.22k| janet_vm.traversal_top = NULL; 37772| | 37773| | /* Core env */ 37774| 3.22k| janet_vm.core_env = NULL; 37775| | 37776| | /* Auto suspension */ 37777| 3.22k| janet_vm.auto_suspend = 0; 37778| | 37779| | /* Dynamic bindings */ 37780| 3.22k| janet_vm.top_dyns = NULL; 37781| | 37782| | /* Seed RNG */ 37783| 3.22k| janet_rng_seed(janet_default_rng(), 0); 37784| | 37785| | /* Fibers */ 37786| 3.22k| janet_vm.fiber = NULL; 37787| 3.22k| janet_vm.root_fiber = NULL; 37788| 3.22k| janet_vm.stackn = 0; 37789| | 37790| 3.22k|#ifdef JANET_EV 37791| 3.22k| janet_ev_init(); 37792| 3.22k|#endif 37793| 3.22k|#ifdef JANET_NET 37794| 3.22k| janet_net_init(); 37795| 3.22k|#endif 37796| 3.22k| return 0; 37797| 3.22k|} janet_deinit: 37812| 3.22k|void janet_deinit(void) { 37813| 3.22k| janet_clear_memory(); 37814| 3.22k| janet_symcache_deinit(); 37815| 3.22k| janet_free(janet_vm.roots); ------------------ | | 2415| 3.22k|#define janet_free(X) free((X)) ------------------ 37816| 3.22k| janet_vm.roots = NULL; 37817| 3.22k| janet_vm.root_count = 0; 37818| 3.22k| janet_vm.root_capacity = 0; 37819| 3.22k| janet_vm.abstract_registry = NULL; 37820| 3.22k| janet_vm.core_env = NULL; 37821| 3.22k| janet_vm.top_dyns = NULL; 37822| 3.22k| janet_vm.user = NULL; 37823| 3.22k| janet_free(janet_vm.traversal_base); ------------------ | | 2415| 3.22k|#define janet_free(X) free((X)) ------------------ 37824| 3.22k| janet_vm.fiber = NULL; 37825| 3.22k| janet_vm.root_fiber = NULL; 37826| 3.22k| janet_free(janet_vm.registry); ------------------ | | 2415| 3.22k|#define janet_free(X) free((X)) ------------------ 37827| | janet_vm.registry = NULL; 37828| 3.22k|#ifdef JANET_EV 37829| 3.22k| janet_ev_deinit(); 37830| 3.22k|#endif 37831| 3.22k|#ifdef JANET_NET 37832| 3.22k| janet_net_deinit(); 37833| 3.22k|#endif 37834| 3.22k|} janet_memalloc_empty: 38002| 4.52M|void *janet_memalloc_empty(int32_t count) { 38003| 4.52M| int32_t i; 38004| 4.52M| void *mem = array_allocate(sizeof(JanetKV), count); 38005| 4.52M| janet_vm.next_collection += (size_t) count * sizeof(JanetKV); 38006| 4.52M| if (NULL == mem) { ------------------ | Branch (38006:9): [True: 0, False: 4.52M] ------------------ 38007| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 38008| 0| } 38009| 4.52M| JanetKV *mmem = (JanetKV *)mem; 38010| 80.0M| for (i = 0; i < count; i++) { ------------------ | Branch (38010:17): [True: 75.5M, False: 4.52M] ------------------ 38011| 75.5M| JanetKV *kv = mmem + i; 38012| 75.5M| kv->key = janet_wrap_nil(); ------------------ | | 831| 75.5M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 75.5M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 75.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 75.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38013| 75.5M| kv->value = janet_wrap_nil(); ------------------ | | 831| 75.5M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 75.5M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 75.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 75.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38014| 75.5M| } 38015| 4.52M| return mem; 38016| 4.52M|} janet_memempty: 38018| 441k|void janet_memempty(JanetKV *mem, int32_t count) { 38019| 441k| int32_t i; 38020| 7.35M| for (i = 0; i < count; i++) { ------------------ | Branch (38020:17): [True: 6.91M, False: 441k] ------------------ 38021| 6.91M| mem[i].key = janet_wrap_nil(); ------------------ | | 831| 6.91M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 6.91M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 6.91M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.91M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38022| 6.91M| mem[i].value = janet_wrap_nil(); ------------------ | | 831| 6.91M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 6.91M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 6.91M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.91M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38023| 6.91M| } 38024| 441k|} janet_wrap_number_safe: 38028| 28.0k|Janet janet_wrap_number_safe(double d) { 38029| 28.0k| Janet ret; 38030| 28.0k| ret.number = isnan(d) ? NAN : d; ------------------ | Branch (38030:18): [True: 4.30k, False: 23.7k] ------------------ 38031| 28.0k| return ret; 38032| 28.0k|} janet_nanbox_to_pointer: 38034| 106M|void *janet_nanbox_to_pointer(Janet x) { 38035| 106M| x.i64 &= JANET_NANBOX_PAYLOADBITS; ------------------ | | 791| 106M|#define JANET_NANBOX_PAYLOADBITS 0x00007FFFFFFFFFFFllu ------------------ 38036| 106M| x.u64 <<= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 106M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 38037| 106M| return x.pointer; 38038| 106M|} janet_nanbox_from_pointer: 38040| 5.02M|Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask) { 38041| 5.02M| Janet ret; 38042| 5.02M| ret.pointer = p; 38043| | /* Should be noop when pointer shift is 0 */ 38044| | /* 38045| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 38046| | */ 38047| 5.02M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 5.02M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 38048| 5.02M| ret.u64 |= tagmask; 38049| 5.02M| return ret; 38050| 5.02M|} janet_nanbox_from_cpointer: 38052| 19.1M|Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask) { 38053| 19.1M| Janet ret; 38054| 19.1M| ret.pointer = (void *)p; 38055| | /* Should be noop when pointer shift is 0 */ 38056| | /* 38057| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 38058| | */ 38059| 19.1M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 19.1M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 38060| 19.1M| ret.u64 |= tagmask; 38061| 19.1M| return ret; 38062| 19.1M|} janet_nanbox_from_double: 38064| 7.78M|Janet janet_nanbox_from_double(double d) { 38065| 7.78M| Janet ret; 38066| 7.78M| ret.number = d; 38067| 7.78M| return ret; 38068| 7.78M|} janet_nanbox_from_bits: 38070| 624M|Janet janet_nanbox_from_bits(uint64_t bits) { 38071| 624M| Janet ret; 38072| 624M| ret.u64 = bits; 38073| 624M| return ret; 38074| 624M|} janet.c:janet_array_impl: 1555| 33.2k|static void janet_array_impl(JanetArray *array, int32_t capacity) { 1556| 33.2k| Janet *data = NULL; 1557| 33.2k| if (capacity > 0) { ------------------ | Branch (1557:9): [True: 19.5k, False: 13.7k] ------------------ 1558| 19.5k| janet_vm.next_collection += capacity * sizeof(Janet); 1559| 19.5k| data = (Janet *) array_allocate(sizeof(Janet), capacity); 1560| 19.5k| if (NULL == data) { ------------------ | Branch (1560:13): [True: 0, False: 19.5k] ------------------ 1561| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 1562| 0| } 1563| 19.5k| } 1564| 33.2k| array->count = 0; 1565| 33.2k| array->capacity = capacity; 1566| 33.2k| array->data = data; 1567| 33.2k|} janet.c:janet_buffer_init_impl: 3122| 6.03k|static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) { 3123| 6.03k| uint8_t *data = NULL; 3124| 6.03k| if (capacity < 4) capacity = 4; ------------------ | Branch (3124:9): [True: 4.16k, False: 1.87k] ------------------ 3125| 6.03k| janet_gcpressure(capacity); 3126| 6.03k| data = array_allocate(sizeof(uint8_t), capacity); 3127| 6.03k| if (NULL == data) { ------------------ | Branch (3127:9): [True: 0, False: 6.03k] ------------------ 3128| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 3129| 0| } 3130| 6.03k| buffer->count = 0; 3131| 6.03k| buffer->capacity = capacity; 3132| 6.03k| buffer->data = data; 3133| 6.03k| return buffer; 3134| 6.03k|} janet.c:janet_buffer_can_realloc: 3115| 1.78k|static void janet_buffer_can_realloc(JanetBuffer *buffer) { 3116| 1.78k| if (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) { ------------------ | | 1779| 1.78k|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3116:9): [True: 0, False: 1.78k] ------------------ 3117| 0| janet_panic("buffer cannot reallocate foreign memory"); 3118| 0| } 3119| 1.78k|} janet.c:janet_load_libs: 7812| 3.22k|static void janet_load_libs(JanetTable *env) { 7813| 3.22k| JanetRegExt corelib_cfuns[] = { 7814| 3.22k| JANET_CORE_REG("native", janet_core_native), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7815| 3.22k| JANET_CORE_REG("describe", janet_core_describe), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7816| 3.22k| JANET_CORE_REG("string", janet_core_string), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7817| 3.22k| JANET_CORE_REG("symbol", janet_core_symbol), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7818| 3.22k| JANET_CORE_REG("keyword", janet_core_keyword), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7819| 3.22k| JANET_CORE_REG("buffer", janet_core_buffer), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7820| 3.22k| JANET_CORE_REG("abstract?", janet_core_is_abstract), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7821| 3.22k| JANET_CORE_REG("table", janet_core_table), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7822| 3.22k| JANET_CORE_REG("array", janet_core_array), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7823| 3.22k| JANET_CORE_REG("scan-number", janet_core_scannumber), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7824| 3.22k| JANET_CORE_REG("tuple", janet_core_tuple), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7825| 3.22k| JANET_CORE_REG("struct", janet_core_struct), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7826| 3.22k| JANET_CORE_REG("gensym", janet_core_gensym), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7827| 3.22k| JANET_CORE_REG("gccollect", janet_core_gccollect), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7828| 3.22k| JANET_CORE_REG("gcsetinterval", janet_core_gcsetinterval), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7829| 3.22k| JANET_CORE_REG("gcinterval", janet_core_gcinterval), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7830| 3.22k| JANET_CORE_REG("type", janet_core_type), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7831| 3.22k| JANET_CORE_REG("hash", janet_core_hash), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7832| 3.22k| JANET_CORE_REG("getline", janet_core_getline), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7833| 3.22k| JANET_CORE_REG("dyn", janet_core_dyn), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7834| 3.22k| JANET_CORE_REG("setdyn", janet_core_setdyn), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7835| 3.22k| JANET_CORE_REG("trace", janet_core_trace), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7836| 3.22k| JANET_CORE_REG("untrace", janet_core_untrace), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7837| 3.22k| JANET_CORE_REG("module/expand-path", janet_core_expand_path), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7838| 3.22k| JANET_CORE_REG("int?", janet_core_check_int), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7839| 3.22k| JANET_CORE_REG("nat?", janet_core_check_nat), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7840| 3.22k| JANET_CORE_REG("bytes?", janet_core_is_bytes), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7841| 3.22k| JANET_CORE_REG("indexed?", janet_core_is_indexed), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7842| 3.22k| JANET_CORE_REG("dictionary?", janet_core_is_dictionary), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7843| 3.22k| JANET_CORE_REG("lengthable?", janet_core_is_lengthable), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7844| 3.22k| JANET_CORE_REG("slice", janet_core_slice), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7845| 3.22k| JANET_CORE_REG("range", janet_core_range), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7846| 3.22k| JANET_CORE_REG("signal", janet_core_signal), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7847| 3.22k| JANET_CORE_REG("memcmp", janet_core_memcmp), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7848| 3.22k| JANET_CORE_REG("getproto", janet_core_getproto), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7849| 3.22k| JANET_CORE_REG("sandbox", janet_core_sandbox), ------------------ | | 479| 3.22k|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2119| 3.22k|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 7850| 3.22k| JANET_REG_END ------------------ | | 2109| 3.22k|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 7851| 3.22k| }; 7852| | janet_core_cfuns_ext(env, NULL, corelib_cfuns); 7853| 3.22k| janet_lib_io(env); 7854| 3.22k| janet_lib_math(env); 7855| 3.22k| janet_lib_array(env); 7856| 3.22k| janet_lib_tuple(env); 7857| 3.22k| janet_lib_buffer(env); 7858| 3.22k| janet_lib_table(env); 7859| 3.22k| janet_lib_struct(env); 7860| 3.22k| janet_lib_fiber(env); 7861| 3.22k| janet_lib_os(env); 7862| 3.22k| janet_lib_parse(env); 7863| 3.22k| janet_lib_compile(env); 7864| 3.22k| janet_lib_debug(env); 7865| 3.22k| janet_lib_string(env); 7866| 3.22k| janet_lib_marsh(env); 7867| 3.22k|#ifdef JANET_PEG 7868| 3.22k| janet_lib_peg(env); 7869| 3.22k|#endif 7870| 3.22k|#ifdef JANET_ASSEMBLER 7871| 3.22k| janet_lib_asm(env); 7872| 3.22k|#endif 7873| 3.22k|#ifdef JANET_INT_TYPES 7874| 3.22k| janet_lib_inttypes(env); 7875| 3.22k|#endif 7876| 3.22k|#ifdef JANET_EV 7877| 3.22k| janet_lib_ev(env); 7878| 3.22k|#ifdef JANET_FILEWATCH 7879| 3.22k| janet_lib_filewatch(env); 7880| 3.22k|#endif 7881| 3.22k|#endif 7882| 3.22k|#ifdef JANET_NET 7883| 3.22k| janet_lib_net(env); 7884| 3.22k|#endif 7885| 3.22k|#ifdef JANET_FFI 7886| 3.22k| janet_lib_ffi(env); 7887| 3.22k|#endif 7888| 3.22k|} janet.c:janet_q_init: 9107| 3.22k|static void janet_q_init(JanetQueue *q) { 9108| | q->data = NULL; 9109| 3.22k| q->head = 0; 9110| 3.22k| q->tail = 0; 9111| 3.22k| q->capacity = 0; 9112| 3.22k|} janet.c:peek_timeout: 9189| 3.22k|static int peek_timeout(JanetTimeout *out) { 9190| 3.22k| if (janet_vm.tq_count == 0) return 0; ------------------ | Branch (9190:9): [True: 3.22k, False: 0] ------------------ 9191| 0| *out = janet_vm.tq[0]; 9192| 0| return 1; 9193| 3.22k|} janet.c:janet_q_deinit: 9114| 3.22k|static void janet_q_deinit(JanetQueue *q) { 9115| 3.22k| janet_free(q->data); ------------------ | | 2415| 3.22k|#define janet_free(X) free((X)) ------------------ 9116| 3.22k|} janet.c:janet_ev_setup_selfpipe: 10607| 3.22k|static void janet_ev_setup_selfpipe(void) { 10608| 3.22k| if (janet_make_pipe(janet_vm.selfpipe, 1)) { ------------------ | Branch (10608:9): [True: 0, False: 3.22k] ------------------ 10609| | JANET_EXIT("failed to initialize self pipe in event loop"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 10610| 0| } 10611| 3.22k|} janet.c:janet_ev_cleanup_selfpipe: 10630| 3.22k|static void janet_ev_cleanup_selfpipe(void) { 10631| 3.22k| close(janet_vm.selfpipe[0]); 10632| 3.22k| close(janet_vm.selfpipe[1]); 10633| 3.22k|} janet.c:janet_deinit_block: 16570| 19.7M|static void janet_deinit_block(JanetGCObject *mem) { 16571| 19.7M| switch (mem->flags & JANET_MEM_TYPEBITS) { ------------------ | | 630| 19.7M|#define JANET_MEM_TYPEBITS 0xFF ------------------ 16572| 7.72M| default: ------------------ | Branch (16572:9): [True: 7.72M, False: 12.0M] ------------------ 16573| 8.98M| case JANET_MEMORY_FUNCTION: ------------------ | Branch (16573:9): [True: 1.26M, False: 18.5M] ------------------ 16574| 8.98M| break; /* Do nothing for non gc types */ 16575| 6.57M| case JANET_MEMORY_SYMBOL: ------------------ | Branch (16575:9): [True: 6.57M, False: 13.1M] ------------------ 16576| 6.57M| janet_symbol_deinit(((JanetStringHead *) mem)->data); 16577| 6.57M| break; 16578| 19.3k| case JANET_MEMORY_ARRAY: ------------------ | Branch (16578:9): [True: 19.3k, False: 19.7M] ------------------ 16579| 19.3k| case JANET_MEMORY_ARRAY_WEAK: ------------------ | Branch (16579:9): [True: 0, False: 19.7M] ------------------ 16580| 19.3k| janet_free(((JanetArray *) mem)->data); ------------------ | | 2415| 19.3k|#define janet_free(X) free((X)) ------------------ 16581| 19.3k| break; 16582| 2.36M| case JANET_MEMORY_TABLE: ------------------ | Branch (16582:9): [True: 2.36M, False: 17.4M] ------------------ 16583| 2.36M| case JANET_MEMORY_TABLE_WEAKK: ------------------ | Branch (16583:9): [True: 0, False: 19.7M] ------------------ 16584| 2.36M| case JANET_MEMORY_TABLE_WEAKV: ------------------ | Branch (16584:9): [True: 0, False: 19.7M] ------------------ 16585| 2.36M| case JANET_MEMORY_TABLE_WEAKKV: ------------------ | Branch (16585:9): [True: 0, False: 19.7M] ------------------ 16586| 2.36M| janet_free(((JanetTable *) mem)->data); ------------------ | | 2415| 2.36M|#define janet_free(X) free((X)) ------------------ 16587| 2.36M| break; 16588| 3.39k| case JANET_MEMORY_FIBER: { ------------------ | Branch (16588:9): [True: 3.39k, False: 19.7M] ------------------ 16589| 3.39k| JanetFiber *f = (JanetFiber *)mem; 16590| 3.39k|#ifdef JANET_EV 16591| 3.39k| if (f->ev_state && !(f->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) { ------------------ | | 802| 0|#define JANET_FIBER_EV_FLAG_IN_FLIGHT 0x1 ------------------ | Branch (16591:17): [True: 0, False: 3.39k] | Branch (16591:32): [True: 0, False: 0] ------------------ 16592| 0| janet_ev_dec_refcount(); 16593| 0| janet_free(f->ev_state); ------------------ | | 2415| 0|#define janet_free(X) free((X)) ------------------ 16594| 3.39k| } else if (f->gc.flags & JANET_FIBER_EV_GCFLAG_SUSPENDED) { ------------------ | | 798| 3.39k|#define JANET_FIBER_EV_GCFLAG_SUSPENDED 0x2000000 ------------------ | Branch (16594:24): [True: 0, False: 3.39k] ------------------ 16595| 0| janet_ev_dec_refcount(); 16596| 0| } 16597| 3.39k|#endif 16598| 3.39k| janet_free(f->data); ------------------ | | 2415| 3.39k|#define janet_free(X) free((X)) ------------------ 16599| 3.39k| } 16600| 3.39k| break; 16601| 4.76k| case JANET_MEMORY_BUFFER: ------------------ | Branch (16601:9): [True: 4.76k, False: 19.7M] ------------------ 16602| 4.76k| janet_buffer_deinit((JanetBuffer *) mem); 16603| 4.76k| break; 16604| 9.68k| case JANET_MEMORY_ABSTRACT: { ------------------ | Branch (16604:9): [True: 9.68k, False: 19.7M] ------------------ 16605| 9.68k| JanetAbstractHead *head = (JanetAbstractHead *)mem; 16606| 9.68k| if (head->type->gcperthread) { ------------------ | Branch (16606:17): [True: 0, False: 9.68k] ------------------ 16607| 0| janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 16608| 0| } 16609| 9.68k| if (head->type->gc) { ------------------ | Branch (16609:17): [True: 9.68k, False: 0] ------------------ 16610| 9.68k| janet_assert(!head->type->gc(head->data, head->size), "finalizer failed"); ------------------ | | 389| 9.68k|#define janet_assert(c, m) do { \ | | 390| 9.68k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 9.68k] | | ------------------ | | 391| 9.68k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 9.68k] | | ------------------ ------------------ 16611| 9.68k| } 16612| 9.68k| } 16613| 9.68k| break; 16614| 45.0k| case JANET_MEMORY_FUNCENV: { ------------------ | Branch (16614:9): [True: 45.0k, False: 19.7M] ------------------ 16615| 45.0k| JanetFuncEnv *env = (JanetFuncEnv *)mem; 16616| 45.0k| if (0 == env->offset) ------------------ | Branch (16616:17): [True: 44.8k, False: 198] ------------------ 16617| 44.8k| janet_free(env->as.values); ------------------ | | 2415| 44.8k|#define janet_free(X) free((X)) ------------------ 16618| 45.0k| } 16619| 45.0k| break; 16620| 1.76M| case JANET_MEMORY_FUNCDEF: { ------------------ | Branch (16620:9): [True: 1.76M, False: 18.0M] ------------------ 16621| 1.76M| JanetFuncDef *def = (JanetFuncDef *)mem; 16622| | /* TODO - get this all with one alloc and one free */ 16623| 1.76M| janet_free(def->defs); ------------------ | | 2415| 1.76M|#define janet_free(X) free((X)) ------------------ 16624| 1.76M| janet_free(def->environments); ------------------ | | 2415| 1.76M|#define janet_free(X) free((X)) ------------------ 16625| 1.76M| janet_free(def->constants); ------------------ | | 2415| 1.76M|#define janet_free(X) free((X)) ------------------ 16626| 1.76M| janet_free(def->bytecode); ------------------ | | 2415| 1.76M|#define janet_free(X) free((X)) ------------------ 16627| 1.76M| janet_free(def->sourcemap); ------------------ | | 2415| 1.76M|#define janet_free(X) free((X)) ------------------ 16628| 1.76M| janet_free(def->closure_bitset); ------------------ | | 2415| 1.76M|#define janet_free(X) free((X)) ------------------ 16629| 1.76M| janet_free(def->symbolmap); ------------------ | | 2415| 1.76M|#define janet_free(X) free((X)) ------------------ 16630| 1.76M| } 16631| 1.76M| break; 16632| 19.7M| } 16633| 19.7M|} janet.c:janet_free_all_scratch: 16820| 3.22k|static void janet_free_all_scratch(void) { 16821| 7.92k| for (size_t i = 0; i < janet_vm.scratch_len; i++) { ------------------ | Branch (16821:24): [True: 4.69k, False: 3.22k] ------------------ 16822| 4.69k| free_one_scratch(janet_vm.scratch_mem[i]); 16823| 4.69k| } 16824| 3.22k| janet_vm.scratch_len = 0; 16825| 3.22k|} janet.c:janet_mem2scratch: 16827| 109k|static JanetScratch *janet_mem2scratch(void *mem) { 16828| 109k| JanetScratch *s = (JanetScratch *)mem; 16829| 109k| return s - 1; 16830| 109k|} janet.c:free_one_scratch: 16812| 14.6k|static void free_one_scratch(JanetScratch *s) { 16813| 14.6k| if (NULL != s->finalize) { ------------------ | Branch (16813:9): [True: 0, False: 14.6k] ------------------ 16814| 0| s->finalize((char *) s->mem); 16815| 0| } 16816| 14.6k| janet_free(s); ------------------ | | 2415| 14.6k|#define janet_free(X) free((X)) ------------------ 16817| 14.6k|} janet.c:makef: 17837| 9.68k|static void *makef(FILE *f, int32_t flags, size_t bufsize) { 17838| 9.68k| JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile)); 17839| 9.68k| iof->file = f; 17840| 9.68k| iof->flags = flags; 17841| 9.68k| iof->vbufsize = bufsize; 17842| 9.68k|#if !(defined(JANET_WINDOWS) || defined(JANET_PLAN9)) 17843| | /* While we would like fopen to set cloexec by default (like O_CLOEXEC) with the e flag, that is 17844| | * not standard. */ 17845| 9.68k| if (!(flags & JANET_FILE_NOT_CLOSEABLE)) ------------------ | | 2278| 9.68k|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ | Branch (17845:9): [True: 0, False: 9.68k] ------------------ 17846| 0| fcntl(fileno(f), F_SETFD, FD_CLOEXEC); 17847| 9.68k|#endif 17848| 9.68k| return iof; 17849| 9.68k|} janet.c:cfun_io_gc: 18040| 9.68k|static int cfun_io_gc(void *p, size_t len) { 18041| 9.68k| (void) len; 18042| 9.68k| JanetFile *iof = (JanetFile *)p; 18043| 9.68k| janet_file_close(iof); 18044| 9.68k| return 0; 18045| 9.68k|} janet.c:entry_getval: 18683| 2.26M|static Janet entry_getval(Janet env_entry) { 18684| 2.26M| if (janet_checktype(env_entry, JANET_TABLE)) { ------------------ | | 806| 2.26M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.26M, False: 0] | | | Branch (806:6): [Folded, False: 2.26M] | | ------------------ | | 807| 2.26M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.26M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.26M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.26M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18685| 2.26M| JanetTable *entry = janet_unwrap_table(env_entry); ------------------ | | 861| 2.26M|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 18686| 2.26M| Janet checkval = janet_table_get(entry, janet_ckeywordv("value")); ------------------ | | 1842| 2.26M|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 2.26M|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 2.26M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 2.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 2.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18687| 2.26M| if (janet_checktype(checkval, JANET_NIL)) { ------------------ | | 806| 2.26M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 2.26M] | | | Branch (806:6): [Folded, False: 2.26M] | | ------------------ | | 807| 2.26M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.26M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.26M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.26M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18688| 0| checkval = janet_table_get(entry, janet_ckeywordv("ref")); ------------------ | | 1842| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18689| 0| } 18690| 2.26M| return checkval; 18691| 2.26M| } else if (janet_checktype(env_entry, JANET_STRUCT)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18692| 0| const JanetKV *entry = janet_unwrap_struct(env_entry); ------------------ | | 857| 0|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 18693| 0| Janet checkval = janet_struct_get(entry, janet_ckeywordv("value")); ------------------ | | 1842| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18694| 0| if (janet_checktype(checkval, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18695| 0| checkval = janet_struct_get(entry, janet_ckeywordv("ref")); ------------------ | | 1842| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18696| 0| } 18697| 0| return checkval; 18698| 0| } else { 18699| 0| return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18700| 0| } 18701| 2.26M|} janet.c:readint: 19326| 230M|static int32_t readint(UnmarshalState *st, const uint8_t **atdata) { 19327| 230M| const uint8_t *data = *atdata; 19328| 230M| int32_t ret; 19329| 230M| MARSH_EOS(st, data); ------------------ | |19321| 230M|#define MARSH_EOS(st, data) do { \ | |19322| 230M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 108, False: 230M] | | ------------------ | |19323| 230M|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 230M] | | ------------------ ------------------ 19330| 230M| if (*data < 128) { ------------------ | Branch (19330:9): [True: 187M, False: 42.1M] ------------------ 19331| 187M| ret = *data++; 19332| 187M| } else if (*data < 192) { ------------------ | Branch (19332:16): [True: 39.8M, False: 2.27M] ------------------ 19333| 39.8M| MARSH_EOS(st, data + 1); ------------------ | |19321| 39.8M|#define MARSH_EOS(st, data) do { \ | |19322| 39.8M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 34, False: 39.8M] | | ------------------ | |19323| 39.8M|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 39.8M] | | ------------------ ------------------ 19334| 39.8M| uint32_t uret = ((data[0] & 0x3F) << 8) + data[1]; 19335| | /* Sign extend 18 MSBs */ 19336| 39.8M| uret |= (uret >> 13) ? 0xFFFFC000 : 0; ------------------ | Branch (19336:17): [True: 10.7M, False: 29.0M] ------------------ 19337| 39.8M| ret = (int32_t)uret; 19338| 39.8M| data += 2; 19339| 39.8M| } else if (*data == LB_INTEGER) { ------------------ | Branch (19339:16): [True: 2.27M, False: 241] ------------------ 19340| 2.27M| MARSH_EOS(st, data + 4); ------------------ | |19321| 2.27M|#define MARSH_EOS(st, data) do { \ | |19322| 2.27M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 7, False: 2.27M] | | ------------------ | |19323| 2.27M|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 2.27M] | | ------------------ ------------------ 19341| 2.27M| uint32_t ui = ((uint32_t)(data[1]) << 24) | 19342| 2.27M| ((uint32_t)(data[2]) << 16) | 19343| 2.27M| ((uint32_t)(data[3]) << 8) | 19344| 2.27M| (uint32_t)(data[4]); 19345| 2.27M| ret = (int32_t)ui; 19346| 2.27M| data += 5; 19347| 2.27M| } else { 19348| 241| janet_panicf("expected integer, got byte %x at index %d", 19349| 241| *data, 19350| 241| data - st->start); 19351| 0| ret = 0; 19352| 0| } 19353| 230M| *atdata = data; 19354| 230M| return ret; 19355| 230M|} janet.c:unmarshal_one: 19933| 64.2M| int flags) { 19934| 64.2M| uint8_t lead; 19935| 64.2M| MARSH_STACKCHECK; ------------------ | |18793| 64.2M|#define MARSH_STACKCHECK if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) janet_panic("stack overflow") | | ------------------ | | | | 296| 64.2M|#define JANET_RECURSION_GUARD 1024 | | ------------------ | | | Branch (18793:30): [True: 10, False: 64.2M] | | ------------------ ------------------ 19936| 64.2M| MARSH_EOS(st, data); ------------------ | |19321| 64.2M|#define MARSH_EOS(st, data) do { \ | |19322| 64.2M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 560, False: 64.2M] | | ------------------ | |19323| 64.2M|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 64.2M] | | ------------------ ------------------ 19937| 64.2M| lead = data[0]; 19938| 64.2M| if (lead < LB_REAL) { ------------------ | Branch (19938:9): [True: 7.76M, False: 56.5M] ------------------ 19939| 7.76M| *out = janet_wrap_integer(readint(st, &data)); ------------------ | | 967| 7.76M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 7.76M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 19940| 7.76M| return data; 19941| 7.76M| } 19942| 56.5M| switch (lead) { 19943| 244k| case LB_NIL: ------------------ | Branch (19943:9): [True: 244k, False: 56.2M] ------------------ 19944| 244k| *out = janet_wrap_nil(); ------------------ | | 831| 244k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 244k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 244k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 244k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19945| 244k| return data + 1; 19946| 131k| case LB_FALSE: ------------------ | Branch (19946:9): [True: 131k, False: 56.3M] ------------------ 19947| 131k| *out = janet_wrap_false(); ------------------ | | 833| 131k|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 131k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 131k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 131k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19948| 131k| return data + 1; 19949| 477k| case LB_TRUE: ------------------ | Branch (19949:9): [True: 477k, False: 56.0M] ------------------ 19950| 477k| *out = janet_wrap_true(); ------------------ | | 832| 477k|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 477k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 477k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 477k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19951| 477k| return data + 1; 19952| 24.8k| case LB_INTEGER: ------------------ | Branch (19952:9): [True: 24.8k, False: 56.4M] ------------------ 19953| | /* Long integer */ 19954| 24.8k| MARSH_EOS(st, data + 4); ------------------ | |19321| 24.8k|#define MARSH_EOS(st, data) do { \ | |19322| 24.8k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 7, False: 24.8k] | | ------------------ | |19323| 24.8k|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 24.8k] | | ------------------ ------------------ 19955| 24.8k| uint32_t ui = ((uint32_t)(data[4])) | 19956| 24.8k| ((uint32_t)(data[3]) << 8) | 19957| 24.8k| ((uint32_t)(data[2]) << 16) | 19958| 24.8k| ((uint32_t)(data[1]) << 24); 19959| 24.8k| int32_t si = (int32_t)ui; 19960| 24.8k| *out = janet_wrap_integer(si); ------------------ | | 967| 24.8k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 24.8k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 19961| 24.8k| return data + 5; 19962| 28.0k| case LB_REAL: ------------------ | Branch (19962:9): [True: 28.0k, False: 56.4M] ------------------ 19963| | /* Real */ 19964| 28.0k| { 19965| 28.0k| union { 19966| 28.0k| double d; 19967| 28.0k| uint8_t bytes[8]; 19968| 28.0k| } u; 19969| 28.0k| MARSH_EOS(st, data + 8); ------------------ | |19321| 28.0k|#define MARSH_EOS(st, data) do { \ | |19322| 28.0k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 17, False: 28.0k] | | ------------------ | |19323| 28.0k|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 28.0k] | | ------------------ ------------------ 19970| |#ifdef JANET_BIG_ENDIAN 19971| | u.bytes[0] = data[8]; 19972| | u.bytes[1] = data[7]; 19973| | u.bytes[2] = data[6]; 19974| | u.bytes[3] = data[5]; 19975| | u.bytes[4] = data[4]; 19976| | u.bytes[5] = data[3]; 19977| | u.bytes[6] = data[2]; 19978| | u.bytes[7] = data[1]; 19979| |#else 19980| 28.0k| memcpy(&u.bytes, data + 1, sizeof(double)); 19981| 28.0k|#endif 19982| 28.0k| *out = janet_wrap_number_safe(u.d); 19983| 28.0k| janet_v_push(st->lookup, *out); ------------------ | | 712| 28.0k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 28.0k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 28.0k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 27.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 27.9k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 27.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 55, False: 27.9k] | | | | | | | Branch (723:50): [True: 405, False: 27.5k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 28.0k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 28.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19984| 28.0k| return data + 9; 19985| 28.0k| } 19986| 4.75M| case LB_STRING: ------------------ | Branch (19986:9): [True: 4.75M, False: 51.7M] ------------------ 19987| 10.9M| case LB_SYMBOL: ------------------ | Branch (19987:9): [True: 6.15M, False: 50.3M] ------------------ 19988| 10.9M| case LB_BUFFER: ------------------ | Branch (19988:9): [True: 4.76k, False: 56.5M] ------------------ 19989| 11.6M| case LB_KEYWORD: ------------------ | Branch (19989:9): [True: 765k, False: 55.7M] ------------------ 19990| 12.8M| case LB_REGISTRY: { ------------------ | Branch (19990:9): [True: 1.21M, False: 55.3M] ------------------ 19991| 12.8M| data++; 19992| 12.8M| int32_t len = readnat(st, &data); 19993| 12.8M| MARSH_EOS(st, data - 1 + len); ------------------ | |19321| 12.8M|#define MARSH_EOS(st, data) do { \ | |19322| 12.8M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 31, False: 12.8M] | | ------------------ | |19323| 12.8M|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 12.8M] | | ------------------ ------------------ 19994| 12.8M| if (lead == LB_STRING) { ------------------ | Branch (19994:17): [True: 4.75M, False: 8.14M] ------------------ 19995| 4.75M| const uint8_t *str = janet_string(data, len); 19996| 4.75M| *out = janet_wrap_string(str); ------------------ | | 848| 4.75M|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 4.75M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 4.75M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.75M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19997| 8.14M| } else if (lead == LB_SYMBOL) { ------------------ | Branch (19997:24): [True: 6.15M, False: 1.98M] ------------------ 19998| 6.15M| const uint8_t *str = janet_symbol(data, len); 19999| 6.15M| *out = janet_wrap_symbol(str); ------------------ | | 849| 6.15M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 6.15M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 6.15M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.15M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20000| 6.15M| } else if (lead == LB_KEYWORD) { ------------------ | Branch (20000:24): [True: 765k, False: 1.21M] ------------------ 20001| 765k| const uint8_t *str = janet_keyword(data, len); ------------------ | | 1839| 765k|#define janet_keyword janet_symbol ------------------ 20002| 765k| *out = janet_wrap_keyword(str); ------------------ | | 850| 765k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | ------------------ | | | | 828| 765k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 765k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 765k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20003| 1.21M| } else if (lead == LB_REGISTRY) { ------------------ | Branch (20003:24): [True: 1.21M, False: 4.79k] ------------------ 20004| 1.21M| if (st->reg) { ------------------ | Branch (20004:21): [True: 1.21M, False: 0] ------------------ 20005| 1.21M| Janet regkey = janet_symbolv(data, len); ------------------ | | 1835| 1.21M|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 1.21M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 1.21M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.21M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.21M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20006| 1.21M| *out = janet_table_get(st->reg, regkey); 20007| 1.21M| } else { 20008| 0| *out = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20009| 0| } 20010| 1.21M| } else { /* (lead == LB_BUFFER) */ 20011| 4.79k| JanetBuffer *buffer = janet_buffer(len); 20012| 4.79k| buffer->count = len; 20013| 4.79k| safe_memcpy(buffer->data, data, len); 20014| 4.79k| *out = janet_wrap_buffer(buffer); ------------------ | | 847| 4.79k|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 4.79k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 4.79k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.79k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20015| 4.79k| } 20016| 12.8M| janet_v_push(st->lookup, *out); ------------------ | | 712| 12.8M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 12.8M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 12.8M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 12.8M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 12.8M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 12.8M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 249, False: 12.8M] | | | | | | | Branch (723:50): [True: 33.9k, False: 12.8M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 34.2k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 721| 12.8M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 12.8M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20017| 12.8M| return data + len; 20018| 12.8M| } 20019| 3.39k| case LB_FIBER: { ------------------ | Branch (20019:9): [True: 3.39k, False: 56.5M] ------------------ 20020| 3.39k| JanetFiber *fiber; 20021| 3.39k| data = unmarshal_one_fiber(st, data + 1, &fiber, flags + 1); 20022| 3.39k| *out = janet_wrap_fiber(fiber); ------------------ | | 844| 3.39k|#define janet_wrap_fiber(s) janet_nanbox_wrap_((s), JANET_FIBER) | | ------------------ | | | | 825| 3.39k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 3.39k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.39k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20023| 3.39k| return data; 20024| 12.8M| } 20025| 1.26M| case LB_FUNCTION: { ------------------ | Branch (20025:9): [True: 1.26M, False: 55.2M] ------------------ 20026| 1.26M| JanetFunction *func; 20027| 1.26M| JanetFuncDef *def; 20028| 1.26M| data++; 20029| 1.26M| int32_t len = readnat(st, &data); 20030| 1.26M| if (len > 255) { ------------------ | Branch (20030:17): [True: 0, False: 1.26M] ------------------ 20031| 0| janet_panicf("invalid function - too many environments (%d)", len); 20032| 0| } 20033| 1.26M| func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + 20034| 1.26M| len * sizeof(JanetFuncEnv)); 20035| 1.26M| func->def = NULL; 20036| 1.88M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20036:33): [True: 614k, False: 1.26M] ------------------ 20037| 614k| func->envs[i] = NULL; 20038| 614k| } 20039| 1.26M| *out = janet_wrap_function(func); ------------------ | | 852| 1.26M|#define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION) | | ------------------ | | | | 825| 1.26M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20040| 1.26M| janet_v_push(st->lookup, *out); ------------------ | | 712| 1.26M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 1.26M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 1.26M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 1.26M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 1.26M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 1.26M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 1.27k, False: 1.26M] | | | | | | | Branch (723:50): [True: 4.37k, False: 1.25M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 5.64k|#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)) | | ------------------ | | | | 721| 1.26M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 1.26M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20041| 1.26M| data = unmarshal_one_def(st, data, &def, flags + 1); 20042| 1.26M| func->def = def; 20043| 1.42M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20043:33): [True: 157k, False: 1.26M] ------------------ 20044| 157k| data = unmarshal_one_env(st, data, &(func->envs[i]), flags + 1); 20045| 157k| } 20046| 1.26M| return data; 20047| 1.26M| } 20048| 15.2k| case LB_ABSTRACT: { ------------------ | Branch (20048:9): [True: 15.2k, False: 56.5M] ------------------ 20049| 15.2k| data++; 20050| 15.2k| return unmarshal_one_abstract(st, data, out, flags); 20051| 1.26M| } 20052| 35.9M| case LB_REFERENCE: ------------------ | Branch (20052:9): [True: 35.9M, False: 20.5M] ------------------ 20053| 35.9M| case LB_ARRAY: ------------------ | Branch (20053:9): [True: 19.3k, False: 56.5M] ------------------ 20054| 35.9M| case LB_ARRAY_WEAK: ------------------ | Branch (20054:9): [True: 13.8k, False: 56.5M] ------------------ 20055| 38.5M| case LB_TUPLE: ------------------ | Branch (20055:9): [True: 2.52M, False: 54.0M] ------------------ 20056| 38.8M| case LB_STRUCT: ------------------ | Branch (20056:9): [True: 369k, False: 56.1M] ------------------ 20057| 38.8M| case LB_STRUCT_PROTO: ------------------ | Branch (20057:9): [True: 19.6k, False: 56.5M] ------------------ 20058| 41.2M| case LB_TABLE: ------------------ | Branch (20058:9): [True: 2.35M, False: 54.1M] ------------------ 20059| 41.2M| case LB_TABLE_PROTO: ------------------ | Branch (20059:9): [True: 1.02k, False: 56.5M] ------------------ 20060| 41.2M| case LB_TABLE_WEAKK: ------------------ | Branch (20060:9): [True: 20.3k, False: 56.5M] ------------------ 20061| 41.2M| case LB_TABLE_WEAKV: ------------------ | Branch (20061:9): [True: 366, False: 56.5M] ------------------ 20062| 41.4M| case LB_TABLE_WEAKKV: ------------------ | Branch (20062:9): [True: 152k, False: 56.3M] ------------------ 20063| 41.4M| case LB_TABLE_WEAKK_PROTO: ------------------ | Branch (20063:9): [True: 897, False: 56.5M] ------------------ 20064| 41.4M| case LB_TABLE_WEAKV_PROTO: ------------------ | Branch (20064:9): [True: 5.35k, False: 56.5M] ------------------ 20065| 41.4M| case LB_TABLE_WEAKKV_PROTO: ------------------ | Branch (20065:9): [True: 593, False: 56.5M] ------------------ 20066| | /* Things that open with integers */ 20067| 41.4M| { 20068| 41.4M| data++; 20069| 41.4M| int32_t len = readnat(st, &data); 20070| | /* DOS check */ 20071| 41.4M| if (lead != LB_REFERENCE) { ------------------ | Branch (20071:17): [True: 5.48M, False: 35.9M] ------------------ 20072| 5.48M| MARSH_EOS(st, data - 1 + len); ------------------ | |19321| 5.48M|#define MARSH_EOS(st, data) do { \ | |19322| 5.48M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 249, False: 5.48M] | | ------------------ | |19323| 5.48M|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 5.48M] | | ------------------ ------------------ 20073| 5.48M| } 20074| 41.4M| if (lead == LB_ARRAY || lead == LB_ARRAY_WEAK) { ------------------ | Branch (20074:17): [True: 19.5k, False: 41.4M] | Branch (20074:37): [True: 13.8k, False: 41.4M] ------------------ 20075| | /* Array */ 20076| 33.2k| JanetArray *array = (lead == LB_ARRAY_WEAK) ? janet_array_weak(len) : janet_array(len); ------------------ | Branch (20076:37): [True: 13.8k, False: 19.3k] ------------------ 20077| 33.2k| array->count = len; 20078| 33.2k| *out = janet_wrap_array(array); ------------------ | | 845| 33.2k|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 33.2k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 33.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 33.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20079| 33.2k| janet_v_push(st->lookup, *out); ------------------ | | 712| 33.2k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 33.2k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 33.2k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 33.1k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 33.1k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 33.1k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 116, False: 33.1k] | | | | | | | Branch (723:50): [True: 520, False: 32.6k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 33.2k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 33.2k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20080| 210k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20080:37): [True: 177k, False: 33.2k] ------------------ 20081| 177k| data = unmarshal_one(st, data, array->data + i, flags + 1); 20082| 177k| } 20083| 41.4M| } else if (lead == LB_TUPLE) { ------------------ | Branch (20083:24): [True: 2.52M, False: 38.8M] ------------------ 20084| | /* Tuple */ 20085| 2.52M| Janet *tup = janet_tuple_begin(len); 20086| 2.52M| int32_t flag = readint(st, &data); 20087| 2.52M| janet_tuple_flag(tup) |= (int32_t) (((uint32_t) flag) << 16); /* Avoid left shift of negative value */ ------------------ | | 1805| 2.52M|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1799| 2.52M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 20088| 9.78M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20088:37): [True: 7.26M, False: 2.52M] ------------------ 20089| 7.26M| data = unmarshal_one(st, data, tup + i, flags + 1); 20090| 7.26M| } 20091| 2.52M| *out = janet_wrap_tuple(janet_tuple_end(tup)); ------------------ | | 843| 2.52M|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 2.52M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.52M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.52M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20092| 2.52M| janet_v_push(st->lookup, *out); ------------------ | | 712| 2.52M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 2.52M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 2.52M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 2.52M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 2.52M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 2.52M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 943, False: 2.52M] | | | | | | | Branch (723:50): [True: 1.11k, False: 2.51M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 2.52M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 2.52M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20093| 38.8M| } else if (lead == LB_STRUCT || lead == LB_STRUCT_PROTO) { ------------------ | Branch (20093:24): [True: 369k, False: 38.5M] | Branch (20093:45): [True: 19.6k, False: 38.4M] ------------------ 20094| | /* Struct */ 20095| 388k| JanetKV *struct_ = janet_struct_begin(len); 20096| 388k| if (lead == LB_STRUCT_PROTO) { ------------------ | Branch (20096:21): [True: 19.6k, False: 368k] ------------------ 20097| 19.6k| Janet proto; 20098| 19.6k| data = unmarshal_one(st, data, &proto, flags + 1); 20099| 19.6k| janet_asserttype(proto, JANET_STRUCT, st); 20100| 19.6k| janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 1850| 19.6k|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1845| 19.6k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 857| 19.6k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 20101| 19.6k| } 20102| 1.45M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20102:37): [True: 1.06M, False: 388k] ------------------ 20103| 1.06M| Janet key, value; 20104| 1.06M| data = unmarshal_one(st, data, &key, flags + 1); 20105| 1.06M| data = unmarshal_one(st, data, &value, flags + 1); 20106| 1.06M| janet_struct_put(struct_, key, value); 20107| 1.06M| } 20108| 388k| *out = janet_wrap_struct(janet_struct_end(struct_)); ------------------ | | 842| 388k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 388k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 388k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 388k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20109| 388k| janet_v_push(st->lookup, *out); ------------------ | | 712| 388k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 388k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 388k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 328k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 328k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 328k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 60.4k, False: 328k] | | | | | | | Branch (723:50): [True: 1.87k, False: 326k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 388k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 388k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20110| 38.4M| } else if (lead == LB_REFERENCE) { ------------------ | Branch (20110:24): [True: 35.9M, False: 2.53M] ------------------ 20111| 35.9M| if (len >= janet_v_count(st->lookup)) ------------------ | | 714| 35.9M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 721| 35.9M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 35.9M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (714:34): [True: 35.9M, False: 0] | | ------------------ ------------------ | Branch (20111:21): [True: 51, False: 35.9M] ------------------ 20112| 51| janet_panicf("invalid reference %d", len); 20113| 35.9M| *out = st->lookup[len]; 20114| 35.9M| } else { 20115| | /* Table */ 20116| 2.53M| JanetTable *t; 20117| 2.53M| if (lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKK) { ------------------ | Branch (20117:21): [True: 1.02k, False: 2.53M] | Branch (20117:53): [True: 20.3k, False: 2.51M] ------------------ 20118| 21.1k| t = janet_table_weakk(len); 20119| 2.51M| } else if (lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKV) { ------------------ | Branch (20119:28): [True: 5.48k, False: 2.51M] | Branch (20119:60): [True: 357, False: 2.51M] ------------------ 20120| 5.70k| t = janet_table_weakv(len); 20121| 2.51M| } else if (lead == LB_TABLE_WEAKKV_PROTO || lead == LB_TABLE_WEAKKV) { ------------------ | Branch (20121:28): [True: 722, False: 2.51M] | Branch (20121:61): [True: 152k, False: 2.35M] ------------------ 20122| 152k| t = janet_table_weakkv(len); 20123| 2.35M| } else { 20124| 2.35M| t = janet_table(len); 20125| 2.35M| } 20126| 2.53M| *out = janet_wrap_table(t); ------------------ | | 846| 2.53M|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 2.53M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.53M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.53M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20127| 2.53M| janet_v_push(st->lookup, *out); ------------------ | | 712| 2.53M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 2.53M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 2.53M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 2.53M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 2.53M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 2.53M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 4.45k, False: 2.53M] | | | | | | | Branch (723:50): [True: 9.59k, False: 2.52M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 13.9k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 721| 2.53M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 2.53M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20128| 2.53M| if (lead == LB_TABLE_PROTO || lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKKV_PROTO) { ------------------ | Branch (20128:21): [True: 1.14k, False: 2.53M] | Branch (20128:47): [True: 891, False: 2.53M] | Branch (20128:79): [True: 5.35k, False: 2.53M] | Branch (20128:111): [True: 588, False: 2.53M] ------------------ 20129| 7.84k| Janet proto; 20130| 7.84k| data = unmarshal_one(st, data, &proto, flags + 1); 20131| 7.84k| janet_asserttype(proto, JANET_TABLE, st); 20132| 7.84k| t->proto = janet_unwrap_table(proto); ------------------ | | 861| 7.84k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 20133| 7.84k| } 20134| 15.3M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (20134:37): [True: 12.8M, False: 2.53M] ------------------ 20135| 12.8M| Janet key, value; 20136| 12.8M| data = unmarshal_one(st, data, &key, flags + 1); 20137| 12.8M| data = unmarshal_one(st, data, &value, flags + 1); 20138| 12.8M| janet_table_put(t, key, value); 20139| 12.8M| } 20140| 2.53M| } 20141| 41.4M| return data; 20142| 41.4M| } 20143| 0| case LB_UNSAFE_POINTER: { ------------------ | Branch (20143:9): [True: 0, False: 56.5M] ------------------ 20144| 0| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |19321| 0|#define MARSH_EOS(st, data) do { \ | |19322| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 0, False: 0] | | ------------------ | |19323| 0|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 0] | | ------------------ ------------------ 20145| 0| data++; 20146| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1910| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (20146:17): [True: 0, False: 0] ------------------ 20147| 0| janet_panicf("unsafe flag not given, " 20148| 0| "will not unmarshal raw pointer at index %d", 20149| 0| (int)(data - st->start)); 20150| 0| } 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| 0| *out = janet_wrap_pointer(u.ptr); ------------------ | | 854| 0|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20158| 0| janet_v_push(st->lookup, *out); ------------------ | | 712| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 0, False: 0] | | | | | | | Branch (723:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20159| 0| return data; 20160| 0| } 20161| 0|#ifdef JANET_EV 20162| 17| case LB_POINTER_BUFFER: { ------------------ | Branch (20162:9): [True: 17, False: 56.5M] ------------------ 20163| 17| data++; 20164| 17| int32_t count = readnat(st, &data); 20165| 17| int32_t capacity = readnat(st, &data); 20166| 17| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |19321| 17|#define MARSH_EOS(st, data) do { \ | |19322| 17| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 2, False: 15] | | ------------------ | |19323| 17|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 15] | | ------------------ ------------------ 20167| 15| union { 20168| 15| void *ptr; 20169| 15| uint8_t bytes[sizeof(void *)]; 20170| 15| } u; 20171| 15| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1910| 15|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (20171:17): [True: 5, False: 10] ------------------ 20172| 5| janet_panicf("unsafe flag not given, " 20173| 5| "will not unmarshal raw pointer at index %d", 20174| 5| (int)(data - st->start)); 20175| 5| } 20176| 10| memcpy(u.bytes, data, sizeof(void *)); 20177| 10| data += sizeof(void *); 20178| 10| JanetBuffer *buffer = janet_pointer_buffer_unsafe(u.ptr, capacity, count); 20179| 10| *out = janet_wrap_buffer(buffer); ------------------ | | 847| 10|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 10| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 10|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 10|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20180| 10| janet_v_push(st->lookup, *out); ------------------ | | 712| 10|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 10|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 10|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 10, False: 0] | | | | | | | Branch (723:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 10|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 10|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20181| 10| return data; 20182| 15| } 20183| 0|#endif 20184| 1| case LB_UNSAFE_CFUNCTION: { ------------------ | Branch (20184:9): [True: 1, False: 56.5M] ------------------ 20185| 1| MARSH_EOS(st, data + sizeof(JanetCFunction)); ------------------ | |19321| 1|#define MARSH_EOS(st, data) do { \ | |19322| 1| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 0, False: 1] | | ------------------ | |19323| 1|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 1] | | ------------------ ------------------ 20186| 1| data++; 20187| 1| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1910| 1|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (20187:17): [True: 1, False: 0] ------------------ 20188| 1| janet_panicf("unsafe flag not given, " 20189| 1| "will not unmarshal function pointer at index %d", 20190| 1| (int)(data - st->start)); 20191| 1| } 20192| 0| union { 20193| 0| JanetCFunction ptr; 20194| 0| uint8_t bytes[sizeof(JanetCFunction)]; 20195| 0| } u; 20196| 0| memcpy(u.bytes, data, sizeof(JanetCFunction)); 20197| 0| data += sizeof(JanetCFunction); 20198| 0| *out = janet_wrap_cfunction(u.ptr); ------------------ | | 853| 0|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20199| 0| janet_v_push(st->lookup, *out); ------------------ | | 712| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 0, False: 0] | | | | | | | Branch (723:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20200| 0| return data; 20201| 1| } 20202| 0|#ifdef JANET_EV 20203| 1| case LB_THREADED_ABSTRACT: { ------------------ | Branch (20203:9): [True: 1, False: 56.5M] ------------------ 20204| 1| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |19321| 1|#define MARSH_EOS(st, data) do { \ | |19322| 1| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 0, False: 1] | | ------------------ | |19323| 1|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 1] | | ------------------ ------------------ 20205| 1| data++; 20206| 1| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1910| 1|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (20206:17): [True: 1, False: 0] ------------------ 20207| 1| janet_panicf("unsafe flag not given, " 20208| 1| "will not unmarshal threaded abstract pointer at index %d", 20209| 1| (int)(data - st->start)); 20210| 1| } 20211| 0| union { 20212| 0| void *ptr; 20213| 0| uint8_t bytes[sizeof(void *)]; 20214| 0| } u; 20215| 0| memcpy(u.bytes, data, sizeof(void *)); 20216| 0| data += sizeof(void *); 20217| | 20218| 0| if (flags & JANET_MARSHAL_DECREF) { ------------------ | | 387| 0|#define JANET_MARSHAL_DECREF 0x40000 ------------------ | Branch (20218:17): [True: 0, False: 0] ------------------ 20219| | /* Decrement immediately and don't bother putting into heap */ 20220| 0| janet_abstract_decref(u.ptr); 20221| 0| *out = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20222| 0| } else { 20223| 0| *out = janet_wrap_abstract(u.ptr); ------------------ | | 851| 0|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20224| 0| Janet check = janet_table_get(&janet_vm.threaded_abstracts, *out); 20225| 0| if (janet_checktype(check, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20226| | /* Transfers reference from threaded channel buffer to current heap */ 20227| 0| janet_table_put(&janet_vm.threaded_abstracts, *out, janet_wrap_false()); ------------------ | | 833| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20228| 0| } else { 20229| | /* Heap reference already accounted for, remove threaded channel reference. */ 20230| 0| janet_abstract_decref(u.ptr); 20231| 0| } 20232| 0| } 20233| | 20234| 0| janet_v_push(st->lookup, *out); ------------------ | | 712| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 0, False: 0] | | | | | | | Branch (723:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 20235| 0| return data; 20236| 1| } 20237| 0|#endif 20238| 249| default: { ------------------ | Branch (20238:9): [True: 249, False: 56.5M] ------------------ 20239| 249| janet_panicf("unknown byte %x at index %d", 20240| 249| *data, 20241| 249| (int)(data - st->start)); 20242| 0| return NULL; 20243| 1| } 20244| 56.5M| } 20245| 56.5M|} janet.c:readnat: 19358| 69.7M|static int32_t readnat(UnmarshalState *st, const uint8_t **atdata) { 19359| 69.7M| int32_t ret = readint(st, atdata); 19360| 69.7M| if (ret < 0) { ------------------ | Branch (19360:9): [True: 211, False: 69.7M] ------------------ 19361| 211| janet_panicf("expected integer >= 0, got %d", ret); 19362| 211| } 19363| 69.7M| return ret; 19364| 69.7M|} janet.c:unmarshal_one_fiber: 19676| 3.39k| int flags) { 19677| | 19678| | /* Initialize a new fiber with gc friendly defaults */ 19679| 3.39k| JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber)); 19680| 3.39k| fiber->flags = 0; 19681| 3.39k| fiber->frame = 0; 19682| 3.39k| fiber->stackstart = 0; 19683| 3.39k| fiber->stacktop = 0; 19684| 3.39k| fiber->capacity = 0; 19685| 3.39k| fiber->maxstack = 0; 19686| 3.39k| fiber->data = NULL; 19687| 3.39k| fiber->child = NULL; 19688| 3.39k| fiber->env = NULL; 19689| 3.39k| fiber->last_value = janet_wrap_nil(); ------------------ | | 831| 3.39k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 3.39k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 3.39k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.39k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19690| 3.39k|#ifdef JANET_EV 19691| 3.39k| fiber->sched_id = 0; 19692| 3.39k| fiber->supervisor_channel = NULL; 19693| 3.39k| fiber->ev_state = NULL; 19694| 3.39k| fiber->ev_callback = NULL; 19695| 3.39k| fiber->ev_stream = NULL; 19696| 3.39k|#endif 19697| | 19698| | /* Push fiber to seen stack */ 19699| 3.39k| janet_v_push(st->lookup, janet_wrap_fiber(fiber)); ------------------ | | 712| 3.39k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 3.39k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 3.39k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 3.13k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 3.13k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 3.13k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 259, False: 3.13k] | | | | | | | Branch (723:50): [True: 204, False: 2.92k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 3.39k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 3.39k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19700| | 19701| | /* Read ints */ 19702| 3.39k| int32_t fiber_flags = readint(st, &data); 19703| 3.39k| int32_t frame = readnat(st, &data); 19704| 3.39k| int32_t fiber_stackstart = readnat(st, &data); 19705| 3.39k| int32_t fiber_stacktop = readnat(st, &data); 19706| 3.39k| int32_t fiber_maxstack = readnat(st, &data); 19707| 3.39k| JanetTable *fiber_env = NULL; 19708| | 19709| | /* Check for bad flags and ints */ 19710| 3.39k| if ((int32_t)(frame + JANET_FRAME_SIZE) > fiber_stackstart || ------------------ | | 1026| 3.39k|#define JANET_FRAME_SIZE 4 ------------------ | Branch (19710:9): [True: 41, False: 3.35k] ------------------ 19711| 3.35k| fiber_stackstart > fiber_stacktop || ------------------ | Branch (19711:13): [True: 4, False: 3.34k] ------------------ 19712| 3.34k| fiber_stacktop > fiber_maxstack) { ------------------ | Branch (19712:13): [True: 6, False: 3.34k] ------------------ 19713| 18| janet_panic("fiber has incorrect stack setup"); 19714| 18| } 19715| | 19716| | /* Allocate stack memory */ 19717| 3.37k| if (fiber_stacktop < INT32_MAX - 10) { ------------------ | Branch (19717:9): [True: 3.34k, False: 33] ------------------ 19718| 3.34k| fiber->capacity = fiber_stacktop + 10; 19719| 3.34k| } else { 19720| | /* Extra capacity is usually nice to avoid immediately reallocing on pushed arguments, but not needed */ 19721| 33| fiber->capacity = INT32_MAX; 19722| 33| } 19723| 3.37k| fiber->data = array_allocate(sizeof(Janet), fiber->capacity); 19724| 3.37k| if (!fiber->data) { ------------------ | Branch (19724:9): [True: 0, False: 3.37k] ------------------ 19725| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19726| 0| } 19727| 458M| for (int32_t i = 0; i < fiber->capacity; i++) { ------------------ | Branch (19727:25): [True: 458M, False: 3.37k] ------------------ 19728| 458M| fiber->data[i] = janet_wrap_nil(); ------------------ | | 831| 458M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 458M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 458M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 458M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19729| 458M| } 19730| | 19731| | /* get frames */ 19732| 3.37k| int32_t stack = frame; 19733| 3.37k| int32_t stacktop = fiber_stackstart - JANET_FRAME_SIZE; ------------------ | | 1026| 3.37k|#define JANET_FRAME_SIZE 4 ------------------ 19734| 3.56k| while (stack > 0) { ------------------ | Branch (19734:12): [True: 200, False: 3.36k] ------------------ 19735| 200| JanetFunction *func = NULL; 19736| 200| JanetFuncDef *def = NULL; 19737| 200| JanetFuncEnv *env = NULL; 19738| 200| int32_t frameflags = readint(st, &data); 19739| 200| int32_t prevframe = readnat(st, &data); 19740| 200| int32_t pcdiff = readnat(st, &data); 19741| | 19742| | /* Get frame items */ 19743| 200| Janet *framestack = fiber->data + stack; 19744| 200| JanetStackFrame *framep = janet_stack_frame(framestack); ------------------ | | 809| 200|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 200|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ 19745| | 19746| | /* Get function */ 19747| 200| Janet funcv; 19748| 200| data = unmarshal_one(st, data, &funcv, flags + 1); 19749| 200| janet_asserttype(funcv, JANET_FUNCTION, st); 19750| 200| func = janet_unwrap_function(funcv); ------------------ | | 868| 200|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 19751| 200| def = func->def; 19752| | 19753| | /* Check env */ 19754| 200| if (frameflags & JANET_STACKFRAME_HASENV) { ------------------ | |18934| 200|#define JANET_STACKFRAME_HASENV (INT32_MIN) ------------------ | Branch (19754:13): [True: 135, False: 65] ------------------ 19755| 135| frameflags &= ~JANET_STACKFRAME_HASENV; ------------------ | |18934| 135|#define JANET_STACKFRAME_HASENV (INT32_MIN) ------------------ 19756| 135| data = unmarshal_one_env(st, data, &env, flags + 1); 19757| 135| } 19758| | 19759| | /* Error checking */ 19760| 200| int32_t expected_framesize = def->slotcount; 19761| 200| if (expected_framesize != stacktop - stack) { ------------------ | Branch (19761:13): [True: 11, False: 189] ------------------ 19762| 11| janet_panic("fiber stackframe size mismatch"); 19763| 11| } 19764| 189| if (pcdiff >= def->bytecode_length) { ------------------ | Branch (19764:13): [True: 1, False: 188] ------------------ 19765| 1| janet_panic("fiber stackframe has invalid pc"); 19766| 1| } 19767| 188| if ((int32_t)(prevframe + JANET_FRAME_SIZE) > stack) { ------------------ | | 1026| 188|#define JANET_FRAME_SIZE 4 ------------------ | Branch (19767:13): [True: 2, False: 186] ------------------ 19768| 2| janet_panic("fiber stackframe does not align with previous frame"); 19769| 2| } 19770| | 19771| | /* Get stack items */ 19772| 186| for (int32_t i = stack; i < stacktop; i++) ------------------ | Branch (19772:33): [True: 0, False: 186] ------------------ 19773| 0| data = unmarshal_one(st, data, fiber->data + i, flags + 1); 19774| | 19775| | /* Set frame */ 19776| 186| framep->env = env; 19777| 186| framep->pc = def->bytecode + pcdiff; 19778| 186| framep->prevframe = prevframe; 19779| 186| framep->flags = frameflags; 19780| 186| framep->func = func; 19781| | 19782| | /* Goto previous frame */ 19783| 186| stacktop = stack - JANET_FRAME_SIZE; ------------------ | | 1026| 186|#define JANET_FRAME_SIZE 4 ------------------ 19784| 186| stack = prevframe; 19785| 186| } 19786| 3.36k| if (stack < 0) { ------------------ | Branch (19786:9): [True: 0, False: 3.36k] ------------------ 19787| 0| janet_panic("fiber has too many stackframes"); 19788| 0| } 19789| | 19790| | /* Check for fiber env */ 19791| 3.36k| if (fiber_flags & JANET_FIBER_FLAG_HASENV) { ------------------ | |18933| 3.36k|#define JANET_FIBER_FLAG_HASENV (1 << 30) ------------------ | Branch (19791:9): [True: 970, False: 2.39k] ------------------ 19792| 970| Janet envv; 19793| 970| fiber_flags &= ~JANET_FIBER_FLAG_HASENV; ------------------ | |18933| 970|#define JANET_FIBER_FLAG_HASENV (1 << 30) ------------------ 19794| 970| data = unmarshal_one(st, data, &envv, flags + 1); 19795| 970| janet_asserttype(envv, JANET_TABLE, st); 19796| 970| fiber_env = janet_unwrap_table(envv); ------------------ | | 861| 970|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 19797| 970| } 19798| | 19799| | /* Check for child fiber */ 19800| 3.36k| if (fiber_flags & JANET_FIBER_FLAG_HASCHILD) { ------------------ | |18932| 3.36k|#define JANET_FIBER_FLAG_HASCHILD (1 << 29) ------------------ | Branch (19800:9): [True: 905, False: 2.45k] ------------------ 19801| 905| Janet fiberv; 19802| 905| fiber_flags &= ~JANET_FIBER_FLAG_HASCHILD; ------------------ | |18932| 905|#define JANET_FIBER_FLAG_HASCHILD (1 << 29) ------------------ 19803| 905| data = unmarshal_one(st, data, &fiberv, flags + 1); 19804| 905| janet_asserttype(fiberv, JANET_FIBER, st); 19805| 905| fiber->child = janet_unwrap_fiber(fiberv); ------------------ | | 859| 905|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 19806| 905| } 19807| | 19808| | /* Get the fiber last value */ 19809| 3.36k| data = unmarshal_one(st, data, &fiber->last_value, flags + 1); 19810| | 19811| | /* We have valid fiber, finally construct remaining fields. */ 19812| 3.36k| fiber->frame = frame; 19813| 3.36k| fiber->flags = fiber_flags; 19814| 3.36k| fiber->stackstart = fiber_stackstart; 19815| 3.36k| fiber->stacktop = fiber_stacktop; 19816| 3.36k| fiber->maxstack = fiber_maxstack; 19817| 3.36k| fiber->env = fiber_env; 19818| | 19819| 3.36k| int status = janet_fiber_status(fiber); 19820| 3.36k| if (status < 0 || status > JANET_STATUS_ALIVE) { ------------------ | Branch (19820:9): [True: 2.38k, False: 971] | Branch (19820:23): [True: 3, False: 968] ------------------ 19821| 3| janet_panic("invalid fiber status"); 19822| 3| } 19823| | 19824| | /* Return data */ 19825| 3.35k| *out = fiber; 19826| 3.35k| return data; 19827| 3.36k|} janet.c:unmarshal_one_def: 19497| 1.77M| int flags) { 19498| 1.77M| MARSH_EOS(st, data); ------------------ | |19321| 1.77M|#define MARSH_EOS(st, data) do { \ | |19322| 1.77M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 10, False: 1.77M] | | ------------------ | |19323| 1.77M|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 1.77M] | | ------------------ ------------------ 19499| 1.77M| if (*data == LB_FUNCDEF_REF) { ------------------ | Branch (19499:9): [True: 12.9k, False: 1.76M] ------------------ 19500| 12.9k| data++; 19501| 12.9k| int32_t index = readint(st, &data); 19502| 12.9k| if (index < 0 || index >= janet_v_count(st->lookup_defs)) ------------------ | | 714| 12.9k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 721| 12.9k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 12.9k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (714:34): [True: 12.9k, False: 0] | | ------------------ ------------------ | Branch (19502:13): [True: 11, False: 12.9k] | Branch (19502:26): [True: 50, False: 12.9k] ------------------ 19503| 61| janet_panicf("invalid funcdef reference %d", index); 19504| 12.9k| *out = st->lookup_defs[index]; 19505| 1.76M| } else { 19506| | /* Initialize with values that will not break garbage collection 19507| | * if unmarshalling fails. */ 19508| 1.76M| JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); 19509| 1.76M| def->environments_length = 0; 19510| 1.76M| def->defs_length = 0; 19511| 1.76M| def->constants_length = 0; 19512| 1.76M| def->bytecode_length = 0; 19513| 1.76M| def->name = NULL; 19514| 1.76M| def->source = NULL; 19515| 1.76M| def->closure_bitset = NULL; 19516| 1.76M| def->defs = NULL; 19517| 1.76M| def->environments = NULL; 19518| 1.76M| def->constants = NULL; 19519| 1.76M| def->bytecode = NULL; 19520| 1.76M| def->sourcemap = NULL; 19521| 1.76M| def->symbolmap = NULL; 19522| 1.76M| def->symbolmap_length = 0; 19523| 1.76M| def->named_args_count = 0; 19524| 1.76M| janet_v_push(st->lookup_defs, def); ------------------ | | 712| 1.76M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 1.76M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 1.76M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 1.75M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 1.75M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 1.75M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 4.65k, False: 1.75M] | | | | | | | Branch (723:50): [True: 34.0k, False: 1.72M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 1.76M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 1.76M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19525| | 19526| | /* Set default lengths to zero */ 19527| 1.76M| int32_t bytecode_length = 0; 19528| 1.76M| int32_t constants_length = 0; 19529| 1.76M| int32_t environments_length = 0; 19530| 1.76M| int32_t defs_length = 0; 19531| 1.76M| int32_t symbolmap_length = 0; 19532| | 19533| | /* Read flags and other fixed values */ 19534| 1.76M| def->flags = readint(st, &data); 19535| 1.76M| def->slotcount = readnat(st, &data); 19536| 1.76M| def->arity = readnat(st, &data); 19537| 1.76M| def->min_arity = readnat(st, &data); 19538| 1.76M| def->max_arity = readnat(st, &data); 19539| | 19540| | /* Read some lengths */ 19541| 1.76M| constants_length = readnat(st, &data); 19542| 1.76M| bytecode_length = readnat(st, &data); 19543| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS) ------------------ | | 1107| 1.76M|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (19543:13): [True: 9.18k, False: 1.75M] ------------------ 19544| 9.18k| def->named_args_count = readnat(st, &data); 19545| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) ------------------ | | 1103| 1.76M|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (19545:13): [True: 1.62M, False: 134k] ------------------ 19546| 1.62M| environments_length = readnat(st, &data); 19547| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) ------------------ | | 1102| 1.76M|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (19547:13): [True: 228k, False: 1.53M] ------------------ 19548| 228k| defs_length = readnat(st, &data); 19549| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) ------------------ | | 1099| 1.76M|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (19549:13): [True: 1.60M, False: 156k] ------------------ 19550| 1.60M| symbolmap_length = readnat(st, &data); 19551| | 19552| | /* Check name and source (optional) */ 19553| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) { ------------------ | | 1100| 1.76M|#define JANET_FUNCDEF_FLAG_HASNAME 0x80000 ------------------ | Branch (19553:13): [True: 1.61M, False: 146k] ------------------ 19554| 1.61M| Janet x; 19555| 1.61M| data = unmarshal_one(st, data, &x, flags + 1); 19556| 1.61M| janet_asserttype(x, JANET_STRING, st); 19557| 1.61M| def->name = janet_unwrap_string(x); ------------------ | | 863| 1.61M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 19558| 1.61M| } 19559| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) { ------------------ | | 1101| 1.76M|#define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000 ------------------ | Branch (19559:13): [True: 1.62M, False: 134k] ------------------ 19560| 1.62M| Janet x; 19561| 1.62M| data = unmarshal_one(st, data, &x, flags + 1); 19562| 1.62M| janet_asserttype(x, JANET_STRING, st); 19563| 1.62M| def->source = janet_unwrap_string(x); ------------------ | | 863| 1.62M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 19564| 1.62M| } 19565| | 19566| | /* Unmarshal constants */ 19567| 1.76M| if (constants_length) { ------------------ | Branch (19567:13): [True: 1.34M, False: 418k] ------------------ 19568| 1.34M| def->constants = array_allocate(sizeof(Janet), constants_length); 19569| 1.34M| if (!def->constants) { ------------------ | Branch (19569:17): [True: 0, False: 1.34M] ------------------ 19570| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19571| 0| } 19572| 8.73M| for (int32_t i = 0; i < constants_length; i++) ------------------ | Branch (19572:33): [True: 7.39M, False: 1.34M] ------------------ 19573| 7.39M| data = unmarshal_one(st, data, def->constants + i, flags + 1); 19574| 1.34M| } else { 19575| 418k| def->constants = NULL; 19576| 418k| } 19577| 1.76M| def->constants_length = constants_length; 19578| | 19579| | /* Unmarshal symbol map, if needed */ 19580| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) { ------------------ | | 1099| 1.76M|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (19580:13): [True: 1.60M, False: 159k] ------------------ 19581| 1.60M| def->symbolmap = array_allocate(sizeof(JanetSymbolMap), symbolmap_length); 19582| 1.60M| if (def->symbolmap == NULL) { ------------------ | Branch (19582:17): [True: 0, False: 1.60M] ------------------ 19583| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19584| 0| } 19585| 19.3M| for (int32_t i = 0; i < symbolmap_length; i++) { ------------------ | Branch (19585:33): [True: 17.7M, False: 1.60M] ------------------ 19586| 17.7M| def->symbolmap[i].birth_pc = (uint32_t) readint(st, &data); 19587| 17.7M| def->symbolmap[i].death_pc = (uint32_t) readint(st, &data); 19588| 17.7M| def->symbolmap[i].slot_index = (uint32_t) readint(st, &data); 19589| 17.7M| Janet value; 19590| 17.7M| data = unmarshal_one(st, data, &value, flags + 1); 19591| 17.7M| if (!janet_checktype(value, JANET_SYMBOL)) { ------------------ | | 806| 17.7M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 17.7M] | | ------------------ | | 807| 17.7M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 17.7M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 17.7M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 17.7M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 17.7M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 17.7M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (19591:21): [True: 20, False: 17.7M] ------------------ 19592| 20| janet_panicf("corrupted symbolmap when unmarshalling debug info, got %v", value); 19593| 20| } 19594| 17.7M| def->symbolmap[i].symbol = janet_unwrap_symbol(value); ------------------ | | 864| 17.7M|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 19595| 17.7M| } 19596| 1.60M| def->symbolmap_length = (uint32_t) symbolmap_length; 19597| 1.60M| } 19598| | 19599| | /* Unmarshal bytecode */ 19600| 1.76M| def->bytecode = array_allocate(sizeof(uint32_t), bytecode_length); 19601| 1.76M| if (!def->bytecode) { ------------------ | Branch (19601:13): [True: 0, False: 1.76M] ------------------ 19602| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19603| 0| } 19604| 1.76M| data = janet_unmarshal_u32s(st, data, def->bytecode, bytecode_length); 19605| 1.76M| def->bytecode_length = bytecode_length; 19606| | 19607| | /* Unmarshal environments */ 19608| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) { ------------------ | | 1103| 1.76M|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (19608:13): [True: 1.62M, False: 136k] ------------------ 19609| 1.62M| def->environments = janet_calloc(1, sizeof(int32_t) * (size_t) environments_length); ------------------ | | 2412| 1.62M|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 19610| 1.62M| if (!def->environments) { ------------------ | Branch (19610:17): [True: 0, False: 1.62M] ------------------ 19611| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19612| 0| } 19613| 2.26M| for (int32_t i = 0; i < environments_length; i++) { ------------------ | Branch (19613:33): [True: 641k, False: 1.62M] ------------------ 19614| 641k| def->environments[i] = readint(st, &data); 19615| 641k| } 19616| 1.62M| } else { 19617| 136k| def->environments = NULL; 19618| 136k| } 19619| 1.76M| def->environments_length = environments_length; 19620| | 19621| | /* Unmarshal sub funcdefs */ 19622| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) { ------------------ | | 1102| 1.76M|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (19622:13): [True: 225k, False: 1.53M] ------------------ 19623| 225k| def->defs = janet_calloc(1, sizeof(JanetFuncDef *) * (size_t) defs_length); ------------------ | | 2412| 225k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 19624| 225k| if (!def->defs) { ------------------ | Branch (19624:17): [True: 0, False: 225k] ------------------ 19625| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19626| 0| } 19627| 733k| for (int32_t i = 0; i < defs_length; i++) { ------------------ | Branch (19627:33): [True: 507k, False: 225k] ------------------ 19628| 507k| data = unmarshal_one_def(st, data, def->defs + i, flags + 1); 19629| 507k| } 19630| 1.53M| } else { 19631| 1.53M| def->defs = NULL; 19632| 1.53M| } 19633| 1.76M| def->defs_length = defs_length; 19634| | 19635| | /* Unmarshal source maps if needed */ 19636| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCEMAP) { ------------------ | | 1104| 1.76M|#define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000 ------------------ | Branch (19636:13): [True: 1.62M, False: 136k] ------------------ 19637| 1.62M| int32_t current = 0; 19638| 1.62M| def->sourcemap = array_allocate(sizeof(JanetSourceMapping), bytecode_length); 19639| 1.62M| if (!def->sourcemap) { ------------------ | Branch (19639:17): [True: 0, False: 1.62M] ------------------ 19640| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19641| 0| } 19642| 48.7M| for (int32_t i = 0; i < bytecode_length; i++) { ------------------ | Branch (19642:33): [True: 47.1M, False: 1.62M] ------------------ 19643| 47.1M| current += readint(st, &data); 19644| 47.1M| def->sourcemap[i].line = current; 19645| 47.1M| def->sourcemap[i].column = readint(st, &data); 19646| 47.1M| } 19647| 1.62M| } else { 19648| 136k| def->sourcemap = NULL; 19649| 136k| } 19650| | 19651| | /* Unmarshal closure bitset if needed */ 19652| 1.76M| if (def->flags & JANET_FUNCDEF_FLAG_HASCLOBITSET) { ------------------ | | 1106| 1.76M|#define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000 ------------------ | Branch (19652:13): [True: 190k, False: 1.56M] ------------------ 19653| 190k| int32_t n = (def->slotcount + 31) >> 5; 19654| 190k| def->closure_bitset = array_allocate(sizeof(uint32_t), n); 19655| 190k| if (NULL == def->closure_bitset) { ------------------ | Branch (19655:17): [True: 0, False: 190k] ------------------ 19656| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19657| 0| } 19658| 190k| data = janet_unmarshal_u32s(st, data, def->closure_bitset, n); 19659| 190k| } 19660| | 19661| | /* Validate */ 19662| 1.76M| if (janet_verify(def)) ------------------ | Branch (19662:13): [True: 556, False: 1.75M] ------------------ 19663| 556| janet_panic("funcdef has invalid bytecode"); 19664| | 19665| | /* Set def */ 19666| 1.75M| *out = def; 19667| 1.75M| } 19668| 1.77M| return data; 19669| 1.77M|} janet.c:janet_unmarshal_u32s: 19479| 1.93M|static const uint8_t *janet_unmarshal_u32s(UnmarshalState *st, const uint8_t *data, uint32_t *into, int32_t n) { 19480| 50.6M| for (int32_t i = 0; i < n; i++) { ------------------ | Branch (19480:25): [True: 48.7M, False: 1.93M] ------------------ 19481| 48.7M| MARSH_EOS(st, data + 3); ------------------ | |19321| 48.7M|#define MARSH_EOS(st, data) do { \ | |19322| 48.7M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 58, False: 48.7M] | | ------------------ | |19323| 48.7M|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 48.7M] | | ------------------ ------------------ 19482| 48.7M| into[i] = 19483| 48.7M| (uint32_t)(data[0]) | 19484| 48.7M| ((uint32_t)(data[1]) << 8) | 19485| 48.7M| ((uint32_t)(data[2]) << 16) | 19486| 48.7M| ((uint32_t)(data[3]) << 24); 19487| 48.7M| data += 4; 19488| 48.7M| } 19489| 1.93M| return data; 19490| 1.93M|} janet.c:unmarshal_one_env: 19435| 158k| int flags) { 19436| 158k| MARSH_EOS(st, data); ------------------ | |19321| 158k|#define MARSH_EOS(st, data) do { \ | |19322| 158k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (19322:9): [True: 9, False: 158k] | | ------------------ | |19323| 158k|} while (0) | | ------------------ | | | Branch (19323:10): [Folded, False: 158k] | | ------------------ ------------------ 19437| 158k| if (*data == LB_FUNCENV_REF) { ------------------ | Branch (19437:9): [True: 112k, False: 45.0k] ------------------ 19438| 112k| data++; 19439| 112k| int32_t index = readint(st, &data); 19440| 112k| if (index < 0 || index >= janet_v_count(st->lookup_envs)) ------------------ | | 714| 112k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 721| 112k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 112k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (714:34): [True: 112k, False: 6] | | ------------------ ------------------ | Branch (19440:13): [True: 15, False: 112k] | Branch (19440:26): [True: 17, False: 112k] ------------------ 19441| 32| janet_panicf("invalid funcenv reference %d", index); 19442| 112k| *out = st->lookup_envs[index]; 19443| 112k| } else { 19444| 45.0k| JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); 19445| 45.0k| env->length = 0; 19446| 45.0k| env->offset = 0; 19447| 45.0k| env->as.values = NULL; 19448| 45.0k| janet_v_push(st->lookup_envs, env); ------------------ | | 712| 45.0k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 724| 45.0k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 723| 45.0k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 721| 41.4k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 719| 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)) | | | | | | ------------------ | | | | | | | | 720| 41.4k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 719| 41.4k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (723:35): [True: 3.58k, False: 41.4k] | | | | | | | Branch (723:50): [True: 13.8k, False: 27.6k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 725| 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)) | | ------------------ | | | | 721| 45.0k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 719| 45.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 19449| 45.0k| int32_t offset = readnat(st, &data); 19450| 45.0k| int32_t length = readnat(st, &data); 19451| 45.0k| if (offset > 0) { ------------------ | Branch (19451:13): [True: 304, False: 44.7k] ------------------ 19452| 304| Janet fiberv; 19453| | /* On stack variant */ 19454| 304| data = unmarshal_one(st, data, &fiberv, flags); 19455| 304| janet_asserttype(fiberv, JANET_FIBER, st); 19456| 304| env->as.fiber = janet_unwrap_fiber(fiberv); ------------------ | | 859| 304|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 19457| | /* Negative offset indicates untrusted input */ 19458| 304| env->offset = -offset; 19459| 44.7k| } else { 19460| | /* Off stack variant */ 19461| 44.7k| if (length == 0) { ------------------ | Branch (19461:17): [True: 8, False: 44.7k] ------------------ 19462| 8| janet_panic("invalid funcenv length"); 19463| 8| } 19464| 44.7k| env->as.values = array_allocate(sizeof(Janet), length); 19465| 44.7k| if (!env->as.values) { ------------------ | Branch (19465:17): [True: 0, False: 44.7k] ------------------ 19466| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 19467| 0| } 19468| 44.7k| env->offset = 0; 19469| 764k| for (int32_t i = 0; i < length; i++) ------------------ | Branch (19469:33): [True: 720k, False: 44.7k] ------------------ 19470| 720k| data = unmarshal_one(st, data, env->as.values + i, flags); 19471| 44.7k| } 19472| 45.0k| env->length = length; 19473| 45.0k| *out = env; 19474| 45.0k| } 19475| 158k| return data; 19476| 158k|} janet.c:unmarshal_one_abstract: 19911| 15.2k|static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *data, Janet *out, int flags) { 19912| 15.2k| Janet key; 19913| 15.2k| data = unmarshal_one(st, data, &key, flags + 1); 19914| 15.2k| const JanetAbstractType *at = janet_get_abstract_type(key); 19915| 15.2k| if (at == NULL) janet_panic("unknown abstract type"); ------------------ | Branch (19915:9): [True: 15, False: 15.2k] ------------------ 19916| 15.2k| if (at->unmarshal) { ------------------ | Branch (19916:9): [True: 0, False: 15.2k] ------------------ 19917| 0| JanetMarshalContext context = {NULL, st, flags, data, at}; 19918| 0| void *abst = at->unmarshal(&context); 19919| 0| janet_assert(abst != NULL, "null pointer abstract"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 19920| 0| *out = janet_wrap_abstract(abst); ------------------ | | 851| 0|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 19921| 0| if (context.at != NULL) { ------------------ | Branch (19921:13): [True: 0, False: 0] ------------------ 19922| 0| janet_panic("janet_unmarshal_abstract not called"); 19923| 0| } 19924| 0| return context.data; 19925| 0| } 19926| 15.2k| janet_panic("invalid abstract type - no unmarshal function pointer"); 19927| 15.2k|} janet.c:janet_asserttype: 19397| 3.26M|static void janet_asserttype(Janet x, JanetType t, UnmarshalState *st) { 19398| 3.26M| if (!janet_checktype(x, t)) { ------------------ | | 806| 3.26M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [True: 0, False: 3.26M] | | ------------------ | | 807| 3.26M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.26M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.26M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.26M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.26M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.26M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (19398:9): [True: 405, False: 3.26M] ------------------ 19399| |#ifdef JANET_MARSHAL_DEBUG 19400| | dump_reference_table(st); 19401| |#else 19402| 405| (void) st; 19403| 405|#endif 19404| 405| janet_panicf("expected type %T, got %v", 1 << t, x); 19405| 405| } 19406| 3.26M|} janet.c:number_to_string_b: 28656| 238|static void number_to_string_b(JanetBuffer *buffer, double x) { 28657| 238| janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2); ------------------ | |28650| 238|#define BUFSIZE 64 ------------------ 28658| 238| const char *fmt = (x == floor(x) && ------------------ | Branch (28658:24): [True: 222, False: 16] ------------------ 28659| 222| x <= JANET_INTMAX_DOUBLE && ------------------ | | 165| 460|#define JANET_INTMAX_DOUBLE 9007199254740992.0 ------------------ | Branch (28659:24): [True: 218, False: 4] ------------------ 28660| 218| x >= JANET_INTMIN_DOUBLE) ? "%.0f" : ("%." STR(DBL_DIG) "g"); ------------------ | | 166| 218|#define JANET_INTMIN_DOUBLE (-9007199254740992.0) ------------------ | Branch (28660:24): [True: 155, False: 63] ------------------ 28661| 238| int count; 28662| 238| if (x == 0.0) { ------------------ | Branch (28662:9): [True: 40, False: 198] ------------------ 28663| | /* Prevent printing of '-0' */ 28664| 40| count = 1; 28665| 40| buffer->data[buffer->count] = '0'; 28666| 198| } else { 28667| 198| count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, fmt, x); ------------------ | |28650| 198|#define BUFSIZE 64 ------------------ 28668| 198| } 28669| 238| buffer->count += count; 28670| 238|} janet.c:string_description_b: 28716| 24|static void string_description_b(JanetBuffer *buffer, const char *title, void *pointer) { 28717| 24| janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2); ------------------ | |28650| 24|#define BUFSIZE 64 ------------------ 28718| 24| uint8_t *c = buffer->data + buffer->count; 28719| 24| int32_t i; 28720| 24| union { 28721| 24| uint8_t bytes[sizeof(void *)]; 28722| 24| void *p; 28723| 24| } pbuf; 28724| | 28725| 24| pbuf.p = pointer; 28726| 24| *c++ = '<'; 28727| | /* Maximum of 32 bytes for abstract type name */ 28728| 159| for (i = 0; i < 32 && title[i]; ++i) ------------------ | Branch (28728:17): [True: 159, False: 0] | Branch (28728:27): [True: 135, False: 24] ------------------ 28729| 135| *c++ = ((uint8_t *)title) [i]; 28730| 24| *c++ = ' '; 28731| 24| *c++ = '0'; 28732| 24| *c++ = 'x'; 28733| 24|#if defined(JANET_64) 28734| 24|#define POINTSIZE 6 28735| |#else 28736| |#define POINTSIZE (sizeof(void *)) 28737| |#endif 28738| 168| for (i = POINTSIZE; i > 0; --i) { ------------------ | |28734| 24|#define POINTSIZE 6 ------------------ | Branch (28738:25): [True: 144, False: 24] ------------------ 28739| 144| uint8_t byte = pbuf.bytes[i - 1]; 28740| 144| *c++ = HEX(byte >> 4); ------------------ | |28712| 144|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 28741| 144| *c++ = HEX(byte & 0xF); ------------------ | |28712| 144|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 28742| 144| } 28743| 24| *c++ = '>'; 28744| 24| buffer->count = (int32_t)(c - buffer->data); 28745| 24|#undef POINTSIZE 28746| 24|} janet.c:janet_escape_string_b: 28818| 92|static void janet_escape_string_b(JanetBuffer *buffer, const uint8_t *str) { 28819| | janet_escape_string_impl(buffer, str, janet_string_length(str)); ------------------ | | 1812| 92|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1811| 92|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 28820| 92|} janet.c:janet_escape_string_impl: 28748| 139|static int janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) { 28749| 139| janet_buffer_push_u8(buffer, '"'); 28750| 139| int align = 1; 28751| 92.1k| for (int32_t i = 0; i < len; ++i) { ------------------ | Branch (28751:25): [True: 91.9k, False: 139] ------------------ 28752| 91.9k| uint8_t c = str[i]; 28753| 91.9k| switch (c) { 28754| 594| case '"': ------------------ | Branch (28754:13): [True: 594, False: 91.3k] ------------------ 28755| 594| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\"", 2); 28756| 594| align += 2; 28757| 594| break; 28758| 551| case '\n': ------------------ | Branch (28758:13): [True: 551, False: 91.4k] ------------------ 28759| 551| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\n", 2); 28760| 551| align += 2; 28761| 551| break; 28762| 492| case '\r': ------------------ | Branch (28762:13): [True: 492, False: 91.4k] ------------------ 28763| 492| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\r", 2); 28764| 492| align += 2; 28765| 492| break; 28766| 14.3k| case '\0': ------------------ | Branch (28766:13): [True: 14.3k, False: 77.5k] ------------------ 28767| 14.3k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2); 28768| 14.3k| align += 2; 28769| 14.3k| break; 28770| 399| case '\f': ------------------ | Branch (28770:13): [True: 399, False: 91.5k] ------------------ 28771| 399| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2); 28772| 399| align += 2; 28773| 399| break; 28774| 756| case '\v': ------------------ | Branch (28774:13): [True: 756, False: 91.2k] ------------------ 28775| 756| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2); 28776| 756| align += 2; 28777| 756| break; 28778| 478| case '\a': ------------------ | Branch (28778:13): [True: 478, False: 91.4k] ------------------ 28779| 478| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2); 28780| 478| align += 2; 28781| 478| break; 28782| 2.67k| case '\b': ------------------ | Branch (28782:13): [True: 2.67k, False: 89.2k] ------------------ 28783| 2.67k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2); 28784| 2.67k| align += 2; 28785| 2.67k| break; 28786| 586| case 27: ------------------ | Branch (28786:13): [True: 586, False: 91.3k] ------------------ 28787| 586| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2); 28788| 586| align += 2; 28789| 586| break; 28790| 532| case '\\': ------------------ | Branch (28790:13): [True: 532, False: 91.4k] ------------------ 28791| 532| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2); 28792| 532| align += 2; 28793| 532| break; 28794| 495| case '\t': ------------------ | Branch (28794:13): [True: 495, False: 91.4k] ------------------ 28795| 495| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\t", 2); 28796| 495| align += 2; 28797| 495| break; 28798| 70.0k| default: ------------------ | Branch (28798:13): [True: 70.0k, False: 21.9k] ------------------ 28799| 70.0k| if (c < 32 || c > 126) { ------------------ | Branch (28799:21): [True: 6.06k, False: 63.9k] | Branch (28799:31): [True: 40.5k, False: 23.4k] ------------------ 28800| 46.5k| uint8_t buf[4]; 28801| 46.5k| buf[0] = '\\'; 28802| 46.5k| buf[1] = 'x'; 28803| 46.5k| buf[2] = janet_base64[(c >> 4) & 0xF]; 28804| 46.5k| buf[3] = janet_base64[c & 0xF]; 28805| 46.5k| janet_buffer_push_bytes(buffer, buf, 4); 28806| 46.5k| align += 4; 28807| 46.5k| } else { 28808| 23.4k| janet_buffer_push_u8(buffer, c); 28809| 23.4k| align++; 28810| 23.4k| } 28811| 70.0k| break; 28812| 91.9k| } 28813| 91.9k| } 28814| 139| janet_buffer_push_u8(buffer, '"'); 28815| 139| return align + 1; 28816| 139|} janet.c:janet_escape_buffer_b: 28822| 47|static void janet_escape_buffer_b(JanetBuffer *buffer, JanetBuffer *bx) { 28823| 47| if (bx == buffer) { ------------------ | Branch (28823:9): [True: 0, False: 47] ------------------ 28824| | /* Ensures buffer won't resize while escaping */ 28825| 0| janet_buffer_ensure(bx, bx->count + 5 * bx->count + 3, 1); 28826| 0| } 28827| 47| janet_buffer_push_u8(buffer, '@'); 28828| 47| janet_escape_string_impl(buffer, bx->data, bx->count); 28829| 47|} janet.c:scanformat: 29533| 2.17k| char precision[3]) { 29534| 2.17k| const char *p = strfrmt; 29535| | 29536| | /* Parse strfrmt */ 29537| 2.17k| memset(width, '\0', 3); 29538| 2.17k| memset(precision, '\0', 3); 29539| 2.17k| while (*p != '\0' && strchr(FMT_FLAGS, *p) != NULL) ------------------ | |29499| 2.17k|#define FMT_FLAGS "-+ #0" ------------------ | Branch (29539:12): [True: 2.17k, False: 0] | Branch (29539:26): [True: 0, False: 2.17k] ------------------ 29540| 0| p++; /* skip flags */ 29541| 2.17k| if ((size_t)(p - strfrmt) >= sizeof(FMT_FLAGS)) janet_panic("invalid format (repeated flags)"); ------------------ | |29499| 2.17k|#define FMT_FLAGS "-+ #0" ------------------ | Branch (29541:9): [True: 0, False: 2.17k] ------------------ 29542| 2.17k| if (isdigit((int)(*p))) ------------------ | Branch (29542:9): [True: 0, False: 2.17k] ------------------ 29543| 0| width[0] = *p++; /* skip width */ 29544| 2.17k| if (isdigit((int)(*p))) ------------------ | Branch (29544:9): [True: 0, False: 2.17k] ------------------ 29545| 0| width[1] = *p++; /* (2 digits at most) */ 29546| 2.17k| if (*p == '.') { ------------------ | Branch (29546:9): [True: 0, False: 2.17k] ------------------ 29547| 0| p++; 29548| 0| if (isdigit((int)(*p))) ------------------ | Branch (29548:13): [True: 0, False: 0] ------------------ 29549| 0| precision[0] = *p++; /* skip precision */ 29550| 0| if (isdigit((int)(*p))) ------------------ | Branch (29550:13): [True: 0, False: 0] ------------------ 29551| 0| precision[1] = *p++; /* (2 digits at most) */ 29552| 0| } 29553| 2.17k| if (isdigit((int)(*p))) ------------------ | Branch (29553:9): [True: 0, False: 2.17k] ------------------ 29554| 0| janet_panic("invalid format (width or precision too long)"); 29555| | 29556| | /* Write to form - replace characters with fixed size stuff */ 29557| 2.17k| *(form++) = '%'; 29558| 2.17k| const char *p2 = strfrmt; 29559| 4.34k| while (p2 <= p) { ------------------ | Branch (29559:12): [True: 2.17k, False: 2.17k] ------------------ 29560| 2.17k| char *loc = strchr(FMT_REPLACE_INTTYPES, *p2); ------------------ | |29500| 2.17k|#define FMT_REPLACE_INTTYPES "diouxX" ------------------ 29561| 2.17k| if (loc != NULL && *loc != '\0') { ------------------ | Branch (29561:13): [True: 1.34k, False: 830] | Branch (29561:28): [True: 1.34k, False: 0] ------------------ 29562| 1.34k| const char *mapping = get_fmt_mapping(*p2++); 29563| 1.34k| size_t len = strlen(mapping); 29564| 1.34k| memcpy(form, mapping, len); 29565| 1.34k| form += len; 29566| 1.34k| } else { 29567| 830| *(form++) = *(p2++); 29568| 830| } 29569| 2.17k| } 29570| 2.17k| *form = '\0'; 29571| | 29572| 2.17k| return p; 29573| 2.17k|} janet.c:get_fmt_mapping: 29521| 1.34k|static const char *get_fmt_mapping(char c) { 29522| 5.98k| for (size_t i = 0; i < (sizeof(format_mappings) / sizeof(struct FmtMapping)); i++) { ------------------ | Branch (29522:24): [True: 5.98k, False: 0] ------------------ 29523| 5.98k| if (format_mappings[i].c == c) ------------------ | Branch (29523:13): [True: 1.34k, False: 4.64k] ------------------ 29524| 1.34k| return format_mappings[i].mapping; 29525| 5.98k| } 29526| 0| janet_assert(0, "bad format mapping"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, Folded] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 29527| 0|} janet.c:pushtypes: 29477| 405|static void pushtypes(JanetBuffer *buffer, int types) { 29478| 405| int first = 1; 29479| 405| int i = 0; 29480| 3.64k| while (types) { ------------------ | Branch (29480:12): [True: 3.24k, False: 405] ------------------ 29481| 3.24k| if (1 & types) { ------------------ | Branch (29481:13): [True: 405, False: 2.83k] ------------------ 29482| 405| if (first) { ------------------ | Branch (29482:17): [True: 405, False: 0] ------------------ 29483| 405| first = 0; 29484| 405| } else { 29485| 0| janet_buffer_push_cstring(buffer, (types == 1) ? " or " : ", "); ------------------ | Branch (29485:51): [True: 0, False: 0] ------------------ 29486| 0| } 29487| 405| janet_buffer_push_cstring(buffer, janet_type_names[i]); 29488| 405| } 29489| 3.24k| i++; 29490| 3.24k| types >>= 1; 29491| 3.24k| } 29492| 405|} janet.c:janet_symcache_findmem: 33175| 23.1M| int *success) { 33176| 23.1M| uint32_t bounds[4]; 33177| 23.1M| uint32_t i, j, index; 33178| 23.1M| const uint8_t **firstEmpty = NULL; 33179| | 33180| | /* We will search two ranges - index to the end, 33181| | * and 0 to the index. */ 33182| 23.1M| index = (uint32_t)hash & (janet_vm.cache_capacity - 1); 33183| 23.1M| bounds[0] = index; 33184| 23.1M| bounds[1] = janet_vm.cache_capacity; 33185| 23.1M| bounds[2] = 0; 33186| 23.1M| bounds[3] = index; 33187| 23.1M| for (j = 0; j < 4; j += 2) ------------------ | Branch (33187:17): [True: 23.1M, False: 0] ------------------ 33188| 34.8M| for (i = bounds[j]; i < bounds[j + 1]; ++i) { ------------------ | Branch (33188:29): [True: 34.8M, False: 3.33k] ------------------ 33189| 34.8M| const uint8_t *test = janet_vm.cache[i]; 33190| | /* Check empty spots */ 33191| 34.8M| if (NULL == test) { ------------------ | Branch (33191:17): [True: 11.6M, False: 23.2M] ------------------ 33192| 11.6M| if (NULL == firstEmpty) ------------------ | Branch (33192:21): [True: 11.6M, False: 0] ------------------ 33193| 11.6M| firstEmpty = janet_vm.cache + i; 33194| 11.6M| goto notfound; 33195| 11.6M| } 33196| | /* Check for marked deleted */ 33197| 23.2M| if (JANET_SYMCACHE_DELETED == test) { ------------------ | Branch (33197:17): [True: 3.20k, False: 23.2M] ------------------ 33198| 3.20k| if (firstEmpty == NULL) ------------------ | Branch (33198:21): [True: 3.20k, False: 6] ------------------ 33199| 3.20k| firstEmpty = janet_vm.cache + i; 33200| 3.20k| continue; 33201| 3.20k| } 33202| 23.2M| if (janet_string_equalconst(test, str, len, hash)) { ------------------ | Branch (33202:17): [True: 11.5M, False: 11.6M] ------------------ 33203| | /* Replace first deleted */ 33204| 11.5M| *success = 1; 33205| 11.5M| if (firstEmpty != NULL) { ------------------ | Branch (33205:21): [True: 3.20k, False: 11.5M] ------------------ 33206| 3.20k| *firstEmpty = test; 33207| 3.20k| janet_vm.cache[i] = JANET_SYMCACHE_DELETED; 33208| 3.20k| return firstEmpty; 33209| 3.20k| } 33210| 11.5M| return janet_vm.cache + i; 33211| 11.5M| } 33212| 23.2M| } 33213| 11.6M|notfound: 33214| 11.6M| *success = 0; 33215| 11.6M| janet_assert(firstEmpty != NULL, "symcache failed to get memory"); ------------------ | | 389| 11.6M|#define janet_assert(c, m) do { \ | | 390| 11.6M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 11.6M] | | ------------------ | | 391| 11.6M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 11.6M] | | ------------------ ------------------ 33216| 11.6M| return firstEmpty; 33217| 11.6M|} janet.c:janet_symcache_put: 33253| 6.57M|static void janet_symcache_put(const uint8_t *x, const uint8_t **bucket) { 33254| 6.57M| if ((janet_vm.cache_count + janet_vm.cache_deleted) * 2 > janet_vm.cache_capacity) { ------------------ | Branch (33254:9): [True: 6.48k, False: 6.56M] ------------------ 33255| 6.48k| int status; 33256| 6.48k| janet_cache_resize(janet_tablen((2 * janet_vm.cache_count + 1))); 33257| 6.48k| bucket = janet_symcache_find(x, &status); ------------------ | |33220| 6.48k| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1812| 6.48k|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1811| 6.48k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 6.48k|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1811| 6.48k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 33258| 6.48k| } 33259| | /* Add x to the cache */ 33260| 6.57M| janet_vm.cache_count++; 33261| 6.57M| *bucket = x; 33262| 6.57M|} janet.c:janet_cache_resize: 33223| 6.48k|static void janet_cache_resize(uint32_t newCapacity) { 33224| 6.48k| uint32_t i, oldCapacity; 33225| 6.48k| const uint8_t **oldCache = janet_vm.cache; 33226| 6.48k| const uint8_t **newCache = janet_calloc(1, (size_t) newCapacity * sizeof(const uint8_t *)); ------------------ | | 2412| 6.48k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 33227| 6.48k| if (newCache == NULL) { ------------------ | Branch (33227:9): [True: 0, False: 6.48k] ------------------ 33228| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 33229| 0| } 33230| 6.48k| oldCapacity = janet_vm.cache_capacity; 33231| 6.48k| janet_vm.cache = newCache; 33232| 6.48k| janet_vm.cache_capacity = newCapacity; 33233| 6.48k| janet_vm.cache_deleted = 0; 33234| | /* Add all of the old cache entries back */ 33235| 10.0M| for (i = 0; i < oldCapacity; ++i) { ------------------ | Branch (33235:17): [True: 10.0M, False: 6.48k] ------------------ 33236| 10.0M| int status; 33237| 10.0M| const uint8_t **bucket; 33238| 10.0M| const uint8_t *x = oldCache[i]; 33239| 10.0M| if (x != NULL && x != JANET_SYMCACHE_DELETED) { ------------------ | Branch (33239:13): [True: 5.03M, False: 5.01M] | Branch (33239:26): [True: 5.03M, False: 0] ------------------ 33240| 5.03M| bucket = janet_symcache_find(x, &status); ------------------ | |33220| 5.03M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1812| 5.03M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1811| 5.03M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 5.03M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1811| 5.03M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 33241| 5.03M| if (status || bucket == NULL) { ------------------ | Branch (33241:17): [True: 0, False: 5.03M] | Branch (33241:27): [True: 0, False: 5.03M] ------------------ 33242| | /* there was a problem with the algorithm. */ 33243| 0| break; 33244| 0| } 33245| 5.03M| *bucket = x; 33246| 5.03M| } 33247| 10.0M| } 33248| | /* Free the old cache */ 33249| 6.48k| janet_free((void *)oldCache); ------------------ | | 2415| 6.48k|#define janet_free(X) free((X)) ------------------ 33250| 6.48k|} janet.c:janet_table_init_impl: 33394| 2.55M|static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) { 33395| 2.55M| JanetKV *data; 33396| 2.55M| capacity = janet_tablen(capacity); 33397| 2.55M| if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK; ------------------ | |33380| 0|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (33397:9): [True: 0, False: 2.55M] ------------------ 33398| 2.55M| if (capacity) { ------------------ | Branch (33398:9): [True: 2.55M, False: 0] ------------------ 33399| 2.55M| if (stackalloc) { ------------------ | Branch (33399:13): [True: 0, False: 2.55M] ------------------ 33400| 0| data = janet_memalloc_empty_local(capacity); 33401| 2.55M| } else { 33402| 2.55M| data = (JanetKV *) janet_memalloc_empty(capacity); 33403| 2.55M| if (NULL == data) { ------------------ | Branch (33403:17): [True: 0, False: 2.55M] ------------------ 33404| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 33405| 0| } 33406| 2.55M| } 33407| 2.55M| table->data = data; 33408| 2.55M| table->capacity = capacity; 33409| 2.55M| } else { 33410| 0| table->data = NULL; 33411| 0| table->capacity = 0; 33412| 0| } 33413| 2.55M| table->count = 0; 33414| 2.55M| table->deleted = 0; 33415| | table->proto = NULL; 33416| 2.55M| return table; 33417| 2.55M|} janet.c:janet_table_rehash: 33467| 1.97M|static void janet_table_rehash(JanetTable *t, int32_t size) { 33468| 1.97M| JanetKV *olddata = t->data; 33469| 1.97M| JanetKV *newdata; 33470| 1.97M| int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK; ------------------ | |33380| 1.97M|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ 33471| 1.97M| if (islocal) { ------------------ | Branch (33471:9): [True: 0, False: 1.97M] ------------------ 33472| 0| newdata = (JanetKV *) janet_memalloc_empty_local(size); 33473| 1.97M| } else { 33474| 1.97M| newdata = (JanetKV *) janet_memalloc_empty(size); 33475| 1.97M| if (NULL == newdata) { ------------------ | Branch (33475:13): [True: 0, False: 1.97M] ------------------ 33476| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 33477| 0| } 33478| 1.97M| } 33479| 1.97M| int32_t oldcapacity = t->capacity; 33480| 1.97M| t->data = newdata; 33481| 1.97M| t->capacity = size; 33482| 1.97M| t->deleted = 0; 33483| 26.5M| for (int32_t i = 0; i < oldcapacity; i++) { ------------------ | Branch (33483:25): [True: 24.6M, False: 1.97M] ------------------ 33484| 24.6M| JanetKV *kv = olddata + i; 33485| 24.6M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 24.6M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 24.6M] | | ------------------ | | 807| 24.6M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 24.6M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 24.6M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 24.6M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 24.6M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 24.6M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33485:13): [True: 12.3M, False: 12.3M] ------------------ 33486| 12.3M| JanetKV *newkv = janet_table_find(t, kv->key); 33487| 12.3M| *newkv = *kv; 33488| 12.3M| } 33489| 24.6M| } 33490| 1.97M| if (islocal) { ------------------ | Branch (33490:9): [True: 0, False: 1.97M] ------------------ 33491| 0| janet_sfree(olddata); 33492| 1.97M| } else { 33493| 1.97M| janet_free(olddata); ------------------ | | 2415| 1.97M|#define janet_free(X) free((X)) ------------------ 33494| 1.97M| } 33495| 1.97M|} janet.c:janet_registry_sort: 34449| 2|static void janet_registry_sort(void) { 34450| 704| for (size_t i = 1; i < janet_vm.registry_count; i++) { ------------------ | Branch (34450:24): [True: 702, False: 2] ------------------ 34451| 702| JanetCFunRegistry reg = janet_vm.registry[i]; 34452| 702| size_t j; 34453| 49.4k| for (j = i; j > 0; j--) { ------------------ | Branch (34453:21): [True: 49.4k, False: 6] ------------------ 34454| 49.4k| if ((void *)(janet_vm.registry[j - 1].cfun) < (void *)(reg.cfun)) break; ------------------ | Branch (34454:17): [True: 696, False: 48.7k] ------------------ 34455| 48.7k| janet_vm.registry[j] = janet_vm.registry[j - 1]; 34456| 48.7k| } 34457| 702| janet_vm.registry[j] = reg; 34458| 702| } 34459| 2| janet_vm.registry_dirty = 0; 34460| 2|} janet.c:janet_check_pointer_align: 34550| 1.16M|static void janet_check_pointer_align(void *p) { 34551| 1.16M| (void) p; 34552| |#if defined(JANET_NANBOX_64) && JANET_NANBOX_64_POINTER_SHIFT != 0 34553| | union { 34554| | void *p; 34555| | uintptr_t u; 34556| | } un; 34557| | un.p = p; 34558| | janet_assert(!(un.u & (uintptr_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), 34559| | "unaligned pointer wrap - cfunction pointers and abstract types must be aligned with this nanboxing configuration."); 34560| |#endif 34561| 1.16M|} janet.c:janet_compare_abstract: 35434| 54|static int janet_compare_abstract(JanetAbstract xx, JanetAbstract yy) { 35435| 54| if (xx == yy) return 0; ------------------ | Branch (35435:9): [True: 0, False: 54] ------------------ 35436| 54| const JanetAbstractType *xt = janet_abstract_type(xx); ------------------ | | 1898| 54|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1896| 54|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 35437| 54| const JanetAbstractType *yt = janet_abstract_type(yy); ------------------ | | 1898| 54|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1896| 54|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 35438| 54| if (xt != yt) { ------------------ | Branch (35438:9): [True: 0, False: 54] ------------------ 35439| 0| return xt > yt ? 1 : -1; ------------------ | Branch (35439:16): [True: 0, False: 0] ------------------ 35440| 0| } 35441| 54| if (xt->compare == NULL) { ------------------ | Branch (35441:9): [True: 54, False: 0] ------------------ 35442| 54| return xx > yy ? 1 : -1; ------------------ | Branch (35442:16): [True: 7, False: 47] ------------------ 35443| 54| } 35444| 0| return xt->compare(xx, yy); 35445| 54|} janet.c:push_traversal_node: 35232| 73.7k|static void push_traversal_node(void *lhs, void *rhs, int32_t index2) { 35233| 73.7k| JanetTraversalNode node; 35234| 73.7k| node.self = (JanetGCObject *) lhs; 35235| 73.7k| node.other = (JanetGCObject *) rhs; 35236| 73.7k| node.index = 0; 35237| 73.7k| node.index2 = index2; 35238| 73.7k| int is_new = janet_vm.traversal_base == NULL; 35239| 73.7k| if (is_new || (janet_vm.traversal + 1 >= janet_vm.traversal_top)) { ------------------ | Branch (35239:9): [True: 479, False: 73.2k] | Branch (35239:19): [True: 0, False: 73.2k] ------------------ 35240| 479| size_t oldsize = is_new ? 0 : (janet_vm.traversal - janet_vm.traversal_base); ------------------ | Branch (35240:26): [True: 479, False: 0] ------------------ 35241| 479| size_t newsize = 2 * oldsize + 1; 35242| 479| if (newsize < 128) { ------------------ | Branch (35242:13): [True: 479, False: 0] ------------------ 35243| 479| newsize = 128; 35244| 479| } 35245| 479| JanetTraversalNode *tn = janet_realloc(janet_vm.traversal_base, newsize * sizeof(JanetTraversalNode)); ------------------ | | 2409| 479|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 35246| 479| if (tn == NULL) { ------------------ | Branch (35246:13): [True: 0, False: 479] ------------------ 35247| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35248| 0| } 35249| 479| janet_vm.traversal_base = tn; 35250| 479| janet_vm.traversal_top = janet_vm.traversal_base + newsize; 35251| 479| janet_vm.traversal = janet_vm.traversal_base + oldsize; 35252| 479| } 35253| 73.7k| *(++janet_vm.traversal) = node; 35254| 73.7k|} janet.c:traversal_next: 35264| 4.35M|static int traversal_next(Janet *x, Janet *y) { 35265| 4.35M| JanetTraversalNode *t = janet_vm.traversal; 35266| 4.42M| while (t && t > janet_vm.traversal_base) { ------------------ | Branch (35266:12): [True: 710k, False: 3.71M] | Branch (35266:17): [True: 237k, False: 473k] ------------------ 35267| 237k| JanetGCObject *self = t->self; 35268| 237k| JanetTupleHead *tself = (JanetTupleHead *)self; 35269| 237k| JanetStructHead *sself = (JanetStructHead *)self; 35270| 237k| JanetGCObject *other = t->other; 35271| 237k| JanetTupleHead *tother = (JanetTupleHead *)other; 35272| 237k| JanetStructHead *sother = (JanetStructHead *)other; 35273| 237k| if ((self->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_TUPLE) { ------------------ | | 630| 237k|#define JANET_MEM_TYPEBITS 0xFF ------------------ | Branch (35273:13): [True: 14.8k, False: 222k] ------------------ 35274| | /* Node is a tuple at index t->index */ 35275| 14.8k| if (t->index < tself->length && t->index < tother->length) { ------------------ | Branch (35275:17): [True: 2.72k, False: 12.0k] | Branch (35275:45): [True: 2.72k, False: 0] ------------------ 35276| 2.72k| int32_t index = t->index++; 35277| 2.72k| *x = tself->data[index]; 35278| 2.72k| *y = tother->data[index]; 35279| 2.72k| janet_vm.traversal = t; 35280| 2.72k| return 0; 35281| 2.72k| } 35282| 12.0k| if (t->index2 && tself->length != tother->length) { ------------------ | Branch (35282:17): [True: 7.69k, False: 4.38k] | Branch (35282:30): [True: 0, False: 7.69k] ------------------ 35283| 0| return tself->length > tother->length ? 3 : 1; ------------------ | Branch (35283:24): [True: 0, False: 0] ------------------ 35284| 0| } 35285| 222k| } else { 35286| | /* Node is a struct at index t->index: if t->index2 is true, we should return the values. */ 35287| 222k| if (t->index2) { ------------------ | Branch (35287:17): [True: 80.4k, False: 141k] ------------------ 35288| 80.4k| t->index2 = 0; 35289| 80.4k| int32_t index = t->index++; 35290| 80.4k| *x = sself->data[index].value; 35291| 80.4k| *y = sother->data[index].value; 35292| 80.4k| janet_vm.traversal = t; 35293| 80.4k| return 0; 35294| 80.4k| } 35295| 141k| for (int32_t i = t->index; i < sself->capacity; i++) { ------------------ | Branch (35295:40): [True: 80.4k, False: 61.4k] ------------------ 35296| 80.4k| t->index2 = 1; 35297| 80.4k| *x = sself->data[t->index].key; 35298| 80.4k| *y = sother->data[t->index].key; 35299| 80.4k| janet_vm.traversal = t; 35300| 80.4k| return 0; 35301| 80.4k| } 35302| | /* Traverse prototype */ 35303| 61.4k| JanetStruct sproto = sself->proto; 35304| 61.4k| JanetStruct oproto = sother->proto; 35305| 61.4k| if (sproto && !oproto) return 3; ------------------ | Branch (35305:17): [True: 2.68k, False: 58.7k] | Branch (35305:27): [True: 0, False: 2.68k] ------------------ 35306| 61.4k| if (!sproto && oproto) return 1; ------------------ | Branch (35306:17): [True: 58.7k, False: 2.68k] | Branch (35306:28): [True: 0, False: 58.7k] ------------------ 35307| 61.4k| if (oproto && sproto) { ------------------ | Branch (35307:17): [True: 2.68k, False: 58.7k] | Branch (35307:27): [True: 2.68k, False: 0] ------------------ 35308| 2.68k| *x = janet_wrap_struct(sproto); ------------------ | | 842| 2.68k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 2.68k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35309| 2.68k| *y = janet_wrap_struct(oproto); ------------------ | | 842| 2.68k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 2.68k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35310| 2.68k| janet_vm.traversal = t - 1; 35311| 2.68k| return 0; 35312| 2.68k| } 35313| 61.4k| } 35314| 70.8k| t--; 35315| 70.8k| } 35316| 4.19M| janet_vm.traversal = t; 35317| 4.19M| return 2; 35318| 4.35M|} janet.c:murmur64: 35497| 15.2M|static uint64_t murmur64(uint64_t h) { 35498| 15.2M| h ^= h >> 33; 35499| 15.2M| h *= 0xff51afd7ed558ccdUL; 35500| 15.2M| h ^= h >> 33; 35501| 15.2M| h *= 0xc4ceb9fe1a85ec53UL; 35502| 15.2M| h ^= h >> 33; 35503| 15.2M| return h; 35504| 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) { ------------------ | | 1980| 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|}