Prepare for 0.5.0 release

string/has-suffix? and string/has-prefix? can now accept
all byte data types for both arguments.

CHANGELOG.md

@@ -1,6 +1,23 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 0.5.0 - 2019-05-09
+- Fix some bugs with buffers.
+- Add `trace` and `untrace` to the core library.
+- Add `string/has-prefix?` and `string/has-suffix?` to string module.
+- Add simple debugger to repl that activates on errors or debug signal
+- Remove `*env*` and `*doc-width*`.
+- Add `fiber/getenv`, `fiber/setenv`, and `dyn`, and `setdyn`.
+- Add support for dynamic bindings (via the `dyn` and `setdyn` functions).
+- Change signatures of some functions like `eval` which no longer takes
+  an optional environment.
+- Add printf function
+- Make `pp` configurable with dynamic binding `:pretty-format`.
+- Remove the `meta` function.
+- Add `with-dyns` for blocks with dynamic bindings assigned.
+- Allow leading and trailing newlines in backtick-delimited string (long strings).
+  These newlines will not be included in the actual string value.
+
 ## 0.4.1 - 2019-04-14
 - Squash some bugs
 - Peg patterns can now make captures in any position in a grammar.

Makefile

@@ -26,6 +26,7 @@ PREFIX?=/usr/local
 
 INCLUDEDIR=$(PREFIX)/include
 BINDIR=$(PREFIX)/bin
+LIBDIR=$(PREFIX)/lib
 JANET_BUILD?="\"$(shell git log --pretty=format:'%h' -n 1)\""
 CLIBS=-lm
 JANET_TARGET=build/janet
@@ -271,11 +272,19 @@ build/janet.tmLanguage: tools/tm_lang_gen.janet $(JANET_TARGET)
 clean:
 	-rm -rf build vgcore.* callgrind.*
 
-install: $(JANET_TARGET)
+build/version.txt: $(JANET_TARGET)
+	$(JANET_TARGET) -e '(print janet/version)' > $@
+
+SONAME=libjanet.so.0
+install: $(JANET_TARGET) build/version.txt
 	mkdir -p $(BINDIR)
 	cp $(JANET_TARGET) $(BINDIR)/janet
 	mkdir -p $(INCLUDEDIR)
 	cp $(JANET_HEADERS) $(INCLUDEDIR)
+	mkdir -p $(LIBDIR)
+	cp $(JANET_LIBRARY) $(LIBDIR)/libjanet.so.$(shell cat build/version.txt)
+	ln -sf $(SONAME) $(LIBDIR)/libjanet.so
+	ln -sf libjanet.so.$(shell cat build/version.txt) $(LIBDIR)/$(SONAME)
 	mkdir -p $(INCLUDEDIR)/janet
 	mkdir -p $(JANET_PATH)
 	ln -sf $(INCLUDEDIR)/janet.h $(JANET_PATH)/janet.h
@@ -285,6 +294,7 @@ install: $(JANET_TARGET)
 	cp tools/bars.janet $(JANET_PATH)
 	mkdir -p $(MANPATH)
 	cp janet.1 $(MANPATH)
+	-ldconfig $(LIBDIR)
 
 test-install:
 	cd test/install && rm -rf build && janet build && janet build

README.md

@@ -48,9 +48,8 @@ Janet makes a good system scripting language, or a language to embed in other pr
 
 ## Documentation
 
