Fix docstring.

stop doc-format detecting other modes within code blocks

.builds/openbsd.yml

@@ -13,7 +13,7 @@ tasks:
     gmake test-install
 - meson_min: |
     cd janet
-    meson setup build_meson_min --buildtype=release -Dsingle_threaded=true -Dnanbox=false -Ddynamic_modules=false -Ddocstrings=false -Dnet=false -Dsourcemaps=false -Dpeg=false -Dassembler=false -Dint_types=false -Dtyped_array=false -Dreduced_os=true -Dffi=false
+    meson setup build_meson_min --buildtype=release -Dsingle_threaded=true -Dnanbox=false -Ddynamic_modules=false -Ddocstrings=false -Dnet=false -Dsourcemaps=false -Dpeg=false -Dassembler=false -Dint_types=false -Dreduced_os=true -Dffi=false
     cd build_meson_min
     ninja
 - meson_prf: |

.gitattributes

@@ -1,3 +1,4 @@
+*.janet linguist-language=Janet
 *.janet text eol=lf
 *.c text eol=lf
 *.h text eol=lf

CHANGELOG.md

@@ -1,8 +1,18 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
-## Unreleased - ???
-- Add experimental `ffi/` module for interfacing with dynamic libraries and raw function pointers.
+## 1.23.1 - ???
+- Don't process shared object names passed to dlopen.
+- Add better support for windows console in the default shell.c for autocompletion and
+  other shell-like input features.
+- Improve default error message from `assert`.
+- Add the `tabseq` macro for simpler table comprehensions.
+- Allow setting `(dyn :task-id)` in fibers to improve context in supervisor messages. Prior to
+  this change, supverisor messages over threaded channels would be from ambiguous threads/fibers.
+
+## 1.23.0 - 2022-06-20
+- Add experimental `ffi/` module for interfacing with dynamic libraries and raw function pointers. Only available
+  on 64 bit linux, mac, and bsd systems.
 - Allow using `&named` in function prototypes for named arguments. This is a more ergonomic
   variant of `&keys` that isn't as redundant, more self documenting, and allows extension to
   things like default arguments.

CONTRIBUTING.md

@@ -43,7 +43,7 @@ For changes to the VM and Core code, you will probably need to know C. Janet is
 a subset of C99 that works with Microsoft Visual C++. This means most of C99 but with the following
 omissions.
 
-* No `restrict` 
+* No `restrict`
 * Certain functions in the standard library are not always available
 
 In practice, this means programming for both MSVC on one hand and everything else on the other.
@@ -64,6 +64,23 @@ ensure a consistent code style for C.
 All janet code in the project should be formatted similar to the code in core.janet.
 The auto formatting from janet.vim will work well.
 
+## Typo Fixing and One-Line changes
+
+Typo fixes are welcome, as are simple one line fixes. Do not open many separate pull requests for each
+individual typo fix. This is incredibly annoying to deal with as someone needs to review each PR, run
+CI, and merge. Instead, accumulate batches of typo fixes into a single PR. If there are objections to
+specific changes, these can be addressed in the review process before the final merge, if the changes
+are accepted.
+
+Similarly, low effort and bad faith changes are annoying to developers and such issues may be closed
+immediately without response.
+
+## Contributions from Automated Tools
+
+People making changes found or generated by automated tools MUST note this when opening an issue
+or creating a pull request. This can help give context to developers if the change/issue is
+confusing or nonsensical.
+
 ## Suggesting Changes
 
 To suggest changes, open an issue on GitHub. Check GitHub for other issues

Makefile

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Calvin Rose
+# Copyright (c) 2022 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -168,9 +168,9 @@ build/c/janet.c: build/janet_boot src/boot/boot.janet
 ########################
 
 ifeq ($(UNAME), Darwin)
-SONAME=libjanet.1.22.dylib
+SONAME=libjanet.1.23.dylib
 else
-SONAME=libjanet.so.1.22
+SONAME=libjanet.so.1.23
 endif
 
 build/c/shell.c: src/mainclient/shell.c
@@ -283,7 +283,7 @@ install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc
 	cp $(JANET_TARGET) '$(DESTDIR)$(BINDIR)/janet'
 	mkdir -p '$(DESTDIR)$(INCLUDEDIR)/janet'
 	cp -r build/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet'
-	ln -sf '$(DESTDIR)$(INCLUDEDIR)/janet/janet.h' '$(DESTDIR)$(INCLUDEDIR)/janet.h'
+	ln -sf -T ./janet/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet.h' || true #fixme bsd
 	mkdir -p '$(DESTDIR)$(JANET_PATH)'
 	mkdir -p '$(DESTDIR)$(LIBDIR)'
 	if test $(UNAME) = Darwin ; then \
@@ -300,7 +300,7 @@ install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc
 	cp janet.1 '$(DESTDIR)$(JANET_MANPATH)'
 	mkdir -p '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)'
 	cp build/janet.pc '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)/janet.pc'
-	[ -z '$(DESTDIR)' ] && $(LDCONFIG) || true
+	[ -z '$(DESTDIR)' ] && $(LDCONFIG) || echo "You can ignore this error for non-Linux systems or local installs"
 
 install-jpm-git: $(JANET_TARGET)
 	mkdir -p build

examples/ffi/gtk.janet

@@ -7,7 +7,7 @@
 (ffi/defbind
   gtk-application-new :ptr
   "Add docstrings as needed."
-  [a :ptr b :uint])
+  [title :string flags :uint])
 
 (ffi/defbind
   g-signal-connect-data :ulong
@@ -15,7 +15,7 @@
 
 (ffi/defbind
   g-application-run :int
-  [a :ptr b :int c :ptr])
+  [app :ptr argc :int argv :ptr])
 
 (ffi/defbind
   gtk-application-window-new :ptr
@@ -39,6 +39,18 @@
 
 (def cb (delay (ffi/trampoline :default)))
 
+(defn ffi/array
+  ``Convert a janet array to a buffer that can be passed to FFI functions.
+  For example, to create an array of type `char *` (array of c strings), one
+  could use `(ffi/array ["hello" "world"] :ptr)`. One needs to be careful that
+  array elements are not garbage collected though - the GC can't follow references
+  inside an arbitrary byte buffer.``
+  [arr ctype &opt buf]
+  (default buf @"")
+  (each el arr
+    (ffi/write ctype el buf))
+  buf)
+
 (defn on-active
   [app]
   (def window (gtk-application-window-new app))
@@ -53,4 +65,7 @@
   [&]
   (def app (gtk-application-new "org.janet-lang.example.HelloApp" 0))
   (g-signal-connect-data app "activate" (cb) on-active nil 1)
-  (g-application-run app 0 nil))
+  # manually build an array with ffi/write
+  # - we are responsible for preventing gc when the arg array is used
+  (def argv (ffi/array (dyn *args*) :string))
+  (g-application-run app (length (dyn *args*)) argv))

examples/ffi/test.janet

@@ -1,5 +1,9 @@
-(def ffi/loc "ffitest/so.so")
-(def ffi/source-loc "ffitest/so.c")
+#
+# Simple FFI test script that tests against a simple shared object
+#
+
+(def ffi/loc "examples/ffi/so.so")
+(def ffi/source-loc "examples/ffi/so.c")
 
 (os/execute ["cc" ffi/source-loc "-shared" "-o" ffi/loc] :px)
 (def module (ffi/native ffi/loc))

meson.build

@@ -20,7 +20,7 @@
 
 project('janet', 'c',
   default_options : ['c_std=c99', 'build.c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.22.1')
+  version : '1.23.1')
 
 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')

src/boot/boot.janet

@@ -1,5 +1,5 @@
 # The core janet library
-# Copyright 2021 © Calvin Rose
+# Copyright 2022 © Calvin Rose
 
 ###
 ###
@@ -76,6 +76,11 @@
   [name & more]
   ~(var ,name :private ,;more))
 
+(defmacro toggle
+  "Set a value to its boolean inverse. Same as `(set value (not value))`."
+  [value]
+  ~(set ,value (,not ,value)))
+
 (defn defglobal
   "Dynamically create a global def."
   [name value]
@@ -158,7 +163,7 @@
      (def ,v ,x)
      (if ,v
        ,v
-       (,error ,(if err err "assert failure")))))
+       (,error ,(if err err (string/format "assert failure in %j" x))))))
 
 (defn errorf
   "A combination of `error` and `string/format`. Equivalent to `(error (string/format fmt ;args))`."
@@ -606,13 +611,20 @@
   See `loop` for details.``
   [head & body]
   (def $accum (gensym))
-  ~(do (def ,$accum @[]) (loop ,head (array/push ,$accum (do ,;body))) ,$accum))
+  ~(do (def ,$accum @[]) (loop ,head (,array/push ,$accum (do ,;body))) ,$accum))
+
+(defmacro tabseq
+  ``Similar to `loop`, but accumulates key value pairs into a table.
+  See `loop` for details.``
+  [head key-body & value-body]
+  (def $accum (gensym))
+  ~(do (def ,$accum @{}) (loop ,head (,put ,$accum ,key-body (do ,;value-body))) ,$accum))
 
 (defmacro generate
   ``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)))) :yi))
