Work on making range take non-integer values.

musl doesn't obey this behavior.

.builds/openbsd.yml

@@ -1,4 +1,4 @@
-image: openbsd/latest
+image: openbsd/7.4
 sources:
 - https://git.sr.ht/~bakpakin/janet
 packages:

.github/cosmo/build

@@ -0,0 +1,38 @@
+#!/bin/sh
+set -eux
+
+COSMO_DIR="/sc/cosmocc"
+
+# build x86_64
+X86_64_CC="/sc/cosmocc/bin/x86_64-unknown-cosmo-cc"
+X86_64_AR="/sc/cosmocc/bin/x86_64-unknown-cosmo-ar"
+mkdir -p /sc/cosmocc/x86_64
+make -j CC="$X86_64_CC" AR="$X86_64_AR" HAS_SHARED=0 JANET_NO_AMALG=1
+cp build/janet /sc/cosmocc/x86_64/janet
+make clean
+
+# build aarch64
+AARCH64_CC="/sc/cosmocc/bin/aarch64-unknown-cosmo-cc"
+AARCH64_AR="/sc/cosmocc/bin/aarch64-unknown-cosmo-ar"
+mkdir -p /sc/cosmocc/aarch64
+make -j CC="$AARCH64_CC" AR="$AARCH64_AR" HAS_SHARED=0 JANET_NO_AMALG=1
+cp build/janet /sc/cosmocc/aarch64/janet
+make clean
+
+# fat binary
+apefat () {
+    OUTPUT="$1"
+    OLDNAME_X86_64="$(basename -- "$2")"
+    OLDNAME_AARCH64="$(basename -- "$3")"
+    TARG_FOLD="$(dirname "$OUTPUT")"
+    "$COSMO_DIR/bin/apelink" -l "$COSMO_DIR/bin/ape-x86_64.elf" \
+        -l "$COSMO_DIR/bin/ape-aarch64.elf" \
+        -M "$COSMO_DIR/bin/ape-m1.c" \
+        -o "$OUTPUT" \
+        "$2" \
+        "$3"
+    cp "$2" "$TARG_FOLD/$OLDNAME_X86_64.x86_64"
+    cp "$3" "$TARG_FOLD/$OLDNAME_AARCH64.aarch64"
+}
+
+apefat /sc/cosmocc/janet.com /sc/cosmocc/x86_64/janet /sc/cosmocc/aarch64/janet

.github/cosmo/setup

@@ -0,0 +1,21 @@
+#!/bin/sh
+set -e
+
+sudo apt update
+sudo apt-get install -y ca-certificates libssl-dev\
+    qemu qemu-utils qemu-user-static\
+    texinfo groff\
+    cmake ninja-build bison zip\
+    pkg-config build-essential autoconf re2c
+
+# download cosmocc
+cd /sc
+wget https://github.com/jart/cosmopolitan/releases/download/3.3.3/cosmocc-3.3.3.zip
+mkdir -p cosmocc
+cd cosmocc
+unzip ../cosmocc-3.3.3.zip
+
+# register
+cd /sc/cosmocc
+sudo cp ./bin/ape-x86_64.elf /usr/bin/ape
+sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"

.github/workflows/release.yml

@@ -60,3 +60,30 @@ jobs:
             ./dist/*.zip
             ./*.zip
             ./*.msi
+
+  release-cosmo:
+    permissions:
+      contents: write  # for softprops/action-gh-release to create GitHub release
+    name: Build release binaries for Cosmo
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@master
+      - name: create build folder
+        run: |
+          sudo mkdir -p /sc
+          sudo chmod -R 0777 /sc
+      - name: setup Cosmopolitan Libc
+        run: bash ./.github/cosmo/setup
+      - name: Set the version
+        run: echo "version=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV
+      - name: Set the platform
+        run: echo "platform=cosmo" >> $GITHUB_ENV
+      - name: build Janet APE binary
+        run: bash ./.github/cosmo/build
+      - name: push binary to github
+        uses: softprops/action-gh-release@v1
+        with:
+          draft: true
+          files: |
+            /sc/cosmocc/janet.com

.github/workflows/test.yml

@@ -73,7 +73,7 @@ jobs:
       - name: Compile the project
         run: make clean && make CC=x86_64-w64-mingw32-gcc LD=x86_64-w64-mingw32-gcc UNAME=MINGW RUN=wine
       - name: Test the project
-        run: make test UNAME=MINGW RUN=wine
+        run: make test UNAME=MINGW RUN=wine VERBOSE=1
 
   test-arm-linux:
     name: Build and test ARM32 cross compilation
@@ -88,4 +88,4 @@ jobs:
       - name: Compile the project
         run: make RUN="qemu-arm -L /usr/arm-linux-gnueabi/" CC=arm-linux-gnueabi-gcc LD=arm-linux-gnueabi-gcc 
       - name: Test the project
-        run: make RUN="qemu-arm -L /usr/arm-linux-gnueabi/" SUBRUN="qemu-arm -L /usr/arm-linux-gnueabi/" test
+        run: make RUN="qemu-arm -L /usr/arm-linux-gnueabi/" SUBRUN="qemu-arm -L /usr/arm-linux-gnueabi/" test VERBOSE=1

.gitignore

@@ -48,6 +48,8 @@ janet.wasm
 # Generated files
 *.gen.h
 *.gen.c
+*.tmp
+temp.*
 
 # Generate test files
 *.out
@@ -126,6 +128,9 @@ vgcore.*
 *.idb
 *.pdb
 
+# GGov
+*.gcov
+
 # Kernel Module Compile Results
 *.mod*
 *.cmd
@@ -134,6 +139,9 @@ Module.symvers
 Mkfile.old
 dkms.conf
 
+# Coverage files
+*.cov
+
 # End of https://www.gitignore.io/api/c
 
 # Created by https://www.gitignore.io/api/cmake

CHANGELOG.md

@@ -1,6 +1,24 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 1.35.2 - 2024-06-16
+- Fix some documentation typos.
+- Allow using `:only` in import without quoting.
+
+## 1.35.0 - 2024-06-15
+- Add `:only` argument to `import` to allow for easier control over imported bindings.
+- Add extra optional `env` argument to `eval` and `eval-string`.
+- Allow naming function literals with a keyword. This allows better stacktraces for macros without
+  accidentally adding new bindings.
+- Add `bundle/` module for managing packages within Janet. This should replace the jpm packaging
+  format eventually and is much simpler and amenable to more complicated builds.
+- Add macros `ev/with-lock`, `ev/with-rlock`, and `ev/with-wlock` for using mutexes and rwlocks.
+- Add `with-env`
+- Add *module-make-env* dynamic binding
+- Add buffer/format-at
+- Add long form command line options for readable CLI usage
+- Fix bug with `net/accept-loop` that would sometimes miss connections.
+
 ## 1.34.0 - 2024-03-22
 - Add a new (split) PEG special by @ianthehenry
 - Add buffer/push-* sized int and float by @pnelson
@@ -100,7 +118,7 @@ All notable changes to this project will be documented in this file.
   See http://no-color.org/
 - Disallow using `(splice x)` in contexts where it doesn't make sense rather than silently coercing to `x`.
   Instead, raise a compiler error.
-- Change the names of `:user8` and `:user9` sigals to `:interrupt` and `:await`
+- Change the names of `:user8` and `:user9` signals to `:interrupt` and `:await`
 - Change the names of `:user8` and `:user9` fiber statuses to `:interrupted` and `:suspended`.
 - Add `ev/all-tasks` to see all currently suspended fibers.
 - Add `keep-syntax` and `keep-syntax!` functions to make writing macros easier.
@@ -271,7 +289,7 @@ All notable changes to this project will be documented in this file.
 - Add the ability to close channels with `ev/chan-close` (or `:close`).
 - Add threaded channels with `ev/thread-chan`.
 - Add `JANET_FN` and `JANET_REG` macros to more easily define C functions that export their source mapping information.
-- Add `janet_interpreter_interupt` and `janet_loop1_interrupt` to interrupt the interpreter while running.
+- Add `janet_interpreter_interrupt` and `janet_loop1_interrupt` to interrupt the interpreter while running.
 - Add `table/clear`
 - Add build option to disable the threading library without disabling all threads.
 - Remove JPM from the main Janet distribution. Instead, JPM must be installed
@@ -325,7 +343,7 @@ saving and restoring the entire VM state.
 - Sort keys in pretty printing output.
 
 ## 1.15.3 - 2021-02-28
-- Fix a fiber bug that occured in deeply nested fibers
+- Fix a fiber bug that occurred in deeply nested fibers
 - Add `unref` combinator to pegs.
 - Small docstring changes.
 
@@ -475,13 +493,13 @@ saving and restoring the entire VM state.
 - Add `symbol/slice`
 - Add `keyword/slice`
 - Allow cross compilation with Makefile.
-- Change `compare-primitve` to `cmp` and make it more efficient.
+- Change `compare-primitive` to `cmp` and make it more efficient.
 - Add `reverse!` for reversing an array or buffer in place.
 - `janet_dobytes` and `janet_dostring` return parse errors in \*out
 - Add `repeat` macro for iterating something n times.
 - Add `eachy` (each yield) macro for iterating a fiber.
 - Fix `:generate` verb in loop macro to accept non symbols as bindings.
-- Add `:h`, `:h+`, and `:h*` in `default-peg-grammar` for hexidecimal digits.
+- Add `:h`, `:h+`, and `:h*` in `default-peg-grammar` for hexadecimal digits.
 - Fix `%j` formatter to print numbers precisely (using the `%.17g` format string to printf).
 
 ## 1.10.1 - 2020-06-18

Makefile

@@ -204,9 +204,9 @@ build/%.bin.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 ########################
 
 ifeq ($(UNAME), Darwin)
-SONAME=libjanet.1.34.dylib
+SONAME=libjanet.1.35.dylib
 else
-SONAME=libjanet.so.1.34
+SONAME=libjanet.so.1.35
 endif
 
 build/c/shell.c: src/mainclient/shell.c

README.md

@@ -315,8 +315,7 @@ See the [Embedding Section](https://janet-lang.org/capi/embedding.html) on the w
 
 ## Discussion
 
-Feel free to ask questions and join the discussion on the [Janet Gitter channel](https://gitter.im/janet-language/community).
-Gitter provides Matrix and IRC bridges as well.
+Feel free to ask questions and join the discussion on the [Janet Zulip Instance](https://janet.zulipchat.com/)
 
 ## FAQ
 

examples/ffi/test.janet

@@ -55,6 +55,7 @@
 (ffi/defbind sixints-fn six-ints [])
 (ffi/defbind sixints-fn-2 :int [x :int s six-ints])
 (ffi/defbind sixints-fn-3 :int [s six-ints x :int])
+(ffi/defbind-alias int-fn int-fn-aliased :int [a :int b :int])
 
 #
 # Struct reading and writing
@@ -119,6 +120,7 @@
 (tracev (return-struct 42))
 (tracev (double-lots 1 2 3 4 5 6 700 800 9 10))
 (tracev (struct-big 11 99.5))
+(tracev (int-fn-aliased 10 20))
 
 (assert (= [10 10 12 12] (split-ret-fn 10 12)))
 (assert (= [12 12 10 10] (split-flip-ret-fn 10 12)))

examples/numarray/numarray.c

@@ -70,7 +70,7 @@ void num_array_put(void *p, Janet key, Janet value) {
     if (!janet_checktype(value, JANET_NUMBER))
         janet_panic("expected number value");
 
-    index = janet_unwrap_size(key);
+    index = (size_t)janet_unwrap_integer(key);
     if (index < array->size) {
         array->data[index] = janet_unwrap_number(value);
     }
@@ -96,7 +96,7 @@ int num_array_get(void *p, Janet key, Janet *out) {
         return janet_getmethod(janet_unwrap_keyword(key), methods, out);
     if (!janet_checkint(key))
         janet_panic("expected integer key");
-    index = janet_unwrap_size(key);
+    index = (size_t)janet_unwrap_integer(key);
     if (index >= array->size) {
         return 0;
     } else {

examples/sample-bundle/bundle/info.jdn

@@ -0,0 +1,4 @@
+@{
+  :name "sample-bundle"
+  :dependencies ["sample-dep1" "sample-dep2"]
+}

examples/sample-bundle/bundle/init.janet

@@ -0,0 +1,3 @@
+(defn install
+  [manifest &]
+  (bundle/add-file manifest "mymod.janet"))

examples/sample-bundle/mymod.janet

@@ -0,0 +1,7 @@
+(import dep1)
+(import dep2)
+
+(defn myfn
+  [x]
+  (def y (dep2/function x))
+  (dep1/function y))

examples/sample-dep1/bundle/info.jdn

@@ -0,0 +1,4 @@
+@{
+  :name "sample-dep1"
+  :dependencies ["sample-dep2"]
+}

examples/sample-dep1/bundle/init.janet

@@ -0,0 +1,3 @@
+(defn install
+  [manifest &]
+  (bundle/add-file manifest "dep1.janet"))

examples/sample-dep1/dep1.janet

@@ -0,0 +1,3 @@
+(defn function
+  [x]
+  (+ x x))

examples/sample-dep2/bundle/info.jdn

@@ -0,0 +1,3 @@
+@{
+  :name "sample-dep2"
+}

examples/sample-dep2/bundle/init.janet

@@ -0,0 +1,3 @@
+(defn install
+  [manifest &]
+  (bundle/add-file manifest "dep2.janet"))

examples/sample-dep2/dep2.janet

@@ -0,0 +1,3 @@
+(defn function
+  [x]
+  (* x x))

meson.build

@@ -20,7 +20,7 @@
 
 project('janet', 'c',
   default_options : ['c_std=c99', 'build.c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.34.0')
+  version : '1.35.2')
 
 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -249,6 +249,7 @@ test_files = [
   'test/suite-asm.janet',
   'test/suite-boot.janet',
   'test/suite-buffer.janet',
+  'test/suite-bundle.janet',
   'test/suite-capi.janet',
   'test/suite-cfuns.janet',
   'test/suite-compile.janet',

src/boot/array_test.c

@@ -26,6 +26,8 @@
 #include "tests.h"
 
 int array_test() {
+
+    int i;
     JanetArray *array1, *array2;
 
     array1 = janet_array(10);
@@ -51,7 +53,7 @@ int array_test() {
     janet_array_push(array2, janet_cstringv("six"));
     janet_array_push(array2, janet_cstringv("seven"));
 
-    for (size_t i = 0; i < array2->count; i++) {
+    for (i = 0; i < array2->count; i++) {
         assert(janet_equals(array1->data[i], array2->data[i]));
     }
 

src/boot/boot.c

@@ -104,7 +104,7 @@ int main(int argc, const char **argv) {
     }
     fclose(boot_file);
 
-    status = janet_dobytes(env, boot_buffer, boot_size, boot_filename, NULL);
+    status = janet_dobytes(env, boot_buffer, (int32_t) boot_size, boot_filename, NULL);
     janet_free(boot_buffer);
 
     /* Deinitialize vm */

src/boot/buffer_test.c

