support lexically scoped vars via dynamic binding

lox/interpreter.janet

···
      token (errorf "Unknown operator %q" token))
     left right))
 
+(defn- declare-var [name]
+  (setdyn name @[]))
+
+(defn- set-var [name val]
+  (if-let [ref (dyn name)]
+    (do (array/clear ref) (array/push ref val))
+    (errorf "Undefined variable '%s'." name)))
+
+(defn- get-var [name]
+  (if-let [@[val] (dyn name)]
+    val
+    (errorf "Undefined variable '%s'." name)))
+
 (defn evaluate [expr]
   (match expr
     [:literal value] value
···
     [:logical left op right] (case ((op :token) 0)
                                :or (if-let [left (evaluate left)] left (evaluate right))
                                :and (if-let [left (evaluate left)] (evaluate right) left))
-    (errorf "Unknown expression type %q" (expr 0))))
+    [:assign {:token [:ident name]} value] (set-var name (evaluate value))
+    [:variable {:token [:ident name]}] (get-var name)
+    [ty] (errorf "Unknown expression type %s" ty)
+    (errorf "Invalid expression %q" expr)))
 
 (var execute nil)
 
 (defn- execute-block [stmts]
-  (each stmt stmts (execute stmt)))
+  # open new scope
+  (with-dyns []
+    (each stmt stmts (execute stmt))))
 
 (varfn execute [stmt]
   (match stmt
     [:print expr] (printf "%q" (evaluate expr))
-    [:expr expr] (xprintf (dyn :expr-out stderr) "%Q" (evaluate expr))
+    [:expr expr] (xprintf (dyn :expr-out @"") "%Q" (evaluate expr))
     # [:return word value] (throw return)
     [:if cond then else] (do
                            (cond
···
                              (not (nil? else)) (execute else)))
     [:while cond body] (while (evaluate cond) (execute body))
     [:block stmts] (execute-block stmts)
-    (errorf "Unknown statement type %q" (stmt 0))))
+    [:var {:token [:ident name]} init] (let [val (and init (evaluate init))]
+                                         (declare-var name)
+                                         (when init (set-var name val)))
+    [ty] (errorf "Unknown statement type %s" ty)
+    (errorf "Invalid statement %q" stmt)))
 
 (defn interpret [stmts]
+  (setdyn :locals @{})
   # TODO error handling
-  (each stmt stmts (try (execute stmt)
-                     ([e] (eprint e)))))
+  (each stmt stmts (execute stmt)))

lox/main.janet

···
 (defn main [_ &opt path & args]
   (unless (empty? args) (error "expected 0 or 1 args"))
   (if (nil? path)
-    (repl/run process)
-    (with-dyns [:expr-out @""] (process (slurp path)))))
+
+    (with-dyns [:expr-out stderr] (repl/run process))
+    (process (slurp path))))

lox/parser.janet

···
     [:nil] [:literal nil]
     [:num val] [:literal val]
     [:str val] [:literal val]
-    [:ident name] [:variable name]
+    [:ident name] [:variable token]
     [:left-paren] (do (def expr (expression parser))
                     (:consume parser :right-paren "Expect ')' after expression.")
                     [:grouping expr])))
···
   (when (def equals (:match parser :eq))
     (def value (assignment parser))
     (match expr
-      [:variable name] (set expr [:assignment name value])
+      [:variable name] (set expr [:assign name value])
       # TODO put equals token in error?
       _ (errorf "Invalid assignment target: %M" expr)))
   expr)

test/test_main.janet

···
 (test-stdout (process "if (false) print 1; else print 2;") `
   2
 `)
+
+(test-stdout (process "var three = 1 + 2; print three;") `
+  3
+`)
+(test-stdout (process "var three; three = 1 + 2; print three;") `
+  3
+`)
+(test-stdout (process "var none = nil; print none;") `
+  nil
+`)
+(test-stdout (process `
+  var n = 1 + 2;
+  {
+    print n;
+    n = n * 10;
+    var n = -1;
+    n = n * 10;
+    print n;
+  }
+  n = n * 10;
+  print n;
+  `) `
+  3
+  -10
+  300
+`)
+(test-error (process "none = nil;") "Undefined variable 'none'.")
+(test-error (process "print none;") "Undefined variable 'none'.")

test/test_parser.janet

···
 (use judge)
+(use ../lox/scanner)
 (use ../lox/parser)
 
 (defn parse [tokens] (:parse (make-parser tokens)))
···
          [:literal true]
          [:print [:literal true]]
          [:print [:literal false]]]])
+
+(defn scan-parse [input] (parse (scan input)))
+
+(test (scan-parse "var three;")
+  @[[:var
+     {:line 1 :token [:ident "three"]}
+     nil]])
+(test (scan-parse "var three = 1 + 2; print three;")
+      @[[:var {:line 1 :token [:ident "three"]}
+         [:binary
+          [:literal 1]
+          {:line 1 :token [:plus]}
+          [:literal 2]]]
+        [:print [:variable {:line 1 :token [:ident "three"]}]]])