-* For a quick tutorial, see [the introduction](https://janet-lang.org/introduction.html) for more details.
-* For an overview of functions in the core library, see [the function index](https://janet-lang.org/funcindex.html).
-* For the full API for all functions in the core library, see [the core API doc](https://janet-lang.org/doc.html)
+* For a quick tutorial, see [the introduction](https://janet-lang.org/docs/index.html) for more details.
+* For the full API for all functions in the core library, see [the core API doc](https://janet-lang.org/api/index.html)
 
 Documentation is also available locally in the repl.
 Use the `(doc symbol-name)` macro to get API
@@ -63,6 +62,12 @@ Shows documentation for the doc macro.
 To get a list of all bindings in the default
 environment, use the `(all-symbols)` function.
 
+## Source
+
+You can get the source on [GitHub](https://github.com/janet-lang/janet) or
+[SourceHut](https://git.sr.ht/~bakpakin/janet). While the GitHub repo is the official repo,
+the SourceHut mirror is actively maintained.
+
 ## Building
 
 ### macos and Unix-like

examples/3sum.janet

@@ -14,5 +14,5 @@
   (map keys (keys solutions)))
 
 (def arr @[2 4 1 3 8 7 -3 -1 12 -5 -8])
-(print "3sum of " (string/pretty arr) ":")
-(print (string/pretty (sum3 arr)))
+(printf "3sum of %P: " arr)
+(printf "%P\n" (sum3 arr))

examples/numarray/build.janet

@@ -4,7 +4,7 @@
     :name "numarray"
     :source @["numarray.c"])
 
-(import build/numarray :prefix "")
+(import build/numarray :as numarray)
 
 (def a (numarray/new 30))
 (print (get a 20))

examples/numarray/numarray.c

@@ -100,12 +100,12 @@ Janet num_array_get(void *p, Janet key) {
 
 static const JanetReg cfuns[] = {
     {
-        "numarray/new", num_array_new,
+        "new", num_array_new,
         "(numarray/new size)\n\n"
         "Create new numarray"
     },
     {
-        "numarray/scale", num_array_scale,
+        "scale", num_array_scale,
         "(numarray/scale numarray factor)\n\n"
         "scale numarray by factor"
     },

src/boot/boot.janet

@@ -7,8 +7,6 @@
 ###
 ###
 
-(var *env* "The current environment." _env)
-
 (def defn :macro
   "(def name & more)\n\nDefine a function. Equivalent to (def name (fn name [args] ...))."
   (fn defn [name & more]
@@ -64,14 +62,14 @@
   "Dynamically create a global def."
   [name value]
   (def name* (symbol name))
-  (put *env* name* @{:value value})
+  (setdyn name* @{:value value})
   nil)
 
 (defn varglobal
   "Dynamically create a global var."
   [name init]
   (def name* (symbol name))
-  (put *env* name* @{:ref @[init]})
+  (setdyn name* @{:ref @[init]})
   nil)
 
 # Basic predicates
@@ -216,7 +214,7 @@
   (let [[[err fib]] catch
         f (gensym)
         r (gensym)]
-    ~(let [,f (,fiber/new (fn [] ,body) :e)
+    ~(let [,f (,fiber/new (fn [] ,body) :ie)
            ,r (resume ,f)]
        (if (= (,fiber/status ,f) :error)
          (do (def ,err ,r) ,(if fib ~(def ,fib ,f)) ,;(tuple/slice catch 1))
@@ -307,6 +305,7 @@
     ~(do
        (var ,i nil)
        (while (set ,i ,expr)
+         (def ,binding ,i)
          ,body))))
 
 (defn- loop1
@@ -414,12 +413,12 @@
   "Create a generator expression using the loop syntax. Returns a fiber
   that yields all values inside the loop in order. See loop for details."
   [head & body]
-  ~(fiber/new (fn [] (loop ,head (yield (do ,;body))))))
+  ~(fiber/new (fn [] (loop ,head (yield (do ,;body)))) :yi))
 
 (defmacro coro
-  "A wrapper for making fibers. Same as (fiber/new (fn [] ...body))."
+  "A wrapper for making fibers. Same as (fiber/new (fn [] ...body) :yi)."
   [& body]
-  (tuple fiber/new (tuple 'fn '[] ;body)))
+  (tuple fiber/new (tuple 'fn '[] ;body) :yi))
 
 (defn sum
   "Returns the sum of xs. If xs is empty, returns 0."
@@ -715,7 +714,7 @@
 
 (defn juxt*
   "Returns the juxtaposition of functions. In other words,
-  ((juxt* a b c) x) evaluates to ((a x) (b x) (c x))."
+  ((juxt* a b c) x) evaluates to [(a x) (b x) (c x)]."
   [& funs]
   (fn [& args]
     (def ret @[])
@@ -854,6 +853,19 @@
     (set prev ~(if-let [,sym ,prev] ,next-prev)))
   prev)
 
+(defmacro with-dyns
+  "Run a block of code in a new fiber that has some
+  dynamic bindings set. The fiber will not mask errors
+  or signals, but the dynamic bindings will be properly
+  unset, as dynamic bindings are fiber local."
+  [bindings & body]
+  (with-syms [currenv env fib]
+    ~(let [,currenv (,fiber/getenv (,fiber/current))
+           ,env (,table/setproto (,table ,;bindings) ,currenv)
+           ,fib (,fiber/new (fn [] ,;body) :)]
+       (,fiber/setenv ,fib ,env)
+       (,resume ,fib))))
+
 (defn partial
   "Partial function application."
   [f & more]
@@ -903,8 +915,9 @@
   res)
 
 (defn update
-  "Accepts a key argument and passes its' associated value to a function.
-  The key then, is associated to the function's return value"
+  "Accepts a key argument and passes its associated value to a function.
+  The key is the re-associated to the function's return value. Returns the updated
+  data structure ds."
   [ds key func & args]
   (def old (get ds key))
   (set (ds key) (func old ;args)))
@@ -1068,6 +1081,12 @@
   (file/close f)
   nil)
 
+(defn printf
+  "Print formatted strings to stdout, followed by
+  a new line."
+  [f & args]
+  (file/write stdout (buffer/format @"" f ;args)))
+
 ###
 ###
 ### Pattern Matching
@@ -1173,15 +1192,11 @@
 ###
 ###
 
-(var *doc-width*
-  "Width in columns to print documentation."
-  80)
-
 (defn doc-format
   "Reformat text to wrap at a given line."
   [text]
 
-  (def maxcol (- *doc-width* 8))
+  (def maxcol (- (dyn :doc-width 80) 8))
   (var buf @"    ")
   (var word @"")
   (var current 0)
@@ -1217,8 +1232,8 @@
 
 (defn doc*
   "Get the documentation for a symbol in a given environment."
-  [env sym]
-  (def x (get env sym))
+  [sym]
+  (def x (dyn sym))
   (if (not x)
     (print "symbol " sym " not found.")
     (do
@@ -1241,7 +1256,7 @@
 (defmacro doc
   "Shows documentation for the given symbol."
   [sym]
-  ~(,doc* *env* ',sym))
+  ~(,doc* ',sym))
 
 ###
 ###
@@ -1320,7 +1335,7 @@
   (defn dotup [t]
     (def h (get t 0))
     (def s (get specs h))
-    (def entry (or (get *env* h) {}))
+    (def entry (or (dyn h) {}))
     (def m (entry :value))
     (def m? (entry :macro))
     (cond
@@ -1390,7 +1405,7 @@
 (defn pp
   "Pretty print to stdout."
   [x]
-  (print (buffer/format @"" "%p" x)))
+  (print (buffer/format @"" (dyn :pretty-format "%p") x)))
 
 ###
 ###
@@ -1436,11 +1451,11 @@
   opts is a table or struct of options. The options are as follows:\n\n\t
   :chunks - callback to read into a buffer - default is getline\n\t
   :on-parse-error - callback when parsing fails - default is bad-parse\n\t
-  :env - the environment to compile against - default is *env*\n\t
+  :env - the environment to compile against - default is the current env\n\t
   :source - string path of source for better errors - default is \"<anonymous>\"\n\t
   :on-compile-error - callback when compilation fails - default is bad-compile\n\t
   :on-status - callback when a value is evaluated - default is debug/stacktrace\n\t
-  :fiber-flags - what flags to wrap the compilation fiber with. Default is :a."
+  :fiber-flags - what flags to wrap the compilation fiber with. Default is :ia."
   [opts]
 
   (def {:env env
@@ -1450,7 +1465,7 @@
         :on-parse-error on-parse-error
         :fiber-flags guard
         :source where} opts)
-  (default env *env*)
+  (default env (fiber/getenv (fiber/current)))
   (default chunks getline)
   (default onstatus debug/stacktrace)
   (default on-compile-error bad-compile)
@@ -1463,7 +1478,7 @@
   # The parser object
   (def p (parser/new))
 
-  # Evaluate 1 source form
+  # Evaluate 1 source form in a protected manner
   (defn eval1 [source]
     (var good true)
     (def f
@@ -1481,13 +1496,11 @@
                   err))
               (on-compile-error msg errf where))))
         (or guard :a)))
+    (fiber/setenv f env)
     (def res (resume f nil))
     (when good (if going (onstatus f res))))
 
-  (def oldenv *env*)
-  (set *env* env)
-
-  # Run loop
+  # Loop
   (def buf @"")
   (while going
     (buffer/clear buf)
@@ -1504,21 +1517,18 @@
         (eval1 (parser/produce p)))
       (when (= (parser/status p) :error)
         (on-parse-error p where))))
-
   # Check final parser state
   (while (parser/has-more p)
     (eval1 (parser/produce p)))
   (when (= (parser/status p) :error)
     (on-parse-error p where))
 
-  (set *env* oldenv)
-
   env)
 
 (defn eval-string
   "Evaluates a string in the current environment. If more control over the
   environment is needed, use run-context."
-  [str &opt env]
+  [str]
   (var state (string str))
   (defn chunks [buf _]
     (def ret state)
@@ -1527,26 +1537,24 @@
       (buffer/push-string buf str)
       (buffer/push-string buf "\n")))
   (var returnval nil)
-  (run-context {:env env
-                :chunks chunks
+  (run-context {:chunks chunks
                 :on-compile-error (fn [msg errf &]
                                     (error (string "compile error: " msg)))
                 :on-parse-error (fn [p x]
                                   (error (string "parse error: " (parser/error p))))
-                :fiber-flags :
+                :fiber-flags :i
                 :on-status (fn [f val]
                              (if-not (= (fiber/status f) :dead)
                                (error val))
                              (set returnval val))
-                :source "eval"})
+                :source "eval-string"})
   returnval)
 
 (defn eval
   "Evaluates a form in the current environment. If more control over the
   environment is needed, use run-context."
-  [form &opt env]
-  (default env *env*)
-  (def res (compile form env "eval"))
+  [form]
+  (def res (compile form (fiber/getenv (fiber/current)) "eval"))
   (if (= (type res) :function)
     (res)
     (error (res :error))))
@@ -1605,7 +1613,7 @@
 (defn module/find
   "Try to match a module or path name from the patterns in module/paths.
   Returns a tuple (fullpath kind) where the kind is one of :source, :native,
-  or image if the module is found, otherise a tuple with nil followed by
+  or image if the module is found, otherwise a tuple with nil followed by
   an error message."
   [path]
   (def parts (string/split "/" path))
@@ -1684,16 +1692,16 @@
       env)))
 
 (defn import*
-  "Import a module into a given environment table. This is the
-  functional form of (import ...) that expects and explicit environment
-  table."
-  [env path & args]
+  "Function form of import. Same parameters, but the path
+  and other symbol parameters should be strings instead."
+  [path & args]
+  (def env (fiber/getenv (fiber/current)))
   (def {:as as
         :prefix prefix
         :export ep} (table ;args))
   (def newenv (require path ;args))
   (def prefix (or (and as (string as "/")) prefix (string path "/")))
-  (loop [[k v] :pairs newenv :when (not (v :private))]
+  (loop [[k v] :pairs newenv :when (symbol? k) :when (not (v :private))]
     (def newv (table/setproto @{:private (not ep)} v))
     (put env (symbol prefix k) newv)))
 
@@ -1709,50 +1717,68 @@
                      x
                      (string x)))
                  args))
-  (tuple import* '*env* (string path) ;argm))
+  (tuple import* (string path) ;argm))
 
 (defn repl
   "Run a repl. The first parameter is an optional function to call to
   get a chunk of source code that should return nil for end of file.
   The second parameter is a function that is called when a signal is
-  caught. fmt is a format string used to print results, and defaults to
-  \"%.20P\""
-  [&opt chunks onsignal fmt]
-  (def newenv (make-env))
-  (default fmt "%.20P")
+  caught."
+  [&opt chunks onsignal env]
+  (def level (+ (dyn :debug-level 0) 1))
+  (default env (make-env))
   (default onsignal (fn [f x]
                       (case (fiber/status f)
                         :dead (do
-                                (put newenv '_ @{:value x})
-                                (print (buffer/format @"" fmt x)))
+                                (pp x)
+                                (put env '_ @{:value x}))
+                        :debug (let [nextenv (make-env env)]
+                                 (put nextenv '_fiber @{:value f})
+                                 (setdyn :debug-level level)
+                                 (debug/stacktrace f x)
+                                 (print ```
+
+entering debugger - Ctrl-D to exit
+_fiber is bound to the suspended fiber
+
+```)
+                          (repl (fn [buf p]
+                                  (def status (parser/state p))
+                                  (def c (parser/where p))
+                                  (def prompt (string "debug[" level "]:" c ":" status "> "))
+                                  (getline prompt buf))
+                                onsignal nextenv))
                         (debug/stacktrace f x))))
-  (run-context {:env newenv
+  (run-context {:env env
                 :chunks chunks
                 :on-status onsignal
                 :source "repl"}))
 
-(defmacro meta
-  "Add metadata to the current environment."
-  [& args]
-  (def opts (table ;args))
-  (loop [[k v] :pairs opts]
-    (put *env* k v)))
+(defn- env-walk
+  [pred]
+  (def env (fiber/getenv (fiber/current)))
+  (def envs @[])
+  (do (var e env) (while e (array/push envs e) (set e (table/getproto e))))
+  (def ret-set @{})
+  (loop [envi :in envs
+         k :keys envi
+         :when (pred k)]
+    (put ret-set k true))
+  (sort (keys ret-set)))
 
 (defn all-bindings
   "Get all symbols available in the current environment."
-  [&opt env]
-  (default env *env*)
-  (def envs @[])
-  (do (var e env) (while e (array/push envs e) (set e (table/getproto e))))
-  (def symbol-set @{})
-  (loop [envi :in envs
-         k :keys envi
-         :when (symbol? k)]
-    (put symbol-set k true))
-  (sort (keys symbol-set)))
+  []
+  (env-walk symbol?))
+
+(defn all-dynamics
+  "Get all dynamic bindings in the current fiber."
+  []
+  (env-walk keyword?))
 
 # Clean up some extra defs
 (put _env 'process/opts nil)
+(put _env 'env-walk nil)
 (put _env '_env nil)
 
 ###
@@ -1762,12 +1788,12 @@
 ###
 
 (do
-
-  (def image (let [env-pairs (pairs (env-lookup *env*))
+  (def env (fiber/getenv (fiber/current)))
+  (def image (let [env-pairs (pairs (env-lookup env))
                    essential-pairs (filter (fn [[k v]] (or (cfunction? v) (abstract? v))) env-pairs)
                    lookup (table ;(mapcat identity essential-pairs))
                    reverse-lookup (invert lookup)]
-               (marshal *env* reverse-lookup)))
+               (marshal env reverse-lookup)))
 
   # Create C source file that contains images a uint8_t buffer. This
   # can be compiled and linked statically into the main janet library

src/boot/system_test.c

@@ -45,6 +45,8 @@ int system_test() {
     assert(janet_equals(janet_wrap_number(1.4), janet_wrap_number(1.4)));
     assert(janet_equals(janet_wrap_number(3.14159265), janet_wrap_number(3.14159265)));
 
+    assert(NULL != &janet_wrap_nil);
+
     assert(janet_equals(janet_cstringv("a string."), janet_cstringv("a string.")));
     assert(janet_equals(janet_csymbolv("sym"), janet_csymbolv("sym")));
 

src/core/buffer.c

@@ -208,6 +208,10 @@ static Janet cfun_buffer_chars(int32_t argc, Janet *argv) {
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     for (i = 1; i < argc; i++) {
         JanetByteView view = janet_getbytes(argv, i);
+        if (view.bytes == buffer->data) {
+            janet_buffer_ensure(buffer, buffer->count + view.len, 2);
+            view.bytes = buffer->data;
+        }
         janet_buffer_push_bytes(buffer, view.bytes, view.len);
     }
     return argv[0];
@@ -296,6 +300,7 @@ static Janet cfun_buffer_blit(int32_t argc, Janet *argv) {
     janet_arity(argc, 2, 5);
     JanetBuffer *dest = janet_getbuffer(argv, 0);
     JanetByteView src = janet_getbytes(argv, 1);
+    int same_buf = src.bytes == dest->data;
     int32_t offset_dest = 0;
     int32_t offset_src = 0;
     if (argc > 2)
@@ -315,7 +320,12 @@ static Janet cfun_buffer_blit(int32_t argc, Janet *argv) {
         janet_panic("buffer blit out of range");
     janet_buffer_ensure(dest, (int32_t) last, 2);
     if (last > dest->count) dest->count = (int32_t) last;
-    memcpy(dest->data + offset_dest, src.bytes + offset_src, length_src);
+    if (same_buf) {
+        src.bytes = dest->data;
+        memmove(dest->data + offset_dest, src.bytes + offset_src, length_src);
+    } else {
+        memcpy(dest->data + offset_dest, src.bytes + offset_src, length_src);
+    }
     return argv[0];
 }
 

src/core/bytecode.c

@@ -23,6 +23,7 @@
 #ifndef JANET_AMALG
 #include <janet.h>
 #include "gc.h"
+#include "util.h"
 #endif
 
 /* Look up table for instructions */

src/core/capi.c

@@ -36,6 +36,34 @@ void janet_panicv(Janet message) {
     }
 }
 
+void janet_panicf(const char *format, ...) {
+    va_list args;
+    const uint8_t *ret;
+    JanetBuffer buffer;
+    int32_t len = 0;
+    while (format[len]) len++;
+    janet_buffer_init(&buffer, len);
+    va_start(args, format);
+    janet_formatb(&buffer, format, args);
+    va_end(args);
+    ret = janet_string(buffer.data, buffer.count);
+    janet_buffer_deinit(&buffer);
+    janet_panics(ret);
+}
+
+void janet_printf(const char *format, ...) {
+    va_list args;
+    JanetBuffer buffer;
+    int32_t len = 0;
+    while (format[len]) len++;
+    janet_buffer_init(&buffer, len);
+    va_start(args, format);
+    janet_formatb(&buffer, format, args);
+    va_end(args);
+    fwrite(buffer.data, buffer.count, 1, stdout);
+    janet_buffer_deinit(&buffer);
+}
+
 void janet_panic(const char *message) {
     janet_panicv(janet_cstringv(message));
 }
@@ -204,3 +232,38 @@ JanetRange janet_getslice(int32_t argc, const Janet *argv) {
     }
     return range;
 }
+
+Janet janet_dyn(const char *name) {
+    if (!janet_vm_fiber) return janet_wrap_nil();
+    if (janet_vm_fiber->env) {
+        return janet_table_get(janet_vm_fiber->env, janet_ckeywordv(name));
+    } else {
+        return janet_wrap_nil();
+    }
+}
+
+void janet_setdyn(const char *name, Janet value) {
+    if (!janet_vm_fiber) return;
+    if (!janet_vm_fiber->env) {
+        janet_vm_fiber->env = janet_table(1);
+    }
+    janet_table_put(janet_vm_fiber->env, janet_ckeywordv(name), value);
+}
+
+/* Some definitions for function-like macros */
+
+JANET_API JanetStructHead *(janet_struct_head)(const JanetKV *st) {
+    return janet_struct_head(st);
+}
+
+JANET_API JanetAbstractHead *(janet_abstract_head)(const void *abstract) {
+    return janet_abstract_head(abstract);
+}
+
+JANET_API JanetStringHead *(janet_string_head)(const uint8_t *s) {
+    return janet_string_head(s);
+}
+
+JANET_API JanetTupleHead *(janet_tuple_head)(const Janet *tuple) {
+    return janet_tuple_head(tuple);
+}

src/core/corelib.c

@@ -69,6 +69,29 @@ JanetModule janet_native(const char *name, const uint8_t **error) {
     return init;
 }
 
+static Janet janet_core_dyn(int32_t argc, Janet *argv) {
+    janet_arity(argc, 1, 2);
+    Janet value;
+    if (janet_vm_fiber->env) {
+        value = janet_table_get(janet_vm_fiber->env, argv[0]);
+    } else {
+        value = janet_wrap_nil();
+    }
+    if (argc == 2 && janet_checktype(value, JANET_NIL)) {
+        return argv[1];
+    }
+    return value;
+}
+
+static Janet janet_core_setdyn(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    if (!janet_vm_fiber->env) {
+        janet_vm_fiber->env = janet_table(2);
+    }
+    janet_table_put(janet_vm_fiber->env, argv[0], argv[1]);
+    return argv[1];
+}
+
 static Janet janet_core_native(int32_t argc, Janet *argv) {
     JanetModule init;
     janet_arity(argc, 1, 2);
@@ -88,19 +111,6 @@ static Janet janet_core_native(int32_t argc, Janet *argv) {
     return janet_wrap_table(env);
 }
 
-static Janet janet_core_print(int32_t argc, Janet *argv) {
-    for (int32_t i = 0; i < argc; ++i) {
-        int32_t j, len;
-        const uint8_t *vstr = janet_to_string(argv[i]);
-        len = janet_string_length(vstr);
-        for (j = 0; j < len; ++j) {
-            putc(vstr[j], stdout);
-        }
-    }
-    putc('\n', stdout);
-    return janet_wrap_nil();
-}
-
 static Janet janet_core_describe(int32_t argc, Janet *argv) {
     JanetBuffer *b = janet_buffer(0);
     for (int32_t i = 0; i < argc; ++i)
@@ -263,6 +273,20 @@ static Janet janet_core_getline(int32_t argc, Janet *argv) {
     return janet_wrap_buffer(buf);
 }
 
+static Janet janet_core_trace(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    JanetFunction *func = janet_getfunction(argv, 0);
+    func->gc.flags |= JANET_FUNCFLAG_TRACE;
+    return argv[0];
+}
+
+static Janet janet_core_untrace(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    JanetFunction *func = janet_getfunction(argv, 0);
+    func->gc.flags &= ~JANET_FUNCFLAG_TRACE;
+    return argv[0];
+}
+
 static const JanetReg corelib_cfuns[] = {
     {
         "native", janet_core_native,
@@ -273,13 +297,6 @@ static const JanetReg corelib_cfuns[] = {
              "Returns an environment table that contains functions and other values "
              "from the native module.")
     },
-    {
-        "print", janet_core_print,
-        JDOC("(print & xs)\n\n"
-             "Print values to the console (standard out). Value are converted "
-             "to strings if they are not already. After printing all values, a "
-             "newline character is printed. Returns nil.")
-    },
     {
         "describe", janet_core_describe,
         JDOC("(describe x)\n\n"
@@ -419,6 +436,26 @@ static const JanetReg corelib_cfuns[] = {
              "Reads a line of input into a buffer, including the newline character, using a prompt. Returns the modified buffer. "
              "Use this function to implement a simple interface for a terminal program.")
     },
+    {
+        "dyn", janet_core_dyn,
+        JDOC("(dyn key [, default=nil])\n\n"
+             "Get a dynamic binding. Returns the default value if no binding found.")
+    },
+    {
+        "setdyn", janet_core_setdyn,
+        JDOC("(setdyn key value)\n\n"
+             "Set a dynamic binding. Returns value.")
+    },
+    {
+        "trace", janet_core_trace,
+        JDOC("(trace func)\n\n"
+             "Enable tracing on a function. Returns the function.")
+    },
+    {
+        "untrace", janet_core_untrace,
+        JDOC("(untrace func)\n\n"
+             "Disables tracing on a function. Returns the function.")
+    },
     {NULL, NULL, NULL}
 };
 

src/core/debug.c

@@ -95,6 +95,7 @@ void janet_debug_find(
  * consitency with the top level code it is defined once. */
 void janet_stacktrace(JanetFiber *fiber, Janet err) {
     int32_t fi;
+    FILE *out = janet_dynfile("err", stderr);
     const char *errstr = (const char *)janet_to_string(err);
     JanetFiber **fibers = NULL;
     int wrote_error = 0;
@@ -116,43 +117,43 @@ void janet_stacktrace(JanetFiber *fiber, Janet err) {
             if (!wrote_error) {
                 JanetFiberStatus status = janet_fiber_status(fiber);
                 const char *prefix = status == JANET_STATUS_ERROR ? "" : "status ";
-                fprintf(stderr, "%s%s: %s\n",
+                fprintf(out, "%s%s: %s\n",
                         prefix,
                         janet_status_names[status],
                         errstr);
                 wrote_error = 1;
             }
 
-            fprintf(stderr, "  in");
+            fprintf(out, "  in");
 
             if (frame->func) {
                 def = frame->func->def;
-                fprintf(stderr, " %s", def->name ? (const char *)def->name : "<anonymous>");
+                fprintf(out, " %s", def->name ? (const char *)def->name : "<anonymous>");
                 if (def->source) {
-                    fprintf(stderr, " [%s]", (const char *)def->source);
+                    fprintf(out, " [%s]", (const char *)def->source);
                 }
             } else {
                 JanetCFunction cfun = (JanetCFunction)(frame->pc);
                 if (cfun) {
                     Janet name = janet_table_get(janet_vm_registry, janet_wrap_cfunction(cfun));
                     if (!janet_checktype(name, JANET_NIL))
-                        fprintf(stderr, " %s", (const char *)janet_to_string(name));
+                        fprintf(out, " %s", (const char *)janet_to_string(name));
                     else
-                        fprintf(stderr, " <cfunction>");
+                        fprintf(out, " <cfunction>");
                 }
             }
             if (frame->flags & JANET_STACKFRAME_TAILCALL)
-                fprintf(stderr, " (tailcall)");
+                fprintf(out, " (tailcall)");
             if (frame->func && frame->pc) {
                 int32_t off = (int32_t)(frame->pc - def->bytecode);
                 if (def->sourcemap) {
                     JanetSourceMapping mapping = def->sourcemap[off];
-                    fprintf(stderr, " at (%d:%d)", mapping.start, mapping.end);
+                    fprintf(out, " at (%d:%d)", mapping.start, mapping.end);
                 } else {
-                    fprintf(stderr, " pc=%d", off);
+                    fprintf(out, " pc=%d", off);
                 }
             }
-            fprintf(stderr, "\n");
+            fprintf(out, "\n");
         }
     }
 

src/core/fiber.c

@@ -35,6 +35,7 @@ static void fiber_reset(JanetFiber *fiber) {
     fiber->stacktop = JANET_FRAME_SIZE;
     fiber->child = NULL;
     fiber->flags = JANET_FIBER_MASK_YIELD;
+    fiber->env = NULL;
     janet_fiber_set_status(fiber, JANET_STATUS_NEW);
 }
 
@@ -291,8 +292,35 @@ void janet_fiber_popframe(JanetFiber *fiber) {
     fiber->frame = frame->prevframe;
 }
 
+JanetFiberStatus janet_fiber_status(JanetFiber *f) {
+    return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET;
+}
+
+JanetFiber *janet_current_fiber(void) {
+    return janet_vm_fiber;
+}
+
 /* CFuns */
 
+static Janet cfun_fiber_getenv(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    JanetFiber *fiber = janet_getfiber(argv, 0);
+    return fiber->env ?
+           janet_wrap_table(fiber->env) :
+           janet_wrap_nil();
+}
+
+static Janet cfun_fiber_setenv(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    JanetFiber *fiber = janet_getfiber(argv, 0);
+    if (janet_checktype(argv[1], JANET_NIL)) {
+        fiber->env = NULL;
+    } else {
+        fiber->env = janet_gettable(argv, 1);
+    }
+    return argv[0];
+}
+
 static Janet cfun_fiber_new(int32_t argc, Janet *argv) {
     janet_arity(argc, 1, 2);
     JanetFunction *func = janet_getfunction(argv, 0);
@@ -333,6 +361,12 @@ static Janet cfun_fiber_new(int32_t argc, Janet *argv) {
                     case 'y':
                         fiber->flags |= JANET_FIBER_MASK_YIELD;
                         break;
+                    case 'i':
+                        if (!janet_vm_fiber->env) {
+                            janet_vm_fiber->env = janet_table(0);
+                        }
+                        fiber->env = janet_vm_fiber->env;
+                        break;
                 }
             }
         }
@@ -343,8 +377,7 @@ static Janet cfun_fiber_new(int32_t argc, Janet *argv) {
 static Janet cfun_fiber_status(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
-    uint32_t s = (fiber->flags & JANET_FIBER_STATUS_MASK) >>
-                 JANET_FIBER_STATUS_OFFSET;
+    uint32_t s = janet_fiber_status(fiber);
     return janet_ckeywordv(janet_status_names[s]);
 }
 
@@ -388,7 +421,8 @@ static const JanetReg fiber_cfuns[] = {
              "\te - block error signals\n"
              "\tu - block user signals\n"
              "\ty - block yield signals\n"
-             "\t0-9 - block a specific user signal")
+             "\t0-9 - block a specific user signal\n"
+             "\ti - inherit the environment from the current fiber (not related to signals)")
     },
     {
         "fiber/status", cfun_fiber_status,
@@ -420,6 +454,18 @@ static const JanetReg fiber_cfuns[] = {
              "Sets the maximum stack size in janet values for a fiber. By default, the "
              "maximum stack size is usually 8192.")
     },
+    {
+        "fiber/getenv", cfun_fiber_getenv,
+        JDOC("(fiber/getenv fiber)\n\n"
+             "Gets the environment for a fiber. Returns nil if no such table is "
+             "set yet.")
+    },
+    {
+        "fiber/setenv", cfun_fiber_setenv,
+        JDOC("(fiber/setenv fiber table)\n\n"
+             "Sets the environment table for a fiber. Set to nil to remove the current "
+             "environment.")
+    },
     {NULL, NULL, NULL}
 };
 

src/core/gc.c

@@ -25,6 +25,7 @@
 #include "state.h"
 #include "symcache.h"
 #include "gc.h"
+#include "util.h"
 #endif
 
 /* GC State */
@@ -107,11 +108,11 @@ static void janet_mark_buffer(JanetBuffer *buffer) {
 }
 
 static void janet_mark_abstract(void *adata) {
-    if (janet_gc_reachable(janet_abstract_header(adata)))
+    if (janet_gc_reachable(janet_abstract_head(adata)))
         return;
-    janet_gc_mark(janet_abstract_header(adata));
-    if (janet_abstract_header(adata)->type->gcmark) {
-        janet_abstract_header(adata)->type->gcmark(adata, janet_abstract_size(adata));
+    janet_gc_mark(janet_abstract_head(adata));
+    if (janet_abstract_head(adata)->type->gcmark) {
+        janet_abstract_head(adata)->type->gcmark(adata, janet_abstract_size(adata));
     }
 }
 
@@ -236,6 +237,9 @@ recur:
         i = frame->prevframe;
     }
 
+    if (fiber->env)
+        janet_mark_table(fiber->env);
+
     /* Explicit tail recursion */
     if (fiber->child) {
         fiber = fiber->child;

src/core/inttypes.c

@@ -83,6 +83,8 @@ static const JanetAbstractType it_u64_type = {
 
 int64_t janet_unwrap_s64(Janet x) {
     switch (janet_type(x)) {
+        default:
+            break;
         case JANET_NUMBER : {
             double dbl = janet_unwrap_number(x);
             if (fabs(dbl) <=  MAX_INT_IN_DBL)
@@ -110,6 +112,8 @@ int64_t janet_unwrap_s64(Janet x) {
 
 uint64_t janet_unwrap_u64(Janet x) {
     switch (janet_type(x)) {
+        default:
+            break;
         case JANET_NUMBER : {
             double dbl = janet_unwrap_number(x);
             if ((dbl >= 0) && (dbl <= MAX_INT_IN_DBL))

src/core/io.c

@@ -333,7 +333,37 @@ static Janet io_file_get(void *p, Janet key) {
     return janet_getmethod(janet_unwrap_keyword(key), io_file_methods);
 }
 
+FILE *janet_dynfile(const char *name, FILE *def) {
+    Janet x = janet_dyn(name);
+    if (!janet_checktype(x, JANET_ABSTRACT)) return def;
+    void *abstract = janet_unwrap_abstract(x);
+    if (janet_abstract_type(abstract) != &cfun_io_filetype) return def;
+    IOFile *iofile = abstract;
+    return iofile->file;
+}
+
+static Janet cfun_io_print(int32_t argc, Janet *argv) {
+    FILE *f = janet_dynfile("out", stdout);
+    for (int32_t i = 0; i < argc; ++i) {
+        int32_t j, len;
+        const uint8_t *vstr = janet_to_string(argv[i]);
+        len = janet_string_length(vstr);
+        for (j = 0; j < len; ++j) {
+            putc(vstr[j], f);
+        }
+    }
+    putc('\n', f);
+    return janet_wrap_nil();
+}
+
 static const JanetReg io_cfuns[] = {
+    {
+        "print", cfun_io_print,
+        JDOC("(print & xs)\n\n"
+             "Print values to the console (standard out). Value are converted "
+             "to strings if they are not already. After printing all values, a "
+             "newline character is printed. Returns nil.")
+    },
     {
         "file/open", cfun_io_fopen,
         JDOC("(file/open path [,mode])\n\n"

src/core/marsh.c

@@ -249,6 +249,7 @@ static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags) {
 }
 
 #define JANET_FIBER_FLAG_HASCHILD (1 << 29)
+#define JANET_FIBER_FLAG_HASENV (1 << 28)
 #define JANET_STACKFRAME_HASENV (1 << 30)
 
 /* Marshal a fiber */
@@ -256,6 +257,7 @@ static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) {
     MARSH_STACKCHECK;
     int32_t fflags = fiber->flags;
     if (fiber->child) fflags |= JANET_FIBER_FLAG_HASCHILD;
+    if (fiber->env) fflags |= JANET_FIBER_FLAG_HASENV;
     if (janet_fiber_status(fiber) == JANET_STATUS_ALIVE)
         janet_panic("cannot marshal alive fiber");
     pushint(st, fflags);
@@ -282,24 +284,31 @@ static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) {
         j = i - JANET_FRAME_SIZE;
         i = frame->prevframe;
     }
+    if (fiber->env) {
+        marshal_one(st, janet_wrap_table(fiber->env), flags + 1);
+    }
     if (fiber->child)
         marshal_one(st, janet_wrap_fiber(fiber->child), flags + 1);
 }
 
+void janet_marshal_size(JanetMarshalContext *ctx, size_t value) {
+    janet_marshal_int64(ctx, (int64_t) value);
+}
+
 void janet_marshal_int64(JanetMarshalContext *ctx, int64_t value) {
     MarshalState *st = (MarshalState *)(ctx->m_state);
     push64(st, (uint64_t) value);
-};
+}
 
 void janet_marshal_int(JanetMarshalContext *ctx, int32_t value) {
     MarshalState *st = (MarshalState *)(ctx->m_state);
     pushint(st, value);
-};
+}
 
 void janet_marshal_byte(JanetMarshalContext *ctx, uint8_t value) {
     MarshalState *st = (MarshalState *)(ctx->m_state);
     pushbyte(st, value);
-};
+}
 
 void janet_marshal_bytes(JanetMarshalContext *ctx, const uint8_t *bytes, size_t len) {
     MarshalState *st = (MarshalState *)(ctx->m_state);
@@ -837,6 +846,7 @@ static const uint8_t *unmarshal_one_fiber(
     fiber->maxstack = 0;
     fiber->data = NULL;
     fiber->child = NULL;
+    fiber->env = NULL;
 
     /* Push fiber to seen stack */
     janet_array_push(&st->lookup, janet_wrap_fiber(fiber));
@@ -934,6 +944,15 @@ static const uint8_t *unmarshal_one_fiber(
         janet_panic("fiber has too many stackframes");
     }
 
+    /* Check for fiber env */
+    if (fiber->flags & JANET_FIBER_FLAG_HASENV) {
+        Janet envv;
+        fiber->flags &= ~JANET_FIBER_FLAG_HASENV;
+        data = unmarshal_one(st, data, &envv, flags + 1);
+        janet_asserttype(envv, JANET_TABLE);
+        fiber->env = janet_unwrap_table(envv);
+    }
+
     /* Check for child fiber */
     if (fiber->flags & JANET_FIBER_FLAG_HASCHILD) {
         Janet fiberv;
@@ -952,18 +971,22 @@ static const uint8_t *unmarshal_one_fiber(
 int32_t janet_unmarshal_int(JanetMarshalContext *ctx) {
     UnmarshalState *st = (UnmarshalState *)(ctx->u_state);
     return readint(st, &(ctx->data));
-};
+}
+
+size_t janet_unmarshal_size(JanetMarshalContext *ctx) {
+    return (size_t) janet_unmarshal_int64(ctx);
+}
 
 int64_t janet_unmarshal_int64(JanetMarshalContext *ctx) {
     UnmarshalState *st = (UnmarshalState *)(ctx->u_state);
     return read64(st, &(ctx->data));
-};
+}
 
 uint8_t janet_unmarshal_byte(JanetMarshalContext *ctx) {
     UnmarshalState *st = (UnmarshalState *)(ctx->u_state);
     MARSH_EOS(st, ctx->data);
     return *(ctx->data++);
-};
+}
 
 void janet_unmarshal_bytes(JanetMarshalContext *ctx, uint8_t *dest, size_t len) {
     UnmarshalState *st = (UnmarshalState *)(ctx->u_state);

src/core/os.c

@@ -734,7 +734,7 @@ static const JanetReg os_cfuns[] = {
              "Returns a struct with following key values. Note that all numbers are 0-indexed.\n\n"
              "\t:seconds - number of seconds [0-61]\n"
              "\t:minutes - number of minutes [0-59]\n"
-             "\t:seconds - number of hours [0-23]\n"
+             "\t:hours - number of hours [0-23]\n"
              "\t:month-day - day of month [0-30]\n"
              "\t:month - month of year [0, 11]\n"
              "\t:year - years since year 0 (e.g. 2019)\n"

src/core/parse.c

@@ -257,12 +257,24 @@ static int escape1(JanetParser *p, JanetParseState *state, uint8_t c) {
 
 static int stringend(JanetParser *p, JanetParseState *state) {
     Janet ret;
+    uint8_t *bufstart = p->buf;
+    int32_t buflen = (int32_t) p->bufcount;
+    if (state->flags & PFLAG_LONGSTRING) {
+        /* Check for leading newline character so we can remove it */
+        if (bufstart[0] == '\n') {
+            bufstart++;
+            buflen--;
+        }
+        if (buflen > 0 && bufstart[buflen - 1] == '\n') {
+            buflen--;
+        }
+    }
     if (state->flags & PFLAG_BUFFER) {
-        JanetBuffer *b = janet_buffer((int32_t)p->bufcount);
-        janet_buffer_push_bytes(b, p->buf, (int32_t)p->bufcount);
+        JanetBuffer *b = janet_buffer(buflen);
+        janet_buffer_push_bytes(b, bufstart, buflen);
         ret = janet_wrap_buffer(b);
     } else {
-        ret = janet_wrap_string(janet_string(p->buf, (int32_t)p->bufcount));
+        ret = janet_wrap_string(janet_string(bufstart, buflen));
     }
     p->bufcount = 0;
     popstate(p, ret);
@@ -622,6 +634,10 @@ void janet_parser_deinit(JanetParser *parser) {
     free(parser->states);
 }
 
+int janet_parser_has_more(JanetParser *parser) {
+    return !!parser->pending;
+}
+
 /* C functions */
 
 static int parsermark(void *p, size_t size) {

src/core/pp.c

@@ -198,8 +198,15 @@ void janet_description_b(JanetBuffer *buffer, Janet x) {
             janet_escape_string_b(buffer, janet_unwrap_string(x));
             return;
         case JANET_BUFFER:
-            janet_escape_buffer_b(buffer, janet_unwrap_buffer(x));
-            return;
+            {
+                JanetBuffer *b = janet_unwrap_buffer(x);
+                if (b == buffer) {
+                    /* Ensures buffer won't resize while escaping */
+                    janet_buffer_ensure(b, 5 * b->count + 3, 1);
+                }
+                janet_escape_buffer_b(buffer, b);
+                return;
+            }
         case JANET_ABSTRACT: {
             void *p = janet_unwrap_abstract(x);
             const JanetAbstractType *at = janet_abstract_type(p);
@@ -298,6 +305,7 @@ struct pretty {
     int depth;
     int indent;
     int flags;
+    int32_t bufstartlen;
     JanetTable seen;
 };
 
@@ -314,23 +322,24 @@ static void print_newline(struct pretty *S, int just_a_space) {
 }
 
 /* Color coding for types */
+static const char janet_cycle_color[] = "\x1B[36m";
 static const char *janet_pretty_colors[] = {
     "\x1B[32m",
     "\x1B[36m",
     "\x1B[36m",
-    NULL,
+    "\x1B[36m",
     "\x1B[35m",
     "\x1B[34m",
     "\x1B[33m",
-    NULL,
-    NULL,
-    NULL,
-    NULL,
+    "\x1B[36m",
+    "\x1B[36m",
+    "\x1B[36m",
+    "\x1B[36m"
     "\x1B[35m",
-    NULL,
-    NULL,
-    NULL,
-    NULL
+    "\x1B[36m",
+    "\x1B[36m",
+    "\x1B[36m",
+    "\x1B[36m"
 };
 
 #define JANET_PRETTY_DICT_ONELINE 4
@@ -348,9 +357,15 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
         default: {
             Janet seenid = janet_table_get(&S->seen, x);
             if (janet_checktype(seenid, JANET_NUMBER)) {
+                if (S->flags & JANET_PRETTY_COLOR) {
+                    janet_buffer_push_cstring(S->buffer, janet_cycle_color);
+                }
                 janet_buffer_push_cstring(S->buffer, "<cycle ");
                 integer_to_string_b(S->buffer, janet_unwrap_integer(seenid));
                 janet_buffer_push_u8(S->buffer, '>');
+                if (S->flags & JANET_PRETTY_COLOR) {
+                    janet_buffer_push_cstring(S->buffer, "\x1B[0m");
+                }
                 return;
             } else {
                 janet_table_put(&S->seen, x, janet_wrap_integer(S->seen.count));
@@ -365,7 +380,13 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
             if (color && (S->flags & JANET_PRETTY_COLOR)) {
                 janet_buffer_push_cstring(S->buffer, color);
             }
-            janet_description_b(S->buffer, x);
+            if (janet_checktype(x, JANET_BUFFER) && janet_unwrap_buffer(x) == S->buffer) {
+                janet_buffer_ensure(S->buffer, S->buffer->count + S->bufstartlen * 4 + 3, 1);
+                janet_buffer_push_u8(S->buffer, '@');
+                janet_escape_string_impl(S->buffer, S->buffer->data, S->bufstartlen);
+            } else {
+                janet_description_b(S->buffer, x);
+            }
             if (color && (S->flags & JANET_PRETTY_COLOR)) {
                 janet_buffer_push_cstring(S->buffer, "\x1B[0m");
             }
@@ -454,9 +475,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
     return;
 }
 
-/* Helper for printing a janet value in a pretty form. Not meant to be used
- * for serialization or anything like that. */
-JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, int flags, Janet x) {
+static JanetBuffer *janet_pretty_(JanetBuffer *buffer, int depth, int flags, Janet x, int32_t startlen) {
     struct pretty S;
     if (NULL == buffer) {
         buffer = janet_buffer(0);
@@ -465,12 +484,19 @@ JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, int flags, Janet x) {
     S.depth = depth;
     S.indent = 0;
     S.flags = flags;
+    S.bufstartlen = startlen;
     janet_table_init(&S.seen, 10);
     janet_pretty_one(&S, x, 0);
     janet_table_deinit(&S.seen);
     return S.buffer;
 }
 
+/* Helper for printing a janet value in a pretty form. Not meant to be used
+ * for serialization or anything like that. */
+JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, int flags, Janet x) {
+    return janet_pretty_(buffer, depth, flags, x, buffer ? buffer->count : 0);
+}
+
 static const char *typestr(Janet x) {
     JanetType t = janet_type(x);
     return (t == JANET_ABSTRACT)
@@ -636,6 +662,7 @@ void janet_buffer_format(
     size_t sfl = strlen(strfrmt);
     const char *strfrmt_end = strfrmt + sfl;
     int32_t arg = argstart;
+    int32_t startlen = b->count;
     while (strfrmt < strfrmt_end) {
         if (*strfrmt != '%')
             janet_buffer_push_u8(b, (uint8_t) * strfrmt++);
@@ -704,7 +731,7 @@ void janet_buffer_format(
                     int depth = atoi(precision);
                     if (depth < 1)
                         depth = 4;
-                    janet_pretty(b, depth, (strfrmt[-1] == 'P') ? JANET_PRETTY_COLOR : 0, argv[arg]);
+                    janet_pretty_(b, depth, (strfrmt[-1] == 'P') ? JANET_PRETTY_COLOR : 0, argv[arg], startlen);
                     break;
                 }
                 default: {

src/core/regalloc.c

@@ -23,6 +23,7 @@
 #ifndef JANET_AMALG
 #include <janet.h>
 #include "regalloc.h"
+#include "util.h"
 #endif
 
 void janetc_regalloc_init(JanetcRegisterAllocator *ra) {

src/core/run.c

@@ -47,6 +47,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
             if (cres.status == JANET_COMPILE_OK) {
                 JanetFunction *f = janet_thunk(cres.funcdef);
                 JanetFiber *fiber = janet_fiber(f, 64, 0, NULL);
+                fiber->env = env;
                 JanetSignal status = janet_continue(fiber, janet_wrap_nil(), &ret);
                 if (status != JANET_SIGNAL_OK) {
                     janet_stacktrace(fiber, ret);

src/core/string.c

@@ -274,6 +274,26 @@ static Janet cfun_string_find(int32_t argc, Janet *argv) {
            : janet_wrap_integer(result);
 }
 
+static Janet cfun_string_hasprefix(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    JanetByteView prefix = janet_getbytes(argv, 0);
+    JanetByteView str = janet_getbytes(argv, 1);
+    return str.len < prefix.len
+           ? janet_wrap_false()
+           : janet_wrap_boolean(memcmp(prefix.bytes, str.bytes, prefix.len) == 0);
+}
+
+static Janet cfun_string_hassuffix(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    JanetByteView suffix = janet_getbytes(argv, 0);
+    JanetByteView str = janet_getbytes(argv, 1);
+    return str.len < suffix.len
+           ? janet_wrap_false()
+           : janet_wrap_boolean(memcmp(suffix.bytes,
+                       str.bytes + str.len - suffix.len,
+                       suffix.len) == 0);
+}
+
 static Janet cfun_string_findall(int32_t argc, Janet *argv) {
     int32_t result;
     struct kmp_state state;
@@ -507,6 +527,16 @@ static const JanetReg string_cfuns[] = {
              "will only contribute to finding at most on occurrence of pattern. If no "
              "occurrences are found, will return an empty array.")
     },
+    {
+        "string/has-prefix?", cfun_string_hasprefix,
+        JDOC("(string/has-prefix? pfx str)\n\n"
+             "Tests whether str starts with pfx.")
+    },
+    {
+        "string/has-suffix?", cfun_string_hassuffix,
+        JDOC("(string/has-suffix? sfx str)\n\n"
+             "Tests whether str ends with sfx.")
+    },
     {
         "string/replace", cfun_string_replace,
         JDOC("(string/replace patt subst str)\n\n"

src/core/strtod.c

@@ -45,6 +45,7 @@
 
 #ifndef JANET_AMALG
 #include <janet.h>
+#include "util.h"
 #endif
 
 /* Lookup table for getting values of characters when parsing numbers. Handles

src/core/util.h

@@ -27,6 +27,28 @@
 #include <janet.h>
 #endif
 
+/* Handle runtime errors */
+#ifndef janet_exit
+#include <stdio.h>
+#define janet_exit(m) do { \
+    printf("C runtime error at line %d in file %s: %s\n",\
+        __LINE__,\
+        __FILE__,\
+        (m));\
+    exit(1);\
+} while (0)
+#endif
+
+#define janet_assert(c, m) do { \
+    if (!(c)) janet_exit((m)); \
+} while (0)
+
+/* What to do when out of memory */
+#ifndef JANET_OUT_OF_MEMORY
+#include <stdio.h>
+#define JANET_OUT_OF_MEMORY do { printf("janet out of memory\n"); exit(1); } while (0)
+#endif
+
 /* Omit docstrings in some builds */
 #ifndef JANET_BOOTSTRAP
 #define JDOC(x) NULL

src/core/vector.c

@@ -22,6 +22,7 @@
 
 #ifndef JANET_AMALG
 #include "vector.h"
+#include "util.h"
 #endif
 
 /* Grow the buffer dynamically. Used for push operations. */

src/core/vm.c

@@ -224,6 +224,23 @@ static void *op_lookup[255] = {
 #define vm_bitop(op) _vm_bitop(op, int32_t)
 #define vm_bitopu(op) _vm_bitop(op, uint32_t)
 
+/* Trace a function call */
+static void vm_do_trace(JanetFunction *func) {
+    Janet *stack = janet_vm_fiber->data + janet_vm_fiber->stackstart;
+    int32_t start = janet_vm_fiber->stackstart;
+    int32_t end = janet_vm_fiber->stacktop;
+    int32_t argc = end - start;
+    if (func->def->name) {
+        janet_printf("trace (%S", func->def->name);
+    } else {
+        janet_printf("trace (%p", janet_wrap_function(func));
+    }
+    for (int32_t i = 0; i < argc; i++) {
+        janet_printf(" %p", stack[i]);
+    }
+    printf(")\n");
+}
+
 /* Call a non function type */
 static Janet call_nonfn(JanetFiber *fiber, Janet callee) {
     int32_t argn = fiber->stacktop - fiber->stackstart;
@@ -563,6 +580,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         }
         if (janet_checktype(callee, JANET_FUNCTION)) {
             func = janet_unwrap_function(callee);
+            if (func->gc.flags & JANET_FUNCFLAG_TRACE) vm_do_trace(func);
             janet_stack_frame(stack)->pc = pc;
             if (janet_fiber_funcframe(fiber, func)) {
                 int32_t n = fiber->stacktop - fiber->stackstart;
@@ -598,6 +616,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         }
         if (janet_checktype(callee, JANET_FUNCTION)) {
             func = janet_unwrap_function(callee);
+            if (func->gc.flags & JANET_FUNCFLAG_TRACE) vm_do_trace(func);
             if (janet_fiber_funcframe_tail(fiber, func)) {
                 janet_stack_frame(fiber->data + fiber->frame)->pc = pc;
                 int32_t n = fiber->stacktop - fiber->stackstart;

src/core/wrap.c

@@ -22,8 +22,141 @@
 
 #ifndef JANET_AMALG
 #include <janet.h>
+#include "util.h"
 #endif
 
+/* Macro fills */
+
+JanetType(janet_type)(Janet x) {
+    return janet_type(x);
+}
+int (janet_checktype)(Janet x, JanetType type) {
+    return janet_checktype(x, type);
+}
+int (janet_checktypes)(Janet x, int typeflags) {
+    return janet_checktypes(x, typeflags);
+}
+int (janet_truthy)(Janet x) {
+    return janet_truthy(x);
+}
+
+const JanetKV *(janet_unwrap_struct)(Janet x) {
+    return janet_unwrap_struct(x);
+}
+const Janet *(janet_unwrap_tuple)(Janet x) {
+    return janet_unwrap_tuple(x);
+}
+JanetFiber *(janet_unwrap_fiber)(Janet x) {
+    return janet_unwrap_fiber(x);
+}
+JanetArray *(janet_unwrap_array)(Janet x) {
+    return janet_unwrap_array(x);
+}
+JanetTable *(janet_unwrap_table)(Janet x) {
+    return janet_unwrap_table(x);
+}
+JanetBuffer *(janet_unwrap_buffer)(Janet x) {
+    return janet_unwrap_buffer(x);
+}
+const uint8_t *(janet_unwrap_string)(Janet x) {
+    return janet_unwrap_string(x);
+}
+const uint8_t *(janet_unwrap_symbol)(Janet x) {
+    return janet_unwrap_symbol(x);
+}
+const uint8_t *(janet_unwrap_keyword)(Janet x) {
+    return janet_unwrap_keyword(x);
+}
+void *(janet_unwrap_abstract)(Janet x) {
+    return janet_unwrap_abstract(x);
+}
+void *(janet_unwrap_pointer)(Janet x) {
+    return janet_unwrap_pointer(x);
+}
+JanetFunction *(janet_unwrap_function)(Janet x) {
+    return janet_unwrap_function(x);
+}
+JanetCFunction(janet_unwrap_cfunction)(Janet x) {
+    return janet_unwrap_cfunction(x);
+}
+int (janet_unwrap_boolean)(Janet x) {
+    return janet_unwrap_boolean(x);
+}
+int32_t (janet_unwrap_integer)(Janet x) {
+    return janet_unwrap_integer(x);
+}
+
+#if defined(JANET_NANBOX_32) || defined(JANET_NANBOX_64)
+Janet(janet_wrap_nil)(void) {
+    return janet_wrap_nil();
+}
+Janet(janet_wrap_true)(void) {
+    return janet_wrap_true();
+}
+Janet(janet_wrap_false)(void) {
+    return janet_wrap_false();
+}
+Janet(janet_wrap_boolean)(int x) {
+    return janet_wrap_boolean(x);
+}
+Janet(janet_wrap_string)(const uint8_t *x) {
+    return janet_wrap_string(x);
+}
+Janet(janet_wrap_symbol)(const uint8_t *x) {
+    return janet_wrap_symbol(x);
+}
+Janet(janet_wrap_keyword)(const uint8_t *x) {
+    return janet_wrap_keyword(x);
+}
+Janet(janet_wrap_array)(JanetArray *x) {
+    return janet_wrap_array(x);
+}
+Janet(janet_wrap_tuple)(const Janet *x) {
+    return janet_wrap_tuple(x);
+}
+Janet(janet_wrap_struct)(const JanetKV *x) {
+    return janet_wrap_struct(x);
+}
+Janet(janet_wrap_fiber)(JanetFiber *x) {
+    return janet_wrap_fiber(x);
+}
+Janet(janet_wrap_buffer)(JanetBuffer *x) {
+    return janet_wrap_buffer(x);
+}
+Janet(janet_wrap_function)(JanetFunction *x) {
+    return janet_wrap_function(x);
+}
+Janet(janet_wrap_cfunction)(JanetCFunction x) {
+    return janet_wrap_cfunction(x);
+}
+Janet(janet_wrap_table)(JanetTable *x) {
+    return janet_wrap_table(x);
+}
+Janet(janet_wrap_abstract)(void *x) {
+    return janet_wrap_abstract(x);
+}
+Janet(janet_wrap_pointer)(void *x) {
+    return janet_wrap_pointer(x);
+}
+Janet(janet_wrap_integer)(int32_t x) {
+    return janet_wrap_integer(x);
+}
+#endif
+
+#ifndef JANET_NANBOX_32
+double (janet_unwrap_number)(Janet x) {
+    return janet_unwrap_number(x);
+}
+#endif
+
+#ifdef JANET_NANBOX_64
+Janet(janet_wrap_number)(double x) {
+    return janet_wrap_number(x);
+}
+#endif
+
+/*****/
+
 void *janet_memalloc_empty(int32_t count) {
     int32_t i;
     void *mem = malloc(count * sizeof(JanetKV));
@@ -110,13 +243,7 @@ double janet_unwrap_number(Janet x) {
 
 #else
 
-/* Wrapper functions wrap a data type that is used from C into a
- * janet value, which can then be used in janet internal functions. Use
- * these functions sparingly, as these function will let the programmer
- * leak memory, where as the stack based API ensures that all values can
- * be collected by the garbage collector. */
-
-Janet janet_wrap_nil() {
+Janet janet_wrap_nil(void) {
     Janet y;
     y.type = JANET_NIL;
     y.as.u64 = 0;

src/include/janet.h

@@ -151,28 +151,6 @@ extern "C" {
 #endif
 #endif
 
-/* Handle runtime errors */
-#ifndef janet_exit
-#include <stdio.h>
-#define janet_exit(m) do { \
-    printf("C runtime error at line %d in file %s: %s\n",\
-        __LINE__,\
-        __FILE__,\
-        (m));\
-    exit(1);\
-} while (0)
-#endif
-
-#define janet_assert(c, m) do { \
-    if (!(c)) janet_exit((m)); \
-} while (0)
-
-/* What to do when out of memory */
-#ifndef JANET_OUT_OF_MEMORY
-#include <stdio.h>
-#define JANET_OUT_OF_MEMORY do { printf("janet out of memory\n"); exit(1); } while (0)
-#endif
-
 /* Prevent some recursive functions from recursing too deeply
  * ands crashing (the parser). Instead, error out. */
 #define JANET_RECURSION_GUARD 1024
@@ -197,7 +175,10 @@ extern "C" {
 #ifndef JANET_NO_NANBOX
 #ifdef JANET_32
 #define JANET_NANBOX_32
-#else
+#elif defined(__x86_64__) || defined(_WIN64)
+/* We will only enable nanboxing by default on 64 bit systems
+ * on x86. This is mainly because the approach is tied to the
+ * implicit 47 bit address space. */
 #define JANET_NANBOX_64
 #endif
 #endif
@@ -221,6 +202,7 @@ extern "C" {
 #include <stdarg.h>
 #include <setjmp.h>
 #include <stddef.h>
+#include <stdio.h>
 
 /* Names of all of the types */
 extern const char *const janet_type_names[16];
@@ -371,6 +353,63 @@ typedef enum JanetType {
  * janet_u64(x) - get 64 bits of payload for hashing
  */
 
+/***** START SECTION NON-C API *****/
+
+/* Some janet types use offset tricks to make operations easier in C. For
+ * external bindings, we should prefer using the Head structs directly, and
+ * use the host language to add sugar around the manipulation of the Janet types. */
+
+JANET_API JanetStructHead *janet_struct_head(const JanetKV *st);
+JANET_API JanetAbstractHead *janet_abstract_head(const void *abstract);
+JANET_API JanetStringHead *janet_string_head(const uint8_t *s);
+JANET_API JanetTupleHead *janet_tuple_head(const Janet *tuple);
+
+/* Some language bindings won't have access to the macro versions. */
+
+JANET_API JanetType janet_type(Janet x);
+JANET_API int janet_checktype(Janet x, JanetType type);
+JANET_API int janet_checktypes(Janet x, int typeflags);
+JANET_API int janet_truthy(Janet x);
+
+JANET_API const JanetKV *janet_unwrap_struct(Janet x);
+JANET_API const Janet *janet_unwrap_tuple(Janet x);
+JANET_API JanetFiber *janet_unwrap_fiber(Janet x);
+JANET_API JanetArray *janet_unwrap_array(Janet x);
+JANET_API JanetTable *janet_unwrap_table(Janet x);
+JANET_API JanetBuffer *janet_unwrap_buffer(Janet x);
+JANET_API const uint8_t *janet_unwrap_string(Janet x);
+JANET_API const uint8_t *janet_unwrap_symbol(Janet x);
+JANET_API const uint8_t *janet_unwrap_keyword(Janet x);
+JANET_API void *janet_unwrap_abstract(Janet x);
+JANET_API void *janet_unwrap_pointer(Janet x);
+JANET_API JanetFunction *janet_unwrap_function(Janet x);
+JANET_API JanetCFunction janet_unwrap_cfunction(Janet x);
+JANET_API int janet_unwrap_boolean(Janet x);
+JANET_API double janet_unwrap_number(Janet x);
+JANET_API int32_t janet_unwrap_integer(Janet x);
+
+JANET_API Janet janet_wrap_nil(void);
+JANET_API Janet janet_wrap_number(double x);
+JANET_API Janet janet_wrap_true(void);
+JANET_API Janet janet_wrap_false(void);
+JANET_API Janet janet_wrap_boolean(int x);
+JANET_API Janet janet_wrap_string(const uint8_t *x);
+JANET_API Janet janet_wrap_symbol(const uint8_t *x);
+JANET_API Janet janet_wrap_keyword(const uint8_t *x);
+JANET_API Janet janet_wrap_array(JanetArray *x);
+JANET_API Janet janet_wrap_tuple(const Janet *x);
+JANET_API Janet janet_wrap_struct(const JanetKV *x);
+JANET_API Janet janet_wrap_fiber(JanetFiber *x);
+JANET_API Janet janet_wrap_buffer(JanetBuffer *x);
+JANET_API Janet janet_wrap_function(JanetFunction *x);
+JANET_API Janet janet_wrap_cfunction(JanetCFunction x);
+JANET_API Janet janet_wrap_table(JanetTable *x);
+JANET_API Janet janet_wrap_abstract(void *x);
+JANET_API Janet janet_wrap_pointer(void *x);
+JANET_API Janet janet_wrap_integer(int32_t x);
+
+/***** END SECTION NON-C API *****/
+
 #ifdef JANET_NANBOX_64
 
 #include <math.h>
@@ -497,7 +536,6 @@ union Janet {
 #define janet_truthy(x) \
     ((x).tagged.type != JANET_NIL && ((x).tagged.type != JANET_BOOLEAN || ((x).tagged.payload.integer & 0x1)))
 
-JANET_API Janet janet_wrap_number(double x);
 JANET_API Janet janet_nanbox32_from_tagi(uint32_t tag, int32_t integer);
 JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 
@@ -535,7 +573,6 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 #define janet_unwrap_function(x) ((JanetFunction *)(x).tagged.payload.pointer)
 #define janet_unwrap_cfunction(x) ((JanetCFunction)(x).tagged.payload.pointer)
 #define janet_unwrap_boolean(x) ((x).tagged.payload.integer)
-JANET_API double janet_unwrap_number(Janet x);
 
 #else
 
@@ -573,25 +610,6 @@ struct Janet {
 #define janet_unwrap_boolean(x) ((x).as.u64 & 0x1)
 #define janet_unwrap_number(x) ((x).as.number)
 
-JANET_API Janet janet_wrap_nil(void);
-JANET_API Janet janet_wrap_number(double x);
-JANET_API Janet janet_wrap_true(void);
-JANET_API Janet janet_wrap_false(void);
-JANET_API Janet janet_wrap_boolean(int x);
-JANET_API Janet janet_wrap_string(const uint8_t *x);
-JANET_API Janet janet_wrap_symbol(const uint8_t *x);
-JANET_API Janet janet_wrap_keyword(const uint8_t *x);
-JANET_API Janet janet_wrap_array(JanetArray *x);
-JANET_API Janet janet_wrap_tuple(const Janet *x);
-JANET_API Janet janet_wrap_struct(const JanetKV *x);
-JANET_API Janet janet_wrap_fiber(JanetFiber *x);
-JANET_API Janet janet_wrap_buffer(JanetBuffer *x);
-JANET_API Janet janet_wrap_function(JanetFunction *x);
-JANET_API Janet janet_wrap_cfunction(JanetCFunction x);
-JANET_API Janet janet_wrap_table(JanetTable *x);
-JANET_API Janet janet_wrap_abstract(void *x);
-JANET_API Janet janet_wrap_pointer(void *x);
-
 /* End of tagged union implementation */
 #endif
 
@@ -645,6 +663,7 @@ struct JanetFiber {
     int32_t stacktop; /* Top of stack. Where values are pushed and popped from. */
     int32_t capacity;
     int32_t maxstack; /* Arbitrary defined limit for stack overflow */
+    JanetTable *env; /* Dynamic bindings table (usually current environment). */
     Janet *data;
     JanetFiber *child; /* Keep linked list of fibers for restarting pending fibers */
 };
@@ -786,6 +805,8 @@ struct JanetFuncEnv {
         environment is no longer on the stack. */
 };
 
+#define JANET_FUNCFLAG_TRACE (1 << 16)
+
 /* A function */
 struct JanetFunction {
     JanetGCObject gc;
@@ -995,7 +1016,7 @@ JANET_API Janet janet_parser_produce(JanetParser *parser);
 JANET_API const char *janet_parser_error(JanetParser *parser);
 JANET_API void janet_parser_flush(JanetParser *parser);
 JANET_API void janet_parser_eof(JanetParser *parser);
-#define janet_parser_has_more(P) ((P)->pending)
+JANET_API int janet_parser_has_more(JanetParser *parser);
 
 /* Assembly */
 #ifdef JANET_ASSEMBLER
@@ -1152,7 +1173,8 @@ JANET_API JanetKV *janet_table_find(JanetTable *t, Janet key);
 /* Fiber */
 JANET_API JanetFiber *janet_fiber(JanetFunction *callee, int32_t capacity, int32_t argc, const Janet *argv);
 JANET_API JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t argc, const Janet *argv);
-#define janet_fiber_status(f) (((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET)
+JANET_API JanetFiberStatus janet_fiber_status(JanetFiber *fiber);
+JANET_API JanetFiber *janet_current_fiber(void);
 
 /* Treat similar types through uniform interfaces for iteration */
 JANET_API int janet_indexed_view(Janet seq, const Janet **data, int32_t *len);
@@ -1162,9 +1184,9 @@ JANET_API Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key
 JANET_API const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv);
 
 /* Abstract */
-#define janet_abstract_header(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data)))
-#define janet_abstract_type(u) (janet_abstract_header(u)->type)
-#define janet_abstract_size(u) (janet_abstract_header(u)->size)
+#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data)))
+#define janet_abstract_type(u) (janet_abstract_head(u)->type)
+#define janet_abstract_size(u) (janet_abstract_head(u)->size)
 JANET_API void *janet_abstract(const JanetAbstractType *type, size_t size);
 
 /* Native */
@@ -1243,8 +1265,8 @@ JANET_API void janet_register(const char *name, JanetCFunction cfun);
 JANET_API void janet_panicv(Janet message);
 JANET_API void janet_panic(const char *message);
 JANET_API void janet_panics(const uint8_t *message);
-#define janet_panicf(...) janet_panics(janet_formatc(__VA_ARGS__))
-#define janet_printf(...) fputs((const char *)janet_formatc(__VA_ARGS__), stdout)
+JANET_API void janet_panicf(const char *format, ...);
+JANET_API void janet_printf(const char *format, ...);
 JANET_API void janet_panic_type(Janet x, int32_t n, int expected);
 JANET_API void janet_panic_abstract(Janet x, int32_t n, const JanetAbstractType *at);
 JANET_API void janet_arity(int32_t arity, int32_t min, int32_t max);
@@ -1278,17 +1300,21 @@ JANET_API JanetRange janet_getslice(int32_t argc, const Janet *argv);
 JANET_API int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which);
 JANET_API int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which);
 
+JANET_API Janet janet_dyn(const char *name);
+JANET_API void janet_setdyn(const char *name, Janet value);
+
 JANET_API FILE *janet_getfile(const Janet *argv, int32_t n, int *flags);
+JANET_API FILE *janet_dynfile(const char *name, FILE *def);
 
 /* Marshal API */
-#define janet_marshal_size(ctx, x) janet_marshal_int64((ctx), (int64_t) (x))
+JANET_API void janet_marshal_size(JanetMarshalContext *ctx, size_t value);
 JANET_API void janet_marshal_int(JanetMarshalContext *ctx, int32_t value);
 JANET_API void janet_marshal_int64(JanetMarshalContext *ctx, int64_t value);
 JANET_API void janet_marshal_byte(JanetMarshalContext *ctx, uint8_t value);
 JANET_API void janet_marshal_bytes(JanetMarshalContext *ctx, const uint8_t *bytes, size_t len);
 JANET_API void janet_marshal_janet(JanetMarshalContext *ctx, Janet x);
 
-#define janet_unmarshal_size(ctx) ((size_t) janet_unmarshal_int64((ctx)))
+JANET_API size_t janet_unmarshal_size(JanetMarshalContext *ctx);
 JANET_API int32_t janet_unmarshal_int(JanetMarshalContext *ctx);
 JANET_API int64_t janet_unmarshal_int64(JanetMarshalContext *ctx);
 JANET_API uint8_t janet_unmarshal_byte(JanetMarshalContext *ctx);

src/include/janetconf.h

@@ -25,7 +25,7 @@
 #ifndef JANETCONF_H
 #define JANETCONF_H
 
-#define JANET_VERSION "0.4.1"
+#define JANET_VERSION "0.5.0"
 
 /* #define JANET_BUILD "local" */
 /* #define JANET_SINGLE_THREADED */

src/mainclient/init.janet

@@ -46,7 +46,7 @@
            3)
      "-" (fn [&] (set *handleopts* false) 1)
      "l" (fn [i &]
-           (import* *env* (get process/args (+ i 1))
+           (import* (get process/args (+ i 1))
                     :prefix "" :exit *exit-on-error*)
            2)
      "e" (fn [i &]
@@ -67,7 +67,7 @@
       (+= i (dohandler (string/slice arg 1 2) i))
       (do
         (set *no-file* false)
-        (import* *env* arg :prefix "" :exit *exit-on-error*)
+        (import* arg :prefix "" :exit *exit-on-error*)
         (set i lenargs))))
 
   (when (or *should-repl* *no-file*)
@@ -86,4 +86,5 @@
     (defn getchunk [buf p]
       (getter (prompter p) buf))
     (def onsig (if *quiet* (fn [x &] x) nil))
-    (repl getchunk onsig (if *colorize* "%.20P" "%.20p"))))
+    (setdyn :pretty-format (if *colorize* "%.20P" "%.20p"))
+    (repl getchunk onsig)))

src/mainclient/line.c

@@ -94,6 +94,7 @@ static int cols = 80;
 static char *history[JANET_HISTORY_MAX];
 static int history_count = 0;
 static int historyi = 0;
+static int sigint_flag = 0;
 static struct termios termios_start;
 
 /* Unsupported terminal list from linenoise */
@@ -333,6 +334,7 @@ static int line() {
                 return 0;
             case 3:     /* ctrl-c */
                 errno = EAGAIN;
+                sigint_flag = 1;
                 return -1;
             case 127:   /* backspace */
             case 8:     /* ctrl-h */
@@ -458,7 +460,11 @@ void janet_line_get(const char *p, JanetBuffer *buffer) {
     }
     if (line()) {
         norawmode();
-        fputc('\n', stdout);
+        if (sigint_flag) {
+            raise(SIGINT);
+        } else {
+            fputc('\n', stdout);
+        }
         return;
     }
     norawmode();

src/webclient/webinit.janet

@@ -3,9 +3,10 @@
 (print (string "Janet " janet/version "-" janet/build "  Copyright (C) 2017-2019 Calvin Rose"))
 
 (fiber/new (fn webrepl []
-  (repl (fn get-line [buf p]
-          (def offset (parser/where p))
-          (def prompt (string "janet:" offset ":" (parser/state p) "> "))
-          (repl-yield prompt buf)
-          (yield)
-          buf))))
+             (setdyn :pretty-format "%.20P")
+             (repl (fn get-line [buf p]
+                     (def offset (parser/where p))
+                     (def prompt (string "janet:" offset ":" (parser/state p) "> "))
+                     (repl-yield prompt buf)
+                     (yield)
+                     buf))))

test/suite1.janet

@@ -140,7 +140,7 @@
 
 # Marshal
 
-(def um-lookup (env-lookup *env*))
+(def um-lookup (env-lookup (fiber/getenv (fiber/current))))
 (def m-lookup (invert um-lookup))
 
 (defn testmarsh [x msg]
@@ -182,7 +182,7 @@
 # Large functions
 (def manydefs (seq [i :range [0 300]] (tuple 'def (gensym) (string "value_" i))))
 (array/push manydefs (tuple * 10000 3 5 7 9))
-(def f (compile ['do ;manydefs] *env*))
+(def f (compile ['do ;manydefs] (fiber/getenv (fiber/current))))
 (assert (= (f) (* 10000 3 5 7 9)) "long function compilation")
 
 # Some higher order functions and macros

test/suite2.janet

@@ -64,6 +64,12 @@
 (assert (= 3 (string/find "abc" "   abcdefghijklmnop")) "string/find 1")
 (assert (= nil (string/find "" "")) "string/find 2")
 (assert (= 0 (string/find "A" "A")) "string/find 3")
+(assert (string/has-prefix? "" "foo") "string/has-prefix? 1")
+(assert (string/has-prefix? "fo" "foo") "string/has-prefix? 2")
+(assert (not (string/has-prefix? "o" "foo")) "string/has-prefix? 3")
+(assert (string/has-suffix? "" "foo") "string/has-suffix? 1")
+(assert (string/has-suffix? "oo" "foo") "string/has-suffix? 2")
+(assert (not (string/has-suffix? "f" "foo")) "string/has-suffix? 3")
 (assert (= (string/replace "X" "." "XXX...XXX...XXX")  ".XX...XXX...XXX") "string/replace 1")
 (assert (= (string/replace-all "X" "." "XXX...XXX...XXX") "...............") "string/replace-all 1")
 (assert (= (string/replace-all "XX" "." "XXX...XXX...XXX") ".X....X....X") "string/replace-all 2")

test/suite3.janet

@@ -159,6 +159,14 @@
 (buffer/blit b2 "abcdefg" 5 6)
 (assert (= (string b2) "joytogjoyto") "buffer/blit 3")
 
+# Buffer self blitting, check for use after free
+(def buf1 @"1234567890")
+(buffer/blit buf1 buf1 -1)
+(buffer/blit buf1 buf1 -1)
+(buffer/blit buf1 buf1 -1)
+(buffer/blit buf1 buf1 -1)
+(assert (= (string buf1) (string/repeat "1234567890" 16)) "buffer blit against self")
+
 # Buffer push word
 
 (def b3 @"")
@@ -170,6 +178,22 @@
 (assert (= 8 (length b3)) "buffer/push-word 3")
 (assert (= "\xFF\xFF\xFF\xFF\0\x11\0\0" (string b3)) "buffer/push-word 4")
 
+# Buffer push string
+
+(def b4 (buffer/new-filled 10 0))
+(buffer/push-string b4 b4)
+(assert (= "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" (string b4)) "buffer/push-buffer 1")
+(def b5 @"123")
+(buffer/push-string b5 "456" @"789")
+(assert (= "123456789" (string b5)) "buffer/push-buffer 2")
+
+# Check for bugs with printing self with buffer/format
+
+(def buftemp @"abcd")
+(assert (= (string (buffer/format buftemp "---%p---" buftemp)) `abcd---@"abcd"---`) "buffer/format on self 1")
+(def buftemp @"abcd")
+(assert (= (string (buffer/format buftemp "---%p %p---" buftemp buftemp)) `abcd---@"abcd" @"abcd"---`) "buffer/format on self 2")
+
 # Peg
 
 (defn check-match

test/suite6.janet

@@ -88,4 +88,12 @@
            ))
         "int64 typed arrays")
 
+# Dynamic bindings
+(setdyn :a 10)
+(assert (= 40 (with-dyns [:a 25 :b 15] (+ (dyn :a) (dyn :b)))) "dyn usage 1")
+(assert (= 10 (dyn :a)) "dyn usage 2")
+(assert (= nil (dyn :b)) "dyn usage 3")
+(setdyn :a 100)
+(assert (= 100 (dyn :a)) "dyn usage 4")
+
 (end-suite)

tools/bars.janet

@@ -49,7 +49,7 @@
   # Make ast from forms
   (def ast ~(fn [&opt params] (default params @{}) (,buffer ,;forms)))
 
-  (def ctor (compile ast *env* source))
+  (def ctor (compile ast (fiber/getenv (fiber/current)) source))
   (if-not (function? ctor)
     (error (string "could not compile template")))
   (ctor))

tools/cook.janet

@@ -17,7 +17,7 @@
   (print cmd)
   (def res (os/shell cmd))
   (unless (zero? res)
-    (error "command exited with status " res)))
+    (error (string "command exited with status " res))))
 
 (defn- rm
   "Remove a directory and all sub directories."
@@ -177,10 +177,14 @@
 
 (defn make-archive
   "Build a janet archive. This is a file that bundles together many janet
-  scripts into a janet form. This file can the be moved to any machine with
+  scripts into a janet image. This file can the be moved to any machine with
   a janet vm and the required dependencies and run there."
   [& opts]
-  (error "Not Yet Implemented."))
+  (def opt-table (table ;opts))
+  (os/mkdir "build")
+  (def entry (opt-table :entry))
+  (def name (opt-table :name))
+  (spit (string name ".jimage") (make-image (require entry))))
 
 (defn make-binary
   "Make a binary executable that can be run on the current platform. This function

tools/gendoc.janet

@@ -103,7 +103,7 @@
 
 # Generate parts and print them to stdout
 (def parts (seq [[k entry]
-                 :in (sort (pairs (table/getproto *env*)))
+                 :in (sort (pairs (table/getproto (fiber/getenv (fiber/current)))))
                  :when (and (get entry :doc) (not (get entry :private)))]
                 (emit-item k entry)))
 (print