@@ -26,6 +26,8 @@
 #include "tests.h"
 
 int buffer_test() {
+
+    int i;
     JanetBuffer *buffer1, *buffer2;
 
     buffer1 = janet_buffer(100);
@@ -52,7 +54,7 @@ int buffer_test() {
     assert(buffer1->capacity >= buffer1->count);
     assert(buffer2->capacity >= buffer2->count);
 
-    for (size_t i = 0; i < buffer1->count; i++) {
+    for (i = 0; i < buffer1->count; i++) {
         assert(buffer1->data[i] == buffer2->data[i]);
     }
 

src/boot/number_test.c

@@ -38,7 +38,7 @@ 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);
 }

src/conf/janetconf.h

@@ -4,10 +4,10 @@
 #define JANETCONF_H
 
 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 34
-#define JANET_VERSION_PATCH 0
+#define JANET_VERSION_MINOR 35
+#define JANET_VERSION_PATCH 2
 #define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.34.0"
+#define JANET_VERSION "1.35.2"
 
 /* #define JANET_BUILD "local" */
 

src/core/array.c

@@ -30,11 +30,11 @@
 
 #include <string.h>
 
-static void janet_array_impl(JanetArray *array, size_t capacity) {
+static void janet_array_impl(JanetArray *array, int32_t capacity) {
     Janet *data = NULL;
     if (capacity > 0) {
         janet_vm.next_collection += capacity * sizeof(Janet);
-        data = (Janet *) janet_malloc(sizeof(Janet) * capacity);
+        data = (Janet *) janet_malloc(sizeof(Janet) * (size_t) capacity);
         if (NULL == data) {
             JANET_OUT_OF_MEMORY;
         }
@@ -45,25 +45,25 @@ static void janet_array_impl(JanetArray *array, size_t capacity) {
 }
 
 /* Creates a new array */
-JanetArray *janet_array(size_t capacity) {
+JanetArray *janet_array(int32_t capacity) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
     janet_array_impl(array, capacity);
     return array;
 }
 
 /* Creates a new array with weak references */
-JanetArray *janet_array_weak(size_t capacity) {
+JanetArray *janet_array_weak(int32_t capacity) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY_WEAK, sizeof(JanetArray));
     janet_array_impl(array, capacity);
     return array;
 }
 
 /* Creates a new array from n elements. */
-JanetArray *janet_array_n(const Janet *elements, size_t n) {
+JanetArray *janet_array_n(const Janet *elements, int32_t n) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
     array->capacity = n;
     array->count = n;
-    array->data = janet_malloc(sizeof(Janet) * n);
+    array->data = janet_malloc(sizeof(Janet) * (size_t) n);
     if (!array->data) {
         JANET_OUT_OF_MEMORY;
     }
@@ -72,13 +72,13 @@ JanetArray *janet_array_n(const Janet *elements, size_t n) {
 }
 
 /* Ensure the array has enough capacity for elements */
-void janet_array_ensure(JanetArray *array, size_t capacity, size_t growth) {
+void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) {
     Janet *newData;
     Janet *old = array->data;
     if (capacity <= array->capacity) return;
-    size_t new_capacity = (capacity) * growth;
-    if (new_capacity > JANET_INTMAX_SIZE) new_capacity = JANET_INTMAX_SIZE;
-    capacity = new_capacity;
+    int64_t new_capacity = ((int64_t) capacity) * growth;
+    if (new_capacity > INT32_MAX) new_capacity = INT32_MAX;
+    capacity = (int32_t) new_capacity;
     newData = janet_realloc(old, capacity * sizeof(Janet));
     if (NULL == newData) {
         JANET_OUT_OF_MEMORY;
@@ -89,9 +89,11 @@ void janet_array_ensure(JanetArray *array, size_t capacity, size_t growth) {
 }
 
 /* Set the count of an array. Extend with nil if needed. */
-void janet_array_setcount(JanetArray *array, size_t count) {
+void janet_array_setcount(JanetArray *array, int32_t count) {
+    if (count < 0)
+        return;
     if (count > array->count) {
-        size_t i;
+        int32_t i;
         janet_array_ensure(array, count, 1);
         for (i = array->count; i < count; i++) {
             array->data[i] = janet_wrap_nil();
@@ -102,10 +104,10 @@ void janet_array_setcount(JanetArray *array, size_t count) {
 
 /* Push a value to the top of the array */
 void janet_array_push(JanetArray *array, Janet x) {
-    if (array->count == JANET_INTMAX_SIZE) {
+    if (array->count == INT32_MAX) {
         janet_panic("array overflow");
     }
-    size_t newcount = array->count + 1;
+    int32_t newcount = array->count + 1;
     janet_array_ensure(array, newcount, 2);
     array->data[array->count] = x;
     array->count = newcount;
@@ -136,7 +138,7 @@ JANET_CORE_FN(cfun_array_new,
               "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.") {
     janet_fixarity(argc, 1);
-    size_t cap = janet_getsize(argv, 0);
+    int32_t cap = janet_getinteger(argv, 0);
     JanetArray *array = janet_array(cap);
     return janet_wrap_array(array);
 }
@@ -145,7 +147,7 @@ JANET_CORE_FN(cfun_array_weak,
               "(array/weak capacity)",
               "Creates a new empty array with a pre-allocated capacity and support for weak references. Similar to `array/new`.") {
     janet_fixarity(argc, 1);
-    size_t cap = janet_getsize(argv, 0);
+    int32_t cap = janet_getinteger(argv, 0);
     JanetArray *array = janet_array_weak(cap);
     return janet_wrap_array(array);
 }
@@ -154,10 +156,10 @@ JANET_CORE_FN(cfun_array_new_filled,
               "(array/new-filled count &opt value)",
               "Creates a new array of `count` elements, all set to `value`, which defaults to nil. Returns the new array.") {
     janet_arity(argc, 1, 2);
-    size_t count = janet_getsize(argv, 0);
+    int32_t count = janet_getnat(argv, 0);
     Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
     JanetArray *array = janet_array(count);
-    for (size_t i = 0; i < count; i++) {
+    for (int32_t i = 0; i < count; i++) {
         array->data[i] = x;
     }
     array->count = count;
@@ -171,7 +173,7 @@ JANET_CORE_FN(cfun_array_fill,
     janet_arity(argc, 1, 2);
     JanetArray *array = janet_getarray(argv, 0);
     Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
-    for (size_t i = 0; i < array->count; i++) {
+    for (int32_t i = 0; i < array->count; i++) {
         array->data[i] = x;
     }
     return argv[0];
@@ -199,10 +201,10 @@ JANET_CORE_FN(cfun_array_push,
               "Push all the elements of xs to the end of an array. Modifies the input array and returns it.") {
     janet_arity(argc, 1, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    if ((size_t) JANET_INTMAX_SIZE - argc + 1 <= array->count) {
+    if (INT32_MAX - argc + 1 <= array->count) {
         janet_panic("array overflow");
     }
-    size_t newcount = array->count - 1 + argc;
+    int32_t newcount = array->count - 1 + argc;
     janet_array_ensure(array, newcount, 2);
     if (argc > 1) memcpy(array->data + array->count, argv + 1, (size_t)(argc - 1) * sizeof(Janet));
     array->count = newcount;
@@ -217,8 +219,8 @@ JANET_CORE_FN(cfun_array_ensure,
               "Otherwise, the backing memory will be reallocated so that there is enough space.") {
     janet_fixarity(argc, 3);
     JanetArray *array = janet_getarray(argv, 0);
-    size_t newcount = janet_getsize(argv, 1);
-    size_t growth = janet_getsize(argv, 2);
+    int32_t newcount = janet_getinteger(argv, 1);
+    int32_t growth = janet_getinteger(argv, 2);
     if (newcount < 1) janet_panic("expected positive integer");
     janet_array_ensure(array, newcount, growth);
     return argv[0];
@@ -246,20 +248,21 @@ JANET_CORE_FN(cfun_array_concat,
               "which must be 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`.") {
+    int32_t i;
     janet_arity(argc, 1, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    for (int32_t i = 1; i < argc; i++) {
+    for (i = 1; i < argc; i++) {
         switch (janet_type(argv[i])) {
             default:
                 janet_array_push(array, argv[i]);
                 break;
             case JANET_ARRAY:
             case JANET_TUPLE: {
-                size_t j, len = 0;
+                int32_t j, len = 0;
                 const Janet *vals = NULL;
                 janet_indexed_view(argv[i], &vals, &len);
                 if (array->data == vals) {
-                    size_t newcount = array->count + len;
+                    int32_t newcount = array->count + len;
                     janet_array_ensure(array, newcount, 2);
                     janet_indexed_view(argv[i], &vals, &len);
                 }
@@ -281,15 +284,15 @@ JANET_CORE_FN(cfun_array_insert,
     size_t chunksize, restsize;
     janet_arity(argc, 2, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    ssize_t at = janet_getssize(argv, 1);
+    int32_t at = janet_getinteger(argv, 1);
     if (at < 0) {
         at = array->count + at + 1;
     }
-    if (at < 0 || (size_t) at > array->count)
-      janet_panicf("insertion index %d out of range [0,%d]", at, array->count);
+    if (at < 0 || at > array->count)
+        janet_panicf("insertion index %d out of range [0,%d]", at, array->count);
     chunksize = (argc - 2) * sizeof(Janet);
     restsize = (array->count - at) * sizeof(Janet);
-    if ((size_t) JANET_INTMAX_SIZE - (argc - 2) < array->count) {
+    if (INT32_MAX - (argc - 2) < array->count) {
         janet_panic("array overflow");
     }
     janet_array_ensure(array, array->count + argc - 2, 2);
@@ -311,15 +314,17 @@ JANET_CORE_FN(cfun_array_remove,
               "Returns the array.") {
     janet_arity(argc, 2, 3);
     JanetArray *array = janet_getarray(argv, 0);
-    ssize_t at = janet_getssize(argv, 1);
-    size_t n = 1;
+    int32_t at = janet_getinteger(argv, 1);
+    int32_t n = 1;
     if (at < 0) {
         at = array->count + at;
     }
-    if (at < 0 || (size_t) at > array->count)
+    if (at < 0 || at > array->count)
         janet_panicf("removal index %d out of range [0,%d]", at, array->count);
     if (argc == 3) {
-        n = janet_getsize(argv, 2);
+        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;

src/core/asm.c

@@ -282,7 +282,7 @@ static int32_t doarg_1(
         case JANET_TUPLE: {
             const Janet *t = janet_unwrap_tuple(x);
             if (argtype == JANET_OAT_TYPE) {
-                size_t i = 0;
+                int32_t i = 0;
                 ret = 0;
                 for (i = 0; i < janet_tuple_length(t); i++) {
                     ret |= doarg_1(a, JANET_OAT_SIMPLETYPE, t[i]);
@@ -492,7 +492,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     JanetAssembler a;
     Janet s = source;
     JanetFuncDef *def;
-    size_t count, i;
+    int32_t count, i;
     const Janet *arr;
     Janet x;
     (void) flags;
@@ -578,7 +578,8 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
             Janet v = arr[i];
             if (janet_checktype(v, JANET_TUPLE)) {
                 const Janet *t = janet_unwrap_tuple(v);
-                for (size_t j = 0; j < janet_tuple_length(t); j++) {
+                int32_t j;
+                for (j = 0; j < janet_tuple_length(t); j++) {
                     if (!janet_checktype(t[j], JANET_SYMBOL))
                         janet_asm_error(&a, "slot names must be symbols");
                     janet_table_put(&a.slots, t[j], janet_wrap_integer(i));
@@ -595,7 +596,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     x = janet_get1(s, janet_ckeywordv("constants"));
     if (janet_indexed_view(x, &arr, &count)) {
         def->constants_length = count;
-        def->constants = janet_malloc(sizeof(Janet) * count);
+        def->constants = janet_malloc(sizeof(Janet) * (size_t) count);
         if (NULL == def->constants) {
             JANET_OUT_OF_MEMORY;
         }
@@ -614,7 +615,8 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
         x = janet_get1(s, janet_ckeywordv("defs"));
     }
     if (janet_indexed_view(x, &arr, &count)) {
-        for (size_t i = 0; i < count; i++) {
+        int32_t i;
+        for (i = 0; i < count; i++) {
             JanetAssembleResult subres;
             Janet subname;
             int32_t newlen;
@@ -699,7 +701,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     /* Check for source mapping */
     x = janet_get1(s, janet_ckeywordv("sourcemap"));
     if (janet_indexed_view(x, &arr, &count)) {
-        janet_asm_assert(&a, count == (size_t) def->bytecode_length, "sourcemap must have the same length as the bytecode");
+        janet_asm_assert(&a, count == def->bytecode_length, "sourcemap must have the same length as the bytecode");
         def->sourcemap = janet_malloc(sizeof(JanetSourceMapping) * (size_t) count);
         if (NULL == def->sourcemap) {
             JANET_OUT_OF_MEMORY;
@@ -773,7 +775,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
         if (def->environments_length) {
             def->environments = janet_realloc(def->environments, def->environments_length * sizeof(int32_t));
         }
-        for (size_t i = 0; i < count; i++) {
+        for (int32_t i = 0; i < count; i++) {
             if (!janet_checkint(arr[i])) {
                 janet_asm_error(&a, "expected integer");
             }

src/core/buffer.c

@@ -36,13 +36,11 @@ static void janet_buffer_can_realloc(JanetBuffer *buffer) {
 }
 
 /* Initialize a buffer */
-static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, size_t capacity) {
+static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) {
     uint8_t *data = NULL;
     if (capacity < 4) capacity = 4;
-    if (capacity > JANET_INTMAX_SIZE)
-      capacity = JANET_INTMAX_SIZE;
     janet_gcpressure(capacity);
-    data = janet_malloc(sizeof(uint8_t) * capacity);
+    data = janet_malloc(sizeof(uint8_t) * (size_t) capacity);
     if (NULL == data) {
         JANET_OUT_OF_MEMORY;
     }
@@ -53,7 +51,7 @@ static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, size_t capacity)
 }
 
 /* Initialize a buffer */
-JanetBuffer *janet_buffer_init(JanetBuffer *buffer, size_t capacity) {
+JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) {
     janet_buffer_init_impl(buffer, capacity);
     buffer->gc.data.next = NULL;
     buffer->gc.flags = JANET_MEM_DISABLED;
@@ -61,7 +59,8 @@ JanetBuffer *janet_buffer_init(JanetBuffer *buffer, size_t capacity) {
 }
 
 /* Initialize an unmanaged buffer */
-JanetBuffer *janet_pointer_buffer_unsafe(void *memory, size_t capacity, size_t count) {
+JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t count) {
+    if (count < 0) janet_panic("count < 0");
     if (capacity < count) janet_panic("capacity < count");
     JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer));
     buffer->gc.flags |= JANET_BUFFER_FLAG_NO_REALLOC;
@@ -79,21 +78,21 @@ void janet_buffer_deinit(JanetBuffer *buffer) {
 }
 
 /* Initialize a buffer */
-JanetBuffer *janet_buffer(size_t capacity) {
+JanetBuffer *janet_buffer(int32_t capacity) {
     JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer));
     return janet_buffer_init_impl(buffer, capacity);
 }
 
 /* Ensure that the buffer has enough internal capacity */
-void janet_buffer_ensure(JanetBuffer *buffer, size_t capacity, size_t growth) {
+void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth) {
     uint8_t *new_data;
     uint8_t *old = buffer->data;
     if (capacity <= buffer->capacity) return;
     janet_buffer_can_realloc(buffer);
-    uint64_t big_capacity = (uint64_t) capacity*growth;
-    capacity = big_capacity > JANET_INTMAX_SIZE ? JANET_INTMAX_SIZE : (size_t) big_capacity;
+    int64_t big_capacity = ((int64_t) capacity) * growth;
+    capacity = big_capacity > INT32_MAX ? INT32_MAX : (int32_t) big_capacity;
     janet_gcpressure(capacity - buffer->capacity);
-    new_data = janet_realloc(old, capacity * sizeof(uint8_t));
+    new_data = janet_realloc(old, (size_t) capacity * sizeof(uint8_t));
     if (NULL == new_data) {
         JANET_OUT_OF_MEMORY;
     }
@@ -102,9 +101,11 @@ void janet_buffer_ensure(JanetBuffer *buffer, size_t capacity, size_t growth) {
 }
 
 /* Ensure that the buffer has enough internal capacity */
-void janet_buffer_setcount(JanetBuffer *buffer, size_t count) {
+void janet_buffer_setcount(JanetBuffer *buffer, int32_t count) {
+    if (count < 0)
+        return;
     if (count > buffer->count) {
-        size_t oldcount = buffer->count;
+        int32_t oldcount = buffer->count;
         janet_buffer_ensure(buffer, count, 1);
         memset(buffer->data + oldcount, 0, count - oldcount);
     }
@@ -113,15 +114,15 @@ void janet_buffer_setcount(JanetBuffer *buffer, size_t count) {
 
 /* Adds capacity for enough extra bytes to the buffer. Ensures that the
  * next n bytes pushed to the buffer will not cause a reallocation */
-void janet_buffer_extra(JanetBuffer *buffer, size_t n) {
+void janet_buffer_extra(JanetBuffer *buffer, int32_t n) {
     /* Check for buffer overflow */
-    if ((int64_t)n + buffer->count > JANET_INTMAX_SIZE) {
+    if ((int64_t)n + buffer->count > INT32_MAX) {
         janet_panic("buffer overflow");
     }
-    size_t new_size = buffer->count + n;
+    int32_t new_size = buffer->count + n;
     if (new_size > buffer->capacity) {
         janet_buffer_can_realloc(buffer);
-        size_t new_capacity = (new_size > (JANET_INTMAX_SIZE / 2)) ? JANET_INTMAX_SIZE : (new_size * 2);
+        int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2);
         uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t));
         janet_gcpressure(new_capacity - buffer->capacity);
         if (NULL == new_data) {
@@ -134,12 +135,12 @@ void janet_buffer_extra(JanetBuffer *buffer, size_t n) {
 
 /* Push a cstring to buffer */
 void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) {
-    size_t len = strlen(cstring);
+    int32_t len = (int32_t) strlen(cstring);
     janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len);
 }
 
 /* Push multiple bytes into the buffer */
-void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, size_t length) {
+void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) {
     if (0 == length) return;
     janet_buffer_extra(buffer, length);
     memcpy(buffer->data + buffer->count, string, length);
@@ -196,7 +197,7 @@ JANET_CORE_FN(cfun_buffer_new,
               "Creates a new, empty buffer with enough backing memory for `capacity` bytes. "
               "Returns a new buffer of length 0.") {
     janet_fixarity(argc, 1);
-    size_t cap = janet_getsize(argv, 0);
+    int32_t cap = janet_getinteger(argv, 0);
     JanetBuffer *buffer = janet_buffer(cap);
     return janet_wrap_buffer(buffer);
 }
@@ -206,7 +207,8 @@ JANET_CORE_FN(cfun_buffer_new_filled,
               "Creates a new buffer of length `count` filled with `byte`. By default, `byte` is 0. "
               "Returns the new buffer.") {
     janet_arity(argc, 1, 2);
-    size_t count = janet_getsize(argv, 0);
+    int32_t count = janet_getinteger(argv, 0);
+    if (count < 0) count = 0;
     int32_t byte = 0;
     if (argc == 2) {
         byte = janet_getinteger(argv, 1) & 0xFF;
@@ -222,9 +224,10 @@ JANET_CORE_FN(cfun_buffer_frombytes,
               "(buffer/from-bytes & byte-vals)",
               "Creates a buffer from integer parameters with byte values. All integers "
               "will be coerced to the range of 1 byte 0-255.") {
+    int32_t i;
     JanetBuffer *buffer = janet_buffer(argc);
-    for (int32_t i = 0; i < argc; i++) {
-        size_t c = janet_getsize(argv, i);
+    for (i = 0; i < argc; i++) {
+        int32_t c = janet_getinteger(argv, i);
         buffer->data[i] = c & 0xFF;
     }
     buffer->count = argc;
@@ -255,7 +258,7 @@ JANET_CORE_FN(cfun_buffer_trim,
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     janet_buffer_can_realloc(buffer);
     if (buffer->count < buffer->capacity) {
-        size_t newcap = buffer->count > 4 ? buffer->count : 4;
+        int32_t newcap = buffer->count > 4 ? buffer->count : 4;
         uint8_t *newData = janet_realloc(buffer->data, newcap);
         if (NULL == newData) {
             JANET_OUT_OF_MEMORY;
@@ -270,9 +273,10 @@ JANET_CORE_FN(cfun_buffer_u8,
               "(buffer/push-byte buffer & xs)",
               "Append bytes to a buffer. Will expand the buffer as necessary. "
               "Returns the modified buffer. Will throw an error if the buffer overflows.") {
+    int32_t i;
     janet_arity(argc, 1, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    for (int32_t i = 1; i < argc; i++) {
+    for (i = 1; i < argc; i++) {
         janet_buffer_push_u8(buffer, (uint8_t)(janet_getinteger(argv, i) & 0xFF));
     }
     return argv[0];
@@ -283,9 +287,10 @@ JANET_CORE_FN(cfun_buffer_word,
               "Append machine words to a buffer. The 4 bytes of the integer are appended "
               "in twos complement, little endian order, unsigned for all x. Returns the modified buffer. Will "
               "throw an error if the buffer overflows.") {
+    int32_t i;
     janet_arity(argc, 1, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    for (int32_t i = 1; i < argc; i++) {
+    for (i = 1; i < argc; i++) {
         double number = janet_getnumber(argv, i);
         uint32_t word = (uint32_t) number;
         if (word != number)
@@ -301,9 +306,10 @@ JANET_CORE_FN(cfun_buffer_chars,
               "Will accept any of strings, keywords, symbols, and buffers. "
               "Returns the modified buffer. "
               "Will throw an error if the buffer overflows.") {
+    int32_t i;
     janet_arity(argc, 1, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    for (int32_t i = 1; i < argc; i++) {
+    for (i = 1; i < argc; i++) {
         JanetByteView view = janet_getbytes(argv, i);
         if (view.bytes == buffer->data) {
             janet_buffer_ensure(buffer, buffer->count + view.len, 2);
@@ -369,7 +375,7 @@ JANET_CORE_FN(cfun_buffer_push_uint16,
         uint16_t data;
         uint8_t bytes[2];
     } u;
-    u.data = (uint16_t) janet_getinteger(argv, 2);
+    u.data = janet_getuinteger16(argv, 2);
     if (reverse) {
         uint8_t temp = u.bytes[1];
         u.bytes[1] = u.bytes[0];
@@ -390,7 +396,7 @@ JANET_CORE_FN(cfun_buffer_push_uint32,
         uint32_t data;
         uint8_t bytes[4];
     } u;
-    u.data = (uint32_t) janet_getinteger(argv, 2);
+    u.data = janet_getuinteger(argv, 2);
     if (reverse)
         reverse_u32(u.bytes);
     janet_buffer_push_u32(buffer, *(uint32_t *) u.bytes);
@@ -408,7 +414,7 @@ JANET_CORE_FN(cfun_buffer_push_uint64,
         uint64_t data;
         uint8_t bytes[8];
     } u;
-    u.data = (uint64_t) janet_getuinteger64(argv, 2);
+    u.data = janet_getuinteger64(argv, 2);
     if (reverse)
         reverse_u64(u.bytes);
     janet_buffer_push_u64(buffer, *(uint64_t *) u.bytes);
@@ -472,9 +478,9 @@ JANET_CORE_FN(cfun_buffer_push_at,
               " at index `index`.") {
     janet_arity(argc, 2, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    size_t index = janet_getsize(argv, 1);
-    size_t old_count = buffer->count;
-    if (index > old_count) {
+    int32_t index = janet_getinteger(argv, 1);
+    int32_t old_count = buffer->count;
+    if (index < 0 || index > old_count) {
         janet_panicf("index out of range [0, %d)", old_count);
     }
     buffer->count = index;
@@ -513,7 +519,8 @@ JANET_CORE_FN(cfun_buffer_popn,
               "Removes the last `n` bytes from the buffer. Returns the modified buffer.") {
     janet_fixarity(argc, 2);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    size_t n = janet_getsize(argv, 1);
+    int32_t n = janet_getinteger(argv, 1);
+    if (n < 0) janet_panic("n must be non-negative");
     if (buffer->count < n) {
         buffer->count = 0;
     } else {
@@ -537,17 +544,17 @@ JANET_CORE_FN(cfun_buffer_slice,
     return janet_wrap_buffer(buffer);
 }
 
-static void bitloc(int32_t argc, Janet *argv, JanetBuffer **b, size_t *index, int *bit) {
+static void bitloc(int32_t argc, Janet *argv, JanetBuffer **b, int32_t *index, int *bit) {
     janet_fixarity(argc, 2);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     double x = janet_getnumber(argv, 1);
     int64_t bitindex = (int64_t) x;
     int64_t byteindex = bitindex >> 3;
     int which_bit = bitindex & 7;
-    if (bitindex != x || bitindex < 0 || (size_t) byteindex >= buffer->count)
+    if (bitindex != x || bitindex < 0 || byteindex >= buffer->count)
         janet_panicf("invalid bit index %v", argv[1]);
     *b = buffer;
-    *index = (size_t) byteindex;
+    *index = (int32_t) byteindex;
     *bit = which_bit;
 }
 
@@ -555,7 +562,7 @@ JANET_CORE_FN(cfun_buffer_bitset,
               "(buffer/bit-set buffer index)",
               "Sets the bit at the given bit-index. Returns the buffer.") {
     int bit;
-    size_t index;
+    int32_t index;
     JanetBuffer *buffer;
     bitloc(argc, argv, &buffer, &index, &bit);
     buffer->data[index] |= 1 << bit;
@@ -566,7 +573,7 @@ JANET_CORE_FN(cfun_buffer_bitclear,
               "(buffer/bit-clear buffer index)",
               "Clears the bit at the given bit-index. Returns the buffer.") {
     int bit;
-    size_t index;
+    int32_t index;
     JanetBuffer *buffer;
     bitloc(argc, argv, &buffer, &index, &bit);
     buffer->data[index] &= ~(1 << bit);
@@ -577,7 +584,7 @@ JANET_CORE_FN(cfun_buffer_bitget,
               "(buffer/bit buffer index)",
               "Gets the bit at the given bit-index. Returns true if the bit is set, false if not.") {
     int bit;
-    size_t index;
+    int32_t index;
     JanetBuffer *buffer;
     bitloc(argc, argv, &buffer, &index, &bit);
     return janet_wrap_boolean(buffer->data[index] & (1 << bit));
@@ -587,7 +594,7 @@ JANET_CORE_FN(cfun_buffer_bittoggle,
               "(buffer/bit-toggle buffer index)",
               "Toggles the bit at the given bit index in buffer. Returns the buffer.") {
     int bit;
-    size_t index;
+    int32_t index;
     JanetBuffer *buffer;
     bitloc(argc, argv, &buffer, &index, &bit);
     buffer->data[index] ^= (1 << bit);
@@ -603,25 +610,26 @@ JANET_CORE_FN(cfun_buffer_blit,
     JanetBuffer *dest = janet_getbuffer(argv, 0);
     JanetByteView src = janet_getbytes(argv, 1);
     int same_buf = src.bytes == dest->data;
-    size_t offset_dest = 0;
-    size_t offset_src = 0;
+    int32_t offset_dest = 0;
+    int32_t offset_src = 0;
     if (argc > 2 && !janet_checktype(argv[2], JANET_NIL))
         offset_dest = janet_gethalfrange(argv, 2, dest->count, "dest-start");
     if (argc > 3 && !janet_checktype(argv[3], JANET_NIL))
         offset_src = janet_gethalfrange(argv, 3, src.len, "src-start");
-    size_t length_src;
+    int32_t length_src;
     if (argc > 4) {
-        size_t src_end = src.len;
+        int32_t src_end = src.len;
         if (!janet_checktype(argv[4], JANET_NIL))
             src_end = janet_gethalfrange(argv, 4, src.len, "src-end");
         length_src = src_end - offset_src;
+        if (length_src < 0) length_src = 0;
     } else {
         length_src = src.len - offset_src;
     }
-    size_t last = offset_dest + length_src;
-    if (last > JANET_INTMAX_SIZE)
+    int64_t last = (int64_t) offset_dest + length_src;
+    if (last > INT32_MAX)
         janet_panic("buffer blit out of range");
-    size_t last32 = (size_t) last;
+    int32_t last32 = (int32_t) last;
     janet_buffer_ensure(dest, last32, 2);
     if (last32 > dest->count) dest->count = last32;
     if (length_src) {
@@ -647,6 +655,27 @@ JANET_CORE_FN(cfun_buffer_format,
     return argv[0];
 }
 
+JANET_CORE_FN(cfun_buffer_format_at,
+              "(buffer/format-at buffer at format & args)",
+              "Snprintf like functionality for printing values into a buffer. Returns "
+              "the modified buffer.") {
+    janet_arity(argc, 2, -1);
+    JanetBuffer *buffer = janet_getbuffer(argv, 0);
+    int32_t at = janet_getinteger(argv, 1);
+    if (at < 0) {
+        at += buffer->count + 1;
+    }
+    if (at > buffer->count || at < 0) janet_panicf("expected index at to be in range [0, %d), got %d", buffer->count, at);
+    int32_t oldcount = buffer->count;
+    buffer->count = at;
+    const char *strfrmt = (const char *) janet_getstring(argv, 2);
+    janet_buffer_format(buffer, strfrmt, 2, argc, argv);
+    if (buffer->count < oldcount) {
+        buffer->count = oldcount;
+    }
+    return argv[0];
+}
+
 void janet_lib_buffer(JanetTable *env) {
     JanetRegExt buffer_cfuns[] = {
         JANET_CORE_REG("buffer/new", cfun_buffer_new),
@@ -673,6 +702,7 @@ void janet_lib_buffer(JanetTable *env) {
         JANET_CORE_REG("buffer/bit-toggle", cfun_buffer_bittoggle),
         JANET_CORE_REG("buffer/blit", cfun_buffer_blit),
         JANET_CORE_REG("buffer/format", cfun_buffer_format),
+        JANET_CORE_REG("buffer/format-at", cfun_buffer_format_at),
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, buffer_cfuns);

src/core/capi.c

@@ -138,7 +138,7 @@ type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, type dflt) { \
 }
 
 #define DEFINE_OPTLEN(name, NAME, type) \
-type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, size_t dflt_len) { \
+type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len) { \
     if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {\
         return janet_##name(dflt_len); \
     }\
@@ -232,19 +232,19 @@ const char *janet_getcbytes(const Janet *argv, int32_t n) {
             char *new_string = janet_smalloc(b->count + 1);
             memcpy(new_string, b->data, b->count);
             new_string[b->count] = 0;
-            if (strlen(new_string) != b->count) goto badzeros;
+            if (strlen(new_string) != (size_t) b->count) goto badzeros;
             return new_string;
         } else {
             /* Ensure trailing 0 */
             janet_buffer_push_u8(b, 0);
             b->count--;
-            if (strlen((char *)b->data) != b->count) goto badzeros;
+            if (strlen((char *)b->data) != (size_t) b->count) goto badzeros;
             return (const char *) b->data;
         }
     }
     JanetByteView view = janet_getbytes(argv, n);
     const char *cstr = (const char *)view.bytes;
-    if (strlen(cstr) != view.len) goto badzeros;
+    if (strlen(cstr) != (size_t) view.len) goto badzeros;
     return cstr;
 
 badzeros:
@@ -303,11 +303,28 @@ int32_t janet_getinteger(const Janet *argv, int32_t n) {
 uint32_t janet_getuinteger(const Janet *argv, int32_t n) {
     Janet x = argv[n];
     if (!janet_checkuint(x)) {
-        janet_panicf("bad slot #%d, expected 32 bit signed integer, got %v", n, x);
+        janet_panicf("bad slot #%d, expected 32 bit unsigned integer, got %v", n, x);
     }
-    return janet_unwrap_integer(x);
+    return (uint32_t) janet_unwrap_number(x);
 }
 
+int16_t janet_getinteger16(const Janet *argv, int32_t n) {
+    Janet x = argv[n];
+    if (!janet_checkint16(x)) {
+        janet_panicf("bad slot #%d, expected 16 bit signed integer, got %v", n, x);
+    }
+    return (int16_t) janet_unwrap_number(x);
+}
+
+uint16_t janet_getuinteger16(const Janet *argv, int32_t n) {
+    Janet x = argv[n];
+    if (!janet_checkuint16(x)) {
+        janet_panicf("bad slot #%d, expected 16 bit unsigned integer, got %v", n, x);
+    }
+    return (uint16_t) janet_unwrap_number(x);
+}
+
+
 int64_t janet_getinteger64(const Janet *argv, int32_t n) {
 #ifdef JANET_INT_TYPES
     return janet_unwrap_s64(argv[n]);
@@ -337,47 +354,39 @@ size_t janet_getsize(const Janet *argv, int32_t n) {
     if (!janet_checksize(x)) {
         janet_panicf("bad slot #%d, expected size, got %v", n, x);
     }
-    return janet_unwrap_size(x);
+    return (size_t) janet_unwrap_number(x);
 }
 
-ssize_t janet_getssize(const Janet *argv, int32_t n) {
-    Janet x = argv[n];
-    if (!janet_checkssize(x)) {
-        janet_panicf("bad slot #%d, expected ssize, got %v", n, x);
-    }
-    return janet_unwrap_ssize(x);
-}
-
-size_t janet_gethalfrange(const Janet *argv, int32_t n, size_t length, const char *which) {
-    ssize_t raw = janet_getssize(argv, n);
-    ssize_t not_raw = raw;
+int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which) {
+    int32_t raw = janet_getinteger(argv, n);
+    int32_t not_raw = raw;
     if (not_raw < 0) not_raw += length + 1;
-    if (not_raw < 0 || (size_t) not_raw > length)
+    if (not_raw < 0 || not_raw > length)
         janet_panicf("%s index %d out of range [%d,%d]", which, (int64_t) raw, -(int64_t)length - 1, (int64_t) length);
-    return (size_t) not_raw;
+    return not_raw;
 }
 
-size_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, size_t length) {
+int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) {
     if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {
         return 0;
     }
     return janet_gethalfrange(argv, n, length, "start");
 }
 
-size_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, size_t length) {
+int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) {
     if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {
         return length;
     }
     return janet_gethalfrange(argv, n, length, "end");
 }
 
-size_t janet_getargindex(const Janet *argv, int32_t n, size_t length, const char *which) {
-    ssize_t raw = janet_getssize(argv, n);
-    ssize_t not_raw = raw;
+int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which) {
+    int32_t raw = janet_getinteger(argv, n);
+    int32_t not_raw = raw;
     if (not_raw < 0) not_raw += length;
-    if (not_raw < 0 || (size_t) not_raw > length)
+    if (not_raw < 0 || not_raw > length)
         janet_panicf("%s index %d out of range [%d,%d)", which, (int64_t)raw, -(int64_t)length, (int64_t)length);
-    return (size_t) not_raw;
+    return not_raw;
 }
 
 JanetView janet_getindexed(const Janet *argv, int32_t n) {
@@ -422,7 +431,7 @@ void *janet_getabstract(const Janet *argv, int32_t n, const JanetAbstractType *a
 JanetRange janet_getslice(int32_t argc, const Janet *argv) {
     janet_arity(argc, 1, 3);
     JanetRange range;
-    size_t length = janet_length(argv[0]);
+    int32_t length = janet_length(argv[0]);
     range.start = janet_getstartrange(argv, argc, 1, length);
     range.end = janet_getendrange(argv, argc, 2, length);
     if (range.end < range.start)
@@ -457,13 +466,13 @@ void janet_setdyn(const char *name, Janet value) {
 uint64_t janet_getflags(const Janet *argv, int32_t n, const char *flags) {
     uint64_t ret = 0;
     const uint8_t *keyw = janet_getkeyword(argv, n);
-    size_t klen = janet_string_length(keyw);
-    size_t flen = strlen(flags);
+    int32_t klen = janet_string_length(keyw);
+    int32_t flen = (int32_t) strlen(flags);
     if (flen > 64) {
         flen = 64;
     }
-    for (size_t j = 0; j < klen; j++) {
-        for (size_t i = 0; i < flen; i++) {
+    for (int32_t j = 0; j < klen; j++) {
+        for (int32_t i = 0; i < flen; i++) {
             if (((uint8_t) flags[i]) == keyw[j]) {
                 ret |= 1ULL << i;
                 goto found;
@@ -500,12 +509,6 @@ size_t janet_optsize(const Janet *argv, int32_t argc, int32_t n, size_t dflt) {
     return janet_getsize(argv, n);
 }
 
-ssize_t janet_optssize(const Janet *argv, int32_t argc, int32_t n, ssize_t dflt) {
-    if (argc <= n) return dflt;
-    if (janet_checktype(argv[n], JANET_NIL)) return dflt;
-    return janet_getssize(argv, n);
-}
-
 void *janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetAbstractType *at, void *dflt) {
     if (argc <= n) return dflt;
     if (janet_checktype(argv[n], JANET_NIL)) return dflt;

src/core/compile.c

@@ -418,11 +418,12 @@ JanetSlot janetc_gettarget(JanetFopts opts) {
 }
 
 /* Get a bunch of slots for function arguments */
-JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, size_t len) {
+JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len) {
+    int32_t i;
     JanetSlot *ret = NULL;
     JanetFopts subopts = janetc_fopts_default(c);
     subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE;
-    for (size_t i = 0; i < len; i++) {
+    for (i = 0; i < len; i++) {
         janet_v_push(ret, janetc_value(subopts, vals[i]));
     }
     return ret;
@@ -434,9 +435,9 @@ JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds) {
     JanetFopts subopts = janetc_fopts_default(c);
     subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE;
     const JanetKV *kvs = NULL;
-    size_t cap = 0, len = 0;
+    int32_t cap = 0, len = 0;
     janet_dictionary_view(ds, &kvs, &len, &cap);
-    for (size_t i = 0; i < cap; i++) {
+    for (int32_t i = 0; i < cap; i++) {
         if (janet_checktype(kvs[i].key, JANET_NIL)) continue;
         janet_v_push(ret, janetc_value(subopts, kvs[i].key));
         janet_v_push(ret, janetc_value(subopts, kvs[i].value));
@@ -933,7 +934,7 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
         int32_t slotchunks = (def->slotcount + 31) >> 5;
         /* numchunks is min of slotchunks and scope->ua.count */
         int32_t numchunks = slotchunks > scope->ua.count ? scope->ua.count : slotchunks;
-        uint32_t *chunks = janet_calloc(sizeof(uint32_t), slotchunks);
+        uint32_t *chunks = janet_calloc(slotchunks, sizeof(uint32_t));
         if (NULL == chunks) {
             JANET_OUT_OF_MEMORY;
         }
@@ -1055,7 +1056,7 @@ JanetCompileResult janet_compile_lint(Janet source,
 
     if (c.result.status == JANET_COMPILE_OK) {
         JanetFuncDef *def = janetc_pop_funcdef(&c);
-        def->name = janet_cstring("_thunk");
+        def->name = janet_cstring("thunk");
         janet_def_addflags(def);
         c.result.funcdef = def;
     } else {

src/core/compile.h

@@ -232,7 +232,7 @@ void janetc_throwaway(JanetFopts opts, Janet x);
 JanetSlot janetc_gettarget(JanetFopts opts);
 
 /* Get a bunch of slots for function arguments */
-JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, size_t len);
+JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len);
 
 /* Get a bunch of slots for function arguments */
 JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds);
@@ -262,7 +262,7 @@ void janetc_popscope(JanetCompiler *c);
 void janetc_popscope_keepslot(JanetCompiler *c, JanetSlot retslot);
 JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c);
 
-/* Create a destory slots */
+/* Create a destroy slot */
 JanetSlot janetc_cslot(Janet x);
 
 /* Search for a symbol */

src/core/corelib.c

@@ -69,15 +69,15 @@ JanetModule janet_native(const char *name, const uint8_t **error) {
             host.minor < modconf.minor ||
             host.bits != modconf.bits) {
         char errbuf[128];
-        sprintf(errbuf, "config mismatch - host %d.%.d.%d(%.4x) vs. module %d.%d.%d(%.4x)",
-                host.major,
-                host.minor,
-                host.patch,
-                host.bits,
-                modconf.major,
-                modconf.minor,
-                modconf.patch,
-                modconf.bits);
+        snprintf(errbuf, sizeof(errbuf), "config mismatch - host %d.%.d.%d(%.4x) vs. module %d.%d.%d(%.4x)",
+                 host.major,
+                 host.minor,
+                 host.patch,
+                 host.bits,
+                 modconf.major,
+                 modconf.minor,
+                 modconf.patch,
+                 modconf.bits);
         *error = janet_cstring(errbuf);
         return NULL;
     }
@@ -92,7 +92,7 @@ static const char *janet_dyncstring(const char *name, const char *dflt) {
     }
     const uint8_t *jstr = janet_unwrap_string(x);
     const char *cstr = (const char *)jstr;
-    if (strlen(cstr) != janet_string_length(jstr)) {
+    if (strlen(cstr) != (size_t) janet_string_length(jstr)) {
         janet_panicf("string %v contains embedded 0s", x);
     }
     return cstr;
@@ -432,27 +432,28 @@ JANET_CORE_FN(janet_core_range,
               "With one argument, returns a range [0, end). With two arguments, returns "
               "a range [start, end). With three, returns a range with optional step size.") {
     janet_arity(argc, 1, 3);
-    int32_t start = 0, stop = 0, step = 1, count = 0;
+    double start = 0, stop = 0, step = 1, count = 0;
     if (argc == 3) {
-        start = janet_getinteger(argv, 0);
-        stop = janet_getinteger(argv, 1);
-        step = janet_getinteger(argv, 2);
-        count = (step > 0) ? (stop - start - 1) / step + 1 :
-                ((step < 0) ? (stop - start + 1) / step + 1 : 0);
+        start = janet_getnumber(argv, 0);
+        stop = janet_getnumber(argv, 1);
+        step = janet_getnumber(argv, 2);
+        count = (step > 0) ? (stop - start) / step :
+                ((step < 0) ? (stop - start) / step : 0);
     } else if (argc == 2) {
-        start = janet_getinteger(argv, 0);
-        stop = janet_getinteger(argv, 1);
+        start = janet_getnumber(argv, 0);
+        stop = janet_getnumber(argv, 1);
         count = stop - start;
     } else {
-        stop = janet_getinteger(argv, 0);
+        stop = janet_getnumber(argv, 0);
         count = stop;
     }
     count = (count > 0) ? count : 0;
-    JanetArray *array = janet_array(count);
-    for (int32_t i = 0; i < count; i++) {
+    int32_t int_count = ceil(count);
+    JanetArray *array = janet_array(int_count);
+    for (int32_t i = 0; i < int_count; i++) {
         array->data[i] = janet_wrap_number(start + i * step);
     }
-    array->count = count;
+    array->count = int_count;
     return janet_wrap_array(array);
 }
 
@@ -718,12 +719,12 @@ JANET_CORE_FN(janet_core_memcmp,
     janet_arity(argc, 2, 5);
     JanetByteView a = janet_getbytes(argv, 0);
     JanetByteView b = janet_getbytes(argv, 1);
-    size_t len = janet_optsize(argv, argc, 2, a.len < b.len ? a.len : b.len);
-    size_t offset_a = janet_optsize(argv, argc, 3, 0);
-    size_t offset_b = janet_optsize(argv, argc, 4, 0);
+    int32_t len = janet_optnat(argv, argc, 2, a.len < b.len ? a.len : b.len);
+    int32_t offset_a = janet_optnat(argv, argc, 3, 0);
+    int32_t offset_b = janet_optnat(argv, argc, 4, 0);
     if (offset_a + len > a.len) janet_panicf("invalid offset-a: %d", offset_a);
     if (offset_b + len > b.len) janet_panicf("invalid offset-b: %d", offset_b);
-    return janet_wrap_integer(memcmp(a.bytes + offset_a, b.bytes + offset_b, len));
+    return janet_wrap_integer(memcmp(a.bytes + offset_a, b.bytes + offset_b, (size_t) len));
 }
 
 typedef struct SandboxOption {
@@ -976,7 +977,7 @@ static void make_apply(JanetTable *env) {
         /* Push the array */
         S(JOP_PUSH_ARRAY, 5),
 
-        /* Call the funciton */
+        /* Call the function */
         S(JOP_TAILCALL, 0)
     };
     janet_quick_asm(env, JANET_FUN_APPLY | JANET_FUNCDEF_FLAG_VARARG,
@@ -1339,7 +1340,7 @@ JanetTable *janet_core_env(JanetTable *replacements) {
     janet_resolve(env, janet_csymbol("make-image-dict"), &midv);
     JanetTable *lid = janet_unwrap_table(lidv);
     JanetTable *mid = janet_unwrap_table(midv);
-    for (size_t i = 0; i < lid->capacity; i++) {
+    for (int32_t i = 0; i < lid->capacity; i++) {
         const JanetKV *kv = lid->data + i;
         if (!janet_checktype(kv->key, JANET_NIL)) {
             janet_table_put(mid, kv->value, kv->key);
@@ -1357,7 +1358,7 @@ JanetTable *janet_core_lookup_table(JanetTable *replacements) {
 
     /* Add replacements */
     if (replacements != NULL) {
-        for (size_t i = 0; i < replacements->capacity; i++) {
+        for (int32_t i = 0; i < replacements->capacity; i++) {
             JanetKV kv = replacements->data[i];
             if (!janet_checktype(kv.key, JANET_NIL)) {
                 janet_table_put(dict, kv.key, kv.value);

src/core/debug.c

@@ -102,7 +102,7 @@ void janet_stacktrace(JanetFiber *fiber, Janet err) {
 }
 
 /* Error reporting. This can be emulated from within Janet, but for
- * consitency with the top level code it is defined once. */
+ * consistency with the top level code it is defined once. */
 void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix) {
 
     int32_t fi;
@@ -164,7 +164,7 @@ void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix) {
                 }
             }
             if (frame->flags & JANET_STACKFRAME_TAILCALL)
-                janet_eprintf(" (tailcall)");
+                janet_eprintf(" (tail call)");
             if (frame->func && frame->pc) {
                 int32_t off = (int32_t)(frame->pc - def->bytecode);
                 if (def->sourcemap) {
@@ -180,6 +180,11 @@ void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix) {
                 }
             }
             janet_eprintf("\n");
+            /* Print fiber points optionally. Clutters traces but provides info
+            if (i <= 0 && fi > 0) {
+                janet_eprintf("  in parent fiber\n");
+            }
+            */
         }
     }
 

src/core/ev.c

@@ -78,7 +78,7 @@ typedef struct {
     JanetQueue items;
     JanetQueue read_pending;
     JanetQueue write_pending;
-    size_t limit;
+    int32_t limit;
     int closed;
     int is_threaded;
 #ifdef JANET_WINDOWS
@@ -124,18 +124,18 @@ static void janet_q_deinit(JanetQueue *q) {
     janet_free(q->data);
 }
 
-static size_t janet_q_count(JanetQueue *q) {
+static int32_t janet_q_count(JanetQueue *q) {
     return (q->head > q->tail)
            ? (q->tail + q->capacity - q->head)
            : (q->tail - q->head);
 }
 
 static int janet_q_maybe_resize(JanetQueue *q, size_t itemsize) {
-    size_t count = janet_q_count(q);
+    int32_t count = janet_q_count(q);
     /* Resize if needed */
     if (count + 1 >= q->capacity) {
         if (count + 1 >= JANET_MAX_Q_CAPACITY) return 1;
-        size_t newcap = (count + 2) * 2;
+        int32_t newcap = (count + 2) * 2;
         if (newcap > JANET_MAX_Q_CAPACITY) newcap = JANET_MAX_Q_CAPACITY;
         q->data = janet_realloc(q->data, itemsize * newcap);
         if (NULL == q->data) {
@@ -143,7 +143,7 @@ static int janet_q_maybe_resize(JanetQueue *q, size_t itemsize) {
         }
         if (q->head > q->tail) {
             /* Two segments, fix 2nd seg. */
-            size_t newhead = q->head + (newcap - q->capacity);
+            int32_t newhead = q->head + (newcap - q->capacity);
             size_t seg1 = (size_t)(q->capacity - q->head);
             if (seg1 > 0) {
                 memmove((char *) q->data + (newhead * itemsize),
@@ -166,7 +166,7 @@ static int janet_q_push(JanetQueue *q, void *item, size_t itemsize) {
 
 static int janet_q_push_head(JanetQueue *q, void *item, size_t itemsize) {
     if (janet_q_maybe_resize(q, itemsize)) return 1;
-    ssize_t newhead = q->head - 1;
+    int32_t newhead = q->head - 1;
     if (newhead < 0) {
         newhead += q->capacity;
     }
@@ -281,13 +281,9 @@ void janet_async_start(JanetStream *stream, JanetAsyncMode mode, JanetEVCallback
     janet_assert(!fiber->ev_callback, "double async on fiber");
     if (mode & JANET_ASYNC_LISTEN_READ) {
         stream->read_fiber = fiber;
-    } else {
-        stream->read_fiber = NULL;
     }
     if (mode & JANET_ASYNC_LISTEN_WRITE) {
         stream->write_fiber = fiber;
-    } else {
-        stream->write_fiber = NULL;
     }
     fiber->ev_callback = callback;
     fiber->ev_stream = stream;
@@ -437,7 +433,7 @@ static void janet_stream_marshal(void *p, JanetMarshalContext *ctx) {
     }
     janet_marshal_int64(ctx, (int64_t)(duph));
 #else
-    /* Marshal after dup becuse it is easier than maintaining our own ref counting. */
+    /* Marshal after dup because it is easier than maintaining our own ref counting. */
     int duph = dup(s->handle);
     if (duph < 0) janet_panicf("failed to duplicate stream handle: %V", janet_ev_lasterr());
     janet_marshal_int(ctx, (int32_t)(duph));
@@ -530,16 +526,16 @@ void janet_ev_mark(void) {
     /* Pending tasks */
     JanetTask *tasks = janet_vm.spawn.data;
     if (janet_vm.spawn.head <= janet_vm.spawn.tail) {
-        for (size_t i = janet_vm.spawn.head; i < janet_vm.spawn.tail; i++) {
+        for (int32_t i = janet_vm.spawn.head; i < janet_vm.spawn.tail; i++) {
             janet_mark(janet_wrap_fiber(tasks[i].fiber));
             janet_mark(tasks[i].value);
         }
     } else {
-        for (size_t i = janet_vm.spawn.head; i < janet_vm.spawn.capacity; i++) {
+        for (int32_t i = janet_vm.spawn.head; i < janet_vm.spawn.capacity; i++) {
             janet_mark(janet_wrap_fiber(tasks[i].fiber));
             janet_mark(tasks[i].value);
         }
-        for (size_t i = 0; i < janet_vm.spawn.tail; i++) {
+        for (int32_t i = 0; i < janet_vm.spawn.tail; i++) {
             janet_mark(janet_wrap_fiber(tasks[i].fiber));
             janet_mark(tasks[i].value);
         }
@@ -599,7 +595,7 @@ void janet_ev_deinit_common(void) {
 
 /* Shorthand to yield to event loop */
 void janet_await(void) {
-    /* Store the fiber in a gobal table */
+    /* Store the fiber in a global table */
     janet_signalv(JANET_SIGNAL_EVENT, janet_wrap_nil());
 }
 
@@ -732,12 +728,12 @@ static int janet_chanat_gc(void *p, size_t s) {
 static void janet_chanat_mark_fq(JanetQueue *fq) {
     JanetChannelPending *pending = fq->data;
     if (fq->head <= fq->tail) {
-        for (size_t i = fq->head; i < fq->tail; i++)
+        for (int32_t i = fq->head; i < fq->tail; i++)
             janet_mark(janet_wrap_fiber(pending[i].fiber));
     } else {
-        for (size_t i = fq->head; i < fq->capacity; i++)
+        for (int32_t i = fq->head; i < fq->capacity; i++)
             janet_mark(janet_wrap_fiber(pending[i].fiber));
-        for (size_t i = 0; i < fq->tail; i++)
+        for (int32_t i = 0; i < fq->tail; i++)
             janet_mark(janet_wrap_fiber(pending[i].fiber));
     }
 }
@@ -750,12 +746,12 @@ static int janet_chanat_mark(void *p, size_t s) {
     JanetQueue *items = &chan->items;
     Janet *data = chan->items.data;
     if (items->head <= items->tail) {
-        for (size_t i = items->head; i < items->tail; i++)
+        for (int32_t i = items->head; i < items->tail; i++)
             janet_mark(data[i]);
     } else {
-        for (size_t i = items->head; i < items->capacity; i++)
+        for (int32_t i = items->head; i < items->capacity; i++)
             janet_mark(data[i]);
-        for (size_t i = 0; i < items->tail; i++)
+        for (int32_t i = 0; i < items->tail; i++)
             janet_mark(data[i]);
     }
     return 0;
@@ -1011,7 +1007,7 @@ JANET_CORE_FN(cfun_channel_pop,
 
 static void chan_unlock_args(const Janet *argv, int32_t n) {
     for (int32_t i = 0; i < n; i++) {
-        size_t len;
+        int32_t len;
         const Janet *data;
         JanetChannel *chan;
         if (janet_indexed_view(argv[i], &data, &len) && len == 2) {
@@ -1036,7 +1032,7 @@ JANET_CORE_FN(cfun_channel_choice,
               "channel was closed while waiting, or that the channel was already "
               "closed.") {
     janet_arity(argc, 1, -1);
-    size_t len;
+    int32_t len;
     const Janet *data;
 
     /* Check channels for immediate reads and writes */
@@ -1246,18 +1242,18 @@ static void janet_chanat_marshal(void *p, JanetMarshalContext *ctx) {
     janet_marshal_byte(ctx, channel->is_threaded);
     janet_marshal_abstract(ctx, channel);
     janet_marshal_byte(ctx, channel->closed);
-    janet_marshal_size(ctx, channel->limit);
-    size_t count = janet_q_count(&channel->items);
-    janet_marshal_size(ctx, count);
+    janet_marshal_int(ctx, channel->limit);
+    int32_t count = janet_q_count(&channel->items);
+    janet_marshal_int(ctx, count);
     JanetQueue *items = &channel->items;
     Janet *data = channel->items.data;
     if (items->head <= items->tail) {
-        for (size_t i = items->head; i < items->tail; i++)
+        for (int32_t i = items->head; i < items->tail; i++)
             janet_marshal_janet(ctx, data[i]);
     } else {
-        for (size_t i = items->head; i < items->capacity; i++)
+        for (int32_t i = items->head; i < items->capacity; i++)
             janet_marshal_janet(ctx, data[i]);
-        for (size_t i = 0; i < items->tail; i++)
+        for (int32_t i = 0; i < items->tail; i++)
             janet_marshal_janet(ctx, data[i]);
     }
 }
@@ -1481,7 +1477,7 @@ static void janet_register_stream(JanetStream *stream) {
 
 void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
     ULONG_PTR completionKey = 0;
-    DWORD num_bytes_transfered = 0;
+    DWORD num_bytes_transferred = 0;
     LPOVERLAPPED overlapped = NULL;
 
     /* Calculate how long to wait before timeout */
@@ -1496,7 +1492,7 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
     } else {
         waittime = INFINITE;
     }
-    BOOL result = GetQueuedCompletionStatus(janet_vm.iocp, &num_bytes_transfered, &completionKey, &overlapped, (DWORD) waittime);
+    BOOL result = GetQueuedCompletionStatus(janet_vm.iocp, &num_bytes_transferred, &completionKey, &overlapped, (DWORD) waittime);
 
     if (result || overlapped) {
         if (0 == completionKey) {
@@ -1519,7 +1515,7 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
             if (fiber != NULL) {
                 fiber->flags &= ~JANET_FIBER_EV_FLAG_IN_FLIGHT;
                 /* System is done with this, we can reused this data */
-                overlapped->InternalHigh = (ULONG_PTR) num_bytes_transfered;
+                overlapped->InternalHigh = (ULONG_PTR) num_bytes_transferred;
                 fiber->ev_callback(fiber, result ? JANET_ASYNC_EVENT_COMPLETE : JANET_ASYNC_EVENT_FAILED);
             } else {
                 janet_free((void *) overlapped);
@@ -1530,6 +1526,14 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
     }
 }
 
+void janet_stream_edge_triggered(JanetStream *stream) {
+    (void) stream;
+}
+
+void janet_stream_level_triggered(JanetStream *stream) {
+    (void) stream;
+}
+
 #elif defined(JANET_EV_EPOLL)
 
 static JanetTimestamp ts_now(void) {
@@ -1541,15 +1545,15 @@ static JanetTimestamp ts_now(void) {
 }
 
 /* Wait for the next event */
-static void janet_register_stream(JanetStream *stream) {
+static void janet_register_stream_impl(JanetStream *stream, int mod, int edge_trigger) {
     struct epoll_event ev;
-    ev.events = EPOLLET;
+    ev.events = edge_trigger ? EPOLLET : 0;
     if (stream->flags & (JANET_STREAM_READABLE | JANET_STREAM_ACCEPTABLE)) ev.events |= EPOLLIN;
     if (stream->flags & JANET_STREAM_WRITABLE) ev.events |= EPOLLOUT;
     ev.data.ptr = stream;
     int status;
     do {
-        status = epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, stream->handle, &ev);
+        status = epoll_ctl(janet_vm.epoll, mod ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, stream->handle, &ev);
     } while (status == -1 && errno == EINTR);
     if (status == -1) {
         if (errno == EPERM) {
@@ -1563,6 +1567,18 @@ static void janet_register_stream(JanetStream *stream) {
     }
 }
 
+static void janet_register_stream(JanetStream *stream) {
+    janet_register_stream_impl(stream, 0, 1);
+}
+
+void janet_stream_edge_triggered(JanetStream *stream) {
+    janet_register_stream_impl(stream, 1, 1);
+}
+
+void janet_stream_level_triggered(JanetStream *stream) {
+    janet_register_stream_impl(stream, 1, 0);
+}
+
 #define JANET_EPOLL_MAX_EVENTS 64
 void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
     struct itimerspec its;
@@ -1692,14 +1708,15 @@ static void timestamp2timespec(struct timespec *t, JanetTimestamp ts) {
     t->tv_nsec = ts == 0 ? 0 : (ts % 1000) * 1000000;
 }
 
-void janet_register_stream(JanetStream *stream) {
+void janet_register_stream_impl(JanetStream *stream, int edge_trigger) {
     struct kevent kevs[2];
     int length = 0;
+    int clear = edge_trigger ? EV_CLEAR : 0;
     if (stream->flags & (JANET_STREAM_READABLE | JANET_STREAM_ACCEPTABLE)) {
-        EV_SETx(&kevs[length++], stream->handle, EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, stream);
+        EV_SETx(&kevs[length++], stream->handle, EVFILT_READ, EV_ADD | EV_ENABLE | clear, 0, 0, stream);
     }
     if (stream->flags & JANET_STREAM_WRITABLE) {
-        EV_SETx(&kevs[length++], stream->handle, EVFILT_WRITE, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, stream);
+        EV_SETx(&kevs[length++], stream->handle, EVFILT_WRITE, EV_ADD | EV_ENABLE | clear, 0, 0, stream);
     }
     int status;
     do {
@@ -1710,6 +1727,18 @@ void janet_register_stream(JanetStream *stream) {
     }
 }
 
+void janet_register_stream(JanetStream *stream) {
+    janet_register_stream_impl(stream, 1);
+}
+
+void janet_stream_edge_triggered(JanetStream *stream) {
+    janet_register_stream_impl(stream, 1);
+}
+
+void janet_stream_level_triggered(JanetStream *stream) {
+    janet_register_stream_impl(stream, 0);
+}
+
 #define JANET_KQUEUE_MAX_EVENTS 64
 
 void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
@@ -1832,6 +1861,14 @@ void janet_register_stream(JanetStream *stream) {
     janet_vm.stream_count = new_count;
 }
 
+void janet_stream_edge_triggered(JanetStream *stream) {
+    (void) stream;
+}
+
+void janet_stream_level_triggered(JanetStream *stream) {
+    (void) stream;
+}
+
 void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
 
     /* set event flags */
@@ -2054,7 +2091,7 @@ void janet_ev_threaded_call(JanetThreadedSubroutine fp, JanetEVGenericMessage ar
     int err = pthread_create(&waiter_thread, &janet_vm.new_thread_attr, janet_thread_body, init);
     if (err) {
         janet_free(init);
-        janet_panicf("%s", strerror(err));
+        janet_panicf("%s", janet_strerror(err));
     }
 #endif
 
@@ -2163,7 +2200,7 @@ Janet janet_ev_lasterr(void) {
 }
 #else
 Janet janet_ev_lasterr(void) {
-    return janet_cstringv(strerror(errno));
+    return janet_cstringv(janet_strerror(errno));
 }
 #endif
 
@@ -2475,7 +2512,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
         break;
         case JANET_ASYNC_EVENT_INIT: {
             /* Begin write */
-            size_t len;
+            int32_t len;
             const uint8_t *bytes;
             if (state->is_buffer) {
                 /* If buffer, convert to string. */
@@ -2795,7 +2832,7 @@ static JanetEVGenericMessage janet_go_thread_subr(JanetEVGenericMessage args) {
             janet_gcroot(janet_wrap_table(janet_vm.abstract_registry));
         }
 
-        /* Get supervsior */
+        /* Get supervisor */
         if (flags & JANET_THREAD_SUPERVISOR_FLAG) {
             Janet sup =
                 janet_unmarshal(nextbytes, endbytes - nextbytes,
@@ -3185,7 +3222,7 @@ JANET_CORE_FN(janet_cfun_ev_all_tasks,
     janet_fixarity(argc, 0);
     (void) argv;
     JanetArray *array = janet_array(janet_vm.active_tasks.count);
-    for (size_t i = 0; i < janet_vm.active_tasks.capacity; i++) {
+    for (int32_t i = 0; i < janet_vm.active_tasks.capacity; i++) {
         if (!janet_checktype(janet_vm.active_tasks.data[i].key, JANET_NIL)) {
             janet_array_push(array, janet_vm.active_tasks.data[i].key);
         }

src/core/features.h

@@ -76,4 +76,6 @@
 #define __BSD_VISIBLE 1
 #endif
 
+#define _FILE_OFFSET_BITS 64
+
 #endif

src/core/ffi.c

@@ -107,7 +107,7 @@ static const JanetFFIPrimInfo janet_ffi_type_info[] = {
 struct JanetFFIType {
     JanetFFIStruct *st;
     JanetFFIPrimType prim;
-    ssize_t array_count;
+    int32_t array_count;
 };
 
 typedef struct {
@@ -408,7 +408,7 @@ static JanetFFIStruct *build_struct_type(int32_t argc, const Janet *argv) {
             st->fields[i].offset = st->size;
             st->size += (uint32_t) el_size;
         } else {
-            if (el_align > (size_t) st->align) st->align = (uint32_t) el_align;
+            if (el_align > st->align) st->align = (uint32_t) el_align;
             st->fields[i].offset = (uint32_t)(((st->size + el_align - 1) / el_align) * el_align);
             st->size = (uint32_t)(el_size + st->fields[i].offset);
         }
@@ -432,13 +432,13 @@ static JanetFFIType decode_ffi_type(Janet x) {
         ret.st = janet_unwrap_abstract(x);
         return ret;
     }
-    size_t len;
+    int32_t len;
     const Janet *els;
     if (janet_indexed_view(x, &els, &len)) {
         if (janet_checktype(x, JANET_ARRAY)) {
             if (len != 2 && len != 1) janet_panicf("array type must be of form @[type count], got %v", x);
             ret = decode_ffi_type(els[0]);
-            ssize_t array_count = len == 1 ? 0 : janet_getssize(els, 1);
+            int32_t array_count = len == 1 ? 0 : janet_getnat(els, 1);
             ret.array_count = array_count;
         } else {
             ret.st = build_struct_type(len, els);
@@ -475,7 +475,7 @@ JANET_CORE_FN(cfun_ffi_align,
 static void *janet_ffi_getpointer(const Janet *argv, int32_t n) {
     switch (janet_type(argv[n])) {
         default:
-            janet_panicf("bad slot #%d, expected ffi pointer convertable type, got %v", n, argv[n]);
+            janet_panicf("bad slot #%d, expected ffi pointer convertible type, got %v", n, argv[n]);
         case JANET_POINTER:
         case JANET_STRING:
         case JANET_KEYWORD:
@@ -518,11 +518,11 @@ static void janet_ffi_write_one(void *to, const Janet *argv, int32_t n, JanetFFI
         el_type.array_count = -1;
         size_t el_size = type_size(el_type);
         JanetView els = janet_getindexed(argv, n);
-        if (els.len != (size_t) type.array_count) {
+        if (els.len != type.array_count) {
             janet_panicf("bad array length, expected %d, got %d", type.array_count, els.len);
         }
         char *cursor = to;
-        for (size_t i = 0; i < els.len; i++) {
+        for (int32_t i = 0; i < els.len; i++) {
             janet_ffi_write_one(cursor, els.items, i, el_type, recur - 1);
             cursor += el_size;
         }
@@ -541,7 +541,7 @@ static void janet_ffi_write_one(void *to, const Janet *argv, int32_t n, JanetFFI
                 janet_panicf("wrong number of fields in struct, expected %d, got %d",
                              (int32_t) st->field_count, els.len);
             }
-            for (size_t i = 0; i < els.len; i++) {
+            for (int32_t i = 0; i < els.len; i++) {
                 JanetFFIType tp = st->fields[i].type;
                 janet_ffi_write_one((char *) to + st->fields[i].offset, els.items, i, tp, recur - 1);
             }
@@ -1308,7 +1308,7 @@ JANET_CORE_FN(cfun_ffi_jitfn,
     JanetByteView bytes = janet_getbytes(argv, 0);
 
     /* Quick hack to align to page boundary, we should query OS. FIXME */
-    size_t alloc_size = (bytes.len + FFI_PAGE_MASK) & ~FFI_PAGE_MASK;
+    size_t alloc_size = ((size_t) bytes.len + FFI_PAGE_MASK) & ~FFI_PAGE_MASK;
 
 #ifdef JANET_FFI_JIT
 #ifdef JANET_EV
@@ -1385,10 +1385,10 @@ JANET_CORE_FN(cfun_ffi_buffer_write,
     janet_sandbox_assert(JANET_SANDBOX_FFI_USE);
     janet_arity(argc, 2, 4);
     JanetFFIType type = decode_ffi_type(argv[0]);
-    size_t el_size = type_size(type);
+    uint32_t el_size = (uint32_t) type_size(type);
     JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, el_size);
-    size_t index = janet_optsize(argv, argc, 3, 0);
-    size_t old_count = buffer->count;
+    int32_t index = janet_optnat(argv, argc, 3, 0);
+    int32_t old_count = buffer->count;
     if (index > old_count) janet_panic("index out of bounds");
     buffer->count = index;
     janet_buffer_extra(buffer, el_size);
@@ -1408,14 +1408,14 @@ JANET_CORE_FN(cfun_ffi_buffer_read,
     janet_sandbox_assert(JANET_SANDBOX_FFI_USE);
     janet_arity(argc, 2, 3);
     JanetFFIType type = decode_ffi_type(argv[0]);
-    size_t offset = janet_optsize(argv, argc, 2, 0);
+    size_t offset = (size_t) janet_optnat(argv, argc, 2, 0);
     if (janet_checktype(argv[1], JANET_POINTER)) {
         uint8_t *ptr = janet_unwrap_pointer(argv[1]);
         return janet_ffi_read_one(ptr + offset, type, JANET_FFI_MAX_RECUR);
     } else {
         size_t el_size = type_size(type);
         JanetByteView bytes = janet_getbytes(argv, 1);
-        if (bytes.len < offset + el_size) janet_panic("read out of range");
+        if ((size_t) bytes.len < offset + el_size) janet_panic("read out of range");
         return janet_ffi_read_one(bytes.bytes + offset, type, JANET_FFI_MAX_RECUR);
     }
 }
@@ -1523,8 +1523,8 @@ JANET_CORE_FN(cfun_ffi_pointer_buffer,
     janet_sandbox_assert(JANET_SANDBOX_FFI_USE);
     janet_arity(argc, 2, 4);
     void *pointer = janet_getpointer(argv, 0);
-    size_t capacity = janet_getsize(argv, 1);
-    size_t count = janet_optsize(argv, argc, 2, 0);
+    int32_t capacity = janet_getnat(argv, 1);
+    int32_t count = janet_optnat(argv, argc, 2, 0);
     int64_t offset = janet_optinteger64(argv, argc, 3, 0);
     uint8_t *offset_pointer = ((uint8_t *) pointer) + offset;
     return janet_wrap_buffer(janet_pointer_buffer_unsafe(offset_pointer, capacity, count));

src/core/fiber.c

@@ -48,7 +48,7 @@ static void fiber_reset(JanetFiber *fiber) {
     janet_fiber_set_status(fiber, JANET_STATUS_NEW);
 }
 
-static JanetFiber *fiber_alloc(size_t capacity) {
+static JanetFiber *fiber_alloc(int32_t capacity) {
     Janet *data;
     JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber));
     if (capacity < 32) {
@@ -196,7 +196,7 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
     int32_t oldframe = fiber->frame;
     int32_t nextframe = fiber->stackstart;
     int32_t nextstacktop = nextframe + func->def->slotcount + JANET_FRAME_SIZE;
-    int32_t next_arity = (int32_t) fiber->stacktop - fiber->stackstart;
+    int32_t next_arity = fiber->stacktop - fiber->stackstart;
 
     /* Check strict arity before messing with state */
     if (next_arity < func->def->min_arity) return 1;
@@ -331,7 +331,7 @@ int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) {
     int32_t i;
     int32_t nextframetop = fiber->frame + func->def->slotcount;
     int32_t nextstacktop = nextframetop + JANET_FRAME_SIZE;
-    int32_t next_arity = (int32_t) fiber->stacktop - fiber->stackstart;
+    int32_t next_arity = fiber->stacktop - fiber->stackstart;
     int32_t stacksize;
 
     /* Check strict arity before messing with state */
@@ -516,10 +516,11 @@ JANET_CORE_FN(cfun_fiber_new,
         fiber->env = janet_gettable(argv, 2);
     }
     if (argc >= 2) {
+        int32_t i;
         JanetByteView view = janet_getbytes(argv, 1);
         fiber->flags = JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
         janet_fiber_set_status(fiber, JANET_STATUS_NEW);
-        for (size_t i = 0; i < view.len; i++) {
+        for (i = 0; i < view.len; i++) {
             if (view.bytes[i] >= '0' && view.bytes[i] <= '9') {
                 fiber->flags |= JANET_FIBER_MASK_USERN(view.bytes[i] - '0');
             } else {

src/core/gc.c

@@ -122,7 +122,7 @@ static void janet_mark_abstract(void *adata) {
 }
 
 /* Mark a bunch of items in memory */
-static void janet_mark_many(const Janet *values, size_t n) {
+static void janet_mark_many(const Janet *values, int32_t n) {
     if (values == NULL)
         return;
     const Janet *end = values + n;
@@ -262,7 +262,7 @@ static void janet_mark_function(JanetFunction *func) {
 }
 
 static void janet_mark_fiber(JanetFiber *fiber) {
-    size_t i, j;
+    int32_t i, j;
     JanetStackFrame *frame;
 recur:
     if (janet_gc_reachable(fiber))
@@ -481,7 +481,7 @@ void janet_sweep() {
 #ifdef JANET_EV
     /* Sweep threaded abstract types for references to decrement */
     JanetKV *items = janet_vm.threaded_abstracts.data;
-    for (size_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) {
+    for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) {
         if (janet_checktype(items[i].key, JANET_ABSTRACT)) {
 
             /* If item was not visited during the mark phase, then this
@@ -665,7 +665,7 @@ int janet_gcunrootall(Janet root) {
 void janet_clear_memory(void) {
 #ifdef JANET_EV
     JanetKV *items = janet_vm.threaded_abstracts.data;
-    for (size_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) {
+    for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) {
         if (janet_checktype(items[i].key, JANET_ABSTRACT)) {
             void *abst = janet_unwrap_abstract(items[i].key);
             if (0 == janet_abstract_decref(abst)) {

src/core/gc.h

@@ -64,7 +64,7 @@ enum JanetMemoryType {
 };
 
 /* To allocate collectable memory, one must call janet_alloc, initialize the memory,
- * and then call when janet_enablegc when it is initailize and reachable by the gc (on the JANET stack) */
+ * and then call when janet_enablegc when it is initialized and reachable by the gc (on the JANET stack) */
 void *janet_gcalloc(enum JanetMemoryType type, size_t size);
 
 #endif

src/core/inttypes.c

@@ -73,13 +73,13 @@ static void *int64_unmarshal(JanetMarshalContext *ctx) {
 
 static void it_s64_tostring(void *p, JanetBuffer *buffer) {
     char str[32];
-    sprintf(str, "%" PRId64, *((int64_t *)p));
+    snprintf(str, sizeof(str), "%" PRId64, *((int64_t *)p));
     janet_buffer_push_cstring(buffer, str);
 }
 
 static void it_u64_tostring(void *p, JanetBuffer *buffer) {
     char str[32];
-    sprintf(str, "%" PRIu64, *((uint64_t *)p));
+    snprintf(str, sizeof(str), "%" PRIu64, *((uint64_t *)p));
     janet_buffer_push_cstring(buffer, str);
 }
 

src/core/io.c

@@ -41,6 +41,11 @@ static void io_file_marshal(void *p, JanetMarshalContext *ctx);
 static void *io_file_unmarshal(JanetMarshalContext *ctx);
 static Janet io_file_next(void *p, Janet key);
 
+#ifdef JANET_WINDOWS
+#define ftell _ftelli64
+#define fseek _fseeki64
+#endif
+
 const JanetAbstractType janet_file_type = {
     "core/file",
     cfun_io_gc,
@@ -59,7 +64,8 @@ const JanetAbstractType janet_file_type = {
 /* Check arguments to fopen */
 static int32_t checkflags(const uint8_t *str) {
     int32_t flags = 0;
-    size_t len = janet_string_length(str);
+    int32_t i;
+    int32_t len = janet_string_length(str);
     if (!len || len > 10)
         janet_panic("file mode must have a length between 1 and 10");
     switch (*str) {
@@ -79,7 +85,7 @@ static int32_t checkflags(const uint8_t *str) {
             janet_sandbox_assert(JANET_SANDBOX_FS_READ);
             break;
     }
-    for (size_t i = 1; i < len; i++) {
+    for (i = 1; i < len; i++) {
         switch (str[i]) {
             default:
                 janet_panicf("invalid flag %c, expected +, b, or n", str[i]);
@@ -125,7 +131,7 @@ JANET_CORE_FN(cfun_io_temp,
     // XXX use mkostemp when we can to avoid CLOEXEC race.
     FILE *tmp = tmpfile();
     if (!tmp)
-        janet_panicf("unable to create temporary file - %s", strerror(errno));
+        janet_panicf("unable to create temporary file - %s", janet_strerror(errno));
     return janet_makefile(tmp, JANET_FILE_WRITE | JANET_FILE_READ | JANET_FILE_BINARY);
 }
 
@@ -167,7 +173,7 @@ JANET_CORE_FN(cfun_io_fopen,
         }
     }
     return f ? janet_makefile(f, flags)
-           : (flags & JANET_FILE_NONIL) ? (janet_panicf("failed to open file %s: %s", fname, strerror(errno)), janet_wrap_nil())
+           : (flags & JANET_FILE_NONIL) ? (janet_panicf("failed to open file %s: %s", fname, janet_strerror(errno)), janet_wrap_nil())
            : janet_wrap_nil();
 }
 
@@ -203,11 +209,11 @@ JANET_CORE_FN(cfun_io_fread,
     } else {
         buffer = janet_getbuffer(argv, 2);
     }
-    size_t bufstart = buffer->count;
+    int32_t bufstart = buffer->count;
     if (janet_checktype(argv[1], JANET_KEYWORD)) {
         const uint8_t *sym = janet_unwrap_keyword(argv[1]);
         if (!janet_cstrcmp(sym, "all")) {
-            size_t sizeBefore;
+            int32_t sizeBefore;
             do {
                 sizeBefore = buffer->count;
                 read_chunk(iof, buffer, 4096);
@@ -288,7 +294,7 @@ int janet_file_close(JanetFile *file) {
     if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) {
         ret = fclose(file->file);
         file->flags |= JANET_FILE_CLOSED;
-        file->file = NULL; /* NULL derefence is easier to debug then other problems */
+        file->file = NULL; /* NULL dereference is easier to debug then other problems */
         return ret;
     }
     return 0;
@@ -336,7 +342,7 @@ JANET_CORE_FN(cfun_io_fseek,
     JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
     if (iof->flags & JANET_FILE_CLOSED)
         janet_panic("file is closed");
-    long int offset = 0;
+    int64_t offset = 0;
     int whence = SEEK_CUR;
     if (argc >= 2) {
         const uint8_t *whence_sym = janet_getkeyword(argv, 1);
@@ -350,7 +356,7 @@ JANET_CORE_FN(cfun_io_fseek,
             janet_panicf("expected one of :cur, :set, :end, got %v", argv[1]);
         }
         if (argc == 3) {
-            offset = (long) janet_getinteger64(argv, 2);
+            offset = (int64_t) janet_getinteger64(argv, 2);
         }
     }
     if (fseek(iof->file, offset, whence)) janet_panic("error seeking file");
@@ -364,7 +370,7 @@ JANET_CORE_FN(cfun_io_ftell,
     JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
     if (iof->flags & JANET_FILE_CLOSED)
         janet_panic("file is closed");
-    long pos = ftell(iof->file);
+    int64_t pos = ftell(iof->file);
     if (pos == -1) janet_panic("error getting position in file");
     return janet_wrap_number((double)pos);
 }
@@ -488,7 +494,7 @@ static Janet cfun_io_print_impl_x(int32_t argc, Janet *argv, int newline,
         }
     }
     for (int32_t i = offset; i < argc; ++i) {
-        size_t len;
+        int32_t len;
         const uint8_t *vstr;
         if (janet_checktype(argv[i], JANET_BUFFER)) {
             JanetBuffer *b = janet_unwrap_buffer(argv[i]);

src/core/marsh.c

@@ -96,12 +96,12 @@ static Janet entry_getval(Janet env_entry) {
 /* Merge values from an environment into an existing lookup table. */
 void janet_env_lookup_into(JanetTable *renv, JanetTable *env, const char *prefix, int recurse) {
     while (env) {
-        for (size_t i = 0; i < env->capacity; i++) {
+        for (int32_t i = 0; i < env->capacity; i++) {
             if (janet_checktype(env->data[i].key, JANET_SYMBOL)) {
                 if (prefix) {
-                    size_t prelen = strlen(prefix);
+                    int32_t prelen = (int32_t) strlen(prefix);
                     const uint8_t *oldsym = janet_unwrap_symbol(env->data[i].key);
-                    size_t oldlen = janet_string_length(oldsym);
+                    int32_t oldlen = janet_string_length(oldsym);
                     uint8_t *symbuf = janet_smalloc(prelen + oldlen);
                     safe_memcpy(symbuf, prefix, prelen);
                     safe_memcpy(symbuf + prelen, oldsym, oldlen);
@@ -158,7 +158,7 @@ static void pushpointer(MarshalState *st, const void *ptr) {
     janet_buffer_push_bytes(st->buf, (const uint8_t *) &ptr, sizeof(ptr));
 }
 
-/* Marshal a uint64_t onto the buffer */
+/* Marshal a size_t onto the buffer */
 static void push64(MarshalState *st, uint64_t x) {
     if (x <= 0xF0) {
         /* Single byte */
@@ -176,11 +176,6 @@ static void push64(MarshalState *st, uint64_t x) {
     }
 }
 
-/* Marshal a size_t onto the buffer */
-static void pushsize(MarshalState *st, size_t x) {
-    push64(st, (uint64_t)x);
-}
-
 /* Forward declaration to enable mutual recursion. */
 static void marshal_one(MarshalState *st, Janet x, int flags);
 static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags);
@@ -194,7 +189,7 @@ static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags);
  * have no false positives, but may have false negatives. */
 static int fiber_cannot_be_marshalled(JanetFiber *fiber) {
     if (janet_fiber_status(fiber) == JANET_STATUS_ALIVE) return 1;
-    size_t i = fiber->frame;
+    int32_t i = fiber->frame;
     while (i > 0) {
         JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE);
         if (!frame->func) return 1; /* has cfunction on stack */
@@ -350,7 +345,7 @@ static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) {
         if (frame->env) frame->flags |= JANET_STACKFRAME_HASENV;
         if (!frame->func) janet_panicf("cannot marshal fiber with c stackframe (%v)", janet_wrap_cfunction((JanetCFunction) frame->pc));
         pushint(st, frame->flags);
-        pushsize(st, frame->prevframe);
+        pushint(st, frame->prevframe);
         int32_t pcdiff = (int32_t)(frame->pc - frame->func->def->bytecode);
         pushint(st, pcdiff);
         marshal_one(st, janet_wrap_function(frame->func), flags + 1);
@@ -500,7 +495,7 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
                 MARK_SEEN();
                 const uint8_t *regname = janet_unwrap_symbol(check);
                 pushbyte(st, LB_REGISTRY);
-                pushsize(st, janet_string_length(regname));
+                pushint(st, janet_string_length(regname));
                 pushbytes(st, regname, janet_string_length(regname));
                 return;
             }
@@ -540,14 +535,14 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
         case JANET_SYMBOL:
         case JANET_KEYWORD: {
             const uint8_t *str = janet_unwrap_string(x);
-            size_t length = janet_string_length(str);
+            int32_t length = janet_string_length(str);
             /* Record reference */
             MARK_SEEN();
             uint8_t lb = (type == JANET_STRING) ? LB_STRING :
                          (type == JANET_SYMBOL) ? LB_SYMBOL :
                          LB_KEYWORD;
             pushbyte(st, lb);
-            pushsize(st, length);
+            pushint(st, length);
             pushbytes(st, str, length);
             return;
         }
@@ -559,34 +554,34 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
             if ((flags & JANET_MARSHAL_UNSAFE) &&
                     (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) {
                 pushbyte(st, LB_POINTER_BUFFER);
-                pushsize(st, buffer->count);
-                pushsize(st, buffer->capacity);
+                pushint(st, buffer->count);
+                pushint(st, buffer->capacity);
                 pushpointer(st, buffer->data);
                 return;
             }
 #endif
             pushbyte(st, LB_BUFFER);
-            pushsize(st, buffer->count);
+            pushint(st, buffer->count);
             pushbytes(st, buffer->data, buffer->count);
             return;
         }
         case JANET_ARRAY: {
+            int32_t i;
             JanetArray *a = janet_unwrap_array(x);
             MARK_SEEN();
             pushbyte(st, LB_ARRAY);
-            pushsize(st, a->count);
-            for (size_t i = 0; i < a->count; i++)
+            pushint(st, a->count);
+            for (i = 0; i < a->count; i++)
                 marshal_one(st, a->data[i], flags + 1);
             return;
         }
         case JANET_TUPLE: {
-            size_t i, count;
-            int32_t flag;
+            int32_t i, count, flag;
             const Janet *tup = janet_unwrap_tuple(x);
             count = janet_tuple_length(tup);
             flag = janet_tuple_flag(tup) >> 16;
             pushbyte(st, LB_TUPLE);
-            pushsize(st, count);
+            pushint(st, count);
             pushint(st, flag);
             for (i = 0; i < count; i++)
                 marshal_one(st, tup[i], flags + 1);
@@ -598,10 +593,10 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
             JanetTable *t = janet_unwrap_table(x);
             MARK_SEEN();
             pushbyte(st, t->proto ? LB_TABLE_PROTO : LB_TABLE);
-            pushsize(st, t->count);
+            pushint(st, t->count);
             if (t->proto)
                 marshal_one(st, janet_wrap_table(t->proto), flags + 1);
-            for (size_t i = 0; i < t->capacity; i++) {
+            for (int32_t i = 0; i < t->capacity; i++) {
                 if (janet_checktype(t->data[i].key, JANET_NIL))
                     continue;
                 marshal_one(st, t->data[i].key, flags + 1);
@@ -610,14 +605,14 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
             return;
         }
         case JANET_STRUCT: {
-            size_t count;
+            int32_t count;
             const JanetKV *struct_ = janet_unwrap_struct(x);
             count = janet_struct_length(struct_);
             pushbyte(st, janet_struct_proto(struct_) ? LB_STRUCT_PROTO : LB_STRUCT);
-            pushsize(st, count);
+            pushint(st, count);
             if (janet_struct_proto(struct_))
                 marshal_one(st, janet_wrap_struct(janet_struct_proto(struct_)), flags + 1);
-            for (size_t i = 0; i < janet_struct_capacity(struct_); i++) {
+            for (int32_t i = 0; i < janet_struct_capacity(struct_); i++) {
                 if (janet_checktype(struct_[i].key, JANET_NIL))
                     continue;
                 marshal_one(st, struct_[i].key, flags + 1);
@@ -767,10 +762,6 @@ static uint64_t read64(UnmarshalState *st, const uint8_t **atdata) {
     return ret;
 }
 
-static size_t readsize(UnmarshalState *st, const uint8_t **atdata) {
-    return (size_t)read64(st, atdata);
-}
-
 #ifdef JANET_MARSHAL_DEBUG
 static void dump_reference_table(UnmarshalState *st) {
     for (int32_t i = 0; i < janet_v_count(st->lookup); i++) {
@@ -1091,7 +1082,7 @@ static const uint8_t *unmarshal_one_fiber(
     JanetTable *fiber_env = NULL;
 
     /* Check for bad flags and ints */
-    if ((frame + JANET_FRAME_SIZE) > fiber_stackstart ||
+    if ((int32_t)(frame + JANET_FRAME_SIZE) > fiber_stackstart ||
             fiber_stackstart > fiber_stacktop ||
             fiber_stacktop > fiber_maxstack) {
         janet_panic("fiber has incorrect stack setup");
@@ -1137,7 +1128,7 @@ static const uint8_t *unmarshal_one_fiber(
 
         /* Error checking */
         int32_t expected_framesize = def->slotcount;
-        if (expected_framesize != (int32_t) stacktop - stack) {
+        if (expected_framesize != stacktop - stack) {
             janet_panic("fiber stackframe size mismatch");
         }
         if (pcdiff >= def->bytecode_length) {
@@ -1364,7 +1355,7 @@ static const uint8_t *unmarshal_one(
         case LB_KEYWORD:
         case LB_REGISTRY: {
             data++;
-            size_t len = readsize(st, &data);
+            int32_t len = readnat(st, &data);
             MARSH_EOS(st, data - 1 + len);
             if (lead == LB_STRING) {
                 const uint8_t *str = janet_string(data, len);
@@ -1425,14 +1416,6 @@ static const uint8_t *unmarshal_one(
             return unmarshal_one_abstract(st, data, out, flags);
         }
         case LB_REFERENCE:
-        {
-            data++;
-            int32_t len = readnat(st, &data);
-            if (len >= janet_v_count(st->lookup))
-                    janet_panicf("invalid reference %d", len);
-            *out = st->lookup[len];
-            return data;
-        }
         case LB_ARRAY:
         case LB_TUPLE:
         case LB_STRUCT:
@@ -1442,7 +1425,7 @@ static const uint8_t *unmarshal_one(
             /* Things that open with integers */
         {
             data++;
-            size_t len = readsize(st, &data);
+            int32_t len = readnat(st, &data);
             /* DOS check */
             if (lead != LB_REFERENCE) {
                 MARSH_EOS(st, data - 1 + len);
@@ -1453,7 +1436,7 @@ static const uint8_t *unmarshal_one(
                 array->count = len;
                 *out = janet_wrap_array(array);
                 janet_v_push(st->lookup, *out);
-                for (size_t i = 0; i < len; i++) {
+                for (int32_t i = 0; i < len; i++) {
                     data = unmarshal_one(st, data, array->data + i, flags + 1);
                 }
             } else if (lead == LB_TUPLE) {
@@ -1461,7 +1444,7 @@ static const uint8_t *unmarshal_one(
                 Janet *tup = janet_tuple_begin(len);
                 int32_t flag = readint(st, &data);
                 janet_tuple_flag(tup) |= flag << 16;
-                for (size_t i = 0; i < len; i++) {
+                for (int32_t i = 0; i < len; i++) {
                     data = unmarshal_one(st, data, tup + i, flags + 1);
                 }
                 *out = janet_wrap_tuple(janet_tuple_end(tup));
@@ -1475,7 +1458,7 @@ static const uint8_t *unmarshal_one(
                     janet_asserttype(proto, JANET_STRUCT, st);
                     janet_struct_proto(struct_) = janet_unwrap_struct(proto);
                 }
-                for (size_t i = 0; i < len; i++) {
+                for (int32_t i = 0; i < len; i++) {
                     Janet key, value;
                     data = unmarshal_one(st, data, &key, flags + 1);
                     data = unmarshal_one(st, data, &value, flags + 1);
@@ -1483,6 +1466,10 @@ static const uint8_t *unmarshal_one(
                 }
                 *out = janet_wrap_struct(janet_struct_end(struct_));
                 janet_v_push(st->lookup, *out);
+            } else if (lead == LB_REFERENCE) {
+                if (len >= janet_v_count(st->lookup))
+                    janet_panicf("invalid reference %d", len);
+                *out = st->lookup[len];
             } else {
                 /* Table */
                 JanetTable *t = janet_table(len);
@@ -1494,7 +1481,7 @@ static const uint8_t *unmarshal_one(
                     janet_asserttype(proto, JANET_TABLE, st);
                     t->proto = janet_unwrap_table(proto);
                 }
-                for (size_t i = 0; i < len; i++) {
+                for (int32_t i = 0; i < len; i++) {
                     Janet key, value;
                     data = unmarshal_one(st, data, &key, flags + 1);
                     data = unmarshal_one(st, data, &value, flags + 1);
@@ -1524,8 +1511,8 @@ static const uint8_t *unmarshal_one(
 #ifdef JANET_EV
         case LB_POINTER_BUFFER: {
             data++;
-            size_t count = readsize(st, &data);
-            size_t capacity = readsize(st, &data);
+            int32_t count = readnat(st, &data);
+            int32_t capacity = readnat(st, &data);
             MARSH_EOS(st, data + sizeof(void *));
             union {
                 void *ptr;

src/core/math.c

@@ -81,9 +81,9 @@ void janet_rng_seed(JanetRNG *rng, uint32_t seed) {
     for (int i = 0; i < 16; i++) janet_rng_u32(rng);
 }
 
-void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, size_t len) {
+void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len) {
     uint8_t state[16] = {0};
-    for (size_t i = 0; i < len; i++)
+    for (int32_t i = 0; i < len; i++)
         state[i & 0xF] ^= bytes[i];
     rng->a = state[0] + (state[1] << 8) + (state[2] << 16) + (state[3] << 24);
     rng->b = state[4] + (state[5] << 8) + (state[6] << 16) + (state[7] << 24);
@@ -349,6 +349,26 @@ JANET_CORE_FN(janet_cfun_lcm, "(math/lcm x y)",
     return janet_wrap_number(janet_lcm(x, y));
 }
 
+JANET_CORE_FN(janet_cfun_frexp, "(math/frexp x)",
+              "Returns a tuple of (mantissa, exponent) from number.") {
+    janet_fixarity(argc, 1);
+    double x = janet_getnumber(argv, 0);
+    int exp;
+    x = frexp(x, &exp);
+    Janet *result = janet_tuple_begin(2);
+    result[0] = janet_wrap_number(x);
+    result[1] = janet_wrap_number((double) exp);
+    return janet_wrap_tuple(janet_tuple_end(result));
+}
+
+JANET_CORE_FN(janet_cfun_ldexp, "(math/ldexp m e)",
+              "Creates a new number from a mantissa and an exponent.") {
+    janet_fixarity(argc, 2);
+    double x = janet_getnumber(argv, 0);
+    int32_t y = janet_getinteger(argv, 1);
+    return janet_wrap_number(ldexp(x, y));
+}
+
 /* Module entry point */
 void janet_lib_math(JanetTable *env) {
     JanetRegExt math_cfuns[] = {
@@ -395,6 +415,8 @@ void janet_lib_math(JanetTable *env) {
         JANET_CORE_REG("math/next", janet_nextafter),
         JANET_CORE_REG("math/gcd", janet_cfun_gcd),
         JANET_CORE_REG("math/lcm", janet_cfun_lcm),
+        JANET_CORE_REG("math/frexp", janet_cfun_frexp),
+        JANET_CORE_REG("math/ldexp", janet_cfun_ldexp),
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, math_cfuns);

src/core/net.c

@@ -152,7 +152,7 @@ void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
         if (res == 0) {
             janet_schedule(fiber, janet_wrap_abstract(stream));
         } else {
-            janet_cancel(fiber, janet_cstringv(strerror(res)));
+            janet_cancel(fiber, janet_cstringv(janet_strerror(res)));
             stream->flags |= JANET_STREAM_TOCLOSE;
         }
     } else {
@@ -319,12 +319,13 @@ JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunctio
     NetStateAccept *state = janet_malloc(sizeof(NetStateAccept));
     memset(state, 0, sizeof(NetStateAccept));
     state->function = fun;
+    if (fun) janet_stream_level_triggered(stream);
     janet_async_start(stream, JANET_ASYNC_LISTEN_READ, net_callback_accept, state);
 }
 
 #endif
 
-/* Adress info */
+/* Address info */
 
 static int janet_get_sockettype(Janet *argv, int32_t argc, int32_t n) {
     JanetKeyword stype = janet_optkeyword(argv, argc, n, NULL);
@@ -1034,7 +1035,7 @@ JANET_CORE_FN(cfun_net_setsockopt,
 
     int r = setsockopt((JSock) stream->handle, st->level, st->optname, optval, optlen);
     if (r == -1) {
-        janet_panicf("setsockopt(%q): %s", argv[1], strerror(errno));
+        janet_panicf("setsockopt(%q): %s", argv[1], janet_strerror(errno));
     }
 
     return janet_wrap_nil();

src/core/os.c

@@ -38,6 +38,7 @@
 #include <string.h>
 #include <sys/stat.h>
 #include <signal.h>
+#include <locale.h>
 
 #ifdef JANET_BSD
 #include <sys/sysctl.h>
@@ -309,7 +310,7 @@ static EnvBlock os_execute_env(int32_t argc, const Janet *argv) {
     JanetDictView dict = janet_getdictionary(argv, 2);
 #ifdef JANET_WINDOWS
     JanetBuffer *temp = janet_buffer(10);
-    for (size_t i = 0; i < dict.cap; i++) {
+    for (int32_t i = 0; i < dict.cap; i++) {
         const JanetKV *kv = dict.kvs + i;
         if (!janet_checktype(kv->key, JANET_STRING)) continue;
         if (!janet_checktype(kv->value, JANET_STRING)) continue;
@@ -325,26 +326,26 @@ static EnvBlock os_execute_env(int32_t argc, const Janet *argv) {
     memcpy(ret, temp->data, temp->count);
     return ret;
 #else
-    char **envp = janet_smalloc(sizeof(char *) * (dict.len + 1));
+    char **envp = janet_smalloc(sizeof(char *) * ((size_t)dict.len + 1));
     int32_t j = 0;
-    for (size_t i = 0; i < dict.cap; i++) {
+    for (int32_t i = 0; i < dict.cap; i++) {
         const JanetKV *kv = dict.kvs + i;
         if (!janet_checktype(kv->key, JANET_STRING)) continue;
         if (!janet_checktype(kv->value, JANET_STRING)) continue;
         const uint8_t *keys = janet_unwrap_string(kv->key);
         const uint8_t *vals = janet_unwrap_string(kv->value);
-        size_t klen = janet_string_length(keys);
-        size_t vlen = janet_string_length(vals);
+        int32_t klen = janet_string_length(keys);
+        int32_t vlen = janet_string_length(vals);
         /* Check keys has no embedded 0s or =s. */
         int skip = 0;
-        for (size_t k = 0; k < klen; k++) {
+        for (int32_t k = 0; k < klen; k++) {
             if (keys[k] == '\0' || keys[k] == '=') {
                 skip = 1;
                 break;
             }
         }
         if (skip) continue;
-        char *envitem = janet_smalloc(klen + vlen + 2);
+        char *envitem = janet_smalloc((size_t) klen + (size_t) vlen + 2);
         memcpy(envitem, keys, klen);
         envitem[klen] = '=';
         memcpy(envitem + klen + 1, vals, vlen);
@@ -380,7 +381,7 @@ static void os_execute_cleanup(EnvBlock envp, const char **child_argv) {
  * a single string of this format. Returns a buffer that can be cast into a c string. */
 static JanetBuffer *os_exec_escape(JanetView args) {
     JanetBuffer *b = janet_buffer(0);
-    for (size_t i = 0; i < args.len; i++) {
+    for (int32_t i = 0; i < args.len; i++) {
         const char *arg = janet_getcstring(args.items, i);
 
         /* Push leading space if not first */
@@ -761,7 +762,7 @@ JANET_CORE_FN(os_proc_kill,
     }
     int status = kill(proc->pid, signal == -1 ? SIGKILL : signal);
     if (status) {
-        janet_panic(strerror(errno));
+        janet_panic(janet_strerror(errno));
     }
 #endif
     /* After killing process we wait on it. */
@@ -1246,8 +1247,8 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     /* Result */
     int status = 0;
 
-    const char **child_argv = janet_smalloc(sizeof(char *) * (exargs.len + 1));
-    for (size_t i = 0; i < exargs.len; i++)
+    const char **child_argv = janet_smalloc(sizeof(char *) * ((size_t) exargs.len + 1));
+    for (int32_t i = 0; i < exargs.len; i++)
         child_argv[i] = janet_getcstring(exargs.items, i);
     child_argv[exargs.len] = NULL;
     /* Coerce to form that works for spawn. I'm fairly confident no implementation
@@ -1274,7 +1275,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
                 status = execv(cargv[0], cargv);
             }
         } while (status == -1 && errno == EINTR);
-        janet_panicf("%p: %s", cargv[0], strerror(errno ? errno : ENOENT));
+        janet_panicf("%p: %s", cargv[0], janet_strerror(errno ? errno : ENOENT));
 #endif
     }
 
@@ -1331,7 +1332,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     os_execute_cleanup(envp, child_argv);
     if (status) {
         /* correct for macos bug where errno is not set */
-        janet_panicf("%p: %s", argv[0], strerror(errno ? errno : ENOENT));
+        janet_panicf("%p: %s", argv[0], janet_strerror(errno ? errno : ENOENT));
     }
 
 #endif
@@ -1412,7 +1413,7 @@ JANET_CORE_FN(os_spawn,
 JANET_CORE_FN(os_posix_exec,
               "(os/posix-exec args &opt flags env)",
               "Use the execvpe or execve system calls to replace the current process with an interface similar to os/execute. "
-              "Hoever, instead of creating a subprocess, the current process is replaced. Is not supported on windows, and "
+              "However, instead of creating a subprocess, the current process is replaced. Is not supported on windows, and "
               "does not allow redirection of stdio.") {
     return os_execute_impl(argc, argv, JANET_EXECUTE_EXEC);
 }
@@ -1432,7 +1433,7 @@ JANET_CORE_FN(os_posix_fork,
         result = fork();
     } while (result == -1 && errno == EINTR);
     if (result == -1) {
-        janet_panic(strerror(errno));
+        janet_panic(janet_strerror(errno));
     }
     if (result) {
         JanetProc *proc = janet_abstract(&ProcAT, sizeof(JanetProc));
@@ -1644,7 +1645,7 @@ JANET_CORE_FN(os_isatty,
     return janet_wrap_boolean(_isatty(fd));
 #else
     int fd = fileno(f);
-    if (fd == -1) janet_panic(strerror(errno));
+    if (fd == -1) janet_panic(janet_strerror(errno));
     return janet_wrap_boolean(isatty(fd));
 #endif
 }
@@ -1670,8 +1671,9 @@ JANET_CORE_FN(os_cryptorand,
               "Get or append `n` bytes of good quality random data provided by the OS. Returns a new buffer or `buf`.") {
     JanetBuffer *buffer;
     janet_arity(argc, 1, 2);
-    size_t offset;
-    size_t n = janet_getsize(argv, 0);
+    int32_t offset;
+    int32_t n = janet_getinteger(argv, 0);
+    if (n < 0) janet_panic("expected positive integer");
     if (argc == 2) {
         buffer = janet_getbuffer(argv, 1);
         offset = buffer->count;
@@ -1878,7 +1880,7 @@ JANET_CORE_FN(os_mktime,
     }
 
     if (t == (time_t) -1) {
-        janet_panicf("%s", strerror(errno));
+        janet_panicf("%s", janet_strerror(errno));
     }
 
     return janet_wrap_number((double)t);
@@ -1890,6 +1892,43 @@ JANET_CORE_FN(os_mktime,
 #define j_symlink symlink
 #endif
 
+JANET_CORE_FN(os_setlocale,
+              "(os/setlocale &opt locale category)",
+              "Set the system locale, which affects how dates and numbers are formatted. "
+              "Passing nil to locale will return the current locale. Category can be one of:\n\n"
+              " * :all (default)\n"
+              " * :collate\n"
+              " * :ctype\n"
+              " * :monetary\n"
+              " * :numeric\n"
+              " * :time\n\n"
+              "Returns the new locale if set successfully, otherwise nil. Note that this will affect "
+              "other functions such as `os/strftime` and even `printf`.") {
+    janet_arity(argc, 0, 2);
+    const char *locale_name = janet_optcstring(argv, argc, 0, NULL);
+    int category_int = LC_ALL;
+    if (argc > 1 && !janet_checktype(argv[1], JANET_NIL)) {
+        if (janet_keyeq(argv[1], "all")) {
+            category_int = LC_ALL;
+        } else if (janet_keyeq(argv[1], "collate")) {
+            category_int = LC_COLLATE;
+        } else if (janet_keyeq(argv[1], "ctype")) {
+            category_int = LC_CTYPE;
+        } else if (janet_keyeq(argv[1], "monetary")) {
+            category_int = LC_MONETARY;
+        } else if (janet_keyeq(argv[1], "numeric")) {
+            category_int = LC_NUMERIC;
+        } else if (janet_keyeq(argv[1], "time")) {
+            category_int = LC_TIME;
+        } else {
+            janet_panicf("expected one of :all, :collate, :ctype, :monetary, :numeric, or :time, got %v", argv[1]);
+        }
+    }
+    const char *old = setlocale(category_int, locale_name);
+    if (old == NULL) return janet_wrap_nil();
+    return janet_cstringv(old);
+}
+
 JANET_CORE_FN(os_link,
               "(os/link oldpath newpath &opt symlink)",
               "Create a link at newpath that points to oldpath and returns nil. "
@@ -1907,7 +1946,7 @@ JANET_CORE_FN(os_link,
     const char *oldpath = janet_getcstring(argv, 0);
     const char *newpath = janet_getcstring(argv, 1);
     int res = ((argc == 3 && janet_truthy(argv[2])) ? j_symlink : link)(oldpath, newpath);
-    if (-1 == res) janet_panicf("%s: %s -> %s", strerror(errno), oldpath, newpath);
+    if (-1 == res) janet_panicf("%s: %s -> %s", janet_strerror(errno), oldpath, newpath);
     return janet_wrap_nil();
 #endif
 }
@@ -1926,7 +1965,7 @@ JANET_CORE_FN(os_symlink,
     const char *oldpath = janet_getcstring(argv, 0);
     const char *newpath = janet_getcstring(argv, 1);
     int res = j_symlink(oldpath, newpath);
-    if (-1 == res) janet_panicf("%s: %s -> %s", strerror(errno), oldpath, newpath);
+    if (-1 == res) janet_panicf("%s: %s -> %s", janet_strerror(errno), oldpath, newpath);
     return janet_wrap_nil();
 #endif
 }
@@ -1948,7 +1987,7 @@ JANET_CORE_FN(os_mkdir,
 #endif
     if (res == 0) return janet_wrap_true();
     if (errno == EEXIST) return janet_wrap_false();
-    janet_panicf("%s: %s", strerror(errno), path);
+    janet_panicf("%s: %s", janet_strerror(errno), path);
 }
 
 JANET_CORE_FN(os_rmdir,
@@ -1962,7 +2001,7 @@ JANET_CORE_FN(os_rmdir,
 #else
     int res = rmdir(path);
 #endif
-    if (-1 == res) janet_panicf("%s: %s", strerror(errno), path);
+    if (-1 == res) janet_panicf("%s: %s", janet_strerror(errno), path);
     return janet_wrap_nil();
 }
 
@@ -1977,7 +2016,7 @@ JANET_CORE_FN(os_cd,
 #else
     int res = chdir(path);
 #endif
-    if (-1 == res) janet_panicf("%s: %s", strerror(errno), path);
+    if (-1 == res) janet_panicf("%s: %s", janet_strerror(errno), path);
     return janet_wrap_nil();
 }
 
@@ -2001,7 +2040,7 @@ JANET_CORE_FN(os_touch,
         bufp = NULL;
     }
     int res = utime(path, bufp);
-    if (-1 == res) janet_panic(strerror(errno));
+    if (-1 == res) janet_panic(janet_strerror(errno));
     return janet_wrap_nil();
 }
 
@@ -2011,7 +2050,7 @@ JANET_CORE_FN(os_remove,
     janet_fixarity(argc, 1);
     const char *path = janet_getcstring(argv, 0);
     int status = remove(path);
-    if (-1 == status) janet_panicf("%s: %s", strerror(errno), path);
+    if (-1 == status) janet_panicf("%s: %s", janet_strerror(errno), path);
     return janet_wrap_nil();
 }
 
@@ -2030,7 +2069,7 @@ JANET_CORE_FN(os_readlink,
     const char *path = janet_getcstring(argv, 0);
     ssize_t len = readlink(path, buffer, sizeof buffer);
     if (len < 0 || (size_t)len >= sizeof buffer)
-        janet_panicf("%s: %s", strerror(errno), path);
+        janet_panicf("%s: %s", janet_strerror(errno), path);
     return janet_stringv((const uint8_t *)buffer, len);
 #endif
 }
@@ -2325,7 +2364,7 @@ JANET_CORE_FN(os_chmod,
 #else
     int res = chmod(path, os_getmode(argv, 1));
 #endif
-    if (-1 == res) janet_panicf("%s: %s", strerror(errno), path);
+    if (-1 == res) janet_panicf("%s: %s", janet_strerror(errno), path);
     return janet_wrap_nil();
 }
 
@@ -2361,7 +2400,7 @@ JANET_CORE_FN(os_dir,
         janet_panicf("path too long: %s", dir);
     sprintf(pattern, "%s/*", dir);
     intptr_t res = _findfirst(pattern, &afile);
-    if (-1 == res) janet_panicv(janet_cstringv(strerror(errno)));
+    if (-1 == res) janet_panicv(janet_cstringv(janet_strerror(errno)));
     do {
         if (strcmp(".", afile.name) && strcmp("..", afile.name)) {
             janet_array_push(paths, janet_cstringv(afile.name));
@@ -2372,8 +2411,18 @@ JANET_CORE_FN(os_dir,
     /* Read directory items with opendir / readdir / closedir */
     struct dirent *dp;
     DIR *dfd = opendir(dir);
-    if (dfd == NULL) janet_panicf("cannot open directory %s", dir);
-    while ((dp = readdir(dfd)) != NULL) {
+    if (dfd == NULL) janet_panicf("cannot open directory %s: %s", dir, janet_strerror(errno));
+    for (;;) {
+        errno = 0;
+        dp = readdir(dfd);
+        if (dp == NULL) {
+            if (errno) {
+                int olderr = errno;
+                closedir(dfd);
+                janet_panicf("failed to read directory %s: %s", dir, janet_strerror(olderr));
+            }
+            break;
+        }
         if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
             continue;
         }
@@ -2393,7 +2442,7 @@ JANET_CORE_FN(os_rename,
     const char *dest = janet_getcstring(argv, 1);
     int status = rename(src, dest);
     if (status) {
-        janet_panic(strerror(errno));
+        janet_panic(janet_strerror(errno));
     }
     return janet_wrap_nil();
 }
@@ -2413,7 +2462,7 @@ JANET_CORE_FN(os_realpath,
 #else
     char *dest = realpath(src, NULL);
 #endif
-    if (NULL == dest) janet_panicf("%s: %s", strerror(errno), src);
+    if (NULL == dest) janet_panicf("%s: %s", janet_strerror(errno), src);
     Janet ret = janet_cstringv(dest);
     janet_free(dest);
     return ret;
@@ -2619,7 +2668,7 @@ JANET_CORE_FN(os_open,
     } else if (write_flag && !read_flag) {
         open_flags |= O_WRONLY;
     } else {
-        open_flags = O_RDWR;
+        open_flags |= O_RDWR;
     }
 
     do {
@@ -2687,6 +2736,7 @@ void janet_lib_os(JanetTable *env) {
         JANET_CORE_REG("os/strftime", os_strftime),
         JANET_CORE_REG("os/sleep", os_sleep),
         JANET_CORE_REG("os/isatty", os_isatty),
+        JANET_CORE_REG("os/setlocale", os_setlocale),
 
         /* env functions */
         JANET_CORE_REG("os/environ", os_environ),

src/core/parse.c

@@ -59,11 +59,11 @@ int janet_is_symbol_char(uint8_t c) {
 /* Validate some utf8. Useful for identifiers. Only validates
  * the encoding, does not check for valid code points (they
  * are less well defined than the encoding). */
-int janet_valid_utf8(const uint8_t *str, size_t len) {
-    size_t i = 0;
-    size_t j;
+int janet_valid_utf8(const uint8_t *str, int32_t len) {
+    int32_t i = 0;
+    int32_t j;
     while (i < len) {
-        size_t nexti;
+        int32_t nexti;
         uint8_t c = str[i];
 
         /* Check the number of bytes in code point */
@@ -434,8 +434,8 @@ static int stringchar(JanetParser *p, JanetParseState *state, uint8_t c) {
 }
 
 /* Check for string equality in the buffer */
-static int check_str_const(const char *cstr, const uint8_t *str, size_t len) {
-    size_t index;
+static int check_str_const(const char *cstr, const uint8_t *str, int32_t len) {
+    int32_t index;
     for (index = 0; index < len; index++) {
         uint8_t c = str[index];
         uint8_t k = ((const uint8_t *)cstr)[index];
@@ -449,14 +449,14 @@ static int check_str_const(const char *cstr, const uint8_t *str, size_t len) {
 static int tokenchar(JanetParser *p, JanetParseState *state, uint8_t c) {
     Janet ret;
     double numval;
-    size_t blen;
+    int32_t blen;
     if (janet_is_symbol_char(c)) {
         push_buf(p, (uint8_t) c);
         if (c > 127) state->argn = 1; /* Use to indicate non ascii */
         return 1;
     }
     /* Token finished */
-    blen = p->bufcount;
+    blen = (int32_t) p->bufcount;
     int start_dig = p->buf[0] >= '0' && p->buf[0] <= '9';
     int start_num = start_dig || p->buf[0] == '-' || p->buf[0] == '+' || p->buf[0] == '.';
     if (p->buf[0] == ':') {
@@ -920,13 +920,13 @@ JANET_CORE_FN(cfun_parse_consume,
     JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
     JanetByteView view = janet_getbytes(argv, 1);
     if (argc == 3) {
-        size_t offset = janet_getsize(argv, 2);
-        if (offset > view.len)
+        int32_t offset = janet_getinteger(argv, 2);
+        if (offset < 0 || offset > view.len)
             janet_panicf("invalid offset %d out of range [0,%d]", offset, view.len);
         view.len -= offset;
         view.bytes += offset;
     }
-    size_t i;
+    int32_t i;
     for (i = 0; i < view.len; i++) {
         janet_parser_consume(p, view.bytes[i]);
         switch (janet_parser_status(p)) {
@@ -934,10 +934,10 @@ JANET_CORE_FN(cfun_parse_consume,
             case JANET_PARSE_PENDING:
                 break;
             default:
-                return janet_wrap_size(i + 1);
+                return janet_wrap_integer(i + 1);
         }
     }
-    return janet_wrap_size(i);
+    return janet_wrap_integer(i);
 }
 
 JANET_CORE_FN(cfun_parse_eof,
@@ -974,7 +974,7 @@ JANET_CORE_FN(cfun_parse_insert,
         }
     } else if (s->flags & (PFLAG_STRING | PFLAG_LONGSTRING)) {
         const uint8_t *str = janet_to_string(argv[1]);
-        size_t slen = janet_string_length(str);
+        int32_t slen = janet_string_length(str);
         size_t newcount = p->bufcount + slen;
         if (p->bufcap < newcount) {
             size_t newcap = 2 * newcount;

src/core/peg.c

@@ -65,9 +65,9 @@ typedef struct {
  * to save state at branches, and then reload
  * if one branch fails and try a new branch. */
 typedef struct {
-    size_t cap;
-    size_t tcap;
-    size_t scratch;
+    int32_t cap;
+    int32_t tcap;
+    int32_t scratch;
 } CapState;
 
 /* Save the current capture state */
@@ -134,7 +134,7 @@ static LineCol get_linecol_from_position(PegState *s, int32_t position) {
      *   a newline character is consider to be on the same line as the character before
      *   (\n is line terminator, not line separator).
      * - in the not-found case, we still want to find the greatest-indexed newline that
-     *   is before position. we use that to calcuate the line and column.
+     *   is before position. we use that to calculate the line and column.
      * - in the case that lo = 0 and s->linemap[0] is still greater than position, we
      *   are on the first line and our column is position + 1. */
     int32_t hi = s->linemaplen; /* hi is greater than the actual line */
@@ -423,10 +423,10 @@ tail:
             /* check number parsing */
             double x = 0.0;
             int32_t base = (int32_t) rule[2];
-            if (janet_scan_number_base(text, (size_t)(result - text), base, &x)) return NULL;
+            if (janet_scan_number_base(text, (int32_t)(result - text), base, &x)) return NULL;
             /* Specialized pushcap - avoid intermediate string creation */
             if (!s->has_backref && s->mode == PEG_MODE_ACCUMULATE) {
-                janet_buffer_push_bytes(s->scratch, text, (size_t)(result - text));
+                janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text));
             } else {
                 uint32_t tag = rule[3];
                 pushcap(s, janet_wrap_number(x), tag);
@@ -597,7 +597,7 @@ tail:
         case RULE_ERROR: {
             int oldmode = s->mode;
             s->mode = PEG_MODE_NORMAL;
-            size_t old_cap = s->captures->count;
+            int32_t old_cap = s->captures->count;
             down1(s);
             const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
             up1(s);
@@ -667,11 +667,11 @@ tail:
         case RULE_READINT: {
             uint32_t tag = rule[2];
             uint32_t signedness = rule[1] & 0x10;
-            uint32_t endianess = rule[1] & 0x20;
+            uint32_t endianness = rule[1] & 0x20;
             int width = (int)(rule[1] & 0xF);
             if (text + width > s->text_end) return NULL;
             uint64_t accum = 0;
-            if (endianess) {
+            if (endianness) {
                 /* BE */
                 for (int i = 0; i < width; i++) accum = (accum << 8) | text[i];
             } else {
@@ -925,7 +925,7 @@ static void spec_set(Builder *b, int32_t argc, const Janet *argv) {
     Reserve r = reserve(b, 9);
     const uint8_t *str = peg_getset(b, argv[0]);
     uint32_t bitmap[8] = {0};
-    for (size_t i = 0; i < janet_string_length(str); i++)
+    for (int32_t i = 0; i < janet_string_length(str); i++)
         bitmap_set(bitmap, str[i]);
     emit_rule(r, RULE_SET, 8, bitmap);
 }
@@ -1384,7 +1384,7 @@ static uint32_t peg_compile1(Builder *b, Janet peg) {
             /* Build grammar table */
             const JanetKV *st = janet_unwrap_struct(peg);
             JanetTable *new_grammar = janet_table(2 * janet_struct_capacity(st));
-            for (size_t i = 0; i < janet_struct_capacity(st); i++) {
+            for (int32_t i = 0; i < janet_struct_capacity(st); i++) {
                 if (janet_checktype(st[i].key, JANET_KEYWORD)) {
                     janet_table_put(new_grammar, st[i].key, st[i].value);
                 }
@@ -1628,7 +1628,7 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                 i += 2;
                 break;
             case RULE_READINT:
-                /* [ width | (endianess << 5) | (signedness << 6), tag ] */
+                /* [ width | (endianness << 5) | (signedness << 6), tag ] */
                 if (rule[1] > JANET_MAX_READINT_WIDTH) goto bad;
                 i += 3;
                 break;
@@ -1725,7 +1725,7 @@ static JanetPeg *compile_peg(Janet x) {
 JANET_CORE_FN(cfun_peg_compile,
               "(peg/compile peg)",
               "Compiles a peg source data structure into a <core/peg>. This will speed up matching "
-              "if the same peg will be used multiple times. Will also use `(dyn :peg-grammar)` to suppliment "
+              "if the same peg will be used multiple times. Will also use `(dyn :peg-grammar)` to supplement "
               "the grammar of the peg for otherwise undefined peg keywords.") {
     janet_fixarity(argc, 1);
     JanetPeg *peg = compile_peg(argv[0]);
@@ -1805,7 +1805,7 @@ JANET_CORE_FN(cfun_peg_find,
               "(peg/find peg text &opt start & args)",
               "Find first index where the peg matches in text. Returns an integer, or nil if not found.") {
     PegCall c = peg_cfun_init(argc, argv, 0);
-    for (size_t i = c.start; i < c.bytes.len; i++) {
+    for (int32_t i = c.start; i < c.bytes.len; i++) {
         peg_call_reset(&c);
         if (peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i))
             return janet_wrap_integer(i);
@@ -1818,7 +1818,7 @@ JANET_CORE_FN(cfun_peg_find_all,
               "Find all indexes where the peg matches in text. Returns an array of integers.") {
     PegCall c = peg_cfun_init(argc, argv, 0);
     JanetArray *ret = janet_array(0);
-    for (size_t i = c.start; i < c.bytes.len; i++) {
+    for (int32_t i = c.start; i < c.bytes.len; i++) {
         peg_call_reset(&c);
         if (peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i))
             janet_array_push(ret, janet_wrap_integer(i));
@@ -1829,8 +1829,8 @@ JANET_CORE_FN(cfun_peg_find_all,
 static Janet cfun_peg_replace_generic(int32_t argc, Janet *argv, int only_one) {
     PegCall c = peg_cfun_init(argc, argv, 1);
     JanetBuffer *ret = janet_buffer(0);
-    size_t trail = 0;
-    for (size_t i = c.start; i < c.bytes.len;) {
+    int32_t trail = 0;
+    for (int32_t i = c.start; i < c.bytes.len;) {
         peg_call_reset(&c);
         const uint8_t *result = peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i);
         if (NULL != result) {
@@ -1838,7 +1838,7 @@ static Janet cfun_peg_replace_generic(int32_t argc, Janet *argv, int only_one) {
                 janet_buffer_push_bytes(ret, c.bytes.bytes + trail, (i - trail));
                 trail = i;
             }
-            size_t nexti = (size_t)(result - c.bytes.bytes);
+            int32_t nexti = (int32_t)(result - c.bytes.bytes);
             JanetByteView subst = janet_text_substitution(&c.subst, c.bytes.bytes + i, nexti - i, c.s.captures);
             janet_buffer_push_bytes(ret, subst.bytes, subst.len);
             trail = nexti;

src/core/pp.c

@@ -134,9 +134,9 @@ static void string_description_b(JanetBuffer *buffer, const char *title, void *p
 #undef POINTSIZE
 }
 
-static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, size_t len) {
+static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) {
     janet_buffer_push_u8(buffer, '"');
-    for (size_t i = 0; i < len; ++i) {
+    for (int32_t i = 0; i < len; ++i) {
         uint8_t c = str[i];
         switch (c) {
             case '"':
@@ -279,10 +279,10 @@ void janet_to_string_b(JanetBuffer *buffer, Janet x) {
 
 /* Check if a symbol or keyword contains no symbol characters */
 static int contains_bad_chars(const uint8_t *sym, int issym) {
-    size_t len = janet_string_length(sym);
+    int32_t len = janet_string_length(sym);
     if (len && issym && sym[0] >= '0' && sym[0] <= '9') return 1;
     if (!janet_valid_utf8(sym, len)) return 1;
-    for (size_t i = 0; i < len; i++) {
+    for (int32_t i = 0; i < len; i++) {
         if (!janet_is_symbol_char(sym[i])) return 1;
     }
     return 0;
@@ -379,8 +379,10 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             break;
         case JANET_NUMBER:
             janet_buffer_ensure(S->buffer, S->buffer->count + BUFSIZE, 2);
-            int count = snprintf((char *) S->buffer->data + S->buffer->count, BUFSIZE, "%.17g", janet_unwrap_number(x));
-            S->buffer->count += count;
+            double num = janet_unwrap_number(x);
+            if (isnan(num)) return 1;
+            if (isinf(num)) return 1;
+            janet_buffer_dtostr(S->buffer, num);
             break;
         case JANET_SYMBOL:
         case JANET_KEYWORD:
@@ -391,7 +393,7 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             JanetTuple t = janet_unwrap_tuple(x);
             int isb = janet_tuple_flag(t) & JANET_TUPLE_FLAG_BRACKETCTOR;
             janet_buffer_push_u8(S->buffer, isb ? '[' : '(');
-            for (size_t i = 0; i < janet_tuple_length(t); i++) {
+            for (int32_t i = 0; i < janet_tuple_length(t); i++) {
                 if (i) janet_buffer_push_u8(S->buffer, ' ');
                 if (print_jdn_one(S, t[i], depth - 1)) return 1;
             }
@@ -402,7 +404,7 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             janet_table_put(&S->seen, x, janet_wrap_true());
             JanetArray *a = janet_unwrap_array(x);
             janet_buffer_push_cstring(S->buffer, "@[");
-            for (size_t i = 0; i < a->count; i++) {
+            for (int32_t i = 0; i < a->count; i++) {
                 if (i) janet_buffer_push_u8(S->buffer, ' ');
                 if (print_jdn_one(S, a->data[i], depth - 1)) return 1;
             }
@@ -414,7 +416,7 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             JanetTable *tab = janet_unwrap_table(x);
             janet_buffer_push_cstring(S->buffer, "@{");
             int isFirst = 1;
-            for (size_t i = 0; i < tab->capacity; i++) {
+            for (int32_t i = 0; i < tab->capacity; i++) {
                 const JanetKV *kv = tab->data + i;
                 if (janet_checktype(kv->key, JANET_NIL)) continue;
                 if (!isFirst) janet_buffer_push_u8(S->buffer, ' ');
@@ -430,7 +432,7 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             JanetStruct st = janet_unwrap_struct(x);
             janet_buffer_push_u8(S->buffer, '{');
             int isFirst = 1;
-            for (size_t i = 0; i < janet_struct_capacity(st); i++) {
+            for (int32_t i = 0; i < janet_struct_capacity(st); i++) {
                 const JanetKV *kv = st + i;
                 if (janet_checktype(kv->key, JANET_NIL)) continue;
                 if (!isFirst) janet_buffer_push_u8(S->buffer, ' ');
@@ -536,7 +538,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
         }
         case JANET_ARRAY:
         case JANET_TUPLE: {
-            size_t i = 0, len = 0;
+            int32_t i = 0, len = 0;
             const Janet *arr = NULL;
             int isarray = janet_checktype(x, JANET_ARRAY);
             janet_indexed_view(x, &arr, &len);
@@ -587,7 +589,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                 if (NULL != proto) {
                     Janet name = janet_table_get(proto, janet_ckeywordv("_name"));
                     const uint8_t *n;
-                    size_t len;
+                    int32_t len;
                     if (janet_bytes_view(name, &n, &len)) {
                         if (S->flags & JANET_PRETTY_COLOR) {
                             janet_buffer_push_cstring(S->buffer, janet_class_color);
@@ -604,7 +606,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                 if (NULL != proto) {
                     Janet name = janet_struct_get(proto, janet_ckeywordv("_name"));
                     const uint8_t *n;
-                    size_t len;
+                    int32_t len;
                     if (janet_bytes_view(name, &n, &len)) {
                         if (S->flags & JANET_PRETTY_COLOR) {
                             janet_buffer_push_cstring(S->buffer, janet_class_color);
@@ -623,7 +625,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
             if (S->depth == 0) {
                 janet_buffer_push_cstring(S->buffer, "...");
             } else {
-                size_t i = 0, len = 0, cap = 0;
+                int32_t i = 0, len = 0, cap = 0;
                 const JanetKV *kvs = NULL;
                 janet_dictionary_view(x, &kvs, &len, &cap);
                 if (!istable && !(S->flags & JANET_PRETTY_ONELINE) && len >= JANET_PRETTY_DICT_ONELINE)
@@ -830,7 +832,7 @@ static const char *scanformat(
         if (loc != NULL && *loc != '\0') {
             const char *mapping = get_fmt_mapping(*p2++);
             size_t len = strlen(mapping);
-            strcpy(form, mapping);
+            memcpy(form, mapping, len);
             form += len;
         } else {
             *(form++) = *(p2++);
@@ -895,13 +897,13 @@ void janet_formatbv(JanetBuffer *b, const char *format, va_list args) {
                 case 's':
                 case 'S': {
                     const char *str = va_arg(args, const char *);
-                    size_t len = c[-1] == 's'
-                                  ? strlen(str)
+                    int32_t len = c[-1] == 's'
+                                  ? (int32_t) strlen(str)
                                   : janet_string_length((JanetString) str);
                     if (form[2] == '\0')
                         janet_buffer_push_bytes(b, (const uint8_t *) str, len);
                     else {
-                        if (len != strlen((const char *) str))
+                        if (len != (int32_t) strlen((const char *) str))
                             janet_panic("string contains zeros");
                         if (!strchr(form, '.') && len >= 100) {
                             janet_panic("no precision and string is too long to be formatted");

src/core/run.c

@@ -27,10 +27,10 @@
 #endif
 
 /* Run a string */
-int janet_dobytes(JanetTable *env, const uint8_t *bytes, size_t len, const char *sourcePath, Janet *out) {
+int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char *sourcePath, Janet *out) {
     JanetParser parser;
     int errflags = 0, done = 0;
-    size_t index = 0;
+    int32_t index = 0;
     Janet ret = janet_wrap_nil();
     JanetFiber *fiber = NULL;
     const uint8_t *where = sourcePath ? janet_cstring(sourcePath) : NULL;
@@ -128,7 +128,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, size_t len, const char
 }
 
 int janet_dostring(JanetTable *env, const char *str, const char *sourcePath, Janet *out) {
-    size_t len = 0;
+    int32_t len = 0;
     while (str[len]) ++len;
     return janet_dobytes(env, (const uint8_t *)str, len, sourcePath, out);
 }

src/core/specials.c

@@ -72,7 +72,7 @@ static JanetSlot quasiquote(JanetFopts opts, Janet x, int depth, int level) {
         default:
             return janetc_cslot(x);
         case JANET_TUPLE: {
-            size_t i, len;
+            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)) {
@@ -96,15 +96,16 @@ static JanetSlot quasiquote(JanetFopts opts, Janet x, int depth, int level) {
                             : JOP_MAKE_TUPLE);
         }
         case JANET_ARRAY: {
+            int32_t i;
             JanetArray *array = janet_unwrap_array(x);
-            for (size_t i = 0; i < array->count; i++)
+            for (i = 0; i < array->count; i++)
                 janet_v_push(slots, quasiquote(subopts, array->data[i], depth - 1, level));
             return qq_slots(opts, slots, JOP_MAKE_ARRAY);
         }
         case JANET_TABLE:
         case JANET_STRUCT: {
             const JanetKV *kv = NULL, *kvs = NULL;
-            size_t len, cap = 0;
+            int32_t len, cap = 0;
             janet_dictionary_view(x, &kvs, &len, &cap);
             while ((kv = janet_dictionary_next(kvs, cap, kv))) {
                 JanetSlot key = quasiquote(subopts, kv->key, depth - 1, level);
@@ -155,10 +156,10 @@ static int destructure(JanetCompiler *c,
             return leaf(c, janet_unwrap_symbol(left), right, attr);
         case JANET_TUPLE:
         case JANET_ARRAY: {
-            size_t len = 0;
+            int32_t len = 0;
             const Janet *values = NULL;
             janet_indexed_view(left, &values, &len);
-            for (size_t i = 0; i < len; i++) {
+            for (int32_t i = 0; i < len; i++) {
                 JanetSlot nextright = janetc_farslot(c);
                 Janet subval = values[i];
 
@@ -169,11 +170,11 @@ static int destructure(JanetCompiler *c,
                     }
 
                     if (i + 2 < len) {
-                        size_t num_extra = len - i - 1;
+                        int32_t num_extra = len - i - 1;
                         Janet *extra = janet_tuple_begin(num_extra);
                         janet_tuple_flag(extra) |= JANET_TUPLE_FLAG_BRACKETCTOR;
 
-                        for (size_t j = 0; j < num_extra; ++j) {
+                        for (int32_t j = 0; j < num_extra; ++j) {
                             extra[j] = values[j + i + 1];
                         }
 
@@ -236,9 +237,9 @@ static int destructure(JanetCompiler *c,
         case JANET_TABLE:
         case JANET_STRUCT: {
             const JanetKV *kvs = NULL;
-            size_t cap = 0, len = 0;
+            int32_t cap = 0, len = 0;
             janet_dictionary_view(left, &kvs, &len, &cap);
-            for (size_t i = 0; i < cap; i++) {
+            for (int32_t 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);
@@ -361,7 +362,7 @@ SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopt
         janet_indexed_view(lhs, &view_lhs.items, &view_lhs.len);
         janet_indexed_view(rhs, &view_rhs.items, &view_rhs.len);
         int found_amp = 0;
-        for (size_t i = 0; i < view_lhs.len; i++) {
+        for (int32_t i = 0; i < view_lhs.len; i++) {
             if (janet_symeq(view_lhs.items[i], "&")) {
                 found_amp = 1;
                 /* Good error will be generated later. */
@@ -369,7 +370,7 @@ SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopt
             }
         }
         if (!found_amp) {
-            for (size_t i = 0; i < view_lhs.len; i++) {
+            for (int32_t i = 0; i < view_lhs.len; i++) {
                 Janet sub_rhs = view_rhs.len <= i ? janet_wrap_nil() : view_rhs.items[i];
                 into = dohead_destructure(c, into, subopts, view_lhs.items[i], sub_rhs);
             }
@@ -924,6 +925,7 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     int structarg = 0;
     int allow_extra = 0;
     int selfref = 0;
+    int hasname = 0;
     int seenamp = 0;
     int seenopt = 0;
     int namedargs = 0;
@@ -942,6 +944,10 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     head = argv[0];
     if (janet_checktype(head, JANET_SYMBOL)) {
         selfref = 1;
+        hasname = 1;
+        parami = 1;
+    } else if (janet_checktype(head, JANET_KEYWORD)) {
+        hasname = 1;
         parami = 1;
     }
     if (parami >= argn || !janet_checktype(argv[parami], JANET_TUPLE)) {
@@ -1102,7 +1108,7 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     if (vararg) def->flags |= JANET_FUNCDEF_FLAG_VARARG;
     if (structarg) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG;
 
-    if (selfref) def->name = janet_unwrap_symbol(head);
+    if (hasname) def->name = janet_unwrap_symbol(head); /* Also correctly unwraps keyword */
     janet_def_addflags(def);
     defindex = janetc_addfuncdef(c, def);
 

src/core/state.c

@@ -58,7 +58,7 @@ void janet_vm_load(JanetVM *from) {
 }
 
 /* Trigger suspension of the Janet vm by trying to
- * exit the interpeter loop when convenient. You can optionally
+ * exit the interpreter loop when convenient. You can optionally
  * use NULL to interrupt the current VM when convenient */
 void janet_interpreter_interrupt(JanetVM *vm) {
     vm = vm ? vm : &janet_vm;

src/core/state.h

@@ -42,14 +42,14 @@ typedef struct JanetScratch {
 typedef struct {
     JanetGCObject *self;
     JanetGCObject *other;
-    size_t index;
-    size_t index2;
+    int32_t index;
+    int32_t index2;
 } JanetTraversalNode;
 
 typedef struct {
-    size_t capacity;
-    size_t head;
-    size_t tail;
+    int32_t capacity;
+    int32_t head;
+    int32_t tail;
     void *data;
 } JanetQueue;
 
@@ -149,6 +149,11 @@ struct JanetVM {
     JanetTraversalNode *traversal_top;
     JanetTraversalNode *traversal_base;
 
+    /* Thread safe strerror error buffer - for janet_strerror */
+#ifndef JANET_WINDOWS
+    char strerror_buf[256];
+#endif
+
     /* Event loop and scheduler globals */
 #ifdef JANET_EV
     size_t tq_count;

src/core/string.c

@@ -31,8 +31,8 @@
 #include <string.h>
 
 /* Begin building a string */
-uint8_t *janet_string_begin(size_t length) {
-    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + length + 1);
+uint8_t *janet_string_begin(int32_t length) {
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) length + 1);
     head->length = length;
     uint8_t *data = (uint8_t *)head->data;
     data[length] = 0;
@@ -46,8 +46,8 @@ const uint8_t *janet_string_end(uint8_t *str) {
 }
 
 /* Load a buffer as a string */
-const uint8_t *janet_string(const uint8_t *buf, size_t len) {
-    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + len + 1);
+const uint8_t *janet_string(const uint8_t *buf, int32_t len) {
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1);
     head->length = len;
     head->hash = janet_string_calchash(buf, len);
     uint8_t *data = (uint8_t *)head->data;
@@ -58,9 +58,9 @@ const uint8_t *janet_string(const uint8_t *buf, size_t len) {
 
 /* Compare two strings */
 int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) {
-    size_t xlen = janet_string_length(lhs);
-    size_t ylen = janet_string_length(rhs);
-    size_t len = xlen > ylen ? ylen : xlen;
+    int32_t xlen = janet_string_length(lhs);
+    int32_t ylen = janet_string_length(rhs);
+    int32_t len = xlen > ylen ? ylen : xlen;
     int res = memcmp(lhs, rhs, len);
     if (res) return res > 0 ? 1 : -1;
     if (xlen == ylen) return 0;
@@ -68,9 +68,9 @@ int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) {
 }
 
 /* Compare a janet string with a piece of memory */
-int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, size_t rlen, int32_t rhash) {
+int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) {
     int32_t lhash = janet_string_hash(lhs);
-    size_t llen = janet_string_length(lhs);
+    int32_t llen = janet_string_length(lhs);
     if (lhs == rhs)
         return 1;
     if (lhash != rhash || llen != rlen)
@@ -92,10 +92,10 @@ const uint8_t *janet_cstring(const char *str) {
 /* Knuth Morris Pratt Algorithm */
 
 struct kmp_state {
-    size_t i;
-    size_t j;
-    size_t textlen;
-    size_t patlen;
+    int32_t i;
+    int32_t j;
+    int32_t textlen;
+    int32_t patlen;
     int32_t *lookup;
     const uint8_t *text;
     const uint8_t *pat;
@@ -103,8 +103,8 @@ struct kmp_state {
 
 static void kmp_init(
     struct kmp_state *s,
-    const uint8_t *text, size_t textlen,
-    const uint8_t *pat, size_t patlen) {
+    const uint8_t *text, int32_t textlen,
+    const uint8_t *pat, int32_t patlen) {
     if (patlen == 0) {
         janet_panic("expected non-empty pattern");
     }
@@ -121,8 +121,7 @@ static void kmp_init(
     s->patlen = patlen;
     /* Init state machine */
     {
-        size_t i;
-        int32_t j;
+        int32_t i, j;
         for (i = 1, j = 0; i < patlen; i++) {
             while (j && pat[j] != pat[i]) j = lookup[j - 1];
             if (pat[j] == pat[i]) j++;
@@ -141,10 +140,10 @@ static void kmp_seti(struct kmp_state *state, int32_t i) {
 }
 
 static int32_t kmp_next(struct kmp_state *state) {
-    size_t i = state->i;
-    size_t j = state->j;
-    size_t textlen = state->textlen;
-    size_t patlen = state->patlen;
+    int32_t i = state->i;
+    int32_t j = state->j;
+    int32_t textlen = state->textlen;
+    int32_t patlen = state->patlen;
     const uint8_t *text = state->text;
     const uint8_t *pat = state->pat;
     int32_t *lookup = state->lookup;
@@ -205,11 +204,12 @@ JANET_CORE_FN(cfun_string_repeat,
               "Returns a string that is `n` copies of `bytes` concatenated.") {
     janet_fixarity(argc, 2);
     JanetByteView view = janet_getbytes(argv, 0);
-    size_t rep = janet_getsize(argv, 1);
+    int32_t rep = janet_getinteger(argv, 1);
+    if (rep < 0) janet_panic("expected non-negative number of repetitions");
     if (rep == 0) return janet_cstringv("");
-    uint64_t mulres = (uint64_t) rep * view.len;
-    if (mulres > JANET_INTMAX_SIZE) janet_panic("result string is too long");
-    uint8_t *newbuf = janet_string_begin(mulres);
+    int64_t mulres = (int64_t) rep * view.len;
+    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;
     for (uint8_t *p = newbuf; p < end; p += view.len) {
         safe_memcpy(p, view.bytes, view.len);
@@ -223,7 +223,7 @@ JANET_CORE_FN(cfun_string_bytes,
     janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     Janet *tup = janet_tuple_begin(view.len);
-    size_t i;
+    int32_t i;
     for (i = 0; i < view.len; i++) {
         tup[i] = janet_wrap_integer((int32_t) view.bytes[i]);
     }
@@ -251,7 +251,7 @@ JANET_CORE_FN(cfun_string_asciilower,
     janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
-    for (size_t i = 0; i < view.len; i++) {
+    for (int32_t i = 0; i < view.len; i++) {
         uint8_t c = view.bytes[i];
         if (c >= 65 && c <= 90) {
             buf[i] = c + 32;
@@ -270,7 +270,7 @@ JANET_CORE_FN(cfun_string_asciiupper,
     janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
-    for (size_t i = 0; i < view.len; i++) {
+    for (int32_t i = 0; i < view.len; i++) {
         uint8_t c = view.bytes[i];
         if (c >= 97 && c <= 122) {
             buf[i] = c - 32;
@@ -287,7 +287,7 @@ JANET_CORE_FN(cfun_string_reverse,
     janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
-    size_t i, j;
+    int32_t i, j;
     for (i = 0, j = view.len - 1; i < view.len; i++, j--) {
         buf[i] = view.bytes[j];
     }
@@ -474,13 +474,13 @@ JANET_CORE_FN(cfun_string_checkset,
     JanetByteView set = janet_getbytes(argv, 0);
     JanetByteView str = janet_getbytes(argv, 1);
     /* Populate set */
-    for (size_t i = 0; i < set.len; i++) {
+    for (int32_t i = 0; i < set.len; i++) {
         int index = set.bytes[i] >> 5;
         uint32_t mask = 1 << (set.bytes[i] & 0x1F);
         bitset[index] |= mask;
     }
     /* Check set */
-    for (size_t i = 0; i < str.len; i++) {
+    for (int32_t i = 0; i < str.len; i++) {
         int index = str.bytes[i] >> 5;
         uint32_t mask = 1 << (str.bytes[i] & 0x1F);
         if (!(bitset[index] & mask)) {
@@ -504,24 +504,24 @@ JANET_CORE_FN(cfun_string_join,
         joiner.len = 0;
     }
     /* Check args */
-    size_t i;
-    size_t finallen = 0;
+    int32_t i;
+    int64_t finallen = 0;
     for (i = 0; i < parts.len; i++) {
         const uint8_t *chunk;
-        size_t chunklen = 0;
+        int32_t chunklen = 0;
         if (!janet_bytes_view(parts.items[i], &chunk, &chunklen)) {
             janet_panicf("item %d of parts is not a byte sequence, got %v", i, parts.items[i]);
         }
         if (i) finallen += joiner.len;
         finallen += chunklen;
-        if (finallen > JANET_INTMAX_SIZE)
+        if (finallen > INT32_MAX)
             janet_panic("result string too long");
     }
     uint8_t *buf, *out;
-    out = buf = janet_string_begin(finallen);
+    out = buf = janet_string_begin((int32_t) finallen);
     for (i = 0; i < parts.len; i++) {
         const uint8_t *chunk = NULL;
-        size_t chunklen = 0;
+        int32_t chunklen = 0;
         if (i) {
             safe_memcpy(out, joiner.bytes, joiner.len);
             out += joiner.len;
@@ -568,23 +568,23 @@ JANET_CORE_FN(cfun_string_format,
 }
 
 static int trim_help_checkset(JanetByteView set, uint8_t x) {
-    for (size_t j = 0; j < set.len; j++)
+    for (int32_t j = 0; j < set.len; j++)
         if (set.bytes[j] == x)
             return 1;
     return 0;
 }
 
-static size_t trim_help_leftedge(JanetByteView str, JanetByteView set) {
-    for (size_t i = 0; i < str.len; i++)
+static int32_t trim_help_leftedge(JanetByteView str, JanetByteView set) {
+    for (int32_t i = 0; i < str.len; i++)
         if (!trim_help_checkset(set, str.bytes[i]))
             return i;
     return str.len;
 }
 
-static size_t trim_help_rightedge(JanetByteView str, JanetByteView set) {
-    for (size_t i = 0; i < str.len; i++)
-        if (!trim_help_checkset(set, str.bytes[str.len - i - 1]))
-            return str.len - i;
+static int32_t trim_help_rightedge(JanetByteView str, JanetByteView set) {
+    for (int32_t i = str.len - 1; i >= 0; i--)
+        if (!trim_help_checkset(set, str.bytes[i]))
+            return i + 1;
     return 0;
 }
 
@@ -605,8 +605,8 @@ JANET_CORE_FN(cfun_string_trim,
               "`set` is provided, consider only characters in `set` to be whitespace.") {
     JanetByteView str, set;
     trim_help_args(argc, argv, &str, &set);
-    size_t left_edge = trim_help_leftedge(str, set);
-    size_t right_edge = trim_help_rightedge(str, set);
+    int32_t left_edge = trim_help_leftedge(str, set);
+    int32_t right_edge = trim_help_rightedge(str, set);
     if (right_edge < left_edge)
         return janet_stringv(NULL, 0);
     return janet_stringv(str.bytes + left_edge, right_edge - left_edge);

src/core/strtod.c

@@ -34,9 +34,9 @@
  * 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
+ * is always in base 10. For example, a hexadecimal number could be written
  * '16rdeadbeef'. janet_scan_number also supports some c style syntax for
- * hexidecimal literals. The previous number could also be written
+ * hexadecimal literals. The previous number could also be written
  * '0xdeadbeef'.
  */
 
@@ -249,7 +249,7 @@ static double convert(
  * and integer, return 0. */
 int janet_scan_number_base(
     const uint8_t *str,
-    size_t len,
+    int32_t len,
     int32_t base,
     double *out) {
     const uint8_t *end = str + len;
@@ -385,7 +385,7 @@ error:
 
 int janet_scan_number(
     const uint8_t *str,
-    size_t len,
+    int32_t len,
     double *out) {
     return janet_scan_number_base(str, len, 0, out);
 }
@@ -394,7 +394,7 @@ int janet_scan_number(
 
 static int scan_uint64(
     const uint8_t *str,
-    size_t len,
+    int32_t len,
     uint64_t *out,
     int *neg) {
     const uint8_t *end = str + len;
@@ -457,7 +457,7 @@ static int scan_uint64(
     return 1;
 }
 
-int janet_scan_int64(const uint8_t *str, size_t len, int64_t *out) {
+int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out) {
     int neg;
     uint64_t bi;
     if (scan_uint64(str, len, &bi, &neg)) {
@@ -477,7 +477,7 @@ int janet_scan_int64(const uint8_t *str, size_t len, int64_t *out) {
     return 0;
 }
 
-int janet_scan_uint64(const uint8_t *str, size_t len, uint64_t *out) {
+int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out) {
     int neg;
     uint64_t bi;
     if (scan_uint64(str, len, &bi, &neg)) {
@@ -490,3 +490,18 @@ int janet_scan_uint64(const uint8_t *str, size_t len, uint64_t *out) {
 }
 
 #endif
+
+void janet_buffer_dtostr(JanetBuffer *buffer, double x) {
+#define BUFSIZE 32
+    janet_buffer_extra(buffer, BUFSIZE);
+    int count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, "%.17g", x);
+#undef BUFSIZE
+    /* fix locale issues with commas */
+    for (int i = 0; i < count; i++) {
+        char c = buffer->data[buffer->count + i];
+        if (c == ',') {
+            buffer->data[buffer->count + i] = '.';
+        }
+    }
+    buffer->count += count;
+}

src/core/struct.c

@@ -29,18 +29,12 @@
 #endif
 
 /* Begin creation of a struct */
-JanetKV *janet_struct_begin(size_t count) {
+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);
 
-    uint64_t double_count =
-        (count > JANET_INTMAX_SIZE / 2) ? JANET_INTMAX_SIZE : 2 * count;
-    uint64_t capacity = janet_tablen(double_count);
-
-    uint64_t part_size = capacity * sizeof(JanetKV);
-    if (part_size > JANET_INTMAX_SIZE){
-        part_size = JANET_INTMIN_SIZE;
-    }
-    size_t size = sizeof(JanetStructHead) + (uint64_t) part_size;
+    size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV);
     JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size);
     head->length = count;
     head->capacity = capacity;
@@ -55,9 +49,9 @@ JanetKV *janet_struct_begin(size_t count) {
 /* Find an item in a struct without looking for prototypes. Should be similar to janet_dict_find, but
  * specialized to structs (slightly more compact). */
 const JanetKV *janet_struct_find(const JanetKV *st, Janet key) {
-    size_t cap = janet_struct_capacity(st);
-    size_t index = (size_t) janet_maphash(cap, janet_hash(key));
-    size_t i;
+    int32_t cap = janet_struct_capacity(st);
+    int32_t index = janet_maphash(cap, janet_hash(key));
+    int32_t i;
     for (i = index; i < cap; i++)
         if (janet_checktype(st[i].key, JANET_NIL) || janet_equals(st[i].key, key))
             return st + i;
@@ -76,20 +70,20 @@ const JanetKV *janet_struct_find(const JanetKV *st, Janet key) {
  * hash map is independent of insertion order.
  */
 void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) {
-    size_t cap = janet_struct_capacity(st);
+    int32_t cap = janet_struct_capacity(st);
     int32_t hash = janet_hash(key);
-    size_t index = (size_t) janet_maphash(cap, hash);
-    size_t i, j, dist;
-    size_t bounds[4] = {index, cap, 0, index};
+    int32_t index = janet_maphash(cap, hash);
+    int32_t i, j, dist;
+    int32_t bounds[4] = {index, cap, 0, index};
     if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return;
     if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return;
     /* Avoid extra items */
-    if ((size_t) janet_struct_hash(st) == janet_struct_length(st)) return;
+    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;
-            size_t otherindex, otherdist;
+            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)) {
@@ -106,7 +100,7 @@ void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) {
              * 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 = (size_t) janet_maphash(cap, otherhash);
+            otherindex = janet_maphash(cap, otherhash);
             otherdist = (i + cap - otherindex) & (cap - 1);
             if (dist < otherdist)
                 status = -1;
@@ -145,12 +139,12 @@ void janet_struct_put(JanetKV *st, Janet key, Janet value) {
 
 /* Finish building a struct */
 const JanetKV *janet_struct_end(JanetKV *st) {
-    if ((size_t) janet_struct_hash(st) != janet_struct_length(st)) {
+    if (janet_struct_hash(st) != janet_struct_length(st)) {
         /* Error building struct, probably duplicate values. We need to rebuild
          * the struct using only the values that went in. The second creation should always
          * succeed. */
         JanetKV *newst = janet_struct_begin(janet_struct_hash(st));
-        for (size_t i = 0; i < janet_struct_capacity(st); i++) {
+        for (int32_t i = 0; i < janet_struct_capacity(st); i++) {
             JanetKV *kv = st + i;
             if (!janet_checktype(kv->key, JANET_NIL)) {
                 janet_struct_put(newst, kv->key, kv->value);
@@ -198,7 +192,7 @@ Janet janet_struct_get_ex(const JanetKV *st, Janet key, JanetStruct *which) {
 /* Convert struct to table */
 JanetTable *janet_struct_to_table(const JanetKV *st) {
     JanetTable *table = janet_table(janet_struct_capacity(st));
-    size_t i;
+    int32_t i;
     for (i = 0; i < janet_struct_capacity(st); i++) {
         const JanetKV *kv = st + i;
         if (!janet_checktype(kv->key, JANET_NIL)) {
@@ -244,21 +238,21 @@ JANET_CORE_FN(cfun_struct_flatten,
     JanetStruct st = janet_getstruct(argv, 0);
 
     /* get an upper bounds on the number of items in the final struct */
-    size_t pair_count = 0;
+    int64_t pair_count = 0;
     JanetStruct cursor = st;
     while (cursor) {
         pair_count += janet_struct_length(cursor);
         cursor = janet_struct_proto(cursor);
     }
 
-    if (pair_count > JANET_INTMAX_SIZE) {
+    if (pair_count > INT32_MAX) {
         janet_panic("struct too large");
     }
 
-    JanetKV *accum = janet_struct_begin(pair_count);
+    JanetKV *accum = janet_struct_begin((int32_t) pair_count);
     cursor = st;
     while (cursor) {
-        for (size_t i = 0; i < janet_struct_capacity(cursor); i++) {
+        for (int32_t i = 0; i < janet_struct_capacity(cursor); i++) {
             const JanetKV *kv = cursor + i;
             if (!janet_checktype(kv->key, JANET_NIL)) {
                 janet_struct_put_ext(accum, kv->key, kv->value, 0);
@@ -289,7 +283,7 @@ JANET_CORE_FN(cfun_struct_to_table,
         }
         /* TODO - implement as memcpy since struct memory should be compatible
          * with table memory */
-        for (size_t i = 0; i < janet_struct_capacity(cursor); i++) {
+        for (int32_t i = 0; i < janet_struct_capacity(cursor); i++) {
             const JanetKV *kv = cursor + i;
             if (!janet_checktype(kv->key, JANET_NIL)) {
                 janet_table_put(tab_cursor, kv->key, kv->value);

src/core/symcache.c

@@ -66,7 +66,7 @@ static const uint8_t JANET_SYMCACHE_DELETED[1] = {0};
  * where one would put it. */
 static const uint8_t **janet_symcache_findmem(
     const uint8_t *str,
-    size_t len,
+    int32_t len,
     int32_t hash,
     int *success) {
     uint32_t bounds[4];
@@ -116,10 +116,10 @@ notfound:
     janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success))
 
 /* Resize the cache. */
-static void janet_cache_resize(size_t newCapacity) {
-    size_t i, oldCapacity;
+static void janet_cache_resize(uint32_t newCapacity) {
+    uint32_t i, oldCapacity;
     const uint8_t **oldCache = janet_vm.cache;
-    const uint8_t **newCache = janet_calloc(1, newCapacity * sizeof(const uint8_t *));
+    const uint8_t **newCache = janet_calloc(1, (size_t) newCapacity * sizeof(const uint8_t *));
     if (newCache == NULL) {
         JANET_OUT_OF_MEMORY;
     }
@@ -169,14 +169,14 @@ void janet_symbol_deinit(const uint8_t *sym) {
 }
 
 /* Create a symbol from a byte string */
-const uint8_t *janet_symbol(const uint8_t *str, size_t len) {
+const uint8_t *janet_symbol(const uint8_t *str, int32_t len) {
     int32_t hash = janet_string_calchash(str, len);
     uint8_t *newstr;
     int success = 0;
     const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success);
     if (success)
         return *bucket;
-    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + len + 1);
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1);
     head->hash = hash;
     head->length = len;
     newstr = (uint8_t *)(head->data);
@@ -188,7 +188,7 @@ const uint8_t *janet_symbol(const uint8_t *str, size_t len) {
 
 /* Get a symbol from a cstring */
 const uint8_t *janet_csymbol(const char *cstr) {
-    return janet_symbol((const uint8_t *)cstr, strlen(cstr));
+    return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr));
 }
 
 /* Increment the gensym buffer */

src/core/table.c

@@ -30,9 +30,9 @@
 
 #define JANET_TABLE_FLAG_STACK 0x10000
 
-static void *janet_memalloc_empty_local(size_t count) {
-    size_t i;
-    void *mem = janet_smalloc(count * sizeof(JanetKV));
+static void *janet_memalloc_empty_local(int32_t count) {
+    int32_t i;
+    void *mem = janet_smalloc((size_t) count * sizeof(JanetKV));
     JanetKV *mmem = (JanetKV *)mem;
     for (i = 0; i < count; i++) {
         JanetKV *kv = mmem + i;
@@ -42,7 +42,7 @@ static void *janet_memalloc_empty_local(size_t count) {
     return mem;
 }
 
-static JanetTable *janet_table_init_impl(JanetTable *table, size_t capacity, int stackalloc) {
+static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) {
     JanetKV *data;
     capacity = janet_tablen(capacity);
     if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK;
@@ -67,13 +67,13 @@ static JanetTable *janet_table_init_impl(JanetTable *table, size_t capacity, int
     return table;
 }
 
-/* Initialize a table (for use withs scratch memory) */
-JanetTable *janet_table_init(JanetTable *table, size_t capacity) {
+/* Initialize a table (for use with scratch memory) */
+JanetTable *janet_table_init(JanetTable *table, int32_t capacity) {
     return janet_table_init_impl(table, capacity, 1);
 }
 
 /* Initialize a table without using scratch memory */
-JanetTable *janet_table_init_raw(JanetTable *table, size_t capacity) {
+JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity) {
     return janet_table_init_impl(table, capacity, 0);
 }
 
@@ -88,22 +88,22 @@ void janet_table_deinit(JanetTable *table) {
 
 /* Create a new table */
 
-JanetTable *janet_table(size_t capacity) {
+JanetTable *janet_table(int32_t capacity) {
     JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable));
     return janet_table_init_impl(table, capacity, 0);
 }
 
-JanetTable *janet_table_weakk(size_t capacity) {
+JanetTable *janet_table_weakk(int32_t capacity) {
     JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKK, sizeof(JanetTable));
     return janet_table_init_impl(table, capacity, 0);
 }
 
-JanetTable *janet_table_weakv(size_t capacity) {
+JanetTable *janet_table_weakv(int32_t capacity) {
     JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKV, sizeof(JanetTable));
     return janet_table_init_impl(table, capacity, 0);
 }
 
-JanetTable *janet_table_weakkv(size_t capacity) {
+JanetTable *janet_table_weakkv(int32_t capacity) {
     JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKKV, sizeof(JanetTable));
     return janet_table_init_impl(table, capacity, 0);
 }
@@ -115,7 +115,7 @@ JanetKV *janet_table_find(JanetTable *t, Janet key) {
 }
 
 /* Resize the dictionary table. */
-static void janet_table_rehash(JanetTable *t, size_t size) {
+static void janet_table_rehash(JanetTable *t, int32_t size) {
     JanetKV *olddata = t->data;
     JanetKV *newdata;
     int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK;
@@ -127,11 +127,11 @@ static void janet_table_rehash(JanetTable *t, size_t size) {
             JANET_OUT_OF_MEMORY;
         }
     }
-    size_t oldcapacity = t->capacity;
+    int32_t oldcapacity = t->capacity;
     t->data = newdata;
     t->capacity = size;
     t->deleted = 0;
-    for (size_t i = 0; i < oldcapacity; i++) {
+    for (int32_t i = 0; i < oldcapacity; i++) {
         JanetKV *kv = olddata + i;
         if (!janet_checktype(kv->key, JANET_NIL)) {
             JanetKV *newkv = janet_table_find(t, kv->key);
@@ -235,7 +235,7 @@ static void janet_table_put_no_overwrite(JanetTable *t, Janet key, Janet value)
 
 /* Clear a table */
 void janet_table_clear(JanetTable *t) {
-    size_t capacity = t->capacity;
+    int32_t capacity = t->capacity;
     JanetKV *data = t->data;
     janet_memempty(data, capacity);
     t->count = 0;
@@ -253,13 +253,13 @@ JanetTable *janet_table_clone(JanetTable *table) {
     if (NULL == newTable->data) {
         JANET_OUT_OF_MEMORY;
     }
-    memcpy(newTable->data, table->data, table->capacity * sizeof(JanetKV));
+    memcpy(newTable->data, table->data, (size_t) table->capacity * sizeof(JanetKV));
     return newTable;
 }
 
 /* Merge a table or struct into a table */
-static void janet_table_mergekv(JanetTable *table, const JanetKV *kvs, size_t cap) {
-    size_t i;
+static void janet_table_mergekv(JanetTable *table, const JanetKV *kvs, int32_t cap) {
+    int32_t i;
     for (i = 0; i < cap; i++) {
         const JanetKV *kv = kvs + i;
         if (!janet_checktype(kv->key, JANET_NIL)) {
@@ -316,23 +316,16 @@ JANET_CORE_FN(cfun_table_new,
               "can be avoided. "
               "Returns the new table.") {
     janet_fixarity(argc, 1);
-    size_t cap = janet_getsize(argv, 0);
+    int32_t cap = janet_getnat(argv, 0);
     return janet_wrap_table(janet_table(cap));
 }
-/*
-    uint32_t flags = janet_getflags(argv, 1, "kv");
-    if (flags == 0) return janet_wrap_table(janet_table(cap));
-    if (flags == 1) return janet_wrap_table(janet_table_weakk(cap));
-    if (flags == 2) return janet_wrap_table(janet_table_weakv(cap));
-    return janet_wrap_table(janet_table_weakkv(cap));
-    */
 
 JANET_CORE_FN(cfun_table_weak,
               "(table/weak capacity)",
               "Creates a new empty table with weak references to keys and values. Similar to `table/new`. "
               "Returns the new table.") {
     janet_fixarity(argc, 1);
-    size_t cap = janet_getsize(argv, 0);
+    int32_t cap = janet_getnat(argv, 0);
     return janet_wrap_table(janet_table_weakkv(cap));
 }
 
@@ -341,7 +334,7 @@ JANET_CORE_FN(cfun_table_weak_keys,
               "Creates a new empty table with weak references to keys and normal references to values. Similar to `table/new`. "
               "Returns the new table.") {
     janet_fixarity(argc, 1);
-    size_t cap = janet_getsize(argv, 0);
+    int32_t cap = janet_getnat(argv, 0);
     return janet_wrap_table(janet_table_weakk(cap));
 }
 
@@ -350,7 +343,7 @@ JANET_CORE_FN(cfun_table_weak_values,
               "Creates a new empty table with normal references to keys and weak references to values. Similar to `table/new`. "
               "Returns the new table.") {
     janet_fixarity(argc, 1);
-    size_t cap = janet_getsize(argv, 0);
+    int32_t cap = janet_getnat(argv, 0);
     return janet_wrap_table(janet_table_weakv(cap));
 }
 

src/core/tuple.c

@@ -31,8 +31,8 @@
 /* Create a new empty tuple of the given size. This will return memory
  * which should be filled with Janets. The memory will not be collected until
  * janet_tuple_end is called. */
-Janet *janet_tuple_begin(size_t length) {
-    size_t size = sizeof(JanetTupleHead) + (length * sizeof(Janet));
+Janet *janet_tuple_begin(int32_t length) {
+    size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet));
     JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size);
     head->sm_line = -1;
     head->sm_column = -1;
@@ -47,7 +47,7 @@ const Janet *janet_tuple_end(Janet *tuple) {
 }
 
 /* Build a tuple with n values */
-const Janet *janet_tuple_n(const Janet *values, size_t n) {
+const Janet *janet_tuple_n(const Janet *values, int32_t n) {
     Janet *t = janet_tuple_begin(n);
     safe_memcpy(t, values, sizeof(Janet) * n);
     return janet_tuple_end(t);

src/core/util.c

@@ -117,7 +117,7 @@ const char *const janet_status_names[16] = {
 
 #ifndef JANET_PRF
 
-int32_t janet_string_calchash(const uint8_t *str, size_t len) {
+int32_t janet_string_calchash(const uint8_t *str, int32_t len) {
     if (NULL == str) return 5381;
     const uint8_t *end = str + len;
     uint32_t hash = 5381;
@@ -230,7 +230,7 @@ void janet_init_hash_key(uint8_t new_key[JANET_HASH_KEY_SIZE]) {
 
 /* Calculate hash for string */
 
-int32_t janet_string_calchash(const uint8_t *str, size_t len) {
+int32_t janet_string_calchash(const uint8_t *str, int32_t len) {
     uint32_t hash;
     hash = halfsiphash(str, len, hash_key);
     return (int32_t)hash;
@@ -244,7 +244,7 @@ uint32_t janet_hash_mix(uint32_t input, uint32_t more) {
 }
 
 /* Computes hash of an array of values */
-int32_t janet_array_calchash(const Janet *array, size_t len) {
+int32_t janet_array_calchash(const Janet *array, int32_t len) {
     const Janet *end = array + len;
     uint32_t hash = 33;
     while (array < end) {
@@ -254,7 +254,7 @@ int32_t janet_array_calchash(const Janet *array, size_t len) {
 }
 
 /* Computes hash of an array of values */
-int32_t janet_kv_calchash(const JanetKV *kvs, size_t len) {
+int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) {
     const JanetKV *end = kvs + len;
     uint32_t hash = 33;
     while (kvs < end) {
@@ -267,7 +267,8 @@ int32_t janet_kv_calchash(const JanetKV *kvs, size_t len) {
 
 /* Calculate next power of 2. May overflow. If n is 0,
  * will return 0. */
-uint64_t janet_tablen(uint64_t n) {
+int32_t janet_tablen(int32_t n) {
+    if (n < 0) return 0;
     n |= n >> 1;
     n |= n >> 2;
     n |= n >> 4;
@@ -284,9 +285,9 @@ void safe_memcpy(void *dest, const void *src, size_t len) {
 
 /* Helper to find a value in a Janet struct or table. Returns the bucket
  * containing the key, or the first empty bucket if there is no such key. */
-const JanetKV *janet_dict_find(const JanetKV *buckets, size_t cap, Janet key) {
+const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) {
     int32_t index = janet_maphash(cap, janet_hash(key));
-    size_t i;
+    int32_t i;
     const JanetKV *first_bucket = NULL;
     /* Higher half */
     for (i = index; i < cap; i++) {
@@ -302,7 +303,7 @@ const JanetKV *janet_dict_find(const JanetKV *buckets, size_t cap, Janet key) {
         }
     }
     /* Lower half */
-    for (i = 0; i < (size_t) index; i++) {
+    for (i = 0; i < index; i++) {
         const JanetKV *kv = buckets + i;
         if (janet_checktype(kv->key, JANET_NIL)) {
             if (janet_checktype(kv->value, JANET_NIL)) {
@@ -318,7 +319,7 @@ const JanetKV *janet_dict_find(const JanetKV *buckets, size_t cap, Janet key) {
 }
 
 /* Get a value from a janet struct or table. */
-Janet janet_dictionary_get(const JanetKV *data, size_t cap, Janet key) {
+Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key) {
     const JanetKV *kv = janet_dict_find(data, cap, key);
     if (kv && !janet_checktype(kv->key, JANET_NIL)) {
         return kv->value;
@@ -327,7 +328,7 @@ Janet janet_dictionary_get(const JanetKV *data, size_t cap, Janet key) {
 }
 
 /* Iterate through a struct or dictionary generically */
-const JanetKV *janet_dictionary_next(const JanetKV *kvs, size_t cap, const JanetKV *kv) {
+const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv) {
     const JanetKV *end = kvs + cap;
     kv = (kv == NULL) ? kvs : kv + 1;
     while (kv < end) {
@@ -341,8 +342,8 @@ const JanetKV *janet_dictionary_next(const JanetKV *kvs, size_t cap, const Janet
 /* Compare a janet string with a cstring. More efficient than loading
  * c string as a janet string. */
 int janet_cstrcmp(const uint8_t *str, const char *other) {
-    size_t len = janet_string_length(str);
-    size_t index;
+    int32_t len = janet_string_length(str);
+    int32_t index;
     for (index = 0; index < len; index++) {
         uint8_t c = str[index];
         uint8_t k = ((const uint8_t *)other)[index];
@@ -690,7 +691,7 @@ static JanetByteView to_byte_view(Janet value) {
 JanetByteView janet_text_substitution(
     Janet *subst,
     const uint8_t *bytes,
-    size_t len,
+    uint32_t len,
     JanetArray *extra_argv) {
     int32_t extra_argc = extra_argv == NULL ? 0 : extra_argv->count;
     JanetType type = janet_type(*subst);
@@ -740,7 +741,7 @@ Janet janet_resolve_core(const char *name) {
 
 /* Read both tuples and arrays as c pointers + int32_t length. Return 1 if the
  * view can be constructed, 0 if an invalid type. */
-int janet_indexed_view(Janet seq, const Janet **data, size_t *len) {
+int janet_indexed_view(Janet seq, const Janet **data, int32_t *len) {
     if (janet_checktype(seq, JANET_ARRAY)) {
         *data = janet_unwrap_array(seq)->data;
         *len = janet_unwrap_array(seq)->count;
@@ -755,7 +756,7 @@ int janet_indexed_view(Janet seq, const Janet **data, size_t *len) {
 
 /* Read both strings and buffer as unsigned character array + int32_t len.
  * Returns 1 if the view can be constructed and 0 if the type is invalid. */
-int janet_bytes_view(Janet str, const uint8_t **data, size_t *len) {
+int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len) {
     JanetType t = janet_type(str);
     if (t == JANET_STRING || t == JANET_SYMBOL || t == JANET_KEYWORD) {
         *data = janet_unwrap_string(str);
@@ -782,7 +783,7 @@ int janet_bytes_view(Janet str, const uint8_t **data, size_t *len) {
 /* Read both structs and tables as the entries of a hashtable with
  * identical structure. Returns 1 if the view can be constructed and
  * 0 if the type is invalid. */
-int janet_dictionary_view(Janet tab, const JanetKV **data, size_t *len, size_t *cap) {
+int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap) {
     if (janet_checktype(tab, JANET_TABLE)) {
         *data = janet_unwrap_table(tab)->data;
         *cap = janet_unwrap_table(tab)->capacity;
@@ -825,18 +826,30 @@ int janet_checkuint64(Janet x) {
     return janet_checkuint64range(dval);
 }
 
+int janet_checkint16(Janet x) {
+    if (!janet_checktype(x, JANET_NUMBER))
+        return 0;
+    double dval = janet_unwrap_number(x);
+    return janet_checkint16range(dval);
+}
+
+int janet_checkuint16(Janet x) {
+    if (!janet_checktype(x, JANET_NUMBER))
+        return 0;
+    double dval = janet_unwrap_number(x);
+    return janet_checkuint16range(dval);
+}
+
 int janet_checksize(Janet x) {
     if (!janet_checktype(x, JANET_NUMBER))
         return 0;
     double dval = janet_unwrap_number(x);
-    return janet_checksizerange(dval);
-}
-
-int janet_checkssize(Janet x) {
-    if (!janet_checktype(x, JANET_NUMBER))
-        return 0;
-    double dval = janet_unwrap_number(x);
-    return janet_checkssizerange(dval);
+    if (dval != (double)((size_t) dval)) return 0;
+    if (SIZE_MAX > JANET_INTMAX_INT64) {
+        return dval <= JANET_INTMAX_INT64;
+    } else {
+        return dval <= SIZE_MAX;
+    }
 }
 
 JanetTable *janet_get_core_table(const char *name) {
@@ -849,21 +862,21 @@ JanetTable *janet_get_core_table(const char *name) {
 }
 
 /* Sort keys of a dictionary type */
-int32_t janet_sorted_keys(const JanetKV *dict, size_t cap, int32_t *index_buffer) {
+int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer) {
 
     /* First, put populated indices into index_buffer */
-    size_t next_index = 0;
-    for (size_t i = 0; i < cap; i++) {
+    int32_t next_index = 0;
+    for (int32_t i = 0; i < cap; i++) {
         if (!janet_checktype(dict[i].key, JANET_NIL)) {
             index_buffer[next_index++] = i;
         }
     }
 
     /* Next, sort those (simple insertion sort here for now) */
-    for (size_t i = 1; i < next_index; i++) {
+    for (int32_t i = 1; i < next_index; i++) {
         int32_t index_to_insert = index_buffer[i];
         Janet lhs = dict[index_to_insert].key;
-        for (size_t j = i - 1; j > 0; j--) {
+        for (int32_t j = i - 1; j >= 0; j--) {
             index_buffer[j + 1] = index_buffer[j];
             Janet rhs = dict[index_buffer[j]].key;
             if (janet_compare(lhs, rhs) >= 0) {
@@ -954,6 +967,20 @@ int janet_gettime(struct timespec *spec, enum JanetTimeSource source) {
 #endif
 #endif
 
+/* Better strerror (thread-safe if available) */
+const char *janet_strerror(int e) {
+#ifdef JANET_WINDOWS
+    /* Microsoft strerror seems sane here and is thread safe by default */
+    return strerror(e);
+#elif defined(__GLIBC__)
+    /* See https://linux.die.net/man/3/strerror_r */
+    return strerror_r(e, janet_vm.strerror_buf, sizeof(janet_vm.strerror_buf));
+#else
+    strerror_r(e, janet_vm.strerror_buf, sizeof(janet_vm.strerror_buf));
+    return janet_vm.strerror_buf;
+#endif
+}
+
 /* Setting C99 standard makes this not available, but it should
  * work/link properly if we detect a BSD */
 #if defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7)

src/core/util.h

@@ -66,20 +66,22 @@
 /* Utils */
 uint32_t janet_hash_mix(uint32_t input, uint32_t more);
 #define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1))
-int janet_valid_utf8(const uint8_t *str, size_t len);
+int janet_valid_utf8(const uint8_t *str, int32_t len);
 int janet_is_symbol_char(uint8_t c);
 extern const char janet_base64[65];
-int32_t janet_array_calchash(const Janet *array, size_t len);
-int32_t janet_kv_calchash(const JanetKV *kvs, size_t len);
-int32_t janet_string_calchash(const uint8_t *str, size_t len);
-uint64_t janet_tablen(uint64_t n);
+int32_t janet_array_calchash(const Janet *array, int32_t len);
+int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len);
+int32_t janet_string_calchash(const uint8_t *str, int32_t len);
+int32_t janet_tablen(int32_t n);
 void safe_memcpy(void *dest, const void *src, size_t len);
 void janet_buffer_push_types(JanetBuffer *buffer, int types);
-const JanetKV *janet_dict_find(const JanetKV *buckets, size_t cap, Janet key);
-void janet_memempty(JanetKV *mem, size_t count);
-void *janet_memalloc_empty(size_t count);
+const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key);
+void janet_memempty(JanetKV *mem, int32_t count);
+void *janet_memalloc_empty(int32_t count);
 JanetTable *janet_get_core_table(const char *name);
 void janet_def_addflags(JanetFuncDef *def);
+void janet_buffer_dtostr(JanetBuffer *buffer, double x);
+const char *janet_strerror(int e);
 const void *janet_strbinsearch(
     const void *tab,
     size_t tabcount,
@@ -96,7 +98,7 @@ JanetBinding janet_binding_from_entry(Janet entry);
 JanetByteView janet_text_substitution(
     Janet *subst,
     const uint8_t *bytes,
-    size_t len,
+    uint32_t len,
     JanetArray *extra_args);
 
 /* Registry functions */
@@ -139,7 +141,7 @@ int janet_gettime(struct timespec *spec, enum JanetTimeSource source);
 #define strdup(x) _strdup(x)
 #endif
 
-/* Use LoadLibrary on windows or dlopen on posix to load dynamic libaries
+/* Use LoadLibrary on windows or dlopen on posix to load dynamic libraries
  * with native code. */
 #if defined(JANET_NO_DYNAMIC_MODULES)
 typedef int Clib;

src/core/value.c

@@ -31,7 +31,7 @@
 
 #include <math.h>
 
-static void push_traversal_node(void *lhs, void *rhs, size_t index2) {
+static void push_traversal_node(void *lhs, void *rhs, int32_t index2) {
     JanetTraversalNode node;
     node.self = (JanetGCObject *) lhs;
     node.other = (JanetGCObject *) rhs;
@@ -75,7 +75,7 @@ static int traversal_next(Janet *x, Janet *y) {
         if ((self->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_TUPLE) {
             /* Node is a tuple at index t->index */
             if (t->index < tself->length && t->index < tother->length) {
-                size_t index = t->index++;
+                int32_t index = t->index++;
                 *x = tself->data[index];
                 *y = tother->data[index];
                 janet_vm.traversal = t;
@@ -88,13 +88,13 @@ static int traversal_next(Janet *x, Janet *y) {
             /* Node is a struct at index t->index: if t->index2 is true, we should return the values. */
             if (t->index2) {
                 t->index2 = 0;
-                size_t index = t->index++;
+                int32_t index = t->index++;
                 *x = sself->data[index].value;
                 *y = sother->data[index].value;
                 janet_vm.traversal = t;
                 return 0;
             }
-            for (size_t i = t->index; i < sself->capacity; i++) {
+            for (int32_t i = t->index; i < sself->capacity; i++) {
                 t->index2 = 1;
                 *x = sself->data[t->index].key;
                 *y = sother->data[t->index].key;
@@ -135,7 +135,7 @@ Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) {
         case JANET_TABLE:
         case JANET_STRUCT: {
             const JanetKV *start;
-            size_t cap;
+            int32_t cap;
             if (t == JANET_TABLE) {
                 JanetTable *tab = janet_unwrap_table(ds);
                 cap = tab->capacity;
@@ -161,7 +161,7 @@ Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) {
         case JANET_BUFFER:
         case JANET_ARRAY:
         case JANET_TUPLE: {
-            size_t i;
+            int32_t i;
             if (janet_checktype(key, JANET_NIL)) {
                 i = 0;
             } else if (janet_checkint(key)) {
@@ -169,7 +169,7 @@ Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) {
             } else {
                 break;
             }
-            size_t len;
+            int32_t len;
             if (t == JANET_BUFFER) {
                 len = janet_unwrap_buffer(ds)->count;
             } else if (t == JANET_ARRAY) {
@@ -179,8 +179,8 @@ Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) {
             } else {
                 len = janet_string_length(janet_unwrap_string(ds));
             }
-            if (i < len) {
-                return janet_wrap_size(i);
+            if (i < len && i >= 0) {
+                return janet_wrap_integer(i);
             }
             break;
         }
@@ -423,8 +423,8 @@ int janet_compare(Janet x, Janet y) {
             case JANET_STRUCT: {
                 const JanetKV *lhs = janet_unwrap_struct(x);
                 const JanetKV *rhs = janet_unwrap_struct(y);
-                size_t llen = janet_struct_capacity(lhs);
-                size_t rlen = janet_struct_capacity(rhs);
+                int32_t llen = janet_struct_capacity(lhs);
+                int32_t rlen = janet_struct_capacity(rhs);
                 int32_t lhash = janet_struct_hash(lhs);
                 int32_t rhash = janet_struct_hash(rhs);
                 if (llen < rlen) return -1;
@@ -439,9 +439,10 @@ int janet_compare(Janet x, Janet y) {
     return status - 2;
 }
 
-static size_t getter_checksize(JanetType type, Janet key, size_t max) {
-    if (!janet_checksize(key)) goto bad;
-    size_t ret = janet_unwrap_size(key);
+static int32_t getter_checkint(JanetType type, Janet key, int32_t max) {
+    if (!janet_checkint(key)) goto bad;
+    int32_t ret = janet_unwrap_integer(key);
+    if (ret < 0) goto bad;
     if (ret >= max) goto bad;
     return ret;
 bad:
@@ -464,19 +465,19 @@ Janet janet_in(Janet ds, Janet key) {
             break;
         case JANET_ARRAY: {
             JanetArray *array = janet_unwrap_array(ds);
-            size_t index = getter_checksize(type, key, array->count);
+            int32_t index = getter_checkint(type, key, array->count);
             value = array->data[index];
             break;
         }
         case JANET_TUPLE: {
             const Janet *tuple = janet_unwrap_tuple(ds);
-            size_t len = janet_tuple_length(tuple);
-            value = tuple[getter_checksize(type, key, len)];
+            int32_t len = janet_tuple_length(tuple);
+            value = tuple[getter_checkint(type, key, len)];
             break;
         }
         case JANET_BUFFER: {
             JanetBuffer *buffer = janet_unwrap_buffer(ds);
-            size_t index = getter_checksize(type, key, buffer->count);
+            int32_t index = getter_checkint(type, key, buffer->count);
             value = janet_wrap_integer(buffer->data[index]);
             break;
         }
@@ -484,7 +485,7 @@ Janet janet_in(Janet ds, Janet key) {
         case JANET_SYMBOL:
         case JANET_KEYWORD: {
             const uint8_t *str = janet_unwrap_string(ds);
-            size_t index = getter_checksize(type, key, janet_string_length(str));
+            int32_t index = getter_checkint(type, key, janet_string_length(str));
             value = janet_wrap_integer(str[index]);
             break;
         }
@@ -518,8 +519,9 @@ Janet janet_get(Janet ds, Janet key) {
         case JANET_STRING:
         case JANET_SYMBOL:
         case JANET_KEYWORD: {
-            if (!janet_checksize(key)) return janet_wrap_nil();
-            size_t index = janet_unwrap_size(key);
+            if (!janet_checkint(key)) return janet_wrap_nil();
+            int32_t index = janet_unwrap_integer(key);
+            if (index < 0) return janet_wrap_nil();
             const uint8_t *str = janet_unwrap_string(ds);
             if (index >= janet_string_length(str)) return janet_wrap_nil();
             return janet_wrap_integer(str[index]);
@@ -537,7 +539,8 @@ Janet janet_get(Janet ds, Janet key) {
         case JANET_TUPLE:
         case JANET_BUFFER: {
             if (!janet_checkint(key)) return janet_wrap_nil();
-            size_t index = janet_unwrap_size(key);
+            int32_t index = janet_unwrap_integer(key);
+            if (index < 0) return janet_wrap_nil();
             if (t == JANET_ARRAY) {
                 JanetArray *a = janet_unwrap_array(ds);
                 if (index >= a->count) return janet_wrap_nil();
@@ -570,8 +573,9 @@ Janet janet_get(Janet ds, Janet key) {
     }
 }
 
-Janet janet_getindex(Janet ds, size_t index) {
+Janet janet_getindex(Janet ds, int32_t index) {
     Janet value;
+    if (index < 0) janet_panic("expected non-negative index");
     switch (janet_type(ds)) {
         default:
             janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, ds);
@@ -634,7 +638,7 @@ Janet janet_getindex(Janet ds, size_t index) {
     return value;
 }
 
-size_t janet_length(Janet x) {
+int32_t janet_length(Janet x) {
     switch (janet_type(x)) {
         default:
             janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, x);
@@ -657,14 +661,14 @@ size_t janet_length(Janet x) {
             const JanetAbstractType *type = janet_abstract_type(abst);
             if (type->length != NULL) {
                 size_t len = type->length(abst, janet_abstract_size(abst));
-                if (len > JANET_INTMAX_SIZE) {
+                if (len > INT32_MAX) {
                     janet_panicf("invalid integer length %u", len);
                 }
-                return len;
+                return (int32_t)(len);
             }
             Janet argv[1] = { x };
             Janet len = janet_mcall("length", 1, argv);
-            if (!janet_checksize(len))
+            if (!janet_checkint(len))
                 janet_panicf("invalid integer length %v", len);
             return janet_unwrap_integer(len);
         }
@@ -678,17 +682,17 @@ Janet janet_lengthv(Janet x) {
         case JANET_STRING:
         case JANET_SYMBOL:
         case JANET_KEYWORD:
-            return janet_wrap_size(janet_string_length(janet_unwrap_string(x)));
+            return janet_wrap_integer(janet_string_length(janet_unwrap_string(x)));
         case JANET_ARRAY:
-            return janet_wrap_size(janet_unwrap_array(x)->count);
+            return janet_wrap_integer(janet_unwrap_array(x)->count);
         case JANET_BUFFER:
-            return janet_wrap_size(janet_unwrap_buffer(x)->count);
+            return janet_wrap_integer(janet_unwrap_buffer(x)->count);
         case JANET_TUPLE:
-            return janet_wrap_size(janet_tuple_length(janet_unwrap_tuple(x)));
+            return janet_wrap_integer(janet_tuple_length(janet_unwrap_tuple(x)));
         case JANET_STRUCT:
-            return janet_wrap_size(janet_struct_length(janet_unwrap_struct(x)));
+            return janet_wrap_integer(janet_struct_length(janet_unwrap_struct(x)));
         case JANET_TABLE:
-            return janet_wrap_size(janet_unwrap_table(x)->count);
+            return janet_wrap_integer(janet_unwrap_table(x)->count);
         case JANET_ABSTRACT: {
             void *abst = janet_unwrap_abstract(x);
             const JanetAbstractType *type = janet_abstract_type(abst);
@@ -711,7 +715,7 @@ Janet janet_lengthv(Janet x) {
     }
 }
 
-void janet_putindex(Janet ds, size_t index, Janet value) {
+void janet_putindex(Janet ds, int32_t index, Janet value) {
     switch (janet_type(ds)) {
         default:
             janet_panicf("expected %T, got %v",
@@ -738,13 +742,13 @@ void janet_putindex(Janet ds, size_t index, Janet value) {
         }
         case JANET_TABLE: {
             JanetTable *table = janet_unwrap_table(ds);
-            janet_table_put(table, janet_wrap_size(index), value);
+            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_size(index), value);
+                (type->put)(janet_unwrap_abstract(ds), janet_wrap_integer(index), value);
             } else {
                 janet_panicf("no setter for %v ", ds);
             }
@@ -761,7 +765,7 @@ void janet_put(Janet ds, Janet key, Janet value) {
                          JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds);
         case JANET_ARRAY: {
             JanetArray *array = janet_unwrap_array(ds);
-            size_t index = getter_checksize(type, key, JANET_INTMAX_SIZE - 1);
+            int32_t index = getter_checkint(type, key, INT32_MAX - 1);
             if (index >= array->count) {
                 janet_array_setcount(array, index + 1);
             }
@@ -770,7 +774,7 @@ void janet_put(Janet ds, Janet key, Janet value) {
         }
         case JANET_BUFFER: {
             JanetBuffer *buffer = janet_unwrap_buffer(ds);
-            size_t index = getter_checksize(type, key, JANET_INTMAX_SIZE - 1);
+            int32_t index = getter_checkint(type, key, INT32_MAX - 1);
             if (!janet_checkint(value))
                 janet_panicf("can only put integers in buffers, got %v", value);
             if (index >= buffer->count) {

src/core/vm.c

@@ -318,7 +318,7 @@ static Janet janet_binop_call(const char *lmethod, const char *rmethod, Janet lh
         Janet lr = janet_method_lookup(rhs, rmethod);
         Janet argv[2] = { rhs, lhs };
         if (janet_checktype(lr, JANET_NIL)) {
-            janet_panicf("could not find method :%s for %v, or :%s for %v",
+            janet_panicf("could not find method :%s for %v or :%s for %v",
                          lmethod, lhs,
                          rmethod, rhs);
         }
@@ -997,7 +997,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
 
     VM_OP(JOP_PUSH_ARRAY) {
         const Janet *vals;
-        size_t len;
+        int32_t len;
         if (janet_indexed_view(stack[D], &vals, &len)) {
             janet_fiber_pushn(fiber, vals, len);
         } else {
@@ -1268,7 +1268,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
 /*
  * Execute a single instruction in the fiber. Does this by inspecting
  * the fiber, setting a breakpoint at the next instruction, executing, and
- * reseting breakpoints to how they were prior. Yes, it's a bit hacky.
+ * resetting breakpoints to how they were prior. Yes, it's a bit hacky.
  */
 JanetSignal janet_step(JanetFiber *fiber, Janet in, Janet *out) {
     /* No finished or currently alive fibers. */
@@ -1613,7 +1613,7 @@ int janet_init(void) {
     janet_vm.registry_count = 0;
     janet_vm.registry_dirty = 0;
 
-    /* Intialize abstract registry */
+    /* Initialize abstract registry */
     janet_vm.abstract_registry = janet_table(0);
     janet_gcroot(janet_wrap_table(janet_vm.abstract_registry));
 

src/core/wrap.c

@@ -88,12 +88,6 @@ int (janet_unwrap_boolean)(Janet x) {
 int32_t (janet_unwrap_integer)(Janet x) {
     return janet_unwrap_integer(x);
 }
-size_t (janet_unwrap_size)(Janet x) {
-    return janet_unwrap_size(x);
-}
-ssize_t (janet_unwrap_ssize)(Janet x) {
-    return janet_unwrap_ssize(x);
-}
 
 #if defined(JANET_NANBOX_32) || defined(JANET_NANBOX_64)
 Janet(janet_wrap_nil)(void) {
@@ -150,12 +144,6 @@ Janet(janet_wrap_pointer)(void *x) {
 Janet(janet_wrap_integer)(int32_t x) {
     return janet_wrap_integer(x);
 }
-Janet(janet_wrap_size)(size_t x) {
-    return janet_wrap_size(x);
-}
-Janet(janet_wrap_ssize)(ssize_t x) {
-    return janet_wrap_ssize(x);
-}
 #endif
 
 #ifndef JANET_NANBOX_32
@@ -172,10 +160,10 @@ Janet(janet_wrap_number)(double x) {
 
 /*****/
 
-void *janet_memalloc_empty(size_t count) {
-    size_t i;
-    void *mem = janet_malloc(count * sizeof(JanetKV));
-    janet_vm.next_collection += count * sizeof(JanetKV);
+void *janet_memalloc_empty(int32_t count) {
+    int32_t i;
+    void *mem = janet_malloc((size_t) count * sizeof(JanetKV));
+    janet_vm.next_collection += (size_t) count * sizeof(JanetKV);
     if (NULL == mem) {
         JANET_OUT_OF_MEMORY;
     }
@@ -188,8 +176,8 @@ void *janet_memalloc_empty(size_t count) {
     return mem;
 }
 
-void janet_memempty(JanetKV *mem, size_t count) {
-    size_t i;
+void janet_memempty(JanetKV *mem, int32_t count) {
+    int32_t i;
     for (i = 0; i < count; i++) {
         mem[i].key = janet_wrap_nil();
         mem[i].value = janet_wrap_nil();

src/include/janet.h

@@ -46,7 +46,7 @@ extern "C" {
 #endif
 
 /*
- * Detect OS and endianess.
+ * Detect OS and endianness.
  * From webkit source. There is likely some extreneous
  * detection for unsupported platforms
  */
@@ -112,7 +112,8 @@ extern "C" {
     || defined(__s390x__) /* S390 64-bit (BE) */ \
     || (defined(__ppc64__) || defined(__PPC64__)) \
     || defined(__aarch64__) /* ARM 64-bit */ \
-    || (defined(__riscv) && (__riscv_xlen == 64)) /* RISC-V 64-bit */
+    || (defined(__riscv) && (__riscv_xlen == 64)) /* RISC-V 64-bit */ \
+    || defined(__loongarch64) /* LoongArch64 64-bit */
 #define JANET_64 1
 #else
 #define JANET_32 1
@@ -143,6 +144,12 @@ extern "C" {
 #define JANET_LITTLE_ENDIAN 1
 #endif
 
+/* Limits for converting doubles to 64 bit integers */
+#define JANET_INTMAX_DOUBLE 9007199254740992.0
+#define JANET_INTMIN_DOUBLE (-9007199254740992.0)
+#define JANET_INTMAX_INT64 9007199254740992
+#define JANET_INTMIN_INT64 (-9007199254740992)
+
 /* Check emscripten */
 #ifdef __EMSCRIPTEN__
 #define JANET_NO_DYNAMIC_MODULES
@@ -255,7 +262,7 @@ extern "C" {
 #endif
 #endif
 
-/* Tell complier some functions don't return */
+/* Tell compiler some functions don't return */
 #ifndef JANET_NO_RETURN
 #ifdef JANET_WINDOWS
 #define JANET_NO_RETURN __declspec(noreturn)
@@ -265,7 +272,7 @@ extern "C" {
 #endif
 
 /* Prevent some recursive functions from recursing too deeply
- * ands crashing (the parser). Instead, error out. */
+ * and crashing (the parser). Instead, error out. */
 #define JANET_RECURSION_GUARD 1024
 
 /* Maximum depth to follow table prototypes before giving up and returning nil. */
@@ -366,26 +373,6 @@ typedef struct JanetOSRWLock JanetOSRWLock;
 #include <stddef.h>
 #include <stdio.h>
 
-/* Limits for converting doubles to 64 bit integers */
-#define JANET_INTMAX_DOUBLE 9007199254740992.0
-#define JANET_INTMIN_DOUBLE (-9007199254740992.0)
-#define JANET_INTMAX_INT64 9007199254740992
-#define JANET_INTMIN_INT64 (-9007199254740992)
-#if defined(JANET_64)
-    #define JANET_INTMAX_SIZE JANET_INTMAX_INT64
-    #define JANET_INTMIN_SIZE JANET_INTMIN_INT64
-#else
-    #define JANET_INTMAX_SIZE INT32_MAX
-    #define JANET_INTMIN_SIZE INT32_MIN
-#endif
-
-/* signed size */
-#ifdef _SSIZE_T
-typedef ssize_t ssize_t;
-#else
-typedef ptrdiff_t ssize_t;
-#endif
-
 /* What to do when out of memory */
 #ifndef JANET_OUT_OF_MEMORY
 #define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0)
@@ -650,6 +637,12 @@ JANET_API void janet_async_end(JanetFiber *fiber);
 /* Needed for windows to mark a fiber as waiting for an IOCP completion event. Noop on other platforms. */
 JANET_API void janet_async_in_flight(JanetFiber *fiber);
 
+/* On some platforms, it is important to be able to control if a stream is edge-trigger or level triggered.
+ * For example, a server that is accepting connections might want to be level triggered or edge-triggered
+ * depending on expected service. */
+JANET_API void janet_stream_edge_triggered(JanetStream *stream);
+JANET_API void janet_stream_level_triggered(JanetStream *stream);
+
 #endif
 
 /* Janet uses atomic integers in several places for synchronization between threads and
@@ -717,8 +710,6 @@ JANET_API JanetCFunction janet_unwrap_cfunction(Janet x);
 JANET_API int janet_unwrap_boolean(Janet x);
 JANET_API double janet_unwrap_number(Janet x);
 JANET_API int32_t janet_unwrap_integer(Janet x);
-JANET_API size_t janet_unwrap_size(Janet x);
-JANET_API ssize_t janet_unwrap_ssize(Janet x);
 
 JANET_API Janet janet_wrap_nil(void);
 JANET_API Janet janet_wrap_number(double x);
@@ -739,8 +730,6 @@ JANET_API Janet janet_wrap_table(JanetTable *x);
 JANET_API Janet janet_wrap_abstract(JanetAbstract x);
 JANET_API Janet janet_wrap_pointer(void *x);
 JANET_API Janet janet_wrap_integer(int32_t x);
-JANET_API Janet janet_wrap_size(size_t x);
-JANET_API Janet janet_wrap_ssize(ssize_t x);
 
 /***** END SECTION NON-C API *****/
 
@@ -908,25 +897,22 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 /* End of tagged union implementation */
 #endif
 
+JANET_API int janet_checkint16(Janet x);
+JANET_API int janet_checkuint16(Janet x);
 JANET_API int janet_checkint(Janet x);
 JANET_API int janet_checkuint(Janet x);
 JANET_API int janet_checkint64(Janet x);
 JANET_API int janet_checkuint64(Janet x);
 JANET_API int janet_checksize(Janet x);
-JANET_API int janet_checkssize(Janet x);
 JANET_API JanetAbstract janet_checkabstract(Janet x, const JanetAbstractType *at);
+#define janet_checkint16range(x) ((x) >= INT16_MIN && (x) <= INT16_MAX && (x) == (int16_t)(x))
+#define janet_checkuint16range(x) ((x) >= 0 && (x) <= UINT16_MAX && (x) == (uint16_t)(x))
 #define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x))
 #define janet_checkuintrange(x) ((x) >= 0 && (x) <= UINT32_MAX && (x) == (uint32_t)(x))
 #define janet_checkint64range(x) ((x) >= JANET_INTMIN_DOUBLE && (x) <= JANET_INTMAX_DOUBLE && (x) == (int64_t)(x))
 #define janet_checkuint64range(x) ((x) >= 0 && (x) <= JANET_INTMAX_DOUBLE && (x) == (uint64_t)(x))
-#define janet_checksizerange(x) ((x) >= 0 && (x) <= JANET_INTMAX_SIZE && (x) == (size_t)(x))
-#define janet_checkssizerange(x) ((x) >= JANET_INTMIN_SIZE && (x) <= JANET_INTMAX_SIZE && (x) == (ssize_t)(x))
 #define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x))
 #define janet_wrap_integer(x) janet_wrap_number((int32_t)(x))
-#define janet_unwrap_size(x) ((size_t) janet_unwrap_number(x))
-#define janet_wrap_size(x) janet_wrap_number((size_t)(x))
-#define janet_unwrap_ssize(x) ((ssize_t) janet_unwrap_number(x))
-#define janet_wrap_ssize(x) janet_wrap_number((ssize_t)(x))
 
 #define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps))
 
@@ -990,25 +976,25 @@ struct JanetStackFrame {
 /* A dynamic array type. */
 struct JanetArray {
     JanetGCObject gc;
-    size_t count;
-    size_t capacity;
+    int32_t count;
+    int32_t capacity;
     Janet *data;
 };
 
 /* A byte buffer type. Used as a mutable string or string builder. */
 struct JanetBuffer {
     JanetGCObject gc;
-    size_t count;
-    size_t capacity;
+    int32_t count;
+    int32_t capacity;
     uint8_t *data;
 };
 
 /* A mutable associative data type. Backed by a hashtable. */
 struct JanetTable {
     JanetGCObject gc;
-    size_t count;
-    size_t capacity;
-    size_t deleted;
+    int32_t count;
+    int32_t capacity;
+    int32_t deleted;
     JanetKV *data;
     JanetTable *proto;
 };
@@ -1022,7 +1008,7 @@ struct JanetKV {
 /* Prefix for a tuple */
 struct JanetTupleHead {
     JanetGCObject gc;
-    size_t length;
+    int32_t length;
     int32_t hash;
     int32_t sm_line;
     int32_t sm_column;
@@ -1032,9 +1018,9 @@ struct JanetTupleHead {
 /* Prefix for a struct */
 struct JanetStructHead {
     JanetGCObject gc;
-    size_t length;
+    int32_t length;
     int32_t hash;
-    size_t capacity;
+    int32_t capacity;
     const JanetKV *proto;
     const JanetKV data[];
 };
@@ -1042,7 +1028,7 @@ struct JanetStructHead {
 /* Prefix for a string */
 struct JanetStringHead {
     JanetGCObject gc;
-    size_t length;
+    int32_t length;
     int32_t hash;
     const uint8_t data[];
 };
@@ -1226,23 +1212,23 @@ struct JanetMethod {
 
 struct JanetView {
     const Janet *items;
-    size_t len;
+    int32_t len;
 };
 
 struct JanetByteView {
     const uint8_t *bytes;
-    size_t len;
+    int32_t len;
 };
 
 struct JanetDictView {
     const JanetKV *kvs;
-    size_t len;
-    size_t cap;
+    int32_t len;
+    int32_t cap;
 };
 
 struct JanetRange {
-    size_t start;
-    size_t end;
+    int32_t start;
+    int32_t end;
 };
 
 struct JanetRNG {
@@ -1601,17 +1587,17 @@ JANET_API JanetTable *janet_core_env(JanetTable *replacements);
 JANET_API JanetTable *janet_core_lookup_table(JanetTable *replacements);
 
 /* Execute strings */
-JANET_API int janet_dobytes(JanetTable *env, const uint8_t *bytes, size_t len, const char *sourcePath, Janet *out);
+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);
 
 /* Run the entrypoint of a wrapped program */
 JANET_API int janet_loop_fiber(JanetFiber *fiber);
 
 /* Number scanning */
-JANET_API int janet_scan_number(const uint8_t *str, size_t len, double *out);
-JANET_API int janet_scan_number_base(const uint8_t *str, size_t len, int32_t base, double *out);
-JANET_API int janet_scan_int64(const uint8_t *str, size_t len, int64_t *out);
-JANET_API int janet_scan_uint64(const uint8_t *str, size_t len, uint64_t *out);
+JANET_API int janet_scan_number(const uint8_t *str, int32_t len, double *out);
+JANET_API int janet_scan_number_base(const uint8_t *str, int32_t len, int32_t base, double *out);
+JANET_API int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out);
+JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out);
 
 /* Debugging */
 JANET_API void janet_debug_break(JanetFuncDef *def, int32_t pc);
@@ -1624,30 +1610,30 @@ JANET_API void janet_debug_find(
 extern JANET_API const JanetAbstractType janet_rng_type;
 JANET_API JanetRNG *janet_default_rng(void);
 JANET_API void janet_rng_seed(JanetRNG *rng, uint32_t seed);
-JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, size_t len);
+JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len);
 JANET_API uint32_t janet_rng_u32(JanetRNG *rng);
 JANET_API double janet_rng_double(JanetRNG *rng);
 
 /* Array functions */
-JANET_API JanetArray *janet_array(size_t capacity);
-JANET_API JanetArray *janet_array_weak(size_t capacity);
-JANET_API JanetArray *janet_array_n(const Janet *elements, size_t n);
-JANET_API void janet_array_ensure(JanetArray *array, size_t capacity, size_t growth);
-JANET_API void janet_array_setcount(JanetArray *array, size_t count);
+JANET_API JanetArray *janet_array(int32_t capacity);
+JANET_API JanetArray *janet_array_weak(int32_t capacity);
+JANET_API JanetArray *janet_array_n(const Janet *elements, int32_t n);
+JANET_API void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth);
+JANET_API void janet_array_setcount(JanetArray *array, int32_t count);
 JANET_API void janet_array_push(JanetArray *array, Janet x);
 JANET_API Janet janet_array_pop(JanetArray *array);
 JANET_API Janet janet_array_peek(JanetArray *array);
 
 /* Buffer functions */
 #define JANET_BUFFER_FLAG_NO_REALLOC 0x10000
-JANET_API JanetBuffer *janet_buffer(size_t capacity);
-JANET_API JanetBuffer *janet_buffer_init(JanetBuffer *buffer, size_t capacity);
-JANET_API JanetBuffer *janet_pointer_buffer_unsafe(void *memory, size_t capacity, size_t count);
+JANET_API JanetBuffer *janet_buffer(int32_t capacity);
+JANET_API JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity);
+JANET_API JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t count);
 JANET_API void janet_buffer_deinit(JanetBuffer *buffer);
-JANET_API void janet_buffer_ensure(JanetBuffer *buffer, size_t capacity, size_t growth);
-JANET_API void janet_buffer_setcount(JanetBuffer *buffer, size_t count);
-JANET_API void janet_buffer_extra(JanetBuffer *buffer, size_t n);
-JANET_API void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, size_t len);
+JANET_API void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth);
+JANET_API void janet_buffer_setcount(JanetBuffer *buffer, int32_t count);
+JANET_API void janet_buffer_extra(JanetBuffer *buffer, int32_t n);
+JANET_API void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t len);
 JANET_API void janet_buffer_push_string(JanetBuffer *buffer, JanetString string);
 JANET_API void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring);
 JANET_API void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t x);
@@ -1666,21 +1652,21 @@ JANET_API void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x);
 #define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line)
 #define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column)
 #define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags)
-JANET_API Janet *janet_tuple_begin(size_t length);
+JANET_API Janet *janet_tuple_begin(int32_t length);
 JANET_API JanetTuple janet_tuple_end(Janet *tuple);
-JANET_API JanetTuple janet_tuple_n(const Janet *values, size_t n);
+JANET_API JanetTuple janet_tuple_n(const Janet *values, int32_t n);
 
 /* String/Symbol functions */
 #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(size_t length);
+JANET_API uint8_t *janet_string_begin(int32_t length);
 JANET_API JanetString janet_string_end(uint8_t *str);
-JANET_API JanetString janet_string(const uint8_t *buf, size_t len);
+JANET_API JanetString janet_string(const uint8_t *buf, int32_t len);
 JANET_API JanetString janet_cstring(const char *cstring);
 JANET_API int janet_string_compare(JanetString lhs, JanetString rhs);
 JANET_API int janet_string_equal(JanetString lhs, JanetString rhs);
-JANET_API int janet_string_equalconst(JanetString lhs, const uint8_t *rhs, size_t rlen, int32_t rhash);
+JANET_API int janet_string_equalconst(JanetString lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash);
 JANET_API JanetString janet_description(Janet x);
 JANET_API JanetString janet_to_string(Janet x);
 JANET_API void janet_to_string_b(JanetBuffer *buffer, Janet x);
@@ -1692,7 +1678,7 @@ JANET_API JanetBuffer *janet_formatb(JanetBuffer *bufp, const char *format, ...)
 JANET_API void janet_formatbv(JanetBuffer *bufp, const char *format, va_list args);
 
 /* Symbol functions */
-JANET_API JanetSymbol janet_symbol(const uint8_t *str, size_t len);
+JANET_API JanetSymbol janet_symbol(const uint8_t *str, int32_t len);
 JANET_API JanetSymbol janet_csymbol(const char *str);
 JANET_API JanetSymbol janet_symbol_gen(void);
 #define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len)))
@@ -1711,7 +1697,7 @@ JANET_API JanetSymbol janet_symbol_gen(void);
 #define janet_struct_capacity(t) (janet_struct_head(t)->capacity)
 #define janet_struct_hash(t) (janet_struct_head(t)->hash)
 #define janet_struct_proto(t) (janet_struct_head(t)->proto)
-JANET_API JanetKV *janet_struct_begin(size_t count);
+JANET_API JanetKV *janet_struct_begin(int32_t count);
 JANET_API void janet_struct_put(JanetKV *st, Janet key, Janet value);
 JANET_API JanetStruct janet_struct_end(JanetKV *st);
 JANET_API Janet janet_struct_get(JanetStruct st, Janet key);
@@ -1721,9 +1707,9 @@ JANET_API JanetTable *janet_struct_to_table(JanetStruct st);
 JANET_API const JanetKV *janet_struct_find(JanetStruct st, Janet key);
 
 /* Table functions */
-JANET_API JanetTable *janet_table(size_t capacity);
-JANET_API JanetTable *janet_table_init(JanetTable *table, size_t capacity);
-JANET_API JanetTable *janet_table_init_raw(JanetTable *table, size_t capacity);
+JANET_API JanetTable *janet_table(int32_t capacity);
+JANET_API JanetTable *janet_table_init(JanetTable *table, int32_t capacity);
+JANET_API JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity);
 JANET_API void janet_table_deinit(JanetTable *table);
 JANET_API Janet janet_table_get(JanetTable *t, Janet key);
 JANET_API Janet janet_table_get_ex(JanetTable *t, Janet key, JanetTable **which);
@@ -1746,11 +1732,11 @@ JANET_API JanetFiber *janet_current_fiber(void);
 JANET_API JanetFiber *janet_root_fiber(void);
 
 /* Treat similar types through uniform interfaces for iteration */
-JANET_API int janet_indexed_view(Janet seq, const Janet **data, size_t *len);
-JANET_API int janet_bytes_view(Janet str, const uint8_t **data, size_t *len);
-JANET_API int janet_dictionary_view(Janet tab, const JanetKV **data, size_t *len, size_t *cap);
-JANET_API Janet janet_dictionary_get(const JanetKV *data, size_t cap, Janet key);
-JANET_API const JanetKV *janet_dictionary_next(const JanetKV *kvs, size_t cap, const JanetKV *kv);
+JANET_API int janet_indexed_view(Janet seq, const Janet **data, int32_t *len);
+JANET_API int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len);
+JANET_API int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap);
+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_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data)))
@@ -1826,17 +1812,17 @@ JANET_API int janet_cstrcmp(JanetString str, const char *other);
 JANET_API Janet janet_in(Janet ds, Janet key);
 JANET_API Janet janet_get(Janet ds, Janet key);
 JANET_API Janet janet_next(Janet ds, Janet key);
-JANET_API Janet janet_getindex(Janet ds, size_t index);
-JANET_API size_t janet_length(Janet x);
+JANET_API Janet janet_getindex(Janet ds, int32_t index);
+JANET_API int32_t janet_length(Janet x);
 JANET_API Janet janet_lengthv(Janet x);
 JANET_API void janet_put(Janet ds, Janet key, Janet value);
-JANET_API void janet_putindex(Janet ds, size_t index, Janet value);
+JANET_API void janet_putindex(Janet ds, int32_t index, Janet value);
 #define janet_flag_at(F, I) ((F) & ((1ULL) << (I)))
 JANET_API Janet janet_wrap_number_safe(double x);
 JANET_API int janet_keyeq(Janet x, const char *cstring);
 JANET_API int janet_streq(Janet x, const char *cstring);
 JANET_API int janet_symeq(Janet x, const char *cstring);
-JANET_API int32_t janet_sorted_keys(const JanetKV *dict, size_t cap, int32_t *index_buffer);
+JANET_API int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer);
 
 /* VM functions */
 JANET_API int janet_init(void);
@@ -2038,19 +2024,21 @@ JANET_API void *janet_getpointer(const Janet *argv, int32_t n);
 
 JANET_API int32_t janet_getnat(const Janet *argv, int32_t n);
 JANET_API int32_t janet_getinteger(const Janet *argv, int32_t n);
+JANET_API int16_t janet_getinteger16(const Janet *argv, int32_t n);
 JANET_API int64_t janet_getinteger64(const Janet *argv, int32_t n);
+JANET_API uint32_t janet_getuinteger(const Janet *argv, int32_t n);
+JANET_API uint16_t janet_getuinteger16(const Janet *argv, int32_t n);
 JANET_API uint64_t janet_getuinteger64(const Janet *argv, int32_t n);
 JANET_API size_t janet_getsize(const Janet *argv, int32_t n);
-JANET_API ssize_t janet_getssize(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);
 JANET_API void *janet_getabstract(const Janet *argv, int32_t n, const JanetAbstractType *at);
 JANET_API JanetRange janet_getslice(int32_t argc, const Janet *argv);
-JANET_API size_t janet_gethalfrange(const Janet *argv, int32_t n, size_t length, const char *which);
-JANET_API size_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, size_t length);
-JANET_API size_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, size_t length);
-JANET_API size_t janet_getargindex(const Janet *argv, int32_t n, size_t length, const char *which);
+JANET_API int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which);
+JANET_API int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length);
+JANET_API int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length);
+JANET_API int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which);
 JANET_API uint64_t janet_getflags(const Janet *argv, int32_t n, const char *flags);
 
 /* Optionals */
@@ -2071,13 +2059,12 @@ JANET_API int32_t janet_optnat(const Janet *argv, int32_t argc, int32_t n, int32
 JANET_API int32_t janet_optinteger(const Janet *argv, int32_t argc, int32_t n, int32_t dflt);
 JANET_API int64_t janet_optinteger64(const Janet *argv, int32_t argc, int32_t n, int64_t dflt);
 JANET_API size_t janet_optsize(const Janet *argv, int32_t argc, int32_t n, size_t dflt);
-JANET_API ssize_t janet_optssize(const Janet *argv, int32_t argc, int32_t n, ssize_t dflt);
 JANET_API JanetAbstract janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetAbstractType *at, JanetAbstract dflt);
 
 /* Mutable optional types specify a size default, and construct a new value if none is provided */
-JANET_API JanetBuffer *janet_optbuffer(const Janet *argv, int32_t argc, int32_t n, size_t dflt_len);
-JANET_API JanetTable *janet_opttable(const Janet *argv, int32_t argc, int32_t n, size_t dflt_len);
-JANET_API JanetArray *janet_optarray(const Janet *argv, int32_t argc, int32_t n, size_t dflt_len);
+JANET_API JanetBuffer *janet_optbuffer(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len);
+JANET_API JanetTable *janet_opttable(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len);
+JANET_API JanetArray *janet_optarray(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len);
 
 JANET_API Janet janet_dyn(const char *name);
 JANET_API void janet_setdyn(const char *name, Janet value);
@@ -2163,7 +2150,7 @@ typedef enum {
     RULE_TO,           /* [rule] */
     RULE_THRU,         /* [rule] */
     RULE_LENPREFIX,    /* [rule_a, rule_b (repeat rule_b rule_a times)] */
-    RULE_READINT,      /* [(signedness << 4) | (endianess << 5) | bytewidth, tag] */
+    RULE_READINT,      /* [(signedness << 4) | (endianness << 5) | bytewidth, tag] */
     RULE_LINE,         /* [tag] */
     RULE_COLUMN,       /* [tag] */
     RULE_UNREF,        /* [rule, tag] */
@@ -2198,8 +2185,8 @@ JANET_API Janet janet_wrap_s64(int64_t x);
 JANET_API Janet janet_wrap_u64(uint64_t x);
 JANET_API int64_t janet_unwrap_s64(Janet x);
 JANET_API uint64_t janet_unwrap_u64(Janet x);
-JANET_API int janet_scan_int64(const uint8_t *str, size_t len, int64_t *out);
-JANET_API int janet_scan_uint64(const uint8_t *str, size_t len, uint64_t *out);
+JANET_API int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out);
+JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out);
 
 #endif
 

src/mainclient/shell.c

@@ -626,7 +626,7 @@ static JanetByteView longest_common_prefix(void) {
         bv = gbl_matches[0];
         for (int i = 0; i < gbl_match_count; i++) {
             JanetByteView other = gbl_matches[i];
-            size_t minlen = other.len < bv.len ? other.len : bv.len;
+            int32_t minlen = other.len < bv.len ? other.len : bv.len;
             for (bv.len = 0; bv.len < minlen; bv.len++) {
                 if (bv.bytes[bv.len] != other.bytes[bv.len]) {
                     break;
@@ -691,7 +691,7 @@ static void doc_format(JanetString doc, int32_t width) {
     int32_t current = 0;
     if (maxcol > 200) maxcol = 200;
     fprintf(stderr, "    ");
-    for (size_t i = 0; i < janet_string_length(doc); i++) {
+    for (int32_t i = 0; i < janet_string_length(doc); i++) {
         uint8_t b = doc[i];
         switch (b) {
             default: {
@@ -814,13 +814,13 @@ static void kshowcomp(void) {
     check_specials(prefix);
 
     JanetByteView lcp = longest_common_prefix();
-    for (size_t i = prefix.len; i < lcp.len; i++) {
+    for (int i = prefix.len; i < lcp.len; i++) {
         insert(lcp.bytes[i], 0);
     }
 
     if (!gbl_lines_below && prefix.len != lcp.len) return;
 
-    size_t maxlen = 0;
+    int32_t maxlen = 0;
     for (int i = 0; i < gbl_match_count; i++)
         if (gbl_matches[i].len > maxlen)
             maxlen = gbl_matches[i].len;

test/suite-boot.janet

@@ -754,7 +754,7 @@
     (default name (string "has-key? " (++ test-has-key-auto)))
     (assert (= expected (has-key? col key)) name)
     (if
-      # guarenteed by `has-key?` to never fail
+      # guaranteed by `has-key?` to never fail
       expected (in col key)
       # if `has-key?` is false, then `in` should fail (for indexed types)
       #
@@ -976,4 +976,7 @@
 (assert (= () '() (macex '())) "macex ()")
 (assert (= '[] (macex '[])) "macex []")
 
+(assert (= :a (with-env @{:b :a} (dyn :b))) "with-env dyn")
+(assert-error "unknown symbol +" (with-env @{} (eval '(+ 1 2))))
+
 (end-suite)

test/suite-buffer.janet

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2024 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
@@ -85,9 +85,11 @@
 (buffer/push-uint16 buffer-uint16-le :le 0x0102)
 (assert (= "\x02\x01" (string buffer-uint16-le)) "buffer/push-uint16 little endian")
 
-(def buffer-uint16-negative @"")
-(buffer/push-uint16 buffer-uint16-negative :be -1)
-(assert (= "\xff\xff" (string buffer-uint16-negative)) "buffer/push-uint16 negative")
+(def buffer-uint16-max @"")
+(buffer/push-uint16 buffer-uint16-max :be 0xFFFF)
+(assert (= "\xff\xff" (string buffer-uint16-max)) "buffer/push-uint16 max")
+(assert-error "too large" (buffer/push-uint16 @"" 0x1FFFF))
+(assert-error "too small" (buffer/push-uint16 @"" -0x1))
 
 (def buffer-uint32-be @"")
 (buffer/push-uint32 buffer-uint32-be :be 0x01020304)
@@ -97,9 +99,9 @@
 (buffer/push-uint32 buffer-uint32-le :le 0x01020304)
 (assert (= "\x04\x03\x02\x01" (string buffer-uint32-le)) "buffer/push-uint32 little endian")
 
-(def buffer-uint32-negative @"")
-(buffer/push-uint32 buffer-uint32-negative :be -1)
-(assert (= "\xff\xff\xff\xff" (string buffer-uint32-negative)) "buffer/push-uint32 negative")
+(def buffer-uint32-max @"")
+(buffer/push-uint32 buffer-uint32-max :be 0xFFFFFFFF)
+(assert (= "\xff\xff\xff\xff" (string buffer-uint32-max)) "buffer/push-uint32 max")
 
 (def buffer-float32-be @"")
 (buffer/push-float32 buffer-float32-be :be 1.234)
@@ -162,5 +164,20 @@
 (assert (deep= @"abc423" (buffer/push-at @"abc123" 3 "4"))
         "buffer/push-at 3")
 
+# buffer/format-at
+(def start-buf (buffer/new-filled 100 (chr "x")))
+(buffer/format-at start-buf 50 "aa%dbb" 32)
+(assert (= (string start-buf) (string (string/repeat "x" 50) "aa32bb"  (string/repeat "x" 44)))
+        "buffer/format-at 1")
+(assert
+  (deep=
+    (buffer/format @"" "%j" [1 2 3 :a :b :c])
+    (buffer/format-at @"" 0 "%j" [1 2 3 :a :b :c]))
+  "buffer/format-at empty buffer")
+(def buf @"xxxyyy")
+(buffer/format-at buf -4 "xxx")
+(assert (= (string buf) "xxxxxx") "buffer/format-at negative index")
+(assert-error "expected index at to be in range [0, 0), got 1" (buffer/format-at @"" 1 "abc"))
+
 (end-suite)
 

test/suite-bundle.janet

@@ -0,0 +1,125 @@
+# Copyright (c) 2024 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 ./helper :prefix "" :exit true)
+(start-suite)
+
+(assert true) # smoke test
+
+# Copy since not exposed in boot.janet
+(defn- bundle-rpath
+  [path]
+  (string/replace-all "\\" "/" (os/realpath path)))
+
+(defn- rmrf
+  "rm -rf in janet"
+  [x]
+  (case (os/lstat x :mode)
+    nil nil
+    :directory (do
+                 (each y (os/dir x)
+                   (rmrf (string x "/" y)))
+                 (os/rmdir x))
+    (os/rm x))
+  nil)
+
+# Test mkdir -> rmdir
+(assert (os/mkdir "tempdir123"))
+(rmrf "tempdir123")
+
+# Setup a temporary syspath for manipultation
+(math/seedrandom (os/cryptorand 16))
+(def syspath (string (math/random) "_jpm_tree.tmp"))
+(rmrf syspath)
+(assert (os/mkdir syspath))
+(put root-env *syspath* (bundle-rpath syspath))
+(unless (os/getenv "VERBOSE")
+  (setdyn *out* @""))
+(assert (empty? (bundle/list)) "initial bundle/list")
+(assert (empty? (bundle/topolist)) "initial bundle/topolist")
+
+# Try (and fail) to install sample-bundle (missing deps)
+(assert-error "missing dependencies sample-dep1, sample-dep2"
+              (bundle/install "./examples/sample-bundle"))
+(assert (empty? (bundle/list)))
+
+# Install deps (dep1 as :auto-remove)
+(assert-no-error "sample-dep2"
+                 (bundle/install "./examples/sample-dep2"))
+(assert (= 1 (length (bundle/list))))
+(assert-no-error "sample-dep1" (bundle/install "./examples/sample-dep1"))
+(assert (= 2 (length (bundle/list))))
+
+(assert-no-error "sample-dep2 reinstall" (bundle/reinstall "sample-dep2"))
+(assert-no-error "sample-dep1 reinstall" (bundle/reinstall "sample-dep1" :auto-remove true))
+
+(assert (= 2 (length (bundle/list))) "bundles are listed correctly 1")
+(assert (= 2 (length (bundle/topolist))) "bundles are listed correctly 2")
+
+# Now install sample-bundle
+(assert-no-error "sample-bundle install" (bundle/install "./examples/sample-bundle"))
+
+(assert-error "" (bundle/install "./examples/sample-dep11111"))
+
+(assert (= 3 (length (bundle/list))) "bundles are listed correctly 3")
+(assert (= 3 (length (bundle/topolist))) "bundles are listed correctly 4")
+
+# Check topolist has not bad order
+(def tlist (bundle/topolist))
+(assert (> (index-of "sample-bundle" tlist) (index-of "sample-dep2" tlist)) "topolist 1")
+(assert (> (index-of "sample-bundle" tlist) (index-of "sample-dep1" tlist)) "topolist 2")
+(assert (> (index-of "sample-dep1" tlist) (index-of "sample-dep2" tlist)) "topolist 3")
+
+# Prune should do nothing
+(assert-no-error "first prune" (bundle/prune))
+(assert (= 3 (length (bundle/list))) "bundles are listed correctly 3")
+(assert (= 3 (length (bundle/topolist))) "bundles are listed correctly 4")
+
+# Check that we can import the main dependency
+(import mymod)
+(assert (= 288 (mymod/myfn 12)) "using sample-bundle")
+
+# Manual uninstall of dep1 and dep2 shouldn't work either since that would break dependencies
+(assert-error "cannot uninstall sample-dep1, breaks dependent bundles @[\"sample-bundle\"]"
+              (bundle/uninstall "sample-dep1"))
+
+# Now re-install sample-bundle as auto-remove
+(assert-no-error "sample-bundle install" (bundle/reinstall "sample-bundle" :auto-remove true))
+
+# Reinstallation should also work without being concerned about breaking dependencies
+(assert-no-error "reinstall dep" (bundle/reinstall "sample-dep2"))
+
+# Now prune should get rid of everything except sample-dep2
+(assert-no-error "second prune" (bundle/prune))
+
+# Now check that we exactly one package left, which is dep2
+(assert (= 1 (length (bundle/list))) "bundles are listed correctly 5")
+(assert (= 1 (length (bundle/topolist))) "bundles are listed correctly 6")
+
+# Which we can uninstall manually
+(assert-no-error "uninstall dep2" (bundle/uninstall "sample-dep2"))
+
+# Now check bundle listing is again empty
+(assert (= 0 (length (bundle/list))) "bundles are listed correctly 7")
+(assert (= 0 (length (bundle/topolist))) "bundles are listed correctly 8")
+
+(rmrf syspath)
+
+(end-suite)

test/suite-peg.janet

@@ -492,7 +492,7 @@
       # header, followed by body, and drop the :header-len capture
       :packet (/ (* :packet-header :packet-body) ,|$1)
 
-      # any exact seqence of packets (no extra characters)
+      # any exact sequence of packets (no extra characters)
       :main (* (any :packet) -1)}))
 
 (assert (deep= @["a" "bb" "ccc"] (peg/match peg2 "1:a2:bb3:ccc"))

test/suite-value.janet

@@ -42,7 +42,7 @@
 
 (defn buffer-factory
   []
-  @"im am a buffer")
+  @"i am a buffer")
 
 (assert (not= (buffer-factory) (buffer-factory)) "buffer instantiation")