symbolslots now use janet_v vectors, flat structure

src/boot/boot.janet

@@ -2769,18 +2769,14 @@
 
   # define variables available at breakpoint
   (def frame ((debug/stack fiber) 0))
-  (def slotsyms ((disasm (frame :function)) :slotsyms))
+  (def symbolslots ((disasm (frame :function)) :symbolslots))
   (def pc (frame :pc))
 
-  (loop [[start stop syms] :in slotsyms]
+  (loop [[birth death slot sym] :in symbolslots]
-    (when (and (or (= start :top)
+    (when (and (<= birth pc)
-                   (<= start pc))
+               (or (= death 0)
-               (or (= stop :top)
+                   (< pc death)))
-                   (< pc stop)))
+        (put nextenv (symbol sym) @{:value (get-in frame [:slots slot])})))
-      (loop [[sym instances] :pairs syms
-             [def-index slot] :in instances
-             :when (<= def-index pc)]
-        (put nextenv (symbol sym) @{:value (get-in frame [:slots slot])}))))
 
   (merge-into nextenv debugger-env)
   (defn debugger-chunks [buf p]

src/core/asm.c

@@ -882,34 +882,19 @@ static Janet janet_disasm_slotcount(JanetFuncDef *def) {
     return janet_wrap_integer(def->slotcount);
 }
 
-/*
+static Janet janet_disasm_symbolslots(JanetFuncDef *def) {
-example structure:
+    JanetArray *symbolslots = janet_array(def->symbolslots_length);
-:slotsyms @[(:top :top @{"o1" @[(-1 0)] "outer" @[(0 1)])])
+    for (int32_t i = 0; i < def->symbolslots_length; i++) {
-            (2    8
+        JanetSymbolSlot ss = def->symbolslots[i];
-#            ^ beginning of scope
+        Janet *t = janet_tuple_begin(4);
-#                 ^ end of scope
+        t[0] = janet_wrap_integer(ss.birth_pc);
-                       @{"inner" @[(6 6)] "odo4" @[(2 4) (10 7)]})]
+        t[1] = janet_wrap_integer(ss.death_pc);
-#                                   ^               ^ bytecode index of def
+        t[2] = janet_wrap_integer(ss.slot_index);
-#                                     ^               ^ slot index
+        t[3] = janet_cstringv((const char *) ss.symbol);
-                                                         ^ redefinition
+        symbolslots->data[i] = janet_wrap_tuple(janet_tuple_end(t));
-
-beginning of scope is the bytecode index of when a scope begins.
-if the program counter is >= beginning of scope and < end of scope, it is
-currently in that scope.
-
-bytecode index of def is the bytecode index from where the slot / sym is actually defined. before this point the slot might have a value, but it's just residual data from earlier slot usage.
-
-the redefinition is an example of what happens if the same symbol is used twice, e.g. due to calling `def` twice with the same symbol in the same scope. in that case the first slot (4) is valid from the first bytecode index until the bytecode index in the redefinition, after which the second slot (4) is valid.
-
-:top means the function's scope, e.g. parameters and `def` calls outside of e.g. a `do`-block
-*/
-static Janet janet_disasm_slotsyms(JanetFuncDef *def) {
-    JanetArray *slotsyms = janet_array(def->slotsyms_length);
-    for (int32_t i = 0; i < def->slotsyms_length; i++) {
-        slotsyms->data[i] = def->slotsyms[i];
     }
-    slotsyms->count = def->slotsyms_length;
+    symbolslots->count = def->symbolslots_length;
-    return janet_wrap_array(slotsyms);
+    return janet_wrap_array(symbolslots);
 }
 
 
@@ -992,7 +977,7 @@ Janet janet_disasm(JanetFuncDef *def) {
     janet_table_put(ret, janet_ckeywordv("structarg"), janet_disasm_structarg(def));
     janet_table_put(ret, janet_ckeywordv("name"), janet_disasm_name(def));
     janet_table_put(ret, janet_ckeywordv("slotcount"), janet_disasm_slotcount(def));
-    janet_table_put(ret, janet_ckeywordv("slotsyms"), janet_disasm_slotsyms(def));
+    janet_table_put(ret, janet_ckeywordv("symbolslots"), janet_disasm_symbolslots(def));
     janet_table_put(ret, janet_ckeywordv("constants"), janet_disasm_constants(def));
     janet_table_put(ret, janet_ckeywordv("sourcemap"), janet_disasm_sourcemap(def));
     janet_table_put(ret, janet_ckeywordv("environments"), janet_disasm_environments(def));
@@ -1029,7 +1014,7 @@ JANET_CORE_FN(cfun_disasm,
               "* :source - name of source file that this function was compiled from.\n"
               "* :name - name of function.\n"
               "* :slotcount - how many virtual registers, or slots, this function uses. Corresponds to stack space used by function.\n"
-              "* :slotsyms - all slots and their symbols.\n"
+              "* :symbolslots - all symbols and their slots.\n"
               "* :constants - an array of constants referenced by this function.\n"
               "* :sourcemap - a mapping of each bytecode instruction to a line and column in the source file.\n"
               "* :environments - an internal mapping of which enclosing functions are referenced for bindings.\n"

src/core/bytecode.c

@@ -218,7 +218,7 @@ JanetFuncDef *janet_funcdef_alloc(void) {
     def->closure_bitset = NULL;
     def->flags = 0;
     def->slotcount = 0;
-    def->slotsyms = 0;
+    def->symbolslots = 0;
     def->arity = 0;
     def->min_arity = 0;
     def->max_arity = INT32_MAX;
@@ -230,6 +230,7 @@ JanetFuncDef *janet_funcdef_alloc(void) {
     def->constants_length = 0;
     def->bytecode_length = 0;
     def->environments_length = 0;
+    def->symbolslots_length = 0;
     return def;
 }
 

src/core/compile.c

@@ -177,49 +177,29 @@ void janetc_popscope(JanetCompiler *c) {
     }
 
     if (janet_truthy(janet_dyn("debug"))) {
-        /* push symbols */
+        bool top_level = (oldscope->flags & (JANET_SCOPE_FUNCTION | JANET_SCOPE_UNUSED));
-        if (true || (!(oldscope->flags & (JANET_SCOPE_FUNCTION | JANET_SCOPE_UNUSED)) && newscope)) {
-            Janet *t = janet_tuple_begin(3);
-            t[0] = janet_wrap_integer(oldscope->bytecode_start);
-            t[1] = janet_wrap_integer(janet_v_count(c->buffer));
         
-            JanetTable *sym_table = janet_table(janet_v_count(oldscope->syms));
+        /* push symbol slots */
+        JanetSymbolSlot ss;
+        int32_t scope_end = top_level ? INT32_MAX : janet_v_count(c->buffer);
 
-            for (int32_t i = 0; i < janet_v_count(oldscope->syms); i++) {
+        janet_assert(janet_v_count(c->local_symbols) > 0, "c->local_symbols should not be empty");
+
+        // due to scopes being added "in reverse" (filo), we will reverse all symbols later. therefore we must first reverse the order of symbols inside each scope as well.
+        for (int32_t i = janet_v_count(oldscope->syms) - 1; i >= 0; i--) {
             SymPair pair = oldscope->syms[i];
 
             if (pair.sym != NULL) {
-                    Janet *symbol_tuple = janet_tuple_begin(2);
+                ss.birth_pc = pair.bytecode_pos;
-                    symbol_tuple[0] = janet_wrap_integer(pair.bytecode_pos);
+                ss.death_pc = scope_end;
-                    symbol_tuple[1] = janet_wrap_integer(pair.slot.index);
+                ss.slot_index = pair.slot.index;
+                ss.symbol = pair.sym;
 
-                    Janet k = janet_cstringv((const char *) pair.sym);
+                janet_v_push(janet_v_last(c->local_symbols), ss);
-
-                    Janet arr = janet_table_get(sym_table, k);
-
-                    if (janet_checktype(arr, JANET_NIL)) {
-                        JanetArray *a = janet_array(1);
-                        janet_array_push(a, janet_wrap_tuple(janet_tuple_end(symbol_tuple)));
-                        janet_table_put(sym_table, k, janet_wrap_array(a));
-                    } else {
-                        JanetArray *a = janet_unwrap_array(arr);
-                        janet_array_push(a, janet_wrap_tuple(janet_tuple_end(symbol_tuple)));
             }
         }
     }
 
-            t[2] = janet_wrap_table(sym_table);
-            if (c->local_binds->count > 0) {
-                janet_array_push(janet_unwrap_array(c->local_binds->data[c->local_binds->count - 1]), janet_wrap_tuple(janet_tuple_end(t)));
-            } else {
-                // this shouldn't occur -- local_binds should always have at least
-                // 1 element when a scope is popped
-                fprintf(stderr, "no local_binds pushed\n");
-            }
-        }
-        /* end push symbols */
-    }
-
     /* Free the old scope */
     janet_v_free(oldscope->consts);
     janet_v_free(oldscope->syms);
@@ -972,23 +952,23 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
     /* Pop the scope */
     janetc_popscope(c);
 
-
     if (janet_truthy(janet_dyn("debug"))) {
-        JanetArray *last_binds = janet_unwrap_array(c->local_binds->data[c->local_binds->count - 1]);
+        JanetSymbolSlot *last_symbols = janet_v_last(c->local_symbols);
 
-        def->slotsyms_length = last_binds->count;
+        def->symbolslots_length = janet_v_count(last_symbols);
-        def->slotsyms = janet_malloc(sizeof(Janet) * (size_t)def->slotsyms_length);
 
-        //                       just gotta modify some tuples
+        def->symbolslots = janet_malloc(sizeof(JanetSymbolSlot) * def->symbolslots_length);
-        Janet *top_level_tuple = (Janet *)janet_unwrap_tuple(last_binds->data[last_binds->count - 1]);
+        if (NULL == def->bytecode) {
-        top_level_tuple[0] = janet_ckeywordv("top");
+            JANET_OUT_OF_MEMORY;
-        top_level_tuple[1] = janet_ckeywordv("top");
+        }
-        for (int i = 0; i < last_binds->count; i++) {
+        
-            def->slotsyms[def->slotsyms_length - i - 1] = last_binds->data[i];
+        // add in reverse, because scopes have been added filo
+        for (int i = 0; i < janet_v_count(last_symbols); i++) {
+            def->symbolslots[def->symbolslots_length - i - 1] = last_symbols[i];
         }
     }
 
-    janet_array_pop(c->local_binds);
+    janet_v_pop(c->local_symbols);
 
     return def;
 }
@@ -1000,7 +980,7 @@ static void janetc_init(JanetCompiler *c, JanetTable *env, const uint8_t *where,
     c->mapbuffer = NULL;
     c->recursion_guard = JANET_RECURSION_GUARD;
     c->env = env;
-    c->local_binds = janet_array(0);
+    c->local_symbols = NULL;
     c->source = where;
     c->current_mapping.line = -1;
     c->current_mapping.column = -1;
@@ -1019,7 +999,7 @@ static void janetc_deinit(JanetCompiler *c) {
     janet_v_free(c->buffer);
     janet_v_free(c->mapbuffer);
     c->env = NULL;
-    c->local_binds = NULL;
+    janet_v_free(c->local_symbols);
 }
 
 /* Compile a form. */
@@ -1033,7 +1013,7 @@ JanetCompileResult janet_compile_lint(Janet source,
 
     /* Push a function scope */
     if (janet_truthy(janet_dyn("debug"))) {
-        janet_array_push(c.local_binds, janet_wrap_array(janet_array(0)));
+        janet_v_push(c.local_symbols, NULL);
     }
     janetc_scope(&rootscope, &c, JANET_SCOPE_FUNCTION | JANET_SCOPE_TOP, "root");
 
@@ -1054,7 +1034,7 @@ JanetCompileResult janet_compile_lint(Janet source,
         c.result.error_mapping = c.current_mapping;
         janetc_popscope(&c);
         if (janet_truthy(janet_dyn("debug"))) {
-            janet_array_pop(c.local_binds);
+            janet_v_pop(c.local_symbols);
         }
     }
 

src/core/compile.h

@@ -161,7 +161,7 @@ struct JanetCompiler {
     /* Hold the environment */
     JanetTable *env;
 
-    JanetArray *local_binds;
+    JanetSymbolSlot **local_symbols;
 
     /* Name of source to attach to generated functions */
     const uint8_t *source;

src/core/specials.c

@@ -755,7 +755,7 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)
 
 
         if (janet_truthy(janet_dyn("debug"))) {
-            janet_array_push(c->local_binds, janet_wrap_array(janet_array(0)));
+            janet_v_push(c->local_symbols, NULL);
         }
         janetc_scope(&tempscope, c, JANET_SCOPE_FUNCTION, "while-iife");
 
@@ -834,7 +834,7 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     /* Begin function */
     c->scope->flags |= JANET_SCOPE_CLOSURE;
     if (janet_truthy(janet_dyn("debug"))) {
-        janet_array_push(c->local_binds, janet_wrap_array(janet_array(0)));
+        janet_v_push(c->local_symbols, NULL);
     }
     janetc_scope(&fnscope, c, JANET_SCOPE_FUNCTION, "function");
 

src/include/janet.h

@@ -448,6 +448,7 @@ typedef struct JanetReg JanetReg;
 typedef struct JanetRegExt JanetRegExt;
 typedef struct JanetMethod JanetMethod;
 typedef struct JanetSourceMapping JanetSourceMapping;
+typedef struct JanetSymbolSlot JanetSymbolSlot;
 typedef struct JanetView JanetView;
 typedef struct JanetByteView JanetByteView;
 typedef struct JanetDictView JanetDictView;
@@ -1018,6 +1019,14 @@ struct JanetSourceMapping {
     int32_t column;
 };
 
+/* Symbol to slot mapping & lifetime structure. */
+struct JanetSymbolSlot {
+    uint32_t birth_pc;
+    uint32_t death_pc;
+    uint32_t slot_index;
+    const uint8_t *symbol;
+};
+
 /* A function definition. Contains information needed to instantiate closures. */
 struct JanetFuncDef {
     JanetGCObject gc;
@@ -1031,7 +1040,7 @@ struct JanetFuncDef {
     JanetSourceMapping *sourcemap;
     JanetString source;
     JanetString name;
-    Janet *slotsyms;
+    JanetSymbolSlot *symbolslots;
 
     int32_t flags;
     int32_t slotcount; /* The amount of stack space required for the function */
@@ -1042,7 +1051,7 @@ struct JanetFuncDef {
     int32_t bytecode_length;
     int32_t environments_length;
     int32_t defs_length;
-    int32_t slotsyms_length;
+    int32_t symbolslots_length;
 };
 
 /* A function environment */

test/suite0011.janet

@@ -106,4 +106,3 @@
 (assert (= ((f 10) 37) 47) "asm environment tables")
 
 (end-suite)
-

test/suite0015.janet

@@ -3,25 +3,40 @@
 (import ./helper :prefix "" :exit true)
 (start-suite 15)
 
-(assert (deep= (in (disasm (defn a [] (def x 10) x)) :slotsyms)
+(assert (deep= (in (disasm (defn a [] (def x 10) x)) :symbolslots)
                @[])
-  "no slotsyms when *debug* is false")
+  "no symbolslots when *debug* is false")
 
 (setdyn *debug* true)
-(assert (deep= (in (disasm (defn a [] (def x 10) x)) :slotsyms)
+(assert (deep= (in (disasm (defn a [] (def x 10) x)) :symbolslots)
-               @[[:top :top @{"a" @[[0 0]] "x" @[[1 1]]}]])
+               @[[0 2147483647 0 "a"] [1 2147483647 1 "x"]])
-  "slotsyms when *debug* is true")
+  "symbolslots when *debug* is true")
 (setdyn *debug* false)
 
+
+# need to fix assembling functions
+(comment
   (setdyn *debug* true)
-(assert (deep= (in (disasm (defn a []
+  (def f (asm (disasm (fn [x] (fn [y] (+ x y))))))
+  (assert (deep= (in (disasm f) :symbolslots)
+                @[[0 2147483647 0 "a"] [1 2147483647 1 "x"]])
+    "symbolslots survive disasm/asm")
+  (setdyn *debug* false)
+  )
+
+(setdyn *debug* true)
+(assert (deep= (in (disasm (defn a [arg]
                             (def x 10)
                             (do
                               (def y 20)
-                              (+ x y)))) :slotsyms)
+                              (def z 30)
-               @[[:top :top @{"a" @[[0 0]] "x" @[[1 1]]}]
+                              (+ x y z)))) :symbolslots)
-                 [2    5    @{"y" @[[2 2]]}]])
+               @[[-1 2147483647 0 "arg"]
-  "inner slotsyms")
+                 [0 2147483647 1 "a"]
+                 [1 2147483647 2 "x"]
+                 [2 7 3 "y"]
+                 [3 7 4 "z"]])
+  "arg & inner symbolslots")
 (setdyn *debug* false)
 
 (end-suite)