+  ~(,fiber/new (fn [] (loop ,head (yield (do ,;body)))) :yi))
 
 (defmacro coro
   "A wrapper for making fibers that may yield multiple values (coroutine). Same as `(fiber/new (fn [] ;body) :yi)`."
@@ -2768,13 +2780,13 @@
     (def c ((:where p) 0))
     (def prpt (string "debug[" level "]:" c ":" status "> "))
     (getline prpt buf nextenv))
-  (print "entering debug[" level "] - (quit) to exit")
+  (eprint "entering debug[" level "] - (quit) to exit")
   (flush)
   (run-context
     {:chunks debugger-chunks
      :on-status (debugger-on-status-var nextenv (+ 1 level) true)
      :env nextenv})
-  (print "exiting debug[" level "]")
+  (eprint "exiting debug[" level "]")
   (flush)
   (nextenv :resume-value))
 
@@ -3013,7 +3025,7 @@
        :italics ["*" "*"]
        :bold ["**" "**"]}))
   (def modes @{})
-  (defn toggle [mode]
+  (defn toggle-mode [mode]
     (def active (get modes mode))
     (def delims (get delimiters mode))
     (put modes mode (not active))
@@ -3123,7 +3135,7 @@
     (def token @"")
     (var token-length 0)
     (defn delim [mode]
-      (def d (toggle mode))
+      (def d (toggle-mode mode))
       (if-not has-color (+= token-length (length d)))
       (buffer/push token d))
     (defn endtoken []
@@ -3134,16 +3146,18 @@
       (def b (get line i))
       (cond
         (or (= b (chr "\n")) (= b (chr " "))) (endtoken)
-        (= b (chr `\`)) (do
-                          (++ token-length)
-                          (buffer/push token (get line (++ i))))
-        (= b (chr "_")) (delim :underline)
         (= b (chr "`")) (delim :code)
-        (= b (chr "*"))
-        (if (= (chr "*") (get line (+ i 1)))
-          (do (++ i)
-            (delim :bold))
-          (delim :italics))
+        (not (modes :code)) (cond
+          (= b (chr `\`)) (do
+                            (++ token-length)
+                            (buffer/push token (get line (++ i))))
+          (= b (chr "_")) (delim :underline)
+          (= b (chr "*"))
+            (if (= (chr "*") (get line (+ i 1)))
+              (do (++ i)
+                (delim :bold))
+              (delim :italics))
+          (do (++ token-length) (buffer/push token b)))
         (do (++ token-length) (buffer/push token b))))
     (endtoken)
     (tuple/slice tokens))
@@ -3413,26 +3427,26 @@
     (def pc (frame :pc))
     (def sourcemap (in dasm :sourcemap))
     (var last-loc [-2 -2])
-    (print "\n  signal:     " (.signal))
-    (print "  status:     " (fiber/status (.fiber)))
-    (print "  function:   " (dasm :name) " [" (in dasm :source "") "]")
+    (eprint "\n  signal:     " (.signal))
+    (eprint "  status:     " (fiber/status (.fiber)))
+    (eprint "  function:   " (get dasm :name "<anonymous>") " [" (in dasm :source "") "]")
     (when-let [constants (dasm :constants)]
-      (printf "  constants:  %.4q" constants))
-    (printf "  slots:      %.4q\n" (frame :slots))
+      (eprintf "  constants:  %.4q" constants))
+    (eprintf "  slots:      %.4q\n" (frame :slots))
     (def padding (string/repeat " " 20))
     (loop [i :range [0 (length bytecode)]
            :let [instr (bytecode i)]]
-      (prin (if (= (tuple/type instr) :brackets) "*" " "))
-      (prin (if (= i pc) "> " "  "))
-      (prinf "%.20s" (string (string/join (map string instr) " ") padding))
+      (eprin (if (= (tuple/type instr) :brackets) "*" " "))
+      (eprin (if (= i pc) "> " "  "))
+      (eprinf "%.20s" (string (string/join (map string instr) " ") padding))
       (when sourcemap
         (let [[sl sc] (sourcemap i)
               loc [sl sc]]
           (when (not= loc last-loc)
             (set last-loc loc)
-            (prin " # line " sl ", column " sc))))
-      (print))
-    (print))
+            (eprin " # line " sl ", column " sc))))
+      (eprint))
+    (eprint))
 
   (defn .breakall
     "Set breakpoints on all instructions in the current function."
@@ -3441,7 +3455,7 @@
     (def bytecode (.bytecode n))
     (forv i 0 (length bytecode)
       (debug/fbreak fun i))
-    (print "Set " (length bytecode) " breakpoints in " fun))
+    (eprint "set " (length bytecode) " breakpoints in " fun))
 
   (defn .clearall
     "Clear all breakpoints on the current function."
@@ -3450,7 +3464,7 @@
     (def bytecode (.bytecode n))
     (forv i 0 (length bytecode)
       (debug/unfbreak fun i))
-    (print "Cleared " (length bytecode) " breakpoints in " fun)))
+    (eprint "cleared " (length bytecode) " breakpoints in " fun)))
 
 (defn .source
   "Show the source code for the function being debugged."
@@ -3458,7 +3472,7 @@
   (def frame (.frame n))
   (def s (frame :source))
   (def all-source (slurp s))
-  (print "\n" all-source "\n"))
+  (eprint "\n" all-source "\n"))
 
 (defn .break
   "Set breakpoint at the current pc."
@@ -3467,7 +3481,7 @@
   (def fun (frame :function))
   (def pc (frame :pc))
   (debug/fbreak fun pc)
-  (print "Set breakpoint in " fun " at pc=" pc))
+  (eprint "set breakpoint in " fun " at pc=" pc))
 
 (defn .clear
   "Clear the current breakpoint."
@@ -3476,7 +3490,7 @@
   (def fun (frame :function))
   (def pc (frame :pc))
   (debug/unfbreak fun pc)
-  (print "Cleared breakpoint in " fun " at pc=" pc))
+  (eprint "cleared breakpoint in " fun " at pc=" pc))
 
 (defn .next
   "Go to the next breakpoint."
@@ -3643,7 +3657,7 @@
   (defn ffi/context
     "Set the path of the dynamic library to implictly bind, as well
      as other global state for ease of creating native bindings."
-    [native-path &named map-symbols lazy]
+    [&opt native-path &named map-symbols lazy]
     (default map-symbols default-mangle)
     (def lib (if lazy nil (ffi/native native-path)))
     (def lazy-lib (if lazy (delay (ffi/native native-path))))
@@ -3663,26 +3677,19 @@
     (def type-args (map 1 arg-pairs))
     (def computed-type-args (eval ~[,;type-args]))
     (def {:native lib
-          :native-path np
           :lazy lazy
           :native-lazy llib
           :map-symbols ms} (assert (dyn *ffi-context*) "no ffi context found"))
     (def raw-symbol (ms name))
+    (defn make-sig []
+      (ffi/signature :default ret-type ;computed-type-args))
+    (defn make-ptr []
+      (assert (ffi/lookup (if lazy (llib) lib) raw-symbol) "failed to find symbol"))
     (if lazy
-      (let [ptr
-            (delay
-              (assert (ffi/lookup (llib) raw-symbol) "failed to find symbol"))
-            sig
-            (delay
-              (ffi/signature :default ret-type ;computed-type-args))]
         ~(defn ,name ,;meta [,;formal-args]
-           (,ffi/call (,ptr) (,sig) ,;formal-args)))
-      (let [ptr
-            (assert (ffi/lookup lib raw-symbol) "failed to find symbol")
-            sig
-            (ffi/signature :default ret-type ;computed-type-args)]
+           (,ffi/call (,(delay (make-ptr))) (,(delay (make-sig))) ,;formal-args))
         ~(defn ,name ,;meta [,;formal-args]
-           (,ffi/call ,ptr ,sig ,;formal-args))))))
+           (,ffi/call ,(make-ptr) ,(make-sig) ,;formal-args)))))
 
 ###
 ###

src/conf/janetconf.h

@@ -4,10 +4,10 @@
 #define JANETCONF_H
 
 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 22
+#define JANET_VERSION_MINOR 23
 #define JANET_VERSION_PATCH 1
 #define JANET_VERSION_EXTRA "-dev"
-#define JANET_VERSION "1.22.1-dev"
+#define JANET_VERSION "1.23.1-dev"
 
 /* #define JANET_BUILD "local" */
 

src/core/abstract.c

@@ -26,12 +26,13 @@
 #include "util.h"
 #include "gc.h"
 #include "state.h"
+#endif
+
 #ifdef JANET_EV
 #ifdef JANET_WINDOWS
 #include <windows.h>
 #endif
 #endif
-#endif
 
 /* Create new userdata */
 void *janet_abstract_begin(const JanetAbstractType *atype, size_t size) {
@@ -86,12 +87,12 @@ void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size) {
 
 #ifdef JANET_WINDOWS
 
-void janet_os_mutex_size(void) {
+size_t janet_os_mutex_size(void) {
     return sizeof(CRITICAL_SECTION);
 }
 
-void janet_os_rwlock_size(void) {
-    return sizeof(SRWLock);
+size_t janet_os_rwlock_size(void) {
+    return sizeof(void *);
 }
 
 static int32_t janet_incref(JanetAbstractHead *ab) {

src/core/ev.c

@@ -535,10 +535,15 @@ static int janet_channel_push(JanetChannel *channel, Janet x, int mode);
 static int janet_channel_pop(JanetChannel *channel, Janet *item, int is_choice);
 
 static Janet make_supervisor_event(const char *name, JanetFiber *fiber, int threaded) {
-    Janet tup[2];
+    Janet tup[3];
     tup[0] = janet_ckeywordv(name);
     tup[1] = threaded ? fiber->last_value : janet_wrap_fiber(fiber) ;
-    return janet_wrap_tuple(janet_tuple_n(tup, 2));
+    if (fiber->env != NULL) {
+        tup[2] = janet_table_get(fiber->env, janet_ckeywordv("task-id"));
+    } else {
+        tup[2] = janet_wrap_nil();
+    }
+    return janet_wrap_tuple(janet_tuple_n(tup, 3));
 }
 
 /* Common init code */
@@ -2719,6 +2724,8 @@ JANET_CORE_FN(cfun_ev_go,
     return janet_wrap_fiber(fiber);
 }
 
+#define JANET_THREAD_SUPERVISOR_FLAG 0x100
+
 /* For ev/thread - Run an interpreter in the new thread. */
 static JanetEVGenericMessage janet_go_thread_subr(JanetEVGenericMessage args) {
     JanetBuffer *buffer = (JanetBuffer *) args.argp;
@@ -2741,7 +2748,7 @@ static JanetEVGenericMessage janet_go_thread_subr(JanetEVGenericMessage args) {
         }
 
         /* Get supervsior */
-        if (flags & 0x8) {
+        if (flags & JANET_THREAD_SUPERVISOR_FLAG) {
             Janet sup =
                 janet_unmarshal(nextbytes, endbytes - nextbytes,
                                 JANET_MARSHAL_UNSAFE, NULL, &nextbytes);
@@ -2793,6 +2800,10 @@ static JanetEVGenericMessage janet_go_thread_subr(JanetEVGenericMessage args) {
         } else {
             fiber = janet_unwrap_fiber(fiberv);
         }
+        if (flags & 0x8) {
+            if (NULL == fiber->env) fiber->env = janet_table(0);
+            janet_table_put(fiber->env, janet_ckeywordv("task-id"), value);
+        }
         fiber->supervisor_channel = janet_vm.user;
         janet_schedule(fiber, value);
         janet_loop();
@@ -2837,6 +2848,7 @@ JANET_CORE_FN(cfun_ev_thread,
               "If you want to run the thread without waiting for a result, pass the `:n` flag to return nil immediately. "
               "Otherwise, returns nil. Available flags:\n\n"
               "* `:n` - return immediately\n"
+              "* `:t` - set the task-id of the new thread to value. The task-id is passed in messages to the supervisor channel.\n"
               "* `:a` - don't copy abstract registry to new thread (performance optimization)\n"
               "* `:c` - don't copy cfunction registry to new thread (performance optimization)") {
     janet_arity(argc, 1, 4);
@@ -2844,10 +2856,10 @@ JANET_CORE_FN(cfun_ev_thread,
     if (!janet_checktype(argv[0], JANET_FUNCTION)) janet_getfiber(argv, 0);
     uint64_t flags = 0;
     if (argc >= 3) {
-        flags = janet_getflags(argv, 2, "nac");
+        flags = janet_getflags(argv, 2, "nact");
     }
     void *supervisor = janet_optabstract(argv, argc, 3, &janet_channel_type, janet_vm.root_fiber->supervisor_channel);
-    if (NULL != supervisor) flags |= 0x8;
+    if (NULL != supervisor) flags |= JANET_THREAD_SUPERVISOR_FLAG;
 
     /* Marshal arguments for the new thread. */
     JanetBuffer *buffer = janet_malloc(sizeof(JanetBuffer));
@@ -2858,7 +2870,7 @@ JANET_CORE_FN(cfun_ev_thread,
     if (!(flags & 0x2)) {
         janet_marshal(buffer, janet_wrap_table(janet_vm.abstract_registry), NULL, JANET_MARSHAL_UNSAFE);
     }
-    if (flags & 0x8) {
+    if (flags & JANET_THREAD_SUPERVISOR_FLAG) {
         janet_marshal(buffer, janet_wrap_abstract(supervisor), NULL, JANET_MARSHAL_UNSAFE);
     }
     if (!(flags & 0x4)) {

src/core/ffi.c

@@ -30,6 +30,11 @@
 
 #ifdef _MSC_VER
 #define alloca _alloca
+#elif defined(JANET_LINUX)
+#include <alloca.h>
+#elif !defined(alloca)
+/* Last ditch effort to get alloca - works for gcc and clang */
+#define alloca __builtin_alloca
 #endif
 
 #define JANET_FFI_MAX_RECUR 64
@@ -51,6 +56,7 @@ typedef enum {
     JANET_FFI_TYPE_VOID,
     JANET_FFI_TYPE_BOOL,
     JANET_FFI_TYPE_PTR,
+    JANET_FFI_TYPE_STRING,
     JANET_FFI_TYPE_FLOAT,
     JANET_FFI_TYPE_DOUBLE,
     JANET_FFI_TYPE_INT8,
@@ -76,6 +82,7 @@ static const JanetFFIPrimInfo janet_ffi_type_info[] = {
     {0, 0}, /* JANET_FFI_TYPE_VOID */
     {sizeof(char), ALIGNOF(char)}, /* JANET_FFI_TYPE_BOOL */
     {sizeof(void *), ALIGNOF(void *)}, /* JANET_FFI_TYPE_PTR */
+    {sizeof(char *), ALIGNOF(char *)}, /* JANET_FFI_TYPE_STRING */
     {sizeof(float), ALIGNOF(float)}, /* JANET_FFI_TYPE_FLOAT */
     {sizeof(double), ALIGNOF(double)}, /* JANET_FFI_TYPE_DOUBLE */
     {sizeof(int8_t), ALIGNOF(int8_t)}, /* JANET_FFI_TYPE_INT8 */
@@ -92,6 +99,7 @@ static const JanetFFIPrimInfo janet_ffi_type_info[] = {
 struct JanetFFIType {
     JanetFFIStruct *st;
     JanetFFIPrimType prim;
+    int32_t array_count;
 };
 
 typedef struct {
@@ -99,6 +107,7 @@ typedef struct {
     size_t offset;
 } JanetFFIStructMember;
 
+/* Also used to store array types */
 struct JanetFFIStruct {
     uint32_t size;
     uint32_t align;
@@ -202,6 +211,7 @@ static const JanetAbstractType janet_struct_type = {
 typedef struct {
     Clib clib;
     int closed;
+    int is_self;
 } JanetAbstractNative;
 
 static const JanetAbstractType janet_native_type = {
@@ -213,14 +223,16 @@ static JanetFFIType prim_type(JanetFFIPrimType pt) {
     JanetFFIType t;
     t.prim = pt;
     t.st = NULL;
+    t.array_count = -1;
     return t;
 }
 
 static size_t type_size(JanetFFIType t) {
+    size_t count = t.array_count < 0 ? 1 : (size_t) t.array_count;
     if (t.prim == JANET_FFI_TYPE_STRUCT) {
-        return t.st->size;
+        return t.st->size * count;
     } else {
-        return janet_ffi_type_info[t.prim].size;
+        return janet_ffi_type_info[t.prim].size * count;
     }
 }
 
@@ -248,6 +260,7 @@ static JanetFFIPrimType decode_ffi_prim(const uint8_t *name) {
     if (!janet_cstrcmp(name, "void")) return JANET_FFI_TYPE_VOID;
     if (!janet_cstrcmp(name, "bool")) return JANET_FFI_TYPE_BOOL;
     if (!janet_cstrcmp(name, "ptr")) return JANET_FFI_TYPE_PTR;
+    if (!janet_cstrcmp(name, "string")) return JANET_FFI_TYPE_STRING;
     if (!janet_cstrcmp(name, "float")) return JANET_FFI_TYPE_FLOAT;
     if (!janet_cstrcmp(name, "double")) return JANET_FFI_TYPE_DOUBLE;
     if (!janet_cstrcmp(name, "int8")) return JANET_FFI_TYPE_INT8;
@@ -281,6 +294,7 @@ static JanetFFIPrimType decode_ffi_prim(const uint8_t *name) {
     if (!janet_cstrcmp(name, "int")) return JANET_FFI_TYPE_INT32;
     if (!janet_cstrcmp(name, "long")) return JANET_FFI_TYPE_INT64;
     if (!janet_cstrcmp(name, "byte")) return JANET_FFI_TYPE_UINT8;
+    if (!janet_cstrcmp(name, "uchar")) return JANET_FFI_TYPE_UINT8;
     if (!janet_cstrcmp(name, "ushort")) return JANET_FFI_TYPE_UINT16;
     if (!janet_cstrcmp(name, "uint")) return JANET_FFI_TYPE_UINT32;
     if (!janet_cstrcmp(name, "ulong")) return JANET_FFI_TYPE_UINT64;
@@ -333,6 +347,7 @@ static JanetFFIStruct *build_struct_type(int32_t argc, const Janet *argv) {
         if (janet_keyeq(argv[j], "pack") || janet_keyeq(argv[j], "pack-all")) {
             pack_one = 1;
             j++;
+            if (j == argc) break;
         }
         st->fields[i].type = decode_ffi_type(argv[j]);
         size_t el_size = type_size(st->fields[i].type);
@@ -349,6 +364,9 @@ static JanetFFIStruct *build_struct_type(int32_t argc, const Janet *argv) {
         i++;
     }
     st->is_aligned = is_aligned;
+    st->size += (st->align - 1);
+    st->size /= st->align;
+    st->size *= st->align;
     return st;
 }
 
@@ -357,6 +375,7 @@ static JanetFFIType decode_ffi_type(Janet x) {
         return prim_type(decode_ffi_prim(janet_unwrap_keyword(x)));
     }
     JanetFFIType ret;
+    ret.array_count = -1;
     ret.prim = JANET_FFI_TYPE_STRUCT;
     if (janet_checkabstract(x, &janet_struct_type)) {
         ret.st = janet_unwrap_abstract(x);
@@ -365,7 +384,14 @@ static JanetFFIType decode_ffi_type(Janet x) {
     int32_t len;
     const Janet *els;
     if (janet_indexed_view(x, &els, &len)) {
-        ret.st = build_struct_type(len, els);
+        if (janet_checktype(x, JANET_ARRAY)) {
+            if (len != 2 && len != 1) janet_panicf("array type must be of form @[type count], got %v", x);
+            ret = decode_ffi_type(els[0]);
+            int32_t array_count = len == 1 ? 0 : janet_getnat(els, 1);
+            ret.array_count = array_count;
+        } else {
+            ret.st = build_struct_type(len, els);
+        }
         return ret;
     } else {
         janet_panicf("bad native type %v", x);
@@ -374,11 +400,27 @@ static JanetFFIType decode_ffi_type(Janet x) {
 
 JANET_CORE_FN(cfun_ffi_struct,
               "(ffi/struct & types)",
-              "Create a struct type descriptor that can be used to pass structs into native functions. ") {
+              "Create a struct type definition that can be used to pass structs into native functions. ") {
     janet_arity(argc, 1, -1);
     return janet_wrap_abstract(build_struct_type(argc, argv));
 }
 
+JANET_CORE_FN(cfun_ffi_size,
+              "(ffi/size type)",
+              "Get the size of an ffi type in bytes.") {
+    janet_fixarity(argc, 1);
+    size_t size = type_size(decode_ffi_type(argv[0]));
+    return janet_wrap_number((double) size);
+}
+
+JANET_CORE_FN(cfun_ffi_align,
+              "(ffi/align type)",
+              "Get the align of an ffi type in bytes.") {
+    janet_fixarity(argc, 1);
+    size_t size = type_align(decode_ffi_type(argv[0]));
+    return janet_wrap_number((double) size);
+}
+
 static void *janet_ffi_getpointer(const Janet *argv, int32_t n) {
     switch (janet_type(argv[n])) {
         default:
@@ -405,6 +447,21 @@ static void *janet_ffi_getpointer(const Janet *argv, int32_t n) {
  * The alignment and space available is assumed to already be sufficient */
 static void janet_ffi_write_one(void *to, const Janet *argv, int32_t n, JanetFFIType type, int recur) {
     if (recur == 0) janet_panic("recursion too deep");
+    if (type.array_count >= 0) {
+        JanetFFIType el_type = type;
+        el_type.array_count = -1;
+        size_t el_size = type_size(el_type);
+        JanetView els = janet_getindexed(argv, n);
+        if (els.len != type.array_count) {
+            janet_panicf("bad array length, expected %d, got %d", type.array_count, els.len);
+        }
+        char *cursor = to;
+        for (int32_t i = 0; i < els.len; i++) {
+            janet_ffi_write_one(cursor, els.items, i, el_type, recur - 1);
+            cursor += el_size;
+        }
+        return;
+    }
     switch (type.prim) {
         case JANET_FFI_TYPE_VOID:
             if (!janet_checktype(argv[n], JANET_NIL)) {
@@ -433,6 +490,9 @@ static void janet_ffi_write_one(void *to, const Janet *argv, int32_t n, JanetFFI
         case JANET_FFI_TYPE_PTR:
             ((void **)(to))[0] = janet_ffi_getpointer(argv, n);
             break;
+        case JANET_FFI_TYPE_STRING:
+            ((const char **)(to))[0] = janet_getcstring(argv, n);
+            break;
         case JANET_FFI_TYPE_BOOL:
             ((bool *)(to))[0] = janet_getboolean(argv, n);
             break;
@@ -468,6 +528,17 @@ static void janet_ffi_write_one(void *to, const Janet *argv, int32_t n, JanetFFI
  * size of the data is correct. */
 static Janet janet_ffi_read_one(const uint8_t *from, JanetFFIType type, int recur) {
     if (recur == 0) janet_panic("recursion too deep");
+    if (type.array_count >= 0) {
+        JanetFFIType el_type = type;
+        el_type.array_count = -1;
+        size_t el_size = type_size(el_type);
+        JanetArray *array = janet_array(type.array_count);
+        for (int32_t i = 0; i < type.array_count; i++) {
+            janet_array_push(array, janet_ffi_read_one(from, el_type, recur - 1));
+            from += el_size;
+        }
+        return janet_wrap_array(array);
+    }
     switch (type.prim) {
         default:
         case JANET_FFI_TYPE_VOID:
@@ -485,8 +556,12 @@ static Janet janet_ffi_read_one(const uint8_t *from, JanetFFIType type, int recu
             return janet_wrap_number(((double *)(from))[0]);
         case JANET_FFI_TYPE_FLOAT:
             return janet_wrap_number(((float *)(from))[0]);
-        case JANET_FFI_TYPE_PTR:
-            return janet_wrap_pointer(((void **)(from))[0]);
+        case JANET_FFI_TYPE_PTR: {
+            void *ptr = ((void **)(from))[0];
+            return (NULL == ptr) ? janet_wrap_nil() : janet_wrap_pointer(ptr);
+        }
+        case JANET_FFI_TYPE_STRING:
+            return janet_cstringv(((char **)(from))[0]);
         case JANET_FFI_TYPE_BOOL:
             return janet_wrap_boolean(((bool *)(from))[0]);
         case JANET_FFI_TYPE_INT8:
@@ -529,6 +604,7 @@ static JanetFFIMapping void_mapping(void) {
 static JanetFFIWordSpec sysv64_classify(JanetFFIType type) {
     switch (type.prim) {
         case JANET_FFI_TYPE_PTR:
+        case JANET_FFI_TYPE_STRING:
         case JANET_FFI_TYPE_BOOL:
         case JANET_FFI_TYPE_INT8:
         case JANET_FFI_TYPE_INT16:
@@ -1054,7 +1130,6 @@ JANET_CORE_FN(cfun_ffi_buffer_write,
     return janet_wrap_buffer(buffer);
 }
 
-
 JANET_CORE_FN(cfun_ffi_buffer_read,
               "(ffi/read ffi-type bytes &opt offset)",
               "Parse a native struct out of a buffer and convert it to normal Janet data structures. "
@@ -1077,7 +1152,7 @@ JANET_CORE_FN(cfun_ffi_buffer_read,
 JANET_CORE_FN(cfun_ffi_get_callback_trampoline,
               "(ffi/trampoline cc)",
               "Get a native function pointer that can be used as a callback and passed to C libraries. "
-              "This callback trampoline has the signature `void trampoline(void *ctx, void *userdata)` in "
+              "This callback trampoline has the signature `void trampoline(void \\*ctx, void \\*userdata)` in "
               "the given calling convention. This is the only function signature supported. "
               "It is up to the programmer to ensure that the `userdata` argument contains a janet function "
               "the will be called with one argument, `ctx` which is an opaque pointer. This pointer can "
@@ -1101,19 +1176,19 @@ JANET_CORE_FN(cfun_ffi_get_callback_trampoline,
 }
 
 JANET_CORE_FN(janet_core_raw_native,
-              "(ffi/native path)",
+              "(ffi/native &opt path)",
               "Load a shared object or dll from the given path, and do not extract"
               " or run any code from it. This is different than `native`, which will "
-              "run initialization code to get a module table. Returns a `core/native`.") {
-    janet_fixarity(argc, 1);
-    const char *path = janet_getcstring(argv, 0);
-    char *processed_name = get_processed_name(path);
-    Clib lib = load_clib(processed_name);
-    if (path != processed_name) janet_free(processed_name);
+              "run initialization code to get a module table. If `path` is nil, opens the current running binary. "
+              "Returns a `core/native`.") {
+    janet_arity(argc, 0, 1);
+    const char *path = janet_optcstring(argv, argc, 0, NULL);
+    Clib lib = load_clib(path);
     if (!lib) janet_panic(error_clib());
     JanetAbstractNative *anative = janet_abstract(&janet_native_type, sizeof(JanetAbstractNative));
     anative->clib = lib;
     anative->closed = 0;
+    anative->is_self = path == NULL;
     return janet_wrap_abstract(anative);
 }
 
@@ -1137,6 +1212,7 @@ JANET_CORE_FN(janet_core_native_close,
     janet_fixarity(argc, 1);
     JanetAbstractNative *anative = janet_getabstract(argv, 0, &janet_native_type);
     if (anative->closed) janet_panic("native object already closed");
+    if (anative->is_self) janet_panic("cannot close self");
     anative->closed = 1;
     free_clib(anative->clib);
     return janet_wrap_nil();
@@ -1152,6 +1228,8 @@ void janet_lib_ffi(JanetTable *env) {
         JANET_CORE_REG("ffi/struct", cfun_ffi_struct),
         JANET_CORE_REG("ffi/write", cfun_ffi_buffer_write),
         JANET_CORE_REG("ffi/read", cfun_ffi_buffer_read),
+        JANET_CORE_REG("ffi/size", cfun_ffi_size),
+        JANET_CORE_REG("ffi/align", cfun_ffi_align),
         JANET_CORE_REG("ffi/trampoline", cfun_ffi_get_callback_trampoline),
         JANET_REG_END
     };

src/core/io.c

@@ -545,6 +545,16 @@ static Janet cfun_io_printf_impl_x(int32_t argc, Janet *argv, int newline,
             if (newline) janet_buffer_push_u8(buf, '\n');
             return janet_wrap_nil();
         }
+        case JANET_FUNCTION: {
+            /* Special case function */
+            JanetFunction *fun = janet_unwrap_function(x);
+            JanetBuffer *buf = janet_buffer(0);
+            janet_buffer_format(buf, fmt, offset, argc, argv);
+            if (newline) janet_buffer_push_u8(buf, '\n');
+            Janet args[1] = { janet_wrap_buffer(buf) };
+            janet_call(fun, 1, args);
+            return janet_wrap_nil();
+        }
         case JANET_NIL:
             f = dflt_file;
             if (f == NULL) janet_panic("cannot print to nil");
@@ -684,6 +694,16 @@ void janet_dynprintf(const char *name, FILE *dflt_file, const char *format, ...)
             janet_buffer_deinit(&buffer);
             break;
         }
+        case JANET_FUNCTION: {
+            JanetFunction *fun = janet_unwrap_function(x);
+            int32_t len = 0;
+            while (format[len]) len++;
+            JanetBuffer *buf = janet_buffer(len);
+            janet_formatbv(buf, format, args);
+            Janet args[1] = { janet_wrap_buffer(buf) };
+            janet_call(fun, 1, args);
+            break;
+        }
         case JANET_BUFFER:
             janet_formatbv(janet_unwrap_buffer(x), format, args);
             break;

src/core/net.c

@@ -884,7 +884,6 @@ static JanetStream *make_stream(JSock handle, uint32_t flags) {
     return janet_stream((JanetHandle) handle, flags | JANET_STREAM_SOCKET, net_stream_methods);
 }
 
-
 void janet_lib_net(JanetTable *env) {
     JanetRegExt net_cfuns[] = {
         JANET_CORE_REG("net/address", cfun_net_sockaddr),

src/core/os.c

@@ -1121,8 +1121,8 @@ JANET_CORE_FN(os_spawn,
               "Execute a program on the system and return a handle to the process. Otherwise, takes the "
               "same arguments as `os/execute`. Does not wait for the process. "
               "For each of the :in, :out, and :err keys to the `env` argument, one "
-              "can also pass in the keyword `:pipe`"
-              "to get streams for standard IO of the subprocess that can be read from and written to."
+              "can also pass in the keyword `:pipe` "
+              "to get streams for standard IO of the subprocess that can be read from and written to. "
               "The returned value `proc` has the fields :in, :out, :err, :return-code, and "
               "the additional field :pid on unix-like platforms. Use `(os/proc-wait proc)` to rejoin the "
               "subprocess or `(os/proc-kill proc)`.") {
@@ -1345,6 +1345,7 @@ JANET_CORE_FN(os_date,
     if (argc >= 2 && janet_truthy(argv[1])) {
         /* local time */
 #ifdef JANET_WINDOWS
+        _tzset();
         localtime_s(&t_infos, &t);
         t_info = &t_infos;
 #else
@@ -2035,23 +2036,23 @@ JANET_CORE_FN(os_open,
               "Allowed flags are as follows:\n\n"
               "  * :r - open this file for reading\n"
               "  * :w - open this file for writing\n"
-              "  * :c - create a new file (O_CREATE)\n"
-              "  * :e - fail if the file exists (O_EXCL)\n"
-              "  * :t - shorten an existing file to length 0 (O_TRUNC)\n\n"
+              "  * :c - create a new file (O\\_CREATE)\n"
+              "  * :e - fail if the file exists (O\\_EXCL)\n"
+              "  * :t - shorten an existing file to length 0 (O\\_TRUNC)\n\n"
               "Posix-only flags:\n\n"
-              "  * :a - append to a file (O_APPEND)\n"
-              "  * :x - O_SYNC\n"
-              "  * :C - O_NOCTTY\n\n"
+              "  * :a - append to a file (O\\_APPEND)\n"
+              "  * :x - O\\_SYNC\n"
+              "  * :C - O\\_NOCTTY\n\n"
               "Windows-only flags:\n\n"
-              "  * :R - share reads (FILE_SHARE_READ)\n"
-              "  * :W - share writes (FILE_SHARE_WRITE)\n"
-              "  * :D - share deletes (FILE_SHARE_DELETE)\n"
-              "  * :H - FILE_ATTRIBUTE_HIDDEN\n"
-              "  * :O - FILE_ATTRIBUTE_READONLY\n"
-              "  * :F - FILE_ATTRIBUTE_OFFLINE\n"
-              "  * :T - FILE_ATTRIBUTE_TEMPORARY\n"
-              "  * :d - FILE_FLAG_DELETE_ON_CLOSE\n"
-              "  * :b - FILE_FLAG_NO_BUFFERING\n") {
+              "  * :R - share reads (FILE\\_SHARE\\_READ)\n"
+              "  * :W - share writes (FILE\\_SHARE\\_WRITE)\n"
+              "  * :D - share deletes (FILE\\_SHARE\\_DELETE)\n"
+              "  * :H - FILE\\_ATTRIBUTE\\_HIDDEN\n"
+              "  * :O - FILE\\_ATTRIBUTE\\_READONLY\n"
+              "  * :F - FILE\\_ATTRIBUTE\\_OFFLINE\n"
+              "  * :T - FILE\\_ATTRIBUTE\\_TEMPORARY\n"
+              "  * :d - FILE\\_FLAG\\_DELETE\\_ON\\_CLOSE\n"
+              "  * :b - FILE\\_FLAG\\_NO\\_BUFFERING\n") {
     janet_arity(argc, 1, 3);
     const char *path = janet_getcstring(argv, 0);
     const uint8_t *opt_flags = janet_optkeyword(argv, argc, 1, (const uint8_t *) "r");

src/core/pp.c

@@ -762,8 +762,7 @@ static const char *scanformat(
     memset(precision, '\0', 3);
     while (*p != '\0' && strchr(FMT_FLAGS, *p) != NULL)
         p++; /* skip flags */
-    if ((size_t)(p - strfrmt) >= sizeof(FMT_FLAGS) / sizeof(char))
-        janet_panic("invalid format (repeated flags)");
+    if ((size_t)(p - strfrmt) >= sizeof(FMT_FLAGS)) janet_panic("invalid format (repeated flags)");
     if (isdigit((int)(*p)))
         width[0] = *p++; /* skip width */
     if (isdigit((int)(*p)))

src/core/specials.c

@@ -31,7 +31,7 @@
 
 static JanetSlot janetc_quote(JanetFopts opts, int32_t argn, const Janet *argv) {
     if (argn != 1) {
-        janetc_cerror(opts.compiler, "expected 1 argument");
+        janetc_cerror(opts.compiler, "expected 1 argument to quote");
         return janetc_cslot(janet_wrap_nil());
     }
     return janetc_cslot(argv[0]);
@@ -40,7 +40,7 @@ static JanetSlot janetc_quote(JanetFopts opts, int32_t argn, const Janet *argv)
 static JanetSlot janetc_splice(JanetFopts opts, int32_t argn, const Janet *argv) {
     JanetSlot ret;
     if (argn != 1) {
-        janetc_cerror(opts.compiler, "expected 1 argument");
+        janetc_cerror(opts.compiler, "expected 1 argument to splice");
         return janetc_cslot(janet_wrap_nil());
     }
     ret = janetc_value(opts, argv[0]);
@@ -117,7 +117,7 @@ static JanetSlot quasiquote(JanetFopts opts, Janet x, int depth, int level) {
 
 static JanetSlot janetc_quasiquote(JanetFopts opts, int32_t argn, const Janet *argv) {
     if (argn != 1) {
-        janetc_cerror(opts.compiler, "expected 1 argument");
+        janetc_cerror(opts.compiler, "expected 1 argument to quasiquote");
         return janetc_cslot(janet_wrap_nil());
     }
     return quasiquote(opts, argv[0], JANET_RECURSION_GUARD, 0);
@@ -143,7 +143,7 @@ static int destructure(JanetCompiler *c,
                        JanetTable *attr) {
     switch (janet_type(left)) {
         default:
-            janetc_cerror(c, "unexpected type in destructuring");
+            janetc_error(c, janet_formatc("unexpected type in destruction, got %v", left));
             return 1;
         case JANET_SYMBOL:
             /* Leaf, assign right to left */
@@ -302,6 +302,9 @@ static JanetSlot janetc_varset(JanetFopts opts, int32_t argn, const Janet *argv)
 static JanetTable *handleattr(JanetCompiler *c, int32_t argn, const Janet *argv) {
     int32_t i;
     JanetTable *tab = janet_table(2);
+    const char *binding_name = janet_type(argv[0]) == JANET_SYMBOL
+                               ? ((const char *)janet_unwrap_symbol(argv[0]))
+                               : "<multiple bindings>";
     for (i = 1; i < argn - 1; i++) {
         Janet attr = argv[i];
         switch (janet_type(attr)) {
@@ -309,7 +312,7 @@ static JanetTable *handleattr(JanetCompiler *c, int32_t argn, const Janet *argv)
                 janetc_cerror(c, "unexpected form - did you intend to use defn?");
                 break;
             default:
-                janetc_cerror(c, "could not add metadata to binding");
+                janetc_error(c, janet_formatc("cannot add metadata %v to binding %s", attr, binding_name));
                 break;
             case JANET_KEYWORD:
                 janet_table_put(tab, attr, janet_wrap_true());
@@ -858,6 +861,7 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     for (i = 0; i < paramcount; i++) {
         Janet param = params[i];
         if (namedargs) {
+            arity--;
             if (!janet_checktype(param, JANET_SYMBOL)) {
                 errmsg = "only named arguments can follow &named";
                 goto error;
@@ -915,7 +919,7 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
                     }
                     vararg = 1;
                     structarg = 1;
-                    arity = i;
+                    arity--;
                     seenamp = 1;
                     namedargs = 1;
                     named_table = janet_table(10);

src/core/string.c

@@ -530,7 +530,7 @@ JANET_CORE_FN(cfun_string_join,
 
 JANET_CORE_FN(cfun_string_format,
               "(string/format format & values)",
-              "Similar to `snprintf`, but specialized for operating with Janet values. Returns "
+              "Similar to C's `snprintf`, but specialized for operating with Janet values. Returns "
               "a new string.") {
     janet_arity(argc, 1, -1);
     JanetBuffer *buffer = janet_buffer(0);

src/core/util.c

@@ -912,6 +912,14 @@ char *error_clib(void) {
     error_clib_buf[strlen(error_clib_buf) - 1] = '\0';
     return error_clib_buf;
 }
+
+Clib load_clib(const char *name) {
+    if (name == NULL) {
+        return GetModuleHandle(NULL);
+    } else {
+        return LoadLibrary(name);
+    }
+}
 #endif
 
 /* Alloc function macro fills */

src/core/util.h

@@ -35,11 +35,9 @@
 #include <stdbool.h>
 
 #ifdef JANET_EV
+#ifndef JANET_WINDOWS
 #include <pthread.h>
 #endif
-
-#ifndef _MSC_VER
-#include <alloca.h>
 #endif
 
 #if !defined(JANET_REDUCED_OS) || !defined(JANET_SINGLE_THREADED)
@@ -142,9 +140,9 @@ typedef int Clib;
 #elif defined(JANET_WINDOWS)
 #include <windows.h>
 typedef HINSTANCE Clib;
-#define load_clib(name) LoadLibrary((name))
 #define free_clib(c) FreeLibrary((c))
 #define symbol_clib(lib, sym) GetProcAddress((lib), (sym))
+Clib load_clib(const char *name);
 char *error_clib(void);
 #else
 #include <dlfcn.h>

src/core/value.c

@@ -348,7 +348,7 @@ int32_t janet_hash(Janet x) {
                 hash = (int32_t)((hilo << 16) | (hilo >> 16));
             } else {
                 /* Assuming 4 byte pointer (or smaller) */
-                ptrdiff_t diff = ((char *)janet_unwrap_pointer(x) - (char *)0);
+                uintptr_t diff = (uintptr_t) janet_unwrap_pointer(x);
                 uint32_t hilo = (uint32_t) diff * 2654435769u;
                 hash = (int32_t)((hilo << 16) | (hilo >> 16));
             }

src/core/vm.c

@@ -220,14 +220,14 @@
 /* Trace a function call */
 static void vm_do_trace(JanetFunction *func, int32_t argc, const Janet *argv) {
     if (func->def->name) {
-        janet_printf("trace (%S", func->def->name);
+        janet_eprintf("trace (%S", func->def->name);
     } else {
-        janet_printf("trace (%p", janet_wrap_function(func));
+        janet_eprintf("trace (%p", janet_wrap_function(func));
     }
     for (int32_t i = 0; i < argc; i++) {
-        janet_printf(" %p", argv[i]);
+        janet_eprintf(" %p", argv[i]);
     }
-    janet_printf(")\n");
+    janet_eprintf(")\n");
 }
 
 /* Invoke a method once we have looked it up */
@@ -1285,6 +1285,12 @@ JanetSignal janet_step(JanetFiber *fiber, Janet in, Janet *out) {
     return signal;
 }
 
+static Janet void_cfunction(int32_t argc, Janet *argv) {
+    (void) argc;
+    (void) argv;
+    janet_panic("placeholder");
+}
+
 Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) {
     /* Check entry conditions */
     if (!janet_vm.fiber)
@@ -1292,9 +1298,17 @@ Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) {
     if (janet_vm.stackn >= JANET_RECURSION_GUARD)
         janet_panic("C stack recursed too deeply");
 
+    /* Dirty stack */
+    int32_t dirty_stack = janet_vm.fiber->stacktop - janet_vm.fiber->stackstart;
+    if (dirty_stack) {
+        janet_fiber_cframe(janet_vm.fiber, void_cfunction);
+    }
+
     /* Tracing */
     if (fun->gc.flags & JANET_FUNCFLAG_TRACE) {
+        janet_vm.stackn++;
         vm_do_trace(fun, argc, argv);
+        janet_vm.stackn--;
     }
 
     /* Push frame */
@@ -1322,6 +1336,10 @@ Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) {
     /* Teardown */
     janet_vm.stackn = oldn;
     janet_gcunlock(handle);
+    if (dirty_stack) {
+        janet_fiber_popframe(janet_vm.fiber);
+        janet_vm.fiber->stacktop += dirty_stack;
+    }
 
     if (signal != JANET_SIGNAL_OK) {
         janet_panicv(*janet_vm.return_reg);

src/include/janet.h

@@ -166,7 +166,7 @@ extern "C" {
 /* Enable or disable the FFI library. Currently, FFI only enabled on
  * x86-64, non-windows operating systems. */
 #ifndef JANET_NO_FFI
-#if !defined(JANET_WINDOWS) && (defined(__x86_64__) || defined(_M_X64))
+#if !defined(JANET_WINDOWS) && !defined(__EMSCRIPTEN__) && (defined(__x86_64__) || defined(_M_X64))
 #define JANET_FFI
 #endif
 #endif

src/mainclient/shell.c

@@ -87,8 +87,30 @@ static void simpleline(JanetBuffer *buffer) {
     }
 }
 
-/* Windows */
-#if defined(JANET_WINDOWS) || defined(JANET_SIMPLE_GETLINE)
+/* State */
+
+#ifndef JANET_SIMPLE_GETLINE
+/* static state */
+#define JANET_LINE_MAX 1024
+#define JANET_MATCH_MAX 256
+#define JANET_HISTORY_MAX 100
+static JANET_THREAD_LOCAL int gbl_israwmode = 0;
+static JANET_THREAD_LOCAL const char *gbl_prompt = "> ";
+static JANET_THREAD_LOCAL int gbl_plen = 2;
+static JANET_THREAD_LOCAL char gbl_buf[JANET_LINE_MAX];
+static JANET_THREAD_LOCAL int gbl_len = 0;
+static JANET_THREAD_LOCAL int gbl_pos = 0;
+static JANET_THREAD_LOCAL int gbl_cols = 80;
+static JANET_THREAD_LOCAL char *gbl_history[JANET_HISTORY_MAX];
+static JANET_THREAD_LOCAL int gbl_history_count = 0;
+static JANET_THREAD_LOCAL int gbl_historyi = 0;
+static JANET_THREAD_LOCAL JanetByteView gbl_matches[JANET_MATCH_MAX];
+static JANET_THREAD_LOCAL int gbl_match_count = 0;
+static JANET_THREAD_LOCAL int gbl_lines_below = 0;
+#endif
+
+/* Fallback */
+#if defined(JANET_SIMPLE_GETLINE)
 
 void janet_line_init() {
     ;
@@ -105,6 +127,80 @@ void janet_line_get(const char *p, JanetBuffer *buffer) {
     simpleline(buffer);
 }
 
+/* Rich implementation */
+#else
+
+/* Windows */
+#ifdef _WIN32
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <io.h>
+
+static void setup_console_output(void) {
+    /* Enable color console on windows 10 console and utf8 output and other processing */
+    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    DWORD dwMode = 0;
+    GetConsoleMode(hOut, &dwMode);
+    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    SetConsoleMode(hOut, dwMode);
+    SetConsoleOutputCP(65001);
+}
+
+/* Ansi terminal raw mode */
+static int rawmode(void) {
+    if (gbl_israwmode) return 0;
+    HANDLE hOut = GetStdHandle(STD_INPUT_HANDLE);
+    DWORD dwMode = 0;
+    GetConsoleMode(hOut, &dwMode);
+    dwMode &= ~ENABLE_LINE_INPUT;
+    dwMode &= ~ENABLE_INSERT_MODE;
+    dwMode &= ~ENABLE_ECHO_INPUT;
+    dwMode |= ENABLE_VIRTUAL_TERMINAL_INPUT;
+    dwMode &= ~ENABLE_PROCESSED_INPUT;
+    if (!SetConsoleMode(hOut, dwMode)) return 1;
+    gbl_israwmode = 1;
+    return 0;
+}
+
+/* Disable raw mode */
+static void norawmode(void) {
+    if (!gbl_israwmode) return;
+    HANDLE hOut = GetStdHandle(STD_INPUT_HANDLE);
+    DWORD dwMode = 0;
+    GetConsoleMode(hOut, &dwMode);
+    dwMode |= ENABLE_LINE_INPUT;
+    dwMode |= ENABLE_INSERT_MODE;
+    dwMode |= ENABLE_ECHO_INPUT;
+    dwMode &= ~ENABLE_VIRTUAL_TERMINAL_INPUT;
+    dwMode |= ENABLE_PROCESSED_INPUT;
+    SetConsoleMode(hOut, dwMode);
+    gbl_israwmode = 0;
+}
+
+static long write_console(const char *bytes, size_t n) {
+    DWORD nwritten = 0;
+    BOOL result = WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), bytes, (DWORD) n, &nwritten, NULL);
+    if (!result) return -1; /* error */
+    return (long)nwritten;
+}
+
+static long read_console(char *into, size_t n) {
+    DWORD numread;
+    BOOL result = ReadConsole(GetStdHandle(STD_INPUT_HANDLE), into, (DWORD) n, &numread, NULL);
+    if (!result) return -1; /* error */
+    return (long)numread;
+}
+
+static int check_simpleline(JanetBuffer *buffer) {
+    if (!_isatty(_fileno(stdin)) || rawmode()) {
+        simpleline(buffer);
+        return 1;
+    }
+    return 0;
+}
+
 /* Posix */
 #else
 
@@ -125,24 +221,7 @@ https://github.com/antirez/linenoise/blob/master/linenoise.c
 #include <string.h>
 #include <signal.h>
 
-/* static state */
-#define JANET_LINE_MAX 1024
-#define JANET_MATCH_MAX 256
-#define JANET_HISTORY_MAX 100
-static JANET_THREAD_LOCAL int gbl_israwmode = 0;
-static JANET_THREAD_LOCAL const char *gbl_prompt = "> ";
-static JANET_THREAD_LOCAL int gbl_plen = 2;
-static JANET_THREAD_LOCAL char gbl_buf[JANET_LINE_MAX];
-static JANET_THREAD_LOCAL int gbl_len = 0;
-static JANET_THREAD_LOCAL int gbl_pos = 0;
-static JANET_THREAD_LOCAL int gbl_cols = 80;
-static JANET_THREAD_LOCAL char *gbl_history[JANET_HISTORY_MAX];
-static JANET_THREAD_LOCAL int gbl_history_count = 0;
-static JANET_THREAD_LOCAL int gbl_historyi = 0;
 static JANET_THREAD_LOCAL struct termios gbl_termios_start;
-static JANET_THREAD_LOCAL JanetByteView gbl_matches[JANET_MATCH_MAX];
-static JANET_THREAD_LOCAL int gbl_match_count = 0;
-static JANET_THREAD_LOCAL int gbl_lines_below = 0;
 
 /* Unsupported terminal list from linenoise */
 static const char *badterms[] = {
@@ -152,15 +231,6 @@ static const char *badterms[] = {
     NULL
 };
 
-static char *sdup(const char *s) {
-    size_t len = strlen(s) + 1;
-    char *mem = janet_malloc(len);
-    if (!mem) {
-        return NULL;
-    }
-    return memcpy(mem, s, len);
-}
-
 /* Ansi terminal raw mode */
 static int rawmode(void) {
     struct termios t;
@@ -186,13 +256,53 @@ static void norawmode(void) {
         gbl_israwmode = 0;
 }
 
+static int checktermsupport() {
+    const char *t = getenv("TERM");
+    int i;
+    if (!t) return 1;
+    for (i = 0; badterms[i]; i++)
+        if (!strcmp(t, badterms[i])) return 0;
+    return 1;
+}
+
+static long write_console(char *bytes, size_t n) {
+    return write(STDOUT_FILENO, bytes, n);
+}
+
+static long read_console(char *into, size_t n) {
+    return read(STDIN_FILENO, into, n);
+}
+
+static int check_simpleline(JanetBuffer *buffer) {
+    if (!isatty(STDIN_FILENO) || !checktermsupport()) {
+        simpleline(buffer);
+        return 1;
+    }
+    if (rawmode()) {
+        simpleline(buffer);
+        return 1;
+    }
+    return 0;
+}
+
+#endif
+
+static char *sdup(const char *s) {
+    size_t len = strlen(s) + 1;
+    char *mem = janet_malloc(len);
+    if (!mem) {
+        return NULL;
+    }
+    return memcpy(mem, s, len);
+}
+
 static int curpos(void) {
     char buf[32];
     int cols, rows;
     unsigned int i = 0;
-    if (write(STDOUT_FILENO, "\x1b[6n", 4) != 4) return -1;
+    if (write_console("\x1b[6n", 4) != 4) return -1;
     while (i < sizeof(buf) - 1) {
-        if (read(STDIN_FILENO, buf + i, 1) != 1) break;
+        if (read_console(buf + i, 1) != 1) break;
         if (buf[i] == 'R') break;
         i++;
     }
@@ -203,18 +313,23 @@ static int curpos(void) {
 }
 
 static int getcols(void) {
+#ifdef _WIN32
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
+    return (int)(csbi.srWindow.Right - csbi.srWindow.Left + 1);
+#else
     struct winsize ws;
     if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
         int start, cols;
         start = curpos();
         if (start == -1) goto failed;
-        if (write(STDOUT_FILENO, "\x1b[999C", 6) != 6) goto failed;
+        if (write_console("\x1b[999C", 6) != 6) goto failed;
         cols = curpos();
         if (cols == -1) goto failed;
         if (cols > start) {
             char seq[32];
             snprintf(seq, 32, "\x1b[%dD", cols - start);
-            if (write(STDOUT_FILENO, seq, strlen(seq)) == -1) {
+            if (write_console(seq, strlen(seq)) == -1) {
                 exit(1);
             }
         }
@@ -224,10 +339,11 @@ static int getcols(void) {
     }
 failed:
     return 80;
+#endif
 }
 
 static void clear(void) {
-    if (write(STDOUT_FILENO, "\x1b[H\x1b[2J", 7) <= 0) {
+    if (write_console("\x1b[H\x1b[2J", 7) <= 0) {
         exit(1);
     }
 }
@@ -259,7 +375,7 @@ static void refresh(void) {
     /* Move cursor to original position. */
     snprintf(seq, 64, "\r\x1b[%dC", (int)(_pos + gbl_plen));
     janet_buffer_push_cstring(&b, seq);
-    if (write(STDOUT_FILENO, b.data, b.count) == -1) {
+    if (write_console((char *) b.data, b.count) == -1) {
         exit(1);
     }
     janet_buffer_deinit(&b);
@@ -285,7 +401,7 @@ static int insert(char c, int draw) {
                 if (gbl_plen + gbl_len < gbl_cols) {
                     /* Avoid a full update of the line in the
                      * trivial case. */
-                    if (write(STDOUT_FILENO, &c, 1) == -1) return -1;
+                    if (write_console(&c, 1) == -1) return -1;
                 } else {
                     refresh();
                 }
@@ -312,7 +428,7 @@ static void historymove(int delta) {
             gbl_historyi = gbl_history_count - 1;
         }
         strncpy(gbl_buf, gbl_history[gbl_historyi], JANET_LINE_MAX - 1);
-        gbl_pos = gbl_len = strlen(gbl_buf);
+        gbl_pos = gbl_len = (int) strlen(gbl_buf);
         gbl_buf[gbl_len] = '\0';
 
         refresh();
@@ -527,6 +643,7 @@ static void check_specials(JanetByteView src) {
     check_cmatch(src, "unquote");
     check_cmatch(src, "var");
     check_cmatch(src, "while");
+    check_cmatch(src, "upscope");
 }
 
 static void resolve_format(JanetTable *entry) {
@@ -740,14 +857,14 @@ static int line() {
 
     addhistory();
 
-    if (write(STDOUT_FILENO, gbl_prompt, gbl_plen) == -1) return -1;
+    if (write_console((char *) gbl_prompt, gbl_plen) == -1) return -1;
     for (;;) {
         char c;
         char seq[3];
 
         int rc;
         do {
-            rc = read(STDIN_FILENO, &c, 1);
+            rc = read_console(&c, 1);
         } while (rc < 0 && errno == EINTR);
         if (rc <= 0) return -1;
 
@@ -764,8 +881,13 @@ static int line() {
                 kleft();
                 break;
             case 3:     /* ctrl-c */
+                clearlines();
                 norawmode();
+#ifdef _WIN32
+                ExitProcess(1);
+#else
                 kill(getpid(), SIGINT);
+#endif
             /* fallthrough */
             case 17:    /* ctrl-q */
                 gbl_cancel_current_repl_form = 1;
@@ -826,23 +948,25 @@ static int line() {
             case 23: /* ctrl-w */
                 kbackspacew();
                 break;
+#ifndef _WIN32
             case 26: /* ctrl-z */
                 norawmode();
                 kill(getpid(), SIGSTOP);
                 rawmode();
                 refresh();
                 break;
+#endif
             case 27:    /* escape sequence */
                 /* Read the next two bytes representing the escape sequence.
                  * Use two calls to handle slow terminals returning the two
                  * chars at different times. */
-                if (read(STDIN_FILENO, seq, 1) == -1) break;
+                if (read_console(seq, 1) == -1) break;
                 /* Esc[ = Control Sequence Introducer (CSI) */
                 if (seq[0] == '[') {
-                    if (read(STDIN_FILENO, seq + 1, 1) == -1) break;
+                    if (read_console(seq + 1, 1) == -1) break;
                     if (seq[1] >= '0' && seq[1] <= '9') {
                         /* Extended escape, read additional byte. */
-                        if (read(STDIN_FILENO, seq + 2, 1) == -1) break;
+                        if (read_console(seq + 2, 1) == -1) break;
                         if (seq[2] == '~') {
                             switch (seq[1]) {
                                 case '1': /* Home */
@@ -861,7 +985,7 @@ static int line() {
                             }
                         }
                     } else if (seq[0] == 'O') {
-                        if (read(STDIN_FILENO, seq + 1, 1) == -1) break;
+                        if (read_console(seq + 1, 1) == -1) break;
                         switch (seq[1]) {
                             default:
                                 break;
@@ -944,28 +1068,12 @@ void janet_line_deinit() {
     gbl_historyi = 0;
 }
 
-static int checktermsupport() {
-    const char *t = getenv("TERM");
-    int i;
-    if (!t) return 1;
-    for (i = 0; badterms[i]; i++)
-        if (!strcmp(t, badterms[i])) return 0;
-    return 1;
-}
-
 void janet_line_get(const char *p, JanetBuffer *buffer) {
     gbl_prompt = p;
     buffer->count = 0;
     gbl_historyi = 0;
+    if (check_simpleline(buffer)) return;
     FILE *out = janet_dynfile("err", stderr);
-    if (!isatty(STDIN_FILENO) || !checktermsupport()) {
-        simpleline(buffer);
-        return;
-    }
-    if (rawmode()) {
-        simpleline(buffer);
-        return;
-    }
     if (line()) {
         norawmode();
         fputc('\n', out);
@@ -981,6 +1089,13 @@ void janet_line_get(const char *p, JanetBuffer *buffer) {
     replacehistory();
 }
 
+static void clear_at_exit(void) {
+    if (!gbl_israwmode) {
+        clearlines();
+        norawmode();
+    }
+}
+
 #endif
 
 /*
@@ -993,18 +1108,11 @@ int main(int argc, char **argv) {
     JanetTable *env;
 
 #ifdef _WIN32
-    /* Enable color console on windows 10 console and utf8 output. */
-    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
-    DWORD dwMode = 0;
-    GetConsoleMode(hOut, &dwMode);
-    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-    SetConsoleMode(hOut, dwMode);
-    SetConsoleOutputCP(65001);
+    setup_console_output();
 #endif
 
-#if !defined(JANET_WINDOWS) && !defined(JANET_SIMPLE_GETLINE)
-    /* Try and not leave the terminal in a bad state */
-    atexit(norawmode);
+#if !defined(JANET_SIMPLE_GETLINE)
+    atexit(clear_at_exit);
 #endif
 
 #if defined(JANET_PRF)

test/suite0009.janet

@@ -164,36 +164,26 @@
 
   (:close s))
 
-(defn check-matching-names [stream]
-  (def ln (net/localname stream))
-  (def pn (net/peername stream))
-  (def [my-ip my-port] ln)
-  (def [remote-ip remote-port] pn)
-  (def msg (string my-ip " " my-port " " remote-ip " " remote-port))
-  (def buf @"")
-  (ev/gather
-    (net/write stream msg)
-    (net/read stream 1024 buf))
-  (def comparison (string/split " " buf))
-  (assert (and (= my-ip (get comparison 2))
-               (= (string my-port) (get comparison 3))
-               (= remote-ip (get comparison 0))
-               (= (string remote-port) (get comparison 1)))
-          (string/format "localname should match peername: msg=%j, buf=%j" msg buf)))
-
 # Test on both server and client
 (defn names-handler
   [stream]
   (defer (:close stream)
-    (check-matching-names stream)))
+    # prevent immediate close
+    (ev/read stream 1)
+    (def [host port] (net/localname stream))
+    (assert (= host "127.0.0.1") "localname host server")
+    (assert (= port 8000) "localname port server")))
 
 # Test localname and peername
-(repeat 20
+(repeat 10
   (with [s (net/server "127.0.0.1" "8000" names-handler)]
-    (defn test-names []
+    (repeat 10
       (with [conn (net/connect "127.0.0.1" "8000")]
-        (check-matching-names conn)))
-    (repeat 20 (test-names)))
+        (def [host port] (net/peername conn))
+        (assert (= host "127.0.0.1") "peername host client ")
+        (assert (= port 8000) "peername port client")
+        # let server close
+        (ev/write conn " "))))
   (gccollect))
 
 # Create pipe

test/suite0011.janet

@@ -87,5 +87,20 @@
 
 (assert (= 15 (named-arguments :bob 3 :sally 5 :joe 7)) "named arguments 1")
 
+(defn named-opt-arguments
+  [&opt x &named a b c]
+  (+ x a b c))
+
+(assert (= 10 (named-opt-arguments 1 :a 2 :b 3 :c 4)) "named arguments 2")
+
+(let [b @""]
+  (defn dummy [a b c]
+    (+ a b c))
+  (trace dummy)
+  (defn errout [arg]
+    (buffer/push b arg))
+  (assert (= 6 (with-dyns [*err* errout] (dummy 1 2 3))) "trace to custom err function")
+  (assert (deep= @"trace (dummy 1 2 3)\n" b) "trace buffer correct"))
+
 (end-suite)
 

test/suite0012.janet

@@ -28,5 +28,27 @@
 (assert (= (thunk) 1) "delay 3")
 (assert (= counter 1) "delay 4")
 
+(def has-ffi (dyn 'ffi/native))
+
+# FFI check
+(compwhen has-ffi
+  (ffi/context))
+(compwhen has-ffi
+  (ffi/defbind memcpy :ptr [dest :ptr src :ptr n :size]))
+(compwhen has-ffi
+  (def buffer1 @"aaaa")
+  (def buffer2 @"bbbb")
+  (memcpy buffer1 buffer2 4)
+  (assert (= (string buffer1) "bbbb") "ffi 1 - memcpy"))
+
+(compwhen has-ffi
+  (assert (= 8 (ffi/size [:int :char])) "size unpacked struct 1")
+  (assert (= 5 (ffi/size [:pack :int :char])) "size packed struct 1")
+  (assert (= 5 (ffi/size [:int :pack-all :char])) "size packed struct 2")
+  (assert (= 4 (ffi/align [:int :char])) "align 1")
+  (assert (= 1 (ffi/align [:pack :int :char])) "align 2")
+  (assert (= 1 (ffi/align [:int :char :pack-all])) "align 3")
+  (assert (= 26 (ffi/size [:char :pack :int @[:char 21]])) "array struct size"))
+
 (end-suite)
 

test/suite0013.janet

@@ -0,0 +1,30 @@
+# Copyright (c) 2022 Calvin Rose & contributors
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+(import ./helper :prefix "" :exit true)
+(start-suite 13)
+
+(assert (deep= (tabseq [i :in (range 3)] i (* 3 i))
+               @{0 0 1 3 2 6}))
+
+(assert (deep= (tabseq [i :in (range 3)] i)
+               @{}))
+
+(end-suite)