Added a getter to the new pointer type.

We moved the literals true and false into one tag
type, so we an extra tag for raw pointer types
(light userdata). These can be used from the C API via
janet_wrap_pointer and janet_unwrap_pointer.

.builds/.freebsd.yaml

@@ -1,4 +1,4 @@
-image: freebsd
+image: freebsd/latest
 packages:
   - gmake
   - gcc
@@ -9,3 +9,5 @@ tasks:
       cd janet
       gmake CC=gcc
       gmake test CC=gcc
+      sudo gmake install CC=gcc
+      gmake test-install CC=gcc

.travis.yml

@@ -2,6 +2,8 @@ language: c
 script:
 - make
 - make test
+- sudo make install
+- make test-install
 - make build/janet-${TRAVIS_TAG}-${TRAVIS_OS_NAME}.tar.gz
 compiler:
 - clang

CHANGELOG.md

@@ -1,7 +1,27 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
-## 0.4.0 - ??
+## 0.4.1 latest - ??
+- Add array/remove function
+
+## 0.4.0 - 2019-03-08
+- Fix a number of smaller bugs
+- Added :export option to import and require
+- Added typed arrays
+- Remove `callable?`.
+- Remove `tuple/append` and `tuple/prepend`, which may have seemed like `O(1)`
+  operations. Instead, use the `splice` special to extend tuples.
+- Add `-m` flag to main client to allow specifying where to load
+  system modules from.
+- Add `-c` flag to main client to allow compiling Janet modules to images.
+- Add `string/format` and `buffer/format`.
+- Remove `string/pretty` and `string/number`.
+- `make-image` function creates pre compiled images for janet. These images
+  link to the core library. They can be loaded via require or manually via
+  `load-image`.
+- Add bracketed tuples as tuple constructor.
+- Add partition function to core library.
+- Pre-compile core library into an image for faster startup.
 - Add methods to parser values that mirror the api.
 - Add janet\_getmethod to CAPI for easier use of method like syntax.
 - Add get/set to abstract types to allow them to behave more

CONTRIBUTING.md

@@ -29,7 +29,12 @@ may require changes before being merged.
   run tests with `make test`. If you want to add a new test suite, simply add a file to
   the test folder and make sure it is run when`make test` is invoked.
 * Be consistent with the style. For C this means follow the indentation and style in
-  other files (files have MIT license at top, 4 spaces indentation, no trailing whitespace, cuddled brackets, etc.)
+  other files (files have MIT license at top, 4 spaces indentation, no trailing
+          whitespace, cuddled brackets, etc.) Use `make format` to
+  automatically format your C code with
+  [astyle](http://astyle.sourceforge.net/astyle.html). You will probably need
+  to install this, but it can be installed with most package managers.
+
   For janet code, the use lisp indentation with 2 spaces. One can use janet.vim to
   do this indentation, or approximate as close as possible.
 
@@ -39,7 +44,6 @@ 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 Variable Length Arrays (yes these may work in newer MSVC compilers)
 * No `restrict` 
 * Certain functions in the standard library are not always available
 
@@ -51,6 +55,11 @@ Code should compile warning free and run valgrind clean. I find that these two c
 of the easiest ways to protect against a large number of bugs in an unsafe language like C. To check for
 valgrind errors, run `make valtest` and check the output for undefined or flagged behavior.
 
+### Formatting
+
+Use [astyle](http://astyle.sourceforge.net/astyle.html) via `make format` to
+ensure a consistent code style for C.
+
 ## Janet style
 
 All janet code in the project should be formatted similar to the code in core.janet.

Makefile

@@ -24,33 +24,33 @@
 
 PREFIX?=/usr/local
 
-INCLUDEDIR=$(PREFIX)/include/janet
-LIBDIR=$(PREFIX)/lib
+INCLUDEDIR=$(PREFIX)/include
 BINDIR=$(PREFIX)/bin
 JANET_BUILD?="\"$(shell git log --pretty=format:'%h' -n 1)\""
+CLIBS=-lm
+JANET_TARGET=build/janet
+JANET_LIBRARY=build/libjanet.so
+JANET_PATH?=$(PREFIX)/lib/janet
+MANPATH?=$(PREFIX)/share/man/man1/
+DEBUGGER=gdb
 
 CFLAGS=-std=c99 -Wall -Wextra -Isrc/include -fpic -O2 -fvisibility=hidden \
 	   -DJANET_BUILD=$(JANET_BUILD)
-CLIBS=-lm -ldl
-JANET_TARGET=build/janet
-JANET_LIBRARY=build/libjanet.so
-JANET_PATH?=/usr/local/lib/janet
-DEBUGGER=gdb
+LDFLAGS=-rdynamic
 
+# Check OS
 UNAME:=$(shell uname -s)
-LDCONFIG:=ldconfig
 ifeq ($(UNAME), Darwin)
-	# Add other macos/clang flags
-	LDCONFIG:=
-else
-	CFLAGS:=$(CFLAGS) -rdynamic
-	CLIBS:=$(CLIBS) -lrt
+	CLIBS:=$(CLIBS) -ldl
+else ifeq ($(UNAME), Linux)
+	CLIBS:=$(CLIBS) -lrt -ldl
 endif
+# For other unix likes, add flags here!
 
 $(shell mkdir -p build/core build/mainclient build/webclient build/boot)
 
 # Source headers
-JANET_HEADERS=$(sort $(wildcard src/include/janet/*.h))
+JANET_HEADERS=$(sort $(wildcard src/include/*.h))
 JANET_LOCAL_HEADERS=$(sort $(wildcard src/*/*.h))
 
 # Source files
@@ -64,7 +64,8 @@ all: $(JANET_TARGET) $(JANET_LIBRARY)
 ##### The bootstrap interpreter that compiles the core image #####
 ##################################################################
 
-JANET_BOOT_OBJECTS=$(patsubst src/%.c,build/%.boot.o,$(JANET_CORE_SOURCES) src/boot/boot.c) \
+JANET_BOOT_SOURCES=$(sort $(wildcard src/boot/*.c))
+JANET_BOOT_OBJECTS=$(patsubst src/%.c,build/%.boot.o,$(JANET_CORE_SOURCES) $(JANET_BOOT_SOURCES)) \
 	build/core.gen.o \
 	build/boot.gen.o
 
@@ -76,7 +77,7 @@ build/janet_boot: $(JANET_BOOT_OBJECTS)
 
 # Now the reason we bootstrap in the first place
 build/core_image.c: build/janet_boot
-	build/janet_boot
+	JANET_PATH=$(JANET_PATH) build/janet_boot
 
 ##########################################################
 ##### The main interpreter program and shared object #####
@@ -93,10 +94,10 @@ build/%.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS)
 	$(CC) $(CFLAGS) -o $@ -c $<
 
 $(JANET_TARGET): $(JANET_CORE_OBJECTS) $(JANET_MAINCLIENT_OBJECTS)
-	$(CC) $(CFLAGS) -o $@ $^ $(CLIBS)
+	$(CC) $(LDFLAGS) $(CFLAGS) -o $@ $^ $(CLIBS)
 
 $(JANET_LIBRARY): $(JANET_CORE_OBJECTS)
-	$(CC) $(CFLAGS) -shared -o $@ $^ $(CLIBS)
+	$(CC) $(LDFLAGS) $(CFLAGS) -shared -o $@ $^ $(CLIBS)
 
 ######################
 ##### Emscripten #####
@@ -155,7 +156,7 @@ amalg: build/janet.c build/janet.h build/core_image.c
 build/janet.c: $(JANET_LOCAL_HEADERS) $(JANET_CORE_SOURCES) tools/amalg.janet $(JANET_TARGET)
 	$(JANET_TARGET) tools/amalg.janet > $@
 
-build/janet.h: src/include/janet/janet.h
+build/janet.h: src/include/janet.h
 	cp $< $@
 
 ###################
@@ -176,13 +177,13 @@ valgrind: $(JANET_TARGET)
 	$(VALGRIND_COMMAND) ./$(JANET_TARGET)
 
 test: $(JANET_TARGET) $(TEST_PROGRAMS)
-	for f in test/*.janet; do ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do ./$(JANET_TARGET) "$$f" || exit; done
 
 valtest: $(JANET_TARGET) $(TEST_PROGRAMS)
-	for f in test/*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
 
 callgrind: $(JANET_TARGET)
-	for f in test/*.janet; do valgrind --tool=callgrind ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do valgrind --tool=callgrind ./$(JANET_TARGET) "$$f" || exit; done
 
 ########################
 ##### Distribution #####
@@ -190,7 +191,7 @@ callgrind: $(JANET_TARGET)
 
 dist: build/janet-dist.tar.gz
 
-build/janet-%.tar.gz: $(JANET_TARGET) src/include/janet/janet.h \
+build/janet-%.tar.gz: $(JANET_TARGET) src/include/janet.h \
 	janet.1 LICENSE CONTRIBUTING.md $(JANET_LIBRARY) \
 	build/doc.html README.md build/janet.c
 	tar -czvf $@ $^
@@ -208,6 +209,13 @@ build/doc.html: $(JANET_TARGET) tools/gendoc.janet
 ##### Other #####
 #################
 
+STYLEOPTS=--style=attach --indent-switches --convert-tabs \
+		  --align-pointer=name --pad-header --pad-oper --unpad-paren --indent-labels
+format:
+	astyle $(STYLEOPTS) */*.c
+	astyle $(STYLEOPTS) */*/*.c
+	astyle $(STYLEOPTS) */*/*.h
+
 grammar: build/janet.tmLanguage
 build/janet.tmLanguage: tools/tm_lang_gen.janet $(JANET_TARGET)
 	$(JANET_TARGET) $< > $@
@@ -220,21 +228,22 @@ install: $(JANET_TARGET)
 	cp $(JANET_TARGET) $(BINDIR)/janet
 	mkdir -p $(INCLUDEDIR)
 	cp $(JANET_HEADERS) $(INCLUDEDIR)
-	mkdir -p $(LIBDIR)
-	cp $(JANET_LIBRARY) $(LIBDIR)/libjanet.so
+	mkdir -p $(INCLUDEDIR)/janet
 	mkdir -p $(JANET_PATH)
+	ln -sf $(INCLUDEDIR)/janet.h $(INCLUDEDIR)/janet/janet.h
+	ln -sf $(INCLUDEDIR)/janet.h $(JANET_PATH)/janet.h
 	cp tools/cook.janet $(JANET_PATH)
 	cp tools/highlight.janet $(JANET_PATH)
-	cp janet.1 /usr/local/share/man/man1/
-	mandb
-	$(LDCONFIG)
+	cp tools/bars.janet $(JANET_PATH)
+	mkdir -p $(MANPATH)
+	cp janet.1 $(MANPATH)
+
+test-install:
+	cd test/install && rm -rf build && janet test
 
 uninstall:
 	-rm $(BINDIR)/../$(JANET_TARGET)
-	-rm $(LIBDIR)/../$(JANET_LIBRARY)
 	-rm -rf $(INCLUDEDIR)
-	$(LDCONFIG)
 
 .PHONY: clean install repl debug valgrind test amalg \
-	valtest emscripten dist uninstall docs grammar \
-	$(TEST_PROGRAM_PHONIES) $(TEST_PROGRAM_VALPHONIES)
+	valtest emscripten dist uninstall docs grammar format

README.md

@@ -1,14 +1,15 @@
 [![Join the chat](https://badges.gitter.im/janet-language/community.svg)](https://gitter.im/janet-language/community)
  
+[![Appveyor Status](https://ci.appveyor.com/api/projects/status/bjraxrxexmt3sxyv/branch/master?svg=true)](https://ci.appveyor.com/project/bakpakin/janet/branch/master)
 [![Build Status](https://travis-ci.org/janet-lang/janet.svg?branch=master)](https://travis-ci.org/janet-lang/janet)
-[![Appveyor Status](https://ci.appveyor.com/api/projects/status/32r7s2skrgm9ubva?svg=true)](https://ci.appveyor.com/project/janet-lang/janet)
+[![builds.sr.ht status](https://builds.sr.ht/~bakpakin/janet/.freebsd.yaml.svg)](https://builds.sr.ht/~bakpakin/janet/.freebsd.yaml?)
 
 <img src="https://raw.githubusercontent.com/janet-lang/janet/master/assets/janet-w200.png" alt="Janet logo" width=200 align="left">
 
 **Janet** is a functional and imperative programming language and bytecode interpreter. It is a
 modern lisp, but lists are replaced
 by other data structures with better utility and performance (arrays, tables, structs, tuples).
-The language also bridging bridging to native code written in C, meta-programming with macros, and bytecode assembly.
+The language also supports bridging to native code written in C, meta-programming with macros, and bytecode assembly.
 
 There is a repl for trying out the language, as well as the ability
 to run script files. This client program is separate from the core runtime, so
@@ -97,7 +98,7 @@ janet:1:> (+ 1 2 3)
 janet:2:> (print "Hello, World!")
 Hello, World!
 nil
-janet:3:> (os.exit)
+janet:3:> (os/exit)
 $ ./janet -h
 usage: ./janet [options] scripts...
 Options are:

build_win.bat

@@ -39,7 +39,7 @@ mkdir build\boot
 @if errorlevel 1 goto :BUILDFAIL
 
 @rem Build the generated sources
-@%JANET_COMPILE% /Fobuild\core\core.gen.obj build\core.gen.c
+@%JANET_COMPILE% /Fobuild\boot\core.gen.obj build\core.gen.c
 @if errorlevel 1 goto :BUILDFAIL
 @%JANET_COMPILE% /Fobuild\mainclient\init.gen.obj build\init.gen.c
 @if errorlevel 1 goto :BUILDFAIL
@@ -57,6 +57,8 @@ for %%f in (src\boot\*.c) do (
 )
 %JANET_LINK% /out:build\janet_boot.exe build\boot\*.obj
 @if errorlevel 1 goto :BUILDFAIL
+set JANET_PATH="C:/Janet/Library"
+set JANET_INCLUDEDIR="C:/Janet/Include"
 build\janet_boot
 
 @rem Build the core image
@@ -122,7 +124,7 @@ copy LICENSE dist\LICENSE
 copy README.md dist\README.md
 copy janet.lib dist\janet.lib
 copy janet.exp dist\janet.exp
-copy src\include\janet\janet.h dist\janet.h
+copy src\include\janet.h dist\janet.h
 copy tools\cook.janet dist\cook.janet
 copy tools\highlight.janet dist\highlight.janet
 exit /b 0

examples/life.janet

@@ -4,11 +4,11 @@
   (seq [x :range [-1 2]
          y :range [-1 2]
          :when (not (and (zero? x) (zero? y)))]
-        (tuple x y)))
+       [x y]))
 
 (defn- neighbors
   [[x y]]
-  (map (fn [[x1 y1]] (tuple (+ x x1) (+ y y1))) window))
+  (map (fn [[x1 y1]] [(+ x x1) (+ y y1)]) window))
 
 (defn tick
   "Get the next state in the Game Of Life."
@@ -28,7 +28,7 @@
   (loop [x :range [x1 (+ 1 x2)]
          :after (print)
          y :range [y1 (+ 1 y2)]]
-    (file/write stdout (if (get cellset (tuple x y)) "X " ". ")))
+    (file/write stdout (if (get cellset [x y]) "X " ". ")))
   (print))
 
 #

examples/numarray/.gitignore

@@ -0,0 +1 @@
+/build

examples/numarray/numarray.c

@@ -1,24 +1,24 @@
 #include <stdlib.h>
-#include <janet/janet.h>
+#include <janet.h>
 
 typedef struct {
-    double * data;
+    double *data;
     size_t size;
 } num_array;
 
-static num_array * num_array_init(num_array * array,size_t size) {
-    array->data=(double *)calloc(size,sizeof(double));
-    array->size=size;
+static num_array *num_array_init(num_array *array, size_t size) {
+    array->data = (double *)calloc(size, sizeof(double));
+    array->size = size;
     return array;
 }
 
-static void num_array_deinit(num_array * array) {
+static void num_array_deinit(num_array *array) {
     free(array->data);
 }
 
 static int num_array_gc(void *p, size_t s) {
     (void) s;
-    num_array * array=(num_array *)p;
+    num_array *array = (num_array *)p;
     num_array_deinit(array);
     return 0;
 }
@@ -36,42 +36,42 @@ static const JanetAbstractType num_array_type = {
 
 static Janet num_array_new(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 1);
-    int32_t size=janet_getinteger(argv,0);
-    num_array * array = (num_array *)janet_abstract(&num_array_type,sizeof(num_array));
-    num_array_init(array,size);
+    int32_t size = janet_getinteger(argv, 0);
+    num_array *array = (num_array *)janet_abstract(&num_array_type, sizeof(num_array));
+    num_array_init(array, size);
     return janet_wrap_abstract(array);
 }
 
 static Janet num_array_scale(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
-    num_array * array = (num_array *)janet_getabstract(argv,0,&num_array_type);
-    double factor = janet_getnumber(argv,1);
+    num_array *array = (num_array *)janet_getabstract(argv, 0, &num_array_type);
+    double factor = janet_getnumber(argv, 1);
     size_t i;
-    for (i=0;i<array->size;i++) {
-        array->data[i]*=factor;
+    for (i = 0; i < array->size; i++) {
+        array->data[i] *= factor;
     }
     return argv[0];
 }
 
 static Janet num_array_sum(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 1);
-    num_array * array = (num_array *)janet_getabstract(argv,0,&num_array_type);
+    num_array *array = (num_array *)janet_getabstract(argv, 0, &num_array_type);
     double sum = 0;
-    for (size_t i=0;i<array->size;i++) sum+=array->data[i];
+    for (size_t i = 0; i < array->size; i++) sum += array->data[i];
     return janet_wrap_number(sum);
 }
 
 void num_array_put(void *p, Janet key, Janet value) {
     size_t index;
-    num_array * array=(num_array *)p;
+    num_array *array = (num_array *)p;
     if (!janet_checkint(key))
         janet_panic("expected integer key");
-    if (!janet_checktype(value,JANET_NUMBER))
+    if (!janet_checktype(value, JANET_NUMBER))
         janet_panic("expected number value");
 
     index = (size_t)janet_unwrap_integer(key);
     if (index < array->size) {
-        array->data[index]=janet_unwrap_number(value);
+        array->data[index] = janet_unwrap_number(value);
     }
 }
 
@@ -84,7 +84,7 @@ static const JanetMethod methods[] = {
 Janet num_array_get(void *p, Janet key) {
     size_t index;
     Janet value;
-    num_array * array=(num_array *)p;
+    num_array *array = (num_array *)p;
     if (janet_checktype(key, JANET_KEYWORD))
         return janet_getmethod(janet_unwrap_keyword(key), methods);
     if (!janet_checkint(key))
@@ -99,15 +99,17 @@ Janet num_array_get(void *p, Janet key) {
 }
 
 static const JanetReg cfuns[] = {
-    {"numarray/new", num_array_new, 
+    {
+        "numarray/new", num_array_new,
         "(numarray/new size)\n\n"
-            "Create new numarray"
+        "Create new numarray"
     },
-    {"numarray/scale", num_array_scale, 
+    {
+        "numarray/scale", num_array_scale,
         "(numarray/scale numarray factor)\n\n"
-            "scale numarray by factor"
+        "scale numarray by factor"
     },
-    {NULL,NULL,NULL}
+    {NULL, NULL, NULL}
 };
 
 JANET_MODULE_ENTRY(JanetTable *env) {

examples/tarray.janet

@@ -0,0 +1,83 @@
+# naive matrix implementation for testing typed array
+
+(defmacro printf [& xs] ['print ['string/format (splice xs)]])
+
+(defn matrix [nrow ncol] {:nrow nrow :ncol ncol :array (tarray/new :float64 (* nrow ncol))})
+
+(defn matrix/row [mat i]
+  (def {:nrow nrow :ncol ncol :array array} mat)
+  (tarray/new :float64 ncol 1 (* i ncol)  array))
+
+(defn matrix/column [mat j]
+  (def {:nrow nrow :ncol ncol :array array} mat)
+  (tarray/new :float64 nrow ncol j array))
+
+(defn matrix/set [mat i j value]
+  (def {:nrow nrow :ncol ncol :array array} mat)
+  (set (array (+ (* i ncol) j)) value))
+
+(defn matrix/get [mat i j value]
+  (def {:nrow nrow :ncol ncol :array array} mat)
+  (array (+ (* i ncol) j)))
+
+
+# other variants to test rows and cols views
+
+(defn matrix/set* [mat i j value]
+  (set ((matrix/row mat i) j) value))
+
+(defn matrix/set** [mat i j value]
+  (set ((matrix/column mat j) i) value))
+
+
+(defn matrix/get* [mat i j value]
+  ((matrix/row mat i) j))
+
+(defn matrix/get** [mat i j value]
+  ((matrix/column j) i))
+
+
+(defn tarray/print [array]
+  (def size (tarray/length array))
+  (def buf @"")
+  (buffer/format buf "[%2i]" size)
+  (for i 0 size
+       (buffer/format buf " %+6.3f " (array i)))
+  (print buf))
+       
+(defn matrix/print [mat]
+  (def {:nrow nrow :ncol ncol :array tarray} mat)
+  (printf "matrix %iX%i %p" nrow ncol tarray)
+  (for i 0 nrow
+       (tarray/print (matrix/row mat i))))
+
+
+(def nr 5)
+(def nc 4)
+(def A (matrix nr nc))
+
+(loop (i :range (0 nr) j :range (0 nc)) 
+      (matrix/set A i j i))
+(matrix/print A)
+
+(loop (i :range (0 nr) j :range (0 nc)) 
+      (matrix/set* A i j i))
+(matrix/print A)
+
+(loop (i :range (0 nr) j :range (0 nc)) 
+      (matrix/set** A i j i))
+(matrix/print A)
+
+
+(printf "properties:\n%p" (tarray/properties (A :array)))
+(for i 0 nr  
+     (printf "row properties:[%i]\n%p" i (tarray/properties (matrix/row A i))))
+(for i 0 nc  
+     (printf "col properties:[%i]\n%p" i (tarray/properties (matrix/column A i))))
+
+
+
+
+
+
+

janet.1

@@ -3,8 +3,11 @@
 janet \- run the Janet language abstract machine
 .SH SYNOPSIS
 .B janet
-[\fB\-hvsrp\fR]
-[\fB\-e\fR \fIJANET SOURCE\fR]
+[\fB\-hvsrpq\fR]
+[\fB\-e\fR \fISOURCE\fR]
+[\fB\-l\fR \fIMODULE\fR]
+[\fB\-m\fR \fIPATH\fR]
+[\fB\-c\fR \fIMODULE JIMAGE\fR]
 [\fB\-\-\fR]
 .IR script
 .IR args ...
@@ -16,7 +19,7 @@ to native code written in C, meta-programming with macros, and bytecode assembly
 
 There is a repl for trying out the language, as well as the ability to run script files.
 This client program is separate from the core runtime, so Janet could be embedded
-into other programs. Try Janet in your browser at https://Janet-lang.org.
+into other programs. Try Janet in your browser at https://janet-lang.org.
 
 Implemented in mostly standard C99, Janet runs on Windows, Linux and macOS.
 The few features that are not standard C99 (dynamic library loading, compiler
@@ -41,8 +44,9 @@ Shows the version text and exits immediately.
 Read raw input from stdin and forgo prompt history and other readline-like features.
 
 .TP
-.BR \-q
-Quiet output. Don't print a repl prompt or expression results to stdout.
+.BR \-e\ code
+Execute a string of Janet source. Source code is executed in the order it is encountered, so earlier
+arguments are executed before later ones.
 
 .TP
 .BR \-r
@@ -56,19 +60,31 @@ it will immediately exit after printing the error message. In persistent mode, J
 after an error. Persistent mode can be good for debugging and testing.
 
 .TP
-.BR \-e
-Execute a string of Janet source. Source code is executed in the order it is encountered, so earlier
-arguments are executed before later ones.
+.BR \-q
+Quiet output. Don't print a repl prompt or expression results to stdout.
 
 .TP
-.BR \-l
+.BR \-m\ syspath
+Set the variable module/*syspath* to the string syspath so that Janet will load system modules
+from a directory different than the default. The default is set when Janet is built, and defaults to
+/usr/local/lib/janet on Linux/Posix, and C:/Janet/Library on Windows. This option supersedes JANET_PATH.
+
+.TP
+.BR \-c\ source\ output
+Precompiles Janet source code into an image, a binary dump that can be efficiently loaded later.
+Source should be a path to the Janet module to compile, and output should be the file path of
+resulting image. Output should usually end with the .jimage extension.
+
+.TP
+.BR \-l\ path
 Load a Janet file before running a script or repl. Multiple files can be loaded
 in this manner, and exports from each file will be made available to the script
 or repl.
 
 .TP
 .BR \-\-
-Stop parsing command line arguments. All arguments after this one will be considered file names.
+Stop parsing command line arguments. All arguments after this one will be considered file names
+and then arguments to the script.
 
 .SH ENVIRONMENT
 
@@ -76,9 +92,7 @@ Stop parsing command line arguments. All arguments after this one will be consid
 .RS
 The location to look for Janet libraries. This is the only environment variable Janet needs to
 find native and source code modules. If no JANET_PATH is set, Janet will look in
-/usr/local/lib/Janet for modules.
-To make Janet search multiple locations, modify the module.paths
-array in Janet.
+the default location set at compile time.
 .RE
 
 .SH AUTHOR

src/boot/array_test.c

@@ -20,16 +20,16 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <assert.h>
 
-int main() {
+#include "tests.h"
+
+int array_test() {
 
     int i;
     JanetArray *array1, *array2;
 
-    janet_init();
-
     array1 = janet_array(10);
     array2 = janet_array(0);
 
@@ -62,7 +62,5 @@ int main() {
 
     assert(array1->count == 5);
 
-    janet_deinit();
-
     return 0;
 }

src/boot/boot.c

@@ -20,18 +20,31 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
+#include "tests.h"
 
 extern const unsigned char *janet_gen_boot;
 extern int32_t janet_gen_boot_size;
 
 int main() {
+
+    /* Init janet */
+    janet_init();
+
+    /* Run tests */
+    array_test();
+    buffer_test();
+    number_test();
+    system_test();
+    table_test();
+
+    /* C tests passed */
+
+    /* Set up VM */
     int status;
     JanetTable *env;
 
-    /* Set up VM */
-    janet_init();
-    env = janet_core_env();
+    env = janet_core_env(NULL);
 
     /* Run bootstrap script to generate core image */
     status = janet_dobytes(env, janet_gen_boot, janet_gen_boot_size, "boot.janet", NULL);

src/boot/boot.janet

@@ -25,16 +25,18 @@
   # Create C source file that contains images a uint8_t buffer. This
   # can be compiled and linked statically into the main janet library
   # and example client.
-  (def chunks (seq [b :in image] (string b)))
+  (def chunks (string/bytes image))
   (def image-file (file/open "build/core_image.c" :w))
   (file/write image-file
-              "#include <janet/janet.h>\n"
-              "static const unsigned char janet_core_image_bytes[] = {")
-  (loop [line :in (partition 16 chunks)]
-    (def str (string ;(interpose ", " line)))
-    (file/write image-file str ",\n"))
+              "#ifndef JANET_AMALG\n"
+              "#include <janet.h>\n"
+              "#endif\n"
+              "static const unsigned char janet_core_image_bytes[] = {\n")
+  (loop [line :in (partition 10 chunks)]
+    (def str (string ;(interpose ", " (map (partial string/format "0x%.2X") line))))
+    (file/write image-file "    " str ",\n"))
   (file/write image-file
-              "0};\n\n"
+              "    0\n};\n\n"
               "const unsigned char *janet_core_image = janet_core_image_bytes;\n"
               "size_t janet_core_image_size = sizeof(janet_core_image_bytes);\n")
   (file/close image-file))

src/boot/buffer_test.c

@@ -20,16 +20,16 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <assert.h>
 
-int main() {
+#include "tests.h"
+
+int buffer_test() {
 
     int i;
     JanetBuffer *buffer1, *buffer2;
 
-    janet_init();
-
     buffer1 = janet_buffer(100);
     buffer2 = janet_buffer(0);
 
@@ -58,7 +58,5 @@ int main() {
         assert(buffer1->data[i] == buffer2->data[i]);
     }
 
-    janet_deinit();
-
     return 0;
 }

src/boot/number_test.c

@@ -20,11 +20,13 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
 
+#include "tests.h"
+
 /* Check a subset of numbers against system implementation.
  * Note that this depends on the system implementation being correct,
  * which may not be the case for old or non compliant systems. Also,
@@ -36,14 +38,12 @@ static void test_valid_str(const char *str) {
     double cnum, jnum;
     jnum = 0.0;
     cnum = atof(str);
-    err = janet_scan_number((const uint8_t *) str, strlen(str), &jnum);
+    err = janet_scan_number((const uint8_t *) str, (int32_t) strlen(str), &jnum);
     assert(!err);
     assert(cnum == jnum);
 }
 
-int main() {
-
-    janet_init();
+int number_test() {
 
     test_valid_str("1.0");
     test_valid_str("1");
@@ -63,7 +63,5 @@ int main() {
     test_valid_str("0000000011111111111111111111111111");
     test_valid_str(".112312333333323123123123123123123");
 
-    janet_deinit();
-
     return 0;
 }

src/boot/system_test.c

@@ -20,11 +20,13 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <assert.h>
 #include <stdio.h>
 
-int main() {
+#include "tests.h"
+
+int system_test() {
 
 #ifdef JANET_32
     assert(sizeof(void *) == 4);
@@ -32,8 +34,6 @@ int main() {
     assert(sizeof(void *) == 8);
 #endif
 
-    janet_init();
-
     /* Reflexive testing and nanbox testing */
     assert(janet_equals(janet_wrap_nil(), janet_wrap_nil()));
     assert(janet_equals(janet_wrap_false(), janet_wrap_false()));
@@ -48,7 +48,5 @@ int main() {
     assert(janet_equals(janet_cstringv("a string."), janet_cstringv("a string.")));
     assert(janet_equals(janet_csymbolv("sym"), janet_csymbolv("sym")));
 
-    janet_deinit();
-
     return 0;
 }

src/boot/table_test.c

@@ -20,15 +20,15 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <assert.h>
 
-int main() {
+#include "tests.h"
+
+int table_test() {
 
     JanetTable *t1, *t2;
 
-    janet_init();
-
     t1 = janet_table(10);
     t2 = janet_table(0);
 
@@ -61,7 +61,5 @@ int main() {
     assert(janet_equals(janet_table_get(t2, janet_csymbolv("t2key1")), janet_wrap_integer(10)));
     assert(janet_equals(janet_table_get(t2, janet_csymbolv("t2key2")), janet_wrap_integer(100)));
 
-    janet_deinit();
-
     return 0;
 }

src/boot/tests.h

@@ -0,0 +1,11 @@
+#ifndef TESTS_H_DNMBUYYL
+#define TESTS_H_DNMBUYYL
+
+/* Tests */
+extern int array_test();
+extern int buffer_test();
+extern int number_test();
+extern int system_test();
+extern int table_test();
+
+#endif /* end of include guard: TESTS_H_DNMBUYYL */

src/core/abstract.c

@@ -21,16 +21,15 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "gc.h"
 #endif
 
 /* Create new userdata */
 void *janet_abstract(const JanetAbstractType *atype, size_t size) {
-    char *data = janet_gcalloc(JANET_MEMORY_ABSTRACT, sizeof(JanetAbstractHeader) + size);
-    JanetAbstractHeader *header = (JanetAbstractHeader *)data;
-    void *a = data + sizeof(JanetAbstractHeader);
+    JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_ABSTRACT,
+                                sizeof(JanetAbstractHead) + size);
     header->size = size;
     header->type = atype;
-    return a;
+    return (void *) & (header->data);
 }

src/core/array.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "gc.h"
 #include "util.h"
 #endif
@@ -165,7 +165,8 @@ static Janet cfun_array_slice(int32_t argc, Janet *argv) {
     JanetRange range = janet_getslice(argc, argv);
     JanetView view = janet_getindexed(argv, 0);
     JanetArray *array = janet_array(range.end - range.start);
-    memcpy(array->data, view.items + range.start, sizeof(Janet) * (range.end - range.start));
+    if (array->data)
+        memcpy(array->data, view.items + range.start, sizeof(Janet) * (range.end - range.start));
     array->count = range.end - range.start;
     return janet_wrap_array(array);
 }
@@ -180,15 +181,14 @@ static Janet cfun_array_concat(int32_t argc, Janet *argv) {
                 janet_array_push(array, argv[i]);
                 break;
             case JANET_ARRAY:
-            case JANET_TUPLE:
-                {
-                    int32_t j, len;
-                    const Janet *vals;
-                    janet_indexed_view(argv[i], &vals, &len);
-                    for (j = 0; j < len; j++)
-                        janet_array_push(array, vals[j]);
-                }
-                break;
+            case JANET_TUPLE: {
+                int32_t j, len;
+                const Janet *vals;
+                janet_indexed_view(argv[i], &vals, &len);
+                for (j = 0; j < len; j++)
+                    janet_array_push(array, vals[j]);
+            }
+            break;
         }
     }
     return janet_wrap_array(array);
@@ -212,55 +212,95 @@ static Janet cfun_array_insert(int32_t argc, Janet *argv) {
             restsize);
     memcpy(array->data + at, argv + 2, chunksize);
     array->count += (argc - 2);
-    return janet_wrap_array(array);
+    return argv[0];
+}
+
+static Janet cfun_array_remove(int32_t argc, Janet *argv) {
+    janet_arity(argc, 2, 3);
+    JanetArray *array = janet_getarray(argv, 0);
+    int32_t at = janet_getinteger(argv, 1);
+    int32_t n = 1;
+    if (at < 0) {
+        at = array->count + at + 1;
+    }
+    if (at < 0 || at > array->count)
+        janet_panicf("removal index %d out of range [0,%d]", at, array->count);
+    if (argc == 3) {
+        n = janet_getinteger(argv, 2);
+        if (n < 0)
+            janet_panicf("expected non-negative integer for argument n, got %v", argv[2]);
+    }
+    if (at + n > array->count) {
+        n = array->count - at;
+    }
+    memmove(array->data + at,
+            array->data + at + n,
+            (array->count - at - n) * sizeof(Janet));
+    array->count -= n;
+    return argv[0];
 }
 
 static const JanetReg array_cfuns[] = {
-    {"array/new", cfun_array_new,
+    {
+        "array/new", cfun_array_new,
         JDOC("(array/new capacity)\n\n"
-                "Creates a new empty array with a pre-allocated capacity. The same as "
-                "(array) but can be more efficient if the maximum size of an array is known.")
+             "Creates a new empty array with a pre-allocated capacity. The same as "
+             "(array) but can be more efficient if the maximum size of an array is known.")
     },
-    {"array/pop", cfun_array_pop,
+    {
+        "array/pop", cfun_array_pop,
         JDOC("(array/pop arr)\n\n"
-                "Remove the last element of the array and return it. If the array is empty, will return nil. Modifies "
-                "the input array.")
+             "Remove the last element of the array and return it. If the array is empty, will return nil. Modifies "
+             "the input array.")
     },
-    {"array/peek", cfun_array_peek,
+    {
+        "array/peek", cfun_array_peek,
         JDOC("(array/peek arr)\n\n"
-                "Returns the last element of the array. Does not modify the array.")
+             "Returns the last element of the array. Does not modify the array.")
     },
-    {"array/push", cfun_array_push,
+    {
+        "array/push", cfun_array_push,
         JDOC("(array/push arr x)\n\n"
-                "Insert an element in the end of an array. Modifies the input array and returns it.")
+             "Insert an element in the end of an array. Modifies the input array and returns it.")
     },
-    {"array/ensure", cfun_array_ensure,
+    {
+        "array/ensure", cfun_array_ensure,
         JDOC("(array/ensure arr capacity)\n\n"
-                "Ensures that the memory backing the array has enough memory for capacity "
-                "items. Capacity must be an integer. If the backing capacity is already enough, "
-                "then this function does nothing. Otherwise, the backing memory will be reallocated "
-                "so that there is enough space.")
+             "Ensures that the memory backing the array has enough memory for capacity "
+             "items. Capacity must be an integer. If the backing capacity is already enough, "
+             "then this function does nothing. Otherwise, the backing memory will be reallocated "
+             "so that there is enough space.")
     },
-    {"array/slice", cfun_array_slice,
+    {
+        "array/slice", cfun_array_slice,
         JDOC("(array/slice arrtup [, start=0 [, end=(length arrtup)]])\n\n"
-                "Takes a slice of array or tuple from start to end. The range is half open, "
-                "[start, end). Indexes can also be negative, indicating indexing from the end of the "
-                "end of the array. By default, start is 0 and end is the length of the array. "
-                "Returns a new array.")
+             "Takes a slice of array or tuple from start to end. The range is half open, "
+             "[start, end). Indexes can also be negative, indicating indexing from the end of the "
+             "end of the array. By default, start is 0 and end is the length of the array. "
+             "Returns a new array.")
     },
-    {"array/concat", cfun_array_concat,
+    {
+        "array/concat", cfun_array_concat,
         JDOC("(array/concat arr & parts)\n\n"
-                "Concatenates a variadic number of arrays (and tuples) into the first argument "
-                "which must an array. If any of the parts are arrays or tuples, their elements will "
-                "be inserted into the array. Otherwise, each part in parts will be appended to arr in order. "
-                "Return the modified array arr.")
+             "Concatenates a variadic number of arrays (and tuples) into the first argument "
+             "which must an array. If any of the parts are arrays or tuples, their elements will "
+             "be inserted into the array. Otherwise, each part in parts will be appended to arr in order. "
+             "Return the modified array arr.")
     },
-    {"array/insert", cfun_array_insert,
+    {
+        "array/insert", cfun_array_insert,
         JDOC("(array/insert arr at & xs)\n\n"
-                "Insert all of xs into array arr at index at. at should be an integer "
-                "0 and the length of the array. A negative value for at will index from "
-                "the end of the array, such that inserting at -1 appends to the array. "
-                "Returns the array.")
+             "Insert all of xs into array arr at index at. at should be an integer "
+             "0 and the length of the array. A negative value for at will index from "
+             "the end of the array, such that inserting at -1 appends to the array. "
+             "Returns the array.")
+    },
+    {
+        "array/remove", cfun_array_remove,
+        JDOC("(array/remove arr at [, n=1])\n\n"
+             "Remove up to n elements starting at index at in array arr. at can index from "
+             "the end of the array with a negative index, and n must be a non-negative integer. "
+             "Returns the array.")
     },
     {NULL, NULL, NULL}
 };

src/core/asm.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "util.h"
 #endif
 
@@ -147,19 +147,18 @@ static const TypeAlias type_aliases[] = {
     {"callable", JANET_TFLAG_CALLABLE},
     {"cfunction", JANET_TFLAG_CFUNCTION},
     {"dictionary", JANET_TFLAG_DICTIONARY},
-    {"false", JANET_TFLAG_FALSE},
     {"fiber", JANET_TFLAG_FIBER},
     {"function", JANET_TFLAG_FUNCTION},
     {"indexed", JANET_TFLAG_INDEXED},
+    {"keyword", JANET_TFLAG_KEYWORD},
     {"nil", JANET_TFLAG_NIL},
     {"number", JANET_TFLAG_NUMBER},
+    {"pointer", JANET_TFLAG_POINTER},
     {"string", JANET_TFLAG_STRING},
     {"struct", JANET_TFLAG_STRUCT},
     {"symbol", JANET_TFLAG_SYMBOL},
-    {"keyword", JANET_TFLAG_KEYWORD},
-    {"table", JANET_TFLAG_BOOLEAN},
-    {"true", JANET_TFLAG_TRUE},
-    {"tuple", JANET_TFLAG_BOOLEAN}
+    {"table", JANET_TFLAG_TABLE},
+    {"tuple", JANET_TFLAG_TUPLE}
 };
 
 /* Deinitialize an Assembler. Does not deinitialize the parents. */
@@ -224,9 +223,9 @@ static int32_t janet_asm_addenv(JanetAssembler *a, Janet envname) {
 /* Parse an argument to an assembly instruction, and return the result as an
  * integer. This integer will need to be bounds checked. */
 static int32_t doarg_1(
-        JanetAssembler *a,
-        enum JanetOpArgType argtype,
-        Janet x) {
+    JanetAssembler *a,
+    enum JanetOpArgType argtype,
+    Janet x) {
     int32_t ret = -1;
     JanetTable *c;
     switch (argtype) {
@@ -253,8 +252,7 @@ static int32_t doarg_1(
         default:
             goto error;
             break;
-        case JANET_NUMBER:
-        {
+        case JANET_NUMBER: {
             double y = janet_unwrap_number(x);
             if (janet_checkintrange(y)) {
                 ret = (int32_t) y;
@@ -263,8 +261,7 @@ static int32_t doarg_1(
             }
             break;
         }
-        case JANET_TUPLE:
-        {
+        case JANET_TUPLE: {
             const Janet *t = janet_unwrap_tuple(x);
             if (argtype == JANET_OAT_TYPE) {
                 int32_t i = 0;
@@ -277,8 +274,7 @@ static int32_t doarg_1(
             }
             break;
         }
-        case JANET_KEYWORD:
-        {
+        case JANET_KEYWORD: {
             if (NULL != c && argtype == JANET_OAT_LABEL) {
                 Janet result = janet_table_get(c, x);
                 if (janet_checktype(result, JANET_NUMBER)) {
@@ -288,10 +284,10 @@ static int32_t doarg_1(
                 }
             } else if (argtype == JANET_OAT_TYPE || argtype == JANET_OAT_SIMPLETYPE) {
                 const TypeAlias *alias = janet_strbinsearch(
-                            &type_aliases,
-                            sizeof(type_aliases)/sizeof(TypeAlias),
-                            sizeof(TypeAlias),
-                            janet_unwrap_keyword(x));
+                                             &type_aliases,
+                                             sizeof(type_aliases) / sizeof(TypeAlias),
+                                             sizeof(TypeAlias),
+                                             janet_unwrap_keyword(x));
                 if (alias) {
                     ret = alias->mask;
                 } else {
@@ -302,8 +298,7 @@ static int32_t doarg_1(
             }
             break;
         }
-        case JANET_SYMBOL:
-        {
+        case JANET_SYMBOL: {
             if (NULL != c) {
                 Janet result = janet_table_get(c, x);
                 if (janet_checktype(result, JANET_NUMBER)) {
@@ -328,7 +323,7 @@ static int32_t doarg_1(
         a->def->slotcount = (int32_t) ret + 1;
     return ret;
 
-    error:
+error:
     janet_asm_errorv(a, janet_formatc("error parsing instruction argument %v", x));
     return 0;
 }
@@ -336,12 +331,12 @@ static int32_t doarg_1(
 /* Parse a single argument to an instruction. Trims it as well as
  * try to convert arguments to bit patterns */
 static uint32_t doarg(
-        JanetAssembler *a,
-        enum JanetOpArgType argtype,
-        int nth,
-        int nbytes,
-        int hassign,
-        Janet x) {
+    JanetAssembler *a,
+    enum JanetOpArgType argtype,
+    int nth,
+    int nbytes,
+    int hassign,
+    Janet x) {
     int32_t arg = doarg_1(a, argtype, x);
     /* Calculate the min and max values that can be stored given
      * nbytes, and whether or not the storage is signed */
@@ -349,59 +344,53 @@ static uint32_t doarg(
     int32_t min = hassign ? -max - 1 : 0;
     if (arg < min)
         janet_asm_errorv(a, janet_formatc("instruction argument %v is too small, must be %d byte%s",
-                    x, nbytes, nbytes > 1 ? "s" : ""));
+                                          x, nbytes, nbytes > 1 ? "s" : ""));
     if (arg > max)
         janet_asm_errorv(a, janet_formatc("instruction argument %v is too large, must be %d byte%s",
-                    x, nbytes, nbytes > 1 ? "s" : ""));
+                                          x, nbytes, nbytes > 1 ? "s" : ""));
     return ((uint32_t) arg) << (nth << 3);
 }
 
 /* Provide parsing methods for the different kinds of arguments */
 static uint32_t read_instruction(
-        JanetAssembler *a,
-        const JanetInstructionDef *idef,
-        const Janet *argt) {
+    JanetAssembler *a,
+    const JanetInstructionDef *idef,
+    const Janet *argt) {
     uint32_t instr = idef->opcode;
     enum JanetInstructionType type = janet_instructions[idef->opcode];
     switch (type) {
-        case JINT_0:
-        {
+        case JINT_0: {
             if (janet_tuple_length(argt) != 1)
                 janet_asm_error(a, "expected 0 arguments: (op)");
             break;
         }
-        case JINT_S:
-        {
+        case JINT_S: {
             if (janet_tuple_length(argt) != 2)
                 janet_asm_error(a, "expected 1 argument: (op, slot)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 2, 0, argt[1]);
             break;
         }
-        case JINT_L:
-        {
+        case JINT_L: {
             if (janet_tuple_length(argt) != 2)
                 janet_asm_error(a, "expected 1 argument: (op, label)");
             instr |= doarg(a, JANET_OAT_LABEL, 1, 3, 1, argt[1]);
             break;
         }
-        case JINT_SS:
-        {
+        case JINT_SS: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, slot)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
             instr |= doarg(a, JANET_OAT_SLOT, 2, 2, 0, argt[2]);
             break;
         }
-        case JINT_SL:
-        {
+        case JINT_SL: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, label)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
             instr |= doarg(a, JANET_OAT_LABEL, 2, 2, 1, argt[2]);
             break;
         }
-        case JINT_ST:
-        {
+        case JINT_ST: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, type)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
@@ -409,24 +398,21 @@ static uint32_t read_instruction(
             break;
         }
         case JINT_SI:
-        case JINT_SU:
-        {
+        case JINT_SU: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, integer)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
             instr |= doarg(a, JANET_OAT_INTEGER, 2, 2, type == JINT_SI, argt[2]);
             break;
         }
-        case JINT_SD:
-        {
+        case JINT_SD: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, funcdef)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
             instr |= doarg(a, JANET_OAT_FUNCDEF, 2, 2, 0, argt[2]);
             break;
         }
-        case JINT_SSS:
-        {
+        case JINT_SSS: {
             if (janet_tuple_length(argt) != 4)
                 janet_asm_error(a, "expected 3 arguments: (op, slot, slot, slot)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
@@ -435,8 +421,7 @@ static uint32_t read_instruction(
             break;
         }
         case JINT_SSI:
-        case JINT_SSU:
-        {
+        case JINT_SSU: {
             if (janet_tuple_length(argt) != 4)
                 janet_asm_error(a, "expected 3 arguments: (op, slot, slot, integer)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
@@ -444,8 +429,7 @@ static uint32_t read_instruction(
             instr |= doarg(a, JANET_OAT_INTEGER, 3, 1, type == JINT_SSI, argt[3]);
             break;
         }
-        case JINT_SES:
-        {
+        case JINT_SES: {
             JanetAssembler *b = a;
             uint32_t env;
             if (janet_tuple_length(argt) != 4)
@@ -461,8 +445,7 @@ static uint32_t read_instruction(
             instr |= doarg(b, JANET_OAT_SLOT, 3, 1, 0, argt[3]);
             break;
         }
-        case JINT_SC:
-        {
+        case JINT_SC: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, constant)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
@@ -528,9 +511,9 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     }
 
     janet_asm_assert(&a,
-            janet_checktype(s, JANET_STRUCT) ||
-            janet_checktype(s, JANET_TABLE),
-            "expected struct or table for assembly source");
+                     janet_checktype(s, JANET_STRUCT) ||
+                     janet_checktype(s, JANET_TABLE),
+                     "expected struct or table for assembly source");
 
     /* Check for function name */
     a.name = janet_get1(s, janet_csymbolv("name"));
@@ -541,15 +524,20 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     /* Set function arity */
     x = janet_get1(s, janet_csymbolv("arity"));
     def->arity = janet_checkint(x) ? janet_unwrap_integer(x) : 0;
+    janet_asm_assert(&a, def->arity >= 0, "arity must be non-negative");
+
+    x = janet_get1(s, janet_csymbolv("max-arity"));
+    def->max_arity = janet_checkint(x) ? janet_unwrap_integer(x) : def->arity;
+    janet_asm_assert(&a, def->max_arity >= def->arity, "max-arity must be greater than or equal to arity");
+
+    x = janet_get1(s, janet_csymbolv("min-arity"));
+    def->min_arity = janet_checkint(x) ? janet_unwrap_integer(x) : def->arity;
+    janet_asm_assert(&a, def->min_arity <= def->arity, "min-arity must be less than or equal to arity");
 
     /* Check vararg */
     x = janet_get1(s, janet_csymbolv("vararg"));
     if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_VARARG;
 
-    /* Check strict arity */
-    x = janet_get1(s, janet_csymbolv("fix-arity"));
-    if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_FIXARITY;
-
     /* Check source */
     x = janet_get1(s, janet_csymbolv("source"));
     if (janet_checktype(x, JANET_STRING)) def->source = janet_unwrap_string(x);
@@ -586,16 +574,16 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
         for (i = 0; i < count; i++) {
             Janet ct = arr[i];
             if (janet_checktype(ct, JANET_TUPLE) &&
-                janet_tuple_length(janet_unwrap_tuple(ct)) > 1 &&
-                janet_checktype(janet_unwrap_tuple(ct)[0], JANET_SYMBOL)) {
+                    janet_tuple_length(janet_unwrap_tuple(ct)) > 1 &&
+                    janet_checktype(janet_unwrap_tuple(ct)[0], JANET_SYMBOL)) {
                 const Janet *t = janet_unwrap_tuple(ct);
                 int32_t tcount = janet_tuple_length(t);
                 const uint8_t *macro = janet_unwrap_symbol(t[0]);
                 if (0 == janet_cstrcmp(macro, "quote")) {
                     def->constants[i] = t[1];
                 } else if (tcount == 3 &&
-                        janet_checktype(t[1], JANET_SYMBOL) &&
-                        0 == janet_cstrcmp(macro, "def")) {
+                           janet_checktype(t[1], JANET_SYMBOL) &&
+                           0 == janet_cstrcmp(macro, "def")) {
                     def->constants[i] = t[2];
                     janet_table_put(&a.constants, t[1], janet_wrap_integer(i));
                 } else {
@@ -658,7 +646,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
         }
         /* Allocate bytecode array */
         def->bytecode_length = blength;
-        def->bytecode = malloc(sizeof(int32_t) * blength);
+        def->bytecode = malloc(sizeof(uint32_t) * blength);
         if (NULL == def->bytecode) {
             JANET_OUT_OF_MEMORY;
         }
@@ -678,12 +666,12 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
                     op = 0;
                 } else {
                     janet_asm_assert(&a, janet_checktype(t[0], JANET_SYMBOL),
-                            "expected symbol in assembly instruction");
+                                     "expected symbol in assembly instruction");
                     idef = janet_strbinsearch(
-                            &janet_ops,
-                            sizeof(janet_ops)/sizeof(JanetInstructionDef),
-                            sizeof(JanetInstructionDef),
-                            janet_unwrap_symbol(t[0]));
+                               &janet_ops,
+                               sizeof(janet_ops) / sizeof(JanetInstructionDef),
+                               sizeof(JanetInstructionDef),
+                               janet_unwrap_symbol(t[0]));
                     if (NULL == idef)
                         janet_asm_errorv(&a, janet_formatc("unknown instruction %v", t[0]));
                     op = read_instruction(&a, idef, t);
@@ -750,7 +738,7 @@ JanetAssembleResult janet_asm(Janet source, int flags) {
 static const JanetInstructionDef *janet_asm_reverse_lookup(uint32_t instr) {
     size_t i;
     uint32_t opcode = instr & 0x7F;
-    for (i = 0; i < sizeof(janet_ops)/sizeof(JanetInstructionDef); i++) {
+    for (i = 0; i < sizeof(janet_ops) / sizeof(JanetInstructionDef); i++) {
         const JanetInstructionDef *def = janet_ops + i;
         if (def->opcode == opcode)
             return def;
@@ -808,25 +796,25 @@ Janet janet_asm_decode_instruction(uint32_t instr) {
         case JINT_SU:
         case JINT_SD:
             return tup3(name,
-                    janet_wrap_integer(oparg(1, 0xFF)),
-                    janet_wrap_integer(oparg(2, 0xFFFF)));
+                        janet_wrap_integer(oparg(1, 0xFF)),
+                        janet_wrap_integer(oparg(2, 0xFFFF)));
         case JINT_SI:
         case JINT_SL:
             return tup3(name,
-                    janet_wrap_integer(oparg(1, 0xFF)),
-                    janet_wrap_integer((int32_t)instr >> 16));
+                        janet_wrap_integer(oparg(1, 0xFF)),
+                        janet_wrap_integer((int32_t)instr >> 16));
         case JINT_SSS:
         case JINT_SES:
         case JINT_SSU:
             return tup4(name,
-                    janet_wrap_integer(oparg(1, 0xFF)),
-                    janet_wrap_integer(oparg(2, 0xFF)),
-                    janet_wrap_integer(oparg(3, 0xFF)));
+                        janet_wrap_integer(oparg(1, 0xFF)),
+                        janet_wrap_integer(oparg(2, 0xFF)),
+                        janet_wrap_integer(oparg(3, 0xFF)));
         case JINT_SSI:
             return tup4(name,
-                    janet_wrap_integer(oparg(1, 0xFF)),
-                    janet_wrap_integer(oparg(2, 0xFF)),
-                    janet_wrap_integer((int32_t)instr >> 24));
+                        janet_wrap_integer(oparg(1, 0xFF)),
+                        janet_wrap_integer(oparg(2, 0xFF)),
+                        janet_wrap_integer((int32_t)instr >> 24));
     }
 #undef oparg
     return janet_wrap_nil();
@@ -838,6 +826,8 @@ Janet janet_disasm(JanetFuncDef *def) {
     JanetArray *constants;
     JanetTable *ret = janet_table(10);
     janet_table_put(ret, janet_csymbolv("arity"), janet_wrap_integer(def->arity));
+    janet_table_put(ret, janet_csymbolv("min-arity"), janet_wrap_integer(def->min_arity));
+    janet_table_put(ret, janet_csymbolv("max-arity"), janet_wrap_integer(def->max_arity));
     janet_table_put(ret, janet_csymbolv("bytecode"), janet_wrap_array(bcode));
     if (NULL != def->source) {
         janet_table_put(ret, janet_csymbolv("source"), janet_wrap_string(def->source));
@@ -845,9 +835,6 @@ Janet janet_disasm(JanetFuncDef *def) {
     if (def->flags & JANET_FUNCDEF_FLAG_VARARG) {
         janet_table_put(ret, janet_csymbolv("vararg"), janet_wrap_true());
     }
-    if (def->flags & JANET_FUNCDEF_FLAG_FIXARITY) {
-        janet_table_put(ret, janet_csymbolv("fix-arity"), janet_wrap_true());
-    }
     if (NULL != def->name) {
         janet_table_put(ret, janet_csymbolv("name"), janet_wrap_string(def->name));
     }
@@ -934,17 +921,19 @@ static Janet cfun_disasm(int32_t argc, Janet *argv) {
 }
 
 static const JanetReg asm_cfuns[] = {
-    {"asm", cfun_asm,
+    {
+        "asm", cfun_asm,
         JDOC("(asm assembly)\n\n"
-                "Returns a new function that is the compiled result of the assembly.\n"
-                "The syntax for the assembly can be found on the janet wiki. Will throw an\n"
-                "error on invalid assembly.")
+             "Returns a new function that is the compiled result of the assembly.\n"
+             "The syntax for the assembly can be found on the janet wiki. Will throw an\n"
+             "error on invalid assembly.")
     },
-    {"disasm", cfun_disasm,
+    {
+        "disasm", cfun_disasm,
         JDOC("(disasm func)\n\n"
-                "Returns assembly that could be used be compile the given function.\n"
-                "func must be a function, not a c function. Will throw on error on a badly\n"
-                "typed argument.")
+             "Returns assembly that could be used be compile the given function.\n"
+             "func must be a function, not a c function. Will throw on error on a badly\n"
+             "typed argument.")
     },
     {NULL, NULL, NULL}
 };

src/core/buffer.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "gc.h"
 #include "util.h"
 #endif
@@ -172,7 +172,8 @@ static Janet cfun_buffer_new_filled(int32_t argc, Janet *argv) {
         byte = janet_getinteger(argv, 1) & 0xFF;
     }
     JanetBuffer *buffer = janet_buffer(count);
-    memset(buffer->data, byte, count);
+    if (buffer->data)
+        memset(buffer->data, byte, count);
     buffer->count = count;
     return janet_wrap_buffer(buffer);
 }
@@ -182,7 +183,7 @@ static Janet cfun_buffer_u8(int32_t argc, Janet *argv) {
     janet_arity(argc, 1, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     for (i = 1; i < argc; i++) {
-        janet_buffer_push_u8(buffer, (uint8_t) (janet_getinteger(argv, i) & 0xFF));
+        janet_buffer_push_u8(buffer, (uint8_t)(janet_getinteger(argv, i) & 0xFF));
     }
     return argv[0];
 }
@@ -236,7 +237,8 @@ static Janet cfun_buffer_slice(int32_t argc, Janet *argv) {
     JanetRange range = janet_getslice(argc, argv);
     JanetByteView view = janet_getbytes(argv, 0);
     JanetBuffer *buffer = janet_buffer(range.end - range.start);
-    memcpy(buffer->data, view.bytes + range.start, range.end - range.start);
+    if (buffer->data)
+        memcpy(buffer->data, view.bytes + range.start, range.end - range.start);
     buffer->count = range.end - range.start;
     return janet_wrap_buffer(buffer);
 }
@@ -317,71 +319,98 @@ static Janet cfun_buffer_blit(int32_t argc, Janet *argv) {
     return argv[0];
 }
 
+static Janet cfun_buffer_format(int32_t argc, Janet *argv) {
+    janet_arity(argc, 2, -1);
+    JanetBuffer *buffer = janet_getbuffer(argv, 0);
+    const char *strfrmt = (const char *) janet_getstring(argv, 1);
+    janet_buffer_format(buffer, strfrmt, 1, argc, argv);
+    return argv[0];
+}
+
 static const JanetReg buffer_cfuns[] = {
-    {"buffer/new", cfun_buffer_new,
+    {
+        "buffer/new", cfun_buffer_new,
         JDOC("(buffer/new capacity)\n\n"
-                "Creates a new, empty buffer with enough memory for capacity bytes. "
-                "Returns a new buffer.")
+             "Creates a new, empty buffer with enough memory for capacity bytes. "
+             "Returns a new buffer.")
     },
-    {"buffer/new-filled", cfun_buffer_new_filled,
+    {
+        "buffer/new-filled", cfun_buffer_new_filled,
         JDOC("(buffer/new-filled count [, byte=0])\n\n"
-                "Creates a new buffer of length count filled with byte. "
-                "Returns the new buffer.")
+             "Creates a new buffer of length count filled with byte. "
+             "Returns the new buffer.")
     },
-    {"buffer/push-byte", cfun_buffer_u8,
+    {
+        "buffer/push-byte", cfun_buffer_u8,
         JDOC("(buffer/push-byte buffer x)\n\n"
-                "Append a byte to a buffer. Will expand the buffer as necessary. "
-                "Returns the modified buffer. Will throw an error if the buffer overflows.")
+             "Append a byte to a buffer. Will expand the buffer as necessary. "
+             "Returns the modified buffer. Will throw an error if the buffer overflows.")
     },
-    {"buffer/push-word", cfun_buffer_word,
+    {
+        "buffer/push-word", cfun_buffer_word,
         JDOC("(buffer/push-word buffer x)\n\n"
-                "Append a machine word to a buffer. The 4 bytes of the integer are appended "
-                "in twos complement, big endian order, unsigned. Returns the modified buffer. Will "
-                "throw an error if the buffer overflows.")
+             "Append a machine word to a buffer. The 4 bytes of the integer are appended "
+             "in twos complement, big endian order, unsigned. Returns the modified buffer. Will "
+             "throw an error if the buffer overflows.")
     },
-    {"buffer/push-string", cfun_buffer_chars,
+    {
+        "buffer/push-string", cfun_buffer_chars,
         JDOC("(buffer/push-string buffer str)\n\n"
-                "Push a string onto the end of a buffer. Non string values will be converted "
-                "to strings before being pushed. Returns the modified buffer. "
-                "Will throw an error if the buffer overflows.")
+             "Push a string onto the end of a buffer. Non string values will be converted "
+             "to strings before being pushed. Returns the modified buffer. "
+             "Will throw an error if the buffer overflows.")
     },
-    {"buffer/popn", cfun_buffer_popn,
+    {
+        "buffer/popn", cfun_buffer_popn,
         JDOC("(buffer/popn buffer n)\n\n"
-                "Removes the last n bytes from the buffer. Returns the modified buffer.")
+             "Removes the last n bytes from the buffer. Returns the modified buffer.")
     },
-    {"buffer/clear", cfun_buffer_clear,
+    {
+        "buffer/clear", cfun_buffer_clear,
         JDOC("(buffer/clear buffer)\n\n"
-                "Sets the size of a buffer to 0 and empties it. The buffer retains "
-                "its memory so it can be efficiently refilled. Returns the modified buffer.")
+             "Sets the size of a buffer to 0 and empties it. The buffer retains "
+             "its memory so it can be efficiently refilled. Returns the modified buffer.")
     },
-    {"buffer/slice", cfun_buffer_slice,
+    {
+        "buffer/slice", cfun_buffer_slice,
         JDOC("(buffer/slice bytes [, start=0 [, end=(length bytes)]])\n\n"
-                "Takes a slice of a byte sequence from start to end. The range is half open, "
-                "[start, end). Indexes can also be negative, indicating indexing from the end of the "
-                "end of the array. By default, start is 0 and end is the length of the buffer. "
-                "Returns a new buffer.")
+             "Takes a slice of a byte sequence from start to end. The range is half open, "
+             "[start, end). Indexes can also be negative, indicating indexing from the end of the "
+             "end of the array. By default, start is 0 and end is the length of the buffer. "
+             "Returns a new buffer.")
     },
-    {"buffer/bit-set", cfun_buffer_bitset,
+    {
+        "buffer/bit-set", cfun_buffer_bitset,
         JDOC("(buffer/bit-set buffer index)\n\n"
-                "Sets the bit at the given bit-index. Returns the buffer.")
+             "Sets the bit at the given bit-index. Returns the buffer.")
     },
-    {"buffer/bit-clear", cfun_buffer_bitclear,
+    {
+        "buffer/bit-clear", cfun_buffer_bitclear,
         JDOC("(buffer/bit-clear buffer index)\n\n"
-                "Clears the bit at the given bit-index. Returns the buffer.")
+             "Clears the bit at the given bit-index. Returns the buffer.")
     },
-    {"buffer/bit", cfun_buffer_bitget,
+    {
+        "buffer/bit", cfun_buffer_bitget,
         JDOC("(buffer/bit buffer index)\n\n"
-                "Gets the bit at the given bit-index. Returns true if the bit is set, false if not.")
+             "Gets the bit at the given bit-index. Returns true if the bit is set, false if not.")
     },
-    {"buffer/bit-toggle", cfun_buffer_bittoggle,
+    {
+        "buffer/bit-toggle", cfun_buffer_bittoggle,
         JDOC("(buffer/bit-toggle buffer index)\n\n"
-                "Toggles the bit at the given bit index in buffer. Returns the buffer.")
+             "Toggles the bit at the given bit index in buffer. Returns the buffer.")
     },
-    {"buffer/blit", cfun_buffer_blit,
+    {
+        "buffer/blit", cfun_buffer_blit,
         JDOC("(buffer/blit dest src [, dest-start=0 [, src-start=0 [, src-end=-1]]])\n\n"
-                "Insert the contents of src into dest. Can optionally take indices that "
-                "indicate which part of src to copy into which part of dest. Indices can be "
-                "negative to index from the end of src or dest. Returns dest.")
+             "Insert the contents of src into dest. Can optionally take indices that "
+             "indicate which part of src to copy into which part of dest. Indices can be "
+             "negative to index from the end of src or dest. Returns dest.")
+    },
+    {
+        "buffer/format", cfun_buffer_format,
+        JDOC("(buffer/format buffer format & args)\n\n"
+             "Snprintf like functionality for printing values into a buffer. Returns "
+             " the modified buffer.")
     },
     {NULL, NULL, NULL}
 };

src/core/bytecode.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "gc.h"
 #endif
 
@@ -118,72 +118,62 @@ int32_t janet_verify(JanetFuncDef *def) {
         switch (type) {
             case JINT_0:
                 continue;
-            case JINT_S:
-                {
-                    if ((int32_t)(instr >> 8) >= sc) return 4;
-                    continue;
-                }
+            case JINT_S: {
+                if ((int32_t)(instr >> 8) >= sc) return 4;
+                continue;
+            }
             case JINT_SI:
             case JINT_SU:
-            case JINT_ST:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    continue;
-                }
-            case JINT_L:
-                {
-                    int32_t jumpdest = i + (((int32_t)instr) >> 8);
-                    if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5;
-                    continue;
-                }
-            case JINT_SS:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc ||
+            case JINT_ST: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                continue;
+            }
+            case JINT_L: {
+                int32_t jumpdest = i + (((int32_t)instr) >> 8);
+                if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5;
+                continue;
+            }
+            case JINT_SS: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc ||
                         (int32_t)(instr >> 16) >= sc) return 4;
-                    continue;
-                }
+                continue;
+            }
             case JINT_SSI:
-            case JINT_SSU:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc ||
+            case JINT_SSU: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc ||
                         (int32_t)((instr >> 16) & 0xFF) >= sc) return 4;
-                    continue;
-                }
-            case JINT_SL:
-                {
-                    int32_t jumpdest = i + (((int32_t)instr) >> 16);
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5;
-                    continue;
-                }
-            case JINT_SSS:
-                {
-                    if (((int32_t)(instr >> 8) & 0xFF) >= sc ||
+                continue;
+            }
+            case JINT_SL: {
+                int32_t jumpdest = i + (((int32_t)instr) >> 16);
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5;
+                continue;
+            }
+            case JINT_SSS: {
+                if (((int32_t)(instr >> 8) & 0xFF) >= sc ||
                         ((int32_t)(instr >> 16) & 0xFF) >= sc ||
                         ((int32_t)(instr >> 24) & 0xFF) >= sc) return 4;
-                    continue;
-                }
-            case JINT_SD:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    if ((int32_t)(instr >> 16) >= def->defs_length) return 6;
-                    continue;
-                }
-            case JINT_SC:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    if ((int32_t)(instr >> 16) >= def->constants_length) return 7;
-                    continue;
-                }
-            case JINT_SES:
-                {
-                    /* How can we check the last slot index? We need info parent funcdefs. Resort
-                     * to runtime checks for now. Maybe invalid upvalue references could be defaulted
-                     * to nil? (don't commit to this in the long term, though) */
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8;
-                    continue;
-                }
+                continue;
+            }
+            case JINT_SD: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                if ((int32_t)(instr >> 16) >= def->defs_length) return 6;
+                continue;
+            }
+            case JINT_SC: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                if ((int32_t)(instr >> 16) >= def->constants_length) return 7;
+                continue;
+            }
+            case JINT_SES: {
+                /* How can we check the last slot index? We need info parent funcdefs. Resort
+                 * to runtime checks for now. Maybe invalid upvalue references could be defaulted
+                 * to nil? (don't commit to this in the long term, though) */
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8;
+                continue;
+            }
         }
     }
 
@@ -218,6 +208,8 @@ JanetFuncDef *janet_funcdef_alloc() {
     def->flags = 0;
     def->slotcount = 0;
     def->arity = 0;
+    def->min_arity = 0;
+    def->max_arity = INT32_MAX;
     def->source = NULL;
     def->sourcemap = NULL;
     def->name = NULL;

src/core/capi.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "state.h"
 #include "fiber.h"
 #endif
@@ -95,16 +95,8 @@ DEFINE_GETTER(buffer, BUFFER, JanetBuffer *)
 DEFINE_GETTER(fiber, FIBER, JanetFiber *)
 DEFINE_GETTER(function, FUNCTION, JanetFunction *)
 DEFINE_GETTER(cfunction, CFUNCTION, JanetCFunction)
-
-int janet_getboolean(const Janet *argv, int32_t n) {
-    Janet x = argv[n];
-    if (janet_checktype(x, JANET_TRUE)) {
-        return 1;
-    } else if (!janet_checktype(x, JANET_FALSE)) {
-        janet_panicf("bad slot #%d, expected boolean, got %v", n, x);
-    }
-    return 0;
-}
+DEFINE_GETTER(boolean, BOOLEAN, int)
+DEFINE_GETTER(pointer, POINTER, void *)
 
 int32_t janet_getinteger(const Janet *argv, int32_t n) {
     Janet x = argv[n];
@@ -122,6 +114,14 @@ int64_t janet_getinteger64(const Janet *argv, int32_t n) {
     return (int64_t) janet_unwrap_number(x);
 }
 
+size_t janet_getsize(const Janet *argv, int32_t n) {
+    Janet x = argv[n];
+    if (!janet_checksize(x)) {
+        janet_panicf("bad slot #%d, expected size, got %v", n, x);
+    }
+    return (size_t) janet_unwrap_number(x);
+}
+
 int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which) {
     int32_t raw = janet_getinteger(argv, n);
     if (raw < 0) raw += length + 1;

src/core/cfuns.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "compile.h"
 #include "emit.h"
 #include "vector.h"
@@ -64,10 +64,10 @@ static JanetSlot genericSSI(JanetFopts opts, int op, JanetSlot s, int32_t imm) {
 
 /* Emit a series of instructions instead of a function call to a math op */
 static JanetSlot opreduce(
-        JanetFopts opts,
-        JanetSlot *args,
-        int op,
-        Janet nullary) {
+    JanetFopts opts,
+    JanetSlot *args,
+    int op,
+    Janet nullary) {
     JanetCompiler *c = opts.compiler;
     int32_t i, len;
     len = janet_v_count(args);
@@ -125,9 +125,9 @@ static JanetSlot do_apply(JanetFopts opts, JanetSlot *args) {
     JanetCompiler *c = opts.compiler;
     int32_t i;
     for (i = 1; i < janet_v_count(args) - 3; i += 3)
-        janetc_emit_sss(c, JOP_PUSH_3, args[i], args[i+1], args[i+2], 0);
+        janetc_emit_sss(c, JOP_PUSH_3, args[i], args[i + 1], args[i + 2], 0);
     if (i == janet_v_count(args) - 3)
-        janetc_emit_ss(c, JOP_PUSH_2, args[i], args[i+1], 0);
+        janetc_emit_ss(c, JOP_PUSH_2, args[i], args[i + 1], 0);
     else if (i == janet_v_count(args) - 2)
         janetc_emit_s(c, JOP_PUSH, args[i], 0);
     /* Push array phase */
@@ -183,10 +183,10 @@ static JanetSlot do_bnot(JanetFopts opts, JanetSlot *args) {
 
 /* Specialization for comparators */
 static JanetSlot compreduce(
-        JanetFopts opts,
-        JanetSlot *args,
-        int op,
-        int invert) {
+    JanetFopts opts,
+    JanetSlot *args,
+    int op,
+    int invert) {
     JanetCompiler *c = opts.compiler;
     int32_t i, len;
     len = janet_v_count(args);
@@ -194,8 +194,8 @@ static JanetSlot compreduce(
     JanetSlot t;
     if (len < 2) {
         return invert
-            ? janetc_cslot(janet_wrap_false())
-            : janetc_cslot(janet_wrap_true());
+               ? janetc_cslot(janet_wrap_false())
+               : janetc_cslot(janet_wrap_true());
     }
     t = janetc_gettarget(opts);
     for (i = 1; i < len; i++) {
@@ -297,7 +297,7 @@ const JanetFunOptimizer *janetc_funopt(uint32_t flags) {
     if (tag == 0)
         return NULL;
     uint32_t index = tag - 1;
-    if (index >= (sizeof(optimizers)/sizeof(optimizers[0])))
+    if (index >= (sizeof(optimizers) / sizeof(optimizers[0])))
         return NULL;
     return optimizers + index;
 }

src/core/compile.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "compile.h"
 #include "emit.h"
 #include "vector.h"
@@ -97,7 +97,6 @@ void janetc_scope(JanetScope *s, JanetCompiler *c, int flags, const char *name)
     scope.syms = NULL;
     scope.envs = NULL;
     scope.defs = NULL;
-    scope.selfconst = -1;
     scope.bytecode_start = janet_v_count(c->buffer);
     scope.flags = flags;
     scope.parent = c->scope;
@@ -166,8 +165,8 @@ void janetc_popscope_keepslot(JanetCompiler *c, JanetSlot retslot) {
 
 /* Allow searching for symbols. Return information about the symbol */
 JanetSlot janetc_resolve(
-        JanetCompiler *c,
-        const uint8_t *sym) {
+    JanetCompiler *c,
+    const uint8_t *sym) {
 
     JanetSlot ret = janetc_cslot(janet_wrap_nil());
     JanetScope *scope = c->scope;
@@ -206,8 +205,7 @@ JanetSlot janetc_resolve(
             case JANET_BINDING_DEF:
             case JANET_BINDING_MACRO: /* Macro should function like defs when not in calling pos */
                 return janetc_cslot(check);
-            case JANET_BINDING_VAR:
-            {
+            case JANET_BINDING_VAR: {
                 JanetSlot ret = janetc_cslot(check);
                 /* TODO save type info */
                 ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOT_MUTABLE | JANET_SLOTTYPE_ANY;
@@ -218,7 +216,7 @@ JanetSlot janetc_resolve(
     }
 
     /* Symbol was found */
-    found:
+found:
 
     /* Constants can be returned immediately (they are stateless) */
     if (ret.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF))
@@ -283,8 +281,8 @@ JanetSlot janetc_return(JanetCompiler *c, JanetSlot s) {
 JanetSlot janetc_gettarget(JanetFopts opts) {
     JanetSlot slot;
     if ((opts.flags & JANET_FOPTS_HINT) &&
-        (opts.hint.envindex < 0) &&
-        (opts.hint.index >= 0 && opts.hint.index <= 0xFF)) {
+            (opts.hint.envindex < 0) &&
+            (opts.hint.index >= 0 && opts.hint.index <= 0xFF)) {
         slot = opts.hint;
     } else {
         slot.envindex = -1;
@@ -334,17 +332,17 @@ void janetc_pushslots(JanetCompiler *c, JanetSlot *slots) {
             i++;
         } else if (slots[i + 1].flags & JANET_SLOT_SPLICED) {
             janetc_emit_s(c, JOP_PUSH, slots[i], 0);
-            janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i+1], 0);
+            janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i + 1], 0);
             i += 2;
         } else if (i + 2 == count) {
-            janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i+1], 0);
+            janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0);
             i += 2;
         } else if (slots[i + 2].flags & JANET_SLOT_SPLICED) {
-            janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i+1], 0);
-            janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i+2], 0);
+            janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0);
+            janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i + 2], 0);
             i += 3;
         } else {
-            janetc_emit_sss(c, JOP_PUSH_3, slots[i], slots[i+1], slots[i+2], 0);
+            janetc_emit_sss(c, JOP_PUSH_3, slots[i], slots[i + 1], slots[i + 2], 0);
             i += 3;
         }
     }
@@ -434,15 +432,23 @@ static JanetSlot janetc_array(JanetFopts opts, Janet x) {
     JanetCompiler *c = opts.compiler;
     JanetArray *a = janet_unwrap_array(x);
     return janetc_maker(opts,
-            janetc_toslots(c, a->data, a->count),
-            JOP_MAKE_ARRAY);
+                        janetc_toslots(c, a->data, a->count),
+                        JOP_MAKE_ARRAY);
+}
+
+static JanetSlot janetc_tuple(JanetFopts opts, Janet x) {
+    JanetCompiler *c = opts.compiler;
+    const Janet *t = janet_unwrap_tuple(x);
+    return janetc_maker(opts,
+                        janetc_toslots(c, t, janet_tuple_length(t)),
+                        JOP_MAKE_TUPLE);
 }
 
 static JanetSlot janetc_tablector(JanetFopts opts, Janet x, int op) {
     JanetCompiler *c = opts.compiler;
     return janetc_maker(opts,
-            janetc_toslotskv(c, x),
-            op);
+                        janetc_toslotskv(c, x),
+                        op);
 }
 
 static JanetSlot janetc_bufferctor(JanetFopts opts, Janet x) {
@@ -450,17 +456,17 @@ static JanetSlot janetc_bufferctor(JanetFopts opts, Janet x) {
     JanetBuffer *b = janet_unwrap_buffer(x);
     Janet onearg = janet_stringv(b->data, b->count);
     return janetc_maker(opts,
-            janetc_toslots(c, &onearg, 1),
-            JOP_MAKE_BUFFER);
+                        janetc_toslots(c, &onearg, 1),
+                        JOP_MAKE_BUFFER);
 }
 
 /* Expand a macro one time. Also get the special form compiler if we
  * find that instead. */
 static int macroexpand1(
-        JanetCompiler *c,
-        Janet x,
-        Janet *out,
-        const JanetSpecial **spec) {
+    JanetCompiler *c,
+    Janet x,
+    Janet *out,
+    const JanetSpecial **spec) {
     if (!janet_checktype(x, JANET_TUPLE))
         return 0;
     const Janet *form = janet_unwrap_tuple(x);
@@ -471,6 +477,9 @@ static int macroexpand1(
         c->current_mapping.start = janet_tuple_sm_start(form);
         c->current_mapping.end = janet_tuple_sm_end(form);
     }
+    /* Bracketed tuples are not specials or macros! */
+    if (janet_tuple_flag(form) & JANET_TUPLE_FLAG_BRACKETCTOR)
+        return 0;
     if (!janet_checktype(form[0], JANET_SYMBOL))
         return 0;
     const uint8_t *name = janet_unwrap_symbol(form[0]);
@@ -486,15 +495,15 @@ static int macroexpand1(
         return 0;
 
     /* Evaluate macro */
-    JanetFiber *fiberp;
+    JanetFiber *fiberp = NULL;
     JanetFunction *macro = janet_unwrap_function(macroval);
     int lock = janet_gclock();
     JanetSignal status = janet_pcall(
-            macro,
-            janet_tuple_length(form) - 1,
-            form + 1,
-            &x,
-            &fiberp);
+                             macro,
+                             janet_tuple_length(form) - 1,
+                             form + 1,
+                             &x,
+                             &fiberp);
     janet_gcunlock(lock);
     if (status != JANET_SIGNAL_OK) {
         const uint8_t *es = janet_formatc("(macro) %V", x);
@@ -540,22 +549,23 @@ JanetSlot janetc_value(JanetFopts opts, Janet x) {
         ret = spec->compile(opts, janet_tuple_length(tup) - 1, tup + 1);
     } else {
         switch (janet_type(x)) {
-            case JANET_TUPLE:
-                {
-                    JanetFopts subopts = janetc_fopts_default(c);
-                    const Janet *tup = janet_unwrap_tuple(x);
-                    /* Empty tuple is tuple literal */
-                    if (janet_tuple_length(tup) == 0) {
-                        ret = janetc_cslot(x);
-                    } else {
-                        JanetSlot head = janetc_value(subopts, tup[0]);
-                        subopts.flags = JANET_FUNCTION | JANET_CFUNCTION;
-                        ret = janetc_call(opts, janetc_toslots(c, tup + 1, janet_tuple_length(tup) - 1), head);
-                        janetc_freeslot(c, head);
-                    }
-                    ret.flags &= ~JANET_SLOT_SPLICED;
+            case JANET_TUPLE: {
+                JanetFopts subopts = janetc_fopts_default(c);
+                const Janet *tup = janet_unwrap_tuple(x);
+                /* Empty tuple is tuple literal */
+                if (janet_tuple_length(tup) == 0) {
+                    ret = janetc_cslot(x);
+                } else if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { /* [] tuples are not function call */
+                    ret = janetc_tuple(opts, x);
+                } else {
+                    JanetSlot head = janetc_value(subopts, tup[0]);
+                    subopts.flags = JANET_FUNCTION | JANET_CFUNCTION;
+                    ret = janetc_call(opts, janetc_toslots(c, tup + 1, janet_tuple_length(tup) - 1), head);
+                    janetc_freeslot(c, head);
                 }
-                break;
+                ret.flags &= ~JANET_SLOT_SPLICED;
+            }
+            break;
             case JANET_SYMBOL:
                 ret = janetc_resolve(c, janet_unwrap_symbol(x));
                 break;
@@ -633,6 +643,7 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
     def->source = c->source;
 
     def->arity = 0;
+    def->min_arity = 0;
     def->flags = 0;
     if (scope->flags & JANET_SCOPE_ENV) {
         def->flags |= JANET_FUNCDEF_FLAG_NEEDSENV;
@@ -727,12 +738,13 @@ static Janet cfun(int32_t argc, Janet *argv) {
 }
 
 static const JanetReg compile_cfuns[] = {
-    {"compile", cfun,
+    {
+        "compile", cfun,
         JDOC("(compile ast env [, source])\n\n"
-                "Compiles an Abstract Syntax Tree (ast) into a janet function. "
-                "Pair the compile function with parsing functionality to implement "
-                "eval. Returns a janet function and does not modify ast. Throws an "
-                "error if the ast cannot be compiled.")
+             "Compiles an Abstract Syntax Tree (ast) into a janet function. "
+             "Pair the compile function with parsing functionality to implement "
+             "eval. Returns a janet function and does not modify ast. Throws an "
+             "error if the ast cannot be compiled.")
     },
     {NULL, NULL, NULL}
 };

src/core/compile.h

@@ -24,7 +24,7 @@
 #define JANET_COMPILE_H
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "regalloc.h"
 #endif
 
@@ -96,6 +96,7 @@ struct JanetSlot {
 #define JANET_SCOPE_TOP 4
 #define JANET_SCOPE_UNUSED 8
 #define JANET_SCOPE_CLOSURE 16
+#define JANET_SCOPE_WHILE 32
 
 /* A symbol and slot pair */
 typedef struct SymPair {
@@ -131,9 +132,6 @@ struct JanetScope {
      * that corresponds to the direct parent's stack will always have value 0. */
     int32_t *envs;
 
-    /* Where to add reference to self in constants */
-    int32_t selfconst;
-
     int32_t bytecode_start;
     int flags;
 };
@@ -180,13 +178,13 @@ JanetFopts janetc_fopts_default(JanetCompiler *c);
 /* For optimizing builtin normal functions. */
 struct JanetFunOptimizer {
     int (*can_optimize)(JanetFopts opts, JanetSlot *args);
-    JanetSlot (*optimize)(JanetFopts opts, JanetSlot *args);
+    JanetSlot(*optimize)(JanetFopts opts, JanetSlot *args);
 };
 
 /* A grouping of a named special and the corresponding compiler fragment */
 struct JanetSpecial {
     const char *name;
-    JanetSlot (*compile)(JanetFopts opts, int32_t argn, const Janet *argv);
+    JanetSlot(*compile)(JanetFopts opts, int32_t argn, const Janet *argv);
 };
 
 /****************************************************/

src/core/corelib.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "compile.h"
 #include "state.h"
 #include "util.h"
@@ -229,8 +229,8 @@ static Janet janet_core_next(int32_t argc, Janet *argv) {
     JanetDictView view = janet_getdictionary(argv, 0);
     const JanetKV *end = view.kvs + view.cap;
     const JanetKV *kv = janet_checktype(argv[1], JANET_NIL)
-        ? view.kvs
-        : janet_dict_find(view.kvs, view.cap, argv[1]) + 1;
+                        ? view.kvs
+                        : janet_dict_find(view.kvs, view.cap, argv[1]) + 1;
     while (kv < end) {
         if (!janet_checktype(kv->key, JANET_NIL)) return kv->key;
         kv++;
@@ -243,135 +243,184 @@ static Janet janet_core_hash(int32_t argc, Janet *argv) {
     return janet_wrap_number(janet_hash(argv[0]));
 }
 
+static Janet janet_core_getline(int32_t argc, Janet *argv) {
+    janet_arity(argc, 0, 2);
+    JanetBuffer *buf = (argc >= 2) ? janet_getbuffer(argv, 1) : janet_buffer(10);
+    if (argc >= 1) {
+        const char *prompt = (const char *) janet_getstring(argv, 0);
+        printf("%s", prompt);
+        fflush(stdout);
+    }
+    {
+        buf->count = 0;
+        int c;
+        for (;;) {
+            c = fgetc(stdin);
+            if (feof(stdin) || c < 0) {
+                break;
+            }
+            janet_buffer_push_u8(buf, (uint8_t) c);
+            if (c == '\n') break;
+        }
+    }
+    return janet_wrap_buffer(buf);
+}
+
 static const JanetReg corelib_cfuns[] = {
-    {"native", janet_core_native,
+    {
+        "native", janet_core_native,
         JDOC("(native path [,env])\n\n"
-                "Load a native module from the given path. The path "
-                "must be an absolute or relative path on the file system, and is "
-                "usually a .so file on Unix systems, and a .dll file on Windows. "
-                "Returns an environment table that contains functions and other values "
-                "from the native module.")
+             "Load a native module from the given path. The path "
+             "must be an absolute or relative path on the file system, and is "
+             "usually a .so file on Unix systems, and a .dll file on Windows. "
+             "Returns an environment table that contains functions and other values "
+             "from the native module.")
     },
-    {"print", janet_core_print,
+    {
+        "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.")
+             "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,
+    {
+        "describe", janet_core_describe,
         JDOC("(describe x)\n\n"
-                "Returns a string that is a human readable description of a value x.")
+             "Returns a string that is a human readable description of a value x.")
     },
-    {"string", janet_core_string,
+    {
+        "string", janet_core_string,
         JDOC("(string & parts)\n\n"
-                "Creates a string by concatenating values together. Values are "
-                "converted to bytes via describe if they are not byte sequences. "
-                "Returns the new string.")
+             "Creates a string by concatenating values together. Values are "
+             "converted to bytes via describe if they are not byte sequences. "
+             "Returns the new string.")
     },
-    {"symbol", janet_core_symbol,
+    {
+        "symbol", janet_core_symbol,
         JDOC("(symbol & xs)\n\n"
-                "Creates a symbol by concatenating values together. Values are "
-                "converted to bytes via describe if they are not byte sequences. Returns "
-                "the new symbol.")
+             "Creates a symbol by concatenating values together. Values are "
+             "converted to bytes via describe if they are not byte sequences. Returns "
+             "the new symbol.")
     },
-    {"keyword", janet_core_keyword,
+    {
+        "keyword", janet_core_keyword,
         JDOC("(keyword & xs)\n\n"
-                "Creates a keyword by concatenating values together. Values are "
-                "converted to bytes via describe if they are not byte sequences. Returns "
-                "the new keyword.")
+             "Creates a keyword by concatenating values together. Values are "
+             "converted to bytes via describe if they are not byte sequences. Returns "
+             "the new keyword.")
     },
-    {"buffer", janet_core_buffer,
+    {
+        "buffer", janet_core_buffer,
         JDOC("(buffer & xs)\n\n"
-                "Creates a new buffer by concatenating values together. Values are "
-                "converted to bytes via describe if they are not byte sequences. Returns "
-                "the new buffer.")
+             "Creates a new buffer by concatenating values together. Values are "
+             "converted to bytes via describe if they are not byte sequences. Returns "
+             "the new buffer.")
     },
-    {"abstract?", janet_core_is_abstract,
+    {
+        "abstract?", janet_core_is_abstract,
         JDOC("(abstract? x)\n\n"
-                "Check if x is an abstract type.")
+             "Check if x is an abstract type.")
     },
-    {"table", janet_core_table,
+    {
+        "table", janet_core_table,
         JDOC("(table & kvs)\n\n"
-                "Creates a new table from a variadic number of keys and values. "
-                "kvs is a sequence k1, v1, k2, v2, k3, v3, ... If kvs has "
-                "an odd number of elements, an error will be thrown. Returns the "
-                "new table.")
+             "Creates a new table from a variadic number of keys and values. "
+             "kvs is a sequence k1, v1, k2, v2, k3, v3, ... If kvs has "
+             "an odd number of elements, an error will be thrown. Returns the "
+             "new table.")
     },
-    {"array", janet_core_array,
+    {
+        "array", janet_core_array,
         JDOC("(array & items)\n\n"
-                "Create a new array that contains items. Returns the new array.")
+             "Create a new array that contains items. Returns the new array.")
     },
-    {"scan-number", janet_core_scannumber,
+    {
+        "scan-number", janet_core_scannumber,
         JDOC("(scan-number str)\n\n"
-                "Parse a number from a byte sequence an return that number, either and integer "
-                "or a real. The number "
-                "must be in the same format as numbers in janet source code. Will return nil "
-                "on an invalid number.")
+             "Parse a number from a byte sequence an return that number, either and integer "
+             "or a real. The number "
+             "must be in the same format as numbers in janet source code. Will return nil "
+             "on an invalid number.")
     },
-    {"tuple", janet_core_tuple,
+    {
+        "tuple", janet_core_tuple,
         JDOC("(tuple & items)\n\n"
-                "Creates a new tuple that contains items. Returns the new tuple.")
+             "Creates a new tuple that contains items. Returns the new tuple.")
     },
-    {"struct", janet_core_struct,
+    {
+        "struct", janet_core_struct,
         JDOC("(struct & kvs)\n\n"
-                "Create a new struct from a sequence of key value pairs. "
-                "kvs is a sequence k1, v1, k2, v2, k3, v3, ... If kvs has "
-                "an odd number of elements, an error will be thrown. Returns the "
-                "new struct.")
+             "Create a new struct from a sequence of key value pairs. "
+             "kvs is a sequence k1, v1, k2, v2, k3, v3, ... If kvs has "
+             "an odd number of elements, an error will be thrown. Returns the "
+             "new struct.")
     },
-    {"gensym", janet_core_gensym,
+    {
+        "gensym", janet_core_gensym,
         JDOC("(gensym)\n\n"
-                "Returns a new symbol that is unique across the runtime. This means it "
-                "will not collide with any already created symbols during compilation, so "
-                "it can be used in macros to generate automatic bindings.")
+             "Returns a new symbol that is unique across the runtime. This means it "
+             "will not collide with any already created symbols during compilation, so "
+             "it can be used in macros to generate automatic bindings.")
     },
-    {"gccollect", janet_core_gccollect,
+    {
+        "gccollect", janet_core_gccollect,
         JDOC("(gccollect)\n\n"
-                "Run garbage collection. You should probably not call this manually.")
+             "Run garbage collection. You should probably not call this manually.")
     },
-    {"gcsetinterval", janet_core_gcsetinterval,
+    {
+        "gcsetinterval", janet_core_gcsetinterval,
         JDOC("(gcsetinterval interval)\n\n"
-                "Set an integer number of bytes to allocate before running garbage collection. "
-                "Low valuesi for interval will be slower but use less memory. "
-                "High values will be faster but use more memory.")
+             "Set an integer number of bytes to allocate before running garbage collection. "
+             "Low valuesi for interval will be slower but use less memory. "
+             "High values will be faster but use more memory.")
     },
-    {"gcinterval", janet_core_gcinterval,
+    {
+        "gcinterval", janet_core_gcinterval,
         JDOC("(gcinterval)\n\n"
-                "Returns the integer number of bytes to allocate before running an iteration "
-                "of garbage collection.")
+             "Returns the integer number of bytes to allocate before running an iteration "
+             "of garbage collection.")
     },
-    {"type", janet_core_type,
+    {
+        "type", janet_core_type,
         JDOC("(type x)\n\n"
-                "Returns the type of x as a keyword symbol. x is one of\n"
-                "\t:nil\n"
-                "\t:boolean\n"
-                "\t:integer\n"
-                "\t:real\n"
-                "\t:array\n"
-                "\t:tuple\n"
-                "\t:table\n"
-                "\t:struct\n"
-                "\t:string\n"
-                "\t:buffer\n"
-                "\t:symbol\n"
-                "\t:keyword\n"
-                "\t:function\n"
-                "\t:cfunction\n\n"
-                "or another symbol for an abstract type.")
+             "Returns the type of x as a keyword symbol. x is one of\n"
+             "\t:nil\n"
+             "\t:boolean\n"
+             "\t:integer\n"
+             "\t:real\n"
+             "\t:array\n"
+             "\t:tuple\n"
+             "\t:table\n"
+             "\t:struct\n"
+             "\t:string\n"
+             "\t:buffer\n"
+             "\t:symbol\n"
+             "\t:keyword\n"
+             "\t:function\n"
+             "\t:cfunction\n\n"
+             "or another symbol for an abstract type.")
     },
-    {"next", janet_core_next,
+    {
+        "next", janet_core_next,
         JDOC("(next dict key)\n\n"
-                "Gets the next key in a struct or table. Can be used to iterate through "
-                "the keys of a data structure in an unspecified order. Keys are guaranteed "
-                "to be seen only once per iteration if they data structure is not mutated "
-                "during iteration. If key is nil, next returns the first key. If next "
-                "returns nil, there are no more keys to iterate through. ")
+             "Gets the next key in a struct or table. Can be used to iterate through "
+             "the keys of a data structure in an unspecified order. Keys are guaranteed "
+             "to be seen only once per iteration if they data structure is not mutated "
+             "during iteration. If key is nil, next returns the first key. If next "
+             "returns nil, there are no more keys to iterate through. ")
     },
-    {"hash", janet_core_hash,
+    {
+        "hash", janet_core_hash,
         JDOC("(hash value)\n\n"
-                "Gets a hash value for any janet value. The hash is an integer can be used "
-                "as a cheap hash function for all janet objects. If two values are strictly equal, "
-                "then they will have the same hash value.")
+             "Gets a hash value for any janet value. The hash is an integer can be used "
+             "as a cheap hash function for all janet objects. If two values are strictly equal, "
+             "then they will have the same hash value.")
+    },
+    {
+        "getline", janet_core_getline,
+        JDOC("(getline [, prompt=\"\" [, buffer=@\"\"]])\n\n"
+             "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.")
     },
     {NULL, NULL, NULL}
 };
@@ -380,16 +429,20 @@ static const JanetReg corelib_cfuns[] = {
 
 /* Utility for inline assembly */
 static void janet_quick_asm(
-        JanetTable *env,
-        int32_t flags,
-        const char *name,
-        int32_t arity,
-        int32_t slots,
-        const uint32_t *bytecode,
-        size_t bytecode_size,
-        const char *doc) {
+    JanetTable *env,
+    int32_t flags,
+    const char *name,
+    int32_t arity,
+    int32_t min_arity,
+    int32_t max_arity,
+    int32_t slots,
+    const uint32_t *bytecode,
+    size_t bytecode_size,
+    const char *doc) {
     JanetFuncDef *def = janet_funcdef_alloc();
     def->arity = arity;
+    def->min_arity = min_arity;
+    def->max_arity = max_arity;
     def->flags = flags;
     def->slotcount = slots;
     def->bytecode = malloc(bytecode_size);
@@ -411,13 +464,13 @@ static void janet_quick_asm(
 
 /* Templatize a varop */
 static void templatize_varop(
-        JanetTable *env,
-        int32_t flags,
-        const char *name,
-        int32_t nullary,
-        int32_t unary,
-        uint32_t op,
-        const char *doc) {
+    JanetTable *env,
+    int32_t flags,
+    const char *name,
+    int32_t nullary,
+    int32_t unary,
+    uint32_t op,
+    const char *doc) {
 
     /* Variadic operator assembly. Must be templatized for each different opcode. */
     /* Reg 0: Argument tuple (args) */
@@ -461,24 +514,26 @@ static void templatize_varop(
     };
 
     janet_quick_asm(
-            env,
-            flags | JANET_FUNCDEF_FLAG_VARARG,
-            name,
-            0,
-            6,
-            varop_asm,
-            sizeof(varop_asm),
-            doc);
+        env,
+        flags | JANET_FUNCDEF_FLAG_VARARG,
+        name,
+        0,
+        0,
+        INT32_MAX,
+        6,
+        varop_asm,
+        sizeof(varop_asm),
+        doc);
 }
 
 /* Templatize variadic comparators */
 static void templatize_comparator(
-        JanetTable *env,
-        int32_t flags,
-        const char *name,
-        int invert,
-        uint32_t op,
-        const char *doc) {
+    JanetTable *env,
+    int32_t flags,
+    const char *name,
+    int invert,
+    uint32_t op,
+    const char *doc) {
 
     /* Reg 0: Argument tuple (args) */
     /* Reg 1: Argument count (argn) */
@@ -514,14 +569,16 @@ static void templatize_comparator(
     };
 
     janet_quick_asm(
-            env,
-            flags | JANET_FUNCDEF_FLAG_VARARG,
-            name,
-            0,
-            6,
-            comparator_asm,
-            sizeof(comparator_asm),
-            doc);
+        env,
+        flags | JANET_FUNCDEF_FLAG_VARARG,
+        name,
+        0,
+        0,
+        INT32_MAX,
+        6,
+        comparator_asm,
+        sizeof(comparator_asm),
+        doc);
 }
 
 /* Make the apply function */
@@ -555,22 +612,22 @@ static void make_apply(JanetTable *env) {
         S(JOP_TAILCALL, 0)
     };
     janet_quick_asm(env, JANET_FUN_APPLY | JANET_FUNCDEF_FLAG_VARARG,
-            "apply", 1, 6, apply_asm, sizeof(apply_asm),
-            JDOC("(apply f & args)\n\n"
-                "Applies a function to a variable number of arguments. Each element in args "
-                "is used as an argument to f, except the last element in args, which is expected to "
-                "be an array-like. Each element in this last argument is then also pushed as an argument to "
-                "f. For example:\n\n"
-                "\t(apply + 1000 (range 10))\n\n"
-                "sums the first 10 integers and 1000.)"));
+                    "apply", 1, 1, INT32_MAX, 6, apply_asm, sizeof(apply_asm),
+                    JDOC("(apply f & args)\n\n"
+                         "Applies a function to a variable number of arguments. Each element in args "
+                         "is used as an argument to f, except the last element in args, which is expected to "
+                         "be an array-like. Each element in this last argument is then also pushed as an argument to "
+                         "f. For example:\n\n"
+                         "\t(apply + 1000 (range 10))\n\n"
+                         "sums the first 10 integers and 1000.)"));
 }
 
 static const uint32_t error_asm[] = {
     JOP_ERROR
 };
 static const uint32_t debug_asm[] = {
-   JOP_SIGNAL | (2 << 24),
-   JOP_RETURN_NIL
+    JOP_SIGNAL | (2 << 24),
+    JOP_RETURN_NIL
 };
 static const uint32_t yield_asm[] = {
     JOP_SIGNAL | (3 << 24),
@@ -598,139 +655,147 @@ static const uint32_t bnot_asm[] = {
 };
 #endif /* ifndef JANET_NO_BOOTSTRAP */
 
-JanetTable *janet_core_env(void) {
-    JanetTable *env = janet_table(0);
+JanetTable *janet_core_env(JanetTable *replacements) {
+    JanetTable *env = (NULL != replacements) ? replacements : janet_table(0);
     janet_core_cfuns(env, NULL, corelib_cfuns);
 
 #ifdef JANET_BOOTSTRAP
-    janet_quick_asm(env, JANET_FUN_YIELD, "debug", 0, 1, debug_asm, sizeof(debug_asm),
-            JDOC("(debug)\n\n"
-                "Throws a debug signal that can be caught by a parent fiber and used to inspect "
-                "the running state of the current fiber. Returns nil."));
-    janet_quick_asm(env, JANET_FUN_ERROR, "error", 1, 1, error_asm, sizeof(error_asm),
-            JDOC("(error e)\n\n"
-                "Throws an error e that can be caught and handled by a parent fiber."));
-    janet_quick_asm(env, JANET_FUN_YIELD, "yield", 1, 2, yield_asm, sizeof(yield_asm),
-            JDOC("(yield x)\n\n"
-                "Yield a value to a parent fiber. When a fiber yields, its execution is paused until "
-                "another thread resumes it. The fiber will then resume, and the last yield call will "
-                "return the value that was passed to resume."));
-    janet_quick_asm(env, JANET_FUN_RESUME, "resume", 2, 2, resume_asm, sizeof(resume_asm),
-            JDOC("(resume fiber [,x])\n\n"
-                "Resume a new or suspended fiber and optionally pass in a value to the fiber that "
-                "will be returned to the last yield in the case of a pending fiber, or the argument to "
-                "the dispatch function in the case of a new fiber. Returns either the return result of "
-                "the fiber's dispatch function, or the value from the next yield call in fiber."));
-    janet_quick_asm(env, JANET_FUN_GET, "get", 2, 2, get_asm, sizeof(get_asm),
-            JDOC("(get ds key)\n\n"
-                "Get a value from any associative data structure. Arrays, tuples, tables, structs, strings, "
-                "symbols, and buffers are all associative and can be used with get. Order structures, name "
-                "arrays, tuples, strings, buffers, and symbols must use integer keys. Structs and tables can "
-                "take any value as a key except nil and return a value except nil. Byte sequences will return "
-                "integer representations of bytes as result of a get call."));
-    janet_quick_asm(env, JANET_FUN_PUT, "put", 3, 3, put_asm, sizeof(put_asm),
-            JDOC("(put ds key value)\n\n"
-                "Associate a key with a value in any mutable associative data structure. Indexed data structures "
-                "(arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds "
-                "value is provided. In an array, extra space will be filled with nils, and in a buffer, extra "
-                "space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype "
-                "will hide the association defined by the prototype, but will not mutate the prototype table. Putting "
-                "a value nil into a table will remove the key from the table. Returns the data structure ds."));
-    janet_quick_asm(env, JANET_FUN_LENGTH, "length", 1, 1, length_asm, sizeof(length_asm),
-            JDOC("(length ds)\n\n"
-                "Returns the length or count of a data structure in constant time as an integer. For "
-                "structs and tables, returns the number of key-value pairs in the data structure."));
-    janet_quick_asm(env, JANET_FUN_BNOT, "bnot", 1, 1, bnot_asm, sizeof(bnot_asm),
-            JDOC("(bnot x)\n\nReturns the bit-wise inverse of integer x."));
+    janet_quick_asm(env, JANET_FUN_DEBUG,
+                    "debug", 0, 0, 0, 1, debug_asm, sizeof(debug_asm),
+                    JDOC("(debug)\n\n"
+                         "Throws a debug signal that can be caught by a parent fiber and used to inspect "
+                         "the running state of the current fiber. Returns nil."));
+    janet_quick_asm(env, JANET_FUN_ERROR,
+                    "error", 1, 1, 1, 1, error_asm, sizeof(error_asm),
+                    JDOC("(error e)\n\n"
+                         "Throws an error e that can be caught and handled by a parent fiber."));
+    janet_quick_asm(env, JANET_FUN_YIELD,
+                    "yield", 1, 0, 1, 2, yield_asm, sizeof(yield_asm),
+                    JDOC("(yield x)\n\n"
+                         "Yield a value to a parent fiber. When a fiber yields, its execution is paused until "
+                         "another thread resumes it. The fiber will then resume, and the last yield call will "
+                         "return the value that was passed to resume."));
+    janet_quick_asm(env, JANET_FUN_RESUME,
+                    "resume", 2, 1, 2, 2, resume_asm, sizeof(resume_asm),
+                    JDOC("(resume fiber &opt x)\n\n"
+                         "Resume a new or suspended fiber and optionally pass in a value to the fiber that "
+                         "will be returned to the last yield in the case of a pending fiber, or the argument to "
+                         "the dispatch function in the case of a new fiber. Returns either the return result of "
+                         "the fiber's dispatch function, or the value from the next yield call in fiber."));
+    janet_quick_asm(env, JANET_FUN_GET,
+                    "get", 2, 2, 2, 2, get_asm, sizeof(get_asm),
+                    JDOC("(get ds key)\n\n"
+                         "Get a value from any associative data structure. Arrays, tuples, tables, structs, strings, "
+                         "symbols, and buffers are all associative and can be used with get. Order structures, name "
+                         "arrays, tuples, strings, buffers, and symbols must use integer keys. Structs and tables can "
+                         "take any value as a key except nil and return a value except nil. Byte sequences will return "
+                         "integer representations of bytes as result of a get call."));
+    janet_quick_asm(env, JANET_FUN_PUT,
+                    "put", 3, 3, 3, 3, put_asm, sizeof(put_asm),
+                    JDOC("(put ds key value)\n\n"
+                         "Associate a key with a value in any mutable associative data structure. Indexed data structures "
+                         "(arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds "
+                         "value is provided. In an array, extra space will be filled with nils, and in a buffer, extra "
+                         "space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype "
+                         "will hide the association defined by the prototype, but will not mutate the prototype table. Putting "
+                         "a value nil into a table will remove the key from the table. Returns the data structure ds."));
+    janet_quick_asm(env, JANET_FUN_LENGTH,
+                    "length", 1, 1, 1, 1, length_asm, sizeof(length_asm),
+                    JDOC("(length ds)\n\n"
+                         "Returns the length or count of a data structure in constant time as an integer. For "
+                         "structs and tables, returns the number of key-value pairs in the data structure."));
+    janet_quick_asm(env, JANET_FUN_BNOT,
+                    "bnot", 1, 1, 1, 1, bnot_asm, sizeof(bnot_asm),
+                    JDOC("(bnot x)\n\nReturns the bit-wise inverse of integer x."));
     make_apply(env);
 
     /* Variadic ops */
     templatize_varop(env, JANET_FUN_ADD, "+", 0, 0, JOP_ADD,
-            JDOC("(+ & xs)\n\n"
-            "Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0."));
+                     JDOC("(+ & xs)\n\n"
+                          "Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0."));
     templatize_varop(env, JANET_FUN_SUBTRACT, "-", 0, 0, JOP_SUBTRACT,
-            JDOC("(- & xs)\n\n"
-            "Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the "
-            "negative value of that element. Otherwise, returns the first element in xs minus the sum of "
-            "the rest of the elements."));
+                     JDOC("(- & xs)\n\n"
+                          "Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the "
+                          "negative value of that element. Otherwise, returns the first element in xs minus the sum of "
+                          "the rest of the elements."));
     templatize_varop(env, JANET_FUN_MULTIPLY, "*", 1, 1, JOP_MULTIPLY,
-            JDOC("(* & xs)\n\n"
-            "Returns the product of all elements in xs. If xs is empty, returns 1."));
+                     JDOC("(* & xs)\n\n"
+                          "Returns the product of all elements in xs. If xs is empty, returns 1."));
     templatize_varop(env, JANET_FUN_DIVIDE, "/", 1, 1, JOP_DIVIDE,
-            JDOC("(/ & xs)\n\n"
-            "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns "
-            "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
-            "values. Division by two integers uses truncating division."));
+                     JDOC("(/ & xs)\n\n"
+                          "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns "
+                          "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
+                          "values. Division by two integers uses truncating division."));
     templatize_varop(env, JANET_FUN_BAND, "band", -1, -1, JOP_BAND,
-            JDOC("(band & xs)\n\n"
-            "Returns the bit-wise and of all values in xs. Each x in xs must be an integer."));
+                     JDOC("(band & xs)\n\n"
+                          "Returns the bit-wise and of all values in xs. Each x in xs must be an integer."));
     templatize_varop(env, JANET_FUN_BOR, "bor", 0, 0, JOP_BOR,
-            JDOC("(bor & xs)\n\n"
-            "Returns the bit-wise or of all values in xs. Each x in xs must be an integer."));
+                     JDOC("(bor & xs)\n\n"
+                          "Returns the bit-wise or of all values in xs. Each x in xs must be an integer."));
     templatize_varop(env, JANET_FUN_BXOR, "bxor", 0, 0, JOP_BXOR,
-            JDOC("(bxor & xs)\n\n"
-            "Returns the bit-wise xor of all values in xs. Each in xs must be an integer."));
+                     JDOC("(bxor & xs)\n\n"
+                          "Returns the bit-wise xor of all values in xs. Each in xs must be an integer."));
     templatize_varop(env, JANET_FUN_LSHIFT, "blshift", 1, 1, JOP_SHIFT_LEFT,
-            JDOC("(blshift x & shifts)\n\n"
-            "Returns the value of x bit shifted left by the sum of all values in shifts. x "
-            "and each element in shift must be an integer."));
+                     JDOC("(blshift x & shifts)\n\n"
+                          "Returns the value of x bit shifted left by the sum of all values in shifts. x "
+                          "and each element in shift must be an integer."));
     templatize_varop(env, JANET_FUN_RSHIFT, "brshift", 1, 1, JOP_SHIFT_RIGHT,
-            JDOC("(brshift x & shifts)\n\n"
-            "Returns the value of x bit shifted right by the sum of all values in shifts. x "
-            "and each element in shift must be an integer."));
+                     JDOC("(brshift x & shifts)\n\n"
+                          "Returns the value of x bit shifted right by the sum of all values in shifts. x "
+                          "and each element in shift must be an integer."));
     templatize_varop(env, JANET_FUN_RSHIFTU, "brushift", 1, 1, JOP_SHIFT_RIGHT_UNSIGNED,
-            JDOC("(brushift x & shifts)\n\n"
-            "Returns the value of x bit shifted right by the sum of all values in shifts. x "
-            "and each element in shift must be an integer. The sign of x is not preserved, so "
-            "for positive shifts the return value will always be positive."));
+                     JDOC("(brushift x & shifts)\n\n"
+                          "Returns the value of x bit shifted right by the sum of all values in shifts. x "
+                          "and each element in shift must be an integer. The sign of x is not preserved, so "
+                          "for positive shifts the return value will always be positive."));
 
     /* Variadic comparators */
     templatize_comparator(env, JANET_FUN_ORDER_GT, "order>", 0, JOP_GREATER_THAN,
-            JDOC("(order> & xs)\n\n"
-                "Check if xs is strictly descending according to a total order "
-                "over all values. Returns a boolean."));
+                          JDOC("(order> & xs)\n\n"
+                               "Check if xs is strictly descending according to a total order "
+                               "over all values. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_ORDER_LT, "order<", 0, JOP_LESS_THAN,
-            JDOC("(order< & xs)\n\n"
-                "Check if xs is strictly increasing according to a total order "
-                "over all values. Returns a boolean."));
+                          JDOC("(order< & xs)\n\n"
+                               "Check if xs is strictly increasing according to a total order "
+                               "over all values. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_ORDER_GTE, "order>=", 1, JOP_LESS_THAN,
-            JDOC("(order>= & xs)\n\n"
-                "Check if xs is not increasing according to a total order "
-                "over all values. Returns a boolean."));
+                          JDOC("(order>= & xs)\n\n"
+                               "Check if xs is not increasing according to a total order "
+                               "over all values. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_ORDER_LTE, "order<=", 1, JOP_GREATER_THAN,
-            JDOC("(order<= & xs)\n\n"
-                "Check if xs is not decreasing according to a total order "
-                "over all values. Returns a boolean."));
+                          JDOC("(order<= & xs)\n\n"
+                               "Check if xs is not decreasing according to a total order "
+                               "over all values. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_ORDER_EQ, "=", 0, JOP_EQUALS,
-            JDOC("(= & xs)\n\n"
-                "Returns true if all values in xs are the same, false otherwise."));
+                          JDOC("(= & xs)\n\n"
+                               "Returns true if all values in xs are the same, false otherwise."));
     templatize_comparator(env, JANET_FUN_ORDER_NEQ, "not=", 1, JOP_EQUALS,
-            JDOC("(not= & xs)\n\n"
-                "Return true if any values in xs are not equal, otherwise false."));
+                          JDOC("(not= & xs)\n\n"
+                               "Return true if any values in xs are not equal, otherwise false."));
     templatize_comparator(env, JANET_FUN_GT, ">", 0, JOP_NUMERIC_GREATER_THAN,
-            JDOC("(> & xs)\n\n"
-                "Check if xs is in numerically descending order. Returns a boolean."));
+                          JDOC("(> & xs)\n\n"
+                               "Check if xs is in numerically descending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_LT, "<", 0, JOP_NUMERIC_LESS_THAN,
-            JDOC("(< & xs)\n\n"
-                "Check if xs is in numerically ascending order. Returns a boolean."));
+                          JDOC("(< & xs)\n\n"
+                               "Check if xs is in numerically ascending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_GTE, ">=", 0, JOP_NUMERIC_GREATER_THAN_EQUAL,
-            JDOC("(>= & xs)\n\n"
-                "Check if xs is in numerically non-ascending order. Returns a boolean."));
+                          JDOC("(>= & xs)\n\n"
+                               "Check if xs is in numerically non-ascending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_LTE, "<=", 0, JOP_NUMERIC_LESS_THAN_EQUAL,
-            JDOC("(<= & xs)\n\n"
-                "Check if xs is in numerically non-descending order. Returns a boolean."));
+                          JDOC("(<= & xs)\n\n"
+                               "Check if xs is in numerically non-descending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_EQ, "==", 0, JOP_NUMERIC_EQUAL,
-            JDOC("(== & xs)\n\n"
-                "Check if all values in xs are numerically equal (4.0 == 4). Returns a boolean."));
+                          JDOC("(== & xs)\n\n"
+                               "Check if all values in xs are numerically equal (4.0 == 4). Returns a boolean."));
     templatize_comparator(env, JANET_FUN_NEQ, "not==", 1, JOP_NUMERIC_EQUAL,
-            JDOC("(not== & xs)\n\n"
-                "Check if any values in xs are not numerically equal (3.0 not== 4). Returns a boolean."));
+                          JDOC("(not== & xs)\n\n"
+                               "Check if any values in xs are not numerically equal (3.0 not== 4). Returns a boolean."));
 
     /* Platform detection */
     janet_def(env, "janet/version", janet_cstringv(JANET_VERSION),
-            JDOC("The version number of the running janet program."));
+              JDOC("The version number of the running janet program."));
     janet_def(env, "janet/build", janet_cstringv(JANET_BUILD),
-            JDOC("The build identifier of the running janet program."));
+              JDOC("The build identifier of the running janet program."));
 
     /* Allow references to the environment */
     janet_def(env, "_env", janet_wrap_table(env), JDOC("The environment table for the current scope."));
@@ -753,10 +818,15 @@ JanetTable *janet_core_env(void) {
     janet_lib_debug(env);
     janet_lib_string(env);
     janet_lib_marsh(env);
+#ifdef JANET_PEG
     janet_lib_peg(env);
+#endif
 #ifdef JANET_ASSEMBLER
     janet_lib_asm(env);
 #endif
+#ifdef JANET_TYPED_ARRAY
+    janet_lib_typed_array(env);
+#endif
 
 #ifdef JANET_BOOTSTRAP
     /* Run bootstrap source */
@@ -764,18 +834,12 @@ JanetTable *janet_core_env(void) {
 #else
 
     /* Unmarshal from core image */
-    Janet marsh_out;
-    int status = janet_unmarshal(
-            janet_core_image,
-            janet_core_image_size,
-            0,
-            &marsh_out,
-            env,
-            NULL);
-    if (status) {
-        printf("error unmarshaling core image\n");
-        exit(1);
-    }
+    Janet marsh_out = janet_unmarshal(
+                          janet_core_image,
+                          janet_core_image_size,
+                          0,
+                          env,
+                          NULL);
     janet_gcroot(marsh_out);
     env = janet_unwrap_table(marsh_out);
 #endif

src/core/debug.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "gc.h"
 #include "state.h"
 #include "util.h"
@@ -51,10 +51,10 @@ void janet_debug_unbreak(JanetFuncDef *def, int32_t pc) {
  * location.
  */
 void janet_debug_find(
-        JanetFuncDef **def_out, int32_t *pc_out,
-        const uint8_t *source, int32_t offset) {
+    JanetFuncDef **def_out, int32_t *pc_out,
+    const uint8_t *source, int32_t offset) {
     /* Scan the heap for right func def */
-    JanetGCMemoryHeader *current = janet_vm_blocks;
+    JanetGCObject *current = janet_vm_blocks;
     /* Keep track of the best source mapping we have seen so far */
     int32_t besti = -1;
     int32_t best_range = INT32_MAX;
@@ -144,7 +144,7 @@ void janet_stacktrace(JanetFiber *fiber, Janet err) {
             if (frame->flags & JANET_STACKFRAME_TAILCALL)
                 fprintf(stderr, " (tailcall)");
             if (frame->func && frame->pc) {
-                int32_t off = (int32_t) (frame->pc - def->bytecode);
+                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);
@@ -192,7 +192,7 @@ static Janet cfun_debug_break(int32_t argc, Janet *argv) {
 
 static Janet cfun_debug_unbreak(int32_t argc, Janet *argv) {
     JanetFuncDef *def;
-    int32_t offset;
+    int32_t offset = 0;
     helper_find(argc, argv, &def, &offset);
     janet_debug_unbreak(def, offset);
     return janet_wrap_nil();
@@ -200,7 +200,7 @@ static Janet cfun_debug_unbreak(int32_t argc, Janet *argv) {
 
 static Janet cfun_debug_fbreak(int32_t argc, Janet *argv) {
     JanetFuncDef *def;
-    int32_t offset;
+    int32_t offset = 0;
     helper_find_fun(argc, argv, &def, &offset);
     janet_debug_break(def, offset);
     return janet_wrap_nil();
@@ -252,7 +252,7 @@ static Janet doframe(JanetStackFrame *frame) {
     if (frame->func && frame->pc) {
         Janet *stack = (Janet *)frame + JANET_FRAME_SIZE;
         JanetArray *slots;
-        off = (int32_t) (frame->pc - def->bytecode);
+        off = (int32_t)(frame->pc - def->bytecode);
         janet_table_put(t, janet_ckeywordv("pc"), janet_wrap_integer(off));
         if (def->sourcemap) {
             JanetSourceMapping mapping = def->sourcemap[off];
@@ -307,69 +307,69 @@ static const JanetReg debug_cfuns[] = {
     {
         "debug/break", cfun_debug_break,
         JDOC("(debug/break source byte-offset)\n\n"
-                "Sets a breakpoint with source a key at a given byte offset. An offset "
-                "of 0 is the first byte in a file. Will throw an error if the breakpoint location "
-                "cannot be found. For example\n\n"
-                "\t(debug/break \"core.janet\" 1000)\n\n"
-                "wil set a breakpoint at the 1000th byte of the file core.janet.")
+             "Sets a breakpoint with source a key at a given byte offset. An offset "
+             "of 0 is the first byte in a file. Will throw an error if the breakpoint location "
+             "cannot be found. For example\n\n"
+             "\t(debug/break \"core.janet\" 1000)\n\n"
+             "wil set a breakpoint at the 1000th byte of the file core.janet.")
     },
     {
         "debug/unbreak", cfun_debug_unbreak,
         JDOC("(debug/unbreak source byte-offset)\n\n"
-                "Remove a breakpoint with a source key at a given byte offset. An offset "
-                "of 0 is the first byte in a file. Will throw an error if the breakpoint "
-                "cannot be found.")
+             "Remove a breakpoint with a source key at a given byte offset. An offset "
+             "of 0 is the first byte in a file. Will throw an error if the breakpoint "
+             "cannot be found.")
     },
     {
         "debug/fbreak", cfun_debug_fbreak,
         JDOC("(debug/fbreak fun [,pc=0])\n\n"
-                "Set a breakpoint in a given function. pc is an optional offset, which "
-                "is in bytecode instructions. fun is a function value. Will throw an error "
-                "if the offset is too large or negative.")
+             "Set a breakpoint in a given function. pc is an optional offset, which "
+             "is in bytecode instructions. fun is a function value. Will throw an error "
+             "if the offset is too large or negative.")
     },
     {
         "debug/unfbreak", cfun_debug_unfbreak,
         JDOC("(debug/unfbreak fun [,pc=0])\n\n"
-                "Unset a breakpoint set with debug/fbreak.")
+             "Unset a breakpoint set with debug/fbreak.")
     },
     {
         "debug/arg-stack", cfun_debug_argstack,
         JDOC("(debug/arg-stack fiber)\n\n"
-                "Gets all values currently on the fiber's argument stack. Normally, "
-                "this should be empty unless the fiber signals while pushing arguments "
-                "to make a function call. Returns a new array.")
+             "Gets all values currently on the fiber's argument stack. Normally, "
+             "this should be empty unless the fiber signals while pushing arguments "
+             "to make a function call. Returns a new array.")
     },
     {
         "debug/stack", cfun_debug_stack,
         JDOC("(debug/stack fib)\n\n"
-                "Gets information about the stack as an array of tables. Each table "
-                "in the array contains information about a stack frame. The top most, current "
-                "stack frame is the first table in the array, and the bottom most stack frame "
-                "is the last value. Each stack frame contains some of the following attributes:\n\n"
-                "\t:c - true if the stack frame is a c function invocation\n"
-                "\t:column - the current source column of the stack frame\n"
-                "\t:function - the function that the stack frame represents\n"
-                "\t:line - the current source line of the stack frame\n"
-                "\t:name - the human friendly name of the function\n"
-                "\t:pc - integer indicating the location of the program counter\n"
-                "\t:source - string with the file path or other identifier for the source code\n"
-                "\t:slots - array of all values in each slot\n"
-                "\t:tail - boolean indicating a tail call")
+             "Gets information about the stack as an array of tables. Each table "
+             "in the array contains information about a stack frame. The top most, current "
+             "stack frame is the first table in the array, and the bottom most stack frame "
+             "is the last value. Each stack frame contains some of the following attributes:\n\n"
+             "\t:c - true if the stack frame is a c function invocation\n"
+             "\t:column - the current source column of the stack frame\n"
+             "\t:function - the function that the stack frame represents\n"
+             "\t:line - the current source line of the stack frame\n"
+             "\t:name - the human friendly name of the function\n"
+             "\t:pc - integer indicating the location of the program counter\n"
+             "\t:source - string with the file path or other identifier for the source code\n"
+             "\t:slots - array of all values in each slot\n"
+             "\t:tail - boolean indicating a tail call")
     },
     {
         "debug/stacktrace", cfun_debug_stacktrace,
         JDOC("(debug/stacktrace fiber err)\n\n"
-                "Prints a nice looking stacktrace for a fiber. The error message "
-                "err must be passed to the function as fiber's do not keep track of "
-                "the last error they have thrown. Returns the fiber.")
+             "Prints a nice looking stacktrace for a fiber. The error message "
+             "err must be passed to the function as fiber's do not keep track of "
+             "the last error they have thrown. Returns the fiber.")
     },
     {
         "debug/lineage", cfun_debug_lineage,
         JDOC("(debug/lineage fib)\n\n"
-                "Returns an array of all child fibers from a root fiber. This function "
-                "is useful when a fiber signals or errors to an ancestor fiber. Using this function, "
-                "the fiber handling the error can see which fiber raised the signal. This function should "
-                "be used mostly for debugging purposes.")
+             "Returns an array of all child fibers from a root fiber. This function "
+             "is useful when a fiber signals or errors to an ancestor fiber. Using this function, "
+             "the fiber handling the error can see which fiber raised the signal. This function should "
+             "be used mostly for debugging purposes.")
     },
     {NULL, NULL, NULL}
 };

src/core/emit.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "emit.h"
 #include "vector.h"
 #include "regalloc.h"
@@ -78,32 +78,31 @@ static void janetc_loadconst(JanetCompiler *c, Janet k, int32_t reg) {
         case JANET_NIL:
             janetc_emit(c, (reg << 8) | JOP_LOAD_NIL);
             break;
-        case JANET_TRUE:
-            janetc_emit(c, (reg << 8) | JOP_LOAD_TRUE);
+        case JANET_BOOLEAN:
+            janetc_emit(c, (reg << 8) |
+                        (janet_unwrap_boolean(k) ? JOP_LOAD_TRUE : JOP_LOAD_FALSE));
             break;
-        case JANET_FALSE:
-            janetc_emit(c, (reg << 8) | JOP_LOAD_FALSE);
-            break;
-        case JANET_NUMBER:
-            {
-                double dval = janet_unwrap_number(k);
-                int32_t i = (int32_t) dval;
-                if (dval != i || !(dval >= INT16_MIN && dval <= INT16_MAX))
-                    goto do_constant;
-                janetc_emit(c,
-                        (i << 16) |
+        case JANET_NUMBER: {
+            double dval = janet_unwrap_number(k);
+            if (dval < INT16_MIN || dval > INT16_MAX)
+                goto do_constant;
+            int32_t i = (int32_t) dval;
+            if (dval != i)
+                goto do_constant;
+            uint32_t iu = (uint32_t)i;
+            janetc_emit(c,
+                        (iu << 16) |
                         (reg << 8) |
                         JOP_LOAD_INTEGER);
-                break;
-            }
+            break;
+        }
         default:
-        do_constant:
-            {
+        do_constant: {
                 int32_t cindex = janetc_const(c, k);
                 janetc_emit(c,
-                        (cindex << 16) |
-                        (reg << 8) |
-                        JOP_LOAD_CONSTANT);
+                            (cindex << 16) |
+                            (reg << 8) |
+                            JOP_LOAD_CONSTANT);
                 break;
             }
     }
@@ -111,53 +110,53 @@ static void janetc_loadconst(JanetCompiler *c, Janet k, int32_t reg) {
 
 /* Move a slot to a near register */
 static void janetc_movenear(JanetCompiler *c,
-        int32_t dest,
-        JanetSlot src) {
+                            int32_t dest,
+                            JanetSlot src) {
     if (src.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) {
         janetc_loadconst(c, src.constant, dest);
         /* If we also are a reference, deref the one element array */
         if (src.flags & JANET_SLOT_REF) {
             janetc_emit(c,
-                    (dest << 16) |
-                    (dest << 8) |
-                    JOP_GET_INDEX);
+                        (dest << 16) |
+                        (dest << 8) |
+                        JOP_GET_INDEX);
         }
     } else if (src.envindex >= 0) {
         janetc_emit(c,
-                ((uint32_t)(src.index) << 24) |
-                ((uint32_t)(src.envindex) << 16) |
-                ((uint32_t)(dest) << 8) |
-                JOP_LOAD_UPVALUE);
+                    ((uint32_t)(src.index) << 24) |
+                    ((uint32_t)(src.envindex) << 16) |
+                    ((uint32_t)(dest) << 8) |
+                    JOP_LOAD_UPVALUE);
     } else if (src.index > 0xFF || src.index != dest) {
         janetc_emit(c,
-                ((uint32_t)(src.index) << 16) |
-                ((uint32_t)(dest) << 8) |
+                    ((uint32_t)(src.index) << 16) |
+                    ((uint32_t)(dest) << 8) |
                     JOP_MOVE_NEAR);
     }
 }
 
 /* Move a near register to a Slot. */
 static void janetc_moveback(JanetCompiler *c,
-        JanetSlot dest,
-        int32_t src) {
+                            JanetSlot dest,
+                            int32_t src) {
     if (dest.flags & JANET_SLOT_REF) {
         int32_t refreg = janetc_regalloc_temp(&c->scope->ra, JANETC_REGTEMP_5);
         janetc_loadconst(c, dest.constant, refreg);
         janetc_emit(c,
-               (src << 16) |
-               (refreg << 8) |
-               JOP_PUT_INDEX);
+                    (src << 16) |
+                    (refreg << 8) |
+                    JOP_PUT_INDEX);
         janetc_regalloc_freetemp(&c->scope->ra, refreg, JANETC_REGTEMP_5);
     } else if (dest.envindex >= 0) {
         janetc_emit(c,
-                ((uint32_t)(dest.index) << 24) |
-                ((uint32_t)(dest.envindex) << 16) |
-                ((uint32_t)(src) << 8) |
-                JOP_SET_UPVALUE);
+                    ((uint32_t)(dest.index) << 24) |
+                    ((uint32_t)(dest.envindex) << 16) |
+                    ((uint32_t)(src) << 8) |
+                    JOP_SET_UPVALUE);
     } else if (dest.index != src) {
         janetc_emit(c,
-                ((uint32_t)(dest.index) << 16) |
-                ((uint32_t)(src) << 8) |
+                    ((uint32_t)(dest.index) << 16) |
+                    ((uint32_t)(src) << 8) |
                     JOP_MOVE_FAR);
     }
 }
@@ -221,9 +220,9 @@ static int janetc_sequal(JanetSlot lhs, JanetSlot rhs) {
 /* Move values from one slot to another. The destination must
  * be writeable (not a literal). */
 void janetc_copy(
-        JanetCompiler *c,
-        JanetSlot dest,
-        JanetSlot src) {
+    JanetCompiler *c,
+    JanetSlot dest,
+    JanetSlot src) {
     if (dest.flags & JANET_SLOT_CONSTANT) {
         janetc_cerror(c, "cannot write to constant");
         return;
@@ -252,7 +251,7 @@ void janetc_copy(
 static int32_t emit1s(JanetCompiler *c, uint8_t op, JanetSlot s, int32_t rest, int wr) {
     int32_t reg = janetc_regnear(c, s, JANETC_REGTEMP_0);
     int32_t label = janet_v_count(c->buffer);
-    janetc_emit(c, op | (reg << 8) | (rest << 16));
+    janetc_emit(c, op | (reg << 8) | ((uint32_t)rest << 16));
     if (wr)
         janetc_moveback(c, s, reg);
     janetc_free_regnear(c, s, reg, JANETC_REGTEMP_0);
@@ -294,7 +293,7 @@ static int32_t emit2s(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2,
     int32_t reg1 = janetc_regnear(c, s1, JANETC_REGTEMP_0);
     int32_t reg2 = janetc_regnear(c, s2, JANETC_REGTEMP_1);
     int32_t label = janet_v_count(c->buffer);
-    janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | (rest << 24));
+    janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | ((uint32_t)rest << 24));
     janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1);
     if (wr)
         janetc_moveback(c, s1, reg1);
@@ -327,7 +326,7 @@ int32_t janetc_emit_sss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2
     int32_t reg2 = janetc_regnear(c, s2, JANETC_REGTEMP_1);
     int32_t reg3 = janetc_regnear(c, s3, JANETC_REGTEMP_2);
     int32_t label = janet_v_count(c->buffer);
-    janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | (reg3 << 24));
+    janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | ((uint32_t)reg3 << 24));
     janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1);
     janetc_free_regnear(c, s3, reg3, JANETC_REGTEMP_2);
     if (wr)

src/core/fiber.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "fiber.h"
 #include "state.h"
 #include "gc.h"
@@ -138,11 +138,8 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
     int32_t next_arity = fiber->stacktop - fiber->stackstart;
 
     /* Check strict arity before messing with state */
-    if (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) {
-        if (func->def->arity != next_arity) {
-            return 1;
-        }
-    }
+    if (next_arity < func->def->min_arity) return 1;
+    if (next_arity > func->def->max_arity) return 1;
 
     if (fiber->capacity < nextstacktop) {
         janet_fiber_setcapacity(fiber, 2 * nextstacktop);
@@ -170,8 +167,8 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
             fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(NULL, 0));
         } else {
             fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(
-                fiber->data + tuplehead,
-                oldtop - tuplehead));
+                                         fiber->data + tuplehead,
+                                         oldtop - tuplehead));
         }
     }
 
@@ -204,11 +201,8 @@ int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) {
     int32_t stacksize;
 
     /* Check strict arity before messing with state */
-    if (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) {
-        if (func->def->arity != next_arity) {
-            return 1;
-        }
-    }
+    if (next_arity < func->def->min_arity) return 1;
+    if (next_arity > func->def->max_arity) return 1;
 
     if (fiber->capacity < nextstacktop) {
         janet_fiber_setcapacity(fiber, 2 * nextstacktop);
@@ -231,8 +225,8 @@ int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) {
             fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(NULL, 0));
         } else {
             fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(
-                fiber->data + tuplehead,
-                fiber->stacktop - tuplehead));
+                                         fiber->data + tuplehead,
+                                         fiber->stacktop - tuplehead));
         }
         stacksize = tuplehead - fiber->stackstart + 1;
     } else {
@@ -303,10 +297,8 @@ static Janet cfun_fiber_new(int32_t argc, Janet *argv) {
     janet_arity(argc, 1, 2);
     JanetFunction *func = janet_getfunction(argv, 0);
     JanetFiber *fiber;
-    if (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) {
-        if (func->def->arity != 0) {
-            janet_panic("expected nullary function in fiber constructor");
-        }
+    if (func->def->min_arity != 0) {
+        janet_panic("expected nullary function in fiber constructor");
     }
     fiber = janet_fiber(func, 64, 0, NULL);
     if (argc == 2) {
@@ -352,7 +344,7 @@ 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;
+                 JANET_FIBER_STATUS_OFFSET;
     return janet_ckeywordv(janet_status_names[s]);
 }
 
@@ -383,50 +375,50 @@ static const JanetReg fiber_cfuns[] = {
     {
         "fiber/new", cfun_fiber_new,
         JDOC("(fiber/new func [,sigmask])\n\n"
-                "Create a new fiber with function body func. Can optionally "
-                "take a set of signals to block from the current parent fiber "
-                "when called. The mask is specified as a keyword where each character "
-                "is used to indicate a signal to block. The default sigmask is :y. "
-                "For example, \n\n"
-                "\t(fiber/new myfun :e123)\n\n"
-                "blocks error signals and user signals 1, 2 and 3. The signals are "
-                "as follows: \n\n"
-                "\ta - block all signals\n"
-                "\td - block debug signals\n"
-                "\te - block error signals\n"
-                "\tu - block user signals\n"
-                "\ty - block yield signals\n"
-                "\t0-9 - block a specific user signal")
+             "Create a new fiber with function body func. Can optionally "
+             "take a set of signals to block from the current parent fiber "
+             "when called. The mask is specified as a keyword where each character "
+             "is used to indicate a signal to block. The default sigmask is :y. "
+             "For example, \n\n"
+             "\t(fiber/new myfun :e123)\n\n"
+             "blocks error signals and user signals 1, 2 and 3. The signals are "
+             "as follows: \n\n"
+             "\ta - block all signals\n"
+             "\td - block debug signals\n"
+             "\te - block error signals\n"
+             "\tu - block user signals\n"
+             "\ty - block yield signals\n"
+             "\t0-9 - block a specific user signal")
     },
     {
         "fiber/status", cfun_fiber_status,
         JDOC("(fiber/status fib)\n\n"
-                "Get the status of a fiber. The status will be one of:\n\n"
-                "\t:dead - the fiber has finished\n"
-                "\t:error - the fiber has errored out\n"
-                "\t:debug - the fiber is suspended in debug mode\n"
-                "\t:pending - the fiber has been yielded\n"
-                "\t:user(0-9) - the fiber is suspended by a user signal\n"
-                "\t:alive - the fiber is currently running and cannot be resumed\n"
-                "\t:new - the fiber has just been created and not yet run")
+             "Get the status of a fiber. The status will be one of:\n\n"
+             "\t:dead - the fiber has finished\n"
+             "\t:error - the fiber has errored out\n"
+             "\t:debug - the fiber is suspended in debug mode\n"
+             "\t:pending - the fiber has been yielded\n"
+             "\t:user(0-9) - the fiber is suspended by a user signal\n"
+             "\t:alive - the fiber is currently running and cannot be resumed\n"
+             "\t:new - the fiber has just been created and not yet run")
     },
     {
         "fiber/current", cfun_fiber_current,
         JDOC("(fiber/current)\n\n"
-                "Returns the currently running fiber.")
+             "Returns the currently running fiber.")
     },
     {
         "fiber/maxstack", cfun_fiber_maxstack,
         JDOC("(fiber/maxstack fib)\n\n"
-                "Gets the maximum stack size in janet values allowed for a fiber. While memory for "
-                "the fiber's stack is not allocated up front, the fiber will not allocated more "
-                "than this amount and will throw a stack-overflow error if more memory is needed. ")
+             "Gets the maximum stack size in janet values allowed for a fiber. While memory for "
+             "the fiber's stack is not allocated up front, the fiber will not allocated more "
+             "than this amount and will throw a stack-overflow error if more memory is needed. ")
     },
     {
         "fiber/setmaxstack", cfun_fiber_setmaxstack,
         JDOC("(fiber/setmaxstack fib maxstack)\n\n"
-                "Sets the maximum stack size in janet values for a fiber. By default, the "
-                "maximum stack size is usually 8192.")
+             "Sets the maximum stack size in janet values for a fiber. By default, the "
+             "maximum stack size is usually 8192.")
     },
     {NULL, NULL, NULL}
 };

src/core/fiber.h

@@ -24,7 +24,7 @@
 #define JANET_FIBER_H_defined
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #endif
 
 extern JANET_THREAD_LOCAL JanetFiber *janet_vm_fiber;

src/core/gc.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "state.h"
 #include "symcache.h"
 #include "gc.h"
@@ -60,18 +60,37 @@ void janet_mark(Janet x) {
     if (depth) {
         depth--;
         switch (janet_type(x)) {
-            default: break;
+            default:
+                break;
             case JANET_STRING:
             case JANET_KEYWORD:
-            case JANET_SYMBOL: janet_mark_string(janet_unwrap_string(x)); break;
-            case JANET_FUNCTION: janet_mark_function(janet_unwrap_function(x)); break;
-            case JANET_ARRAY: janet_mark_array(janet_unwrap_array(x)); break;
-            case JANET_TABLE: janet_mark_table(janet_unwrap_table(x)); break;
-            case JANET_STRUCT: janet_mark_struct(janet_unwrap_struct(x)); break;
-            case JANET_TUPLE: janet_mark_tuple(janet_unwrap_tuple(x)); break;
-            case JANET_BUFFER: janet_mark_buffer(janet_unwrap_buffer(x)); break;
-            case JANET_FIBER: janet_mark_fiber(janet_unwrap_fiber(x)); break;
-            case JANET_ABSTRACT: janet_mark_abstract(janet_unwrap_abstract(x)); break;
+            case JANET_SYMBOL:
+                janet_mark_string(janet_unwrap_string(x));
+                break;
+            case JANET_FUNCTION:
+                janet_mark_function(janet_unwrap_function(x));
+                break;
+            case JANET_ARRAY:
+                janet_mark_array(janet_unwrap_array(x));
+                break;
+            case JANET_TABLE:
+                janet_mark_table(janet_unwrap_table(x));
+                break;
+            case JANET_STRUCT:
+                janet_mark_struct(janet_unwrap_struct(x));
+                break;
+            case JANET_TUPLE:
+                janet_mark_tuple(janet_unwrap_tuple(x));
+                break;
+            case JANET_BUFFER:
+                janet_mark_buffer(janet_unwrap_buffer(x));
+                break;
+            case JANET_FIBER:
+                janet_mark_fiber(janet_unwrap_fiber(x));
+                break;
+            case JANET_ABSTRACT:
+                janet_mark_abstract(janet_unwrap_abstract(x));
+                break;
         }
         depth++;
     } else {
@@ -80,7 +99,7 @@ void janet_mark(Janet x) {
 }
 
 static void janet_mark_string(const uint8_t *str) {
-    janet_gc_mark(janet_string_raw(str));
+    janet_gc_mark(janet_string_head(str));
 }
 
 static void janet_mark_buffer(JanetBuffer *buffer) {
@@ -123,7 +142,7 @@ static void janet_mark_array(JanetArray *array) {
 }
 
 static void janet_mark_table(JanetTable *table) {
-    recur: /* Manual tail recursion */
+recur: /* Manual tail recursion */
     if (janet_gc_reachable(table))
         return;
     janet_gc_mark(table);
@@ -135,16 +154,16 @@ static void janet_mark_table(JanetTable *table) {
 }
 
 static void janet_mark_struct(const JanetKV *st) {
-    if (janet_gc_reachable(janet_struct_raw(st)))
+    if (janet_gc_reachable(janet_struct_head(st)))
         return;
-    janet_gc_mark(janet_struct_raw(st));
+    janet_gc_mark(janet_struct_head(st));
     janet_mark_kvs(st, janet_struct_capacity(st));
 }
 
 static void janet_mark_tuple(const Janet *tuple) {
-    if (janet_gc_reachable(janet_tuple_raw(tuple)))
+    if (janet_gc_reachable(janet_tuple_head(tuple)))
         return;
-    janet_gc_mark(janet_tuple_raw(tuple));
+    janet_gc_mark(janet_tuple_head(tuple));
     janet_mark_many(tuple, janet_tuple_length(tuple));
 }
 
@@ -201,7 +220,7 @@ recur:
 
     /* Mark values on the argument stack */
     janet_mark_many(fiber->data + fiber->stackstart,
-            fiber->stacktop - fiber->stackstart);
+                    fiber->stacktop - fiber->stackstart);
 
     i = fiber->frame;
     j = fiber->stackstart - JANET_FRAME_SIZE;
@@ -225,21 +244,19 @@ recur:
 }
 
 /* Deinitialize a block of memory */
-static void janet_deinit_block(JanetGCMemoryHeader *block) {
-    void *mem = ((char *)(block + 1));
-    JanetAbstractHeader *h = (JanetAbstractHeader *)mem;
-    switch (block->flags & JANET_MEM_TYPEBITS) {
+static void janet_deinit_block(JanetGCObject *mem) {
+    switch (mem->flags & JANET_MEM_TYPEBITS) {
         default:
         case JANET_MEMORY_FUNCTION:
             break; /* Do nothing for non gc types */
         case JANET_MEMORY_SYMBOL:
-            janet_symbol_deinit((const uint8_t *)mem + 2 * sizeof(int32_t));
+            janet_symbol_deinit(((JanetStringHead *) mem)->data);
             break;
         case JANET_MEMORY_ARRAY:
-            janet_array_deinit((JanetArray*) mem);
+            janet_array_deinit((JanetArray *) mem);
             break;
         case JANET_MEMORY_TABLE:
-            janet_table_deinit((JanetTable*) mem);
+            janet_table_deinit((JanetTable *) mem);
             break;
         case JANET_MEMORY_FIBER:
             free(((JanetFiber *)mem)->data);
@@ -247,38 +264,38 @@ static void janet_deinit_block(JanetGCMemoryHeader *block) {
         case JANET_MEMORY_BUFFER:
             janet_buffer_deinit((JanetBuffer *) mem);
             break;
-        case JANET_MEMORY_ABSTRACT:
-            if (h->type->gc) {
-                janet_assert(!h->type->gc((void *)(h + 1), h->size), "finalizer failed");
+        case JANET_MEMORY_ABSTRACT: {
+            JanetAbstractHead *head = (JanetAbstractHead *)mem;
+            if (head->type->gc) {
+                janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
             }
-            break;
-        case JANET_MEMORY_FUNCENV:
-            {
-                JanetFuncEnv *env = (JanetFuncEnv *)mem;
-                if (0 == env->offset)
-                    free(env->as.values);
-            }
-            break;
-        case JANET_MEMORY_FUNCDEF:
-            {
-                JanetFuncDef *def = (JanetFuncDef *)mem;
-                /* TODO - get this all with one alloc and one free */
-                free(def->defs);
-                free(def->environments);
-                free(def->constants);
-                free(def->bytecode);
-                free(def->sourcemap);
-            }
-            break;
+        }
+        break;
+        case JANET_MEMORY_FUNCENV: {
+            JanetFuncEnv *env = (JanetFuncEnv *)mem;
+            if (0 == env->offset)
+                free(env->as.values);
+        }
+        break;
+        case JANET_MEMORY_FUNCDEF: {
+            JanetFuncDef *def = (JanetFuncDef *)mem;
+            /* TODO - get this all with one alloc and one free */
+            free(def->defs);
+            free(def->environments);
+            free(def->constants);
+            free(def->bytecode);
+            free(def->sourcemap);
+        }
+        break;
     }
 }
 
 /* Iterate over all allocated memory, and free memory that is not
  * marked as reachable. Flip the gc color flag for next sweep. */
 void janet_sweep() {
-    JanetGCMemoryHeader *previous = NULL;
-    JanetGCMemoryHeader *current = janet_vm_blocks;
-    JanetGCMemoryHeader *next;
+    JanetGCObject *previous = NULL;
+    JanetGCObject *current = janet_vm_blocks;
+    JanetGCObject *next;
     while (NULL != current) {
         next = current->next;
         if (current->flags & (JANET_MEM_REACHABLE | JANET_MEM_DISABLED)) {
@@ -299,29 +316,26 @@ void janet_sweep() {
 
 /* Allocate some memory that is tracked for garbage collection */
 void *janet_gcalloc(enum JanetMemoryType type, size_t size) {
-    JanetGCMemoryHeader *mdata;
-    size_t total = size + sizeof(JanetGCMemoryHeader);
+    JanetGCObject *mem;
 
     /* Make sure everything is inited */
     janet_assert(NULL != janet_vm_cache, "please initialize janet before use");
-    void *mem = malloc(total);
+    mem = malloc(size);
 
     /* Check for bad malloc */
     if (NULL == mem) {
         JANET_OUT_OF_MEMORY;
     }
 
-    mdata = (JanetGCMemoryHeader *)mem;
-
     /* Configure block */
-    mdata->flags = type;
+    mem->flags = type;
 
     /* Prepend block to heap list */
     janet_vm_next_collection += (int32_t) size;
-    mdata->next = janet_vm_blocks;
-    janet_vm_blocks = mdata;
+    mem->next = janet_vm_blocks;
+    janet_vm_blocks = mem;
 
-    return (char *) mem + sizeof(JanetGCMemoryHeader);
+    return (void *)mem;
 }
 
 /* Run garbage collection */
@@ -362,8 +376,7 @@ static int janet_gc_idequals(Janet lhs, Janet rhs) {
     if (janet_type(lhs) != janet_type(rhs))
         return 0;
     switch (janet_type(lhs)) {
-        case JANET_TRUE:
-        case JANET_FALSE:
+        case JANET_BOOLEAN:
         case JANET_NIL:
         case JANET_NUMBER:
             /* These values don't really matter to the gc so returning 1 all the time is fine. */
@@ -377,9 +390,8 @@ static int janet_gc_idequals(Janet lhs, Janet rhs) {
  * a value and all its children. */
 int janet_gcunroot(Janet root) {
     Janet *vtop = janet_vm_roots + janet_vm_root_count;
-    Janet *v = janet_vm_roots;
     /* Search from top to bottom as access is most likely LIFO */
-    for (v = janet_vm_roots; v < vtop; v++) {
+    for (Janet *v = janet_vm_roots; v < vtop; v++) {
         if (janet_gc_idequals(root, *v)) {
             *v = janet_vm_roots[--janet_vm_root_count];
             return 1;
@@ -391,10 +403,9 @@ int janet_gcunroot(Janet root) {
 /* Remove a root value from the GC. This sets the effective reference count to 0. */
 int janet_gcunrootall(Janet root) {
     Janet *vtop = janet_vm_roots + janet_vm_root_count;
-    Janet *v = janet_vm_roots;
     int ret = 0;
     /* Search from top to bottom as access is most likely LIFO */
-    for (v = janet_vm_roots; v < vtop; v++) {
+    for (Janet *v = janet_vm_roots; v < vtop; v++) {
         if (janet_gc_idequals(root, *v)) {
             *v = janet_vm_roots[--janet_vm_root_count];
             vtop--;
@@ -406,10 +417,10 @@ int janet_gcunrootall(Janet root) {
 
 /* Free all allocated memory */
 void janet_clear_memory(void) {
-    JanetGCMemoryHeader *current = janet_vm_blocks;
+    JanetGCObject *current = janet_vm_blocks;
     while (NULL != current) {
         janet_deinit_block(current);
-        JanetGCMemoryHeader *next = current->next;
+        JanetGCObject *next = current->next;
         free(current);
         current = next;
     }
@@ -417,5 +428,9 @@ void janet_clear_memory(void) {
 }
 
 /* Primitives for suspending GC. */
-int janet_gclock(void) { return janet_vm_gc_suspend++; }
-void janet_gcunlock(int handle) { janet_vm_gc_suspend = handle; }
+int janet_gclock(void) {
+    return janet_vm_gc_suspend++;
+}
+void janet_gcunlock(int handle) {
+    janet_vm_gc_suspend = handle;
+}

src/core/gc.h

@@ -24,11 +24,11 @@
 #define JANET_GC_H
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #endif
 
 /* The metadata header associated with an allocated block of memory */
-#define janet_gc_header(mem) ((JanetGCMemoryHeader *)(mem) - 1)
+#define janet_gc_header(mem) ((JanetGCObject *)(mem))
 
 #define JANET_MEM_TYPEBITS 0xFF
 #define JANET_MEM_REACHABLE 0x100
@@ -40,13 +40,6 @@
 #define janet_gc_mark(m) (janet_gc_header(m)->flags |= JANET_MEM_REACHABLE)
 #define janet_gc_reachable(m) (janet_gc_header(m)->flags & JANET_MEM_REACHABLE)
 
-/* Memory header struct. Node of a linked list of memory blocks. */
-typedef struct JanetGCMemoryHeader JanetGCMemoryHeader;
-struct JanetGCMemoryHeader {
-    JanetGCMemoryHeader *next;
-    uint32_t flags;
-};
-
 /* Memory types for the GC. Different from JanetType to include funcenv and funcdef. */
 enum JanetMemoryType {
     JANET_MEMORY_NONE,

src/core/io.c

@@ -28,7 +28,7 @@
 #include <errno.h>
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "util.h"
 #endif
 
@@ -56,6 +56,8 @@ JanetAbstractType cfun_io_filetype = {
     cfun_io_gc,
     NULL,
     io_file_get,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -122,7 +124,7 @@ static Janet cfun_io_popen(int32_t argc, Janet *argv) {
     if (argc == 2) {
         fmode = janet_getkeyword(argv, 1);
         if (janet_string_length(fmode) != 1 ||
-            !(fmode[0] == 'r' || fmode[0] == 'w')) {
+                !(fmode[0] == 'r' || fmode[0] == 'w')) {
             janet_panicf("invalid file mode :%S, expected :r or :w", fmode);
         }
         flags = IO_PIPED | (fmode[0] == 'r' ? IO_READ : IO_WRITE);
@@ -195,6 +197,12 @@ static Janet cfun_io_fread(int32_t argc, Janet *argv) {
             } else {
                 fseek(iof->file, 0, SEEK_END);
                 long fsize = ftell(iof->file);
+                if (fsize < 0) {
+                    janet_panicf("could not get file size of %v", argv[0]);
+                }
+                if (fsize > (INT32_MAX)) {
+                    janet_panic("file to large to read into buffer");
+                }
                 fseek(iof->file, 0, SEEK_SET);
                 read_chunk(iof, buffer, (int32_t) fsize);
             }
@@ -328,84 +336,93 @@ static const JanetReg io_cfuns[] = {
     {
         "file/open", cfun_io_fopen,
         JDOC("(file/open path [,mode])\n\n"
-                "Open a file. path is an absolute or relative path, and "
-                "mode is a set of flags indicating the mode to open the file in. "
-                "mode is a keyword where each character represents a flag. If the file "
-                "cannot be opened, returns nil, otherwise returns the new file handle. "
-                "Mode flags:\n\n"
-                "\tr - allow reading from the file\n"
-                "\tw - allow writing to the file\n"
-                "\ta - append to the file\n"
-                "\tb - open the file in binary mode (rather than text mode)\n"
-                "\t+ - append to the file instead of overwriting it")
+             "Open a file. path is an absolute or relative path, and "
+             "mode is a set of flags indicating the mode to open the file in. "
+             "mode is a keyword where each character represents a flag. If the file "
+             "cannot be opened, returns nil, otherwise returns the new file handle. "
+             "Mode flags:\n\n"
+             "\tr - allow reading from the file\n"
+             "\tw - allow writing to the file\n"
+             "\ta - append to the file\n"
+             "\tb - open the file in binary mode (rather than text mode)\n"
+             "\t+ - append to the file instead of overwriting it")
     },
     {
         "file/close", cfun_io_fclose,
         JDOC("(file/close f)\n\n"
-                "Close a file and release all related resources. When you are "
-                "done reading a file, close it to prevent a resource leak and let "
-                "other processes read the file.")
+             "Close a file and release all related resources. When you are "
+             "done reading a file, close it to prevent a resource leak and let "
+             "other processes read the file.")
     },
     {
         "file/read", cfun_io_fread,
         JDOC("(file/read f what [,buf])\n\n"
-                "Read a number of bytes from a file into a buffer. A buffer can "
-                "be provided as an optional fourth argument, otherwise a new buffer "
-                "is created. 'what' can either be an integer or a keyword. Returns the "
-                "buffer with file contents. "
-                "Values for 'what':\n\n"
-                "\t:all - read the whole file\n"
-                "\t:line - read up to and including the next newline character\n"
-                "\tn (integer) - read up to n bytes from the file")
+             "Read a number of bytes from a file into a buffer. A buffer can "
+             "be provided as an optional fourth argument, otherwise a new buffer "
+             "is created. 'what' can either be an integer or a keyword. Returns the "
+             "buffer with file contents. "
+             "Values for 'what':\n\n"
+             "\t:all - read the whole file\n"
+             "\t:line - read up to and including the next newline character\n"
+             "\tn (integer) - read up to n bytes from the file")
     },
     {
         "file/write", cfun_io_fwrite,
         JDOC("(file/write f bytes)\n\n"
-                "Writes to a file. 'bytes' must be string, buffer, or symbol. Returns the "
-                "file.")
+             "Writes to a file. 'bytes' must be string, buffer, or symbol. Returns the "
+             "file.")
     },
     {
         "file/flush", cfun_io_fflush,
         JDOC("(file/flush f)\n\n"
-                "Flush any buffered bytes to the file system. In most files, writes are "
-                "buffered for efficiency reasons. Returns the file handle.")
+             "Flush any buffered bytes to the file system. In most files, writes are "
+             "buffered for efficiency reasons. Returns the file handle.")
     },
     {
         "file/seek", cfun_io_fseek,
         JDOC("(file/seek f [,whence [,n]])\n\n"
-                "Jump to a relative location in the file. 'whence' must be one of\n\n"
-                "\t:cur - jump relative to the current file location\n"
-                "\t:set - jump relative to the beginning of the file\n"
-                "\t:end - jump relative to the end of the file\n\n"
-                "By default, 'whence' is :cur. Optionally a value n may be passed "
-                "for the relative number of bytes to seek in the file. n may be a real "
-                "number to handle large files of more the 4GB. Returns the file handle.")
+             "Jump to a relative location in the file. 'whence' must be one of\n\n"
+             "\t:cur - jump relative to the current file location\n"
+             "\t:set - jump relative to the beginning of the file\n"
+             "\t:end - jump relative to the end of the file\n\n"
+             "By default, 'whence' is :cur. Optionally a value n may be passed "
+             "for the relative number of bytes to seek in the file. n may be a real "
+             "number to handle large files of more the 4GB. Returns the file handle.")
     },
     {
         "file/popen", cfun_io_popen,
         JDOC("(file/popen path [,mode])\n\n"
-                "Open a file that is backed by a process. The file must be opened in either "
-                "the :r (read) or the :w (write) mode. In :r mode, the stdout of the "
-                "process can be read from the file. In :w mode, the stdin of the process "
-                "can be written to. Returns the new file.")
+             "Open a file that is backed by a process. The file must be opened in either "
+             "the :r (read) or the :w (write) mode. In :r mode, the stdout of the "
+             "process can be read from the file. In :w mode, the stdin of the process "
+             "can be written to. Returns the new file.")
     },
     {NULL, NULL, NULL}
 };
 
+/* C API */
+
+FILE *janet_getfile(const Janet *argv, int32_t n, int *flags) {
+    IOFile *iof = janet_getabstract(argv, n, &cfun_io_filetype);
+    if (NULL != flags) *flags = iof->flags;
+    return iof->file;
+}
+
 /* Module entry point */
 void janet_lib_io(JanetTable *env) {
     janet_core_cfuns(env, NULL, io_cfuns);
 
     /* stdout */
     janet_core_def(env, "stdout",
-            makef(stdout, IO_APPEND | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
-            JDOC("The standard output file."));
+                   makef(stdout, IO_APPEND | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
+                   JDOC("The standard output file."));
     /* stderr */
     janet_core_def(env, "stderr",
-            makef(stderr, IO_APPEND | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
-            JDOC("The standard error file."));
+                   makef(stderr, IO_APPEND | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
+                   JDOC("The standard error file."));
     /* stdin */
     janet_core_def(env, "stdin",
-            makef(stdin, IO_READ | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
-            JDOC("The standard input file."));
+                   makef(stdin, IO_READ | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
+                   JDOC("The standard input file."));
+
 }

src/core/math.c

@@ -23,12 +23,12 @@
 #include <math.h>
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "util.h"
 #endif
 
 /* Get a random number */
-Janet janet_rand(int32_t argc, Janet *argv) {
+static Janet janet_rand(int32_t argc, Janet *argv) {
     (void) argv;
     janet_fixarity(argc, 0);
     double r = (rand() % RAND_MAX) / ((double) RAND_MAX);
@@ -36,14 +36,14 @@ Janet janet_rand(int32_t argc, Janet *argv) {
 }
 
 /* Seed the random number generator */
-Janet janet_srand(int32_t argc, Janet *argv) {
+static Janet janet_srand(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 1);
     int32_t x = janet_getinteger(argv, 0);
     srand((unsigned) x);
     return janet_wrap_nil();
 }
 
-Janet janet_remainder(int32_t argc, Janet *argv) {
+static Janet janet_remainder(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     double x = janet_getnumber(argv, 0);
     double y = janet_getnumber(argv, 1);
@@ -51,7 +51,7 @@ Janet janet_remainder(int32_t argc, Janet *argv) {
 }
 
 #define JANET_DEFINE_MATHOP(name, fop)\
-Janet janet_##name(int32_t argc, Janet *argv) {\
+static Janet janet_##name(int32_t argc, Janet *argv) {\
     janet_fixarity(argc, 1); \
     double x = janet_getnumber(argv, 0); \
     return janet_wrap_number(fop(x)); \
@@ -75,7 +75,7 @@ JANET_DEFINE_MATHOP(fabs, fabs)
 JANET_DEFINE_MATHOP(floor, floor)
 
 #define JANET_DEFINE_MATH2OP(name, fop)\
-Janet janet_##name(int32_t argc, Janet *argv) {\
+static Janet janet_##name(int32_t argc, Janet *argv) {\
     janet_fixarity(argc, 2); \
     double lhs = janet_getnumber(argv, 0); \
     double rhs = janet_getnumber(argv, 1); \
@@ -94,7 +94,7 @@ static const JanetReg math_cfuns[] = {
     {
         "%", janet_remainder,
         JDOC("(% dividend divisor)\n\n"
-                "Returns the remainder of dividend / divisor.")
+             "Returns the remainder of dividend / divisor.")
     },
     {
         "not", janet_not,
@@ -103,78 +103,103 @@ static const JanetReg math_cfuns[] = {
     {
         "math/random", janet_rand,
         JDOC("(math/random)\n\n"
-                "Returns a uniformly distributed random number between 0 and 1.")
+             "Returns a uniformly distributed random number between 0 and 1.")
     },
     {
         "math/seedrandom", janet_srand,
         JDOC("(math/seedrandom seed)\n\n"
-                "Set the seed for the random number generator. 'seed' should be an "
-                "an integer.")
+             "Set the seed for the random number generator. 'seed' should be an "
+             "an integer.")
     },
     {
         "math/cos", janet_cos,
         JDOC("(math/cos x)\n\n"
-                "Returns the cosine of x.")
+             "Returns the cosine of x.")
     },
     {
         "math/sin", janet_sin,
         JDOC("(math/sin x)\n\n"
-                "Returns the sine of x.")
+             "Returns the sine of x.")
     },
     {
         "math/tan", janet_tan,
         JDOC("(math/tan x)\n\n"
-                "Returns the tangent of x.")
+             "Returns the tangent of x.")
     },
     {
         "math/acos", janet_acos,
         JDOC("(math/acos x)\n\n"
-                "Returns the arccosine of x.")
+             "Returns the arccosine of x.")
     },
     {
         "math/asin", janet_asin,
         JDOC("(math/asin x)\n\n"
-                "Returns the arcsine of x.")
+             "Returns the arcsine of x.")
     },
     {
         "math/atan", janet_atan,
         JDOC("(math/atan x)\n\n"
-                "Returns the arctangent of x.")
+             "Returns the arctangent of x.")
     },
     {
         "math/exp", janet_exp,
         JDOC("(math/exp x)\n\n"
-                "Returns e to the power of x.")
+             "Returns e to the power of x.")
     },
     {
         "math/log", janet_log,
         JDOC("(math/log x)\n\n"
-                "Returns log base 2 of x.")
+             "Returns log base 2 of x.")
     },
     {
         "math/log10", janet_log10,
         JDOC("(math/log10 x)\n\n"
-                "Returns log base 10 of x.")
+             "Returns log base 10 of x.")
     },
     {
         "math/sqrt", janet_sqrt,
         JDOC("(math/sqrt x)\n\n"
-                "Returns the square root of x.")
+             "Returns the square root of x.")
     },
     {
         "math/floor", janet_floor,
         JDOC("(math/floor x)\n\n"
-                "Returns the largest integer value number that is not greater than x.")
+             "Returns the largest integer value number that is not greater than x.")
     },
     {
         "math/ceil", janet_ceil,
         JDOC("(math/ceil x)\n\n"
-                "Returns the smallest integer value number that is not less than x.")
+             "Returns the smallest integer value number that is not less than x.")
     },
     {
         "math/pow", janet_pow,
         JDOC("(math/pow a x)\n\n"
-                "Return a to the power of x.")
+             "Return a to the power of x.")
+    },
+    {
+        "math/abs", janet_fabs,
+        JDOC("(math/abs x)\n\n"
+             "Return the absolute value of x.")
+    },
+    {
+        "math/sinh", janet_sinh,
+        JDOC("(math/sinh x)\n\n"
+             "Return the hyperbolic sine of x.")
+    },
+    {
+        "math/cosh", janet_cosh,
+        JDOC("(math/cosh x)\n\n"
+             "Return the hyperbolic cosine of x.")
+    },
+    {
+        "math/tanh", janet_tanh,
+        JDOC("(math/tanh x)\n\n"
+             "Return the hyperbolic tangent of x.")
+    },
+    {
+        "math/atan2", janet_atan2,
+        JDOC("(math/atan2 y x)\n\n"
+             "Return the arctangent of y/x. Works even when x is 0.")
     },
     {NULL, NULL, NULL}
 };
@@ -184,10 +209,10 @@ void janet_lib_math(JanetTable *env) {
     janet_core_cfuns(env, NULL, math_cfuns);
 #ifdef JANET_BOOTSTRAP
     janet_def(env, "math/pi", janet_wrap_number(3.1415926535897931),
-            JDOC("The value pi."));
+              JDOC("The value pi."));
     janet_def(env, "math/e", janet_wrap_number(2.7182818284590451),
-            JDOC("The base of the natural log."));
+              JDOC("The base of the natural log."));
     janet_def(env, "math/inf", janet_wrap_number(INFINITY),
-            JDOC("The number representing positive infinity"));
+              JDOC("The number representing positive infinity"));
 #endif
 }

src/core/os.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "util.h"
 #endif
 
@@ -47,15 +47,15 @@
 static Janet os_which(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 0);
     (void) argv;
-    #ifdef JANET_WINDOWS
-        return janet_ckeywordv("windows");
-    #elif __APPLE__
-        return janet_ckeywordv("macos");
-    #elif defined(__EMSCRIPTEN__)
-        return janet_ckeywordv("web");
-    #else
-        return janet_ckeywordv("posix");
-    #endif
+#ifdef JANET_WINDOWS
+    return janet_ckeywordv("windows");
+#elif __APPLE__
+    return janet_ckeywordv("macos");
+#elif defined(__EMSCRIPTEN__)
+    return janet_ckeywordv("web");
+#else
+    return janet_ckeywordv("posix");
+#endif
 }
 
 #ifdef JANET_WINDOWS
@@ -77,12 +77,12 @@ static Janet os_execute(int32_t argc, Janet *argv) {
         JANET_OUT_OF_MEMORY;
     }
     int nwritten = MultiByteToWideChar(
-        CP_UTF8,
-        MB_PRECOMPOSED,
-        buffer->data,
-        buffer->count,
-        sys_str,
-        buffer->count);
+                       CP_UTF8,
+                       MB_PRECOMPOSED,
+                       buffer->data,
+                       buffer->count,
+                       sys_str,
+                       buffer->count);
     if (nwritten == 0) {
         free(sys_str);
         janet_panic("could not create process");
@@ -96,16 +96,16 @@ static Janet os_execute(int32_t argc, Janet *argv) {
     ZeroMemory(&pi, sizeof(pi));
 
     // Start the child process.
-    if(!CreateProcess(NULL,
-                (LPSTR) sys_str,
-                NULL,
-                NULL,
-                FALSE,
-                0,
-                NULL,
-                NULL,
-                &si,
-                &pi)) {
+    if (!CreateProcess(NULL,
+                       (LPSTR) sys_str,
+                       NULL,
+                       NULL,
+                       FALSE,
+                       0,
+                       NULL,
+                       NULL,
+                       &si,
+                       &pi)) {
         free(sys_str);
         janet_panic("could not create process");
     }
@@ -125,6 +125,7 @@ static Janet os_execute(int32_t argc, Janet *argv) {
 static Janet os_execute(int32_t argc, Janet *argv) {
     janet_arity(argc, 1, -1);
     const uint8_t **child_argv = malloc(sizeof(uint8_t *) * (argc + 1));
+    int status = 0;
     if (NULL == child_argv) {
         JANET_OUT_OF_MEMORY;
     }
@@ -141,9 +142,10 @@ static Janet os_execute(int32_t argc, Janet *argv) {
         if (-1 == execve((const char *)child_argv[0], (char **)child_argv, NULL)) {
             exit(1);
         }
+    } else {
+        waitpid(pid, &status, 0);
     }
-    int status;
-    waitpid(pid, &status, 0);
+    free(child_argv);
     return janet_wrap_integer(status);
 }
 #endif
@@ -151,12 +153,12 @@ static Janet os_execute(int32_t argc, Janet *argv) {
 static Janet os_shell(int32_t argc, Janet *argv) {
     janet_arity(argc, 0, 1);
     const char *cmd = argc
-        ? (const char *)janet_getstring(argv, 0)
-        : NULL;
+                      ? (const char *)janet_getstring(argv, 0)
+                      : NULL;
     int stat = system(cmd);
     return argc
-        ? janet_wrap_integer(stat)
-        : janet_wrap_boolean(stat);
+           ? janet_wrap_integer(stat)
+           : janet_wrap_boolean(stat);
 }
 
 static Janet os_getenv(int32_t argc, Janet *argv) {
@@ -165,8 +167,8 @@ static Janet os_getenv(int32_t argc, Janet *argv) {
     const char *cstr = (const char *) k;
     const char *res = getenv(cstr);
     return (res && cstr)
-        ? janet_cstringv(res)
-        : janet_wrap_nil();
+           ? janet_cstringv(res)
+           : janet_wrap_nil();
 }
 
 static Janet os_setenv(int32_t argc, Janet *argv) {
@@ -212,7 +214,7 @@ static Janet os_time(int32_t argc, Janet *argv) {
 #ifdef JANET_WINDOWS
 static int gettime(struct timespec *spec) {
     int64_t wintime = 0LL;
-    GetSystemTimeAsFileTime((FILETIME*)&wintime);
+    GetSystemTimeAsFileTime((FILETIME *)&wintime);
     /* Windows epoch is January 1, 1601 apparently*/
     wintime -= 116444736000000000LL;
     spec->tv_sec  = wintime / 10000000LL;
@@ -249,13 +251,13 @@ static Janet os_sleep(int32_t argc, Janet *argv) {
     double delay = janet_getnumber(argv, 0);
     if (delay < 0) janet_panic("invalid argument to sleep");
 #ifdef JANET_WINDOWS
-    Sleep((DWORD) (delay * 1000));
+    Sleep((DWORD)(delay * 1000));
 #else
     struct timespec ts;
     ts.tv_sec = (time_t) delay;
     ts.tv_nsec = (delay <= UINT32_MAX)
-        ? (long)((delay - ((uint32_t)delay)) * 1000000000)
-        : 0;
+                 ? (long)((delay - ((uint32_t)delay)) * 1000000000)
+                 : 0;
     nanosleep(&ts, NULL);
 #endif
     return janet_wrap_nil();
@@ -303,75 +305,75 @@ static const JanetReg os_cfuns[] = {
     {
         "os/which", os_which,
         JDOC("(os/which)\n\n"
-                "Check the current operating system. Returns one of:\n\n"
-                "\t:windows - Microsoft Windows\n"
-                "\t:macos - Apple macos\n"
-                "\t:posix - A POSIX compatible system (default)")
+             "Check the current operating system. Returns one of:\n\n"
+             "\t:windows - Microsoft Windows\n"
+             "\t:macos - Apple macos\n"
+             "\t:posix - A POSIX compatible system (default)")
     },
     {
         "os/execute", os_execute,
         JDOC("(os/execute program & args)\n\n"
-                "Execute a program on the system and pass it string arguments. Returns "
-                "the exit status of the program.")
+             "Execute a program on the system and pass it string arguments. Returns "
+             "the exit status of the program.")
     },
     {
         "os/shell", os_shell,
         JDOC("(os/shell str)\n\n"
-                "Pass a command string str directly to the system shell.")
+             "Pass a command string str directly to the system shell.")
     },
     {
         "os/exit", os_exit,
         JDOC("(os/exit x)\n\n"
-                "Exit from janet with an exit code equal to x. If x is not an integer, "
-                "the exit with status equal the hash of x.")
+             "Exit from janet with an exit code equal to x. If x is not an integer, "
+             "the exit with status equal the hash of x.")
     },
     {
         "os/getenv", os_getenv,
         JDOC("(os/getenv variable)\n\n"
-                "Get the string value of an environment variable.")
+             "Get the string value of an environment variable.")
     },
     {
         "os/setenv", os_setenv,
         JDOC("(os/setenv variable value)\n\n"
-            "Set an environment variable.")
+             "Set an environment variable.")
     },
     {
         "os/time", os_time,
         JDOC("(os/time)\n\n"
-            "Get the current time expressed as the number of seconds since "
-            "January 1, 1970, the Unix epoch. Returns a real number.")
+             "Get the current time expressed as the number of seconds since "
+             "January 1, 1970, the Unix epoch. Returns a real number.")
     },
     {
         "os/clock", os_clock,
         JDOC("(os/clock)\n\n"
-            "Return the number of seconds since some fixed point in time. The clock "
-            "is guaranteed to be non decreasing in real time.")
+             "Return the number of seconds since some fixed point in time. The clock "
+             "is guaranteed to be non decreasing in real time.")
     },
     {
         "os/sleep", os_sleep,
         JDOC("(os/sleep nsec)\n\n"
-            "Suspend the program for nsec seconds. 'nsec' can be a real number. Returns "
-            "nil.")
+             "Suspend the program for nsec seconds. 'nsec' can be a real number. Returns "
+             "nil.")
     },
     {
         "os/cwd", os_cwd,
         JDOC("(os/cwd)\n\n"
-            "Returns the current working directory.")
+             "Returns the current working directory.")
     },
     {
         "os/date", os_date,
         JDOC("(os/date [,time])\n\n"
-            "Returns the given time as a date struct, or the current time if no time is given. "
-            "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: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"
-            "\t:week-day - day of the week [0-6]\n"
-            "\t:year-day - day of the year [0-365]\n"
-            "\t:dst - If Day Light Savings is in effect")
+             "Returns the given time as a date struct, or the current time if no time is given. "
+             "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: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"
+             "\t:week-day - day of the week [0-6]\n"
+             "\t:year-day - day of the year [0-365]\n"
+             "\t:dst - If Day Light Savings is in effect")
     },
     {NULL, NULL, NULL}
 };

src/core/parse.c

@@ -21,18 +21,19 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "util.h"
 #endif
 
 /* Check if a character is whitespace */
 static int is_whitespace(uint8_t c) {
     return c == ' '
-        || c == '\t'
-        || c == '\n'
-        || c == '\r'
-        || c == '\0'
-        || c == '\f';
+           || c == '\t'
+           || c == '\n'
+           || c == '\r'
+           || c == '\0'
+           || c == '\v'
+           || c == '\f';
 }
 
 /* Code generated by tools/symcharsgen.c.
@@ -48,7 +49,7 @@ static const uint32_t symchars[8] = {
 /* Check if a character is a valid symbol character
  * symbol chars are A-Z, a-z, 0-9, or one of !$&*+-./:<=>@\^_~| */
 static int is_symbol_char(uint8_t c) {
-    return symchars[c >> 5] & (1 << (c & 0x1F));
+    return symchars[c >> 5] & ((uint32_t)1 << (c & 0x1F));
 }
 
 /* Validate some utf8. Useful for identifiers. Only validates
@@ -191,17 +192,30 @@ static void popstate(JanetParser *p, Janet val) {
 
 static int checkescape(uint8_t c) {
     switch (c) {
-        default: return -1;
-        case 'x': return 1;
-        case 'n': return '\n';
-        case 't': return '\t';
-        case 'r': return '\r';
-        case '0': return '\0';
-        case 'z': return '\0';
-        case 'f': return '\f';
-        case 'e': return 27;
-        case '"': return '"';
-        case '\\': return '\\';
+        default:
+            return -1;
+        case 'x':
+            return 1;
+        case 'n':
+            return '\n';
+        case 't':
+            return '\t';
+        case 'r':
+            return '\r';
+        case '0':
+            return '\0';
+        case 'z':
+            return '\0';
+        case 'f':
+            return '\f';
+        case 'v':
+            return '\v';
+        case 'e':
+            return 27;
+        case '"':
+            return '"';
+        case '\\':
+            return '\\';
     }
 }
 
@@ -335,8 +349,9 @@ static int comment(JanetParser *p, JanetParseState *state, uint8_t c) {
     return 1;
 }
 
-static Janet close_tuple(JanetParser *p, JanetParseState *state) {
+static Janet close_tuple(JanetParser *p, JanetParseState *state, int32_t flag) {
     Janet *ret = janet_tuple_begin(state->argn);
+    janet_tuple_flag(ret) |= flag;
     for (int32_t i = state->argn - 1; i >= 0; i--)
         ret[i] = p->args[--p->argcount];
     return janet_wrap_tuple(janet_tuple_end(ret));
@@ -420,23 +435,23 @@ static int ampersand(JanetParser *p, JanetParseState *state, uint8_t c) {
     (void) state;
     p->statecount--;
     switch (c) {
-    case '{':
-        pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM);
-        return 1;
-    case '"':
-        pushstate(p, stringchar, PFLAG_BUFFER | PFLAG_STRING);
-        return 1;
-    case '`':
-        pushstate(p, longstring, PFLAG_BUFFER | PFLAG_LONGSTRING);
-        return 1;
-    case '[':
-        pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM);
-        return 1;
-    case '(':
-        pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM);
-        return 1;
-    default:
-        break;
+        case '{':
+            pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM);
+            return 1;
+        case '"':
+            pushstate(p, stringchar, PFLAG_BUFFER | PFLAG_STRING);
+            return 1;
+        case '`':
+            pushstate(p, longstring, PFLAG_BUFFER | PFLAG_LONGSTRING);
+            return 1;
+        case '[':
+            pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM);
+            return 1;
+        case '(':
+            pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM);
+            return 1;
+        default:
+            break;
     }
     pushstate(p, tokenchar, 0);
     push_buf(p, '@'); /* Push the leading ampersand that was dropped */
@@ -474,37 +489,36 @@ static int root(JanetParser *p, JanetParseState *state, uint8_t c) {
             return 1;
         case ')':
         case ']':
-        case '}':
-            {
-                Janet ds;
-                if (p->statecount == 1) {
-                    p->error = "unexpected delimiter";
-                    return 1;
-                }
-                if ((c == ')' && (state->flags & PFLAG_PARENS)) ||
-                        (c == ']' && (state->flags & PFLAG_SQRBRACKETS))) {
-                    if (state->flags & PFLAG_ATSYM) {
-                        ds = close_array(p, state);
-                    } else {
-                        ds = close_tuple(p, state);
-                    }
-                } else if (c == '}' && (state->flags & PFLAG_CURLYBRACKETS)) {
-                    if (state->argn & 1) {
-                        p->error = "struct and table literals expect even number of arguments";
-                        return 1;
-                    }
-                    if (state->flags & PFLAG_ATSYM) {
-                        ds = close_table(p, state);
-                    } else {
-                        ds = close_struct(p, state);
-                    }
-                } else {
-                    p->error = "mismatched delimiter";
-                    return 1;
-                }
-                popstate(p, ds);
+        case '}': {
+            Janet ds;
+            if (p->statecount == 1) {
+                p->error = "unexpected delimiter";
+                return 1;
             }
-            return 1;
+            if ((c == ')' && (state->flags & PFLAG_PARENS)) ||
+                    (c == ']' && (state->flags & PFLAG_SQRBRACKETS))) {
+                if (state->flags & PFLAG_ATSYM) {
+                    ds = close_array(p, state);
+                } else {
+                    ds = close_tuple(p, state, c == ']' ? JANET_TUPLE_FLAG_BRACKETCTOR : 0);
+                }
+            } else if (c == '}' && (state->flags & PFLAG_CURLYBRACKETS)) {
+                if (state->argn & 1) {
+                    p->error = "struct and table literals expect even number of arguments";
+                    return 1;
+                }
+                if (state->flags & PFLAG_ATSYM) {
+                    ds = close_table(p, state);
+                } else {
+                    ds = close_struct(p, state);
+                }
+            } else {
+                p->error = "mismatched delimiter";
+                return 1;
+            }
+            popstate(p, ds);
+        }
+        return 1;
         case '(':
             pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS);
             return 1;
@@ -517,20 +531,37 @@ static int root(JanetParser *p, JanetParseState *state, uint8_t c) {
     }
 }
 
-int janet_parser_consume(JanetParser *parser, uint8_t c) {
+static void janet_parser_checkdead(JanetParser *parser) {
+    if (parser->flag) janet_panic("parser is dead, cannot consume");
+    if (parser->error) janet_panic("parser has unchecked error, cannot consume");
+}
+
+/* Public API */
+
+void janet_parser_consume(JanetParser *parser, uint8_t c) {
     int consumed = 0;
-    if (parser->error) return 0;
+    janet_parser_checkdead(parser);
     parser->offset++;
     while (!consumed && !parser->error) {
         JanetParseState *state = parser->states + parser->statecount - 1;
         consumed = state->consumer(parser, state, c);
     }
     parser->lookback = c;
-    return 1;
+}
+
+void janet_parser_eof(JanetParser *parser) {
+    janet_parser_checkdead(parser);
+    janet_parser_consume(parser, '\n');
+    if (parser->statecount > 1) {
+        parser->error = "unexpected end of source";
+    }
+    parser->offset--;
+    parser->flag = 1;
 }
 
 enum JanetParserStatus janet_parser_status(JanetParser *parser) {
     if (parser->error) return JANET_PARSE_ERROR;
+    if (parser->flag) return JANET_PARSE_DEAD;
     if (parser->statecount > 1) return JANET_PARSE_PENDING;
     return JANET_PARSE_ROOT;
 }
@@ -580,6 +611,7 @@ void janet_parser_init(JanetParser *parser) {
     parser->lookback = -1;
     parser->offset = 0;
     parser->pending = 0;
+    parser->flag = 0;
 
     pushstate(parser, root, PFLAG_CONTAINER);
 }
@@ -616,6 +648,8 @@ static JanetAbstractType janet_parse_parsertype = {
     parsergc,
     parsermark,
     parserget,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -653,6 +687,13 @@ static Janet cfun_parse_consume(int32_t argc, Janet *argv) {
     return janet_wrap_integer(i);
 }
 
+static Janet cfun_parse_eof(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
+    janet_parser_eof(p);
+    return argv[0];
+}
+
 static Janet cfun_parse_insert(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
@@ -714,6 +755,9 @@ static Janet cfun_parse_status(int32_t argc, Janet *argv) {
         case JANET_PARSE_ROOT:
             stat = "root";
             break;
+        case JANET_PARSE_DEAD:
+            stat = "dead";
+            break;
     }
     return janet_ckeywordv(stat);
 }
@@ -785,6 +829,7 @@ static const JanetMethod parser_methods[] = {
     {"state", cfun_parse_state},
     {"status", cfun_parse_status},
     {"where", cfun_parse_where},
+    {"eof", cfun_parse_eof},
     {NULL, NULL}
 };
 
@@ -798,78 +843,83 @@ static const JanetReg parse_cfuns[] = {
     {
         "parser/new", cfun_parse_parser,
         JDOC("(parser/new)\n\n"
-                "Creates and returns a new parser object. Parsers are state machines "
-                "that can receive bytes, and generate a stream of janet values. ")
+             "Creates and returns a new parser object. Parsers are state machines "
+             "that can receive bytes, and generate a stream of janet values. ")
     },
     {
         "parser/has-more", cfun_parse_has_more,
         JDOC("(parser/has-more parser)\n\n"
-                "Check if the parser has more values in the value queue.")
+             "Check if the parser has more values in the value queue.")
     },
     {
         "parser/produce", cfun_parse_produce,
         JDOC("(parser/produce parser)\n\n"
-                "Dequeue the next value in the parse queue. Will return nil if "
-                "no parsed values are in the queue, otherwise will dequeue the "
-                "next value.")
+             "Dequeue the next value in the parse queue. Will return nil if "
+             "no parsed values are in the queue, otherwise will dequeue the "
+             "next value.")
     },
     {
         "parser/consume", cfun_parse_consume,
         JDOC("(parser/consume parser bytes [, index])\n\n"
-                "Input bytes into the parser and parse them. Will not throw errors "
-                "if there is a parse error. Starts at the byte index given by index. Returns "
-                "the number of bytes read.")
+             "Input bytes into the parser and parse them. Will not throw errors "
+             "if there is a parse error. Starts at the byte index given by index. Returns "
+             "the number of bytes read.")
     },
     {
         "parser/byte", cfun_parse_byte,
         JDOC("(parser/byte parser b)\n\n"
-                "Input a single byte into the parser byte stream. Returns the parser.")
+             "Input a single byte into the parser byte stream. Returns the parser.")
     },
     {
         "parser/error", cfun_parse_error,
         JDOC("(parser/error parser)\n\n"
-                "If the parser is in the error state, returns the message associated with "
-                "that error. Otherwise, returns nil. Also flushes the parser state and parser "
-                "queue, so be sure to handle everything in the queue before calling "
-                "parser/error.")
+             "If the parser is in the error state, returns the message associated with "
+             "that error. Otherwise, returns nil. Also flushes the parser state and parser "
+             "queue, so be sure to handle everything in the queue before calling "
+             "parser/error.")
     },
     {
         "parser/status", cfun_parse_status,
         JDOC("(parser/status parser)\n\n"
-                "Gets the current status of the parser state machine. The status will "
-                "be one of:\n\n"
-                "\t:pending - a value is being parsed.\n"
-                "\t:error - a parsing error was encountered.\n"
-                "\t:root - the parser can either read more values or safely terminate.")
+             "Gets the current status of the parser state machine. The status will "
+             "be one of:\n\n"
+             "\t:pending - a value is being parsed.\n"
+             "\t:error - a parsing error was encountered.\n"
+             "\t:root - the parser can either read more values or safely terminate.")
     },
     {
         "parser/flush", cfun_parse_flush,
         JDOC("(parser/flush parser)\n\n"
-                "Clears the parser state and parse queue. Can be used to reset the parser "
-                "if an error was encountered. Does not reset the line and column counter, so "
-                "to begin parsing in a new context, create a new parser.")
+             "Clears the parser state and parse queue. Can be used to reset the parser "
+             "if an error was encountered. Does not reset the line and column counter, so "
+             "to begin parsing in a new context, create a new parser.")
     },
     {
         "parser/state", cfun_parse_state,
         JDOC("(parser/state parser)\n\n"
-                "Returns a string representation of the internal state of the parser. "
-                "Each byte in the string represents a nested data structure. For example, "
-                "if the parser state is '([\"', then the parser is in the middle of parsing a "
-                "string inside of square brackets inside parentheses. Can be used to augment a REPL prompt.")
+             "Returns a string representation of the internal state of the parser. "
+             "Each byte in the string represents a nested data structure. For example, "
+             "if the parser state is '([\"', then the parser is in the middle of parsing a "
+             "string inside of square brackets inside parentheses. Can be used to augment a REPL prompt.")
     },
     {
         "parser/where", cfun_parse_where,
         JDOC("(parser/where parser)\n\n"
-                "Returns the current line number and column number of the parser's location "
-                "in the byte stream as a tuple (line, column). Lines and columns are counted from "
-                "1, (the first byte is line 1, column 1) and a newline is considered ASCII 0x0A.")
+             "Returns the current line number and column number of the parser's location "
+             "in the byte stream as a tuple (line, column). Lines and columns are counted from "
+             "1, (the first byte is line 1, column 1) and a newline is considered ASCII 0x0A.")
+    },
+    {
+        "parser/eof", cfun_parse_eof,
+        JDOC("(parser/insert parser)\n\n"
+             "Indicate that the end of file was reached to the parser. This puts the parser in the :dead state.")
     },
     {
         "parser/insert", cfun_parse_insert,
         JDOC("(parser/insert parser value)\n\n"
-                "Insert a value into the parser. This means that the parser state can be manipulated "
-                "in between chunks of bytes. This would allow a user to add extra elements to arrays "
-                "and tuples, for example. Returns the parser.")
+             "Insert a value into the parser. This means that the parser state can be manipulated "
+             "in between chunks of bytes. This would allow a user to add extra elements to arrays "
+             "and tuples, for example. Returns the parser.")
     },
     {NULL, NULL, NULL}
 };

src/core/peg.c

@@ -21,13 +21,15 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include <string.h>
 #include "util.h"
 #include "vector.h"
 #include "util.h"
 #endif
 
+#ifdef JANET_PEG
+
 /*
  * Runtime
  */
@@ -127,338 +129,317 @@ static void pushcap(PegState *s, Janet capture, uint32_t tag) {
  * not be changed, though.
  */
 static const uint8_t *peg_rule(
-        PegState *s,
-        const uint32_t *rule,
-        const uint8_t *text) {
+    PegState *s,
+    const uint32_t *rule,
+    const uint8_t *text) {
 tail:
-    switch(*rule & 0x1F) {
+    switch (*rule & 0x1F) {
         default:
             janet_panic("unexpected opcode");
             return NULL;
 
-        case RULE_LITERAL:
-            {
-                uint32_t len = rule[1];
-                if (text + len > s->text_end) return NULL;
-                return memcmp(text, rule + 2, len) ? NULL : text + len;
-            }
+        case RULE_LITERAL: {
+            uint32_t len = rule[1];
+            if (text + len > s->text_end) return NULL;
+            return memcmp(text, rule + 2, len) ? NULL : text + len;
+        }
 
-        case RULE_NCHAR:
-            {
-                uint32_t n = rule[1];
-                return (text + n > s->text_end) ? NULL : text + n;
-            }
+        case RULE_NCHAR: {
+            uint32_t n = rule[1];
+            return (text + n > s->text_end) ? NULL : text + n;
+        }
 
-        case RULE_NOTNCHAR:
-            {
-                uint32_t n = rule[1];
-                return (text + n > s->text_end) ? text : NULL;
-            }
+        case RULE_NOTNCHAR: {
+            uint32_t n = rule[1];
+            return (text + n > s->text_end) ? text : NULL;
+        }
 
-        case RULE_RANGE:
-            {
-                uint8_t lo = rule[1] & 0xFF;
-                uint8_t hi = (rule[1] >> 16) & 0xFF;
-                return (text < s->text_end &&
-                        text[0] >= lo &&
-                        text[0] <= hi)
-                    ? text + 1
-                    : NULL;
-            }
+        case RULE_RANGE: {
+            uint8_t lo = rule[1] & 0xFF;
+            uint8_t hi = (rule[1] >> 16) & 0xFF;
+            return (text < s->text_end &&
+                    text[0] >= lo &&
+                    text[0] <= hi)
+                   ? text + 1
+                   : NULL;
+        }
 
-        case RULE_SET:
-            {
-                uint32_t word = rule[1 + (text[0] >> 5)];
-                uint32_t mask = (uint32_t)1 << (text[0] & 0x1F);
-                return (text < s->text_end && (word & mask))
-                    ? text + 1
-                    : NULL;
-            }
+        case RULE_SET: {
+            uint32_t word = rule[1 + (text[0] >> 5)];
+            uint32_t mask = (uint32_t)1 << (text[0] & 0x1F);
+            return (text < s->text_end && (word & mask))
+                   ? text + 1
+                   : NULL;
+        }
 
-        case RULE_LOOK:
-            {
-                text += ((int32_t *)rule)[1];
-                if (text < s->text_start || text > s->text_end) return NULL;
-                int oldmode = s->mode;
-                s->mode = PEG_MODE_NOCAPTURE;
-                down1(s);
-                const uint8_t *result = peg_rule(s, s->bytecode + rule[2], text);
-                up1(s);
-                s->mode = oldmode;
-                return result ? text : NULL;
-            }
+        case RULE_LOOK: {
+            text += ((int32_t *)rule)[1];
+            if (text < s->text_start || text > s->text_end) return NULL;
+            int oldmode = s->mode;
+            s->mode = PEG_MODE_NOCAPTURE;
+            down1(s);
+            const uint8_t *result = peg_rule(s, s->bytecode + rule[2], text);
+            up1(s);
+            s->mode = oldmode;
+            return result ? text : NULL;
+        }
 
-        case RULE_CHOICE:
-            {
-                uint32_t len = rule[1];
-                const uint32_t *args = rule + 2;
-                if (len == 0) return NULL;
-                down1(s);
-                CapState cs = cap_save(s);
-                for (uint32_t i = 0; i < len - 1; i++) {
-                    const uint8_t *result = peg_rule(s, s->bytecode + args[i], text);
-                    if (result) {
-                        up1(s);
-                        return result;
-                    }
-                    cap_load(s, cs);
+        case RULE_CHOICE: {
+            uint32_t len = rule[1];
+            const uint32_t *args = rule + 2;
+            if (len == 0) return NULL;
+            down1(s);
+            CapState cs = cap_save(s);
+            for (uint32_t i = 0; i < len - 1; i++) {
+                const uint8_t *result = peg_rule(s, s->bytecode + args[i], text);
+                if (result) {
+                    up1(s);
+                    return result;
                 }
-                up1(s);
-                rule = s->bytecode + args[len - 1];
-                goto tail;
+                cap_load(s, cs);
             }
+            up1(s);
+            rule = s->bytecode + args[len - 1];
+            goto tail;
+        }
 
-        case RULE_SEQUENCE:
-            {
-                uint32_t len = rule[1];
-                const uint32_t *args = rule + 2;
-                if (len == 0) return text;
-                down1(s);
-                for (uint32_t i = 0; text && i < len - 1; i++)
-                    text = peg_rule(s, s->bytecode + args[i], text);
-                up1(s);
-                if (!text) return NULL;
-                rule = s->bytecode + args[len - 1];
-                goto tail;
-            }
+        case RULE_SEQUENCE: {
+            uint32_t len = rule[1];
+            const uint32_t *args = rule + 2;
+            if (len == 0) return text;
+            down1(s);
+            for (uint32_t i = 0; text && i < len - 1; i++)
+                text = peg_rule(s, s->bytecode + args[i], text);
+            up1(s);
+            if (!text) return NULL;
+            rule = s->bytecode + args[len - 1];
+            goto tail;
+        }
 
         case RULE_IF:
-        case RULE_IFNOT:
-            {
-                const uint32_t *rule_a = s->bytecode + rule[1];
-                const uint32_t *rule_b = s->bytecode + rule[2];
-                int oldmode = s->mode;
-                s->mode = PEG_MODE_NOCAPTURE;
-                down1(s);
-                const uint8_t *result = peg_rule(s, rule_a, text);
-                up1(s);
-                s->mode = oldmode;
-                if (rule[0] == RULE_IF ? !result : !!result) return NULL;
-                rule = rule_b;
-                goto tail;
-            }
+        case RULE_IFNOT: {
+            const uint32_t *rule_a = s->bytecode + rule[1];
+            const uint32_t *rule_b = s->bytecode + rule[2];
+            int oldmode = s->mode;
+            s->mode = PEG_MODE_NOCAPTURE;
+            down1(s);
+            const uint8_t *result = peg_rule(s, rule_a, text);
+            up1(s);
+            s->mode = oldmode;
+            if (rule[0] == RULE_IF ? !result : !!result) return NULL;
+            rule = rule_b;
+            goto tail;
+        }
 
-        case RULE_NOT:
-            {
-                const uint32_t *rule_a = s->bytecode + rule[1];
-                int oldmode = s->mode;
-                s->mode = PEG_MODE_NOCAPTURE;
-                down1(s);
-                const uint8_t *result = peg_rule(s, rule_a, text);
-                up1(s);
-                s->mode = oldmode;
-                return (result) ? NULL : text;
-            }
+        case RULE_NOT: {
+            const uint32_t *rule_a = s->bytecode + rule[1];
+            int oldmode = s->mode;
+            s->mode = PEG_MODE_NOCAPTURE;
+            down1(s);
+            const uint8_t *result = peg_rule(s, rule_a, text);
+            up1(s);
+            s->mode = oldmode;
+            return (result) ? NULL : text;
+        }
 
-        case RULE_BETWEEN:
-            {
-                uint32_t lo = rule[1];
-                uint32_t hi = rule[2];
-                const uint32_t *rule_a = s->bytecode + rule[3];
-                uint32_t captured = 0;
-                const uint8_t *next_text;
-                CapState cs = cap_save(s);
-                down1(s);
-                while (captured < hi) {
-                    CapState cs2 = cap_save(s);
-                    next_text = peg_rule(s, rule_a, text);
-                    if (!next_text || next_text == text) {
-                        cap_load(s, cs2);
-                        break;
-                    }
-                    captured++;
-                    text = next_text;
+        case RULE_BETWEEN: {
+            uint32_t lo = rule[1];
+            uint32_t hi = rule[2];
+            const uint32_t *rule_a = s->bytecode + rule[3];
+            uint32_t captured = 0;
+            const uint8_t *next_text;
+            CapState cs = cap_save(s);
+            down1(s);
+            while (captured < hi) {
+                CapState cs2 = cap_save(s);
+                next_text = peg_rule(s, rule_a, text);
+                if (!next_text || next_text == text) {
+                    cap_load(s, cs2);
+                    break;
                 }
-                up1(s);
-                if (captured < lo) {
-                    cap_load(s, cs);
-                    return NULL;
-                }
-                return text;
+                captured++;
+                text = next_text;
             }
+            up1(s);
+            if (captured < lo) {
+                cap_load(s, cs);
+                return NULL;
+            }
+            return text;
+        }
 
         /* Capturing rules */
 
-        case RULE_GETTAG:
-            {
-                uint32_t search = rule[1];
-                uint32_t tag = rule[2];
-                for (int32_t i = s->tags->count - 1; i >= 0; i--) {
-                    if (s->tags->data[i] == search) {
-                        pushcap(s, s->captures->data[i], tag);
-                        return text;
-                    }
+        case RULE_GETTAG: {
+            uint32_t search = rule[1];
+            uint32_t tag = rule[2];
+            for (int32_t i = s->tags->count - 1; i >= 0; i--) {
+                if (s->tags->data[i] == search) {
+                    pushcap(s, s->captures->data[i], tag);
+                    return text;
                 }
-                return NULL;
             }
+            return NULL;
+        }
 
-        case RULE_POSITION:
-            {
-                pushcap(s, janet_wrap_number((double)(text - s->text_start)), rule[1]);
-                return text;
-            }
+        case RULE_POSITION: {
+            pushcap(s, janet_wrap_number((double)(text - s->text_start)), rule[1]);
+            return text;
+        }
 
-        case RULE_ARGUMENT:
-            {
-                int32_t index = ((int32_t *)rule)[1];
-                Janet capture = (index >= s->extrac) ? janet_wrap_nil() : s->extrav[index];
-                pushcap(s, capture, rule[2]);
-                return text;
-            }
+        case RULE_ARGUMENT: {
+            int32_t index = ((int32_t *)rule)[1];
+            Janet capture = (index >= s->extrac) ? janet_wrap_nil() : s->extrav[index];
+            pushcap(s, capture, rule[2]);
+            return text;
+        }
 
-        case RULE_CONSTANT:
-            {
-                pushcap(s, s->constants[rule[1]], rule[2]);
-                return text;
-            }
+        case RULE_CONSTANT: {
+            pushcap(s, s->constants[rule[1]], rule[2]);
+            return text;
+        }
 
-        case RULE_CAPTURE:
-            {
-                uint32_t tag = rule[2];
-                if (!tag && s->mode == PEG_MODE_NOCAPTURE) {
-                    rule = s->bytecode + rule[1];
-                    goto tail;
-                }
-                down1(s);
-                const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
-                up1(s);
-                if (!result) return NULL;
-                /* Specialized pushcap - avoid intermediate string creation */
-                if (!tag && s->mode == PEG_MODE_ACCUMULATE) {
-                    janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text));
-                } else {
-                    pushcap(s, janet_stringv(text, (int32_t)(result - text)), tag);
-                }
-                return result;
+        case RULE_CAPTURE: {
+            uint32_t tag = rule[2];
+            if (!tag && s->mode == PEG_MODE_NOCAPTURE) {
+                rule = s->bytecode + rule[1];
+                goto tail;
             }
+            down1(s);
+            const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
+            up1(s);
+            if (!result) return NULL;
+            /* Specialized pushcap - avoid intermediate string creation */
+            if (!tag && s->mode == PEG_MODE_ACCUMULATE) {
+                janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text));
+            } else {
+                pushcap(s, janet_stringv(text, (int32_t)(result - text)), tag);
+            }
+            return result;
+        }
 
-        case RULE_ACCUMULATE:
-            {
-                uint32_t tag = rule[2];
-                int oldmode = s->mode;
-                /* No capture mode, skip captures. Accumulate inside accumulate also does nothing. */
-                if (!tag && oldmode != PEG_MODE_NORMAL) {
-                    rule = s->bytecode + rule[1];
-                    goto tail;
-                }
-                CapState cs = cap_save(s);
-                s->mode = PEG_MODE_ACCUMULATE;
-                down1(s);
-                const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
-                up1(s);
-                s->mode = oldmode;
-                if (!result) return NULL;
-                Janet cap = janet_stringv(s->scratch->data + cs.scratch, s->scratch->count - cs.scratch);
-                cap_load(s, cs);
-                pushcap(s, cap, tag);
-                return result;
+        case RULE_ACCUMULATE: {
+            uint32_t tag = rule[2];
+            int oldmode = s->mode;
+            /* No capture mode, skip captures. Accumulate inside accumulate also does nothing. */
+            if (!tag && oldmode != PEG_MODE_NORMAL) {
+                rule = s->bytecode + rule[1];
+                goto tail;
             }
+            CapState cs = cap_save(s);
+            s->mode = PEG_MODE_ACCUMULATE;
+            down1(s);
+            const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
+            up1(s);
+            s->mode = oldmode;
+            if (!result) return NULL;
+            Janet cap = janet_stringv(s->scratch->data + cs.scratch, s->scratch->count - cs.scratch);
+            cap_load(s, cs);
+            pushcap(s, cap, tag);
+            return result;
+        }
 
-        case RULE_DROP:
-            {
-                CapState cs = cap_save(s);
-                down1(s);
-                const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
-                up1(s);
-                if (!result) return NULL;
-                cap_load(s, cs);
-                return result;
-            }
+        case RULE_DROP: {
+            CapState cs = cap_save(s);
+            down1(s);
+            const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
+            up1(s);
+            if (!result) return NULL;
+            cap_load(s, cs);
+            return result;
+        }
 
-        case RULE_GROUP:
-            {
-                uint32_t tag = rule[2];
-                int oldmode = s->mode;
-                if (!tag && oldmode == PEG_MODE_NOCAPTURE) {
-                    rule = s->bytecode + rule[1];
-                    goto tail;
-                }
-                CapState cs = cap_save(s);
-                s->mode = PEG_MODE_NORMAL;
-                down1(s);
-                const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
-                up1(s);
-                s->mode = oldmode;
-                if (!result) return NULL;
-                int32_t num_sub_captures = s->captures->count - cs.cap;
-                JanetArray *sub_captures = janet_array(num_sub_captures);
-                memcpy(sub_captures->data,
-                        s->captures->data + cs.cap,
-                        sizeof(Janet) * num_sub_captures);
-                sub_captures->count = num_sub_captures;
-                cap_load(s, cs);
-                pushcap(s, janet_wrap_array(sub_captures), tag);
-                return result;
+        case RULE_GROUP: {
+            uint32_t tag = rule[2];
+            int oldmode = s->mode;
+            if (!tag && oldmode == PEG_MODE_NOCAPTURE) {
+                rule = s->bytecode + rule[1];
+                goto tail;
             }
+            CapState cs = cap_save(s);
+            s->mode = PEG_MODE_NORMAL;
+            down1(s);
+            const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
+            up1(s);
+            s->mode = oldmode;
+            if (!result) return NULL;
+            int32_t num_sub_captures = s->captures->count - cs.cap;
+            JanetArray *sub_captures = janet_array(num_sub_captures);
+            memcpy(sub_captures->data,
+                   s->captures->data + cs.cap,
+                   sizeof(Janet) * num_sub_captures);
+            sub_captures->count = num_sub_captures;
+            cap_load(s, cs);
+            pushcap(s, janet_wrap_array(sub_captures), tag);
+            return result;
+        }
 
         case RULE_REPLACE:
-        case RULE_MATCHTIME:
-            {
-                uint32_t tag = rule[3];
-                int oldmode = s->mode;
-                if (!tag && rule[0] == RULE_REPLACE && oldmode == PEG_MODE_NOCAPTURE) {
-                    rule = s->bytecode + rule[1];
-                    goto tail;
-                }
-                CapState cs = cap_save(s);
-                s->mode = PEG_MODE_NORMAL;
-                down1(s);
-                const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
-                up1(s);
-                s->mode = oldmode;
-                if (!result) return NULL;
-
-                Janet cap;
-                Janet constant = s->constants[rule[2]];
-                switch (janet_type(constant)) {
-                    default:
-                        cap = constant;
-                        break;
-                    case JANET_STRUCT:
-                        cap = janet_struct_get(janet_unwrap_struct(constant),
-                                s->captures->data[s->captures->count - 1]);
-                        break;
-                    case JANET_TABLE:
-                        cap = janet_table_get(janet_unwrap_table(constant),
-                                s->captures->data[s->captures->count - 1]);
-                        break;
-                    case JANET_CFUNCTION:
-                        cap = janet_unwrap_cfunction(constant)(s->captures->count - cs.cap,
-                                s->captures->data + cs.cap);
-                        break;
-                    case JANET_FUNCTION:
-                        cap = janet_call(janet_unwrap_function(constant),
-                                s->captures->count - cs.cap,
-                                s->captures->data + cs.cap);
-                        break;
-                }
-                cap_load(s, cs);
-                if (rule[0] == RULE_MATCHTIME && !janet_truthy(cap)) return NULL;
-                pushcap(s, cap, tag);
-                return result;
+        case RULE_MATCHTIME: {
+            uint32_t tag = rule[3];
+            int oldmode = s->mode;
+            if (!tag && rule[0] == RULE_REPLACE && oldmode == PEG_MODE_NOCAPTURE) {
+                rule = s->bytecode + rule[1];
+                goto tail;
             }
+            CapState cs = cap_save(s);
+            s->mode = PEG_MODE_NORMAL;
+            down1(s);
+            const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
+            up1(s);
+            s->mode = oldmode;
+            if (!result) return NULL;
 
-        case RULE_ERROR:
-            {
-                int oldmode = s->mode;
-                s->mode = PEG_MODE_NORMAL;
-                int32_t old_cap = s->captures->count;
-                down1(s);
-                const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
-                up1(s);
-                s->mode = oldmode;
-                if (!result) return NULL;
-                if (s->captures->count > old_cap) {
-                    /* Throw last capture */
-                    janet_panicv(s->captures->data[s->captures->count - 1]);
-                } else {
-                    /* Throw generic error */
-                    int32_t start = (int32_t)(text - s->text_start);
-                    int32_t end = (int32_t)(result - s->text_start);
-                    janet_panicf("match error in range (%d:%d)", start, end);
-                }
-                return NULL;
+            Janet cap;
+            Janet constant = s->constants[rule[2]];
+            switch (janet_type(constant)) {
+                default:
+                    cap = constant;
+                    break;
+                case JANET_STRUCT:
+                    cap = janet_struct_get(janet_unwrap_struct(constant),
+                                           s->captures->data[s->captures->count - 1]);
+                    break;
+                case JANET_TABLE:
+                    cap = janet_table_get(janet_unwrap_table(constant),
+                                          s->captures->data[s->captures->count - 1]);
+                    break;
+                case JANET_CFUNCTION:
+                    cap = janet_unwrap_cfunction(constant)(s->captures->count - cs.cap,
+                                                           s->captures->data + cs.cap);
+                    break;
+                case JANET_FUNCTION:
+                    cap = janet_call(janet_unwrap_function(constant),
+                                     s->captures->count - cs.cap,
+                                     s->captures->data + cs.cap);
+                    break;
             }
+            cap_load(s, cs);
+            if (rule[0] == RULE_MATCHTIME && !janet_truthy(cap)) return NULL;
+            pushcap(s, cap, tag);
+            return result;
+        }
+
+        case RULE_ERROR: {
+            int oldmode = s->mode;
+            s->mode = PEG_MODE_NORMAL;
+            int32_t old_cap = s->captures->count;
+            down1(s);
+            const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
+            up1(s);
+            s->mode = oldmode;
+            if (!result) return NULL;
+            if (s->captures->count > old_cap) {
+                /* Throw last capture */
+                janet_panicv(s->captures->data[s->captures->count - 1]);
+            } else {
+                /* Throw generic error */
+                int32_t start = (int32_t)(text - s->text_start);
+                int32_t end = (int32_t)(result - s->text_start);
+                janet_panicf("match error in range (%d:%d)", start, end);
+            }
+            return NULL;
+        }
     }
 }
 
@@ -478,7 +459,7 @@ typedef struct {
 } Builder;
 
 /* Forward declaration to allow recursion */
-static uint32_t compile1(Builder *b, Janet peg);
+static uint32_t peg_compile1(Builder *b, Janet peg);
 
 /*
  * Errors
@@ -499,9 +480,9 @@ static void peg_panic(Builder *b, const char *msg) {
 static void peg_fixarity(Builder *b, int32_t argc, int32_t arity) {
     if (argc != arity) {
         peg_panicf(b, "expected %d argument%s, got %d%",
-                arity,
-                arity == 1 ? "" : "s",
-                argc);
+                   arity,
+                   arity == 1 ? "" : "s",
+                   argc);
     }
 }
 
@@ -664,7 +645,7 @@ static void spec_look(Builder *b, int32_t argc, const Janet *argv) {
     Reserve r = reserve(b, 3);
     int32_t rulearg = argc == 2 ? 1 : 0;
     int32_t offset = argc == 2 ? peg_getinteger(b, argv[0]) : 0;
-    uint32_t subrule = compile1(b, argv[rulearg]);
+    uint32_t subrule = peg_compile1(b, argv[rulearg]);
     emit_2(r, RULE_LOOK, (uint32_t) offset, subrule);
 }
 
@@ -676,7 +657,7 @@ static void spec_variadic(Builder *b, int32_t argc, const Janet *argv, uint32_t
     for (int32_t i = 0; i < argc; i++)
         janet_v_push(b->bytecode, 0);
     for (int32_t i = 0; i < argc; i++) {
-        uint32_t rulei = compile1(b, argv[i]);
+        uint32_t rulei = peg_compile1(b, argv[i]);
         b->bytecode[rule + 2 + i] = rulei;
     }
 }
@@ -692,8 +673,8 @@ static void spec_sequence(Builder *b, int32_t argc, const Janet *argv) {
 static void spec_branch(Builder *b, int32_t argc, const Janet *argv, uint32_t rule) {
     peg_fixarity(b, argc, 2);
     Reserve r = reserve(b, 3);
-    uint32_t rule_a = compile1(b, argv[0]);
-    uint32_t rule_b = compile1(b, argv[1]);
+    uint32_t rule_a = peg_compile1(b, argv[0]);
+    uint32_t rule_b = peg_compile1(b, argv[1]);
     emit_2(r, rule, rule_a, rule_b);
 }
 
@@ -709,14 +690,14 @@ static void spec_between(Builder *b, int32_t argc, const Janet *argv) {
     Reserve r = reserve(b, 4);
     int32_t lo = peg_getnat(b, argv[0]);
     int32_t hi = peg_getnat(b, argv[1]);
-    uint32_t subrule = compile1(b, argv[2]);
+    uint32_t subrule = peg_compile1(b, argv[2]);
     emit_3(r, RULE_BETWEEN, lo, hi, subrule);
 }
 
 static void spec_repeater(Builder *b, int32_t argc, const Janet *argv, int32_t min) {
     peg_fixarity(b, argc, 1);
     Reserve r = reserve(b, 4);
-    uint32_t subrule = compile1(b, argv[0]);
+    uint32_t subrule = peg_compile1(b, argv[0]);
     emit_3(r, RULE_BETWEEN, min, UINT32_MAX, subrule);
 }
 
@@ -731,7 +712,7 @@ static void spec_atleast(Builder *b, int32_t argc, const Janet *argv) {
     peg_fixarity(b, argc, 2);
     Reserve r = reserve(b, 4);
     int32_t n = peg_getnat(b, argv[0]);
-    uint32_t subrule = compile1(b, argv[1]);
+    uint32_t subrule = peg_compile1(b, argv[1]);
     emit_3(r, RULE_BETWEEN, n, UINT32_MAX, subrule);
 }
 
@@ -739,14 +720,14 @@ static void spec_atmost(Builder *b, int32_t argc, const Janet *argv) {
     peg_fixarity(b, argc, 2);
     Reserve r = reserve(b, 4);
     int32_t n = peg_getnat(b, argv[0]);
-    uint32_t subrule = compile1(b, argv[1]);
+    uint32_t subrule = peg_compile1(b, argv[1]);
     emit_3(r, RULE_BETWEEN, 0, n, subrule);
 }
 
 static void spec_opt(Builder *b, int32_t argc, const Janet *argv) {
     peg_fixarity(b, argc, 1);
     Reserve r = reserve(b, 4);
-    uint32_t subrule = compile1(b, argv[0]);
+    uint32_t subrule = peg_compile1(b, argv[0]);
     emit_3(r, RULE_BETWEEN, 0, 1, subrule);
 }
 
@@ -755,7 +736,7 @@ static void spec_opt(Builder *b, int32_t argc, const Janet *argv) {
 static void spec_onerule(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
     peg_fixarity(b, argc, 1);
     Reserve r = reserve(b, 2);
-    uint32_t rule = compile1(b, argv[0]);
+    uint32_t rule = peg_compile1(b, argv[0]);
     emit_1(r, op, rule);
 }
 
@@ -774,7 +755,7 @@ static void spec_cap1(Builder *b, int32_t argc, const Janet *argv, uint32_t op)
     peg_arity(b, argc, 1, 2);
     Reserve r = reserve(b, 3);
     uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0;
-    uint32_t rule = compile1(b, argv[0]);
+    uint32_t rule = peg_compile1(b, argv[0]);
     emit_2(r, op, rule, tag);
 }
 
@@ -822,7 +803,7 @@ static void spec_constant(Builder *b, int32_t argc, const Janet *argv) {
 static void spec_replace(Builder *b, int32_t argc, const Janet *argv) {
     peg_arity(b, argc, 2, 3);
     Reserve r = reserve(b, 4);
-    uint32_t subrule = compile1(b, argv[0]);
+    uint32_t subrule = peg_compile1(b, argv[0]);
     uint32_t constant = emit_constant(b, argv[1]);
     uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0;
     emit_3(r, RULE_REPLACE, subrule, constant, tag);
@@ -831,7 +812,7 @@ static void spec_replace(Builder *b, int32_t argc, const Janet *argv) {
 static void spec_matchtime(Builder *b, int32_t argc, const Janet *argv) {
     peg_arity(b, argc, 2, 3);
     Reserve r = reserve(b, 4);
-    uint32_t subrule = compile1(b, argv[0]);
+    uint32_t subrule = peg_compile1(b, argv[0]);
     Janet fun = argv[1];
     if (!janet_checktype(fun, JANET_FUNCTION) &&
             !janet_checktype(fun, JANET_CFUNCTION)) {
@@ -850,7 +831,7 @@ typedef struct {
 } SpecialPair;
 
 /* Keep in lexical order (vim :sort works well) */
-static const SpecialPair specials[] = {
+static const SpecialPair peg_specials[] = {
     {"!", spec_not},
     {"$", spec_position},
     {"%", spec_accumulate},
@@ -890,7 +871,7 @@ static const SpecialPair specials[] = {
 };
 
 /* Compile a janet value into a rule and return the rule index. */
-static uint32_t compile1(Builder *b, Janet peg) {
+static uint32_t peg_compile1(Builder *b, Janet peg) {
 
     /* Check for already compiled rules */
     Janet check = janet_table_get(b->memoized, peg);
@@ -919,62 +900,59 @@ static uint32_t compile1(Builder *b, Janet peg) {
         default:
             peg_panicf(b, "unexpected peg source");
             return 0;
-        case JANET_NUMBER:
-            {
-                int32_t n = peg_getinteger(b, peg);
-                Reserve r = reserve(b, 2);
-                if (n < 0) {
-                    emit_1(r, RULE_NOTNCHAR, -n);
-                } else {
-                    emit_1(r, RULE_NCHAR, n);
-                }
-                break;
+        case JANET_NUMBER: {
+            int32_t n = peg_getinteger(b, peg);
+            Reserve r = reserve(b, 2);
+            if (n < 0) {
+                emit_1(r, RULE_NOTNCHAR, -n);
+            } else {
+                emit_1(r, RULE_NCHAR, n);
             }
-        case JANET_STRING:
-            {
-                const uint8_t *str = janet_unwrap_string(peg);
-                int32_t len = janet_string_length(str);
-                emit_bytes(b, RULE_LITERAL, len, str);
-                break;
-            }
-        case JANET_KEYWORD:
-            {
-                Janet check = janet_table_get(b->grammar, peg);
-                if (janet_checktype(check, JANET_NIL))
-                    peg_panicf(b, "unknown rule");
-                rule = compile1(b, check);
-                break;
-            }
-        case JANET_STRUCT:
-            {
-                JanetTable *grammar = janet_struct_to_table(janet_unwrap_struct(peg));
-                grammar->proto = b->grammar;
-                b->grammar = grammar;
-                Janet main_rule = janet_table_get(grammar, janet_ckeywordv("main"));
-                if (janet_checktype(main_rule, JANET_NIL))
-                    peg_panicf(b, "grammar requires :main rule");
-                rule = compile1(b, main_rule);
-                b->grammar = grammar->proto;
-                break;
-            }
-        case JANET_TUPLE:
-            {
-                const Janet *tup = janet_unwrap_tuple(peg);
-                int32_t len = janet_tuple_length(tup);
-                if (len == 0) peg_panic(b, "tuple in grammar must have non-zero length");
-                if (!janet_checktype(tup[0], JANET_SYMBOL))
-                    peg_panicf(b, "expected grammar command, found %v", tup[0]);
-                const uint8_t *sym = janet_unwrap_symbol(tup[0]);
-                const SpecialPair *sp = janet_strbinsearch(
-                        &specials,
-                        sizeof(specials)/sizeof(SpecialPair),
-                        sizeof(SpecialPair),
-                        sym);
-                if (!sp)
-                    peg_panicf(b, "unknown special %S", sym);
+            break;
+        }
+        case JANET_STRING: {
+            const uint8_t *str = janet_unwrap_string(peg);
+            int32_t len = janet_string_length(str);
+            emit_bytes(b, RULE_LITERAL, len, str);
+            break;
+        }
+        case JANET_KEYWORD: {
+            Janet check = janet_table_get(b->grammar, peg);
+            if (janet_checktype(check, JANET_NIL))
+                peg_panicf(b, "unknown rule");
+            rule = peg_compile1(b, check);
+            break;
+        }
+        case JANET_STRUCT: {
+            JanetTable *grammar = janet_struct_to_table(janet_unwrap_struct(peg));
+            grammar->proto = b->grammar;
+            b->grammar = grammar;
+            Janet main_rule = janet_table_get(grammar, janet_ckeywordv("main"));
+            if (janet_checktype(main_rule, JANET_NIL))
+                peg_panicf(b, "grammar requires :main rule");
+            rule = peg_compile1(b, main_rule);
+            b->grammar = grammar->proto;
+            break;
+        }
+        case JANET_TUPLE: {
+            const Janet *tup = janet_unwrap_tuple(peg);
+            int32_t len = janet_tuple_length(tup);
+            if (len == 0) peg_panic(b, "tuple in grammar must have non-zero length");
+            if (!janet_checktype(tup[0], JANET_SYMBOL))
+                peg_panicf(b, "expected grammar command, found %v", tup[0]);
+            const uint8_t *sym = janet_unwrap_symbol(tup[0]);
+            const SpecialPair *sp = janet_strbinsearch(
+                                        &peg_specials,
+                                        sizeof(peg_specials) / sizeof(SpecialPair),
+                                        sizeof(SpecialPair),
+                                        sym);
+            if (sp) {
                 sp->special(b, len - 1, tup + 1);
-                break;
+            } else {
+                peg_panicf(b, "unknown special %S", sym);
             }
+            break;
+        }
     }
 
     /* Increase depth again */
@@ -1006,18 +984,29 @@ static JanetAbstractType peg_type = {
     NULL,
     peg_mark,
     NULL,
+    NULL,
+    NULL,
     NULL
 };
 
+/* Used to ensure that if we place several arrays in one memory chunk, each
+ * array will be correctly aligned */
+static size_t size_padded(size_t offset, size_t size) {
+    size_t x = size + offset - 1;
+    return x - (x % size);
+}
+
 /* Convert Builder to Peg (Janet Abstract Value) */
 static Peg *make_peg(Builder *b) {
+    size_t bytecode_start = size_padded(sizeof(Peg), sizeof(uint32_t));
     size_t bytecode_size = janet_v_count(b->bytecode) * sizeof(uint32_t);
+    size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet));
     size_t constants_size = janet_v_count(b->constants) * sizeof(Janet);
-    size_t total_size = bytecode_size + constants_size + sizeof(Peg);
+    size_t total_size = constants_start + constants_size;
     char *mem = janet_abstract(&peg_type, total_size);
     Peg *peg = (Peg *)mem;
-    peg->bytecode = (uint32_t *)(mem + sizeof(Peg));
-    peg->constants = (Janet *)(mem + sizeof(Peg) + bytecode_size);
+    peg->bytecode = (uint32_t *)(mem + bytecode_start);
+    peg->constants = (Janet *)(mem + constants_start);
     peg->num_constants = janet_v_count(b->constants);
     memcpy(peg->bytecode, b->bytecode, bytecode_size);
     memcpy(peg->constants, b->constants, constants_size);
@@ -1035,7 +1024,7 @@ static Peg *compile_peg(Janet x) {
     builder.nexttag = 1;
     builder.form = x;
     builder.depth = JANET_RECURSION_GUARD;
-    compile1(&builder, x);
+    peg_compile1(&builder, x);
     Peg *peg = make_peg(&builder);
     builder_cleanup(&builder);
     return peg;
@@ -1079,7 +1068,6 @@ static Janet cfun_peg_match(int32_t argc, Janet *argv) {
     s.captures = janet_array(0);
     s.scratch = janet_buffer(10);
     s.tags = janet_buffer(10);
-
     s.constants = peg->constants;
     s.bytecode = peg->bytecode;
     const uint8_t *result = peg_rule(&s, s.bytecode, bytes.bytes + start);
@@ -1087,16 +1075,18 @@ static Janet cfun_peg_match(int32_t argc, Janet *argv) {
 }
 
 static const JanetReg peg_cfuns[] = {
-    {"peg/compile", cfun_peg_compile,
+    {
+        "peg/compile", cfun_peg_compile,
         JDOC("(peg/compile peg)\n\n"
-                "Compiles a peg source data structure into a <core/peg>. This will speed up matching "
-                "if the same peg will be used multiple times.")
+             "Compiles a peg source data structure into a <core/peg>. This will speed up matching "
+             "if the same peg will be used multiple times.")
     },
-    {"peg/match", cfun_peg_match,
+    {
+        "peg/match", cfun_peg_match,
         JDOC("(peg/match peg text [,start=0])\n\n"
-                "Match a Parsing Expression Grammar to a byte string and return an array of captured values. "
-                "Returns nil if text does not match the language defined by peg. The syntax of PEGs are very "
-                "similar to those defined by LPeg, and have similar capabilities.")
+             "Match a Parsing Expression Grammar to a byte string and return an array of captured values. "
+             "Returns nil if text does not match the language defined by peg. The syntax of PEGs are very "
+             "similar to those defined by LPeg, and have similar capabilities.")
     },
     {NULL, NULL, NULL}
 };
@@ -1105,3 +1095,5 @@ static const JanetReg peg_cfuns[] = {
 void janet_lib_peg(JanetTable *env) {
     janet_core_cfuns(env, NULL, peg_cfuns);
 }
+
+#endif /* ifdef JANET_PEG */

src/core/pp.c

@@ -20,8 +20,11 @@
 * IN THE SOFTWARE.
 */
 
+#include <string.h>
+#include <ctype.h>
+
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "util.h"
 #include "state.h"
 #endif
@@ -70,7 +73,7 @@ static void integer_to_string_b(JanetBuffer *buffer, int32_t x) {
     len = count_dig10(x);
     buf += len;
     while (x) {
-        uint8_t digit = (uint8_t) -(x % 10);
+        uint8_t digit = (uint8_t) - (x % 10);
         *(--buf) = '0' + digit;
         x /= 10;
     }
@@ -133,6 +136,15 @@ static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, in
             case '\0':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2);
                 break;
+            case '\f':
+                janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2);
+                break;
+            case '\v':
+                janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2);
+                break;
+            case 27:
+                janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2);
+                break;
             case '\\':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2);
                 break;
@@ -164,53 +176,48 @@ static void janet_escape_buffer_b(JanetBuffer *buffer, JanetBuffer *bx) {
 
 void janet_description_b(JanetBuffer *buffer, Janet x) {
     switch (janet_type(x)) {
-    case JANET_NIL:
-        janet_buffer_push_cstring(buffer, "nil");
-        return;
-    case JANET_TRUE:
-        janet_buffer_push_cstring(buffer, "true");
-        return;
-    case JANET_FALSE:
-        janet_buffer_push_cstring(buffer, "false");
-        return;
-    case JANET_NUMBER:
-        number_to_string_b(buffer, janet_unwrap_number(x));
-        return;
-    case JANET_KEYWORD:
-        janet_buffer_push_u8(buffer, ':');
+        case JANET_NIL:
+            janet_buffer_push_cstring(buffer, "nil");
+            return;
+        case JANET_BOOLEAN:
+            janet_buffer_push_cstring(buffer,
+                                      janet_unwrap_boolean(x) ? "true" : "false");
+            return;
+        case JANET_NUMBER:
+            number_to_string_b(buffer, janet_unwrap_number(x));
+            return;
+        case JANET_KEYWORD:
+            janet_buffer_push_u8(buffer, ':');
         /* fallthrough */
-    case JANET_SYMBOL:
-        janet_buffer_push_bytes(buffer,
-                janet_unwrap_string(x),
-                janet_string_length(janet_unwrap_string(x)));
-        return;
-    case JANET_STRING:
-        janet_escape_string_b(buffer, janet_unwrap_string(x));
-        return;
-    case JANET_BUFFER:
-        janet_escape_buffer_b(buffer, janet_unwrap_buffer(x));
-        return;
-    case JANET_ABSTRACT:
-        {
+        case JANET_SYMBOL:
+            janet_buffer_push_bytes(buffer,
+                                    janet_unwrap_string(x),
+                                    janet_string_length(janet_unwrap_string(x)));
+            return;
+        case JANET_STRING:
+            janet_escape_string_b(buffer, janet_unwrap_string(x));
+            return;
+        case JANET_BUFFER:
+            janet_escape_buffer_b(buffer, janet_unwrap_buffer(x));
+            return;
+        case JANET_ABSTRACT: {
             const char *n = janet_abstract_type(janet_unwrap_abstract(x))->name;
             string_description_b(buffer, n, janet_unwrap_abstract(x));
-			return;
+            return;
         }
-    case JANET_CFUNCTION:
-        {
+        case JANET_CFUNCTION: {
             Janet check = janet_table_get(janet_vm_registry, x);
             if (janet_checktype(check, JANET_SYMBOL)) {
                 janet_buffer_push_cstring(buffer, "<cfunction ");
                 janet_buffer_push_bytes(buffer,
-                        janet_unwrap_symbol(check),
-                        janet_string_length(janet_unwrap_symbol(check)));
+                                        janet_unwrap_symbol(check),
+                                        janet_string_length(janet_unwrap_symbol(check)));
                 janet_buffer_push_u8(buffer, '>');
                 break;
             }
             goto fallthrough;
         }
-    case JANET_FUNCTION:
-        {
+        case JANET_FUNCTION: {
             JanetFunction *fun = janet_unwrap_function(x);
             JanetFuncDef *def = fun->def;
             if (def->name) {
@@ -223,9 +230,9 @@ void janet_description_b(JanetBuffer *buffer, Janet x) {
             goto fallthrough;
         }
     fallthrough:
-    default:
-        string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x));
-        break;
+        default:
+            string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x));
+            break;
     }
 }
 
@@ -236,15 +243,15 @@ void janet_to_string_b(JanetBuffer *buffer, Janet x) {
             break;
         case JANET_BUFFER:
             janet_buffer_push_bytes(buffer,
-                    janet_unwrap_buffer(x)->data,
-                    janet_unwrap_buffer(x)->count);
+                                    janet_unwrap_buffer(x)->data,
+                                    janet_unwrap_buffer(x)->count);
             break;
         case JANET_STRING:
         case JANET_SYMBOL:
         case JANET_KEYWORD:
             janet_buffer_push_bytes(buffer,
-                    janet_unwrap_string(x),
-                    janet_string_length(janet_unwrap_string(x)));
+                                    janet_unwrap_string(x),
+                                    janet_string_length(janet_unwrap_string(x)));
             break;
     }
 }
@@ -262,15 +269,14 @@ const uint8_t *janet_description(Janet x) {
  * strings, symbols, and buffers will return their content. */
 const uint8_t *janet_to_string(Janet x) {
     switch (janet_type(x)) {
-        default:
-            {
-                JanetBuffer b;
-                janet_buffer_init(&b, 10);
-                janet_to_string_b(&b, x);
-                const uint8_t *ret = janet_string(b.data, b.count);
-                janet_buffer_deinit(&b);
-                return ret;
-            }
+        default: {
+            JanetBuffer b;
+            janet_buffer_init(&b, 10);
+            janet_to_string_b(&b, x);
+            const uint8_t *ret = janet_string(b.data, b.count);
+            janet_buffer_deinit(&b);
+            return ret;
+        }
         case JANET_BUFFER:
             return janet_string(janet_unwrap_buffer(x)->data, janet_unwrap_buffer(x)->count);
         case JANET_STRING:
@@ -307,22 +313,20 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
         case JANET_NIL:
         case JANET_NUMBER:
         case JANET_SYMBOL:
-        case JANET_TRUE:
-        case JANET_FALSE:
+        case JANET_BOOLEAN:
             break;
-        default:
-            {
-                Janet seenid = janet_table_get(&S->seen, x);
-                if (janet_checktype(seenid, JANET_NUMBER)) {
-                    janet_buffer_push_cstring(S->buffer, "<cycle ");
-                    integer_to_string_b(S->buffer, janet_unwrap_integer(seenid));
-                    janet_buffer_push_u8(S->buffer, '>');
-                    return;
-                } else {
-                    janet_table_put(&S->seen, x, janet_wrap_integer(S->seen.count));
-                    break;
-                }
+        default: {
+            Janet seenid = janet_table_get(&S->seen, x);
+            if (janet_checktype(seenid, JANET_NUMBER)) {
+                janet_buffer_push_cstring(S->buffer, "<cycle ");
+                integer_to_string_b(S->buffer, janet_unwrap_integer(seenid));
+                janet_buffer_push_u8(S->buffer, '>');
+                return;
+            } else {
+                janet_table_put(&S->seen, x, janet_wrap_integer(S->seen.count));
+                break;
             }
+        }
     }
 
     switch (janet_type(x)) {
@@ -330,81 +334,82 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
             janet_description_b(S->buffer, x);
             break;
         case JANET_ARRAY:
-        case JANET_TUPLE:
-            {
-                int isarray = janet_checktype(x, JANET_ARRAY);
-                janet_buffer_push_cstring(S->buffer, isarray ? "@[" : "(");
-                S->depth--;
-                S->indent += 2;
-                if (S->depth == 0) {
-                    janet_buffer_push_cstring(S->buffer, "...");
-                } else {
-                    int32_t i, len;
-                    const Janet *arr;
-                    janet_indexed_view(x, &arr, &len);
-                    if (!isarray && len >= 5)
-                        janet_buffer_push_u8(S->buffer, ' ');
-                    if (is_dict_value && len >= 5) print_newline(S, 0);
-                    for (i = 0; i < len; i++) {
-                        if (i) print_newline(S, len < 5);
-                        janet_pretty_one(S, arr[i], 0);
-                    }
+        case JANET_TUPLE: {
+            int32_t i, len;
+            const Janet *arr;
+            int isarray = janet_checktype(x, JANET_ARRAY);
+            janet_indexed_view(x, &arr, &len);
+            int hasbrackets = !isarray && (janet_tuple_flag(arr) & JANET_TUPLE_FLAG_BRACKETCTOR);
+            const char *startstr = isarray ? "@[" : hasbrackets ? "[" : "(";
+            const char endchar = isarray ? ']' : hasbrackets ? ']' : ')';
+            janet_buffer_push_cstring(S->buffer, startstr);
+            S->depth--;
+            S->indent += 2;
+            if (S->depth == 0) {
+                janet_buffer_push_cstring(S->buffer, "...");
+            } else {
+                if (!isarray && len >= 5)
+                    janet_buffer_push_u8(S->buffer, ' ');
+                if (is_dict_value && len >= 5) print_newline(S, 0);
+                for (i = 0; i < len; i++) {
+                    if (i) print_newline(S, len < 5);
+                    janet_pretty_one(S, arr[i], 0);
                 }
-                S->indent -= 2;
-                S->depth++;
-                janet_buffer_push_u8(S->buffer, isarray ? ']' : ')');
-                break;
             }
+            S->indent -= 2;
+            S->depth++;
+            janet_buffer_push_u8(S->buffer, endchar);
+            break;
+        }
         case JANET_STRUCT:
-        case JANET_TABLE:
-            {
-                int istable = janet_checktype(x, JANET_TABLE);
-                janet_buffer_push_cstring(S->buffer, istable ? "@" : "{");
+        case JANET_TABLE: {
+            int istable = janet_checktype(x, JANET_TABLE);
+            janet_buffer_push_cstring(S->buffer, istable ? "@" : "{");
 
-                /* For object-like tables, print class name */
-                if (istable) {
-                    JanetTable *t = janet_unwrap_table(x);
-                    JanetTable *proto = t->proto;
-                    if (NULL != proto) {
-                        Janet name = janet_table_get(proto, janet_csymbolv(":name"));
-                        if (janet_checktype(name, JANET_SYMBOL)) {
-                            const uint8_t *sym = janet_unwrap_symbol(name);
-                            janet_buffer_push_bytes(S->buffer, sym, janet_string_length(sym));
-                        }
-                    }
-                    janet_buffer_push_cstring(S->buffer, "{");
-                }
-
-                S->depth--;
-                S->indent += 2;
-                if (S->depth == 0) {
-                    janet_buffer_push_cstring(S->buffer, "...");
-                } else {
-                    int32_t i, len, cap;
-                    int first_kv_pair = 1;
-                    const JanetKV *kvs;
-                    janet_dictionary_view(x, &kvs, &len, &cap);
-                    if (!istable && len >= 4)
-                        janet_buffer_push_u8(S->buffer, ' ');
-                    if (is_dict_value && len >= 5) print_newline(S, 0);
-                    for (i = 0; i < cap; i++) {
-                        if (!janet_checktype(kvs[i].key, JANET_NIL)) {
-                            if (first_kv_pair) {
-                                first_kv_pair = 0;
-                            } else {
-                                print_newline(S, len < 4);
-                            }
-                            janet_pretty_one(S, kvs[i].key, 0);
-                            janet_buffer_push_u8(S->buffer, ' ');
-                            janet_pretty_one(S, kvs[i].value, 1);
-                        }
+            /* For object-like tables, print class name */
+            if (istable) {
+                JanetTable *t = janet_unwrap_table(x);
+                JanetTable *proto = t->proto;
+                if (NULL != proto) {
+                    Janet name = janet_table_get(proto, janet_csymbolv(":name"));
+                    if (janet_checktype(name, JANET_SYMBOL)) {
+                        const uint8_t *sym = janet_unwrap_symbol(name);
+                        janet_buffer_push_bytes(S->buffer, sym, janet_string_length(sym));
                     }
                 }
-                S->indent -= 2;
-                S->depth++;
-                janet_buffer_push_u8(S->buffer, '}');
-                break;
+                janet_buffer_push_cstring(S->buffer, "{");
             }
+
+            S->depth--;
+            S->indent += 2;
+            if (S->depth == 0) {
+                janet_buffer_push_cstring(S->buffer, "...");
+            } else {
+                int32_t i, len, cap;
+                int first_kv_pair = 1;
+                const JanetKV *kvs;
+                janet_dictionary_view(x, &kvs, &len, &cap);
+                if (!istable && len >= 4)
+                    janet_buffer_push_u8(S->buffer, ' ');
+                if (is_dict_value && len >= 5) print_newline(S, 0);
+                for (i = 0; i < cap; i++) {
+                    if (!janet_checktype(kvs[i].key, JANET_NIL)) {
+                        if (first_kv_pair) {
+                            first_kv_pair = 0;
+                        } else {
+                            print_newline(S, len < 4);
+                        }
+                        janet_pretty_one(S, kvs[i].key, 0);
+                        janet_buffer_push_u8(S->buffer, ' ');
+                        janet_pretty_one(S, kvs[i].value, 1);
+                    }
+                }
+            }
+            S->indent -= 2;
+            S->depth++;
+            janet_buffer_push_u8(S->buffer, '}');
+            break;
+        }
     }
     /* Remove from seen */
     janet_table_remove(&S->seen, x);
@@ -430,8 +435,8 @@ JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, Janet x) {
 static const char *typestr(Janet x) {
     JanetType t = janet_type(x);
     return (t == JANET_ABSTRACT)
-        ? janet_abstract_type(janet_unwrap_abstract(x))->name
-        : janet_type_names[t];
+           ? janet_abstract_type(janet_unwrap_abstract(x))->name
+           : janet_type_names[t];
 }
 
 static void pushtypes(JanetBuffer *buffer, int types) {
@@ -477,8 +482,7 @@ const uint8_t *janet_formatc(const char *format, ...) {
             default:
                 janet_buffer_push_u8(bufp, c);
                 break;
-            case '%':
-            {
+            case '%': {
                 if (i + 1 >= len)
                     break;
                 switch (format[++i]) {
@@ -491,8 +495,7 @@ const uint8_t *janet_formatc(const char *format, ...) {
                     case 'd':
                         integer_to_string_b(bufp, va_arg(args, long));
                         break;
-                    case 'S':
-                    {
+                    case 'S': {
                         const uint8_t *str = va_arg(args, const uint8_t *);
                         janet_buffer_push_bytes(bufp, str, janet_string_length(str));
                         break;
@@ -503,35 +506,29 @@ const uint8_t *janet_formatc(const char *format, ...) {
                     case 'c':
                         janet_buffer_push_u8(bufp, (uint8_t) va_arg(args, long));
                         break;
-                    case 'q':
-                    {
+                    case 'q': {
                         const uint8_t *str = va_arg(args, const uint8_t *);
                         janet_escape_string_b(bufp, str);
                         break;
                     }
-                    case 't':
-                    {
+                    case 't': {
                         janet_buffer_push_cstring(bufp, typestr(va_arg(args, Janet)));
                         break;
                     }
-                    case 'T':
-                    {
+                    case 'T': {
                         int types = va_arg(args, long);
                         pushtypes(bufp, types);
                         break;
                     }
-                    case 'V':
-                    {
+                    case 'V': {
                         janet_to_string_b(bufp, va_arg(args, Janet));
                         break;
                     }
-                    case 'v':
-                    {
+                    case 'v': {
                         janet_description_b(bufp, va_arg(args, Janet));
                         break;
                     }
-                    case 'p':
-                    {
+                    case 'p': {
                         janet_pretty(bufp, 4, va_arg(args, Janet));
                     }
                 }
@@ -546,3 +543,138 @@ const uint8_t *janet_formatc(const char *format, ...) {
     return ret;
 }
 
+/*
+ * code adapted from lua/lstrlib.c http://lua.org
+ */
+
+#define MAX_ITEM  256
+#define FMT_FLAGS "-+ #0"
+#define MAX_FORMAT 32
+
+static const char *scanformat(
+    const char *strfrmt,
+    char *form,
+    char width[3],
+    char precision[3]) {
+    const char *p = strfrmt;
+    memset(width, '\0', 3);
+    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 (isdigit((int)(*p)))
+        width[0] = *p++; /* skip width */
+    if (isdigit((int)(*p)))
+        width[1] = *p++; /* (2 digits at most) */
+    if (*p == '.') {
+        p++;
+        if (isdigit((int)(*p)))
+            precision[0] = *p++; /* skip precision */
+        if (isdigit((int)(*p)))
+            precision[1] = *p++; /* (2 digits at most) */
+    }
+    if (isdigit((int)(*p)))
+        janet_panic("invalid format (width or precision too long)");
+    *(form++) = '%';
+    memcpy(form, strfrmt, ((p - strfrmt) + 1) * sizeof(char));
+    form += (p - strfrmt) + 1;
+    *form = '\0';
+    return p;
+}
+
+/* Shared implementation between string/format and
+ * buffer/format */
+void janet_buffer_format(
+    JanetBuffer *b,
+    const char *strfrmt,
+    int32_t argstart,
+    int32_t argc,
+    Janet *argv) {
+    size_t sfl = strlen(strfrmt);
+    const char *strfrmt_end = strfrmt + sfl;
+    int32_t arg = argstart;
+    while (strfrmt < strfrmt_end) {
+        if (*strfrmt != '%')
+            janet_buffer_push_u8(b, (uint8_t) * strfrmt++);
+        else if (*++strfrmt == '%')
+            janet_buffer_push_u8(b, (uint8_t) * strfrmt++); /* %% */
+        else { /* format item */
+            char form[MAX_FORMAT], item[MAX_ITEM];
+            char width[3], precision[3];
+            int nb = 0; /* number of bytes in added item */
+            if (++arg >= argc)
+                janet_panic("not enough values for format");
+            strfrmt = scanformat(strfrmt, form, width, precision);
+            switch (*strfrmt++) {
+                case 'c': {
+                    nb = snprintf(item, MAX_ITEM, form, (int)
+                                  janet_getinteger(argv, arg));
+                    break;
+                }
+                case 'd':
+                case 'i':
+                case 'o':
+                case 'u':
+                case 'x':
+                case 'X': {
+                    int32_t n = janet_getinteger(argv, arg);
+                    nb = snprintf(item, MAX_ITEM, form, n);
+                    break;
+                }
+                case 'a':
+                case 'A':
+                case 'e':
+                case 'E':
+                case 'f':
+                case 'g':
+                case 'G': {
+                    double d = janet_getnumber(argv, arg);
+                    nb = snprintf(item, MAX_ITEM, form, d);
+                    break;
+                }
+                case 's': {
+                    const uint8_t *s = janet_getstring(argv, arg);
+                    int32_t l = janet_string_length(s);
+                    if (form[2] == '\0')
+                        janet_buffer_push_bytes(b, s, l);
+                    else {
+                        if (l != (int32_t) strlen((const char *) s))
+                            janet_panic("string contains zeros");
+                        if (!strchr(form, '.') && l >= 100) {
+                            janet_panic
+                            ("no precision and string is too long to be formatted");
+                        } else {
+                            nb = snprintf(item, MAX_ITEM, form, s);
+                        }
+                    }
+                    break;
+                }
+                case 'V': {
+                    janet_to_string_b(b, argv[arg]);
+                    break;
+                }
+                case 'v': {
+                    janet_description_b(b, argv[arg]);
+                    break;
+                }
+                case 'p': { /* janet pretty , precision = depth */
+                    int depth = atoi(precision);
+                    if (depth < 1)
+                        depth = 4;
+                    janet_pretty(b, depth, argv[arg]);
+                    break;
+                }
+                default: {
+                    /* also treat cases 'nLlh' */
+                    janet_panicf("invalid conversion '%s' to 'format'",
+                                 form);
+                }
+            }
+            if (nb >= MAX_ITEM)
+                janet_panicf("format buffer overflow", form);
+            if (nb > 0)
+                janet_buffer_push_bytes(b, (uint8_t *) item, nb);
+        }
+    }
+}

src/core/regalloc.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "regalloc.h"
 #endif
 
@@ -66,12 +66,16 @@ void janetc_regalloc_clone(JanetcRegisterAllocator *dest, JanetcRegisterAllocato
     dest->capacity = src->capacity;
     dest->max = src->max;
     size = sizeof(uint32_t) * dest->capacity;
-    dest->chunks = malloc(size);
     dest->regtemps = 0;
-    if (!dest->chunks) {
-        JANET_OUT_OF_MEMORY;
+    if (size) {
+        dest->chunks = malloc(size);
+        if (!dest->chunks) {
+            JANET_OUT_OF_MEMORY;
+        }
+        memcpy(dest->chunks, src->chunks, size);
+    } else {
+        dest->chunks = NULL;
     }
-    memcpy(dest->chunks, src->chunks, size);
 }
 
 /* Allocate one more chunk in chunks */

src/core/run.c

@@ -21,24 +21,24 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "state.h"
 #endif
 
 /* Run a string */
 int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char *sourcePath, Janet *out) {
     JanetParser parser;
-    int errflags = 0;
+    int errflags = 0, done = 0;
     int32_t index = 0;
-    int dudeol = 0;
-    int done = 0;
     Janet ret = janet_wrap_nil();
     const uint8_t *where = sourcePath ? janet_cstring(sourcePath) : NULL;
+
     if (where) janet_gcroot(janet_wrap_string(where));
     if (NULL == sourcePath) sourcePath = "<unknown>";
     janet_parser_init(&parser);
 
-    while (!errflags && !done) {
+    /* While we haven't seen an error */
+    while (!done) {
 
         /* Evaluate parsed values */
         while (janet_parser_has_more(&parser)) {
@@ -51,38 +51,37 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
                 if (status != JANET_SIGNAL_OK) {
                     janet_stacktrace(fiber, ret);
                     errflags |= 0x01;
+                    done = 1;
                 }
             } else {
                 fprintf(stderr, "compile error in %s: %s\n", sourcePath,
                         (const char *)cres.error);
                 errflags |= 0x02;
+                done = 1;
             }
         }
 
         /* Dispatch based on parse state */
         switch (janet_parser_status(&parser)) {
+            case JANET_PARSE_DEAD:
+                done = 1;
+                break;
             case JANET_PARSE_ERROR:
                 errflags |= 0x04;
                 fprintf(stderr, "parse error in %s: %s\n",
                         sourcePath, janet_parser_error(&parser));
+                done = 1;
                 break;
             case JANET_PARSE_PENDING:
-                if (index >= len) {
-                    if (dudeol) {
-                        errflags |= 0x04;
-                        fprintf(stderr, "internal parse error in %s: unexpected end of source\n",
-                                sourcePath);
-                    } else {
-                        dudeol = 1;
-                        janet_parser_consume(&parser, '\n');
-                    }
+                if (index == len) {
+                    janet_parser_eof(&parser);
                 } else {
                     janet_parser_consume(&parser, bytes[index++]);
                 }
                 break;
             case JANET_PARSE_ROOT:
                 if (index >= len) {
-                    done = 1;
+                    janet_parser_eof(&parser);
                 } else {
                     janet_parser_consume(&parser, bytes[index++]);
                 }
@@ -90,6 +89,8 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
         }
 
     }
+
+    /* Clean up and return errors */
     janet_parser_deinit(&parser);
     if (where) janet_gcunroot(janet_wrap_string(where));
     if (out) *out = ret;

src/core/specials.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "compile.h"
 #include "util.h"
 #include "vector.h"
@@ -60,45 +60,42 @@ static JanetSlot quasiquote(JanetFopts opts, Janet x) {
     switch (janet_type(x)) {
         default:
             return janetc_cslot(x);
-        case JANET_TUPLE:
-            {
-                int32_t i, len;
-                const Janet *tup = janet_unwrap_tuple(x);
-                len = janet_tuple_length(tup);
-                if (len > 1 && janet_checktype(tup[0], JANET_SYMBOL)) {
-                    const uint8_t *head = janet_unwrap_symbol(tup[0]);
-                    if (!janet_cstrcmp(head, "unquote"))
-                        return janetc_value(janetc_fopts_default(opts.compiler), tup[1]);
-                }
-                for (i = 0; i < len; i++)
-                    janet_v_push(slots, quasiquote(opts, tup[i]));
-                return qq_slots(opts, slots, JOP_MAKE_TUPLE);
-            }
-        case JANET_ARRAY:
-            {
-                int32_t i;
-                JanetArray *array = janet_unwrap_array(x);
-                for (i = 0; i < array->count; i++)
-                    janet_v_push(slots, quasiquote(opts, array->data[i]));
-                return qq_slots(opts, slots, JOP_MAKE_ARRAY);
+        case JANET_TUPLE: {
+            int32_t i, len;
+            const Janet *tup = janet_unwrap_tuple(x);
+            len = janet_tuple_length(tup);
+            if (len > 1 && janet_checktype(tup[0], JANET_SYMBOL)) {
+                const uint8_t *head = janet_unwrap_symbol(tup[0]);
+                if (!janet_cstrcmp(head, "unquote"))
+                    return janetc_value(janetc_fopts_default(opts.compiler), tup[1]);
             }
+            for (i = 0; i < len; i++)
+                janet_v_push(slots, quasiquote(opts, tup[i]));
+            return qq_slots(opts, slots, JOP_MAKE_TUPLE);
+        }
+        case JANET_ARRAY: {
+            int32_t i;
+            JanetArray *array = janet_unwrap_array(x);
+            for (i = 0; i < array->count; i++)
+                janet_v_push(slots, quasiquote(opts, array->data[i]));
+            return qq_slots(opts, slots, JOP_MAKE_ARRAY);
+        }
         case JANET_TABLE:
-        case JANET_STRUCT:
-            {
-                const JanetKV *kv = NULL, *kvs = NULL;
-                int32_t len, cap;
-                janet_dictionary_view(x, &kvs, &len, &cap);
-                while ((kv = janet_dictionary_next(kvs, cap, kv))) {
-                    JanetSlot key = quasiquote(opts, kv->key);
-                    JanetSlot value =  quasiquote(opts, kv->value);
-                    key.flags &= ~JANET_SLOT_SPLICED;
-                    value.flags &= ~JANET_SLOT_SPLICED;
-                    janet_v_push(slots, key);
-                    janet_v_push(slots, value);
-                }
-                return qq_slots(opts, slots,
-                        janet_checktype(x, JANET_TABLE) ? JOP_MAKE_TABLE : JOP_MAKE_STRUCT);
+        case JANET_STRUCT: {
+            const JanetKV *kv = NULL, *kvs = NULL;
+            int32_t len, cap;
+            janet_dictionary_view(x, &kvs, &len, &cap);
+            while ((kv = janet_dictionary_next(kvs, cap, kv))) {
+                JanetSlot key = quasiquote(opts, kv->key);
+                JanetSlot value =  quasiquote(opts, kv->value);
+                key.flags &= ~JANET_SLOT_SPLICED;
+                value.flags &= ~JANET_SLOT_SPLICED;
+                janet_v_push(slots, key);
+                janet_v_push(slots, value);
             }
+            return qq_slots(opts, slots,
+                            janet_checktype(x, JANET_TABLE) ? JOP_MAKE_TABLE : JOP_MAKE_STRUCT);
+        }
     }
 }
 
@@ -121,13 +118,13 @@ static JanetSlot janetc_unquote(JanetFopts opts, int32_t argn, const Janet *argv
  * keep the order registers are freed.
  * Returns if the slot 'right' can be freed. */
 static int destructure(JanetCompiler *c,
-        Janet left,
-        JanetSlot right,
-        int (*leaf)(JanetCompiler *c,
-            const uint8_t *sym,
-            JanetSlot s,
-            JanetTable *attr),
-        JanetTable *attr) {
+                       Janet left,
+                       JanetSlot right,
+                       int (*leaf)(JanetCompiler *c,
+                                   const uint8_t *sym,
+                                   JanetSlot s,
+                                   JanetTable *attr),
+                       JanetTable *attr) {
     switch (janet_type(left)) {
         default:
             janetc_cerror(c, "unexpected type in destructuring");
@@ -136,41 +133,39 @@ static int destructure(JanetCompiler *c,
             /* Leaf, assign right to left */
             return leaf(c, janet_unwrap_symbol(left), right, attr);
         case JANET_TUPLE:
-        case JANET_ARRAY:
-            {
-                int32_t i, len;
-                const Janet *values;
-                janet_indexed_view(left, &values, &len);
-                for (i = 0; i < len; i++) {
-                    JanetSlot nextright = janetc_farslot(c);
-                    Janet subval = values[i];
-                    if (i < 0x100) {
-                        janetc_emit_ssu(c, JOP_GET_INDEX, nextright, right, (uint8_t) i, 1);
-                    } else {
-                        JanetSlot k = janetc_cslot(janet_wrap_integer(i));
-                        janetc_emit_sss(c, JOP_GET, nextright, right, k, 1);
-                    }
-                    if (destructure(c, subval, nextright, leaf, attr))
-                        janetc_freeslot(c, nextright);
-                }
-            }
-            return 1;
-        case JANET_TABLE:
-        case JANET_STRUCT:
-            {
-                const JanetKV *kvs = NULL;
-                int32_t i, cap, len;
-                janet_dictionary_view(left, &kvs, &len, &cap);
-                for (i = 0; i < cap; i++) {
-                    if (janet_checktype(kvs[i].key, JANET_NIL)) continue;
-                    JanetSlot nextright = janetc_farslot(c);
-                    JanetSlot k = janetc_value(janetc_fopts_default(c), kvs[i].key);
+        case JANET_ARRAY: {
+            int32_t i, len;
+            const Janet *values;
+            janet_indexed_view(left, &values, &len);
+            for (i = 0; i < len; i++) {
+                JanetSlot nextright = janetc_farslot(c);
+                Janet subval = values[i];
+                if (i < 0x100) {
+                    janetc_emit_ssu(c, JOP_GET_INDEX, nextright, right, (uint8_t) i, 1);
+                } else {
+                    JanetSlot k = janetc_cslot(janet_wrap_integer(i));
                     janetc_emit_sss(c, JOP_GET, nextright, right, k, 1);
-                    if (destructure(c, kvs[i].value, nextright, leaf, attr))
-                        janetc_freeslot(c, nextright);
                 }
+                if (destructure(c, subval, nextright, leaf, attr))
+                    janetc_freeslot(c, nextright);
             }
-            return 1;
+        }
+        return 1;
+        case JANET_TABLE:
+        case JANET_STRUCT: {
+            const JanetKV *kvs = NULL;
+            int32_t i, cap, len;
+            janet_dictionary_view(left, &kvs, &len, &cap);
+            for (i = 0; i < cap; i++) {
+                if (janet_checktype(kvs[i].key, JANET_NIL)) continue;
+                JanetSlot nextright = janetc_farslot(c);
+                JanetSlot k = janetc_value(janetc_fopts_default(c), kvs[i].key);
+                janetc_emit_sss(c, JOP_GET, nextright, right, k, 1);
+                if (destructure(c, kvs[i].value, nextright, leaf, attr))
+                    janetc_freeslot(c, nextright);
+            }
+        }
+        return 1;
     }
 }
 
@@ -264,8 +259,8 @@ static JanetSlot dohead(JanetCompiler *c, JanetFopts opts, Janet *head, int32_t
 /* Def or var a symbol in a local scope */
 static int namelocal(JanetCompiler *c, const uint8_t *head, int32_t flags, JanetSlot ret) {
     int isUnnamedRegister = !(ret.flags & JANET_SLOT_NAMED) &&
-        ret.index > 0 &&
-        ret.envindex >= 0;
+                            ret.index > 0 &&
+                            ret.envindex >= 0;
     if (!isUnnamedRegister) {
         /* Slot is not able to be named */
         JanetSlot localslot = janetc_farslot(c);
@@ -278,10 +273,10 @@ static int namelocal(JanetCompiler *c, const uint8_t *head, int32_t flags, Janet
 }
 
 static int varleaf(
-        JanetCompiler *c,
-        const uint8_t *sym,
-        JanetSlot s,
-        JanetTable *attr) {
+    JanetCompiler *c,
+    const uint8_t *sym,
+    JanetSlot s,
+    JanetTable *attr) {
     if (c->scope->flags & JANET_SCOPE_TOP) {
         /* Global var, generate var */
         JanetSlot refslot;
@@ -291,7 +286,7 @@ static int varleaf(
         janet_array_push(ref, janet_wrap_nil());
         janet_table_put(reftab, janet_ckeywordv("ref"), janet_wrap_array(ref));
         janet_table_put(reftab, janet_ckeywordv("source-map"),
-                janet_wrap_tuple(janetc_make_sourcemap(c)));
+                        janet_wrap_tuple(janetc_make_sourcemap(c)));
         janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(reftab));
         refslot = janetc_cslot(janet_wrap_array(ref));
         janetc_emit_ssu(c, JOP_PUT_INDEX, refslot, s, 0, 0);
@@ -312,14 +307,14 @@ static JanetSlot janetc_var(JanetFopts opts, int32_t argn, const Janet *argv) {
 }
 
 static int defleaf(
-        JanetCompiler *c,
-        const uint8_t *sym,
-        JanetSlot s,
-        JanetTable *attr) {
+    JanetCompiler *c,
+    const uint8_t *sym,
+    JanetSlot s,
+    JanetTable *attr) {
     if (c->scope->flags & JANET_SCOPE_TOP) {
         JanetTable *tab = janet_table(2);
         janet_table_put(tab, janet_ckeywordv("source-map"),
-                janet_wrap_tuple(janetc_make_sourcemap(c)));
+                        janet_wrap_tuple(janetc_make_sourcemap(c)));
         tab->proto = attr;
         JanetSlot valsym = janetc_cslot(janet_ckeywordv("value"));
         JanetSlot tabslot = janetc_cslot(janet_wrap_table(tab));
@@ -382,8 +377,8 @@ static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) {
 
     /* Set target for compilation */
     target = (drop || tail)
-        ? janetc_cslot(janet_wrap_nil())
-        : janetc_gettarget(opts);
+             ? janetc_cslot(janet_wrap_nil())
+             : janetc_gettarget(opts);
 
     /* Compile condition */
     janetc_scope(&condscope, c, 0, "if");
@@ -476,6 +471,61 @@ static int32_t janetc_addfuncdef(JanetCompiler *c, JanetFuncDef *def) {
     return janet_v_count(scope->defs) - 1;
 }
 
+/*
+ * break
+ *
+ * jump :end or retn if in function
+ */
+static JanetSlot janetc_break(JanetFopts opts, int32_t argn, const Janet *argv) {
+    JanetCompiler *c = opts.compiler;
+    JanetScope *scope = c->scope;
+    if (argn > 1) {
+        janetc_cerror(c, "expected at most 1 argument");
+        return janetc_cslot(janet_wrap_nil());
+    }
+
+    /* Find scope to break from */
+    while (scope) {
+        if (scope->flags & (JANET_SCOPE_FUNCTION | JANET_SCOPE_WHILE))
+            break;
+        scope = scope->parent;
+    }
+    if (NULL == scope) {
+        janetc_cerror(c, "break must occur in while loop or closure");
+        return janetc_cslot(janet_wrap_nil());
+    }
+
+    /* Emit code to break from that scope */
+    JanetFopts subopts = janetc_fopts_default(c);
+    if (scope->flags & JANET_SCOPE_FUNCTION) {
+        if (!(scope->flags & JANET_SCOPE_WHILE) && argn) {
+            /* Closure body with return argument */
+            subopts.flags |= JANET_FOPTS_TAIL;
+            JanetSlot ret = janetc_value(subopts, argv[0]);
+            ret.flags |= JANET_SLOT_RETURNED;
+            return ret;
+        } else {
+            /* while loop IIFE or no argument */
+            if (argn) {
+                subopts.flags |= JANET_FOPTS_DROP;
+                janetc_value(subopts, argv[0]);
+            }
+            janetc_emit(c, JOP_RETURN_NIL);
+            JanetSlot s = janetc_cslot(janet_wrap_nil());
+            s.flags |= JANET_SLOT_RETURNED;
+            return s;
+        }
+    } else {
+        if (argn) {
+            subopts.flags |= JANET_FOPTS_DROP;
+            janetc_value(subopts, argv[0]);
+        }
+        /* Tag the instruction so the while special can turn it into a proper jump */
+        janetc_emit(c, 0x80 | JOP_JUMP);
+        return janetc_cslot(janet_wrap_nil());
+    }
+}
+
 /*
  * :whiletop
  * ...
@@ -500,7 +550,7 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)
 
     labelwt = janet_v_count(c->buffer);
 
-    janetc_scope(&tempscope, c, 0, "while");
+    janetc_scope(&tempscope, c, JANET_SCOPE_WHILE, "while");
 
     /* Compile condition */
     cond = janetc_value(subopts, argv[0]);
@@ -518,8 +568,8 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)
 
     /* Infinite loop does not need to check condition */
     labelc = infinite
-        ? 0
-        : janetc_emit_si(c, JOP_JUMP_IF_NOT, cond, 0, 0);
+             ? 0
+             : janetc_emit_si(c, JOP_JUMP_IF_NOT, cond, 0, 0);
 
     /* Compile body */
     for (i = 1; i < argn; i++) {
@@ -571,8 +621,15 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)
 
     /* Calculate jumps */
     labeld = janet_v_count(c->buffer);
-    if (!infinite) c->buffer[labelc] |= (labeld - labelc) << 16;
-    c->buffer[labeljt] |= (labelwt - labeljt) << 8;
+    if (!infinite) c->buffer[labelc] |= (uint32_t)(labeld - labelc) << 16;
+    c->buffer[labeljt] |= (uint32_t)(labelwt - labeljt) << 8;
+
+    /* Calculate breaks */
+    for (int32_t i = labelwt; i < labeld; i++) {
+        if (c->buffer[i] == (0x80 | JOP_JUMP)) {
+            c->buffer[i] = JOP_JUMP | ((labeld - i) << 8);
+        }
+    }
 
     /* Pop scope and return nil slot */
     janetc_popscope(c);
@@ -586,16 +643,17 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     JanetSlot ret;
     Janet head;
     JanetScope fnscope;
-    int32_t paramcount, argi, parami, arity, defindex, i;
+    int32_t paramcount, argi, parami, arity, min_arity, max_arity, defindex, i;
     JanetFopts subopts = janetc_fopts_default(c);
     const Janet *params;
     const char *errmsg = NULL;
 
     /* Function flags */
     int vararg = 0;
-    int fixarity = 1;
+    int allow_extra = 0;
     int selfref = 0;
     int seenamp = 0;
+    int seenopt = 0;
 
     /* Begin function */
     c->scope->flags |= JANET_SCOPE_CLOSURE;
@@ -626,19 +684,32 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
         Janet param = params[i];
         if (janet_checktype(param, JANET_SYMBOL)) {
             /* Check for varargs and unfixed arity */
-            if ((!seenamp) &&
-                    (0 == janet_cstrcmp(janet_unwrap_symbol(param), "&"))) {
-                seenamp = 1;
-                fixarity = 0;
-                if (i == paramcount - 1) {
+            if (!janet_cstrcmp(janet_unwrap_symbol(param), "&")) {
+                if (seenamp) {
+                    errmsg = "& in unexpected location";
+                    goto error;
+                } else if (i == paramcount - 1) {
+                    allow_extra = 1;
                     arity--;
                 } else if (i == paramcount - 2) {
                     vararg = 1;
                     arity -= 2;
                 } else {
-                    errmsg = "variable argument symbol in unexpected location";
+                    errmsg = "& in unexpected location";
                     goto error;
                 }
+                seenamp = 1;
+            } else if (!janet_cstrcmp(janet_unwrap_symbol(param), "&opt")) {
+                if (seenopt) {
+                    errmsg = "only one &opt allowed";
+                    goto error;
+                } else if (i == paramcount - 1) {
+                    errmsg = "&opt cannot be last item in parameter list";
+                    goto error;
+                }
+                min_arity = i;
+                arity--;
+                seenopt = 1;
             } else {
                 janetc_nameslot(c, janet_unwrap_symbol(param), janetc_farslot(c));
             }
@@ -647,6 +718,9 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
         }
     }
 
+    max_arity = (vararg || allow_extra) ? INT32_MAX : arity;
+    if (!seenopt) min_arity = arity;
+
     /* Check for self ref */
     if (selfref) {
         JanetSlot slot = janetc_farslot(c);
@@ -658,17 +732,20 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     /* Compile function body */
     if (parami + 1 == argn) {
         janetc_emit(c, JOP_RETURN_NIL);
-    } else for (argi = parami + 1; argi < argn; argi++) {
-        subopts.flags = (argi == (argn - 1)) ? JANET_FOPTS_TAIL : JANET_FOPTS_DROP;
-        janetc_value(subopts, argv[argi]);
-        if (c->result.status == JANET_COMPILE_ERROR)
-            goto error2;
+    } else {
+        for (argi = parami + 1; argi < argn; argi++) {
+            subopts.flags = (argi == (argn - 1)) ? JANET_FOPTS_TAIL : JANET_FOPTS_DROP;
+            janetc_value(subopts, argv[argi]);
+            if (c->result.status == JANET_COMPILE_ERROR)
+                goto error2;
+        }
     }
 
     /* Build function */
     def = janetc_pop_funcdef(c);
     def->arity = arity;
-    if (fixarity) def->flags |= JANET_FUNCDEF_FLAG_FIXARITY;
+    def->min_arity = min_arity;
+    def->max_arity = max_arity;
     if (vararg) def->flags |= JANET_FUNCDEF_FLAG_VARARG;
 
     if (selfref) def->name = janet_unwrap_symbol(head);
@@ -691,6 +768,7 @@ error2:
 
 /* Keep in lexicographic order */
 static const JanetSpecial janetc_specials[] = {
+    {"break", janetc_break},
     {"def", janetc_def},
     {"do", janetc_do},
     {"fn", janetc_fn},
@@ -707,9 +785,9 @@ static const JanetSpecial janetc_specials[] = {
 /* Find a special */
 const JanetSpecial *janetc_special(const uint8_t *name) {
     return janet_strbinsearch(
-            &janetc_specials,
-            sizeof(janetc_specials)/sizeof(JanetSpecial),
-            sizeof(JanetSpecial),
-            name);
+               &janetc_specials,
+               sizeof(janetc_specials) / sizeof(JanetSpecial),
+               sizeof(JanetSpecial),
+               name);
 }
 

src/core/string.c

@@ -23,7 +23,7 @@
 #include <string.h>
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "gc.h"
 #include "util.h"
 #include "state.h"
@@ -31,11 +31,11 @@
 
 /* Begin building a string */
 uint8_t *janet_string_begin(int32_t length) {
-    char *data = janet_gcalloc(JANET_MEMORY_STRING, 2 * sizeof(int32_t) + length + 1);
-    uint8_t *str = (uint8_t *) (data + 2 * sizeof(int32_t));
-    janet_string_length(str) = length;
-    str[length] = 0;
-    return str;
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + length + 1);
+    head->length = length;
+    uint8_t *data = (uint8_t *)head->data;
+    data[length] = 0;
+    return data;
 }
 
 /* Finish building a string */
@@ -46,14 +46,13 @@ const uint8_t *janet_string_end(uint8_t *str) {
 
 /* Load a buffer as a string */
 const uint8_t *janet_string(const uint8_t *buf, int32_t len) {
-    int32_t hash = janet_string_calchash(buf, len);
-    char *data = janet_gcalloc(JANET_MEMORY_STRING, 2 * sizeof(int32_t) + len + 1);
-    uint8_t *str = (uint8_t *) (data + 2 * sizeof(int32_t));
-    memcpy(str, buf, len);
-    str[len] = 0;
-    janet_string_length(str) = len;
-    janet_string_hash(str) = hash;
-    return str;
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + len + 1);
+    head->length = len;
+    head->hash = janet_string_calchash(buf, len);
+    uint8_t *data = (uint8_t *)head->data;
+    memcpy(data, buf, len);
+    data[len] = 0;
+    return data;
 }
 
 /* Compare two strings */
@@ -81,7 +80,7 @@ int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen
 /* Check if two strings are equal */
 int janet_string_equal(const uint8_t *lhs, const uint8_t *rhs) {
     return janet_string_equalconst(lhs, rhs,
-            janet_string_length(rhs), janet_string_hash(rhs));
+                                   janet_string_length(rhs), janet_string_hash(rhs));
 }
 
 /* Load a c string */
@@ -102,9 +101,9 @@ struct kmp_state {
 };
 
 static void kmp_init(
-        struct kmp_state *s,
-        const uint8_t *text, int32_t textlen,
-        const uint8_t *pat, int32_t patlen) {
+    struct kmp_state *s,
+    const uint8_t *text, int32_t textlen,
+    const uint8_t *pat, int32_t patlen) {
     int32_t *lookup = calloc(patlen, sizeof(int32_t));
     if (!lookup) {
         JANET_OUT_OF_MEMORY;
@@ -183,8 +182,7 @@ static Janet cfun_string_repeat(int32_t argc, Janet *argv) {
     if (mulres > INT32_MAX) janet_panic("result string is too long");
     uint8_t *newbuf = janet_string_begin((int32_t) mulres);
     uint8_t *end = newbuf + mulres;
-    uint8_t *p = newbuf;
-    for (p = newbuf; p < end; p += view.len) {
+    for (uint8_t *p = newbuf; p < end; p += view.len) {
         memcpy(p, view.bytes, view.len);
     }
     return janet_wrap_string(janet_string_end(newbuf));
@@ -272,8 +270,8 @@ static Janet cfun_string_find(int32_t argc, Janet *argv) {
     result = kmp_next(&state);
     kmp_deinit(&state);
     return result < 0
-        ? janet_wrap_nil()
-        : janet_wrap_integer(result);
+           ? janet_wrap_nil()
+           : janet_wrap_integer(result);
 }
 
 static Janet cfun_string_findall(int32_t argc, Janet *argv) {
@@ -324,8 +322,8 @@ static Janet cfun_string_replace(int32_t argc, Janet *argv) {
     memcpy(buf, s.kmp.text, result);
     memcpy(buf + result, s.subst, s.substlen);
     memcpy(buf + result + s.substlen,
-            s.kmp.text + result + s.kmp.patlen,
-            s.kmp.textlen - result - s.kmp.patlen);
+           s.kmp.text + result + s.kmp.patlen,
+           s.kmp.textlen - result - s.kmp.patlen);
     kmp_deinit(&s.kmp);
     return janet_wrap_string(janet_string_end(buf));
 }
@@ -441,178 +439,110 @@ static Janet cfun_string_join(int32_t argc, Janet *argv) {
     return janet_wrap_string(janet_string_end(buf));
 }
 
-static struct formatter {
-    const char *lead;
-    const char *f1;
-    const char *f2;
-} formatters[] = {
-    {"g", "%g", "%.*g"},
-    {"G", "%G", "%.*G"},
-    {"e", "%e", "%.*e"},
-    {"E", "%E", "%.*E"},
-    {"f", "%f", "%.*f"},
-    {"F", "%F", "%.*F"}
-};
-
-static Janet cfun_string_number(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 4);
-    double x = janet_getnumber(argv, 0);
-    struct formatter fmter = formatters[0];
-    char buf[100];
-    int formatNargs = 1;
-    int32_t precision = 0;
-    if (argc >= 2) {
-        const uint8_t *flag = janet_getkeyword(argv, 1);
-        int i;
-        for (i = 0; i < 6; i++) {
-            struct formatter fmttest = formatters[i];
-            if (!janet_cstrcmp(flag, fmttest.lead)) {
-                fmter = fmttest;
-                break;
-            }
-        }
-        if (i == 6)
-            janet_panicf("unsupported formatter %v", argv[1]);
-    }
-
-    if (argc >= 3) {
-        precision = janet_getinteger(argv, 2);
-        formatNargs++;
-    }
-
-    if (formatNargs == 1) {
-        snprintf(buf, sizeof(buf), fmter.f1, x);
-    } else if (formatNargs == 2) {
-        snprintf(buf, sizeof(buf), fmter.f2, precision, x);
-    }
-
-    return janet_cstringv(buf);
-}
-
-static Janet cfun_string_pretty(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 3);
-    JanetBuffer *buffer = NULL;
-    int32_t depth = 4;
-    if (argc > 1)
-        depth = janet_getinteger(argv, 1);
-    if (argc > 2)
-        buffer = janet_getbuffer(argv, 2);
-    buffer = janet_pretty(buffer, depth, argv[0]);
-    return janet_wrap_buffer(buffer);
+static Janet cfun_string_format(int32_t argc, Janet *argv) {
+    janet_arity(argc, 1, -1);
+    JanetBuffer *buffer = janet_buffer(0);
+    const char *strfrmt = (const char *) janet_getstring(argv, 0);
+    janet_buffer_format(buffer, strfrmt, 0, argc, argv);
+    return janet_stringv(buffer->data, buffer->count);
 }
 
 static const JanetReg string_cfuns[] = {
     {
         "string/slice", cfun_string_slice,
         JDOC("(string/slice bytes [,start=0 [,end=(length str)]])\n\n"
-                "Returns a substring from a byte sequence. The substring is from "
-                "index start inclusive to index end exclusive. All indexing "
-                "is from 0. 'start' and 'end' can also be negative to indicate indexing "
-                "from the end of the string.")
+             "Returns a substring from a byte sequence. The substring is from "
+             "index start inclusive to index end exclusive. All indexing "
+             "is from 0. 'start' and 'end' can also be negative to indicate indexing "
+             "from the end of the string.")
     },
     {
         "string/repeat", cfun_string_repeat,
         JDOC("(string/repeat bytes n)\n\n"
-                "Returns a string that is n copies of bytes concatenated.")
+             "Returns a string that is n copies of bytes concatenated.")
     },
     {
         "string/bytes", cfun_string_bytes,
         JDOC("(string/bytes str)\n\n"
-                "Returns an array of integers that are the byte values of the string.")
+             "Returns an array of integers that are the byte values of the string.")
     },
     {
         "string/from-bytes", cfun_string_frombytes,
         JDOC("(string/from-bytes byte-array)\n\n"
-                "Creates a string from an array of integers with byte values. All integers "
-                "will be coerced to the range of 1 byte 0-255.")
+             "Creates a string from an array of integers with byte values. All integers "
+             "will be coerced to the range of 1 byte 0-255.")
     },
     {
         "string/ascii-lower", cfun_string_asciilower,
         JDOC("(string/ascii-lower str)\n\n"
-                "Returns a new string where all bytes are replaced with the "
-                "lowercase version of themselves in ASCII. Does only a very simple "
-                "case check, meaning no unicode support.")
+             "Returns a new string where all bytes are replaced with the "
+             "lowercase version of themselves in ASCII. Does only a very simple "
+             "case check, meaning no unicode support.")
     },
     {
         "string/ascii-upper", cfun_string_asciiupper,
         JDOC("(string/ascii-upper str)\n\n"
-                "Returns a new string where all bytes are replaced with the "
-                "uppercase version of themselves in ASCII. Does only a very simple "
-                "case check, meaning no unicode support.")
+             "Returns a new string where all bytes are replaced with the "
+             "uppercase version of themselves in ASCII. Does only a very simple "
+             "case check, meaning no unicode support.")
     },
     {
         "string/reverse", cfun_string_reverse,
         JDOC("(string/reverse str)\n\n"
-                "Returns a string that is the reversed version of str.")
+             "Returns a string that is the reversed version of str.")
     },
     {
         "string/find", cfun_string_find,
         JDOC("(string/find patt str)\n\n"
-                "Searches for the first instance of pattern patt in string "
-                "str. Returns the index of the first character in patt if found, "
-                "otherwise returns nil.")
+             "Searches for the first instance of pattern patt in string "
+             "str. Returns the index of the first character in patt if found, "
+             "otherwise returns nil.")
     },
     {
         "string/find-all", cfun_string_findall,
         JDOC("(string/find patt str)\n\n"
-                "Searches for all instances of pattern patt in string "
-                "str. Returns an array of all indices of found patterns. Overlapping "
-                "instances of the pattern are not counted, meaning a byte in string "
-                "will only contribute to finding at most on occurrence of pattern. If no "
-                "occurrences are found, will return an empty array.")
+             "Searches for all instances of pattern patt in string "
+             "str. Returns an array of all indices of found patterns. Overlapping "
+             "instances of the pattern are not counted, meaning a byte in string "
+             "will only contribute to finding at most on occurrence of pattern. If no "
+             "occurrences are found, will return an empty array.")
     },
     {
         "string/replace", cfun_string_replace,
         JDOC("(string/replace patt subst str)\n\n"
-                "Replace the first occurrence of patt with subst in the string str. "
-                "Will return the new string if patt is found, otherwise returns str.")
+             "Replace the first occurrence of patt with subst in the string str. "
+             "Will return the new string if patt is found, otherwise returns str.")
     },
     {
         "string/replace-all", cfun_string_replaceall,
         JDOC("(string/replace-all patt subst str)\n\n"
-                "Replace all instances of patt with subst in the string str. "
-                "Will return the new string if patt is found, otherwise returns str.")
+             "Replace all instances of patt with subst in the string str. "
+             "Will return the new string if patt is found, otherwise returns str.")
     },
     {
         "string/split", cfun_string_split,
         JDOC("(string/split delim str)\n\n"
-                "Splits a string str with delimiter delim and returns an array of "
-                "substrings. The substrings will not contain the delimiter delim. If delim "
-                "is not found, the returned array will have one element.")
+             "Splits a string str with delimiter delim and returns an array of "
+             "substrings. The substrings will not contain the delimiter delim. If delim "
+             "is not found, the returned array will have one element.")
     },
     {
         "string/check-set", cfun_string_checkset,
         JDOC("(string/check-set set str)\n\n"
-                "Checks if any of the bytes in the string set appear in the string str. "
-                "Returns true if some bytes in set do appear in str, false if no bytes do.")
+             "Checks if any of the bytes in the string set appear in the string str. "
+             "Returns true if some bytes in set do appear in str, false if no bytes do.")
     },
     {
         "string/join", cfun_string_join,
         JDOC("(string/join parts [,sep])\n\n"
-                "Joins an array of strings into one string, optionally separated by "
-                "a separator string sep.")
+             "Joins an array of strings into one string, optionally separated by "
+             "a separator string sep.")
     },
     {
-        "string/number", cfun_string_number,
-        JDOC("(string/number x [,format [,maxlen [,precision]]])\n\n"
-                "Formats a number as string. The format parameter indicates how "
-                "to display the number, either as floating point, scientific, or "
-                "whichever representation is shorter. format can be:\n\n"
-                "\t:g - (default) shortest representation with lowercase e.\n"
-                "\t:G - shortest representation with uppercase E.\n"
-                "\t:e - scientific with lowercase e.\n"
-                "\t:E - scientific with uppercase E.\n"
-                "\t:f - floating point representation.\n"
-                "\t:F - same as :f\n\n"
-                "The programmer can also specify the max length of the output string "
-                "and the precision (number of places after decimal) in the output number. "
-                "Returns a string representation of x.")
-    },
-    {
-        "string/pretty", cfun_string_pretty,
-        JDOC("(string/pretty x [,depth=4 [,buffer=@\"\"]])\n\n"
-                "Pretty prints a value to a buffer. Optionally allows setting max "
-                "recursion depth, as well as writing to a buffer. Returns the buffer.")
+        "string/format", cfun_string_format,
+        JDOC("(string/format format & values)\n\n"
+             "Similar to snprintf, but specialized for operating with janet. Returns "
+             "a new string.")
     },
     {NULL, NULL, NULL}
 };

src/core/strtod.c

@@ -26,42 +26,38 @@
  * This version has been modified for much greater flexibility in parsing, such
  * as choosing the radix and supporting scientific notation with any radix.
  *
- * Numbers are of the form [-+]R[rR]I.F[eE&][-+]X where R is the radix, I is
- * the integer part, F is the fractional part, and X is the exponent. All
- * signs, radix, decimal point, fractional part, and exponent can be omitted.
- * The number will be considered and integer if the there is no decimal point
- * and no exponent. Any number greater the 2^32-1 or less than -(2^32) will be
- * coerced to a double. If there is an error, the function janet_scan_number will
- * return a janet nil. The radix is assumed to be 10 if omitted, and the E
+ * Numbers are of the form [-+]R[rR]I.F[eE&][-+]X in pseudo-regex form, where R
+ * is the radix, I is the integer part, F is the fractional part, and X is the
+ * exponent. All signs, radix, decimal point, fractional part, and exponent can
+ * be omitted.  The radix is assumed to be 10 if omitted, and the E or e
  * separator for the exponent can only be used when the radix is 10. This is
- * because E is a valid digit in bases 15 or greater. For bases greater than 10,
- * the letters are used as digits. A through Z correspond to the digits 10
+ * because E is a valid digit in bases 15 or greater. For bases greater than
+ * 10, the letters are used as digits. A through Z correspond to the digits 10
  * through 35, and the lowercase letters have the same values. The radix number
  * is always in base 10. For example, a hexidecimal number could be written
  * '16rdeadbeef'. janet_scan_number also supports some c style syntax for
  * hexidecimal literals. The previous number could also be written
- * '0xdeadbeef'. Note that in this case, the number will actually be a double
- * as it will not fit in the range for a signed 32 bit integer. The string
- * '0xbeef' would parse to an integer as it is in the range of an int32_t. */
+ * '0xdeadbeef'.
+ */
 
 #include <math.h>
 #include <string.h>
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #endif
 
 /* Lookup table for getting values of characters when parsing numbers. Handles
  * digits 0-9 and a-z (and A-Z). A-Z have values of 10 to 35. */
 static uint8_t digit_lookup[128] = {
-    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
-    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
-    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
-    0,1,2,3,4,5,6,7,8,9,0xff,0xff,0xff,0xff,0xff,0xff,
-    0xff,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
-    25,26,27,28,29,30,31,32,33,34,35,0xff,0xff,0xff,0xff,0xff,
-    0xff,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
-    25,26,27,28,29,30,31,32,33,34,35,0xff,0xff,0xff,0xff,0xff
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 0xff, 0xff, 0xff, 0xff, 0xff
 };
 
 #define BIGNAT_NBIT 31
@@ -75,6 +71,7 @@ struct BigNat {
     uint32_t *digits; /* Each digit is base (2 ^ 31). Digits are least significant first. */
 };
 
+/* Initialize a bignat to 0 */
 static void bignat_zero(struct BigNat *x) {
     x->first_digit = 0;
     x->n = 0;
@@ -125,7 +122,7 @@ static void bignat_div(struct BigNat *mant, uint32_t divisor) {
     int32_t i;
     uint32_t quotient, remainder;
     uint64_t dividend;
-    remainder = 0;
+    remainder = 0, quotient = 0;
     for (i = mant->n - 1; i >= 0; i--) {
         dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->digits[i];
         if (i < mant->n - 1) mant->digits[i + 1] = quotient;
@@ -197,13 +194,13 @@ static double bignat_extract(struct BigNat *mant, int32_t exponent2) {
 }
 
 /* Read in a mantissa and exponent of a certain base, and give
- * back the double value. Should properly handle 0s, Infinities, and
+ * back the double value. Should properly handle 0s, infinities, and
  * denormalized numbers. (When the exponent values are too large) */
 static double convert(
-        int negative,
-        struct BigNat *mant,
-        int32_t base,
-        int32_t exponent) {
+    int negative,
+    struct BigNat *mant,
+    int32_t base,
+    int32_t exponent) {
 
     int32_t exponent2 = 0;
 
@@ -217,9 +214,9 @@ static double convert(
      * Get exponent to zero while holding X constant. */
 
     /* Positive exponents are simple */
-    for (;exponent > 3; exponent -= 4) bignat_muladd(mant, base * base * base * base, 0);
-    for (;exponent > 1; exponent -= 2) bignat_muladd(mant, base * base, 0);
-    for (;exponent > 0; exponent -= 1) bignat_muladd(mant, base, 0);
+    for (; exponent > 3; exponent -= 4) bignat_muladd(mant, base * base * base * base, 0);
+    for (; exponent > 1; exponent -= 2) bignat_muladd(mant, base * base, 0);
+    for (; exponent > 0; exponent -= 1) bignat_muladd(mant, base, 0);
 
     /* Negative exponents are tricky - we don't want to loose bits
      * from integer division, so we need to premultiply. */
@@ -227,22 +224,22 @@ static double convert(
         int32_t shamt = 5 - exponent / 4;
         bignat_lshift_n(mant, shamt);
         exponent2 -= shamt * BIGNAT_NBIT;
-        for (;exponent < -3; exponent += 4) bignat_div(mant, base * base * base * base);
-        for (;exponent < -1; exponent += 2) bignat_div(mant, base * base);
-        for (;exponent <  0; exponent += 1) bignat_div(mant, base);
+        for (; exponent < -3; exponent += 4) bignat_div(mant, base * base * base * base);
+        for (; exponent < -1; exponent += 2) bignat_div(mant, base * base);
+        for (; exponent <  0; exponent += 1) bignat_div(mant, base);
     }
 
     return negative
-        ? -bignat_extract(mant, exponent2)
-        : bignat_extract(mant, exponent2);
+           ? -bignat_extract(mant, exponent2)
+           : bignat_extract(mant, exponent2);
 }
 
 /* Scan a real (double) from a string. If the string cannot be converted into
  * and integer, set *err to 1 and return 0. */
 int janet_scan_number(
-        const uint8_t *str,
-        int32_t len,
-        double *out) {
+    const uint8_t *str,
+    int32_t len,
+    double *out) {
     const uint8_t *end = str + len;
     int seenadigit = 0;
     int ex = 0;
@@ -274,14 +271,14 @@ int janet_scan_number(
         base = 16;
         str += 2;
     } else if (str + 1 < end  &&
-            str[0] >= '0' && str[0] <= '9' &&
-            str[1] == 'r') {
+               str[0] >= '0' && str[0] <= '9' &&
+               str[1] == 'r') {
         base = str[0] - '0';
         str += 2;
     } else if (str + 2 < end  &&
-            str[0] >= '0' && str[0] <= '9' &&
-            str[1] >= '0' && str[1] <= '9' &&
-            str[2] == 'r') {
+               str[0] >= '0' && str[0] <= '9' &&
+               str[1] >= '0' && str[1] <= '9' &&
+               str[2] == 'r') {
         base = 10 * (str[0] - '0') + (str[1] - '0');
         if (base < 2 || base > 36) goto error;
         str += 3;
@@ -349,7 +346,8 @@ int janet_scan_number(
             str++;
             seenadigit = 1;
         }
-        if (eneg) ex -= ee; else ex += ee;
+        if (eneg) ex -= ee;
+        else ex += ee;
     }
 
     if (!seenadigit)
@@ -359,7 +357,7 @@ int janet_scan_number(
     free(mant.digits);
     return 0;
 
-    error:
+error:
     free(mant.digits);
     return 1;
 }

src/core/struct.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "gc.h"
 #include "util.h"
 #include <math.h>
@@ -29,18 +29,18 @@
 
 /* Begin creation of a struct */
 JanetKV *janet_struct_begin(int32_t count) {
-
     /* Calculate capacity as power of 2 after 2 * count. */
     int32_t capacity = janet_tablen(2 * count);
     if (capacity < 0) capacity = janet_tablen(count + 1);
 
-    size_t s = sizeof(int32_t) * 4 + (capacity * sizeof(JanetKV));
-    char *data = janet_gcalloc(JANET_MEMORY_STRUCT, s);
-    JanetKV *st = (JanetKV *) (data + 4 * sizeof(int32_t));
+    size_t size = sizeof(JanetStructHead) + capacity * sizeof(JanetKV);
+    JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size);
+    head->length = count;
+    head->capacity = capacity;
+    head->hash = 0;
+
+    JanetKV *st = (JanetKV *)(head->data);
     janet_memempty(st, capacity);
-    janet_struct_length(st) = count;
-    janet_struct_capacity(st) = capacity;
-    janet_struct_hash(st) = 0;
     return st;
 }
 
@@ -78,54 +78,54 @@ void janet_struct_put(JanetKV *st, Janet key, Janet value) {
     /* Avoid extra items */
     if (janet_struct_hash(st) == janet_struct_length(st)) return;
     for (dist = 0, j = 0; j < 4; j += 2)
-    for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) {
-        int status;
-        int32_t otherhash;
-        int32_t otherindex, otherdist;
-        JanetKV *kv = st + i;
-        /* We found an empty slot, so just add key and value */
-        if (janet_checktype(kv->key, JANET_NIL)) {
-            kv->key = key;
-            kv->value = value;
-            /* Update the temporary count */
-            janet_struct_hash(st)++;
-            return;
+        for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) {
+            int status;
+            int32_t otherhash;
+            int32_t otherindex, otherdist;
+            JanetKV *kv = st + i;
+            /* We found an empty slot, so just add key and value */
+            if (janet_checktype(kv->key, JANET_NIL)) {
+                kv->key = key;
+                kv->value = value;
+                /* Update the temporary count */
+                janet_struct_hash(st)++;
+                return;
+            }
+            /* Robinhood hashing - check if colliding kv pair
+             * is closer to their source than current. We use robinhood
+             * hashing to ensure that equivalent structs that are constructed
+             * with different order have the same internal layout, and therefor
+             * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}.
+             * Collisions are resolved via an insertion sort insertion. */
+            otherhash = janet_hash(kv->key);
+            otherindex = janet_maphash(cap, otherhash);
+            otherdist = (i + cap - otherindex) & (cap - 1);
+            if (dist < otherdist)
+                status = -1;
+            else if (otherdist < dist)
+                status = 1;
+            else if (hash < otherhash)
+                status = -1;
+            else if (otherhash < hash)
+                status = 1;
+            else
+                status = janet_compare(key, kv->key);
+            /* If other is closer to their ideal slot */
+            if (status == 1) {
+                /* Swap current kv pair with pair in slot */
+                JanetKV temp = *kv;
+                kv->key = key;
+                kv->value = value;
+                key = temp.key;
+                value = temp.value;
+                /* Save dist and hash of new kv pair */
+                dist = otherdist;
+                hash = otherhash;
+            } else if (status == 0) {
+                /* A key was added to the struct more than once */
+                return;
+            }
         }
-        /* Robinhood hashing - check if colliding kv pair
-         * is closer to their source than current. We use robinhood
-         * hashing to ensure that equivalent structs that are constructed
-         * with different order have the same internal layout, and therefor
-         * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}.
-         * Collisions are resolved via an insertion sort insertion. */
-        otherhash = janet_hash(kv->key);
-        otherindex = janet_maphash(cap, otherhash);
-        otherdist = (i + cap - otherindex) & (cap - 1);
-        if (dist < otherdist)
-            status = -1;
-        else if (otherdist < dist)
-            status = 1;
-        else if (hash < otherhash)
-            status = -1;
-        else if (otherhash < hash)
-            status = 1;
-        else
-            status = janet_compare(key, kv->key);
-        /* If other is closer to their ideal slot */
-        if (status == 1) {
-            /* Swap current kv pair with pair in slot */
-            JanetKV temp = *kv;
-            kv->key = key;
-            kv->value = value;
-            key = temp.key;
-            value = temp.value;
-            /* Save dist and hash of new kv pair */
-            dist = otherdist;
-            hash = otherhash;
-        } else if (status == 0) {
-            /* A key was added to the struct more than once */
-            return;
-        }
-    }
 }
 
 /* Finish building a struct */

src/core/symcache.c

@@ -25,11 +25,14 @@
  * checks, all symbols are interned so that there is a single copy of it in the
  * whole program. Equality is then just a pointer check. */
 
+#include <string.h>
+
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "state.h"
 #include "gc.h"
 #include "util.h"
+#include "symcache.h"
 #endif
 
 /* Cache state */
@@ -41,7 +44,7 @@ JANET_THREAD_LOCAL uint32_t janet_vm_cache_deleted = 0;
 /* Initialize the cache (allocate cache memory) */
 void janet_symcache_init() {
     janet_vm_cache_capacity = 1024;
-    janet_vm_cache = calloc(1, janet_vm_cache_capacity * sizeof(const uint8_t **));
+    janet_vm_cache = calloc(1, janet_vm_cache_capacity * sizeof(const uint8_t *));
     if (NULL == janet_vm_cache) {
         JANET_OUT_OF_MEMORY;
     }
@@ -65,10 +68,10 @@ static const uint8_t JANET_SYMCACHE_DELETED[1] = {0};
  * If the item is not found, return the location
  * where one would put it. */
 static const uint8_t **janet_symcache_findmem(
-        const uint8_t *str,
-        int32_t len,
-        int32_t hash,
-        int *success) {
+    const uint8_t *str,
+    int32_t len,
+    int32_t hash,
+    int *success) {
     uint32_t bounds[4];
     uint32_t i, j, index;
     const uint8_t **firstEmpty = NULL;
@@ -81,7 +84,7 @@ static const uint8_t **janet_symcache_findmem(
     bounds[2] = 0;
     bounds[3] = index;
     for (j = 0; j < 4; j += 2)
-        for (i = bounds[j]; i < bounds[j+1]; ++i) {
+        for (i = bounds[j]; i < bounds[j + 1]; ++i) {
             const uint8_t *test = janet_vm_cache[i];
             /* Check empty spots */
             if (NULL == test) {
@@ -106,7 +109,7 @@ static const uint8_t **janet_symcache_findmem(
                 return janet_vm_cache + i;
             }
         }
-    notfound:
+notfound:
     *success = 0;
     return firstEmpty;
 }
@@ -118,7 +121,7 @@ static const uint8_t **janet_symcache_findmem(
 static void janet_cache_resize(uint32_t newCapacity) {
     uint32_t i, oldCapacity;
     const uint8_t **oldCache = janet_vm_cache;
-    const uint8_t **newCache = calloc(1, newCapacity * sizeof(const uint8_t **));
+    const uint8_t **newCache = calloc(1, newCapacity * sizeof(const uint8_t *));
     if (newCache == NULL) {
         JANET_OUT_OF_MEMORY;
     }
@@ -175,10 +178,10 @@ const uint8_t *janet_symbol(const uint8_t *str, int32_t len) {
     const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success);
     if (success)
         return *bucket;
-    newstr = (uint8_t *) janet_gcalloc(JANET_MEMORY_SYMBOL, 2 * sizeof(int32_t) + len + 1)
-        + (2 * sizeof(int32_t));
-    janet_string_hash(newstr) = hash;
-    janet_string_length(newstr) = len;
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + len + 1);
+    head->hash = hash;
+    head->length = len;
+    newstr = (uint8_t *)(head->data);
     memcpy(newstr, str, len);
     newstr[len] = 0;
     janet_symcache_put((const uint8_t *)newstr, bucket);
@@ -187,9 +190,7 @@ const uint8_t *janet_symbol(const uint8_t *str, int32_t len) {
 
 /* Get a symbol from a cstring */
 const uint8_t *janet_csymbol(const char *cstr) {
-    int32_t len = 0;
-    while (cstr[len]) len++;
-    return janet_symbol((const uint8_t *)cstr, len);
+    return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr));
 }
 
 /* Store counter for genysm to avoid quadratic behavior */
@@ -225,21 +226,19 @@ const uint8_t *janet_symbol_gen(void) {
      * is enough for resolving collisions. */
     do {
         hash = janet_string_calchash(
-                gensym_counter,
-                sizeof(gensym_counter) - 1);
+                   gensym_counter,
+                   sizeof(gensym_counter) - 1);
         bucket = janet_symcache_findmem(
-                gensym_counter,
-                sizeof(gensym_counter) - 1,
-                hash,
-                &status);
+                     gensym_counter,
+                     sizeof(gensym_counter) - 1,
+                     hash,
+                     &status);
     } while (status && (inc_gensym(), 1));
-    sym = (uint8_t *) janet_gcalloc(
-            JANET_MEMORY_SYMBOL,
-            2 * sizeof(int32_t) + sizeof(gensym_counter)) +
-        (2 * sizeof(int32_t));
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + sizeof(gensym_counter));
+    head->length = sizeof(gensym_counter) - 1;
+    head->hash = hash;
+    sym = (uint8_t *)(head->data);
     memcpy(sym, gensym_counter, sizeof(gensym_counter));
-    janet_string_length(sym) = sizeof(gensym_counter) - 1;
-    janet_string_hash(sym) = hash;
     janet_symcache_put((const uint8_t *)sym, bucket);
     return (const uint8_t *)sym;
 }

src/core/symcache.h

@@ -24,7 +24,7 @@
 #define JANET_SYMCACHE_H_defined
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #endif
 
 /* Initialize the cache (allocate cache memory) */

src/core/table.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "gc.h"
 #include "util.h"
 #include <math.h>
@@ -144,7 +144,7 @@ void janet_table_put(JanetTable *t, Janet key, Janet value) {
                 janet_table_rehash(t, janet_tablen(2 * t->count + 2));
             }
             bucket = janet_table_find(t, key);
-            if (janet_checktype(bucket->value, JANET_FALSE))
+            if (janet_checktype(bucket->value, JANET_BOOLEAN))
                 --t->deleted;
             bucket->key = key;
             bucket->value = value;
@@ -208,8 +208,8 @@ static Janet cfun_table_getproto(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 1);
     JanetTable *t = janet_gettable(argv, 0);
     return t->proto
-        ? janet_wrap_table(t->proto)
-        : janet_wrap_nil();
+           ? janet_wrap_table(t->proto)
+           : janet_wrap_nil();
 }
 
 static Janet cfun_table_setproto(int32_t argc, Janet *argv) {
@@ -239,34 +239,34 @@ static const JanetReg table_cfuns[] = {
     {
         "table/new", cfun_table_new,
         JDOC("(table/new capacity)\n\n"
-                "Creates a new empty table with pre-allocated memory "
-                "for capacity entries. This means that if one knows the number of "
-                "entries going to go in a table on creation, extra memory allocation "
-                "can be avoided. Returns the new table.")
+             "Creates a new empty table with pre-allocated memory "
+             "for capacity entries. This means that if one knows the number of "
+             "entries going to go in a table on creation, extra memory allocation "
+             "can be avoided. Returns the new table.")
     },
     {
         "table/to-struct", cfun_table_tostruct,
         JDOC("(table/to-struct tab)\n\n"
-                "Convert a table to a struct. Returns a new struct. This function "
-                "does not take into account prototype tables.")
+             "Convert a table to a struct. Returns a new struct. This function "
+             "does not take into account prototype tables.")
     },
     {
         "table/getproto", cfun_table_getproto,
         JDOC("(table/getproto tab)\n\n"
-                "Get the prototype table of a table. Returns nil if a table "
-                "has no prototype, otherwise returns the prototype.")
+             "Get the prototype table of a table. Returns nil if a table "
+             "has no prototype, otherwise returns the prototype.")
     },
     {
         "table/setproto", cfun_table_setproto,
         JDOC("(table/setproto tab proto)\n\n"
-                "Set the prototype of a table. Returns the original table tab.")
+             "Set the prototype of a table. Returns the original table tab.")
     },
     {
         "table/rawget", cfun_table_rawget,
         JDOC("(table/rawget tab key)\n\n"
-                "Gets a value from a table without looking at the prototype table. "
-                "If a table tab does not contain t directly, the function will return "
-                "nil without checking the prototype. Returns the value in the table.")
+             "Gets a value from a table without looking at the prototype table. "
+             "If a table tab does not contain t directly, the function will return "
+             "nil without checking the prototype. Returns the value in the table.")
     },
     {NULL, NULL, NULL}
 };

src/core/tuple.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "symcache.h"
 #include "gc.h"
 #include "util.h"
@@ -31,12 +31,12 @@
  * which should be filled with Janets. The memory will not be collected until
  * janet_tuple_end is called. */
 Janet *janet_tuple_begin(int32_t length) {
-    char *data = janet_gcalloc(JANET_MEMORY_TUPLE, 4 * sizeof(int32_t) + length * sizeof(Janet));
-    Janet *tuple = (Janet *)(data + (4 * sizeof(int32_t)));
-    janet_tuple_length(tuple) = length;
-    janet_tuple_sm_start(tuple) = -1;
-    janet_tuple_sm_end(tuple) = -1;
-    return tuple;
+    size_t size = sizeof(JanetTupleHead) + (length * sizeof(Janet));
+    JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size);
+    head->sm_start = -1;
+    head->sm_end = -1;
+    head->length = length;
+    return (Janet *)(head->data);
 }
 
 /* Finish building a tuple */
@@ -93,53 +93,50 @@ int janet_tuple_compare(const Janet *lhs, const Janet *rhs) {
 
 /* C Functions */
 
+static Janet cfun_tuple_brackets(int32_t argc, Janet *argv) {
+    const Janet *tup = janet_tuple_n(argv, argc);
+    janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR;
+    return janet_wrap_tuple(tup);
+}
+
 static Janet cfun_tuple_slice(int32_t argc, Janet *argv) {
     JanetRange range = janet_getslice(argc, argv);
     JanetView view = janet_getindexed(argv, 0);
     return janet_wrap_tuple(janet_tuple_n(view.items + range.start, range.end - range.start));
 }
 
-static Janet cfun_tuple_prepend(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, -1);
-    JanetView view = janet_getindexed(argv, 0);
-    Janet *n = janet_tuple_begin(view.len - 1 + argc);
-    memcpy(n - 1 + argc, view.items, sizeof(Janet) * view.len);
-    for (int32_t i = 1; i < argc; i++) {
-        n[argc - i - 1] = argv[i];
+static Janet cfun_tuple_type(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    const Janet *tup = janet_gettuple(argv, 0);
+    if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) {
+        return janet_ckeywordv("brackets");
+    } else {
+        return janet_ckeywordv("parens");
     }
-    return janet_wrap_tuple(janet_tuple_end(n));
-}
-
-static Janet cfun_tuple_append(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, -1);
-    JanetView view = janet_getindexed(argv, 0);
-    Janet *n = janet_tuple_begin(view.len - 1 + argc);
-    memcpy(n, view.items, sizeof(Janet) * view.len);
-    memcpy(n + view.len, argv + 1, sizeof(Janet) * (argc - 1));
-    return janet_wrap_tuple(janet_tuple_end(n));
 }
 
 static const JanetReg tuple_cfuns[] = {
+    {
+        "tuple/brackets", cfun_tuple_brackets,
+        JDOC("(tuple/brackets & xs)\n\n"
+             "Creates a new bracketed tuple containing the elements xs.")
+    },
     {
         "tuple/slice", cfun_tuple_slice,
         JDOC("(tuple/slice arrtup [,start=0 [,end=(length arrtup)]])\n\n"
-                "Take a sub sequence of an array or tuple from index start "
-                "inclusive to index end exclusive. If start or end are not provided, "
-                "they default to 0 and the length of arrtup respectively."
-                "Returns the new tuple.")
+             "Take a sub sequence of an array or tuple from index start "
+             "inclusive to index end exclusive. If start or end are not provided, "
+             "they default to 0 and the length of arrtup respectively."
+             "Returns the new tuple.")
     },
     {
-        "tuple/append", cfun_tuple_append,
-        JDOC("(tuple/append tup & items)\n\n"
-                "Returns a new tuple that is the result of appending "
-                "each element in items to tup.")
-    },
-    {
-        "tuple/prepend", cfun_tuple_prepend,
-        JDOC("(tuple/prepend tup & items)\n\n"
-                "Prepends each element in items to tuple and "
-                "returns a new tuple. Items are prepended such that the "
-                "last element in items is the first element in the new tuple.")
+        "tuple/type", cfun_tuple_type,
+        JDOC("(tuple/type tup)\n\n"
+             "Checks how the tuple was constructed. Will return the keyword "
+             ":brackets if the tuple was parsed with brackets, and :parens "
+             "otherwise. The two types of tuples will behave the same most of "
+             "the time, but will print differently and be treated differently by "
+             "the compiler.")
     },
     {NULL, NULL, NULL}
 };

src/core/typedarray.c

@@ -0,0 +1,558 @@
+/*
+* Copyright (c) 2019 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.
+*/
+
+/* Compiler feature test macros for things */
+#define _DEFAULT_SOURCE
+#define _BSD_SOURCE
+
+#ifndef JANET_AMALG
+#include <janet.h>
+#include "util.h"
+#endif
+
+typedef uint8_t ta_uint8_t;
+typedef int8_t ta_int8_t;
+typedef uint16_t ta_uint16_t;
+typedef int16_t ta_int16_t;
+typedef uint32_t ta_uint32_t;
+typedef int32_t ta_int32_t;
+typedef float ta_float32_t;
+typedef double ta_float64_t;
+
+static char *ta_type_names[] = {
+    "uint8",
+    "int8",
+    "uint16",
+    "int16",
+    "uint32",
+    "int32",
+    "float32",
+    "float64",
+    "any"
+};
+
+static size_t ta_type_sizes[] = {
+    sizeof(ta_uint8_t),
+    sizeof(ta_int8_t),
+    sizeof(ta_uint16_t),
+    sizeof(ta_int16_t),
+    sizeof(ta_uint32_t),
+    sizeof(ta_int32_t),
+    sizeof(ta_float32_t),
+    sizeof(ta_float64_t),
+    0
+};
+
+#define TA_COUNT_TYPES (JANET_TARRAY_TYPE_float64 + 1)
+#define TA_ATOM_MAXSIZE 8
+#define TA_FLAG_BIG_ENDIAN 1
+
+static JanetTArrayType get_ta_type_by_name(const uint8_t *name) {
+    for (int i = 0; i < TA_COUNT_TYPES; i++) {
+        if (!janet_cstrcmp(name, ta_type_names[i]))
+            return i;
+    }
+    janet_panicf("invalid typed array type %S", name);
+    return 0;
+}
+
+static JanetTArrayBuffer *ta_buffer_init(JanetTArrayBuffer *buf, size_t size) {
+    buf->data = NULL;
+    if (size > 0) {
+        buf->data = (uint8_t *)calloc(size, sizeof(uint8_t));
+        if (buf->data == NULL) {
+            JANET_OUT_OF_MEMORY;
+        }
+    }
+    buf->size = size;
+#ifdef JANET_BIG_ENDIAN
+    buf->flags = TA_FLAG_BIG_ENDIAN;
+#else
+    buf->flags = 0;
+#endif
+    return buf;
+}
+
+static int ta_buffer_gc(void *p, size_t s) {
+    (void) s;
+    JanetTArrayBuffer *buf = (JanetTArrayBuffer *)p;
+    free(buf->data);
+    return 0;
+}
+
+static void ta_buffer_marshal(void *p, JanetMarshalContext *ctx) {
+    JanetTArrayBuffer *buf = (JanetTArrayBuffer *)p;
+    janet_marshal_size(ctx, buf->size);
+    janet_marshal_int(ctx, buf->flags);
+    janet_marshal_bytes(ctx, buf->data, buf->size);
+}
+
+static void ta_buffer_unmarshal(void *p, JanetMarshalContext *ctx) {
+    JanetTArrayBuffer *buf = (JanetTArrayBuffer *)p;
+    size_t size;
+    janet_unmarshal_size(ctx, &size);
+    ta_buffer_init(buf, size);
+    janet_unmarshal_int(ctx, &(buf->flags));
+    janet_unmarshal_bytes(ctx, buf->data, size);
+}
+
+static const JanetAbstractType ta_buffer_type = {
+    "ta/buffer",
+    ta_buffer_gc,
+    NULL,
+    NULL,
+    NULL,
+    ta_buffer_marshal,
+    ta_buffer_unmarshal,
+};
+
+static int ta_mark(void *p, size_t s) {
+    (void) s;
+    JanetTArrayView *view = (JanetTArrayView *)p;
+    janet_mark(janet_wrap_abstract(view->buffer));
+    return 0;
+}
+
+static void ta_view_marshal(void *p, JanetMarshalContext *ctx) {
+    JanetTArrayView *view = (JanetTArrayView *)p;
+    size_t offset = (view->buffer->data - (uint8_t *)(view->data));
+    janet_marshal_size(ctx, view->size);
+    janet_marshal_size(ctx, view->stride);
+    janet_marshal_int(ctx, view->type);
+    janet_marshal_size(ctx, offset);
+    janet_marshal_janet(ctx, janet_wrap_abstract(view->buffer));
+}
+
+static void ta_view_unmarshal(void *p, JanetMarshalContext *ctx) {
+    JanetTArrayView *view = (JanetTArrayView *)p;
+    size_t offset;
+    int32_t atype;
+    Janet buffer;
+    janet_unmarshal_size(ctx, &(view->size));
+    janet_unmarshal_size(ctx, &(view->stride));
+    janet_unmarshal_int(ctx, &atype);
+    if (atype < 0 || atype >= TA_COUNT_TYPES)
+        janet_panic("bad typed array type");
+    view->type = atype;
+    janet_unmarshal_size(ctx, &offset);
+    janet_unmarshal_janet(ctx, &buffer);
+    if (!janet_checktype(buffer, JANET_ABSTRACT) ||
+            (janet_abstract_type(janet_unwrap_abstract(buffer)) != &ta_buffer_type)) {
+        janet_panicf("expected typed array buffer");
+    }
+    view->buffer = (JanetTArrayBuffer *)janet_unwrap_abstract(buffer);
+    size_t buf_need_size = offset + (janet_tarray_type_size(view->type)) * ((view->size - 1) * view->stride + 1);
+    if (view->buffer->size < buf_need_size)
+        janet_panic("bad typed array offset in marshalled data");
+    view->data = view->buffer->data + offset;
+}
+
+#define DEFINE_VIEW_TYPE(thetype) \
+  typedef struct { \
+    JanetTArrayBuffer *buffer; \
+    ta_##thetype##_t *data; \
+    size_t size; \
+    size_t stride; \
+    JanetTArrayType type; \
+  } TA_View_##thetype ;
+
+#define DEFINE_VIEW_GETTER(type) \
+static Janet ta_get_##type(void *p, Janet key) { \
+  Janet value;  \
+  size_t index; \
+  if (!janet_checksize(key))      \
+    janet_panic("expected size as key");     \
+  index = (size_t)janet_unwrap_number(key);\
+  TA_View_##type *array=(TA_View_##type *)p; \
+  if (index >= array->size) { \
+    value = janet_wrap_nil(); \
+  } else { \
+    value = janet_wrap_number(array->data[index*array->stride]); \
+  } \
+  return value; \
+}
+
+#define DEFINE_VIEW_SETTER(type) \
+void ta_put_##type(void *p, Janet key,Janet value) { \
+  size_t index;\
+  if (!janet_checksize(key))\
+    janet_panic("expected size as key"); \
+  if (!janet_checktype(value,JANET_NUMBER)) \
+    janet_panic("expected number value"); \
+  index = (size_t)janet_unwrap_number(key); \
+  TA_View_##type *array=(TA_View_##type *)p; \
+  if (index >= array->size) { \
+    janet_panic("index out of bounds"); \
+  } \
+  array->data[index*array->stride]=(ta_##type##_t)janet_unwrap_number(value); \
+}
+
+#define DEFINE_VIEW_INITIALIZER(thetype) \
+  static JanetTArrayView *ta_init_##thetype(JanetTArrayView *view, \
+          JanetTArrayBuffer *buf, size_t size, \
+          size_t offset, size_t stride) { \
+  if ((stride<1) || (size <1)) {                    \
+      janet_panic("stride and size should be > 0");     \
+  }; \
+  TA_View_##thetype * tview=(TA_View_##thetype *) view; \
+  size_t buf_size=offset+(sizeof(ta_##thetype##_t))*((size-1)*stride+1);    \
+  if (buf==NULL) {  \
+    buf=(JanetTArrayBuffer *)janet_abstract(&ta_buffer_type,sizeof(JanetTArrayBuffer)); \
+    ta_buffer_init(buf,buf_size); \
+  } \
+  if (buf->size<buf_size) { \
+    janet_panicf("bad buffer size, %i bytes allocated < %i required",buf->size,buf_size); \
+  } \
+  tview->buffer=buf; \
+  tview->stride=stride; \
+  tview->size=size; \
+  tview->data=(ta_##thetype##_t *)(buf->data+offset);  \
+  tview->type=JANET_TARRAY_TYPE_##thetype; \
+  return view; \
+};
+
+#define BUILD_TYPE(type) \
+DEFINE_VIEW_TYPE(type)   \
+DEFINE_VIEW_GETTER(type)  \
+DEFINE_VIEW_SETTER(type) \
+DEFINE_VIEW_INITIALIZER(type)
+
+BUILD_TYPE(uint8)
+BUILD_TYPE(int8)
+BUILD_TYPE(uint16)
+BUILD_TYPE(int16)
+BUILD_TYPE(uint32)
+BUILD_TYPE(int32)
+BUILD_TYPE(float32)
+BUILD_TYPE(float64)
+
+#undef DEFINE_VIEW_TYPE
+#undef DEFINE_VIEW_GETTER
+#undef DEFINE_VIEW_SETTER
+#undef DEFINE_VIEW_INITIALIZER
+
+#define DEFINE_VIEW_ABSTRACT_TYPE(type) \
+{ \
+  "ta/"#type, \
+  NULL, \
+  ta_mark, \
+  ta_get_##type, \
+  ta_put_##type, \
+  ta_view_marshal, \
+  ta_view_unmarshal \
+}
+
+static const JanetAbstractType ta_array_types[] = {
+    DEFINE_VIEW_ABSTRACT_TYPE(uint8),
+    DEFINE_VIEW_ABSTRACT_TYPE(int8),
+    DEFINE_VIEW_ABSTRACT_TYPE(uint16),
+    DEFINE_VIEW_ABSTRACT_TYPE(int16),
+    DEFINE_VIEW_ABSTRACT_TYPE(uint32),
+    DEFINE_VIEW_ABSTRACT_TYPE(int32),
+    DEFINE_VIEW_ABSTRACT_TYPE(float32),
+    DEFINE_VIEW_ABSTRACT_TYPE(float64)
+};
+
+#undef DEFINE_VIEW_ABSTRACT_TYPE
+
+static int is_ta_anytype(Janet x) {
+    if (janet_checktype(x, JANET_ABSTRACT)) {
+        const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(x));
+        for (size_t i = 0; i < TA_COUNT_TYPES; i++) {
+            if (at == ta_array_types + i) return 1;
+        }
+    }
+    return 0;
+}
+
+static int is_ta_type(Janet x, JanetTArrayType type) {
+    return janet_checktype(x, JANET_ABSTRACT) &&
+           (type < TA_COUNT_TYPES) &&
+           (janet_abstract_type(janet_unwrap_abstract(x)) == &ta_array_types[type]);
+}
+
+#define CASE_TYPE_INITIALIZE(type) case JANET_TARRAY_TYPE_##type: \
+    ta_init_##type(view,buffer,size,offset,stride); break
+
+JanetTArrayBuffer *janet_tarray_buffer(size_t size) {
+    JanetTArrayBuffer *buf = (JanetTArrayBuffer *)janet_abstract(&ta_buffer_type, sizeof(JanetTArrayBuffer));
+    ta_buffer_init(buf, size);
+    return buf;
+}
+
+JanetTArrayView *janet_tarray_view(JanetTArrayType type, size_t size, size_t stride, size_t offset, JanetTArrayBuffer *buffer) {
+    JanetTArrayView *view = janet_abstract(&ta_array_types[type], sizeof(JanetTArrayView));
+    switch (type) {
+            CASE_TYPE_INITIALIZE(uint8);
+            CASE_TYPE_INITIALIZE(int8);
+            CASE_TYPE_INITIALIZE(uint16);
+            CASE_TYPE_INITIALIZE(int16);
+            CASE_TYPE_INITIALIZE(uint32);
+            CASE_TYPE_INITIALIZE(int32);
+            CASE_TYPE_INITIALIZE(float32);
+            CASE_TYPE_INITIALIZE(float64);
+        default :
+            janet_panic("bad typed array type");
+    }
+    return view;
+}
+
+#undef CASE_TYPE_INITIALIZE
+
+JanetTArrayBuffer *janet_gettarray_buffer(const Janet *argv, int32_t n) {
+    return (JanetTArrayBuffer *)janet_getabstract(argv, n, &ta_buffer_type);
+}
+
+int janet_is_tarray_view(Janet x, JanetTArrayType type) {
+    return (type == JANET_TARRAY_TYPE_any) ? is_ta_anytype(x) : is_ta_type(x, type);
+}
+
+size_t janet_tarray_type_size(JanetTArrayType type) {
+    return (type < TA_COUNT_TYPES) ? ta_type_sizes[type] : 0;
+}
+
+JanetTArrayView *janet_gettarray_view(const Janet *argv, int32_t n, JanetTArrayType type) {
+    if (janet_is_tarray_view(argv[n], type)) {
+        return (JanetTArrayView *)janet_unwrap_abstract(argv[n]);
+    } else {
+        janet_panicf("bad slot #%d, expected typed array of type %s, got %v",
+                     n, (type <= JANET_TARRAY_TYPE_any) ? ta_type_names[type] : "?", argv[n]);
+        return NULL;
+    }
+}
+
+static Janet cfun_typed_array_new(int32_t argc, Janet *argv) {
+    janet_arity(argc, 2, 5);
+    size_t offset = 0;
+    size_t stride = 1;
+    JanetTArrayBuffer *buffer = NULL;
+    const uint8_t *keyw = janet_getkeyword(argv, 0);
+    JanetTArrayType type = get_ta_type_by_name(keyw);
+    size_t size = janet_getsize(argv, 1);
+    if (argc > 2)
+        stride = janet_getsize(argv, 2);
+    if (argc > 3)
+        offset = janet_getsize(argv, 3);
+    if (argc > 4) {
+        if (is_ta_anytype(argv[4])) {
+            JanetTArrayView *view = (JanetTArrayView *)janet_unwrap_abstract(argv[4]);
+            offset = (view->buffer->data - (uint8_t *)(view->data)) + offset * ta_type_sizes[view->type];
+            stride *= view->stride;
+            buffer = view->buffer;
+        } else {
+            buffer = (JanetTArrayBuffer *)janet_getabstract(argv, 4, &ta_buffer_type);
+        }
+    }
+    JanetTArrayView *view = janet_tarray_view(type, size, stride, offset, buffer);
+    return janet_wrap_abstract(view);
+}
+
+static Janet cfun_typed_array_buffer(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    if (is_ta_anytype(argv[0])) {
+        JanetTArrayView *view = (JanetTArrayView *)janet_unwrap_abstract(argv[0]);
+        return janet_wrap_abstract(view->buffer);
+    }
+    size_t size = janet_getsize(argv, 0);
+    JanetTArrayBuffer *buf = janet_tarray_buffer(size);
+    return janet_wrap_abstract(buf);
+}
+
+static Janet cfun_typed_array_size(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    if (is_ta_anytype(argv[0])) {
+        JanetTArrayView *view = (JanetTArrayView *)janet_unwrap_abstract(argv[0]);
+        return janet_wrap_number((double) view->size);
+    }
+    JanetTArrayBuffer *buf = (JanetTArrayBuffer *)janet_getabstract(argv, 0, &ta_buffer_type);
+    return janet_wrap_number((double) buf->size);
+}
+
+static Janet cfun_typed_array_properties(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    if (is_ta_anytype(argv[0])) {
+        JanetTArrayView *view = (JanetTArrayView *)janet_unwrap_abstract(argv[0]);
+        JanetKV *props = janet_struct_begin(6);
+        ptrdiff_t boffset = (uint8_t *)(view->data) - view->buffer->data;
+        janet_struct_put(props, janet_ckeywordv("size"),
+                         janet_wrap_number((double) view->size));
+        janet_struct_put(props, janet_ckeywordv("byte-offset"),
+                         janet_wrap_number((double) boffset));
+        janet_struct_put(props, janet_ckeywordv("stride"),
+                         janet_wrap_number((double) view->stride));
+        janet_struct_put(props, janet_ckeywordv("type"),
+                         janet_ckeywordv(ta_type_names[view->type]));
+        janet_struct_put(props, janet_ckeywordv("type-size"),
+                         janet_wrap_number((double) ta_type_sizes[view->type]));
+        janet_struct_put(props, janet_ckeywordv("buffer"),
+                         janet_wrap_abstract(view->buffer));
+        return janet_wrap_struct(janet_struct_end(props));
+    } else {
+        JanetTArrayBuffer *buffer = janet_gettarray_buffer(argv, 0);
+        JanetKV *props = janet_struct_begin(2);
+        janet_struct_put(props, janet_ckeywordv("size"),
+                         janet_wrap_number((double) buffer->size));
+        janet_struct_put(props, janet_ckeywordv("big-endian"),
+                         janet_wrap_boolean(buffer->flags & TA_FLAG_BIG_ENDIAN));
+        return janet_wrap_struct(janet_struct_end(props));
+    }
+}
+
+static Janet cfun_typed_array_slice(int32_t argc, Janet *argv) {
+    janet_arity(argc, 1, 3);
+    JanetTArrayView *src = janet_gettarray_view(argv, 0, JANET_TARRAY_TYPE_any);
+    const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(argv[0]));
+    JanetRange range;
+    int32_t length = (int32_t)src->size;
+    if (argc == 1) {
+        range.start = 0;
+        range.end = length;
+    } else if (argc == 2) {
+        range.start = janet_gethalfrange(argv, 1, length, "start");
+        range.end = length;
+    } else {
+        range.start = janet_gethalfrange(argv, 1, length, "start");
+        range.end = janet_gethalfrange(argv, 2, length, "end");
+        if (range.end < range.start)
+            range.end = range.start;
+    }
+    JanetArray *array = janet_array(range.end - range.start);
+    if (array->data) {
+        for (int32_t i = range.start; i < range.end; i++) {
+            array->data[i - range.start] = at->get(src, janet_wrap_number(i));
+        }
+    }
+    array->count = range.end - range.start;
+    return janet_wrap_array(array);
+}
+
+static Janet cfun_typed_array_copy_bytes(int32_t argc, Janet *argv) {
+    janet_arity(argc, 4, 5);
+    JanetTArrayView *src = janet_gettarray_view(argv, 0, JANET_TARRAY_TYPE_any);
+    size_t index_src = janet_getsize(argv, 1);
+    JanetTArrayView *dst = janet_gettarray_view(argv, 2, JANET_TARRAY_TYPE_any);
+    size_t index_dst = janet_getsize(argv, 3);
+    size_t count = (argc == 5) ? janet_getsize(argv, 4) : 1;
+    size_t src_atom_size = ta_type_sizes[src->type];
+    size_t dst_atom_size = ta_type_sizes[dst->type];
+    size_t step_src = src->stride * src_atom_size;
+    size_t step_dst = dst->stride * dst_atom_size;
+    size_t pos_src = ((uint8_t *)(src->data) - src->buffer->data) + (index_src * step_src);
+    size_t pos_dst = ((uint8_t *)(dst->data) - dst->buffer->data) + (index_dst * step_dst);
+    uint8_t *ps = src->buffer->data + pos_src, * pd = dst->buffer->data + pos_dst;
+    if ((pos_dst + (count - 1)*step_dst + src_atom_size <= dst->buffer->size) &&
+            (pos_src + (count - 1)*step_src + src_atom_size <= src->buffer->size)) {
+        for (size_t i = 0; i < count; i++) {
+            memmove(pd, ps, src_atom_size);
+            pd += step_dst;
+            ps += step_src;
+        }
+    } else {
+        janet_panic("typed array copy out of bounds");
+    }
+    return janet_wrap_nil();
+}
+
+static Janet cfun_typed_array_swap_bytes(int32_t argc, Janet *argv) {
+    janet_arity(argc, 4, 5);
+    JanetTArrayView *src = janet_gettarray_view(argv, 0, JANET_TARRAY_TYPE_any);
+    size_t index_src = janet_getsize(argv, 1);
+    JanetTArrayView *dst = janet_gettarray_view(argv, 2, JANET_TARRAY_TYPE_any);
+    size_t index_dst = janet_getsize(argv, 3);
+    size_t count = (argc == 5) ? janet_getsize(argv, 4) : 1;
+    size_t src_atom_size = ta_type_sizes[src->type];
+    size_t dst_atom_size = ta_type_sizes[dst->type];
+    size_t step_src = src->stride * src_atom_size;
+    size_t step_dst = dst->stride * dst_atom_size;
+    size_t pos_src = ((uint8_t *)(src->data) - src->buffer->data) + (index_src * step_src);
+    size_t pos_dst = ((uint8_t *)(dst->data) - dst->buffer->data) + (index_dst * step_dst);
+    uint8_t *ps = src->buffer->data + pos_src, * pd = dst->buffer->data + pos_dst;
+    uint8_t temp[TA_ATOM_MAXSIZE];
+    if ((pos_dst + (count - 1)*step_dst + src_atom_size <= dst->buffer->size) &&
+            (pos_src + (count - 1)*step_src + src_atom_size <= src->buffer->size)) {
+        for (size_t i = 0; i < count; i++) {
+            memcpy(temp, ps, src_atom_size);
+            memcpy(ps, pd, src_atom_size);
+            memcpy(pd, temp, src_atom_size);
+            pd += step_dst;
+            ps += step_src;
+        }
+    } else {
+        janet_panic("typed array swap out of bounds");
+    }
+    return janet_wrap_nil();
+}
+
+static const JanetReg ta_cfuns[] = {
+    {
+        "tarray/new", cfun_typed_array_new,
+        JDOC("(tarray/new type size [stride = 1 [offset = 0 [tarray | buffer]]] )\n\n"
+             "Create new typed array.")
+    },
+    {
+        "tarray/buffer", cfun_typed_array_buffer,
+        JDOC("(tarray/buffer (array | size) )\n\n"
+             "Return typed array buffer or create a new buffer.")
+    },
+    {
+        "tarray/length", cfun_typed_array_size,
+        JDOC("(tarray/length (array | buffer) )\n\n"
+             "Return typed array or buffer size.")
+    },
+    {
+        "tarray/properties", cfun_typed_array_properties,
+        JDOC("(tarray/properties array )\n\n"
+             "Return typed array properties as a struct.")
+    },
+    {
+        "tarray/copy-bytes", cfun_typed_array_copy_bytes,
+        JDOC("(tarray/copy-bytes src sindex dst dindex [count=1])\n\n"
+             "Copy count elements of src array from index sindex "
+             "to dst array at position dindex "
+             "memory can overlap.")
+    },
+    {
+        "tarray/swap-bytes", cfun_typed_array_swap_bytes,
+        JDOC("(tarray/swap-bytes src sindex dst dindex [count=1])\n\n"
+             "Swap count elements between src array from index sindex "
+             "and dst array at position dindex "
+             "memory can overlap.")
+    },
+    {
+        "tarray/slice", cfun_typed_array_slice,
+        JDOC("(tarray/slice tarr [, start=0 [, end=(size tarr)]])\n\n"
+             "Takes a slice of a typed array from start to end. The range is half "
+             "open, [start, end). Indexes can also be negative, indicating indexing "
+             "from the end of the end of the typed array. By default, start is 0 and end is "
+             "the size of the typed array. Returns a new janet array.")
+    },
+    {NULL, NULL, NULL}
+};
+
+/* Module entry point */
+void janet_lib_typed_array(JanetTable *env) {
+    janet_core_cfuns(env, NULL, ta_cfuns);
+    janet_register_abstract_type(&ta_buffer_type);
+    for (int i = 0; i < TA_COUNT_TYPES; i++) {
+        janet_register_abstract_type(ta_array_types + i);
+    }
+}

src/core/util.c

@@ -23,7 +23,7 @@
 #include <inttypes.h>
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "util.h"
 #include "state.h"
 #include "gc.h"
@@ -42,7 +42,6 @@ const char *const janet_type_names[16] = {
     "number",
     "nil",
     "boolean",
-    "boolean",
     "fiber",
     "string",
     "symbol",
@@ -54,7 +53,8 @@ const char *const janet_type_names[16] = {
     "buffer",
     "function",
     "cfunction",
-    "abstract"
+    "abstract",
+    "pointer"
 };
 
 const char *const janet_signal_names[14] = {
@@ -210,10 +210,10 @@ int janet_cstrcmp(const uint8_t *str, const char *other) {
  * have a string as its first element, and the struct must be sorted
  * lexicographically by that element. */
 const void *janet_strbinsearch(
-        const void *tab,
-        size_t tabcount,
-        size_t itemsize,
-        const uint8_t *key) {
+    const void *tab,
+    size_t tabcount,
+    size_t itemsize,
+    const uint8_t *key) {
     size_t low = 0;
     size_t hi = tabcount;
     const char *t = (const char *)tab;
@@ -284,19 +284,71 @@ void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns)
     }
 }
 
+/* Abstract type introspection */
+
+static const JanetAbstractType type_wrap = {
+    "core/type-info",
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+typedef struct {
+    const JanetAbstractType *at;
+} JanetAbstractTypeWrap;
+
+void janet_register_abstract_type(const JanetAbstractType *at) {
+    JanetAbstractTypeWrap *abstract = (JanetAbstractTypeWrap *)
+                                      janet_abstract(&type_wrap, sizeof(JanetAbstractTypeWrap));
+    abstract->at = at;
+    Janet sym = janet_csymbolv(at->name);
+    if (!(janet_checktype(janet_table_get(janet_vm_registry, sym), JANET_NIL))) {
+        janet_panicf("cannot register abstract type %s, "
+                     "a type with the same name exists", at->name);
+    }
+    janet_table_put(janet_vm_registry, sym, janet_wrap_abstract(abstract));
+}
+
+const JanetAbstractType *janet_get_abstract_type(Janet key) {
+    Janet twrap = janet_table_get(janet_vm_registry, key);
+    if (janet_checktype(twrap, JANET_NIL)) {
+        return NULL;
+    }
+    if (!janet_checktype(twrap, JANET_ABSTRACT) ||
+            (janet_abstract_type(janet_unwrap_abstract(twrap)) != &type_wrap)) {
+        janet_panic("expected abstract type");
+    }
+    JanetAbstractTypeWrap *w = (JanetAbstractTypeWrap *)janet_unwrap_abstract(twrap);
+    return w->at;
+}
+
 #ifndef JANET_BOOTSTRAP
 void janet_core_def(JanetTable *env, const char *name, Janet x, const void *p) {
     (void) p;
-    janet_table_put(env, janet_csymbolv(name), x);
+    Janet key = janet_csymbolv(name);
+    Janet value;
+    /* During boot, allow replacing core library cfunctions with values from
+     * the env. */
+    Janet check = janet_table_get(env, key);
+    if (janet_checktype(check, JANET_NIL)) {
+        value = x;
+    } else {
+        value = check;
+        if (janet_checktype(check, JANET_CFUNCTION)) {
+            janet_table_put(janet_vm_registry, value, key);
+        }
+    }
+    janet_table_put(env, key, value);
 }
 
 void janet_core_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns) {
     (void) regprefix;
     while (cfuns->name) {
-        Janet name = janet_csymbolv(cfuns->name);
         Janet fun = janet_wrap_cfunction(cfuns->cfun);
         janet_core_def(env, cfuns->name, fun, cfuns->documentation);
-        janet_table_put(janet_vm_registry, fun, name);
         cfuns++;
     }
 }
@@ -311,8 +363,8 @@ JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out)
         return JANET_BINDING_NONE;
     entry_table = janet_unwrap_table(entry);
     if (!janet_checktype(
-        janet_table_get(entry_table, janet_ckeywordv("macro")),
-        JANET_NIL)) {
+                janet_table_get(entry_table, janet_ckeywordv("macro")),
+                JANET_NIL)) {
         *out = janet_table_get(entry_table, janet_ckeywordv("value"));
         return JANET_BINDING_MACRO;
     }
@@ -334,7 +386,7 @@ int janet_indexed_view(Janet seq, const Janet **data, int32_t *len) {
         return 1;
     } else if (janet_checktype(seq, JANET_TUPLE)) {
         *data = janet_unwrap_tuple(seq);
-        *len = janet_tuple_length(janet_unwrap_struct(seq));
+        *len = janet_tuple_length(janet_unwrap_tuple(seq));
         return 1;
     }
     return 0;
@@ -388,42 +440,10 @@ int janet_checkint64(Janet x) {
     return janet_checkint64range(dval);
 }
 
-/* Useful for inspecting values while debugging */
-void janet_inspect(Janet x) {
-    printf("<type=%s, ", janet_type_names[janet_type(x)]);
-
-#ifdef JANET_BIG_ENDIAN
-    printf("be ");
-#else
-    printf("le ");
-#endif
-
-#ifdef JANET_NANBOX_64
-    printf("nanbox64 raw=0x%.16" PRIx64 ", ", x.u64);
-#endif
-
-#ifdef JANET_NANBOX_32
-    printf("nanbox32 type=0x%.8" PRIx32 ", ", x.tagged.type);
-    printf("payload=%" PRId32 ", ", x.tagged.payload.integer);
-#endif
-
-    switch (janet_type(x)) {
-        case JANET_NIL:
-            printf("value=nil");
-            break;
-        case JANET_NUMBER:
-            printf("number=%.17g", janet_unwrap_number(x));
-            break;
-        case JANET_TRUE:
-            printf("value=true");
-            break;
-        case JANET_FALSE:
-            printf("value=false");
-            break;
-        default:
-            printf("pointer=%p", janet_unwrap_pointer(x));
-            break;
-    }
-
-    printf(">\n");
+int janet_checksize(Janet x) {
+    if (!janet_checktype(x, JANET_NUMBER))
+        return 0;
+    double dval = janet_unwrap_number(x);
+    return dval == (double)((size_t) dval) &&
+           dval <= SIZE_MAX;
 }

src/core/util.h

@@ -24,7 +24,7 @@
 #define JANET_UTIL_H_defined
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #endif
 
 /* Omit docstrings in some builds */
@@ -48,10 +48,16 @@ Janet janet_dict_get(const JanetKV *buckets, int32_t cap, Janet key);
 void janet_memempty(JanetKV *mem, int32_t count);
 void *janet_memalloc_empty(int32_t count);
 const void *janet_strbinsearch(
-        const void *tab,
-        size_t tabcount,
-        size_t itemsize,
-        const uint8_t *key);
+    const void *tab,
+    size_t tabcount,
+    size_t itemsize,
+    const uint8_t *key);
+void janet_buffer_format(
+    JanetBuffer *b,
+    const char *strfrmt,
+    int32_t argstart,
+    int32_t argc,
+    Janet *argv);
 
 /* Inside the janet core, defining globals is different
  * at bootstrap time and normal runtime */
@@ -80,6 +86,11 @@ void janet_lib_asm(JanetTable *env);
 #endif
 void janet_lib_compile(JanetTable *env);
 void janet_lib_debug(JanetTable *env);
+#ifdef JANET_PEG
 void janet_lib_peg(JanetTable *env);
+#endif
+#ifdef JANET_TYPED_ARRAY
+void janet_lib_typed_array(JanetTable *env);
+#endif
 
 #endif

src/core/value.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #endif
 
 /*
@@ -35,27 +35,28 @@ int janet_equals(Janet x, Janet y) {
         result = 0;
     } else {
         switch (janet_type(x)) {
-        case JANET_NIL:
-        case JANET_TRUE:
-        case JANET_FALSE:
-            result = 1;
-            break;
-        case JANET_NUMBER:
-            result = (janet_unwrap_number(x) == janet_unwrap_number(y));
-            break;
-        case JANET_STRING:
-            result = janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y));
-            break;
-        case JANET_TUPLE:
-            result = janet_tuple_equal(janet_unwrap_tuple(x), janet_unwrap_tuple(y));
-            break;
-        case JANET_STRUCT:
-            result = janet_struct_equal(janet_unwrap_struct(x), janet_unwrap_struct(y));
-            break;
-        default:
-            /* compare pointers */
-            result = (janet_unwrap_pointer(x) == janet_unwrap_pointer(y));
-            break;
+            case JANET_NIL:
+                result = 1;
+                break;
+            case JANET_BOOLEAN:
+                result = (janet_unwrap_boolean(x) == janet_unwrap_boolean(y));
+                break;
+            case JANET_NUMBER:
+                result = (janet_unwrap_number(x) == janet_unwrap_number(y));
+                break;
+            case JANET_STRING:
+                result = janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y));
+                break;
+            case JANET_TUPLE:
+                result = janet_tuple_equal(janet_unwrap_tuple(x), janet_unwrap_tuple(y));
+                break;
+            case JANET_STRUCT:
+                result = janet_struct_equal(janet_unwrap_struct(x), janet_unwrap_struct(y));
+                break;
+            default:
+                /* compare pointers */
+                result = (janet_unwrap_pointer(x) == janet_unwrap_pointer(y));
+                break;
         }
     }
     return result;
@@ -65,41 +66,38 @@ int janet_equals(Janet x, Janet y) {
 int32_t janet_hash(Janet x) {
     int32_t hash = 0;
     switch (janet_type(x)) {
-    case JANET_NIL:
-        hash = 0;
-        break;
-    case JANET_FALSE:
-        hash = 1;
-        break;
-    case JANET_TRUE:
-        hash = 2;
-        break;
-    case JANET_STRING:
-    case JANET_SYMBOL:
-    case JANET_KEYWORD:
-        hash = janet_string_hash(janet_unwrap_string(x));
-        break;
-    case JANET_TUPLE:
-        hash = janet_tuple_hash(janet_unwrap_tuple(x));
-        break;
-    case JANET_STRUCT:
-        hash = janet_struct_hash(janet_unwrap_struct(x));
-        break;
-    default:
-        /* TODO - test performance with different hash functions */
-        if (sizeof(double) == sizeof(void *)) {
-            /* Assuming 8 byte pointer */
-            uint64_t i = janet_u64(x);
-            hash = (int32_t)(i & 0xFFFFFFFF);
-            /* Get a bit more entropy by shifting the low bits out */
-            hash >>= 3;
-            hash ^= (int32_t) (i >> 32);
-        } else {
-            /* Assuming 4 byte pointer (or smaller) */
-            hash = (int32_t) ((char *)janet_unwrap_pointer(x) - (char *)0);
-            hash >>= 2;
-        }
-        break;
+        case JANET_NIL:
+            hash = 0;
+            break;
+        case JANET_BOOLEAN:
+            hash = janet_unwrap_boolean(x);
+            break;
+        case JANET_STRING:
+        case JANET_SYMBOL:
+        case JANET_KEYWORD:
+            hash = janet_string_hash(janet_unwrap_string(x));
+            break;
+        case JANET_TUPLE:
+            hash = janet_tuple_hash(janet_unwrap_tuple(x));
+            break;
+        case JANET_STRUCT:
+            hash = janet_struct_hash(janet_unwrap_struct(x));
+            break;
+        default:
+            /* TODO - test performance with different hash functions */
+            if (sizeof(double) == sizeof(void *)) {
+                /* Assuming 8 byte pointer */
+                uint64_t i = janet_u64(x);
+                hash = (int32_t)(i & 0xFFFFFFFF);
+                /* Get a bit more entropy by shifting the low bits out */
+                hash >>= 3;
+                hash ^= (int32_t)(i >> 32);
+            } else {
+                /* Assuming 4 byte pointer (or smaller) */
+                hash = (int32_t)((char *)janet_unwrap_pointer(x) - (char *)0);
+                hash >>= 2;
+            }
+            break;
     }
     return hash;
 }
@@ -111,15 +109,15 @@ int janet_compare(Janet x, Janet y) {
     if (janet_type(x) == janet_type(y)) {
         switch (janet_type(x)) {
             case JANET_NIL:
-            case JANET_FALSE:
-            case JANET_TRUE:
                 return 0;
+            case JANET_BOOLEAN:
+                return janet_unwrap_boolean(x) - janet_unwrap_boolean(y);
             case JANET_NUMBER:
                 /* Check for NaNs to ensure total order */
                 if (janet_unwrap_number(x) != janet_unwrap_number(x))
                     return janet_unwrap_number(y) != janet_unwrap_number(y)
-                        ? 0
-                        : -1;
+                           ? 0
+                           : -1;
                 if (janet_unwrap_number(y) != janet_unwrap_number(y))
                     return 1;
 
@@ -161,75 +159,70 @@ Janet janet_get(Janet ds, Janet key) {
         case JANET_TABLE:
             value = janet_table_get(janet_unwrap_table(ds), key);
             break;
-        case JANET_ARRAY:
-            {
-                JanetArray *array = janet_unwrap_array(ds);
-                int32_t index;
-                if (!janet_checkint(key))
-                    janet_panic("expected integer key");
-                index = janet_unwrap_integer(key);
-                if (index < 0 || index >= array->count) {
-                    value = janet_wrap_nil();
-                } else {
-                    value = array->data[index];
-                }
-                break;
+        case JANET_ARRAY: {
+            JanetArray *array = janet_unwrap_array(ds);
+            int32_t index;
+            if (!janet_checkint(key))
+                janet_panic("expected integer key");
+            index = janet_unwrap_integer(key);
+            if (index < 0 || index >= array->count) {
+                value = janet_wrap_nil();
+            } else {
+                value = array->data[index];
             }
-        case JANET_TUPLE:
-            {
-                const Janet *tuple = janet_unwrap_tuple(ds);
-                int32_t index;
-                if (!janet_checkint(key))
-                    janet_panic("expected integer key");
-                index = janet_unwrap_integer(key);
-                if (index < 0 || index >= janet_tuple_length(tuple)) {
-                    value = janet_wrap_nil();
-                } else {
-                    value = tuple[index];
-                }
-                break;
+            break;
+        }
+        case JANET_TUPLE: {
+            const Janet *tuple = janet_unwrap_tuple(ds);
+            int32_t index;
+            if (!janet_checkint(key))
+                janet_panic("expected integer key");
+            index = janet_unwrap_integer(key);
+            if (index < 0 || index >= janet_tuple_length(tuple)) {
+                value = janet_wrap_nil();
+            } else {
+                value = tuple[index];
             }
-        case JANET_BUFFER:
-            {
-                JanetBuffer *buffer = janet_unwrap_buffer(ds);
-                int32_t index;
-                if (!janet_checkint(key))
-                    janet_panic("expected integer key");
-                index = janet_unwrap_integer(key);
-                if (index < 0 || index >= buffer->count) {
-                    value = janet_wrap_nil();
-                } else {
-                    value = janet_wrap_integer(buffer->data[index]);
-                }
-                break;
+            break;
+        }
+        case JANET_BUFFER: {
+            JanetBuffer *buffer = janet_unwrap_buffer(ds);
+            int32_t index;
+            if (!janet_checkint(key))
+                janet_panic("expected integer key");
+            index = janet_unwrap_integer(key);
+            if (index < 0 || index >= buffer->count) {
+                value = janet_wrap_nil();
+            } else {
+                value = janet_wrap_integer(buffer->data[index]);
             }
+            break;
+        }
         case JANET_STRING:
         case JANET_SYMBOL:
-        case JANET_KEYWORD:
-            {
-                const uint8_t *str = janet_unwrap_string(ds);
-                int32_t index;
-                if (!janet_checkint(key))
-                    janet_panic("expected integer key");
-                index = janet_unwrap_integer(key);
-                if (index < 0 || index >= janet_string_length(str)) {
-                    value = janet_wrap_nil();
-                } else {
-                    value = janet_wrap_integer(str[index]);
-                }
-                break;
+        case JANET_KEYWORD: {
+            const uint8_t *str = janet_unwrap_string(ds);
+            int32_t index;
+            if (!janet_checkint(key))
+                janet_panic("expected integer key");
+            index = janet_unwrap_integer(key);
+            if (index < 0 || index >= janet_string_length(str)) {
+                value = janet_wrap_nil();
+            } else {
+                value = janet_wrap_integer(str[index]);
             }
-    case JANET_ABSTRACT:
-      {
-	JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
-	if (type->get) {
-	  value = (type->get)(janet_unwrap_abstract(ds),key);
-	} else {
-	  janet_panicf("no getter for %T ", JANET_TFLAG_LENGTHABLE, ds);
-	  value = janet_wrap_nil();
-	}
-	break;
-      }
+            break;
+        }
+        case JANET_ABSTRACT: {
+            JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
+            if (type->get) {
+                value = (type->get)(janet_unwrap_abstract(ds), key);
+            } else {
+                janet_panicf("no getter for %T ", JANET_TFLAG_LENGTHABLE, ds);
+                value = janet_wrap_nil();
+            }
+            break;
+        }
     }
     return value;
 }
@@ -278,17 +271,16 @@ Janet janet_getindex(Janet ds, int32_t index) {
         case JANET_STRUCT:
             value = janet_struct_get(janet_unwrap_struct(ds), janet_wrap_integer(index));
             break;
-    case JANET_ABSTRACT:
-      {
-	JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
-	if (type->get) {
-	  value = (type->get)(janet_unwrap_abstract(ds),janet_wrap_integer(index));
-	} else {
-	  janet_panicf("no getter for %T ", JANET_TFLAG_LENGTHABLE, ds);
-	  value = janet_wrap_nil();
-	}
-	break;
-      }
+        case JANET_ABSTRACT: {
+            JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
+            if (type->get) {
+                value = (type->get)(janet_unwrap_abstract(ds), janet_wrap_integer(index));
+            } else {
+                janet_panicf("no getter for %T ", JANET_TFLAG_LENGTHABLE, ds);
+                value = janet_wrap_nil();
+            }
+            break;
+        }
     }
     return value;
 }
@@ -319,46 +311,42 @@ void janet_putindex(Janet ds, int32_t index, Janet value) {
     switch (janet_type(ds)) {
         default:
             janet_panicf("expected %T, got %v",
-                    JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds);
+                         JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds);
             break;
-        case JANET_ARRAY:
-            {
-                JanetArray *array = janet_unwrap_array(ds);
-                if (index >= array->count) {
-                    janet_array_ensure(array, index + 1, 2);
-                    array->count = index + 1;
-                }
-                array->data[index] = value;
-                break;
+        case JANET_ARRAY: {
+            JanetArray *array = janet_unwrap_array(ds);
+            if (index >= array->count) {
+                janet_array_ensure(array, index + 1, 2);
+                array->count = index + 1;
             }
-        case JANET_BUFFER:
-            {
-                JanetBuffer *buffer = janet_unwrap_buffer(ds);
-                if (!janet_checkint(value))
-                    janet_panicf("can only put integers in buffers, got %v", value);
-                if (index >= buffer->count) {
-                    janet_buffer_ensure(buffer, index + 1, 2);
-                    buffer->count = index + 1;
-                }
-                buffer->data[index] = janet_unwrap_integer(value);
-                break;
+            array->data[index] = value;
+            break;
+        }
+        case JANET_BUFFER: {
+            JanetBuffer *buffer = janet_unwrap_buffer(ds);
+            if (!janet_checkint(value))
+                janet_panicf("can only put integers in buffers, got %v", value);
+            if (index >= buffer->count) {
+                janet_buffer_ensure(buffer, index + 1, 2);
+                buffer->count = index + 1;
             }
-        case JANET_TABLE:
-            {
-                JanetTable *table = janet_unwrap_table(ds);
-                janet_table_put(table, janet_wrap_integer(index), value);
-                break;
+            buffer->data[index] = janet_unwrap_integer(value);
+            break;
+        }
+        case JANET_TABLE: {
+            JanetTable *table = janet_unwrap_table(ds);
+            janet_table_put(table, janet_wrap_integer(index), value);
+            break;
+        }
+        case JANET_ABSTRACT: {
+            JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
+            if (type->put) {
+                (type->put)(janet_unwrap_abstract(ds), janet_wrap_integer(index), value);
+            } else {
+                janet_panicf("no setter for %T ", JANET_TFLAG_LENGTHABLE, ds);
             }
-        case JANET_ABSTRACT:
-	  {
-	    JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
-	    if (type->put) {
-	      (type->put)(janet_unwrap_abstract(ds),janet_wrap_integer(index),value);
-	    } else {
-	      janet_panicf("no setter for %T ", JANET_TFLAG_LENGTHABLE, ds);
-	    }
-	    break;
-	  }
+            break;
+        }
     }
 }
 
@@ -366,49 +354,45 @@ void janet_put(Janet ds, Janet key, Janet value) {
     switch (janet_type(ds)) {
         default:
             janet_panicf("expected %T, got %v",
-                    JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds);
+                         JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds);
             break;
-        case JANET_ARRAY:
-            {
-                int32_t index;
-                JanetArray *array = janet_unwrap_array(ds);
-                if (!janet_checkint(key)) janet_panicf("expected integer key, got %v", key);
-                index = janet_unwrap_integer(key);
-                if (index < 0 || index == INT32_MAX) janet_panicf("bad integer key, got %v", key);
-                if (index >= array->count) {
-                    janet_array_setcount(array, index + 1);
-                }
-                array->data[index] = value;
-                break;
+        case JANET_ARRAY: {
+            int32_t index;
+            JanetArray *array = janet_unwrap_array(ds);
+            if (!janet_checkint(key)) janet_panicf("expected integer key, got %v", key);
+            index = janet_unwrap_integer(key);
+            if (index < 0 || index == INT32_MAX) janet_panicf("bad integer key, got %v", key);
+            if (index >= array->count) {
+                janet_array_setcount(array, index + 1);
             }
-        case JANET_BUFFER:
-            {
-                int32_t index;
-                JanetBuffer *buffer = janet_unwrap_buffer(ds);
-                if (!janet_checkint(key)) janet_panicf("expected integer key, got %v", key);
-                index = janet_unwrap_integer(key);
-                if (index < 0 || index == INT32_MAX) janet_panicf("bad integer key, got %v", key);
-                if (!janet_checkint(value))
-                    janet_panicf("can only put integers in buffers, got %v", value);
-                if (index >= buffer->count) {
-                    janet_buffer_setcount(buffer, index + 1);
-                }
-                buffer->data[index] = (uint8_t) (janet_unwrap_integer(value) & 0xFF);
-                break;
+            array->data[index] = value;
+            break;
+        }
+        case JANET_BUFFER: {
+            int32_t index;
+            JanetBuffer *buffer = janet_unwrap_buffer(ds);
+            if (!janet_checkint(key)) janet_panicf("expected integer key, got %v", key);
+            index = janet_unwrap_integer(key);
+            if (index < 0 || index == INT32_MAX) janet_panicf("bad integer key, got %v", key);
+            if (!janet_checkint(value))
+                janet_panicf("can only put integers in buffers, got %v", value);
+            if (index >= buffer->count) {
+                janet_buffer_setcount(buffer, index + 1);
             }
+            buffer->data[index] = (uint8_t)(janet_unwrap_integer(value) & 0xFF);
+            break;
+        }
         case JANET_TABLE:
             janet_table_put(janet_unwrap_table(ds), key, value);
             break;
-        case JANET_ABSTRACT:
-	  {
-	    JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
-	    if (type->put) {
-	      (type->put)(janet_unwrap_abstract(ds),key,value);
-	    } else {
-	      janet_panicf("no setter for %T ", JANET_TFLAG_LENGTHABLE, ds);
-	    }
-	    break;
-	  }
-	  
+        case JANET_ABSTRACT: {
+            JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
+            if (type->put) {
+                (type->put)(janet_unwrap_abstract(ds), key, value);
+            } else {
+                janet_panicf("no setter for %T ", JANET_TFLAG_LENGTHABLE, ds);
+            }
+            break;
+        }
     }
 }

src/core/vector.c

@@ -29,17 +29,17 @@ void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) {
     int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0;
     int32_t min_needed = janet_v_count(v) + increment;
     int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed;
-    int32_t *p = (int32_t *) realloc(v ? janet_v__raw(v) : 0, itemsize * m + sizeof(int32_t)*2);
+    int32_t *p = (int32_t *) realloc(v ? janet_v__raw(v) : 0, itemsize * m + sizeof(int32_t) * 2);
     if (NULL != p) {
         if (!v) p[1] = 0;
         p[0] = m;
         return p + 2;
-   } else {
-       {
-           JANET_OUT_OF_MEMORY;
-       }
-       return (void *) (2 * sizeof(int32_t));
-   }
+    } else {
+        {
+            JANET_OUT_OF_MEMORY;
+        }
+        return (void *)(2 * sizeof(int32_t));
+    }
 }
 
 /* Convert a buffer to normal allocated memory (forget capacity) */
@@ -53,10 +53,10 @@ void *janet_v_flattenmem(void *v, int32_t itemsize) {
         memcpy(p, v, sizen);
         return p;
     } else {
-       {
-           JANET_OUT_OF_MEMORY;
-       }
-       return NULL;
+        {
+            JANET_OUT_OF_MEMORY;
+        }
+        return NULL;
     }
 }
 

src/core/vector.h

@@ -24,7 +24,7 @@
 #define JANET_VECTOR_H_defined
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #endif
 
 /*

src/core/vm.c

@@ -21,7 +21,7 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #include "state.h"
 #include "fiber.h"
 #include "gc.h"
@@ -228,7 +228,8 @@ static Janet call_nonfn(JanetFiber *fiber, Janet callee) {
     int32_t argn = fiber->stacktop - fiber->stackstart;
     Janet ds, key;
     if (argn != 1) janet_panicf("%v called with arity %d, expected 1", callee, argn);
-    if (janet_checktypes(callee, JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY | JANET_TFLAG_ABSTRACT)) {
+    if (janet_checktypes(callee, JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY |
+                         JANET_TFLAG_STRING | JANET_TFLAG_BUFFER | JANET_TFLAG_ABSTRACT)) {
         ds = callee;
         key = fiber->data[fiber->stackstart];
     } else {
@@ -262,8 +263,8 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
      * the breakpoint bit set and we were in the debug state, skip
      * that first breakpoint. */
     uint8_t first_opcode = (status == JANET_STATUS_DEBUG)
-        ? (*pc & 0x7F)
-        : (*pc & 0xFF);
+                           ? (*pc & 0x7F)
+                           : (*pc & 0xFF);
 
     /* Main interpreter loop. Semantically is a switch on
      * (*pc & 0xFF) inside of an infinite loop. */
@@ -282,8 +283,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
     vm_assert_types(stack[A], E);
     vm_pcnext();
 
-    VM_OP(JOP_RETURN)
-    {
+    VM_OP(JOP_RETURN) {
         Janet retval = stack[D];
         int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE;
         janet_fiber_popframe(fiber);
@@ -293,8 +293,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_checkgc_pcnext();
     }
 
-    VM_OP(JOP_RETURN_NIL)
-    {
+    VM_OP(JOP_RETURN_NIL) {
         Janet retval = janet_wrap_nil();
         int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE;
         janet_fiber_popframe(fiber);
@@ -320,37 +319,36 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
     vm_binop(*);
 
     VM_OP(JOP_NUMERIC_LESS_THAN)
-    vm_numcomp(<);
+    vm_numcomp( <);
 
     VM_OP(JOP_NUMERIC_LESS_THAN_EQUAL)
-    vm_numcomp(<=);
+    vm_numcomp( <=);
 
     VM_OP(JOP_NUMERIC_GREATER_THAN)
-    vm_numcomp(>);
+    vm_numcomp( >);
 
     VM_OP(JOP_NUMERIC_GREATER_THAN_EQUAL)
-    vm_numcomp(>=);
+    vm_numcomp( >=);
 
     VM_OP(JOP_NUMERIC_EQUAL)
-    vm_numcomp(==);
+    vm_numcomp( ==);
 
     VM_OP(JOP_DIVIDE_IMMEDIATE)
-    vm_binop_immediate(/);
+    vm_binop_immediate( /);
 
     VM_OP(JOP_DIVIDE)
-    vm_binop(/);
+    vm_binop( /);
 
     VM_OP(JOP_BAND)
     vm_bitop(&);
 
     VM_OP(JOP_BOR)
-    vm_bitop(|);
+    vm_bitop( |);
 
     VM_OP(JOP_BXOR)
     vm_bitop(^);
 
-    VM_OP(JOP_BNOT)
-    {
+    VM_OP(JOP_BNOT) {
         Janet op = stack[E];
         vm_assert_type(op, JANET_NUMBER);
         stack[A] = janet_wrap_integer(~janet_unwrap_integer(op));
@@ -358,22 +356,22 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
     }
 
     VM_OP(JOP_SHIFT_RIGHT_UNSIGNED)
-    vm_bitopu(>>);
+    vm_bitopu( >>);
 
     VM_OP(JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE)
-    vm_bitopu_immediate(>>);
+    vm_bitopu_immediate( >>);
 
     VM_OP(JOP_SHIFT_RIGHT)
-    vm_bitop(>>);
+    vm_bitop( >>);
 
     VM_OP(JOP_SHIFT_RIGHT_IMMEDIATE)
-    vm_bitop_immediate(>>);
+    vm_bitop_immediate( >>);
 
     VM_OP(JOP_SHIFT_LEFT)
-    vm_bitop(<<);
+    vm_bitop( <<);
 
     VM_OP(JOP_SHIFT_LEFT_IMMEDIATE)
-    vm_bitop_immediate(<<);
+    vm_bitop_immediate( <<);
 
     VM_OP(JOP_MOVE_NEAR)
     stack[A] = stack[E];
@@ -447,8 +445,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
     stack[A] = janet_wrap_integer(ES);
     vm_pcnext();
 
-    VM_OP(JOP_LOAD_CONSTANT)
-    {
+    VM_OP(JOP_LOAD_CONSTANT) {
         int32_t cindex = (int32_t)E;
         vm_assert(cindex < func->def->constants_length, "invalid constant");
         stack[A] = func->def->constants[cindex];
@@ -459,8 +456,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
     stack[D] = janet_wrap_function(func);
     vm_pcnext();
 
-    VM_OP(JOP_LOAD_UPVALUE)
-    {
+    VM_OP(JOP_LOAD_UPVALUE) {
         int32_t eindex = B;
         int32_t vindex = C;
         JanetFuncEnv *env;
@@ -477,8 +473,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_pcnext();
     }
 
-    VM_OP(JOP_SET_UPVALUE)
-    {
+    VM_OP(JOP_SET_UPVALUE) {
         int32_t eindex = B;
         int32_t vindex = C;
         JanetFuncEnv *env;
@@ -493,8 +488,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_pcnext();
     }
 
-    VM_OP(JOP_CLOSURE)
-    {
+    VM_OP(JOP_CLOSURE) {
         JanetFuncDef *fd;
         JanetFunction *fn;
         int32_t elen;
@@ -543,8 +537,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
     stack = fiber->data + fiber->frame;
     vm_checkgc_pcnext();
 
-    VM_OP(JOP_PUSH_ARRAY)
-    {
+    VM_OP(JOP_PUSH_ARRAY) {
         const Janet *vals;
         int32_t len;
         if (janet_indexed_view(stack[D], &vals, &len)) {
@@ -556,8 +549,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
     stack = fiber->data + fiber->frame;
     vm_checkgc_pcnext();
 
-    VM_OP(JOP_CALL)
-    {
+    VM_OP(JOP_CALL) {
         Janet callee = stack[E];
         if (fiber->stacktop > fiber->maxstack) {
             vm_throw("stack overflow");
@@ -574,7 +566,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
             if (janet_fiber_funcframe(fiber, func)) {
                 int32_t n = fiber->stacktop - fiber->stackstart;
                 janet_panicf("%v called with %d argument%s, expected %d",
-                        callee, n, n == 1 ? "" : "s", func->def->arity);
+                             callee, n, n == 1 ? "" : "s", func->def->arity);
             }
             stack = fiber->data + fiber->frame;
             pc = func->def->bytecode;
@@ -596,8 +588,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         }
     }
 
-    VM_OP(JOP_TAILCALL)
-    {
+    VM_OP(JOP_TAILCALL) {
         Janet callee = stack[D];
         if (janet_checktype(callee, JANET_KEYWORD)) {
             vm_commit();
@@ -611,7 +602,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
                 janet_stack_frame(fiber->data + fiber->frame)->pc = pc;
                 int32_t n = fiber->stacktop - fiber->stackstart;
                 janet_panicf("%v called with %d argument%s, expected %d",
-                        callee, n, n == 1 ? "" : "s", func->def->arity);
+                             callee, n, n == 1 ? "" : "s", func->def->arity);
             }
             stack = fiber->data + fiber->frame;
             pc = func->def->bytecode;
@@ -637,8 +628,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         }
     }
 
-    VM_OP(JOP_RESUME)
-    {
+    VM_OP(JOP_RESUME) {
         Janet retreg;
         vm_assert_type(stack[B], JANET_FIBER);
         JanetFiber *child = janet_unwrap_fiber(stack[B]);
@@ -651,8 +641,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_checkgc_pcnext();
     }
 
-    VM_OP(JOP_SIGNAL)
-    {
+    VM_OP(JOP_SIGNAL) {
         int32_t s = C;
         if (s > JANET_SIGNAL_USER9) s = JANET_SIGNAL_USER9;
         if (s < 0) s = 0;
@@ -684,8 +673,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
     stack[A] = janet_wrap_integer(janet_length(stack[E]));
     vm_pcnext();
 
-    VM_OP(JOP_MAKE_ARRAY)
-    {
+    VM_OP(JOP_MAKE_ARRAY) {
         int32_t count = fiber->stacktop - fiber->stackstart;
         Janet *mem = fiber->data + fiber->stackstart;
         stack[D] = janet_wrap_array(janet_array_n(mem, count));
@@ -693,8 +681,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_checkgc_pcnext();
     }
 
-    VM_OP(JOP_MAKE_TUPLE)
-    {
+    VM_OP(JOP_MAKE_TUPLE) {
         int32_t count = fiber->stacktop - fiber->stackstart;
         Janet *mem = fiber->data + fiber->stackstart;
         stack[D] = janet_wrap_tuple(janet_tuple_n(mem, count));
@@ -702,8 +689,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_checkgc_pcnext();
     }
 
-    VM_OP(JOP_MAKE_TABLE)
-    {
+    VM_OP(JOP_MAKE_TABLE) {
         int32_t count = fiber->stacktop - fiber->stackstart;
         Janet *mem = fiber->data + fiber->stackstart;
         if (count & 1)
@@ -716,8 +702,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_checkgc_pcnext();
     }
 
-    VM_OP(JOP_MAKE_STRUCT)
-    {
+    VM_OP(JOP_MAKE_STRUCT) {
         int32_t count = fiber->stacktop - fiber->stackstart;
         Janet *mem = fiber->data + fiber->stackstart;
         if (count & 1)
@@ -730,8 +715,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_checkgc_pcnext();
     }
 
-    VM_OP(JOP_MAKE_STRING)
-    {
+    VM_OP(JOP_MAKE_STRING) {
         int32_t count = fiber->stacktop - fiber->stackstart;
         Janet *mem = fiber->data + fiber->stackstart;
         JanetBuffer buffer;
@@ -744,8 +728,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in, JanetFiberStatus status)
         vm_checkgc_pcnext();
     }
 
-    VM_OP(JOP_MAKE_BUFFER)
-    {
+    VM_OP(JOP_MAKE_BUFFER) {
         int32_t count = fiber->stacktop - fiber->stackstart;
         Janet *mem = fiber->data + fiber->stackstart;
         JanetBuffer *buffer = janet_buffer(10 * count);
@@ -783,8 +766,8 @@ Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) {
 
     /* Run vm */
     JanetSignal signal = run_vm(janet_vm_fiber,
-            janet_wrap_nil(),
-            JANET_STATUS_ALIVE);
+                                janet_wrap_nil(),
+                                JANET_STATUS_ALIVE);
 
     /* Teardown */
     janet_vm_return_reg = old_return_reg;
@@ -864,12 +847,17 @@ JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out) {
 }
 
 JanetSignal janet_pcall(
-        JanetFunction *fun,
-        int32_t argc,
-        const Janet *argv,
-        Janet *out,
-        JanetFiber **f) {
-    JanetFiber *fiber = janet_fiber(fun, 64, argc, argv);
+    JanetFunction *fun,
+    int32_t argc,
+    const Janet *argv,
+    Janet *out,
+    JanetFiber **f) {
+    JanetFiber *fiber;
+    if (f && *f) {
+        fiber = janet_fiber_reset(*f, fun, argc, argv);
+    } else {
+        fiber = janet_fiber(fun, 64, argc, argv);
+    }
     if (f) *f = fiber;
     if (!fiber) {
         *out = janet_cstringv("arity mismatch");

src/core/wrap.c

@@ -21,12 +21,15 @@
 */
 
 #ifndef JANET_AMALG
-#include <janet/janet.h>
+#include <janet.h>
 #endif
 
 void *janet_memalloc_empty(int32_t count) {
     int32_t i;
     void *mem = malloc(count * sizeof(JanetKV));
+    if (NULL == mem) {
+        JANET_OUT_OF_MEMORY;
+    }
     JanetKV *mmem = (JanetKV *)mem;
     for (i = 0; i < count; i++) {
         JanetKV *kv = mmem + i;
@@ -122,22 +125,22 @@ Janet janet_wrap_nil() {
 
 Janet janet_wrap_true(void) {
     Janet y;
-    y.type = JANET_TRUE;
-    y.as.u64 = 0;
+    y.type = JANET_BOOLEAN;
+    y.as.u64 = 1;
     return y;
 }
 
 Janet janet_wrap_false(void) {
     Janet y;
-    y.type = JANET_FALSE;
+    y.type = JANET_BOOLEAN;
     y.as.u64 = 0;
     return y;
 }
 
 Janet janet_wrap_boolean(int x) {
     Janet y;
-    y.type = x ? JANET_TRUE : JANET_FALSE;
-    y.as.u64 = 0;
+    y.type = JANET_BOOLEAN;
+    y.as.u64 = !!x;
     return y;
 }
 
@@ -163,6 +166,7 @@ JANET_WRAP_DEFINE(function, JanetFunction *, JANET_FUNCTION, pointer)
 JANET_WRAP_DEFINE(cfunction, JanetCFunction, JANET_CFUNCTION, pointer)
 JANET_WRAP_DEFINE(table, JanetTable *, JANET_TABLE, pointer)
 JANET_WRAP_DEFINE(abstract, void *, JANET_ABSTRACT, pointer)
+JANET_WRAP_DEFINE(pointer, void *, JANET_POINTER, pointer)
 
 #undef JANET_WRAP_DEFINE
 

src/include/janet.h

@@ -29,7 +29,7 @@ extern "C" {
 
 /***** START SECTION CONFIG *****/
 
-#define JANET_VERSION "0.4.0"
+#define JANET_VERSION "0.4.1"
 
 #ifndef JANET_BUILD
 #define JANET_BUILD "local"
@@ -67,7 +67,7 @@ extern "C" {
 /* Check 64-bit vs 32-bit */
 #if ((defined(__x86_64__) || defined(_M_X64)) \
      && (defined(JANET_UNIX) || defined(JANET_WINDOWS))) \
-	|| (defined(_WIN64)) /* Windows 64 bit */ \
+    || (defined(_WIN64)) /* Windows 64 bit */ \
     || (defined(__ia64__) && defined(__LP64__)) /* Itanium in LP64 mode */ \
     || defined(__alpha__) /* DEC Alpha */ \
     || (defined(__sparc__) && defined(__arch64__) || defined (__sparcv9)) /* BE */ \
@@ -123,6 +123,16 @@ extern "C" {
 #define JANET_ASSEMBLER
 #endif
 
+/* Enable or disable the peg module */
+#ifndef JANET_NO_PEG
+#define JANET_PEG
+#endif
+
+/* Enable or disable the typedarray module */
+#ifndef JANET_NO_TYPED_ARRAY
+#define JANET_TYPED_ARRAY
+#endif
+
 /* How to export symbols */
 #ifndef JANET_API
 #ifdef JANET_WINDOWS
@@ -167,7 +177,9 @@ extern "C" {
 /* Define max stack size for stacks before raising a stack overflow error.
  * If this is not defined, fiber stacks can grow without limit (until memory
  * runs out) */
-#define JANET_STACK_MAX 8192
+#ifndef JANET_STACK_MAX
+#define JANET_STACK_MAX 16384
+#endif
 
 /* Use nanboxed values - uses 8 bytes per value instead of 12 or 16.
  * To turn of nanboxing, for debugging purposes or for certain
@@ -199,6 +211,7 @@ extern "C" {
 #include <stdlib.h>
 #include <stdarg.h>
 #include <setjmp.h>
+#include <stddef.h>
 
 /* Names of all of the types */
 extern const char *const janet_type_names[16];
@@ -251,15 +264,23 @@ typedef union Janet Janet;
 typedef struct Janet Janet;
 #endif
 
-/* All of the janet types */
+/* Use type punning for GC objects */
+typedef struct JanetGCObject JanetGCObject;
+
+/* All of the primary Janet GCed types */
 typedef struct JanetFunction JanetFunction;
 typedef struct JanetArray JanetArray;
 typedef struct JanetBuffer JanetBuffer;
 typedef struct JanetTable JanetTable;
 typedef struct JanetFiber JanetFiber;
 
+/* Prefixed Janet types */
+typedef struct JanetTupleHead JanetTupleHead;
+typedef struct JanetStructHead JanetStructHead;
+typedef struct JanetStringHead JanetStringHead;
+typedef struct JanetAbstractHead JanetAbstractHead;
+
 /* Other structs */
-typedef struct JanetAbstractHeader JanetAbstractHeader;
 typedef struct JanetFuncDef JanetFuncDef;
 typedef struct JanetFuncEnv JanetFuncEnv;
 typedef struct JanetKV JanetKV;
@@ -272,14 +293,13 @@ typedef struct JanetView JanetView;
 typedef struct JanetByteView JanetByteView;
 typedef struct JanetDictView JanetDictView;
 typedef struct JanetRange JanetRange;
-typedef Janet (*JanetCFunction)(int32_t argc, Janet *argv);
+typedef Janet(*JanetCFunction)(int32_t argc, Janet *argv);
 
 /* Basic types for all Janet Values */
 typedef enum JanetType {
     JANET_NUMBER,
     JANET_NIL,
-    JANET_FALSE,
-    JANET_TRUE,
+    JANET_BOOLEAN,
     JANET_FIBER,
     JANET_STRING,
     JANET_SYMBOL,
@@ -291,15 +311,15 @@ typedef enum JanetType {
     JANET_BUFFER,
     JANET_FUNCTION,
     JANET_CFUNCTION,
-    JANET_ABSTRACT
+    JANET_ABSTRACT,
+    JANET_POINTER
 } JanetType;
 
-#define JANET_COUNT_TYPES (JANET_ABSTRACT + 1)
+#define JANET_COUNT_TYPES (JANET_POINTER + 1)
 
 /* Type flags */
 #define JANET_TFLAG_NIL (1 << JANET_NIL)
-#define JANET_TFLAG_FALSE (1 << JANET_FALSE)
-#define JANET_TFLAG_TRUE (1 << JANET_TRUE)
+#define JANET_TFLAG_BOOLEAN (1 << JANET_BOOLEAN)
 #define JANET_TFLAG_FIBER (1 << JANET_FIBER)
 #define JANET_TFLAG_NUMBER (1 << JANET_NUMBER)
 #define JANET_TFLAG_STRING (1 << JANET_STRING)
@@ -313,9 +333,9 @@ typedef enum JanetType {
 #define JANET_TFLAG_FUNCTION (1 << JANET_FUNCTION)
 #define JANET_TFLAG_CFUNCTION (1 << JANET_CFUNCTION)
 #define JANET_TFLAG_ABSTRACT (1 << JANET_ABSTRACT)
+#define JANET_TFLAG_POINTER (1 << JANET_POINTER)
 
 /* Some abstractions */
-#define JANET_TFLAG_BOOLEAN (JANET_TFLAG_TRUE | JANET_TFLAG_FALSE)
 #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD)
 #define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE)
 #define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT)
@@ -382,7 +402,8 @@ JANET_API Janet janet_nanbox_from_double(double d);
 JANET_API Janet janet_nanbox_from_bits(uint64_t bits);
 
 #define janet_truthy(x) \
-    (!(janet_checktype((x), JANET_NIL) || janet_checktype((x), JANET_FALSE)))
+    (!janet_checktype((x), JANET_NIL) && \
+     (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1)))
 
 #define janet_nanbox_from_payload(t, p) \
     janet_nanbox_from_bits(janet_nanbox_tag(t) | (p))
@@ -395,14 +416,13 @@ JANET_API Janet janet_nanbox_from_bits(uint64_t bits);
 
 /* Wrap the simple types */
 #define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1)
-#define janet_wrap_true() janet_nanbox_from_payload(JANET_TRUE, 1)
-#define janet_wrap_false() janet_nanbox_from_payload(JANET_FALSE, 1)
-#define janet_wrap_boolean(b) janet_nanbox_from_payload((b) ? JANET_TRUE : JANET_FALSE, 1)
+#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1)
+#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0)
+#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b))
 #define janet_wrap_number(r) janet_nanbox_from_double(r)
 
 /* Unwrap the simple types */
-#define janet_unwrap_boolean(x) \
-    (janet_checktype(x, JANET_TRUE))
+#define janet_unwrap_boolean(x) ((x).u64 & 0x1)
 #define janet_unwrap_number(x) ((x).number)
 
 /* Wrap the pointer types */
@@ -418,6 +438,7 @@ JANET_API Janet janet_nanbox_from_bits(uint64_t bits);
 #define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT)
 #define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION)
 #define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION)
+#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER)
 
 /* Unwrap the pointer types */
 #define janet_unwrap_struct(x) ((const JanetKV *)janet_nanbox_to_pointer(x))
@@ -464,16 +485,17 @@ union Janet {
 #define janet_checktype(x, t) ((t) == JANET_NUMBER \
         ? (x).tagged.type >= JANET_DOUBLE_OFFSET \
         : (x).tagged.type == (t))
-#define janet_truthy(x) ((x).tagged.type != JANET_NIL && (x).tagged.type != JANET_FALSE)
+#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);
 
 #define janet_wrap_nil() janet_nanbox32_from_tagi(JANET_NIL, 0)
-#define janet_wrap_true() janet_nanbox32_from_tagi(JANET_TRUE, 0)
-#define janet_wrap_false() janet_nanbox32_from_tagi(JANET_FALSE, 0)
-#define janet_wrap_boolean(b) janet_nanbox32_from_tagi((b) ? JANET_TRUE : JANET_FALSE, 0)
+#define janet_wrap_true() janet_nanbox32_from_tagi(JANET_BOOLEAN, 1)
+#define janet_wrap_false() janet_nanbox32_from_tagi(JANET_BOOLEAN, 0)
+#define janet_wrap_boolean(b) janet_nanbox32_from_tagi(JANET_BOOLEAN, !!(b))
 
 /* Wrap the pointer types */
 #define janet_wrap_struct(s) janet_nanbox32_from_tagp(JANET_STRUCT, (void *)(s))
@@ -488,6 +510,7 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 #define janet_wrap_abstract(s) janet_nanbox32_from_tagp(JANET_ABSTRACT, (void *)(s))
 #define janet_wrap_function(s) janet_nanbox32_from_tagp(JANET_FUNCTION, (void *)(s))
 #define janet_wrap_cfunction(s) janet_nanbox32_from_tagp(JANET_CFUNCTION, (void *)(s))
+#define janet_wrap_pointer(s) janet_nanbox32_from_tagp(JANET_POINTER, (void *)(s))
 
 #define janet_unwrap_struct(x) ((const JanetKV *)(x).tagged.payload.pointer)
 #define janet_unwrap_tuple(x) ((const Janet *)(x).tagged.payload.pointer)
@@ -502,7 +525,7 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 #define janet_unwrap_pointer(x) ((x).tagged.payload.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.type == JANET_TRUE)
+#define janet_unwrap_boolean(x) ((x).tagged.payload.integer)
 JANET_API double janet_unwrap_number(Janet x);
 
 #else
@@ -523,7 +546,7 @@ struct Janet {
 #define janet_type(x) ((x).type)
 #define janet_checktype(x, t) ((x).type == (t))
 #define janet_truthy(x) \
-    ((x).type != JANET_NIL && (x).type != JANET_FALSE)
+    ((x).type != JANET_NIL && ((x).type != JANET_BOOLEAN || ((x).as.integer & 0x1)))
 
 #define janet_unwrap_struct(x) ((const JanetKV *)(x).as.pointer)
 #define janet_unwrap_tuple(x) ((const Janet *)(x).as.pointer)
@@ -538,7 +561,7 @@ struct Janet {
 #define janet_unwrap_pointer(x) ((x).as.pointer)
 #define janet_unwrap_function(x) ((JanetFunction *)(x).as.pointer)
 #define janet_unwrap_cfunction(x) ((JanetCFunction)(x).as.pointer)
-#define janet_unwrap_boolean(x) ((x).type == JANET_TRUE)
+#define janet_unwrap_boolean(x) ((x).as.u64 & 0x1)
 #define janet_unwrap_number(x) ((x).as.number)
 
 JANET_API Janet janet_wrap_nil(void);
@@ -558,12 +581,14 @@ 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
 
 JANET_API int janet_checkint(Janet x);
 JANET_API int janet_checkint64(Janet x);
+JANET_API int janet_checksize(Janet x);
 #define janet_checkintrange(x) ((x) == (int32_t)(x))
 #define janet_checkint64range(x) ((x) == (int64_t)(x))
 #define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x))
@@ -571,6 +596,14 @@ JANET_API int janet_checkint64(Janet x);
 
 #define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps))
 
+/* GC Object type pun. The lower 16 bits of flags are reserved for the garbage collector,
+ * but the upper 16 can be used per type for custom flags. The current collector is a linked
+ * list of blocks, which is naive but works. */
+struct JanetGCObject {
+    int32_t flags;
+    JanetGCObject *next;
+};
+
 /* Fiber signal masks. */
 #define JANET_FIBER_MASK_ERROR 2
 #define JANET_FIBER_MASK_DEBUG 4
@@ -596,14 +629,15 @@ JANET_API int janet_checkint64(Janet x);
 /* A lightweight green thread in janet. Does not correspond to
  * operating system threads. */
 struct JanetFiber {
-    Janet *data;
-    JanetFiber *child; /* Keep linked list of fibers for restarting pending fibers */
+    JanetGCObject gc; /* GC Object stuff */
+    int32_t flags; /* More flags */
     int32_t frame; /* Index of the stack frame */
     int32_t stackstart; /* Beginning of next args */
     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 */
-    int32_t flags; /* Various flags */
+    Janet *data;
+    JanetFiber *child; /* Keep linked list of fibers for restarting pending fibers */
 };
 
 /* Mark if a stack frame is a tail call for debugging */
@@ -626,25 +660,28 @@ struct JanetStackFrame {
 
 /* A dynamic array type. */
 struct JanetArray {
-    Janet *data;
+    JanetGCObject gc;
     int32_t count;
     int32_t capacity;
+    Janet *data;
 };
 
 /* A byte buffer type. Used as a mutable string or string builder. */
 struct JanetBuffer {
-    uint8_t *data;
+    JanetGCObject gc;
     int32_t count;
     int32_t capacity;
+    uint8_t *data;
 };
 
 /* A mutable associative data type. Backed by a hashtable. */
 struct JanetTable {
-    JanetKV *data;
-    JanetTable *proto;
+    JanetGCObject gc;
     int32_t count;
     int32_t capacity;
     int32_t deleted;
+    JanetKV *data;
+    JanetTable *proto;
 };
 
 /* A key value pair in a struct or table */
@@ -653,10 +690,44 @@ struct JanetKV {
     Janet value;
 };
 
+/* Prefix for a tuple */
+struct JanetTupleHead {
+    JanetGCObject gc;
+    int32_t length;
+    int32_t hash;
+    int32_t sm_start;
+    int32_t sm_end;
+    const Janet data[];
+};
+
+/* Prefix for a struct */
+struct JanetStructHead {
+    JanetGCObject gc;
+    int32_t length;
+    int32_t hash;
+    int32_t capacity;
+    const JanetKV data[];
+};
+
+/* Prefix for a string */
+struct JanetStringHead {
+    JanetGCObject gc;
+    int32_t length;
+    int32_t hash;
+    const uint8_t data[];
+};
+
+/* Prefix for an abstract value */
+struct JanetAbstractHead {
+    JanetGCObject gc;
+    const JanetAbstractType *type;
+    size_t size;
+    long long data[]; /* Use long long to ensure most general alignment */
+};
+
 /* Some function definition flags */
 #define JANET_FUNCDEF_FLAG_VARARG 0x10000
 #define JANET_FUNCDEF_FLAG_NEEDSENV 0x20000
-#define JANET_FUNCDEF_FLAG_FIXARITY 0x40000
 #define JANET_FUNCDEF_FLAG_HASNAME 0x80000
 #define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000
 #define JANET_FUNCDEF_FLAG_HASDEFS 0x200000
@@ -672,6 +743,7 @@ struct JanetSourceMapping {
 
 /* A function definition. Contains information needed to instantiate closures. */
 struct JanetFuncDef {
+    JanetGCObject gc;
     int32_t *environments; /* Which environments to capture from parent. */
     Janet *constants;
     JanetFuncDef **defs;
@@ -685,6 +757,8 @@ struct JanetFuncDef {
     int32_t flags;
     int32_t slotcount; /* The amount of stack space required for the function */
     int32_t arity; /* Not including varargs */
+    int32_t min_arity; /* Including varargs */
+    int32_t max_arity; /* Including varargs */
     int32_t constants_length;
     int32_t bytecode_length;
     int32_t environments_length;
@@ -693,6 +767,7 @@ struct JanetFuncDef {
 
 /* A function environment */
 struct JanetFuncEnv {
+    JanetGCObject gc;
     union {
         JanetFiber *fiber;
         Janet *values;
@@ -704,6 +779,7 @@ struct JanetFuncEnv {
 
 /* A function */
 struct JanetFunction {
+    JanetGCObject gc;
     JanetFuncDef *def;
     JanetFuncEnv *envs[];
 };
@@ -714,12 +790,13 @@ typedef struct JanetParser JanetParser;
 enum JanetParserStatus {
     JANET_PARSE_ROOT,
     JANET_PARSE_ERROR,
-    JANET_PARSE_PENDING
+    JANET_PARSE_PENDING,
+    JANET_PARSE_DEAD
 };
 
 /* A janet parser */
 struct JanetParser {
-    Janet* args;
+    Janet *args;
     const char *error;
     JanetParseState *states;
     uint8_t *buf;
@@ -732,21 +809,25 @@ struct JanetParser {
     size_t offset;
     size_t pending;
     int lookback;
+    int flag;
 };
 
+typedef struct {
+    void *m_state;  /* void* to not expose MarshalState ?*/
+    void *u_state;
+    int flags;
+    const uint8_t *data;
+} JanetMarshalContext;
+
 /* Defines an abstract type */
 struct JanetAbstractType {
     const char *name;
     int (*gc)(void *data, size_t len);
     int (*gcmark)(void *data, size_t len);
-    Janet (*get)(void *data, Janet key);
+    Janet(*get)(void *data, Janet key);
     void (*put)(void *data, Janet key, Janet value);
-};
-
-/* Contains information about abstract types */
-struct JanetAbstractHeader {
-    const JanetAbstractType *type;
-    size_t size;
+    void (*marshal)(void *p, JanetMarshalContext *ctx);
+    void (*unmarshal)(void *p, JanetMarshalContext *ctx);
 };
 
 struct JanetReg {
@@ -897,12 +978,12 @@ extern enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT];
 /* Parsing */
 JANET_API void janet_parser_init(JanetParser *parser);
 JANET_API void janet_parser_deinit(JanetParser *parser);
-JANET_API int janet_parser_consume(JanetParser *parser, uint8_t c);
+JANET_API void janet_parser_consume(JanetParser *parser, uint8_t c);
 JANET_API enum JanetParserStatus janet_parser_status(JanetParser *parser);
 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 JanetParser *janet_check_parser(Janet x);
+JANET_API void janet_parser_eof(JanetParser *parser);
 #define janet_parser_has_more(P) ((P)->pending)
 
 /* Assembly */
@@ -938,7 +1019,7 @@ struct JanetCompileResult {
 JANET_API JanetCompileResult janet_compile(Janet source, JanetTable *env, const uint8_t *where);
 
 /* Get the default environment for janet */
-JANET_API JanetTable *janet_core_env(void);
+JANET_API JanetTable *janet_core_env(JanetTable *replacements);
 
 JANET_API int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char *sourcePath, Janet *out);
 JANET_API int janet_dostring(JanetTable *env, const char *str, const char *sourcePath, Janet *out);
@@ -950,8 +1031,8 @@ JANET_API int janet_scan_number(const uint8_t *str, int32_t len, double *out);
 JANET_API void janet_debug_break(JanetFuncDef *def, int32_t pc);
 JANET_API void janet_debug_unbreak(JanetFuncDef *def, int32_t pc);
 JANET_API void janet_debug_find(
-        JanetFuncDef **def_out, int32_t *pc_out,
-        const uint8_t *source, int32_t offset);
+    JanetFuncDef **def_out, int32_t *pc_out,
+    const uint8_t *source, int32_t offset);
 
 /* Array functions */
 JANET_API JanetArray *janet_array(int32_t capacity);
@@ -980,11 +1061,15 @@ JANET_API void janet_buffer_push_u32(JanetBuffer *buffer, uint32_t x);
 JANET_API void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x);
 
 /* Tuple */
-#define janet_tuple_raw(t) ((int32_t *)(t) - 4)
-#define janet_tuple_length(t) (janet_tuple_raw(t)[0])
-#define janet_tuple_hash(t) ((janet_tuple_raw(t)[1]))
-#define janet_tuple_sm_start(t) ((janet_tuple_raw(t)[2]))
-#define janet_tuple_sm_end(t) ((janet_tuple_raw(t)[3]))
+
+#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000
+
+#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data)))
+#define janet_tuple_length(t) (janet_tuple_head(t)->length)
+#define janet_tuple_hash(t) (janet_tuple_head(t)->hash)
+#define janet_tuple_sm_start(t) (janet_tuple_head(t)->sm_start)
+#define janet_tuple_sm_end(t) (janet_tuple_head(t)->sm_end)
+#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags)
 JANET_API Janet *janet_tuple_begin(int32_t length);
 JANET_API const Janet *janet_tuple_end(Janet *tuple);
 JANET_API const Janet *janet_tuple_n(const Janet *values, int32_t n);
@@ -992,9 +1077,9 @@ JANET_API int janet_tuple_equal(const Janet *lhs, const Janet *rhs);
 JANET_API int janet_tuple_compare(const Janet *lhs, const Janet *rhs);
 
 /* String/Symbol functions */
-#define janet_string_raw(s) ((int32_t *)(s) - 2)
-#define janet_string_length(s) (janet_string_raw(s)[0])
-#define janet_string_hash(s) ((janet_string_raw(s)[1]))
+#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data)))
+#define janet_string_length(s) (janet_string_head(s)->length)
+#define janet_string_hash(s) (janet_string_head(s)->hash)
 JANET_API uint8_t *janet_string_begin(int32_t length);
 JANET_API const uint8_t *janet_string_end(uint8_t *str);
 JANET_API const uint8_t *janet_string(const uint8_t *buf, int32_t len);
@@ -1024,11 +1109,10 @@ JANET_API const uint8_t *janet_symbol_gen(void);
 #define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr))
 
 /* Structs */
-#define janet_struct_raw(t) ((int32_t *)(t) - 4)
-#define janet_struct_length(t) (janet_struct_raw(t)[0])
-#define janet_struct_capacity(t) (janet_struct_raw(t)[1])
-#define janet_struct_hash(t) (janet_struct_raw(t)[2])
-/* Do something with the 4th header slot - flags? */
+#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data)))
+#define janet_struct_length(t) (janet_struct_head(t)->length)
+#define janet_struct_capacity(t) (janet_struct_head(t)->capacity)
+#define janet_struct_hash(t) (janet_struct_head(t)->hash)
 JANET_API JanetKV *janet_struct_begin(int32_t count);
 JANET_API void janet_struct_put(JanetKV *st, Janet key, Janet value);
 JANET_API const JanetKV *janet_struct_end(JanetKV *st);
@@ -1064,7 +1148,7 @@ 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) ((JanetAbstractHeader *)(u) - 1)
+#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)
 JANET_API void *janet_abstract(const JanetAbstractType *type, size_t size);
@@ -1074,19 +1158,17 @@ typedef void (*JanetModule)(JanetTable *);
 JANET_API JanetModule janet_native(const char *name, const uint8_t **error);
 
 /* Marshaling */
-JANET_API int janet_marshal(
-        JanetBuffer *buf,
-        Janet x,
-        Janet *errval,
-        JanetTable *rreg,
-        int flags);
-JANET_API int janet_unmarshal(
-        const uint8_t *bytes,
-        size_t len,
-        int flags,
-        Janet *out,
-        JanetTable *reg,
-        const uint8_t **next);
+JANET_API void janet_marshal(
+    JanetBuffer *buf,
+    Janet x,
+    JanetTable *rreg,
+    int flags);
+JANET_API Janet janet_unmarshal(
+    const uint8_t *bytes,
+    size_t len,
+    int flags,
+    JanetTable *reg,
+    const uint8_t **next);
 JANET_API JanetTable *janet_env_lookup(JanetTable *env);
 
 /* GC */
@@ -1165,9 +1247,11 @@ JANET_API JanetFiber *janet_getfiber(const Janet *argv, int32_t n);
 JANET_API JanetFunction *janet_getfunction(const Janet *argv, int32_t n);
 JANET_API JanetCFunction janet_getcfunction(const Janet *argv, int32_t n);
 JANET_API int janet_getboolean(const Janet *argv, int32_t n);
+JANET_API void *janet_getpointer(const Janet *argv, int32_t n);
 
 JANET_API int32_t janet_getinteger(const Janet *argv, int32_t n);
 JANET_API int64_t janet_getinteger64(const Janet *argv, int32_t n);
+JANET_API size_t janet_getsize(const Janet *argv, int32_t n);
 JANET_API JanetView janet_getindexed(const Janet *argv, int32_t n);
 JANET_API JanetByteView janet_getbytes(const Janet *argv, int32_t n);
 JANET_API JanetDictView janet_getdictionary(const Janet *argv, int32_t n);
@@ -1176,6 +1260,61 @@ 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 FILE *janet_getfile(const Janet *argv, int32_t n, int *flags);
+
+/* Marshal API */
+JANET_API void janet_marshal_int(JanetMarshalContext *ctx, int32_t value);
+JANET_API void janet_marshal_size(JanetMarshalContext *ctx, size_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);
+
+JANET_API void janet_unmarshal_int(JanetMarshalContext *ctx, int32_t *i);
+JANET_API void janet_unmarshal_size(JanetMarshalContext *ctx, size_t *i);
+JANET_API void janet_unmarshal_byte(JanetMarshalContext *ctx, uint8_t *b);
+JANET_API void janet_unmarshal_bytes(JanetMarshalContext *ctx, uint8_t *dest, size_t len);
+JANET_API void janet_unmarshal_janet(JanetMarshalContext *ctx, Janet *out);
+
+JANET_API void janet_register_abstract_type(const JanetAbstractType *at);
+JANET_API const JanetAbstractType *janet_get_abstract_type(Janet key);
+
+#ifdef JANET_TYPED_ARRAY
+
+typedef enum {
+    JANET_TARRAY_TYPE_uint8,
+    JANET_TARRAY_TYPE_int8,
+    JANET_TARRAY_TYPE_uint16,
+    JANET_TARRAY_TYPE_int16,
+    JANET_TARRAY_TYPE_uint32,
+    JANET_TARRAY_TYPE_int32,
+    JANET_TARRAY_TYPE_float32,
+    JANET_TARRAY_TYPE_float64,
+    JANET_TARRAY_TYPE_any,
+} JanetTArrayType;
+
+typedef struct {
+    uint8_t *data;
+    size_t size;
+    int32_t flags;
+} JanetTArrayBuffer;
+
+typedef struct {
+    JanetTArrayBuffer *buffer;
+    void *data; /* pointer inside buffer->data */
+    size_t size;
+    size_t stride;
+    JanetTArrayType type;
+} JanetTArrayView;
+
+JANET_API JanetTArrayBuffer *janet_tarray_buffer(size_t size);
+JANET_API JanetTArrayView *janet_tarray_view(JanetTArrayType type, size_t size, size_t stride, size_t offset, JanetTArrayBuffer *buffer);
+JANET_API int janet_is_tarray_view(Janet x, JanetTArrayType type);
+JANET_API size_t janet_tarray_type_size(JanetTArrayType type);
+JANET_API JanetTArrayBuffer *janet_gettarray_buffer(const Janet *argv, int32_t n);
+JANET_API JanetTArrayView *janet_gettarray_view(const Janet *argv, int32_t n, JanetTArrayType type);
+
+#endif
+
 /***** END SECTION MAIN *****/
 
 #ifdef __cplusplus

src/mainclient/init.janet

@@ -9,21 +9,25 @@
   (var *handleopts* true)
   (var *exit-on-error* true)
 
+  (if-let [jp (os/getenv "JANET_PATH")] (set module/*syspath* jp))
+
   # Flag handlers
   (def handlers :private
     {"h" (fn [&]
            (print "usage: " (get process/args 0) " [options] script args...")
            (print
              `Options are:
-  -h Show this help
-  -v Print the version string
-  -s Use raw stdin instead of getline like functionality
-  -e Execute a string of janet
-  -r Enter the repl after running all scripts
-  -p Keep on executing if there is a top level error (persistent)
-  -q Hide prompt, logo, and repl output (quiet)
-  -l Execute code in a file before running the main script
-  -- Stop handling options`)
+  -h : Show this help
+  -v : Print the version string
+  -s : Use raw stdin instead of getline like functionality
+  -e code : Execute a string of janet
+  -r : Enter the repl after running all scripts
+  -p : Keep on executing if there is a top level error (persistent)
+  -q : Hide prompt, logo, and repl output (quiet)
+  -m syspath : Set system path for loading global modules
+  -c source output : Compile janet source code into an image
+  -l path : Execute code in a file before running the main script
+  -- : Stop handling options`)
            (os/exit 0)
            1)
      "v" (fn [&] (print janet/version "-" janet/build) (os/exit 0) 1)
@@ -31,6 +35,12 @@
      "r" (fn [&] (set *should-repl* true) 1)
      "p" (fn [&] (set *exit-on-error* false) 1)
      "q" (fn [&] (set *quiet* true) 1)
+     "m" (fn [i &] (set module/*syspath* (get process/args (+ i 1))) 2)
+     "c" (fn [i &]
+           (def e (require (get process/args (+ i 1))))
+           (spit (get process/args (+ i 2)) (make-image e))
+           (set *no-file* false)
+           3)
      "-" (fn [&] (set *handleopts* false) 1)
      "l" (fn [i &]
            (import* *env* (get process/args (+ i 1))

src/mainclient/line.c

@@ -144,8 +144,8 @@ static int curpos() {
     int cols, rows;
     unsigned int i = 0;
     if (write(STDOUT_FILENO, "\x1b[6n", 4) != 4) return -1;
-    while (i < sizeof(buf)-1) {
-        if (read(STDIN_FILENO, buf+i, 1) != 1) break;
+    while (i < sizeof(buf) - 1) {
+        if (read(STDIN_FILENO, buf + i, 1) != 1) break;
         if (buf[i] == 'R') break;
         i++;
     }
@@ -166,7 +166,7 @@ static int getcols() {
         if (cols == -1) goto failed;
         if (cols > start) {
             char seq[32];
-            snprintf(seq, 32, "\x1b[%dD", cols-start);
+            snprintf(seq, 32, "\x1b[%dD", cols - start);
             if (write(STDOUT_FILENO, seq, strlen(seq)) == -1) {}
         }
         return cols;
@@ -178,7 +178,7 @@ failed:
 }
 
 static void clear() {
-    if (write(STDOUT_FILENO,"\x1b[H\x1b[2J",7) <= 0) {}
+    if (write(STDOUT_FILENO, "\x1b[H\x1b[2J", 7) <= 0) {}
 }
 
 static void refresh() {
@@ -206,7 +206,7 @@ static void refresh() {
     /* Erase to right */
     janet_buffer_push_cstring(&b, "\x1b[0K");
     /* Move cursor to original position. */
-    snprintf(seq, 64,"\r\x1b[%dC", (int)(_pos + plen));
+    snprintf(seq, 64, "\r\x1b[%dC", (int)(_pos + plen));
     janet_buffer_push_cstring(&b, seq);
     if (write(STDOUT_FILENO, b.data, b.count) == -1) {}
     janet_buffer_deinit(&b);
@@ -321,103 +321,103 @@ static int line() {
         nread = read(STDIN_FILENO, &c, 1);
         if (nread <= 0) return -1;
 
-        switch(c) {
-        default:
-            if (insert(c)) return -1;
-            break;
-        case 9:     /* tab */
-            if (insert(' ')) return -1;
-            if (insert(' ')) return -1;
-            break;
-        case 13:    /* enter */
-            return 0;
-        case 3:     /* ctrl-c */
-            errno = EAGAIN;
-            return -1;
-        case 127:   /* backspace */
-        case 8:     /* ctrl-h */
-            kbackspace();
-            break;
-        case 4:     /* ctrl-d, eof */
-            return -1;
-        case 2:     /* ctrl-b */
-            kleft();
-            break;
-        case 6:     /* ctrl-f */
-            kright();
-            break;
-        case 21:
-            buf[0] = '\0';
-            pos = len = 0;
-            refresh();
-            break;
-        case 26: /* ctrl-z */
-            norawmode();
-            kill(getpid(), SIGSTOP);
-            rawmode();
-            refresh();
-            break;
-        case 12:
-            clear();
-            refresh();
-            break;
-        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(STDIN_FILENO, seq + 1, 1) == -1) break;
-            if (seq[0] == '[') {
-                if (seq[1] >= '0' && seq[1] <= '9') {
-                    /* Extended escape, read additional byte. */
-                    if (read(STDIN_FILENO, seq + 2, 1) == -1) break;
-                    if (seq[2] == '~') {
-                        switch(seq[1]) {
-                        default:
-                            break;
+        switch (c) {
+            default:
+                if (insert(c)) return -1;
+                break;
+            case 9:     /* tab */
+                if (insert(' ')) return -1;
+                if (insert(' ')) return -1;
+                break;
+            case 13:    /* enter */
+                return 0;
+            case 3:     /* ctrl-c */
+                errno = EAGAIN;
+                return -1;
+            case 127:   /* backspace */
+            case 8:     /* ctrl-h */
+                kbackspace();
+                break;
+            case 4:     /* ctrl-d, eof */
+                return -1;
+            case 2:     /* ctrl-b */
+                kleft();
+                break;
+            case 6:     /* ctrl-f */
+                kright();
+                break;
+            case 21:
+                buf[0] = '\0';
+                pos = len = 0;
+                refresh();
+                break;
+            case 26: /* ctrl-z */
+                norawmode();
+                kill(getpid(), SIGSTOP);
+                rawmode();
+                refresh();
+                break;
+            case 12:
+                clear();
+                refresh();
+                break;
+            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(STDIN_FILENO, seq + 1, 1) == -1) break;
+                if (seq[0] == '[') {
+                    if (seq[1] >= '0' && seq[1] <= '9') {
+                        /* Extended escape, read additional byte. */
+                        if (read(STDIN_FILENO, seq + 2, 1) == -1) break;
+                        if (seq[2] == '~') {
+                            switch (seq[1]) {
+                                default:
+                                    break;
+                            }
+                        }
+                    } else {
+                        switch (seq[1]) {
+                            default:
+                                break;
+                            case 'A':
+                                historymove(1);
+                                break;
+                            case 'B':
+                                historymove(-1);
+                                break;
+                            case 'C': /* Right */
+                                kright();
+                                break;
+                            case 'D': /* Left */
+                                kleft();
+                                break;
+                            case 'H':
+                                pos = 0;
+                                refresh();
+                                break;
+                            case 'F':
+                                pos = len;
+                                refresh();
+                                break;
                         }
                     }
-                } else {
+                } else if (seq[0] == 'O') {
                     switch (seq[1]) {
-                    default:
-                        break;
-                    case 'A':
-                        historymove(1);
-                        break;
-                    case 'B':
-                        historymove(-1);
-                        break;
-                    case 'C': /* Right */
-                        kright();
-                        break;
-                    case 'D': /* Left */
-                        kleft();
-                        break;
-                    case 'H':
-                        pos = 0;
-                        refresh();
-                        break;
-                    case 'F':
-                        pos = len;
-                        refresh();
-                        break;
+                        default:
+                            break;
+                        case 'H':
+                            pos = 0;
+                            refresh();
+                            break;
+                        case 'F':
+                            pos = len;
+                            refresh();
+                            break;
                     }
                 }
-            } else if (seq[0] == 'O') {
-                switch (seq[1]) {
-                default:
-                    break;
-                case 'H':
-                    pos = 0;
-                    refresh();
-                    break;
-                case 'F':
-                    pos = len;
-                    refresh();
-                    break;
-                }
-            }
-            break;
+                break;
         }
     }
     return 0;

src/mainclient/line.h

@@ -23,7 +23,7 @@
 #ifndef JANET_LINE_H_defined
 #define JANET_LINE_H_defined
 
-#include <janet/janet.h>
+#include <janet.h>
 
 void janet_line_init();
 void janet_line_deinit();

src/mainclient/main.c

@@ -20,7 +20,7 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include "line.h"
 
 extern const unsigned char *janet_gen_init;
@@ -33,7 +33,14 @@ int main(int argc, char **argv) {
 
     /* Set up VM */
     janet_init();
-    env = janet_core_env();
+
+    /* Replace original getline with new line getter */
+    JanetTable *replacements = janet_table(0);
+    janet_table_put(replacements, janet_csymbolv("getline"), janet_wrap_cfunction(janet_line_getter));
+    janet_line_init();
+
+    /* Get core env */
+    env = janet_core_env(replacements);
 
     /* Create args tuple */
     args = janet_array(argc);
@@ -41,11 +48,6 @@ int main(int argc, char **argv) {
         janet_array_push(args, janet_cstringv(argv[i]));
     janet_def(env, "process/args", janet_wrap_array(args), "Command line arguments.");
 
-    /* Expose line getter */
-    janet_def(env, "getline", janet_wrap_cfunction(janet_line_getter), NULL);
-    janet_register("getline", janet_line_getter);
-    janet_line_init();
-
     /* Run startup script */
     status = janet_dobytes(env, janet_gen_init, janet_gen_init_size, "init.janet", NULL);
 

src/webclient/main.c

@@ -20,7 +20,7 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <emscripten.h>
 
 extern const unsigned char *janet_gen_webinit;
@@ -70,7 +70,7 @@ void repl_init(void) {
     janet_init();
     janet_register("repl-yield", repl_yield);
     janet_register("js", cfun_js);
-    env = janet_core_env();
+    env = janet_core_env(NULL);
 
     janet_def(env, "repl-yield", janet_wrap_cfunction(repl_yield), NULL);
     janet_def(env, "js", janet_wrap_cfunction(cfun_js), NULL);

test/helper.janet

@@ -26,6 +26,11 @@
   (def errsym (keyword (gensym)))
   ~(assert (= ,errsym (try (do ,;forms) ([_] ,errsym))) ,msg))
 
+(defmacro assert-no-error
+  [msg & forms]
+  (def errsym (keyword (gensym)))
+  ~(assert (not= ,errsym (try (do ,;forms) ([_] ,errsym))) ,msg))
+
 (defn start-suite [x]
  (set suite-num x)
  (print "\nRunning test suite " x " tests...\n  "))

test/install/.gitignore

@@ -0,0 +1 @@
+/build

test/install/test.janet

@@ -0,0 +1,11 @@
+(import cook)
+
+(cook/make-native
+    :name "testmod"
+    :source @["testmod.c"])
+
+(import build/testmod :as testmod)
+
+(if (not= 5 (testmod/get5)) (error "testmod/get5 failed"))
+
+(print "OK!")

test/install/testmod.c

@@ -0,0 +1,40 @@
+/*
+* Copyright (c) 2019 Calvin Rose and 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.
+*/
+
+/* A very simple native module */
+
+#include <janet.h>
+
+static Janet cfun_get_five(int32_t argc, Janet *argv) {
+    (void) argv;
+    janet_fixarity(argc, 0);
+    return janet_wrap_number(5.0);
+}
+
+static const JanetReg array_cfuns[] = {
+    {"get5", cfun_get_five, NULL},
+    {NULL, NULL, NULL}
+};
+
+JANET_MODULE_ENTRY(JanetTable *env) {
+    janet_cfuns(env, NULL, array_cfuns);
+}

test/suite1.janet

@@ -97,8 +97,8 @@
 # of the triangle to the leaves of the triangle.
 
 (defn myfold [xs ys]
-  (let [xs1 (tuple/prepend xs 0)
-        xs2 (tuple/append xs 0)
+  (let [xs1 [;xs 0]
+        xs2 [0 ;xs]
         m1 (map + xs1 ys)
         m2 (map + xs2 ys)]
     (map max m1 m2)))
@@ -154,6 +154,10 @@
 (testmarsh 1 "marshal small integers")
 (testmarsh -1 "marshal integers (-1)")
 (testmarsh 199 "marshal small integers (199)")
+(testmarsh 5000 "marshal medium integers (5000)")
+(testmarsh -5000 "marshal small integers (-5000)")
+(testmarsh 10000 "marshal large integers (10000)")
+(testmarsh -10000 "marshal large integers (-10000)")
 (testmarsh 1.0 "marshal double")
 (testmarsh "doctordolittle" "marshal string")
 (testmarsh :chickenshwarma "marshal symbol")
@@ -171,10 +175,14 @@
 (testmarsh (fiber/new (fn [] (yield 1) 2)) "marshal simple fiber 1")
 (testmarsh (fiber/new (fn [&] (yield 1) 2)) "marshal simple fiber 2")
 
+(def strct {:a @[nil]})
+(put (strct :a) 0 strct)
+(testmarsh strct "cyclic struct")
+
 # 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 (tuple/prepend manydefs 'do) *env*))
+(def f (compile ['do ;manydefs] *env*))
 (assert (= (f) (* 10000 3 5 7 9)) "long function compilation")
 
 # Some higher order functions and macros
@@ -208,6 +216,9 @@
 (def xs (apply tuple (seq [x :range [0 10] :when (even? x)] (tuple (/ x 2) x))))
 (assert (= xs '((0 0) (1 2) (2 4) (3 6) (4 8))) "seq macro 1")
 
+(def xs (apply tuple (seq [x :down [8 -2] :when (even? x)] (tuple (/ x 2) x))))
+(assert (= xs '((4 8) (3 6) (2 4) (1 2) (0 0))) "seq macro 2")
+
 # Some testing for not=
 (assert (not= 1 1 0) "not= 1")
 (assert (not= 0 1 1) "not= 2")

test/suite3.janet

@@ -351,4 +351,12 @@
 (def t (put @{} :hi 1))
 (assert (deep= t @{:hi 1}) "regression #24")
 
+# Tuple types
+
+(assert (= (tuple/type '(1 2 3)) :parens) "normal tuple")
+(assert (= (tuple/type [1 2 3]) :parens) "normal tuple 1")
+(assert (= (tuple/type '[1 2 3]) :brackets) "bracketed tuple 2")
+(assert (= (tuple/type (-> '(1 2 3) marshal unmarshal)) :parens) "normal tuple marshalled/unmarshalled")
+(assert (= (tuple/type (-> '[1 2 3] marshal unmarshal)) :brackets) "normal tuple marshalled/unmarshalled")
+
 (end-suite)

test/suite4.janet

@@ -0,0 +1,72 @@
+# Copyright (c) 2019 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
+# 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 test/helper :prefix "" :exit true)
+(start-suite 4)
+# some tests for string/format and buffer/format
+
+(assert (= (string (buffer/format @"" "pi = %6.3f" math/pi)) "pi =  3.142") "%6.3f")
+(assert (= (string (buffer/format @"" "pi = %+6.3f" math/pi)) "pi = +3.142") "%6.3f")
+(assert (= (string (buffer/format @"" "pi = %40.20g" math/pi)) "pi =                     3.141592653589793116") "%6.3f")
+
+(assert (= (string (buffer/format @"" "🐼 = %6.3f" math/pi)) "🐼 =  3.142") "UTF-8")
+(assert (= (string (buffer/format @"" "π = %.8g" math/pi)) "π = 3.1415927") "π")
+(assert (= (string (buffer/format @"" "\xCF\x80 = %.8g" math/pi)) "\xCF\x80 = 3.1415927") "\xCF\x80")
+
+(assert (= (string/format "pi = %6.3f" math/pi) "pi =  3.142") "%6.3f")
+(assert (= (string/format "pi = %+6.3f" math/pi) "pi = +3.142") "%6.3f")
+(assert (= (string/format "pi = %40.20g" math/pi) "pi =                     3.141592653589793116") "%6.3f")
+
+(assert (= (string/format "🐼 = %6.3f" math/pi) "🐼 =  3.142") "UTF-8")
+(assert (= (string/format "π = %.8g" math/pi) "π = 3.1415927") "π")
+(assert (= (string/format "\xCF\x80 = %.8g" math/pi) "\xCF\x80 = 3.1415927") "\xCF\x80")
+
+# Range
+(assert (deep= (range 10) @[0 1 2 3 4 5 6 7 8 9]) "range 1 argument")
+(assert (deep= (range 5 10) @[5 6 7 8 9]) "range 2 arguments")
+(assert (deep= (range 5 10 2) @[5 7 9]) "range 3 arguments")
+
+# More marshalling code
+
+(defn check-image
+  "Run a marshaling test using the make-image and load-image functions."
+  [x msg]
+  (assert-no-error msg (load-image (make-image x))))
+
+(check-image (fn [] (fn [] 1)) "marshal nested functions")
+(check-image (fiber/new (fn [] (fn [] 1))) "marshal nested functions in fiber")
+(check-image (fiber/new (fn [] (fiber/new (fn [] 1)))) "marshal nested fibers")
+
+(def issue-53-x 
+  (fiber/new 
+    (fn [] 
+      (var y (fiber/new (fn [] (print "1") (yield) (print "2")))))))
+
+(check-image issue-53-x "issue 53 regression")
+
+# Bracket tuple issue
+
+(def do 3)
+(assert (= [3 1 2 3] [do 1 2 3]) "bracket tuples are never special forms")
+(assert (= ~(,defn 1 2 3) [defn 1 2 3]) "bracket tuples are never macros")
+(assert (= ~(,+ 1 2 3) [+ 1 2 3]) "bracket tuples are never function calls")
+
+(end-suite)
+

test/suite5.janet

@@ -0,0 +1,91 @@
+# Copyright (c) 2019 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 test/helper :prefix "" :exit true)
+(start-suite 5)
+
+# some tests typed array
+
+(defn inspect-tarray
+  [x]
+  (def a @[])
+  (for i 0 (tarray/length x) (array/push a (x i)))
+  (pp a))
+
+(assert-no-error
+ "create some typed arrays"
+ (do
+   (def a (tarray/new :float64 10))
+   (def b (tarray/new :float64 5 2 0 a))
+   (def c (tarray/new :uint32 20))))
+
+(assert-no-error
+ "create some typed arrays from a buffer"
+ (do
+   (def buf (tarray/buffer (+ 64 (* (+ 1 (* (- 10 1) 2)) 8))))
+   (def b (tarray/new :float64 10 2 64 buf))))
+
+(def a (tarray/new :float64 10))
+(def b (tarray/new :float64 5 2 0 a))
+
+(assert-no-error
+ "fill tarray"
+ (for i 0 (tarray/length a)
+      (set (a i) i)))
+
+(assert (= (tarray/buffer a) (tarray/buffer b)) "tarray views pointing same buffer")
+(assert (= (a 2) (b 1) ) "tarray views pointing same buffer")
+(assert (= ((tarray/slice b) 3) (b 3) (a 6) 6) "tarray slice")
+(assert (= ((tarray/slice b 1) 2) (b 3) (a 6) 6) "tarray slice")
+
+(assert (= ((unmarshal (marshal b)) 3) (b 3)) "marshal")
+
+# Array remove
+
+(assert (deep= (array/remove @[1 2 3 4 5] 2) @[1 2 4 5]) "array/remove 1")
+(assert (deep= (array/remove @[1 2 3 4 5] 2 2) @[1 2 5]) "array/remove 2")
+(assert (deep= (array/remove @[1 2 3 4 5] 2 200) @[1 2]) "array/remove 3")
+(assert (deep= (array/remove @[1 2 3 4 5] -3 200) @[1 2 3]) "array/remove 4")
+
+# Break
+
+(var summation 0)
+(for i 0 10
+  (+= summation i)
+  (if (= i 7) (break)))
+(assert (= summation 28) "break 1")
+
+(assert (= nil ((fn [] (break) 4))) "break 2")
+
+# Break with value
+
+# Shouldn't error out
+(assert-no-error "break 3" (for i 0 10 (if (> i 8) (break i))))
+(assert-no-error "break 4" ((fn [i] (if (> i 8) (break i))) 100))
+
+# drop-until
+
+(assert (deep= (drop-until pos? @[]) @[]) "drop-until 1")
+(assert (deep= (drop-until pos? @[1 2 3]) @[1 2 3]) "drop-until 2")
+(assert (deep= (drop-until pos? @[-1 -2 -3]) @[]) "drop-until 3")
+(assert (deep= (drop-until pos? @[-1 -2 3]) @[3]) "drop-until 4")
+(assert (deep= (drop-until pos? @[-1 1 -2]) @[1 -2]) "drop-until 5")
+
+(end-suite)

tools/amalg.janet

@@ -51,6 +51,7 @@
     "src/core/symcache.c"
     "src/core/table.c"
     "src/core/tuple.c"
+    "src/core/typedarray.c"
     "src/core/util.c"
     "src/core/value.c"
     "src/core/vector.c"
@@ -72,5 +73,4 @@
 (each s sources (dofile s))
 
 # Relies on these files being built
-(dofile "build/core.gen.c")
 (dofile "build/core_image.c")

tools/bars.janet

@@ -47,7 +47,7 @@
     :error (error (parser/error p)))
 
   # Make ast from forms
-  (def ast ~(fn [params &] (default params @{}) (,buffer ;forms)))
+  (def ast ~(fn [&opt params] (default params @{}) (,buffer ,;forms)))
 
   (def ctor (compile ast *env* source))
   (if-not (function? ctor)

tools/cook.janet

@@ -3,6 +3,7 @@
 
 # Windows is the OS outlier
 (def- is-win (= (os/which) :windows))
+(def- is-mac (= (os/which) :macos))
 (def- sep (if is-win "\\" "/"))
 (def- objext (if is-win ".obj" ".o"))
 (def- modext (if is-win ".dll" ".so"))
@@ -93,8 +94,16 @@
 # Defaults
 (def OPTIMIZE 2)
 (def CC (if is-win "cl" "cc"))
-(def LD (if is-win "link" (string CC " -shared")))
-(def CFLAGS (string (if is-win "/O" "-std=c99 -Wall -Wextra -fpic -O") OPTIMIZE))
+(def LD (if is-win 
+          "link" 
+          (string CC 
+                  " -shared" 
+                  (if is-mac " -undefined dynamic_lookup" ""))))
+(def CFLAGS (string
+              (if is-win "/I" "-I")
+              module/*syspath*
+              (if is-win " /O" " -std=c99 -Wall -Wextra -fpic -O")
+              OPTIMIZE))
 
 (defn- compile-c
   "Compile a C file into an object file."

tools/gendoc.janet

@@ -1,7 +1,5 @@
 # Generate documentation
 
-# TODO - make tool reusable
-
 (def- prelude
 ```
 <!doctype html>
@@ -57,14 +55,29 @@
       (buffer/push-byte buf byte)))
   buf)
 
+(def- months '("January" "February" "March" "April" "May" "June" "July" "August" "September"
+                        "October" "November" "December"))
+(defn nice-date
+  "Get the current date nicely formatted"
+  []
+  (let [date (os/date)
+        M (months (date :month))
+        D (+ (date :month-day) 1)
+        Y (date :year)
+        HH (date :hours)
+        MM (date :minutes)
+        SS (date :seconds)]
+    (string/format "%s %d, %d at %.2d:%.2d:%.2d"
+                   M D Y HH MM SS)))
+
 (defn- make-title
   "Generate title"
   []
   (string "<h1>Janet Core API</h1>"
           "<p>Version " janet/version  "-" janet/build "</p>"
           "<p>Generated "
-          (string/number (os/time) :f 0 20)
-          " seconds after epoch</p>"
+          (nice-date)
+          "</p>"
           "<hr>"))
 
 (defn- emit-item

tools/highlight.janet

@@ -13,6 +13,7 @@
                'def true
                'splice true
                'set true
+               'break true
                'unquote true
                'quasiquote true
                'quote true
@@ -37,13 +38,13 @@
     (def should-color (or (specials sym) (core-env sym)))
     (paint (if should-color :coresym :symbol) text))
 
-  ~{:ws (set " \t\r\f\n\0")
+  ~{:ws (set " \t\r\f\n\v\0")
     :readermac (set "';~,")
     :symchars (+ (range "09" "AZ" "az" "\x80\xFF") (set "!$%&*+-./:<?=>@^_|"))
     :token (some :symchars)
     :hex (range "09" "af" "AF")
-    :escape (* "\\" (+ (set "ntrzf0\"\\e") 
-                       (* "x" :hex :hex) 
+    :escape (* "\\" (+ (set "ntrvzf0\"\\e")
+                       (* "x" :hex :hex)
                        (error (constant "bad hex escape"))))
 
     :comment ,(<-c :comment ~(* "#" (any (if-not (+ "\n" -1) 1))))

tools/symcharsgen.c

@@ -29,23 +29,23 @@ static int is_symbol_char_gen(uint8_t c) {
     if (c >= 'A' && c <= 'Z') return 1;
     if (c >= '0' && c <= '9') return 1;
     return (c == '!' ||
-        c == '$' ||
-        c == '%' ||
-        c == '&' ||
-        c == '*' ||
-        c == '+' ||
-        c == '-' ||
-        c == '.' ||
-        c == '/' ||
-        c == ':' ||
-        c == '<' ||
-        c == '?' ||
-        c == '=' ||
-        c == '>' ||
-        c == '@' ||
-        c == '^' ||
-        c == '_' ||
-        c == '|');
+            c == '$' ||
+            c == '%' ||
+            c == '&' ||
+            c == '*' ||
+            c == '+' ||
+            c == '-' ||
+            c == '.' ||
+            c == '/' ||
+            c == ':' ||
+            c == '<' ||
+            c == '?' ||
+            c == '=' ||
+            c == '>' ||
+            c == '@' ||
+            c == '^' ||
+            c == '_' ||
+            c == '|');
 }
 
 int main() {

tools/tm_lang_gen.janet

@@ -8,331 +8,331 @@
 <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-	<key>fileTypes</key>
-	<array>
-		<string>janet</string>
-	</array>
-	<key>foldingStartMarker</key>
-	<string>\{</string>
-	<key>foldingStopMarker</key>
-	<string>\}</string>
-	<key>foldingStartMarker</key>
-	<string>\[</string>
-	<key>foldingStopMarker</key>
-	<string>\]</string>
-	<key>foldingStartMarker</key>
-	<string>\(</string>
-	<key>foldingStopMarker</key>
-	<string>\)</string>
-	<key>keyEquivalent</key>
-	<string>^~L</string>
-	<key>name</key>
-	<string>Janet</string>
-	<key>patterns</key>
-	<array>
-		<dict>
-			<key>include</key>
-			<string>#all</string>
-		</dict>
+  <key>fileTypes</key>
+  <array>
+    <string>janet</string>
+  </array>
+  <key>foldingStartMarker</key>
+  <string>\{</string>
+  <key>foldingStopMarker</key>
+  <string>\}</string>
+  <key>foldingStartMarker</key>
+  <string>\[</string>
+  <key>foldingStopMarker</key>
+  <string>\]</string>
+  <key>foldingStartMarker</key>
+  <string>\(</string>
+  <key>foldingStopMarker</key>
+  <string>\)</string>
+  <key>keyEquivalent</key>
+  <string>^~L</string>
+  <key>name</key>
+  <string>Janet</string>
+  <key>patterns</key>
+  <array>
+    <dict>
+      <key>include</key>
+      <string>#all</string>
+    </dict>
     </array>
-	<key>repository</key>
-	<dict>
-		<key>all</key>
-		<dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#comment</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#parens</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#brackets</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#braces</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#readermac</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#string</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#longstring</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#literal</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#corelib</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#r-number</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#dec-number</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#hex-number</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#keysym</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#symbol</string>
-				</dict>
-			</array>
-		</dict>
-		<key>comment</key>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.comment.janet</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>(#).*$</string>
-			<key>name</key>
-			<string>comment.line.janet</string>
-		</dict>
-		<key>braces</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?{)</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.braces.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(})</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.braces.end.janet</string>
-				</dict>
-			</dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#all</string>
-				</dict>
-			</array>
-		</dict>
-		<key>brackets</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?\[)</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.brackets.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(\])</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.brackets.end.janet</string>
-				</dict>
-			</dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#all</string>
-				</dict>
-			</array>
-		</dict>
-		<key>parens</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?\()</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.parens.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(\))</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.parens.end.janet</string>
-				</dict>
-			</dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#all</string>
-				</dict>
-			</array>
-		</dict>
-		<key>readermac</key>
-		<dict>
-			<key>match</key>
-			<string>[\'\~\;\,]</string>
-			<key>name</key>
-			<string>punctuation.other.janet</string>
-		</dict>
-		<!-- string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]) token match here (?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string -->
-		<key>literal</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])(true|false|nil)(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>constant.language.janet</string>
-		</dict>
-		<key>corelib</key>
-		<dict>
-			<key>match</key>
+  <key>repository</key>
+  <dict>
+    <key>all</key>
+    <dict>
+      <key>patterns</key>
+      <array>
+        <dict>
+          <key>include</key>
+          <string>#comment</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#parens</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#brackets</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#braces</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#readermac</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#string</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#longstring</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#literal</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#corelib</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#r-number</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#dec-number</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#hex-number</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#keysym</string>
+        </dict>
+        <dict>
+          <key>include</key>
+          <string>#symbol</string>
+        </dict>
+      </array>
+    </dict>
+    <key>comment</key>
+    <dict>
+      <key>captures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.comment.janet</string>
+        </dict>
+      </dict>
+      <key>match</key>
+      <string>(#).*$</string>
+      <key>name</key>
+      <string>comment.line.janet</string>
+    </dict>
+    <key>braces</key>
+    <dict>
+      <key>begin</key>
+      <string>(@?{)</string>
+      <key>captures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.braces.begin.janet</string>
+        </dict>
+      </dict>
+      <key>end</key>
+      <string>(})</string>
+      <key>captures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.braces.end.janet</string>
+        </dict>
+      </dict>
+      <key>patterns</key>
+      <array>
+        <dict>
+          <key>include</key>
+          <string>#all</string>
+        </dict>
+      </array>
+    </dict>
+    <key>brackets</key>
+    <dict>
+      <key>begin</key>
+      <string>(@?\[)</string>
+      <key>captures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.brackets.begin.janet</string>
+        </dict>
+      </dict>
+      <key>end</key>
+      <string>(\])</string>
+      <key>captures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.brackets.end.janet</string>
+        </dict>
+      </dict>
+      <key>patterns</key>
+      <array>
+        <dict>
+          <key>include</key>
+          <string>#all</string>
+        </dict>
+      </array>
+    </dict>
+    <key>parens</key>
+    <dict>
+      <key>begin</key>
+      <string>(@?\()</string>
+      <key>captures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.parens.begin.janet</string>
+        </dict>
+      </dict>
+      <key>end</key>
+      <string>(\))</string>
+      <key>captures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.parens.end.janet</string>
+        </dict>
+      </dict>
+      <key>patterns</key>
+      <array>
+        <dict>
+          <key>include</key>
+          <string>#all</string>
+        </dict>
+      </array>
+    </dict>
+    <key>readermac</key>
+    <dict>
+      <key>match</key>
+      <string>[\'\~\;\,]</string>
+      <key>name</key>
+      <string>punctuation.other.janet</string>
+    </dict>
+    <!-- string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]) token match here (?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string -->
+    <key>literal</key>
+    <dict>
+      <key>match</key>
+      <string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])(true|false|nil)(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
+      <key>name</key>
+      <string>constant.language.janet</string>
+    </dict>
+    <key>corelib</key>
+    <dict>
+      <key>match</key>
             <string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])(%ALLSYMBOLS%)(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>keyword.control.janet</string>
-		</dict>
-		<key>keysym</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]):[\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]*</string>
-			<key>name</key>
-			<string>constant.keyword.janet</string>
-		</dict>
-		<key>symbol</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[\.a-zA-Z_\-=!@\$%^&amp;?|\\/&lt;&gt;*][\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]*</string>
-			<key>name</key>
-			<string>variable.other.janet</string>
-		</dict>
-		<key>hex-number</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?0x([_\da-fA-F]+|[_\da-fA-F]+\.[_\da-fA-F]*|\.[_\da-fA-F]+)(&amp;[+-]?[\da-fA-F]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>constant.numeric.hex.janet</string>
-		</dict>
-		<key>dec-number</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?([_\d]+|[_\d]+\.[_\d]*|\.[_\d]+)([eE&amp;][+-]?[\d]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>constant.numeric.decimal.janet</string>
-		</dict>
-		<key>r-number</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?\d\d?r([_\w]+|[_\w]+\.[_\w]*|\.[_\w]+)(&amp;[+-]?[\w]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>constant.numeric.decimal.janet</string>
-		</dict>
-		<key>string</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?")</string>
-			<key>beginCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(")</string>
-			<key>endCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.end.janet</string>
-				</dict>
-			</dict>
-			<key>name</key>
-			<string>string.quoted.double.janet</string>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>match</key>
-					<string>(\\[ne0zft"\\']|\\x[0-9a-fA-F][0-9a-fA-f])</string>
-					<key>name</key>
-					<string>constant.character.escape.janet</string>
-				</dict>
-			</array>
-		</dict>
-		<key>longstring</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?)(`+)</string>
-			<key>beginCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.janet</string>
-				</dict>
-				<key>2</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>\2</string>
-			<key>endCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.end.janet</string>
-				</dict>
-			</dict>
-			<key>name</key>
-			<string>string.quoted.triple.janet</string>
-		</dict>
-		<key>nomatch</key>
-		<dict>
-			<key>match</key>
-			<string>\S+</string>
-			<key>name</key>
-			<string>invalid.illegal.janet</string>
-		</dict>
-	</dict>
+      <key>name</key>
+      <string>keyword.control.janet</string>
+    </dict>
+    <key>keysym</key>
+    <dict>
+      <key>match</key>
+      <string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]):[\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]*</string>
+      <key>name</key>
+      <string>constant.keyword.janet</string>
+    </dict>
+    <key>symbol</key>
+    <dict>
+      <key>match</key>
+      <string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[\.a-zA-Z_\-=!@\$%^&amp;?|\\/&lt;&gt;*][\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]*</string>
+      <key>name</key>
+      <string>variable.other.janet</string>
+    </dict>
+    <key>hex-number</key>
+    <dict>
+      <key>match</key>
+      <string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?0x([_\da-fA-F]+|[_\da-fA-F]+\.[_\da-fA-F]*|\.[_\da-fA-F]+)(&amp;[+-]?[\da-fA-F]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
+      <key>name</key>
+      <string>constant.numeric.hex.janet</string>
+    </dict>
+    <key>dec-number</key>
+    <dict>
+      <key>match</key>
+      <string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?([_\d]+|[_\d]+\.[_\d]*|\.[_\d]+)([eE&amp;][+-]?[\d]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
+      <key>name</key>
+      <string>constant.numeric.decimal.janet</string>
+    </dict>
+    <key>r-number</key>
+    <dict>
+      <key>match</key>
+      <string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?\d\d?r([_\w]+|[_\w]+\.[_\w]*|\.[_\w]+)(&amp;[+-]?[\w]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
+      <key>name</key>
+      <string>constant.numeric.decimal.janet</string>
+    </dict>
+    <key>string</key>
+    <dict>
+      <key>begin</key>
+      <string>(@?")</string>
+      <key>beginCaptures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.string.begin.janet</string>
+        </dict>
+      </dict>
+      <key>end</key>
+      <string>(")</string>
+      <key>endCaptures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.string.end.janet</string>
+        </dict>
+      </dict>
+      <key>name</key>
+      <string>string.quoted.double.janet</string>
+      <key>patterns</key>
+      <array>
+        <dict>
+          <key>match</key>
+          <string>(\\[nevr0zft"\\']|\\x[0-9a-fA-F][0-9a-fA-f])</string>
+          <key>name</key>
+          <string>constant.character.escape.janet</string>
+        </dict>
+      </array>
+    </dict>
+    <key>longstring</key>
+    <dict>
+      <key>begin</key>
+      <string>(@?)(`+)</string>
+      <key>beginCaptures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.string.begin.janet</string>
+        </dict>
+        <key>2</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.string.begin.janet</string>
+        </dict>
+      </dict>
+      <key>end</key>
+      <string>\2</string>
+      <key>endCaptures</key>
+      <dict>
+        <key>1</key>
+        <dict>
+          <key>name</key>
+          <string>punctuation.definition.string.end.janet</string>
+        </dict>
+      </dict>
+      <key>name</key>
+      <string>string.quoted.triple.janet</string>
+    </dict>
+    <key>nomatch</key>
+    <dict>
+      <key>match</key>
+      <string>\S+</string>
+      <key>name</key>
+      <string>invalid.illegal.janet</string>
+    </dict>
+  </dict>
     <key>scopeName</key>
     <string>source.janet</string>
     <key>uuid</key>
@@ -344,7 +344,8 @@
 # Now we generate the bindings in the language.
 
 (def- specials
-  @["def"
+  @["break"
+    "def"
     "do"
     "var"
     "set"

tools/xxd.c

@@ -33,72 +33,72 @@
 
 int main(int argc, const char **argv) {
 
-	static const char hex[] = "0123456789ABCDEF";
-	char buf[BUFSIZE];
-	size_t bytesRead = 0;
-	int32_t totalRead = 0;
-	int lineIndex = 0;
-	int line = 0;
+    static const char hex[] = "0123456789ABCDEF";
+    char buf[BUFSIZE];
+    size_t bytesRead = 0;
+    int32_t totalRead = 0;
+    int lineIndex = 0;
+    int line = 0;
 
-	if (argc != 4) {
-		fprintf(stderr, "Usage: %s infile outfile symbol\n", argv[0]);
-		return 1;
-	}
+    if (argc != 4) {
+        fprintf(stderr, "Usage: %s infile outfile symbol\n", argv[0]);
+        return 1;
+    }
 
-	/* Open the files */
-	FILE *in = fopen(argv[1], "rb");
-	FILE *out = fopen(argv[2], "wb");
+    /* Open the files */
+    FILE *in = fopen(argv[1], "rb");
+    FILE *out = fopen(argv[2], "wb");
 
-	/* Check if files open successfully */
-	if (in == NULL) {
-		fprintf(stderr, "Could not open input file %s\n", argv[1]);
-		return 1;
-	} else if (out == NULL) {
-		fprintf(stderr, "Could not open output file %s\n", argv[2]);
-		return 1;
-	}
+    /* Check if files open successfully */
+    if (in == NULL) {
+        fprintf(stderr, "Could not open input file %s\n", argv[1]);
+        return 1;
+    } else if (out == NULL) {
+        fprintf(stderr, "Could not open output file %s\n", argv[2]);
+        return 1;
+    }
 
-	/* Write the header */
-	fprintf(out, "/* Auto generated - DO NOT EDIT */\n\n#include <stdint.h>\n\n");
-	fprintf(out, "static const unsigned char bytes_%s[] = {", argv[3]);
+    /* Write the header */
+    fprintf(out, "/* Auto generated - DO NOT EDIT */\n\n#include <stdint.h>\n\n");
+    fprintf(out, "static const unsigned char bytes_%s[] = {", argv[3]);
 
-	/* Read in chunks from buffer */
-	while ((bytesRead = fread(buf, 1, sizeof(buf), in)) > 0) {
-		size_t i;
-		totalRead += bytesRead;
-		for (i = 0; i < bytesRead; ++i) {
-			int byte = ((uint8_t *)buf) [i];
+    /* Read in chunks from buffer */
+    while ((bytesRead = fread(buf, 1, sizeof(buf), in)) > 0) {
+        size_t i;
+        totalRead += bytesRead;
+        for (i = 0; i < bytesRead; ++i) {
+            int byte = ((uint8_t *)buf) [i];
 
-			/* Write the byte */
-			if (lineIndex++ == 0) {
-				if (line++)
-					fputc(',', out);
-				fputs("\n\t", out);
-			} else {
-				fputs(", ", out);
-			}
-			fputs("0x", out);
-			fputc(hex[byte >> 4], out);
-			fputc(hex[byte & 0xF], out);
+            /* Write the byte */
+            if (lineIndex++ == 0) {
+                if (line++)
+                    fputc(',', out);
+                fputs("\n    ", out);
+            } else {
+                fputs(", ", out);
+            }
+            fputs("0x", out);
+            fputc(hex[byte >> 4], out);
+            fputc(hex[byte & 0xF], out);
 
-			/* Make line index wrap */
-			if (lineIndex >= PERLINE)
-				lineIndex = 0;
+            /* Make line index wrap */
+            if (lineIndex >= PERLINE)
+                lineIndex = 0;
 
-		}
-  	}
+        }
+    }
 
-  	/* Write the tail */
-	fputs("\n};\n\n", out);
+    /* Write the tail */
+    fputs("\n};\n\n", out);
 
-	fprintf(out, "const unsigned char *%s = bytes_%s;\n\n", argv[3], argv[3]);
+    fprintf(out, "const unsigned char *%s = bytes_%s;\n\n", argv[3], argv[3]);
 
     /* Write chunk size */
-	fprintf(out, "int32_t %s_size = %d;\n", argv[3], totalRead);
+    fprintf(out, "int32_t %s_size = %d;\n", argv[3], totalRead);
 
-	/* Close the file handles */
-	fclose(in);
-	fclose(out);
+    /* Close the file handles */
+    fclose(in);
+    fclose(out);
 
-	return 0;
+    return 0;
 }