Fix docstring.

stop doc-format detecting other modes within code blocks

.builds/.freebsd.yaml

@@ -1,11 +0,0 @@
-image: freebsd
-packages:
-  - gmake
-  - gcc
-sources:
-  - https://github.com/bakpakin/janet.git
-tasks:
-  - build: |
-      cd janet
-      gmake CC=gcc
-      gmake test CC=gcc

.builds/freebsd.yml

@@ -0,0 +1,11 @@
+image: freebsd/12.x
+sources:
+- https://git.sr.ht/~bakpakin/janet
+packages:
+- gmake
+tasks:
+- build: |
+    cd janet
+    gmake
+    gmake test
+    sudo gmake install

.builds/linux.yml

@@ -0,0 +1,21 @@
+image: archlinux
+sources:
+- https://git.sr.ht/~bakpakin/janet
+packages:
+- meson
+tasks:
+- with-epoll: |
+    cd janet
+    meson setup with-epoll --buildtype=release
+    cd with-epoll
+    meson configure -Depoll=true
+    ninja
+    ninja test
+- no-epoll: |
+    cd janet
+    meson setup no-epoll --buildtype=release
+    cd no-epoll
+    meson configure -Depoll=false
+    ninja
+    ninja test
+    sudo ninja install

.builds/openbsd.yml

@@ -0,0 +1,32 @@
+image: openbsd/latest
+sources:
+- https://git.sr.ht/~bakpakin/janet
+packages:
+- gmake
+- meson
+tasks:
+- gmake: |
+    cd janet
+    gmake
+    gmake test
+    doas gmake install
+    gmake test-install
+- meson_min: |
+    cd janet
+    meson setup build_meson_min --buildtype=release -Dsingle_threaded=true -Dnanbox=false -Ddynamic_modules=false -Ddocstrings=false -Dnet=false -Dsourcemaps=false -Dpeg=false -Dassembler=false -Dint_types=false -Dreduced_os=true -Dffi=false
+    cd build_meson_min
+    ninja
+- meson_prf: |
+    cd janet
+    meson setup build_meson_prf --buildtype=release -Dprf=true
+    cd build_meson_prf
+    ninja
+    ninja test
+- meson_default: |
+    cd janet
+    meson setup build_meson_default --buildtype=release
+    cd build_meson_default
+    ninja
+    ninja test
+    doas ninja install
+

.gitattributes

@@ -0,0 +1,9 @@
+*.janet linguist-language=Janet
+*.janet text eol=lf
+*.c text eol=lf
+*.h text eol=lf
+*.md text eol=lf
+*.yml text eol=lf
+*.build text eol=lf
+*.txt text eol=lf
+*.sh text eol=lf

.github/workflows/release.yml

@@ -0,0 +1,62 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+permissions:
+  contents: read
+
+jobs:
+
+  release:
+    permissions:
+      contents: write  # for softprops/action-gh-release to create GitHub release
+    name: Build release binaries
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, macos-latest ]
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@master
+      - name: Set the version
+        run: echo "version=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV
+      - name: Set the platform
+        run: echo "platform=$(tr '[A-Z]' '[a-z]' <<< $RUNNER_OS)" >> $GITHUB_ENV
+      - name: Compile the project
+        run: make clean && make
+      - name: Build the artifact
+        run: JANET_DIST_DIR=janet-${{ env.version }}-${{ env.platform }} make build/janet-${{ env.version }}-${{ env.platform }}-x64.tar.gz
+      - name: Draft the release
+        uses: softprops/action-gh-release@v1
+        with:
+          draft: true
+          files: |
+            build/*.gz
+            build/janet.h
+            build/c/janet.c
+            build/c/shell.c
+
+  release-windows:
+    permissions:
+      contents: write  # for softprops/action-gh-release to create GitHub release
+    name: Build release binaries for windows
+    runs-on: windows-latest
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@master
+      - name: Setup MSVC
+        uses: ilammy/msvc-dev-cmd@v1
+      - name: Build the project
+        shell: cmd
+        run: build_win all
+      - name: Draft the release
+        uses: softprops/action-gh-release@v1
+        with:
+          draft: true
+          files: |
+            ./dist/*.zip
+            ./*.zip
+            ./*.msi

.github/workflows/test.yml

@@ -0,0 +1,37 @@
+name: Test
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+
+  test-posix:
+    name: Build and test on POSIX systems
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, macos-latest ]
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@master
+      - name: Compile the project
+        run: make clean && make
+      - name: Test the project
+        run: make test
+
+  test-windows:
+    name: Build and test on Windows
+    runs-on: windows-latest
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@master
+      - name: Setup MSVC
+        uses: ilammy/msvc-dev-cmd@v1
+      - name: Build the project
+        shell: cmd
+        run: build_win
+      - name: Test the project
+        shell: cmd
+        run: build_win test

.gitignore

@@ -4,6 +4,7 @@ dst
 janet
 !*/**/janet
 /build
+/builddir
 /Build
 /Release
 /Debug
@@ -12,6 +13,30 @@ janet
 janet-*.tar.gz
 dist
 
+# jpm lockfile
+lockfile.janet
+
+# Kakoune (fzf via fd)
+.fdignore
+
+# VSCode
+.vscode
+
+# Eclipse
+.project
+.cproject
+
+# Gnome Builder
+.buildconfig
+
+# Local directory for testing
+local
+
+# Common test files I use.
+temp.janet
+temp*.janet
+scratch.janet
+
 # Emscripten
 *.bc
 janet.js
@@ -23,6 +48,7 @@ janet.wasm
 
 # Generate test files
 *.out
+.orig
 
 # Tools
 xxd
@@ -30,6 +56,7 @@ xxd.exe
 
 # VSCode
 .vs
+.clangd
 
 # Swap files
 *.swp
@@ -41,6 +68,10 @@ tags
 vgcore.*
 *.out.*
 
+# Wix artifacts
+*.msi
+*.wixpdb
+
 # Created by https://www.gitignore.io/api/c
 
 ### C ###
@@ -111,3 +142,6 @@ compile_commands.json
 CTestTestfile.cmake
 
 # End of https://www.gitignore.io/api/cmake
+
+# Astyle
+*.orig

.travis.yml

@@ -1,23 +0,0 @@
-language: c
-script:
-- make
-- make test
-- make build/janet-${TRAVIS_TAG}-${TRAVIS_OS_NAME}.tar.gz
-compiler:
-- clang
-- gcc
-os:
-- linux
-- osx
-before_deploy: 
-deploy:
-  provider: releases
-  api_key:
-    secure: JSqAOTH1jmfVlbOuPO3BbY1BhPq+ddiBNPCxuAyKHoVwfO4eNAmq9COI+UwCMWY3dg+YlspufRwkHj//B7QQ6hPbSsKu+Mapu6gr/CAE/jxbfO/E98LkIkUwbGjplwtzw2kiBkHN/Bu6J5X76cwo4D8nwQ1JIcV3nWtoG87t7H4W0R4AYQkbLGAPylgUFr11YMPx2cRBBqCdLAGIrny7kQ/0cRBfkN81R/gUJv/q3OjmUvY7sALXp7mFdZb75QPSilKIDuVUU5hLvPYTeRl6cWI/M+m5SmGZx1rjv5S9Qaw070XoNyt9JAADtbOUnADKvDguDZIP1FCuT1Gb+cnJPzrvk6+OBU9s8UjCTFtgV+LKlhmRZcwV5YQBE94PKRMJNC6VvIWM7UeQ8Zhm1jmQS6ONNWbuoUAlkZP57NtDQa2x0GT2wkubNSQKlaY+6/gwTD9KAJIzaZG7HYXH7b+4g7VbccCyhDAtDZtXgrOIS4WAkNc8rWezRO4H0qHMyON9aCEb0eTE8hWIufbx6ymG4gUxnYO+AkrEYMCwQvU6lS8BsevkaMTVtSShqlQtJ9FRlmJA3MA2ONyqzQXJENqRydyVbpFrKSv+0HbMyhEc5BoKbt0QcTh/slouNV4eASNar/GKN7aP8XKGUeMwIoCcRpP+3ehmwX9SUw7Ah5S42pA=
-  file: build/janet-${TRAVIS_TAG}-${TRAVIS_OS_NAME}.tar.gz
-  draft: true
-  skip_cleanup: true
-  on:
-    tags: true
-    repo: bakpakin/janet
-    condition: "$CC = clang"

CHANGELOG.md

@@ -0,0 +1,726 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+## 1.23.1 - ???
+- Don't process shared object names passed to dlopen.
+- Add better support for windows console in the default shell.c for autocompletion and
+  other shell-like input features.
+- Improve default error message from `assert`.
+- Add the `tabseq` macro for simpler table comprehensions.
+- Allow setting `(dyn :task-id)` in fibers to improve context in supervisor messages. Prior to
+  this change, supverisor messages over threaded channels would be from ambiguous threads/fibers.
+
+## 1.23.0 - 2022-06-20
+- Add experimental `ffi/` module for interfacing with dynamic libraries and raw function pointers. Only available
+  on 64 bit linux, mac, and bsd systems.
+- Allow using `&named` in function prototypes for named arguments. This is a more ergonomic
+  variant of `&keys` that isn't as redundant, more self documenting, and allows extension to
+  things like default arguments.
+- Add `delay` macro for lazy evaluate-and-save thunks.
+- Remove pthread.h from janet.h for easier includes.
+- Add `debugger` - an easy to use debugger function that just takes a fiber.
+- `dofile` will now start a debugger on errors if the environment it is passed has `:debug` set.
+- Add `debugger-on-status` function, which can be passed to `run-context` to start a debugger on
+  abnormal fiber signals.
+- Allow running scripts with the `-d` flag to use the built-in debugger on errors and breakpoints.
+- Add mutexes (locks) and reader-writer locks to ev module for thread coordination.
+- Add `parse-all` as a generalization of the `parse` function.
+- Add `os/cpu-count` to get the number of available processors on a machine
+
+## 1.22.0 - 2022-05-09
+- Prohibit negative size argument to `table/new`.
+- Add `module/value`.
+- Remove `file/popen`. Use `os/spawn` with the `:pipe` options instead.
+- Fix bug in peg `thru` and `to` combinators.
+- Fix printing issue in `doc` macro.
+- Numerous updates to function docstrings
+- Add `defdyn` aliases for various dynamic bindings used in core.
+- Install `janet.h` symlink to make Janet native libraries and applications
+  easier to build without `jpm`.
+
+## 1.21.2 - 2022-04-01
+- C functions `janet_dobytes` and `janet_dostring` will now enter the event loop if it is enabled.
+- Fix hashing regression - hash of negative 0 must be the same as positive 0 since they are equal.
+- The `flycheck` function no longer pollutes the module/cache
+- Fix quasiquote bug in compiler
+- Disallow use of `cancel` and `resume` on fibers scheduled or created with `ev/go`, as well as the root
+  fiber.
+
+## 1.20.0 - 2022-1-27
+- Add `:missing-symbol` hook to `compile` that will act as a catch-all macro for undefined symbols.
+- Add `:redef` dynamic binding that will allow users to redefine top-level bindings with late binding. This
+  is intended for development use.
+- Fix a bug with reading from a stream returned by `os/open` on Windows and Linux.
+- Add `:ppc64` as a detectable OS type.
+- Add `& more` support for destructuring in the match macro.
+- Add `& more` support for destructuring in all binding forms (`def`).
+
+## 1.19.2 - 2021-12-06
+- Fix bug with missing status lines in some stack traces.
+- Update hash function to have better statistical properties.
+
+## 1.19.1 - 2021-12-04
+- Add an optional `prefix` parameter to `debug/stacktrace` to allow printing prettier error messages.
+- Remove appveyor for CI pipeline
+- Fixed a bug that prevented sending threaded abstracts over threaded channels.
+- Fix bug in the `map` function with arity at least 3.
+
+## 1.19.0 - 2021-11-27
+- Add `math/log-gamma` to replace `math/gamma`, and change `math/gamma` to be the expected gamma function.
+- Fix leaking file-descriptors in os/spawn and os/execute.
+- Ctrl-C will now raise SIGINT.
+- Allow quoted literals in the `match` macro to behave as expected in patterns.
+- Fix windows net related bug for TCP servers.
+- Allow evaluating ev streams with dofile.
+- Fix `ev` related bug with operations on already closed file descriptors.
+- Add struct and table agnostic `getproto` function.
+- Add a number of functions related to structs.
+- Add prototypes to structs. Structs can now inherit from other structs, just like tables.
+- Create a struct with a prototype with `struct/with-proto`.
+- Deadlocked channels will no longer exit early - instead they will hang, which is more intuitive.
+
+## 1.18.1 - 2021-10-16
+- Fix some documentation typos
+- Fix - Set pipes passed to subprocess to blocking mode.
+- Fix `-r` switch in repl.
+
+## 1.18.0 - 2021-10-10
+- Allow `ev/cancel` to work on already scheduled fibers.
+- Fix bugs with ev/ module.
+- Add optional `base` argument to scan-number
+- Add `-i` flag to janet binary to make it easier to run image files from the command line
+- Remove `thread/` module.
+- Add `(number ...)` pattern to peg for more efficient number parsing using Janet's
+  scan-number function without immediate string creation.
+
+## 1.17.2 - 2021-09-18
+- Remove include of windows.h from janet.h. This caused issues on certain projects.
+- Fix formatting in doc-format to better handle special characters in signatures.
+- Fix some marshalling bugs.
+- Add optional Makefile target to install jpm as well.
+- Supervisor channels in threads will no longer include a wasteful copy of the fiber in every
+  message across a thread.
+- Allow passing a closure to `ev/thread` as well as a whole fiber.
+- Allow passing a closure directly to `ev/go` to spawn fibers on the event loop.
+
+## 1.17.1 - 2021-08-29
+- Fix docstring typos
+- Add `make install-jpm-git` to make jpm co-install simpler if using the Makefile.
+- Fix bugs with starting ev/threads and fiber marshaling.
+
+## 1.17.0 - 2021-08-21
+- Add the `-E` flag for one-liners with the `short-fn` syntax for argument passing.
+- Add support for threaded abstract types. Threaded abstract types can easily be shared between threads.
+- Deprecate the `thread` library. Use threaded channels and ev instead.
+- Channels can now be marshalled.
+- 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 `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
+  separately like any other package.
+- Fix issue with `ev/go` when called with an initial value and supervisor.
+- Add the C API functions `janet_vm_save` and `janet_vm_load` to allow
+saving and restoring the entire VM state.
+
+## 1.16.1 - 2021-06-09
+- Add `maclintf` - a utility for adding linting messages when inside macros.
+- Print source code of offending line on compiler warnings and errors.
+- Fix some issues with linting and re-add missing `make docs`.
+- Allow controlling linting with dynamic bindings `:lint-warn`, `:lint-error`, and `:lint-levels`.
+- Add `-w` and `-x` command line flags to the `janet` binary to set linting thresholds.
+  linting thresholds are as follows:
+    - :none - will never be trigger.
+    - :relaxed - will only trigger on `:relaxed` lints.
+    - :normal - will trigger on `:relaxed` and `:normal` lints.
+    - :strict - will trigger on `:strict`, `:normal`, and `:relaxed` lints. This will catch the most issues
+      but can be distracting.
+
+## 1.16.0 - 2021-05-30
+- Add color documentation to the `doc` macro - enable/disable with `(dyn :doc-color)`.
+- Remove simpler HTML docs from distribution - use website or built-in documentation instead.
+- Add compiler warnings and deprecation levels.
+- Add `as-macro` to make using macros within quasiquote easier to do hygienically.
+- Expose `JANET_OUT_OF_MEMORY` as part of the Janet API.
+- Add `native-deps` option to `declare-native` in `jpm`. This lets native libraries link to other
+  native libraries when building with jpm.
+- Remove the `tarray` module. The functionality of typed arrays will be moved to an external module
+  that can be installed via `jpm`.
+- Add `from-pairs` to core.
+- Add `JPM_OS_WHICH` environment variable to jpm to allow changing auto-detection behavior.
+- The flychecker will consider any top-level calls of functions that start with `define-` to
+  be safe to execute and execute them. This allows certain patterns (like spork/path) to be
+  better processed by the flychecker.
+
+## 1.15.5 - 2021-04-25
+- Add `declare-headers` to jpm.
+- Fix error using unix pipes on BSDs.
+- Support .cc and .cxx extensions in `jpm` for C++ code.
+- Change networking code to not create as many HUP errors.
+- Add `net/shutdown` to close sockets in one direction without hang ups.
+- Update code for printing the debug repl
+
+## 1.15.4 - 2021-03-16
+- Increase default nesting depth of pretty printing to `JANET_RECURSION_GUARD`
+- Update meson.build
+- Add option to automatically add shebang line in installed scripts with `jpm`.
+- Add `partition-by` and `group-by` to the core.
+- Sort keys in pretty printing output.
+
+## 1.15.3 - 2021-02-28
+- Fix a fiber bug that occured in deeply nested fibers
+- Add `unref` combinator to pegs.
+- Small docstring changes.
+
+## 1.15.2 - 2021-02-15
+- Fix bug in windows version of `os/spawn` and `os/execute` with setting environment variables.
+- Fix documentation typos.
+- Fix peg integer reading combinators when used with capture tags.
+
+## 1.15.0 - 2021-02-08
+- Fix `gtim` and `ltim` bytecode instructions on non-integer values.
+- Clean up output of flychecking to be the same as the repl.
+- Change behavior of `debug/stacktrace` with a nil error value.
+- Add optional argument to `parser/produce`.
+- Add `no-core` option to creating standalone binaries to make execution faster.
+- Fix bug where a buffer overflow could be confused with an out of memory error.
+- Change error output to `file:line:column: message`. Column is in bytes - tabs
+  are considered to have width 1 (instead of 8).
+
+## 1.14.2 - 2021-01-23
+- Allow `JANET_PROFILE` env variable to load a profile before loading the repl.
+- Update `tracev` macro to allow `def` and `var` inside to work as expected.
+- Use `(dyn :peg-grammar)` for passing a default grammar to `peg/compile` instead of loading
+  `default-peg-grammar` directly from the root environment.
+- Add `ev/thread` for combining threading with the event loop.
+- Add `ev/do-thread` to make `ev/thread` easier to use.
+- Automatically set supervisor channel in `net/accept-loop` and `net/server` correctly.
+
+## 1.14.1 - 2021-01-18
+- Add `doc-of` for reverse documentation lookup.
+- Add `ev/give-supervsior` to send a message to the supervising channel.
+- Add `ev/gather` and `chan` argument to `ev/go`. This new argument allows "supervisor channels"
+  for fibers to enable structured concurrency.
+- Make `-k` flag work on stdin if no files are given.
+- Add `flycheck` function to core.
+- Make `backmatch` and `backref` more expressive in pegs.
+- Fix buggy `string/split`.
+- Add `fiber/last-value` to get the value that was last yielded, errored, or signaled
+  by a fiber.
+- Remove `:generate` verb from `loop` macros. Instead, use the `:in` verb
+  which will now work on fibers as well as other data structures.
+- Define `next`, `get`, and `in` for fibers. This lets
+  `each`, `map`, and similar iteration macros can now iterate over fibers.
+- Remove macro `eachy`, which can be replaced by `each`.
+- Add `dflt` argument to find-index.
+- Deprecate `file/popen` in favor of `os/spawn`.
+- Add `:all` keyword to `ev/read` and `net/read` to make them more like `file/read`. However, we
+  do not provide any `:line` option as that requires buffering.
+- Change repl behavior to make Ctrl-C raise SIGINT on posix. The old behavior for Ctrl-C,
+  to clear the current line buffer, has been moved to Ctrl-Q.
+- Importing modules that start with `/` is now the only way to import from project root.
+  Before, this would import from / on disk. Previous imports that did not start with `.` or `/`
+  are now unambiguously importing from the syspath, instead of checking both the syspath and
+  the project root. This is backwards incompatible and dependencies should be updated for this.
+- Change hash function for numbers.
+- Improve error handling of `dofile`.
+- Bug fixes in networking and subprocess code.
+- Use markdown formatting in more places for docstrings.
+
+## 1.13.1 - 2020-12-13
+- Pretty printing a table with a prototype will look for `:_name` instead of `:name`
+  in the prototype table to tag the output.
+- `match` macro implementation changed to be tail recursive.
+- Adds a :preload loader which allows one to manually put things into `module/cache`.
+- Add `buffer/push` function.
+- Backtick delimited strings and buffers are now reindented based on the column of the
+  opening delimiter. Whitespace in columns to the left of the starting column is ignored unless
+  there are non-space/non-newline characters in that region, in which case the old behavior is preserved.
+- Argument to `(error)` combinator in PEGs is now optional.
+- Add `(line)` and `(column)` combinators to PEGs to capture source line and column.
+  This should make error reporting a bit easier.
+- Add `merge-module` to core.
+- During installation and release, merge janetconf.h into janet.h for easier install.
+- Add `upscope` special form.
+- `os/execute` and `os/spawn` can take streams for redirecting IO.
+- Add `:parser` and `:read` parameters to `run-context`.
+- Add `os/open` if ev is enabled.
+- Add `os/pipe` if ev is enabled.
+- Add `janet_thread_current(void)` to C API
+- Add integer parsing forms to pegs. This makes parsing many binary protocols easier.
+- Lots of updates to networking code - now can use epoll (or poll) on linux and IOCP on windows.
+- Add `ev/` module. This exposes a fiber scheduler, queues, timeouts, and other functionality to users
+  for single threaded cooperative scheduling and asynchronous IO.
+- Add `net/accept-loop` and `net/listen`. These functions break down `net/server` into it's essential parts
+  and are more flexible. They also allow further improvements to these utility functions.
+- Various small bug fixes.
+
+## 1.12.2 - 2020-09-20
+- Add janet\_try and janet\_restore to C API.
+- Fix `os/execute` regression on windows.
+- Add :pipe option to `os/spawn`.
+- Fix docstring typos.
+
+## 1.12.1 - 2020-09-07
+- Make `zero?`, `one?`, `pos?`, and `neg?` polymorphic.
+- Add C++ support to jpm and improve C++ interop in janet.h.
+- Add `%t` formatter to `printf`, `string/format`, and other formatter functions.
+- Expose `janet_cfuns_prefix` in C API.
+- Add `os/proc-wait` and `os/proc-kill` for interacting with processes.
+- Add `janet_getjfile` to C API.
+- Allow redirection of stdin, stdout, and stderr by passing keywords in the env table in `os/spawn` and `os/execute`.
+- Add `os/spawn` to get a core/process back instead of an exit code as in `os/execute`.
+  When called like this, `os/execute` returns immediately.
+- Add `:x` flag to os/execute to raise error when exit code is non-zero.
+- Don't run `main` when flychecking.
+- Add `:n` flag to `file/open` to raise an error if file cannot be opened.
+- Fix import macro to not try and coerce everything to a string.
+- Allow passing a second argument to `disasm`.
+- Add `cancel`. Resumes a fiber but makes it immediately error at the yield point.
+- Allow multi-line paste into built in repl.
+- Add `(curenv)`.
+- Change `net/read`, `net/chunk`, and `net/write` to raise errors in the case of failures.
+- Add `janet_continue_signal` to C API. This indirectly enables C functions that yield to the event loop
+  to raise errors or other signals.
+- Update meson build script to fix bug on Debian's version of meson
+- Add `xprint`, `xprin`, `xprintf`, and `xprinf`.
+- `net/write` now raises an error message if write fails.
+- Fix issue with SIGPIPE on macOS and BSDs.
+
+## 1.11.3 - 2020-08-03
+- Add `JANET_HASHSEED` environment variable when `JANET_PRF` is enabled.
+- Expose `janet_cryptorand` in C API.
+- Properly initialize PRF in default janet program
+- Add `index-of` to core library.
+- Add `-fPIC` back to core CFLAGS (non-optional when compiling default client with Makefile)
+- Fix defaults on Windows for ARM
+- Fix defaults on NetBSD.
+
+## 1.11.1 - 2020-07-25
+- Fix jpm and git with multiple git installs on Windows
+- Fix importing a .so file in the current directory
+- Allow passing byte sequence types directly to typed-array constructors.
+- Fix bug sending files between threads.
+- Disable PRF by default.
+- Update the soname.
+
+## 1.11.0 - 2020-07-18
+- Add `forever` macro.
+- Add `any?` predicate to core.
+- Add `jpm list-pkgs` subcommand to see which package aliases are in the listing.
+- Add `jpm list-installed` subcommand to see which packages are installed.
+- Add `math/int-min`, `math/int-max`, `math/int32-min`, and `math/int32-max` for getting integer limits.
+- The gc interval is now autotuned, to prevent very bad gc behavior.
+- Improvements to the bytecode compiler, Janet will now generate more efficient bytecode.
+- Add `peg/find`, `peg/find-all`, `peg/replace`, and `peg/replace-all`
+- Add `math/nan`
+- Add `forv` macro
+- Add `symbol/slice`
+- Add `keyword/slice`
+- Allow cross compilation with Makefile.
+- Change `compare-primitve` 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.
+- Fix `%j` formatter to print numbers precisely (using the `%.17g` format string to printf).
+
+## 1.10.1 - 2020-06-18
+- Expose `janet_table_clear` in API.
+- Respect `JANET_NO_PROCESSES` define when building
+- Fix `jpm` rules having multiple copies of the same dependency.
+- Fix `jpm` install in some cases.
+- Add `array/trim` and `buffer/trim` to shrink the backing capacity of these types
+  to their current length.
+
+## 1.10.0 - 2020-06-14
+- Hardcode default jpm paths on install so env variables are needed in fewer cases.
+- Add `:no-compile` to `create-executable` option for jpm.
+- Fix bug with the `trace` function.
+- Add `:h`, `:a`, and `:c` flags to `thread/new` for creating new kinds of threads.
+  By default, threads will now consume much less memory per thread, but sending data between
+  threads may cost more.
+- Fix flychecking when using the `use` macro.
+- CTRL-C no longer exits the repl, and instead cancels the current form.
+- Various small bug fixes
+- New MSI installer instead of NSIS based installer.
+- Make `os/realpath` work on windows.
+- Add polymorphic `compare` functions for comparing numbers.
+- Add `to` and `thru` peg combinators.
+- Add `JANET_GIT` environment variable to jpm to use a specific git binary (useful mainly on windows).
+- `asm` and `disasm` functions now use keywords instead of macros for keys. Also
+  some slight changes to the way constants are encoded (remove wrapping `quote` in some cases).
+- Expose current macro form inside macros as (dyn :macro-form)
+- Add `tracev` macro.
+- Fix compiler bug that emitted incorrect code in some cases for while loops that create closures.
+- Add `:fresh` option to `(import ...)` to overwrite the module cache.
+- `(range x y 0)` will return an empty array instead of hanging forever.
+- Rename `jpm repl` to `jpm debug-repl`.
+
+## 1.9.1 - 2020-05-12
+- Add :prefix option to declare-source
+- Re-enable minimal builds with the debugger.
+- Add several flags for configuring Janet on different platforms.
+- Fix broken meson build from 1.9.0 and add meson to CI.
+- Fix compilation issue when nanboxing is disabled.
+
+## 1.9.0 - 2020-05-10
+- Add `:ldflags` option to many jpm declare functions.
+- Add `errorf` to core.
+- Add `lenprefix` combinator to PEGs.
+- Add `%M`, `%m`, `%N`, and `%n` formatters to formatting functions. These are the
+  same as `%Q`, `%q`, `%P`, and `%p`, but will not truncate long values.
+- Add `fiber/root`.
+- Add beta `net/` module to core for socket based networking.
+- Add the `parse` function to parse strings of source code more conveniently.
+- Add `jpm rule-tree` subcommand.
+- Add `--offline` flag to jpm to force use of the cache.
+- Allow sending pointers and C functions across threads via `thread/send`.
+- Fix bug in `getline`.
+- Add `sh-rule` and `sh-phony` to jpm's dialect of Janet.
+- Change C api's `janet_formatb` -> `janet_formatbv`, and add new function `janet_formatb` to C api.
+- Add `edefer` macro to core.
+- A struct/table literal/constructor with duplicate keys will use the last value given.
+  Previously, this was inconsistent between tables and structs, literals and constructor functions.
+- Add debugger to core. The debugger functions are only available
+  in a debug repl, and are prefixed by a `.`.
+- Add `sort-by` and `sorted-by` to core.
+- Support UTF-8 escapes in strings via `\uXXXX` or `\UXXXXXX`.
+- Add `math/erf`
+- Add `math/erfc`
+- Add `math/log1p`
+- Add `math/next`
+- Add os/umask
+- Add os/perm-int
+- Add os/perm-string
+- Add :int-permissions option for os/stat.
+- Add `jpm repl` subcommand, as well as `post-deps` macro in project.janet files.
+- Various bug fixes.
+
+## 1.8.1 - 2020-03-31
+- Fix bugs for big endian systems
+- Fix 1.8.0 regression on BSDs
+
+## 1.8.0 - 2020-03-29
+- Add `reduce2`, `accumulate`, and `accumulate2`.
+- Add lockfiles to `jpm` via `jpm make-lockfile` and `jpm load-lockfile`.
+- Add `os/realpath` (Not supported on windows).
+- Add `os/chmod`.
+- Add `chr` macro.
+- Allow `_` in the `match` macro to match anything without creating a binding
+  or doing unification. Also change behavior of matching nil.
+- Add `:range-to` and `:down-to` verbs in the `loop` macro.
+- Fix `and` and `or` macros returning nil instead of false in some cases.
+- Allow matching successfully against nil values in the `match` macro.
+- Improve `janet_formatc` and `janet_panicf` formatters to be more like `string/format`.
+  This makes it easier to make nice error messages from C.
+- Add `signal`
+- Add `fiber/can-resume?`
+- Allow fiber functions to accept arguments that are passed in via `resume`.
+- Make flychecking slightly less strict but more useful
+- Correct arity for `next`
+- Correct arity for `marshal`
+- Add `flush` and `eflush`
+- Add `prompt` and `return` on top of signal for user friendly delimited continuations.
+- Fix bug in buffer/blit when using the offset-src argument.
+- Fix segfault with malformed pegs.
+
+## 1.7.0 - 2020-02-01
+- Remove `file/fileno` and `file/fdopen`.
+- Remove `==`, `not==`, `order<`, `order>`, `order<=`, and `order>=`. Instead, use the normal
+  comparison and equality functions.
+- Let abstract types define a hash function and comparison/equality semantics. This lets
+  abstract types much better represent value types. This adds more fields to abstract types, which
+  will generate warnings when compiled against other versions.
+- Remove Emscripten build. Instead, use the amalgamated source code with a custom toolchain.
+- Update documentation.
+- Add `var-`
+- Add `module/add-paths`
+- Add `file/temp`
+- Add `mod` function to core.
+- Small bug fixes
+- Allow signaling from C functions (yielding) via janet\_signalv. This
+  makes it easy to write C functions that work with event loops, such as
+  in libuv or embedded in a game.
+- Add '%j' formatting option to the format family of functions.
+- Add `defer`
+- Add `assert`
+- Add `when-with`
+- Add `if-with`
+- Add completion to the default repl based on currently defined bindings. Also generally improve
+  the repl keybindings.
+- Add `eachk`
+- Add `eachp`
+- Improve functionality of the `next` function. `next` now works on many different
+  types, not just tables and structs. This allows for more generic data processing.
+- Fix thread module issue where sometimes decoding a message failed.
+- Fix segfault regression when macros are called with bad arity.
+
+## 1.6.0 - 2019-12-22
+- Add `thread/` module to the core.
+- Allow seeding RNGs with any sequence of bytes. This provides
+  a wider key space for the RNG. Exposed in C as `janet_rng_longseed`.
+- Fix issue in `resume` and similar functions that could cause breakpoints to be skipped.
+- Add a number of new math functions.
+- Improve debugger experience and capabilities. See examples/debugger.janet
+  for what an interactive debugger could look like.
+- Add `debug/step` (janet\_step in the C API) for single stepping Janet bytecode.
+- The built in repl now can enter the debugger on any signal (errors, yields,
+  user signals, and debug signals). To enable this, type (setdyn :debug true)
+  in the repl environment.
+- When exiting the debugger, the fiber being debugged is resumed with the exit value
+  of the debug session (the value returned by `(quit return-value)`, or nil if user typed Ctrl-D).
+- `(quit)` can take an optional argument that is the return value. If a module
+  contains `(quit some-value)`, the value of that module returned to `(require "somemod")`
+  is the return value. This lets module writers completely customize a module without writing
+  a loader.
+- Add nested quasiquotation.
+- Add `os/cryptorand`
+- Add `prinf` and `eprinf` to be have like `printf` and `eprintf`. The latter two functions
+  now including a trailing newline, like the other print functions.
+- Add nan?
+- Add `janet_in` to C API.
+- Add `truthy?`
+- Add `os/environ`
+- Add `buffer/fill` and `array/fill`
+- Add `array/new-filled`
+- Use `(doc)` with no arguments to see available bindings and dynamic bindings.
+- `jpm` will use `CC` and `AR` environment variables when compiling programs.
+- Add `comptime` macro for compile time evaluation.
+- Run `main` functions in scripts if they exist, just like jpm standalone binaries.
+- Add `protect` macro.
+- Add `root-env` to get the root environment table.
+- Change marshalling protocol with regard to abstract types.
+- Add `show-paths` to `jpm`.
+- Add several default patterns, like `:d` and `:s+`, to PEGs.
+- Update `jpm` path settings to make using `jpm` easier on non-global module trees.
+- Numerous small bug fixes and usability improvements.
+
+### 1.5.1 - 2019-11-16
+- Fix bug when printing buffer to self in some edge cases.
+- Fix bug with `jpm` on windows.
+- Fix `update` return value.
+
+## 1.5.0 - 2019-11-10
+- `os/date` now defaults to UTC.
+- Add `--test` flag to jpm to test libraries on installation.
+- Add `math/rng`, `math/rng-int`, and `math/rng-uniform`.
+- Add `in` function to index in a stricter manner. Conversely, `get` will
+  now not throw errors on bad keys.
+- Indexed types and byte sequences will now error when indexed out of range or
+  with bad keys.
+- Add rng functions to Janet. This also replaces the RNG behind `math/random`
+  and `math/seedrandom` with a consistent, platform independent RNG.
+- Add `with-vars` macro.
+- Add the `quickbin` command to jpm.
+- Create shell.c when making the amalgamated source. This can be compiled with
+  janet.c to make the janet interpreter.
+- Add `cli-main` function to the core, which invokes Janet's CLI interface.
+  This basically moves what was init.janet into boot.janet.
+- Improve flychecking, and fix flychecking bugs introduced in 1.4.0.
+- Add `prin`, `eprint`, `eprintf` and `eprin` functions. The
+  functions prefix with e print to `(dyn :err stderr)`
+- Print family of functions can now also print to buffers
+  (before, they could only print to files.) Output can also
+  be completely disabled with `(setdyn :out false)`.
+- `printf` is now a c function for optimizations in the case
+  of printing to buffers.
+
+## 1.4.0 - 2019-10-14
+- Add `quit` function to exit from a repl, but not always exit the entire
+  application.
+- Add `update-pkgs` to jpm.
+- Integrate jpm with https://github.com/janet-lang/pkgs.git. jpm can now
+  install packages based on their short names in the package listing, which
+  can be customized via an env variable.
+- Add `varfn` macro
+- Add compile time arity checking when function in function call is known.
+- Added `slice` to the core library.
+- The `*/slice` family of functions now can take nil as start or end to get
+  the same behavior as the defaults (0 and -1) for those parameters.
+- `string/` functions that take a pattern to search for will throw an error
+  when receiving the empty string.
+- Replace (start:end) style stacktrace source position information with
+  line, column. This should be more readable for humans. Also, range information
+  can be recovered by re-parsing source.
+
+## 1.3.1 - 2019-09-21
+- Fix some linking issues when creating executables with native dependencies.
+- jpm now runs each test script in a new interpreter.
+- Fix an issue that prevent some valid programs from compiling.
+- Add `mean` to core.
+- Abstract types that implement the `:+`, `:-`, `:*`, `:/`, `:>`, `:==`, `:<`,
+  `:<=`, and `:>=` methods will work with the corresponding built-in
+  arithmetic functions. This means built-in integer types can now be used as
+  normal number values in many contexts.
+- Allow (length x) on typed arrays an other abstract types that implement
+  the :length method.
+
+## 1.3.0 - 2019-09-05
+- Add `get-in`, `put-in`, `update-in`, and `freeze` to core.
+- Add `jpm run rule` and `jpm rules` to jpm to improve utility and discoverability of jpm.
+- Remove `cook` module and move `path` module to https://github.com/janet-lang/path.git.
+  The functionality in `cook` is now bundled directly in the `jpm` script.
+- Add `buffer/format` and `string/format` format flags `Q` and `q` to print colored and
+  non-colored single-line values, similar to `P` and `p`.
+- Change default repl to print long sequences on one line and color stacktraces if color is enabled.
+- Add `backmatch` pattern for PEGs.
+- jpm detects if not in a Developer Command prompt on windows for a better error message.
+- jpm install git submodules in dependencies
+- Change default fiber stack limit to the maximum value of a 32 bit signed integer.
+- Some bug fixes with `jpm`
+- Fix bugs with pegs.
+- Add `os/arch` to get ISA that janet was compiled for
+- Add color to stacktraces via `(dyn :err-color)`
+
+## 1.2.0 - 2019-08-08
+- Add `take` and `drop` functions that are easier to use compared to the
+  existing slice functions.
+- Add optional default value to `get`.
+- Add function literal short-hand via `|` reader macro, which maps to the
+  `short-fn` macro.
+- Add `int?` and `nat?` functions to the core.
+- Add `(dyn :executable)` at top level to get what used to be
+  `(process/args 0)`.
+- Add `:linux` to platforms returned by `(os/which)`.
+- Update jpm to build standalone executables. Use `declare-executable` for this.
+- Add `use` macro.
+- Remove `process/args` in favor of `(dyn :args)`.
+- Fix bug with Nanbox implementation allowing users to created
+  custom values of any type with typed array and marshal modules, which
+  was unsafe.
+- Add `janet_wrap_number_safe` to API, for converting numbers to Janets
+  where the number could be any 64 bit, user provided bit pattern. Certain
+  NaN values (which a machine will never generate as a result of a floating
+  point operation) are guarded against and converted to a default NaN value.
+
+## 1.1.0 - 2019-07-08
+- Change semantics of `-l` flag to be import rather than dofile.
+- Fix compiler regression in top level defs with destructuring.
+- Add `table/clone`.
+- Improve `jpm` tool with git and dependency capabilities, as well as better
+  module uninstalls.
+
+## 1.0.0 - 2019-07-01
+- Add `with` macro for resource handling.
+- Add `propagate` function so we can "rethrow" signals after they are
+  intercepted. This makes signals even more flexible.
+- Add `JANET_NO_DOCSTRINGS` and `JANET_NO_SOURCEMAPS` defines in janetconf.h
+  for shrinking binary size.
+  This seems to save about 50kB in most builds, so it's not usually worth it.
+- Update module system to allow relative imports. The `:cur:` pattern
+  in `module/expand-path` will expand to the directory part of the current file, or
+  whatever the value of `(dyn :current-file)` is. The `:dir:` pattern gets
+  the directory part of the input path name.
+- Remove `:native:` pattern in `module/paths`.
+- Add `module/expand-path`
+- Remove `module/*syspath*` and `module/*headerpath*` in favor of dynamic
+  bindings `:syspath` and `:headerpath`.
+- Compiled PEGs can now be marshaled and unmarshaled.
+- Change signature to `parser/state`
+- Add `:until` verb to loop.
+- Add `:p` flag to `fiber/new`.
+- Add `file/{fdopen,fileno}` functions.
+- Add `parser/clone` function.
+- Add optional argument to `parser/where` to set parser byte index.
+- Add optional `env` argument to `all-bindings` and `all-dynamics`.
+- Add scratch memory C API functions for auto-released memory on next gc.
+  Scratch memory differs from normal GCed memory as it can also be freed normally
+  for better performance.
+- Add API compatibility checking for modules. This will let native modules not load
+  when the host program is not of a compatible version or configuration.
+- Change signature of `os/execute` to be much more flexible.
+
+## 0.6.0 - 2019-05-29
+- `file/close` returns exit code when closing file opened with `file/popen`.
+- Add `os/rename`
+- Update windows installer to include tools like `jpm`.
+- Add `jpm` tool for building and managing projects.
+- Change interface to `cook` tool.
+- Add optional filters to `module/paths` to further refine import methods.
+- Add keyword arguments via `&keys` in parameter list.
+- Add `-k` flag for flychecking source.
+- Change signature to `compile` function.
+- Add `module/loaders` for custom loading functions.
+- Add external unification to `match` macro.
+- Add static library to main build.
+- Add `janet/*headerpath*` and change location of installed headers.
+- Let `partition` take strings.
+- Haiku OS support
+- Add `string/trim`, `string/trimr`, and `string/triml`.
+- Add `dofile` function.
+- Numbers require at least 1 significant digit.
+- `file/read` will return nil on end of file.
+- Fix various bugs.
+
+## 0.5.0 - 2019-05-09
+- Fix some bugs with buffers.
+- Add `trace` and `untrace` to the core library.
+- Add `string/has-prefix?` and `string/has-suffix?` to string module.
+- Add simple debugger to repl that activates on errors or debug signal
+- Remove `*env*` and `*doc-width*`.
+- Add `fiber/getenv`, `fiber/setenv`, and `dyn`, and `setdyn`.
+- Add support for dynamic bindings (via the `dyn` and `setdyn` functions).
+- Change signatures of some functions like `eval` which no longer takes
+  an optional environment.
+- Add printf function
+- Make `pp` configurable with dynamic binding `:pretty-format`.
+- Remove the `meta` function.
+- Add `with-dyns` for blocks with dynamic bindings assigned.
+- Allow leading and trailing newlines in backtick-delimited string (long strings).
+  These newlines will not be included in the actual string value.
+
+## 0.4.1 - 2019-04-14
+- Squash some bugs
+- Peg patterns can now make captures in any position in a grammar.
+- Add color to repl output
+- Add array/remove function
+- Add meson build support
+- Add int module for int types
+- Add meson build option
+- Add (break) special form and improve loop macro
+- Allow abstract types to specify custom tostring method
+- Extend C API for marshalling abstract types and other values
+- Add functions to `os` module.
+
+## 0.4.0 - 2019-03-08
+- Fix a number of smaller bugs
+- Added :export option to import and require
+- Added typed arrays
+- Remove `callable?`.
+- Remove `tuple/append` and `tuple/prepend`, which may have seemed like `O(1)`
+  operations. Instead, use the `splice` special to extend tuples.
+- Add `-m` flag to main client to allow specifying where to load
+  system modules from.
+- Add `-c` flag to main client to allow compiling Janet modules to images.
+- Add `string/format` and `buffer/format`.
+- Remove `string/pretty` and `string/number`.
+- `make-image` function creates pre compiled images for janet. These images
+  link to the core library. They can be loaded via require or manually via
+  `load-image`.
+- Add bracketed tuples as tuple constructor.
+- Add partition function to core library.
+- Pre-compile core library into an image for faster startup.
+- Add methods to parser values that mirror the api.
+- Add janet\_getmethod to CAPI for easier use of method like syntax.
+- Add get/set to abstract types to allow them to behave more
+  like objects with methods.
+- Add parser/insert to modify parser state programmatically
+- Add debug/stacktrace for easy, pretty stacktraces
+- Remove the status-pp function
+- Update API to run-context to be much more sane
+- Add :lflags option to cook/make-native
+- Disallow NaNs as table or struct keys
+- Update module resolution paths and format
+
+## 0.3.0 - 2019-01-26
+- Add amalgamated build to janet for easier embedding.
+- Add os/date function
+- Add slurp and spit to core library.
+- Added this changelog.
+- Added peg module (Parsing Expression Grammars)
+- Move hand written documentation into website repository.

CONTRIBUTING.md

@@ -14,7 +14,6 @@ Please read this document before making contributions.
   on how to reproduce it. If it is a compiler or language bug, please try to include a minimal
   example. This means don't post all 200 lines of code from your project, but spend some time
   distilling the problem to just the relevant code.
-* Add the `bug` tag to the issue.
 
 ## Contributing Changes
 
@@ -29,9 +28,14 @@ may require changes before being merged.
   run tests with `make test`. If you want to add a new test suite, simply add a file to
   the test folder and make sure it is run when`make test` is invoked.
 * Be consistent with the style. For C this means follow the indentation and style in
-  other files (files have MIT license at top, 4 spaces indentation, no trailing whitespace, cuddled brackets, etc.)
-  For janet code, the use lisp indentation with 2 spaces. One can use janet.vim to
-  do this indentation, or approximate as close as possible.
+  other files (files have MIT license at top, 4 spaces indentation, no trailing
+  whitespace, cuddled brackets, etc.) Use `make format` to automatically format your C code with
+  [astyle](http://astyle.sourceforge.net/astyle.html). You will probably need
+  to install this, but it can be installed with most package managers.
+
+  For janet code, use lisp indentation with 2 spaces. One can use janet.vim to
+  do this indentation, or approximate as close as possible. There is a janet formatter
+  in [spork](https://github.com/janet-lang/spork.git) that can be used to format code as well.
 
 ## C style
 
@@ -39,8 +43,7 @@ For changes to the VM and Core code, you will probably need to know C. Janet is
 a subset of C99 that works with Microsoft Visual C++. This means most of C99 but with the following
 omissions.
 
-* No Variable Length Arrays (yes these may work in newer MSVC compilers)
-* No `restrict` 
+* No `restrict`
 * Certain functions in the standard library are not always available
 
 In practice, this means programming for both MSVC on one hand and everything else on the other.
@@ -51,11 +54,33 @@ Code should compile warning free and run valgrind clean. I find that these two c
 of the easiest ways to protect against a large number of bugs in an unsafe language like C. To check for
 valgrind errors, run `make valtest` and check the output for undefined or flagged behavior.
 
+### Formatting
+
+Use [astyle](http://astyle.sourceforge.net/astyle.html) via `make format` to
+ensure a consistent code style for C.
+
 ## Janet style
 
 All janet code in the project should be formatted similar to the code in core.janet.
 The auto formatting from janet.vim will work well.
 
+## Typo Fixing and One-Line changes
+
+Typo fixes are welcome, as are simple one line fixes. Do not open many separate pull requests for each
+individual typo fix. This is incredibly annoying to deal with as someone needs to review each PR, run
+CI, and merge. Instead, accumulate batches of typo fixes into a single PR. If there are objections to
+specific changes, these can be addressed in the review process before the final merge, if the changes
+are accepted.
+
+Similarly, low effort and bad faith changes are annoying to developers and such issues may be closed
+immediately without response.
+
+## Contributions from Automated Tools
+
+People making changes found or generated by automated tools MUST note this when opening an issue
+or creating a pull request. This can help give context to developers if the change/issue is
+confusing or nonsensical.
+
 ## Suggesting Changes
 
 To suggest changes, open an issue on GitHub. Check GitHub for other issues
@@ -65,4 +90,3 @@ timely manner. In short, if you want extra functionality now, then build it.
 
 * Include a good description of the problem that is being solved
 * Include descriptions of potential solutions if you have some in mind.
-* Add the appropriate tags to the issue. For new features, add the `enhancement` tag.

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2019 Calvin Rose
+Copyright (c) 2021 Calvin Rose and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

Makefile

@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Calvin Rose
+# Copyright (c) 2022 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -24,111 +24,186 @@
 
 PREFIX?=/usr/local
 
-INCLUDEDIR=$(PREFIX)/include/janet
-LIBDIR=$(PREFIX)/lib
-BINDIR=$(PREFIX)/bin
-JANET_BUILD?="\"$(shell git log --pretty=format:'%h' -n 1)\""
-
-CFLAGS=-std=c99 -Wall -Wextra -Isrc/include -fpic -O2 -fvisibility=hidden \
-	   -DJANET_BUILD=$(JANET_BUILD)
-CLIBS=-lm -ldl
+INCLUDEDIR?=$(PREFIX)/include
+BINDIR?=$(PREFIX)/bin
+LIBDIR?=$(PREFIX)/lib
+JANET_BUILD?="\"$(shell git log --pretty=format:'%h' -n 1 2> /dev/null || echo local)\""
+CLIBS=-lm -lpthread
 JANET_TARGET=build/janet
 JANET_LIBRARY=build/libjanet.so
-JANET_PATH?=/usr/local/lib/janet
+JANET_STATIC_LIBRARY=build/libjanet.a
+JANET_PATH?=$(LIBDIR)/janet
+JANET_MANPATH?=$(PREFIX)/share/man/man1/
+JANET_PKG_CONFIG_PATH?=$(LIBDIR)/pkgconfig
+JANET_DIST_DIR?=janet-dist
+JPM_TAG?=master
 DEBUGGER=gdb
+SONAME_SETTER=-Wl,-soname,
 
+# For cross compilation
+HOSTCC?=$(CC)
+HOSTAR?=$(AR)
+CFLAGS?=-O2
+LDFLAGS?=-rdynamic
+
+COMMON_CFLAGS:=-std=c99 -Wall -Wextra -Isrc/include -Isrc/conf -fvisibility=hidden -fPIC
+BOOT_CFLAGS:=-DJANET_BOOTSTRAP -DJANET_BUILD=$(JANET_BUILD) -O0 -g $(COMMON_CFLAGS)
+BUILD_CFLAGS:=$(CFLAGS) $(COMMON_CFLAGS)
+
+# For installation
+LDCONFIG:=ldconfig "$(LIBDIR)"
+
+# Check OS
 UNAME:=$(shell uname -s)
-LDCONFIG:=ldconfig
 ifeq ($(UNAME), Darwin)
-	# Add other macos/clang flags
-	LDCONFIG:=
-else
-	CFLAGS:=$(CFLAGS) -rdynamic
-	CLIBS:=$(CLIBS) -lrt
+	CLIBS:=$(CLIBS) -ldl
+	SONAME_SETTER:=-Wl,-install_name,
+	JANET_LIBRARY=build/libjanet.dylib
+	LDCONFIG:=true
+else ifeq ($(UNAME), Linux)
+	CLIBS:=$(CLIBS) -lrt -ldl
 endif
 
-$(shell mkdir -p build/core build/mainclient build/webclient)
+# For other unix likes, add flags here!
+ifeq ($(UNAME), Haiku)
+	LDCONFIG:=true
+	LDFLAGS=-Wl,--export-dynamic
+endif
+# For Android (termux)
+ifeq ($(UNAME), Linux) # uname on Darwin doesn't recognise -o
+ifeq ($(shell uname -o), Android)
+	CLIBS:=$(CLIBS) -landroid-spawn
+endif
+endif
 
-# Source headers
-JANET_HEADERS=$(sort $(wildcard src/include/janet/*.h))
-JANET_LOCAL_HEADERS=$(sort $(wildcard src/*/*.h))
-
-# Source files
-JANET_CORE_SOURCES=$(sort $(wildcard src/core/*.c))
-JANET_MAINCLIENT_SOURCES=$(sort $(wildcard src/mainclient/*.c))
-JANET_WEBCLIENT_SOURCES=$(sort $(wildcard src/webclient/*.c))
-
-all: $(JANET_TARGET) $(JANET_LIBRARY)
-
-##########################################################
-##### The main interpreter program and shared object #####
-##########################################################
-
-JANET_CORE_OBJECTS=$(patsubst src/%.c,build/%.o,$(JANET_CORE_SOURCES)) build/core.gen.o
-JANET_MAINCLIENT_OBJECTS=$(patsubst src/%.c,build/%.o,$(JANET_MAINCLIENT_SOURCES)) build/init.gen.o
-
-%.gen.o: %.gen.c
-	$(CC) $(CFLAGS) -o $@ -c $<
-
-build/%.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS)
-	$(CC) $(CFLAGS) -o $@ -c $<
-
-$(JANET_TARGET): $(JANET_CORE_OBJECTS) $(JANET_MAINCLIENT_OBJECTS)
-	$(CC) $(CFLAGS) -o $@ $^ $(CLIBS)
-
-$(JANET_LIBRARY): $(JANET_CORE_OBJECTS)
-	$(CC) $(CFLAGS) -shared -o $@ $^ $(CLIBS)
+$(shell mkdir -p build/core build/c build/boot)
+all: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.h
 
 ######################
-##### Emscripten #####
+##### Name Files #####
 ######################
 
-EMCC=emcc
-EMCFLAGS=-std=c99 -Wall -Wextra -Isrc/include -O2 \
-		  -s EXTRA_EXPORTED_RUNTIME_METHODS='["cwrap"]' \
-		  -s ALLOW_MEMORY_GROWTH=1 \
-		  -s AGGRESSIVE_VARIABLE_ELIMINATION=1 \
-		  -DJANET_BUILD=$(JANET_BUILD)
-JANET_EMTARGET=build/janet.js
-JANET_WEB_SOURCES=$(JANET_CORE_SOURCES) $(JANET_WEBCLIENT_SOURCES)
-JANET_EMOBJECTS=$(patsubst src/%.c,build/%.bc,$(JANET_WEB_SOURCES)) \
-				build/webinit.gen.bc build/core.gen.bc
+JANET_HEADERS=src/include/janet.h src/conf/janetconf.h
 
-%.gen.bc: %.gen.c
-	$(EMCC) $(EMCFLAGS) -o $@ -c $<
+JANET_LOCAL_HEADERS=src/core/features.h \
+					src/core/util.h \
+					src/core/state.h \
+					src/core/gc.h \
+					src/core/vector.h \
+					src/core/fiber.h \
+					src/core/regalloc.h \
+					src/core/compile.h \
+					src/core/emit.h \
+					src/core/symcache.h
 
-build/%.bc: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS)
-	$(EMCC) $(EMCFLAGS) -o $@ -c $<
+JANET_CORE_SOURCES=src/core/abstract.c \
+				   src/core/array.c \
+				   src/core/asm.c \
+				   src/core/buffer.c \
+				   src/core/bytecode.c \
+				   src/core/capi.c \
+				   src/core/cfuns.c \
+				   src/core/compile.c \
+				   src/core/corelib.c \
+				   src/core/debug.c \
+				   src/core/emit.c \
+				   src/core/ev.c \
+				   src/core/ffi.c \
+				   src/core/fiber.c \
+				   src/core/gc.c \
+				   src/core/inttypes.c \
+				   src/core/io.c \
+				   src/core/marsh.c \
+				   src/core/math.c \
+				   src/core/net.c \
+				   src/core/os.c \
+				   src/core/parse.c \
+				   src/core/peg.c \
+				   src/core/pp.c \
+				   src/core/regalloc.c \
+				   src/core/run.c \
+				   src/core/specials.c \
+				   src/core/state.c \
+				   src/core/string.c \
+				   src/core/strtod.c \
+				   src/core/struct.c \
+				   src/core/symcache.c \
+				   src/core/table.c \
+				   src/core/tuple.c \
+				   src/core/util.c \
+				   src/core/value.c \
+				   src/core/vector.c \
+				   src/core/vm.c \
+				   src/core/wrap.c
 
-$(JANET_EMTARGET): $(JANET_EMOBJECTS)
-	$(EMCC) $(EMCFLAGS) -shared -o $@ $^
+JANET_BOOT_SOURCES=src/boot/array_test.c \
+				   src/boot/boot.c \
+				   src/boot/buffer_test.c \
+				   src/boot/number_test.c \
+				   src/boot/system_test.c \
+				   src/boot/table_test.c
+JANET_BOOT_HEADERS=src/boot/tests.h
 
-emscripten: $(JANET_EMTARGET)
+##########################################################
+##### The bootstrap interpreter that creates janet.c #####
+##########################################################
 
-#############################
-##### Generated C files #####
-#############################
+JANET_BOOT_OBJECTS=$(patsubst src/%.c,build/%.boot.o,$(JANET_CORE_SOURCES) $(JANET_BOOT_SOURCES))
 
-build/xxd: tools/xxd.c
-	$(CC) $< -o $@
+$(JANET_BOOT_OBJECTS): $(JANET_BOOT_HEADERS)
 
-build/core.gen.c: src/core/core.janet build/xxd
-	build/xxd $< $@ janet_gen_core
-build/init.gen.c: src/mainclient/init.janet build/xxd
-	build/xxd $< $@ janet_gen_init
-build/webinit.gen.c: src/webclient/webinit.janet build/xxd
-	build/xxd $< $@ janet_gen_webinit
+build/%.boot.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
+	$(CC) $(BOOT_CFLAGS) -o $@ -c $<
+
+build/janet_boot: $(JANET_BOOT_OBJECTS)
+	$(CC) $(BOOT_CFLAGS) -o $@ $(JANET_BOOT_OBJECTS) $(CLIBS)
+
+# Now the reason we bootstrap in the first place
+build/c/janet.c: build/janet_boot src/boot/boot.janet
+	build/janet_boot . JANET_PATH '$(JANET_PATH)' > $@
+	cksum $@
+
+########################
+##### Amalgamation #####
+########################
+
+ifeq ($(UNAME), Darwin)
+SONAME=libjanet.1.23.dylib
+else
+SONAME=libjanet.so.1.23
+endif
+
+build/c/shell.c: src/mainclient/shell.c
+	cp $< $@
+
+build/janet.h: $(JANET_TARGET) src/include/janet.h src/conf/janetconf.h
+	./$(JANET_TARGET) tools/patch-header.janet src/include/janet.h src/conf/janetconf.h $@
+
+build/janetconf.h: src/conf/janetconf.h
+	cp $< $@
+
+build/janet.o: build/c/janet.c src/conf/janetconf.h src/include/janet.h
+	$(HOSTCC) $(BUILD_CFLAGS) -c $< -o $@
+
+build/shell.o: build/c/shell.c src/conf/janetconf.h src/include/janet.h
+	$(HOSTCC) $(BUILD_CFLAGS) -c $< -o $@
+
+$(JANET_TARGET): build/janet.o build/shell.o
+	$(HOSTCC) $(LDFLAGS) $(BUILD_CFLAGS) -o $@ $^ $(CLIBS)
+
+$(JANET_LIBRARY): build/janet.o build/shell.o
+	$(HOSTCC) $(LDFLAGS) $(BUILD_CFLAGS) $(SONAME_SETTER)$(SONAME) -shared -o $@ $^ $(CLIBS)
+
+$(JANET_STATIC_LIBRARY): build/janet.o build/shell.o
+	$(HOSTAR) rcs $@ $^
 
 ###################
 ##### Testing #####
 ###################
 
-TEST_SOURCES=$(wildcard ctest/*.c)
-TEST_PROGRAMS=$(patsubst ctest/%.c,build/%.out,$(TEST_SOURCES))
-TEST_SCRIPTS=$(wildcard test/suite*.janet)
+# Testing assumes HOSTCC=CC
 
-build/%.out: ctest/%.c $(JANET_CORE_OBJECTS)
-	$(CC) $(CFLAGS) -o $@ $^ $(CLIBS)
+TEST_SCRIPTS=$(wildcard test/suite*.janet)
 
 repl: $(JANET_TARGET)
 	./$(JANET_TARGET)
@@ -142,15 +217,15 @@ valgrind: $(JANET_TARGET)
 	$(VALGRIND_COMMAND) ./$(JANET_TARGET)
 
 test: $(JANET_TARGET) $(TEST_PROGRAMS)
-	for f in build/*.out; do "$$f" || exit; done
-	for f in test/*.janet; do ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do ./$(JANET_TARGET) "$$f" || exit; done
+	for f in examples/*.janet; do ./$(JANET_TARGET) -k "$$f"; done
 
 valtest: $(JANET_TARGET) $(TEST_PROGRAMS)
-	for f in build/*.out; do $(VALGRIND_COMMAND) "$$f" || exit; done
-	for f in test/*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
+	for f in examples/*.janet; do ./$(JANET_TARGET) -k "$$f"; done
 
 callgrind: $(JANET_TARGET)
-	for f in test/*.janet; do valgrind --tool=callgrind ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do valgrind --tool=callgrind ./$(JANET_TARGET) "$$f" || exit; done
 
 ########################
 ##### Distribution #####
@@ -158,10 +233,22 @@ callgrind: $(JANET_TARGET)
 
 dist: build/janet-dist.tar.gz
 
-build/janet-%.tar.gz: $(JANET_TARGET) src/include/janet/janet.h \
-	janet.1 LICENSE CONTRIBUTING.md $(JANET_LIBRARY) \
-	build/doc.html README.md $(wildcard doc/*.md)
-	tar -czvf $@ $^
+build/janet-%.tar.gz: $(JANET_TARGET) \
+	build/janet.h \
+	janet.1 LICENSE CONTRIBUTING.md $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) \
+	README.md build/c/janet.c build/c/shell.c
+	mkdir -p build/$(JANET_DIST_DIR)/bin
+	cp $(JANET_TARGET) build/$(JANET_DIST_DIR)/bin/
+	mkdir -p build/$(JANET_DIST_DIR)/include
+	cp build/janet.h build/$(JANET_DIST_DIR)/include/
+	mkdir -p build/$(JANET_DIST_DIR)/lib/
+	cp $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/$(JANET_DIST_DIR)/lib/
+	mkdir -p build/$(JANET_DIST_DIR)/man/man1/
+	cp janet.1 build/$(JANET_DIST_DIR)/man/man1/janet.1
+	mkdir -p build/$(JANET_DIST_DIR)/src/
+	cp build/c/janet.c build/c/shell.c build/$(JANET_DIST_DIR)/src/
+	cp CONTRIBUTING.md LICENSE README.md build/$(JANET_DIST_DIR)/
+	cd build && tar -czvf ../$@ ./$(JANET_DIST_DIR)
 
 #########################
 ##### Documentation #####
@@ -172,32 +259,113 @@ docs: build/doc.html
 build/doc.html: $(JANET_TARGET) tools/gendoc.janet
 	$(JANET_TARGET) tools/gendoc.janet > build/doc.html
 
+########################
+##### Installation #####
+########################
+
+.INTERMEDIATE: build/janet.pc
+build/janet.pc: $(JANET_TARGET)
+	echo 'prefix=$(PREFIX)' > $@
+	echo 'exec_prefix=$${prefix}' >> $@
+	echo 'includedir=$(INCLUDEDIR)/janet' >> $@
+	echo 'libdir=$(LIBDIR)' >> $@
+	echo "" >> $@
+	echo "Name: janet" >> $@
+	echo "Url: https://janet-lang.org" >> $@
+	echo "Description: Library for the Janet programming language." >> $@
+	$(JANET_TARGET) -e '(print "Version: " janet/version)' >> $@
+	echo 'Cflags: -I$${includedir}' >> $@
+	echo 'Libs: -L$${libdir} -ljanet' >> $@
+	echo 'Libs.private: $(CLIBS)' >> $@
+
+install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc build/janet.h
+	mkdir -p '$(DESTDIR)$(BINDIR)'
+	cp $(JANET_TARGET) '$(DESTDIR)$(BINDIR)/janet'
+	mkdir -p '$(DESTDIR)$(INCLUDEDIR)/janet'
+	cp -r build/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet'
+	ln -sf -T ./janet/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet.h' || true #fixme bsd
+	mkdir -p '$(DESTDIR)$(JANET_PATH)'
+	mkdir -p '$(DESTDIR)$(LIBDIR)'
+	if test $(UNAME) = Darwin ; then \
+		cp $(JANET_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.$(shell $(JANET_TARGET) -e '(print janet/version)').dylib' ; \
+		ln -sf $(SONAME) '$(DESTDIR)$(LIBDIR)/libjanet.dylib' ; \
+		ln -sf libjanet.$(shell $(JANET_TARGET) -e '(print janet/version)').dylib $(DESTDIR)$(LIBDIR)/$(SONAME) ; \
+	else \
+		cp $(JANET_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.so.$(shell $(JANET_TARGET) -e '(print janet/version)')' ; \
+		ln -sf $(SONAME) '$(DESTDIR)$(LIBDIR)/libjanet.so' ; \
+		ln -sf libjanet.so.$(shell $(JANET_TARGET) -e '(print janet/version)') $(DESTDIR)$(LIBDIR)/$(SONAME) ; \
+	fi
+	cp $(JANET_STATIC_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.a'
+	mkdir -p '$(DESTDIR)$(JANET_MANPATH)'
+	cp janet.1 '$(DESTDIR)$(JANET_MANPATH)'
+	mkdir -p '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)'
+	cp build/janet.pc '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)/janet.pc'
+	[ -z '$(DESTDIR)' ] && $(LDCONFIG) || echo "You can ignore this error for non-Linux systems or local installs"
+
+install-jpm-git: $(JANET_TARGET)
+	mkdir -p build
+	rm -rf build/jpm
+	git clone --depth=1 --branch='$(JPM_TAG)' https://github.com/janet-lang/jpm.git build/jpm
+	cd build/jpm && PREFIX='$(PREFIX)' \
+		DESTDIR=$(DESTDIR) \
+		JANET_MANPATH='$(JANET_MANPATH)' \
+		JANET_HEADERPATH='$(INCLUDEDIR)/janet' \
+		JANET_BINPATH='$(BINDIR)' \
+		JANET_LIBPATH='$(LIBDIR)' \
+		../../$(JANET_TARGET) ./bootstrap.janet
+
+uninstall:
+	-rm '$(DESTDIR)$(BINDIR)/janet'
+	-rm -rf '$(DESTDIR)$(INCLUDEDIR)/janet'
+	-rm -rf '$(DESTDIR)$(INCLUDEDIR)/janet.h'
+	-rm -rf '$(DESTDIR)$(LIBDIR)'/libjanet.*
+	-rm '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)/janet.pc'
+	-rm '$(DESTDIR)$(JANET_MANPATH)/janet.1'
+	# -rm -rf '$(DESTDIR)$(JANET_PATH)'/* - err on the side of correctness here
+
 #################
 ##### Other #####
 #################
 
+format:
+	tools/format.sh
+
+grammar: build/janet.tmLanguage
+build/janet.tmLanguage: tools/tm_lang_gen.janet $(JANET_TARGET)
+	$(JANET_TARGET) $< > $@
+
+compile-commands:
+	# Requires pip install copmiledb
+	compiledb make
+
 clean:
 	-rm -rf build vgcore.* callgrind.*
+	-rm -rf test/install/build test/install/modpath
 
-install: $(JANET_TARGET)
-	mkdir -p $(BINDIR)
-	cp $(JANET_TARGET) $(BINDIR)/janet
-	mkdir -p $(INCLUDEDIR)
-	cp $(JANET_HEADERS) $(INCLUDEDIR)
-	mkdir -p $(LIBDIR)
-	cp $(JANET_LIBRARY) $(LIBDIR)/libjanet.so
-	mkdir -p $(JANET_PATH)
-	cp tools/cook.janet $(JANET_PATH)
-	cp janet.1 /usr/local/share/man/man1/
-	mandb
-	$(LDCONFIG)
+test-install:
+	echo "JPM has been removed from default install."
 
-uninstall:
-	-rm $(BINDIR)/../$(JANET_TARGET)
-	-rm $(LIBDIR)/../$(JANET_LIBRARY)
-	-rm -rf $(INCLUDEDIR)
-	$(LDCONFIG)
+help:
+	@echo
+	@echo 'Janet: A Dynamic Language & Bytecode VM'
+	@echo
+	@echo Usage:
+	@echo '   make            Build Janet'
+	@echo '   make repl       Start a REPL from a built Janet'
+	@echo
+	@echo '   make test       Test a built Janet'
+	@echo '   make valgrind   Assess Janet with Valgrind'
+	@echo '   make callgrind  Assess Janet with Valgrind, using Callgrind'
+	@echo '   make valtest    Run the test suite with Valgrind to check for memory leaks'
+	@echo '   make dist       Create a distribution tarball'
+	@echo '   make docs       Generate documentation'
+	@echo '   make debug      Run janet with GDB or LLDB'
+	@echo '   make install    Install into the current filesystem'
+	@echo '   make uninstall  Uninstall from the current filesystem'
+	@echo '   make clean      Clean intermediate build artifacts'
+	@echo "   make format     Format Janet's own source files"
+	@echo '   make grammar    Generate a TextMate language grammar'
+	@echo
 
 .PHONY: clean install repl debug valgrind test \
-	valtest emscripten dist uninstall docs \
-	$(TEST_PROGRAM_PHONIES) $(TEST_PROGRAM_VALPHONIES)
+	valtest dist uninstall docs grammar format help compile-commands

README.md

@@ -1,167 +1,305 @@
-[![Build Status](https://travis-ci.org/janet-lang/janet.svg?branch=master)](https://travis-ci.org/janet-lang/janet)
-[![Appveyor Status](https://ci.appveyor.com/api/projects/status/32r7s2skrgm9ubva?svg=true)](https://ci.appveyor.com/project/janet-lang/janet)
+[![Join the chat](https://badges.gitter.im/janet-language/community.svg)](https://gitter.im/janet-language/community)
+ 
+[![builds.sr.ht status](https://builds.sr.ht/~bakpakin/janet/commits/master/freebsd.yml.svg)](https://builds.sr.ht/~bakpakin/janet/commits/master/freebsd.yml?)
+[![builds.sr.ht status](https://builds.sr.ht/~bakpakin/janet/commits/master/openbsd.yml.svg)](https://builds.sr.ht/~bakpakin/janet/commits/master/openbsd.yml?)
+[![Actions Status](https://github.com/janet-lang/janet/actions/workflows/test.yml/badge.svg)](https://github.com/janet-lang/janet/actions/workflows/test.yml)
 
 <img src="https://raw.githubusercontent.com/janet-lang/janet/master/assets/janet-w200.png" alt="Janet logo" width=200 align="left">
 
 **Janet** is a functional and imperative programming language and bytecode interpreter. It is a
-modern lisp, but lists are replaced
-by other data structures with better utility and performance (arrays, tables, structs, tuples).
-The language also bridging bridging to native code written in C, meta-programming with macros, and bytecode assembly.
+lisp-like language, but lists are replaced
+by other data structures (arrays, tables (hash table), struct (immutable hash table), tuples).
+The language also supports bridging to native code written in C, meta-programming with macros, and bytecode assembly.
 
-There is a repl for trying out the language, as well as the ability
+There is a REPL for trying out the language, as well as the ability
 to run script files. This client program is separate from the core runtime, so
-janet could be embedded into other programs. Try janet in your browser at
+Janet can be embedded in other programs. Try Janet in your browser at
 [https://janet-lang.org](https://janet-lang.org).
 
-#
+If you'd like to financially support the ongoing development of Janet, consider
+[sponsoring its primary author](https://github.com/sponsors/bakpakin) through GitHub.
 
-Implemented in mostly standard C99, janet runs on Windows, Linux and macOS.
-The few features that are not standard C (dynamic library loading, compiler specific optimizations),
-are fairly straight forward. Janet can be easily ported to new platforms.
-
-For syntax highlighting, there is some preliminary vim syntax highlighting in [janet.vim](https://github.com/janet-lang/janet.vim).
-Generic lisp syntax highlighting should, however, provide good results. There is also a janet.tmLanguage file
-that should provide good syntax highlighting for many editors.
+<br>
 
 ## Use Cases
 
-Janet makes a good system scripting language, or a language to embed in other programs. Think Lua or Guile.
+Janet makes a good system scripting language, or a language to embed in other programs.
+It's like Lua and Guile in that regard. It has more built-in functionality and a richer core language than
+Lua, but smaller than GNU Guile or Python.
 
 ## Features
 
+* Configurable at build time - turn features on or off for a smaller or more featureful build
 * Minimal setup - one binary and you are good to go!
-* First class closures
+* First-class closures
 * Garbage collection
-* First class green threads (continuations)
-* Python style generators (implemented as a plain macro)
+* First-class green threads (continuations)
+* Python-style generators (implemented as a plain macro)
 * Mutable and immutable arrays (array/tuple)
 * Mutable and immutable hashtables (table/struct)
 * Mutable and immutable strings (buffer/string)
-* Lisp Macros
+* Macros
+* Multithreading
+* Per-thread event loop for efficient evented IO
 * Byte code interpreter with an assembly interface, as well as bytecode verification
-* Tailcall Optimization
+* Tail call Optimization
 * Direct interop with C via abstract types and C functions
 * Dynamically load C libraries
 * Functional and imperative standard library
 * Lexical scoping
 * Imperative programming as well as functional
 * REPL
-* 300+ functions and macros in the core library
+* Parsing Expression Grammars built into the core library
+* 400+ functions and macros in the core library
+* Embedding Janet in other programs
 * Interactive environment with detailed stack traces
 
 ## Documentation
 
-Documentation can be found in the doc directory of
-the repository. There is an introduction
-section contains a good overview of the language.
+* For a quick tutorial, see [the introduction](https://janet-lang.org/docs/index.html) for more details.
+* For the full API for all functions in the core library, see [the core API doc](https://janet-lang.org/api/index.html)
 
-API documentation for all bindings can also be generated
-with `make docs`, which will create `build/doc.html`, which
-can be viewed with any web browser. This
-includes all forms in the core library except special forms.
-
-For individual bindings from within the REPL, use the `(doc symbol-name)` macro to get API
-documentation for the core library. For example,
+Documentation is also available locally in the REPL.
+Use the `(doc symbol-name)` macro to get API
+documentation for symbols in the core library. For example,
 ```
-(doc doc)
+(doc apply)
 ```
-Shows documentation for the doc macro.
+Shows documentation for the `apply` function.
 
 To get a list of all bindings in the default
-environment, use the `(all-symbols)` function.
+environment, use the `(all-bindings)` function. You
+can also use the `(doc)` macro with no arguments if you are in the REPL
+to show bound symbols.
+
+## Source
+
+You can get the source on [GitHub](https://github.com/janet-lang/janet) or
+[SourceHut](https://git.sr.ht/~bakpakin/janet). While the GitHub repo is the official repo,
+the SourceHut mirror is actively maintained.
+
+## Building
+
+### macOS and Unix-like
+
+The Makefile is non-portable and requires GNU-flavored make.
+
+```
+cd somewhere/my/projects/janet
+make
+make test
+make repl
+make install
+make install-jpm-git
+```
+
+Find out more about the available make targets by running `make help`.
+
+### 32-bit Haiku
+
+32-bit Haiku build instructions are the same as the UNIX-like build instructions,
+but you need to specify an alternative compiler, such as `gcc-x86`.
+
+```
+cd somewhere/my/projects/janet
+make CC=gcc-x86
+make test
+make repl
+make install
+make install-jpm-git
+```
+
+### FreeBSD
+
+FreeBSD build instructions are the same as the UNIX-like build instructions,
+but you need `gmake` to compile. Alternatively, install directly from
+packages, using `pkg install lang/janet`.
+
+```
+cd somewhere/my/projects/janet
+gmake
+gmake test
+gmake repl
+gmake install
+gmake install-jpm-git
+```
+
+### NetBSD
+
+NetBSD build instructions are the same as the FreeBSD build instructions.
+Alternatively, install directly from packages, using `pkgin install janet`.
+
+### Windows
+
+1. Install [Visual Studio](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15#) or [Visual Studio Build Tools](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools&rel=15#)
+2. Run a Visual Studio Command Prompt (cl.exe and link.exe need to be on the PATH) and cd to the directory with janet.
+3. Run `build_win` to compile janet.
+4. Run `build_win test` to make sure everything is working.
+
+To build an `.msi` installer executable, in addition to the above steps, you will have to:
+
+5. Install, or otherwise add to your PATH the [WiX 3.11 Toolset](https://github.com/wixtoolset/wix3/releases)
+6. run `build_win dist`
+
+Now you should have an `.msi`. You can run `build_win install` to install the `.msi`, or execute the file itself.
+
+### Meson
+
+Janet also has a build file for [Meson](https://mesonbuild.com/), a cross-platform build
+system. Although Meson has a Python dependency, Meson is a very complete build system that
+is maybe more convenient and flexible for integrating into existing pipelines.
+Meson also provides much better IDE integration than Make or batch files, as well as support
+for cross-compilation.
+
+For the impatient, building with Meson is as follows. The options provided to
+`meson setup` below emulate Janet's Makefile.
+
+```sh
+git clone https://github.com/janet-lang/janet.git
+cd janet
+meson setup build \
+          --buildtype release \
+          --optimization 2 \
+          --libdir /usr/local/lib \
+          -Dgit_hash=$(git log --pretty=format:'%h' -n 1)
+ninja -C build
+
+# Run the binary
+build/janet
+
+# Installation
+ninja -C build install
+```
+
+## Development
+
+Janet can be hacked on with pretty much any environment you like, but for IDE
+lovers, [Gnome Builder](https://wiki.gnome.org/Apps/Builder) is probably the
+best option, as it has excellent meson integration. It also offers code completion
+for Janet's C API right out of the box, which is very useful for exploring. VSCode, Vim,
+Emacs, and Atom will have syntax packages for the Janet language, though.
 
 ## Installation
 
-Install a stable version of janet from the [releases page](https://github.com/janet-lang/janet/releases).
-Janet is prebuilt for a few systems, but if you want to develop janet, run janet on a non-x86 system, or
-get the latest, you must build janet from source.
+See the [Introduction](https://janet-lang.org/docs/index.html) for more details. If you just want
+to try out the language, you don't need to install anything. You can also move the `janet` executable wherever you want on your system and run it.
 
 ## Usage
 
-A repl is launched when the binary is invoked with no arguments. Pass the -h flag
+A REPL is launched when the binary is invoked with no arguments. Pass the -h flag
 to display the usage information. Individual scripts can be run with `./janet myscript.janet`
 
 If you are looking to explore, you can print a list of all available macros, functions, and constants
-by entering the command `(all-symbols)` into the repl.
+by entering the command `(all-bindings)` into the REPL.
 
 ```
-$ ./janet
-Janet 0.0.0 alpha  Copyright (C) 2017-2018 Calvin Rose
+$ janet
+Janet 1.7.1-dev-951e10f  Copyright (C) 2017-2020 Calvin Rose
 janet:1:> (+ 1 2 3)
 6
 janet:2:> (print "Hello, World!")
 Hello, World!
 nil
-janet:3:> (os.exit)
-$ ./janet -h
-usage: ./janet [options] scripts...
+janet:3:> (os/exit)
+$ janet -h
+usage: build/janet [options] script args...
 Options are:
-  -h Show this help
-  -v Print the version string
-  -s Use raw stdin instead of getline like functionality
-  -e Execute a string of janet
-  -r Enter the repl after running all scripts
-  -p Keep on executing if there is a top level error (persistent)
-  -- Stop handling option
-$
+  -h : Show this help
+  -v : Print the version string
+  -s : Use raw stdin instead of getline like functionality
+  -e code : Execute a string of janet
+  -r : Enter the REPL after running all scripts
+  -p : Keep on executing if there is a top-level error (persistent)
+  -q : Hide prompt, logo, and REPL output (quiet)
+  -k : Compile scripts but do not execute (flycheck)
+  -m syspath : Set system path for loading global modules
+  -c source output : Compile janet source code into an image
+  -n : Disable ANSI color output in the REPL
+  -l path : Execute code in a file before running the main script
+  -- : Stop handling options
 ```
 
-## Compiling and Running
+If installed, you can also run `man janet` to get usage information.
 
-Janet only uses Make and batch files to compile on Posix and windows
-respectively. To configure janet, edit the header file src/include/janet/janet.h
-before compilation.
+## Embedding
 
-### Unix-like
+Janet can be embedded in a host program very easily. The normal build
+will create a file `build/janet.c`, which is a single C file
+that contains all the source to Janet. This file, along with
+`src/include/janet.h` and `src/conf/janetconf.h` can be dragged into any C
+project and compiled into the project. Janet should be compiled with `-std=c99`
+on most compilers, and will need to be linked to the math library, `-lm`, and
+the dynamic linker, `-ldl`, if one wants to be able to load dynamic modules. If
+there is no need for dynamic modules, add the define
+`-DJANET_NO_DYNAMIC_MODULES` to the compiler options.
 
-On most platforms, use Make to build janet. The resulting binary will be in `build/janet`.
-
-```sh
-cd somewhere/my/projects/janet
-make
-make test
-```
-
-After building, run `make install` to install the janet binary and libs.
-Will install in `/usr/local` by default, see the Makefile to customize.
-
-It's also recommended to set the `JANET_PATH` variable in your profile.
-This is where janet will look for imported libraries after the current directory.
-
-### FreeBSD
-
-FreeBSD build instructions are the same as the unix-like build instuctions,
-but you need `gmake` and `gcc` to compile.
-
-```
-cd somewhere/my/projects/janet
-gmake CC=gcc
-gmake test CC=gcc
-```
-
-### Windows
-
-1. Install [Visual Studio](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15#)
-or [Visual Studio Build Tools](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools&rel=15#)
-2. Run a Visual Studio Command Prompt (cl.exe and link.exe need to be on the PATH) and cd to the directory with janet.
-3. Run `build_win` to compile janet.
-4. Run `build_win test` to make sure everything is working.
-
-### Emscripten
-
-To build janet for the web via [Emscripten](https://kripken.github.io/emscripten-site/), make sure you
-have `emcc` installed and on your path. On a linux or macOS system, use `make emscripten` to build
-`janet.js` and `janet.wasm` - both are needed to run janet in a browser or in node.
-The JavaScript build is what runs the repl on the main website,
-but really serves mainly as a proof of concept. Janet will run slower in a browser.
-Building with emscripten on windows is currently unsupported.
+See the [Embedding Section](https://janet-lang.org/capi/embedding.html) on the website for more information.
 
 ## Examples
 
 See the examples directory for some example janet code.
 
-## Why Janet
+## 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.
+
+## FAQ
+
+### Where is (favorite feature from other language)?
+
+It may exist, it may not. If you want to propose major language features, go ahead and open an issue, but
+they will likely by closed as "will not implement". Often, such features make one usecase simpler at the expense
+of 5 others by making the language more complicated.
+
+### Is there a language spec?
+
+There is not currently a spec besides the documentation at https://janet-lang.org.
+
+### Is this Scheme/Common Lisp? Where are the cons cells?
+
+Nope. There are no cons cells here.
+
+### Is this a Clojure port?
+
+No. It's similar to Clojure superficially because I like Lisps and I like the aesthetics.
+Internally, Janet is not at all like Clojure.
+
+### Are the immutable data structures (tuples and structs) implemented as hash tries?
+
+No. They are immutable arrays and hash tables. Don't try and use them like Clojure's vectors
+and maps, instead they work well as table keys or other identifiers.
+
+### Can I do Object Oriented programming with Janet?
+
+To some extent, yes. However, it is not the recommended method of abstraction, and performance may suffer.
+That said, tables can be used to make mutable objects with inheritance and polymorphism, where object
+methods are implemeted with keywords.
+
+```
+(def Car @{:honk (fn [self msg] (print "car " self " goes " msg)) })
+(def my-car (table/setproto @{} Car))
+(:honk my-car "Beep!")
+```
+
+### Why can't we add (feature from Clojure) into the core?
+
+Usually, one of a few reasons:
+- Often, it already exists in a different form and the Clojure port would be redundant.
+- Clojure programs often generate a lot of garbage and rely on the JVM to clean it up.
+  Janet does not run on the JVM, and has a more primitive garbage collector.
+- We want to keep the Janet core small. With Lisps, usually a feature can be added as a library
+  without feeling "bolted on", especially when compared to ALGOL like languages. Adding features
+  to the core also makes it a bit more difficult to keep Janet maximally portable.
+
+### Why is my terminal spitting out junk when I run the REPL?
+
+Make sure your terminal supports ANSI escape codes. Most modern terminals will
+support these, but some older terminals, Windows consoles, or embedded terminals
+will not. If your terminal does not support ANSI escape codes, run the REPL with
+the `-n` flag, which disables color output. You can also try the `-s` if further issues
+ensue.
+
+## Why is it called "Janet"?
 
 Janet is named after the almost omniscient and friendly artificial being in [The Good Place](https://en.wikipedia.org/wiki/The_Good_Place).
-
-<img src="https://raw.githubusercontent.com/janet-lang/janet/master/assets/janet-the-good-place.gif" alt="Janet logo" width="115px" align="left">

appveyor.yml

@@ -1,48 +0,0 @@
-version: build-{build}
-clone_folder: c:\projects\janet
-image:
-- Visual Studio 2017
-configuration:
-- Release
-- Debug
-platform:
-- x64
-environment:
-  matrix:
-  - arch: Win64
-matrix:
-  fast_finish: true
-
-# skip unsupported combinations
-init:
-- call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
-
-install:
-    - build_win
-    - build_win test
-    - choco install nsis -y -pre
-    - call "C:\Program Files (x86)\NSIS\makensis.exe" janet-installer.nsi 
-    - build_win dist
-    - copy janet-install.exe dist\install.exe 
-    
-build: off
-
-only_commits:
-  files:
-    - appveyor.yml
-    - src/
-
-artifacts:
-    - path: dist
-      name: janet-windows
-      type: Zip
-
-deploy:
-  description: 'The Janet Programming Language.'
-  provider: GitHub
-  auth_token:
-    secure: lwEXy09qhj2jSH9s1C/KvCkAUqJSma8phFR+0kbsfUc3rVxpNK5uD3z9Md0SjYRx
-  artifact: janet-windows
-  draft: true
-  on:
-    APPVEYOR_REPO_TAG: true

assets/icon_svg.svg

@@ -0,0 +1,11 @@
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg" width="64px" height="64px" viewBox="0 0 640 640" preserveAspectRatio="xMidYMid meet">
+<g id="layer101" fill="#d45500" stroke="none">
+ <path d="M145 531 c-46 -31 -58 -75 -30 -118 21 -32 30 -22 44 47 7 30 19 62 27 71 26 29 1 29 -41 0z"/>
+ <path d="M341 534 c-23 -29 -26 -50 -11 -88 10 -28 64 -60 86 -52 12 5 12 2 0 -22 -24 -47 -51 -64 -116 -71 -51 -6 -65 -12 -85 -37 -14 -16 -24 -32 -25 -36 0 -12 -35 -9 -48 4 -7 7 -12 24 -12 38 0 41 -11 43 -47 8 -47 -46 -46 -90 5 -138 20 -19 49 -51 63 -70 l27 -35 88 0 c49 0 106 4 127 8 46 10 106 62 143 125 25 42 28 58 30 142 0 52 4 103 9 113 11 27 -14 75 -49 93 -41 21 -115 44 -143 44 -12 0 -31 -12 -42 -26z m89 -119 c0 -3 -2 -5 -5 -5 -3 0 -5 2 -5 5 0 3 2 5 5 5 3 0 5 -2 5 -5z"/>
+ </g>
+<g id="layer102" fill="#deaa87" stroke="none">
+ <path d="M186 549 c-33 -31 -38 -43 -56 -137 -26 -135 -26 -163 3 -190 33 -31 49 -28 85 17 28 35 36 39 87 43 46 4 61 10 90 38 18 18 39 46 46 62 10 25 9 32 -5 46 -17 16 -19 16 -29 1 -8 -14 -15 -15 -34 -6 -27 12 -40 65 -24 96 10 17 8 23 -12 36 -13 8 -44 18 -69 21 -42 6 -49 4 -82 -27z"/>
+ </g>
+
+</svg>

build_win.bat

@@ -13,48 +13,59 @@
 @if "%1"=="clean" goto CLEAN
 @if "%1"=="test" goto TEST
 @if "%1"=="dist" goto DIST
+@if "%1"=="install" goto INSTALL
+@if "%1"=="all" goto ALL
 
 @rem Set compile and link options here
 @setlocal
-@set JANET_COMPILE=cl /nologo /Isrc\include /c /O2 /W3 /LD /D_CRT_SECURE_NO_WARNINGS
+
+@rem Example use asan
+@rem set JANET_COMPILE=cl /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD /fsanitize=address /Zi
+@rem set JANET_LINK=link /nologo clang_rt.asan_dynamic-x86_64.lib clang_rt.asan_dynamic_runtime_thunk-x86_64.lib
+
+@set JANET_COMPILE=cl /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD
 @set JANET_LINK=link /nologo
 
-mkdir build
-mkdir build\core
-mkdir build\mainclient
+@set JANET_LINK_STATIC=lib /nologo
 
-@rem Build the xxd tool for generating sources
-@cl /nologo /c tools/xxd.c /Fobuild\xxd.obj
-@if errorlevel 1 goto :BUILDFAIL
-@link /nologo /out:build\xxd.exe build\xxd.obj
-@if errorlevel 1 goto :BUILDFAIL
+@rem Add janet build tag
+if not "%JANET_BUILD%" == "" (
+    @set JANET_COMPILE=%JANET_COMPILE% /DJANET_BUILD="\"%JANET_BUILD%\""
+)
 
-@rem Generate the embedded sources
-@build\xxd.exe src\core\core.janet build\core\core.gen.c janet_gen_core
-@if errorlevel 1 goto :BUILDFAIL
-@build\xxd.exe src\mainclient\init.janet build\mainclient\init.gen.c janet_gen_init
-@if errorlevel 1 goto :BUILDFAIL
+if not exist build mkdir build
+if not exist build\core mkdir build\core
+if not exist build\c mkdir build\c
+if not exist build\boot mkdir build\boot
 
-@rem Build the generated sources
-@%JANET_COMPILE% /Fobuild\core\core.gen.obj build\core\core.gen.c
-@if errorlevel 1 goto :BUILDFAIL
-@%JANET_COMPILE% /Fobuild\mainclient\init.gen.obj build\mainclient\init.gen.c
+@rem Build the bootstrap interpreter
+for %%f in (src\core\*.c) do (
+    %JANET_COMPILE% /DJANET_BOOTSTRAP /Fobuild\boot\%%~nf.obj %%f
+    @if errorlevel 1 goto :BUILDFAIL
+)
+for %%f in (src\boot\*.c) do (
+    %JANET_COMPILE% /DJANET_BOOTSTRAP /Fobuild\boot\%%~nf.obj %%f
+    @if errorlevel 1 goto :BUILDFAIL
+)
+%JANET_LINK% /out:build\janet_boot.exe build\boot\*.obj
 @if errorlevel 1 goto :BUILDFAIL
+build\janet_boot . > build\c\janet.c
 
 @rem Build the sources
-for %%f in (src\core\*.c) do (
-    @%JANET_COMPILE% /Fobuild\core\%%~nf.obj %%f
-    @if errorlevel 1 goto :BUILDFAIL
-)
+%JANET_COMPILE% /Fobuild\janet.obj build\c\janet.c
+@if errorlevel 1 goto :BUILDFAIL
+%JANET_COMPILE% /Fobuild\shell.obj src\mainclient\shell.c
+@if errorlevel 1 goto :BUILDFAIL
 
-@rem Build the main client
-for %%f in (src\mainclient\*.c) do (
-    @%JANET_COMPILE% /Fobuild\mainclient\%%~nf.obj %%f
-    @if errorlevel 1 goto :BUILDFAIL
-)
+@rem Build the resources
+rc /nologo /fobuild\janet_win.res janet_win.rc
 
 @rem Link everything to main client
-%JANET_LINK% /out:janet.exe build\core\*.obj build\mainclient\*.obj
+%JANET_LINK% /out:janet.exe build\janet.obj build\shell.obj build\janet_win.res
+@if errorlevel 1 goto :BUILDFAIL
+
+@rem Build static library (libjanet.a)
+%JANET_LINK_STATIC% /out:build\libjanet.lib build\janet.obj
 @if errorlevel 1 goto :BUILDFAIL
 
 echo === Successfully built janet.exe for Windows ===
@@ -76,17 +87,18 @@ exit /b 1
 @echo command prompt.
 exit /b 0
 
-@rem Clean build artifacts 
+@rem Clean build artifacts
 :CLEAN
-del janet.exe janet.exp janet.lib
+del *.exe *.lib *.exp
 rd /s /q build
+rd /s /q dist
 exit /b 0
 
 @rem Run tests
 :TEST
 for %%f in (test/suite*.janet) do (
     janet.exe test\%%f
-    @if errorlevel 1 goto :TESTFAIL
+    @if errorlevel 1 goto TESTFAIL
 )
 exit /b 0
 
@@ -94,12 +106,61 @@ exit /b 0
 :DIST
 mkdir dist
 janet.exe tools\gendoc.janet > dist\doc.html
+janet.exe tools\removecr.janet dist\doc.html
+janet.exe tools\removecr.janet build\c\janet.c
+
+copy build\c\janet.c dist\janet.c
+copy src\mainclient\shell.c dist\shell.c
 copy janet.exe dist\janet.exe
 copy LICENSE dist\LICENSE
 copy README.md dist\README.md
+
 copy janet.lib dist\janet.lib
 copy janet.exp dist\janet.exp
-copy src\include\janet\janet.h dist\janet.h
+
+janet.exe tools\patch-header.janet src\include\janet.h src\conf\janetconf.h build\janet.h
+copy build\janet.h dist\janet.h
+copy build\libjanet.lib dist\libjanet.lib
+
+@rem Create installer
+janet.exe -e "(->> janet/version (peg/match ''(* :d+ `.` :d+ `.` :d+)) first print)" > build\version.txt
+janet.exe -e "(print (os/arch))" > build\arch.txt
+set /p JANET_VERSION= < build\version.txt
+set /p BUILDARCH= < build\arch.txt
+echo "JANET_VERSION is %JANET_VERSION%"
+if defined APPVEYOR_REPO_TAG_NAME (
+    set RELEASE_VERSION=%APPVEYOR_REPO_TAG_NAME%
+) else (
+    set RELEASE_VERSION=%JANET_VERSION%
+)
+if defined CI (
+    set WIXBIN="c:\Program Files (x86)\WiX Toolset v3.11\bin\"
+) else (
+    set WIXBIN=
+)
+%WIXBIN%candle.exe tools\msi\janet.wxs -arch %BUILDARCH% -out build\
+%WIXBIN%light.exe "-sice:ICE38" -b tools\msi -ext WixUIExtension build\janet.wixobj -out janet-%RELEASE_VERSION%-windows-%BUILDARCH%-installer.msi
+exit /b 0
+
+@rem Run the installer. (Installs to the local user with default settings)
+:INSTALL
+FOR %%a in (janet-*-windows-*-installer.msi) DO (
+    @echo Running Installer %%a...
+    %%a /QN
+)
+exit /b 0
+
+@rem build, test, dist, install. Useful for local dev.
+:ALL
+call %0 build
+@if errorlevel 1 exit /b 1
+call %0 test
+@if errorlevel 1 exit /b 1
+call %0 dist
+@if errorlevel 1 exit /b 1
+call %0 install
+@if errorlevel 1 exit /b 1
+@echo Done!
 exit /b 0
 
 :TESTFAIL

doc/Home.md

@@ -1,6 +0,0 @@
-Janet is a dynamic, lightweight programming language with strong functional
-capabilities as well as support for imperative programming. It to be used
-for short lived scripts as well as for building real programs. It can also
-be extended with native code (C modules) for better performance and interfacing with
-existing software. Janet takes ideas from Lua, Scheme, Racket, Clojure, Smalltalk, Erlang, Arc, and
-a whole bunch of other dynamic languages.

doc/Introduction.md

@@ -1,739 +0,0 @@
-# Hello, world!
-
-Following tradition, a simple Janet program will print "Hello, world!".
-
-```
-(print "Hello, world!")
-```
-
-Put the following code in a file named `hello.janet`, and run `./janet hello.janet`.
-The words "Hello, world!" should be printed to the console, and then the program
-should immediately exit. You now have a working janet program!
-
-Alternatively, run the program `./janet` without any arguments to enter a REPL,
-or read eval print loop. This is a mode where Janet functions like a calculator,
-reading some input from the user, evaluating it, and printing out the result, all
-in an infinite loop. This is a useful mode for exploring or prototyping in Janet.
-
-This hello world program is about the simplest program one can write, and consists of only
-a few pieces of syntax. This first element is the `print` symbol. This is a function
-that simply prints its arguments to the console. The second argument is the
-string literal "Hello, world!", which is the one and only argument to the
-print function. Lastly, the print symbol and the string literal are wrapped
-in parentheses, forming a tuple. In Janet, parentheses and brackets are interchangeable,
-brackets are used mostly when the resulting tuple is not a function call. The tuple
-above indicates that the function `print` is to be called with one argument, `"Hello, world"`.
-
-Like all lisps, all operations in Janet are in prefix notation; the name of the
-operator is the first value in the tuple, and the arguments passed to it are
-in the rest of the tuple.
-
-# A bit more - Arithmetic
-
-Any programming language will have some way to do arithmetic. Janet is no exception,
-and supports the basic arithmetic operators
-
-```
-# Prints 13
-# (1 + (2*2) + (10/5) + 3 + 4 + (5 - 6))
-(print (+ 1 (* 2 2) (/ 10 5) 3 4 (- 5 6)))
-```
-
-Just like the print function, all arithmetic operators are entered in
-prefix notation. Janet also supports the remainder operator, or `%`, which returns
-the remainder of division. For example, `(% 10 3)` is 1, and `(% 10.5 3)` is
-1.5. The lines that begin with `#` are comments.
-
-All janet numbers are IEEE 754 floating point numbers. They can be used to represent
-both integers and real numbers to a finite precision.
-
-## Numeric literals
-
-Numeric literals can be written in many ways. Numbers can be written in base 10, with
-underscores used to separate digits into groups. A decimal point can be used for floating
-point numbers. Numbers can also be written in other bases by prefixing the number with the desired
-base and the character 'r'. For example, 16 can be written as `16`, `1_6`, `16r10`, `4r100`, or `0x10`. The
-`0x` prefix can be used for hexadecimal as it is so common. The radix must be themselves written in base 10, and
-can be any integer from 2 to 36. For any radix above 10, use the letters as digits (not case sensitive).
-
-Numbers can also be in scientific notation such as `3e10`. A custom radix can be used as well
-as for scientific notation numbers, (the exponent will share the radix). For numbers in scientific
-notation with a radix besides 10, use the `&` symbol to indicate the exponent rather then `e`.
-
-## Arithmetic Functions
-
-Besides the 5 main arithmetic functions, janet also supports a number of math functions
-taken from the C library `<math.h>`, as well as bit-wise operators that behave like they
-do in C or Java. Functions like `math/sin`, `math/cos`, `math/log`, and `math/exp` will
-behave as expected to a C programmer. They all take either 1 or 2 numeric arguments and
-return a real number (never an integer!) Bit-wise functions are all prefixed with b.
-They are `bnot`, `bor`, `bxor`, `band`, `blshift`, `brshift`, and `brushift`. Bit-wise
-functions only work on integers.
-
-# Strings, Keywords and Symbols
-
-Janet supports several varieties of types that can be used as labels for things in
-your program. The most useful type for this purpose is the keyword type. A keyword
-begins with a semicolon, and then contains 0 or more alphanumeric or a few other common
-characters. For example, `:hello`, `:my-name`, `::`, and `:ABC123_-*&^%$` are all keywords.
-
-Keywords, symbols, and strings all behave similarly and can be used as keys for tables and structs.
-Symbols and keywords are optimized for fast equality checks, so are preferred for table keys.
-
-The difference between symbols and keywords is that keywords evaluate to themselves, while
-symbols evaluate to whatever they are bound to. To have a symbol evaluate to itself, it must be
-quoted.
-
-```lisp
-# Evaluates to :monday
-:monday
-
-# Will throw a compile error as monday is not defined
-monday
-
-# Quote it - evaluates to the symbol monday
-'monday
-
-# Or first define monday
-(def monday "It is monday")
-
-# Now the evaluation should work - monday evaluates to "It is monday"
-monday
-```
-
-The most common thing to do with a keyword is to check it for equality or use it as a key into
-a table or struct. Note that symbols, keywords and strings are all immutable. Besides making your
-code easier to reason about, it allows for many optimizations involving these types.
-
-```lisp
-# Evaluates to true
-(= :hello :hello)
-
-# Evaluates to false, everything in janet is case sensitive
-(= :hello :HeLlO)
-
-# Look up into a table - evaluates to 25
-(get {
-    :name "John"
-    :age 25
-    :occupation "plumber"
-} :age)
-```
-
-Strings can be used similarly to keywords, but there primary usage is for defining either text
-or arbitrary sequences of bytes. Strings (and symbols) in janet are what is sometimes known as
-"8-bit clean"; they can hold any number of bytes, and are completely unaware of things like character
-encodings. This is completely compatible with ASCII and UTF-8, two of the most common character
-encodings. By being encoding agnostic, janet strings can be very simple, fast, and useful for
-for other uses besides holding text.
-
-Literal text can be entered inside quotes, as we have seen above.
-
-```
-"Hello, this is a string."
-
-# We can also add escape characters for newlines, double quotes, backslash, tabs, etc.
-"Hello\nThis is on line two\n\tThis is indented\n"
-
-# For long strings where you don't want to type a lot of escape characters,
-# you can use 1 or more backticks (`\``) to delimit a string.
-# To close this string, simply repeat the opening sequence of backticks
-``
-This is a string.
-Line 2
-    Indented
-"We can just type quotes here", and backslashes \ no problem.
-``
-```
-
-# Functions
-
-Janet is a functional language - that means that one of the basic building blocks of your
-program will be defining functions (the other is using data structures). Because janet
-is a Lisp, functions are values just like numbers or strings - they can be passed around and
-created as needed.
-
-Functions can be defined with the `defn` macro, like so:
-
-```lisp
-(defn triangle-area
- "Calculates the area of a triangle."
- [base height]
- (print "calculating area of a triangle...")
- (* base height 0.5))
-```
-
-A function defined with `defn` consists of a name, a number of optional flags for def, and
-finally a function body. The example above is named triangle-area and takes two parameters named base and height. The body of the function will print a message and then evaluate to the area of the triangle.
-
-Once a function like the above one is defined, the programmer can use the `triangle-area`
-function just like any other, say `print` or `+`.
-
-```lisp
-# Prints "calculating area of a triangle..." and then "25"
-(print (triangle-area 5 10))
-```
-
-Note that when nesting function calls in other function calls like above (a call to triangle-area is
-nested inside a call to print), the inner function calls are evaluated first. Also, arguments to
-a function call are evaluated in order, from first argument to last argument).
-
-Because functions are first-class values like numbers or strings, they can be passed
-as arguments to other functions as well.
-
-```lisp
-(print triangle-area)
-```
-
-This prints the location in memory of the function triangle area.
-
-Functions don't need to have names. The `fn` keyword can be used to introduce function
-literals without binding them to a symbol.
-
-```lisp
-# Evaluates to 40
-((fn [x y] (+ x x y)) 10 20)
-# Also evaluates to 40
-((fn [x y &] (+ x x y)) 10 20)
-
-# Will throw an error about the wrong arity
-((fn [x] x) 1 2)
-# Will not throw an error about the wrong arity
-((fn [x &] x) 1 2)
-```
-
-The first expression creates an anonymous function that adds twice
-the first argument to the second, and then calls that function with arguments 10 and 20.
-This will return (10 + 10 + 20) = 40.
-
-There is a common macro `defn` that can be used for creating functions and immediately binding
-them to a name. `defn` works as expected at both the top level and inside another form. There is also
-the corresponding
-
-Note that putting an ampersand at the end of the argument list inhibits strict arity checking.
-This means that such a function will accept fewer or more arguments than specified.
-
-```lisp
-(defn myfun [x y]
- (+ x x y))
-
-# You can think of defn as a shorthand for def and fn together
-(def myfun-same (fn [x y]
-            (+ x x Y)))
-
-(myfun 3 4) # -> 10
-```
-
-Janet has many macros provided for you (and you can write your own).
-Macros are just functions that take your source code
-and transform it into some other source code, usually automating some repetitive pattern for you.
-
-# Defs and Vars
-
-Values can be bound to symbols for later use using the keyword `def`. Using undefined
-symbols will raise an error.
-
-```lisp
-(def a 100)
-(def b (+ 1 a))
-(def c (+ b b))
-(def d (- c 100))
-```
-
-Bindings created with def have lexical scoping. Also, bindings created with def are immutable; they
-cannot be changed after definition. For mutable bindings, like variables in other programming
-languages, use the `var` keyword. The assignment special form `set` can then be used to update
-a var.
-
-```lisp
-(var myvar 1)
-(print myvar)
-(set myvar 10)
-(print myvar)
-```
-
-In the global scope, you can use the `:private` option on a def or var to prevent it from
-being exported to code that imports your current module. You can also add documentation to
-a function by passing a string the def or var command.
-
-```lisp
-(def mydef :private "This will have priavte scope. My doc here." 123)
-(var myvar "docstring here" 321)
-```
-
-## Scopes
-
-Defs and vars (collectively known as bindings) live inside what is called a scope. A scope is
-simply where the bindings are valid. If a binding is referenced outside of its scope, the compiler
-will throw an error. Scopes are useful for organizing your bindings and my extension your programs.
-There are two main ways to create a scope in Janet.
-
-The first is to use the `do` special form. `do` executes a series of statements in a scope
-and evaluates to the last statement. Bindings create inside the form do not escape outside
-of its scope.
-
-```lisp
-(def a :outera)
-
-(do
- (def a 1)
- (def b 2)
- (def c 3)
- (+ a b c)) # -> 6
-
-a # -> :outera
-b # -> compile error: "unknown symbol \"b\""
-c # -> compile error: "unknown symbol \"c\""
-```
-
-Any attempt to reference the bindings from the do form after it has finished
-executing will fail. Also notice who defining `a` inside the do form did not
-overwrite the original definition of `a` for the global scope.
-
-The second way to create a scope is to create a closure.
-The `fn` special form also introduces a scope just like
-the `do` special form.
-
-There is another built in macro, `let`, that does multiple defs at once, and then introduces a scope.
-`let` is a wrapper around a combination of defs and dos, and is the most "functional" way of
-creating bindings.
-
-```lisp
-(let [a 1
-      b 2
-      c 3]
-      (+ a b c)) # -> 6
-```
-
-The above is equivalent to the example using `do` and `def`.
-This is the preferable form in most cases,
-but using do with multiple defs is fine as well.
-
-# Data Structures
-
-Once you have a handle on functions and the primitive value types, you may be wondering how
-to work with collections of things. Janet has a small number of core data structure types
-that are very versatile. Tables, Structs, Arrays, Tuples, Strings, and Buffers, are the 6 main
-built in data structure types. These data structures can be arranged in a useful table describing
-there relationship to each other.
-
-|            | Mutable | Immutable       |
-| ---------- | ------- | --------------- |
-| Indexed    | Array   | Tuple           |
-| Dictionary | Table   | Struct          |
-| Bytes      | Buffer  | String          |
-
-Indexed types are linear lists of elements than can be accessed in constant time with an integer index.
-Indexed types are backed by a single chunk of memory for fast access, and are indexed from 0 as in C.
-Dictionary types associate keys with values. The difference between dictionaries and indexed types
-is that dictionaries are not limited to integer keys. They are backed by a hashtable and also offer
-constant time lookup (and insertion for the mutable case).
-Finally, the 'bytes' abstraction is any type that contains a sequence of bytes. A 'bytes' value or byteseq associates
-integer keys (the indices) with integer values between 0 and 255 (the byte values). In this way,
-they behave much like Arrays and Tuples. However, one cannot put non integer values into a byteseq
-
-```lisp
-(def mytuple (tuple 1 2 3))
-
-(def myarray @(1 2 3))
-(def myarray (array 1 2 3))
-
-(def mystruct {
- :key "value"
- :key2 "another"
- 1 2
- 4 3})
-
-(def another-struct
- (struct :a 1 :b 2))
-
-(def my-table @{
- :a :b
- :c :d
- :A :qwerty})
-(def another-table
- (table 1 2 3 4))
-
-(def my-buffer @"thisismutable")
-(def my-buffer2 @```
- This is also mutable ":)"
- ```)
-```
-
-To read the values in a data structure, use the get function. The first parameter is the data structure
-itself, and the second parameter is the key.
-
-```lisp
-(get @{:a 1} :a) # -> 1
-(get {:a 1} :a) # -> 1
-(get @[:a :b :c] 2) # -> :c
-(get (tuple "a" "b" "c") 1) # -> "b"
-(get @"hello, world" 1) # -> 101
-(get "hello, world" 0) # -> 104
-```
-
-### Destructuring
-
-In many cases, however, you do not need the `get` function at all. Janet supports destructuring, which
-means both the `def` and `var` special forms can extract values from inside structures themselves.
-
-```lisp
-# Before, we might do
-(def my-array @[:mary :had :a :little :lamb])
-(def lamb (get my-array 4))
-(print lamb) # Prints :lamb
-
-# Now, with destructuring,
-(def [_ _ _ _ lamb] my-array)
-(print lamb) # Again, prints :lamb
-
-# Destructuring works with tables as well
-(def person @{:name "Bob Dylan" :age 77}
-(def
-  {:name person-name
-   :age person-age} person)
-```
-To update a mutable data structure, use the `put` function. It takes 3 arguments, the data structure,
-the key, and the value, and returns the data structure. The allowed types keys and values
-depend on what data structure is passed in.
-
-```lisp
-(put @[] 100 :a)
-(put @{} :key "value")
-(put @"" 100 92)
-```
-
-Note that for Arrays and Buffers, putting an index that is outside the length of the data structure
-will extend the data structure and fill it with nils in the case of the Array,
-or 0s in the case of the Buffer.
-
-The last generic function for all data structures is the `length` function. This returns the number of
-values in a data structure (the number of keys in a dictionary type).
-
-# Flow Control
-
-Janet has only two built in primitives to change flow while inside a function. The first is the
-`if` special form, which behaves as expected in most functional languages. It takes two or three parameters:
-a condition, an expression to evaluate to if the condition is true (not nil or false),
-and an optional condition to evaluate to when the condition is nil or false. If the optional parameter
-is omitted, the if form evaluates to nil.
-
-```lisp
-(if (> 4 3)
-  "4 is greater than 3"
-  "4 is not greater then three") # Evaluates to the first statement
-
-(if true
-  (print "Hey")) # Will print
-
-(if false
-  (print "Oy!")) # Will not print
-```
-
-The second primitive control flow construct is the while loop. The while behaves much the same
-as in many other programming languages, including C, Java, and Python. The while loop takes
-two or more parameters: the first is a condition (like in the `if` statement), that is checked before
-every iteration of the loop. If it is nil or false, the while loop ends and evaluates to nil. Otherwise,
-the rest of the parameters will be evaluated sequentially and then the program will return to the beginning
-of the loop.
-
-```lisp
-# Loop from 100 down to 1 and print each time
-(var i 100)
-(while (pos? i)
-  (print "the number is " i)
-  (-- i))
-
-# Print ... until a random number in range [0, 1) is >= 0.9
-# (math/random evaluates to a value between 0 and 1)
-(while (> 0.9 (math/random))
-  (print "..."))
-```
-
-Besides these special forms, Janet has many macros for both conditional testing and looping
-that are much better for the majority of cases. For conditional testing, the `cond`, `switch`, and
-`when` macros can be used to great effect. `cond` can be used for making an if-else chain, where using
-just raw if forms would result in many parentheses. `case` For looping, the `loop`, `seq`, and `generate`
-implement janet's form of list comprehension, as in Python or Clojure.
-
-# The Core Library
-
-Janet has a built in core library of over 300 functions and macros at the time of writing.
-While some of these functions may be refactored into separate modules, it is useful to get to know
-the core to avoid rewriting provided functions.
-
-For any given function, use the `doc` macro to view the documentation for it in the repl.
-
-```lisp
-(doc defn) -> Prints the documentation for "defn"
-```
-To see a list of all global functions in the repl, type the command
-
-```lisp
-(table/getproto *env*)
-# Or
-(all-symbols)
-```
-Which will print out every built-in global binding
-(it will not show your global bindings). To print all
-of your global bindings, just use \*env\*, which is a var
-that is bound to the current environment.
-
-The convention of surrounding a symbol in stars is taken from lisp
-and Clojure, and indicates a global dynamic variable rather than a normal
-definition. To get the static environment at the time of compilation, use the
-`_env` symbol.
-
-# Prototypes
-
-To support basic generic programming, Janet tables support a prototype
-table. A prototype table contains default values for a table if certain keys
-are not found in the original table. This allows many similar tables to share
-contents without duplicating memory.
-
-```lisp
-# One of many Object Oriented schemes that can
-# be implented in janet.
-(def proto1 @{:type :custom1
-              :behave (fn [self x] (print "behaving " x))})
-(def proto2 @{:type :custom2
-              :behave (fn [self x] (print "behaving 2 " x))})
-
-(def thing1 (table/setproto @{} proto1))
-(def thing2 (table/setproto @{} proto2))
-
-(print thing1:type) # prints :custom1
-(print thing2:type) # prints :custom2
-
-(thing1:behave thing1 :a) # prints "behaving :a"
-(thing2:behave thing2 :b) # prints "behaving 2 :b"
-```
-
-Looking up in a table with a prototype can be summed up with the following algorithm.
-
-1. `(get my-table my-key)` is called.
-2. my-table is checked for the key if my-key. If there is a value for the key, it is returned.
-3. if there is a prototype table for my-table, set `my-table = my-table's prototype` and got to 2.
-4. Return nil as the key was not found.
-
-Janet will check up to about a 1000 prototypes recursively by default before giving up and returning nil. This
-is to prevent an infinite loop. This value can be changed by adjusting the `JANET_RECURSION_GUARD` value
-in janet.h.
-
-Note that Janet prototypes are not as expressive as metatables in Lua and many other languages.
-This is by design, as adding Lua or Python like capabilities would not be technically difficult.
-Users should prefer plain data and functions that operate on them rather than mutable objects
-with methods.
-
-# Fibers
-
-Janet has support for single-core asynchronous programming via coroutines, or fibers.
-Fibers allow a process to stop and resume execution later, essentially enabling
-multiple returns from a function. This allows many patterns such a schedules, generators,
-iterators, live debugging, and robust error handling. Janet's error handling is actually built on
-top of fibers (when an error is thrown, the parent fiber will handle the error).
-
-A temporary return from a fiber is called a yield, and can be invoked with the `yield` function.
-To resume a fiber that has been yielded, use the `resume` function. When resume is called on a fiber,
-it will only return when that fiber either returns, yields, throws an error, or otherwise emits
-a signal.
-
-Different from traditional coroutines, Janet's fibers implement a signaling mechanism, which
-is used to differentiate different kinds of returns. When a fiber yields or throws an error,
-control is returned to the calling fiber. The parent fiber must then check what kind of state the
-fiber is in to differentiate errors from return values from user defined signals.
-
-To create a fiber, user the `fiber/new` function. The fiber constructor take one or two arguments.
-The first, necessary argument is the function that the fiber will execute. This function must accept
-an arity of zero. The next optional argument is a collection of flags checking what kinds of
-signals to trap and return via `resume`. This is useful so
-the programmer does not need to handle all different kinds of signals from a fiber. Any un-trapped signals
-are simply propagated to the next fiber.
-
-```lisp
-(def f (fiber/new (fn []
-                   (yield 1)
-                   (yield 2)
-                   (yield 3)
-                   (yield 4)
-                   5)))
-
-# Get the status of the fiber (:alive, :dead, :debug, :new, :pending, or :user0-:user9)
-(print (fiber/status f)) # -> :new
-
-(print (resume f)) # -> prints 1
-(print (resume f)) # -> prints 2
-(print (resume f)) # -> prints 3
-(print (resume f)) # -> prints 4
-(print (fiber/status f)) # -> print :pending
-(print (resume f)) # -> prints 5
-(print (fiber/status f)) # -> print :dead
-(print (resume f)) # -> throws an error because the fiber is dead
-```
-
-## Using Fibers to Capture Errors
-
-Besides being used as coroutines, fibers can be used to implement error handling (exceptions).
-
-```lisp
-(defn my-function-that-errors [x]
- (print "start function with " x)
- (error "oops!")
- (print "never gets here"))
-
-# Use the :e flag to only trap errors.
-(def f (fiber/new my-function-that-errors :e))
-(def result (resume f))
-(if (= (fiber/status f) :error)
- (print "result contains the error")
- (print "result contains the good result"))
-```
-
-# Macros
-
-Janet supports macros like most lisps. A macro is like a function, but transforms
-the code itself rather than data. They let you extend the syntax of the language itself.
-
-You have seen some macros already. The `let`, `loop`, and `defn` forms are macros. When the compiler
-sees a macro, it evaluates the macro and then compiles the result. We say the macro has been
-*expanded* after the compiler evaluates it. A simple version of the `defn` macro can
-be thought of as transforming code of the form
-
-```lisp
-(defn1 myfun [x] body)
-```
-into
-```lisp
-(def myfun (fn myfun [x] body))
-```
-
-We could write such a macro like so:
-
-```lisp
-(defmacro defn1 [name args body]
- (tuple 'def name (tuple 'fn name args body)))
-```
-
-There are a couple of issues with this macro, but it will work for simple functions
-quite well.
-
-The first issue is that our defn2 macro can't define functions with multiple expressions
-in the body. We can make the macro variadic, just like a function. Here is a second version
-of this macro.
-
-```lisp
-(defmacro defn2 [name args & body]
- (tuple 'def name (apply tuple 'fn name args body)))
-```
-
-Great! Now we can define functions with multiple elements in the body. We can still improve this
-macro even more though. First, we can add a docstring to it. If someone is using the function later,
-they can use `(doc defn3)` to get a description of the function. Next, we can rewrite the macro
-using janet's builtin quasiquoting facilities.
-
-```lisp
-(defmacro defn3
- "Defines a new function."
- [name args & body]
- ~(def ,name (fn ,name ,args ,;body)))
-```
-
-This is functionally identical to our previous version `defn2`, but written in such
-a way that the macro output is more clear. The leading tilde `~` is shorthand for the
-`(quasiquote x)` special form, which is like `(quote x)` except we can unquote
-expressions inside it. The comma in front of `name` and `args` is an unquote, which
-allows us to put a value in the quasiquote. Without the unquote, the symbol \'name\'
-would be put in the returned tuple. Without the unquote, every function we defined
-would be called \'name\'!.
-
-Similar to name, we must also unquote body. However, a normal unquote doesn't work.
-See what happens if we use a normal unquote for body as well.
-
-```lisp
-(def name 'myfunction)
-(def args '[x y z])
-(defn body '[(print x) (print y) (print z)])
-
-~(def ,name (fn ,name ,args ,body))
-# -> (def myfunction (fn myfunction (x y z) ((print x) (print y) (print z))))
-```
-
-There is an extra set of parentheses around the body of our function! We don't
-want to put the body *inside* the form `(fn args ...)`, we want to *splice* it
-into the form. Luckily, janet has the `(splice x)` special form for this purpose,
-and a shorthand for it, the ; character.
-When combined with the unquote special, we get the desired output.
-
-```lisp
-~(def ,name (fn ,name ,args ,;body))
-# -> (def myfunction (fn myfunction (x y z) (print x) (print y) (print z)))
-```
-
-## Hygiene
-
-Sometime when we write macros, we must generate symbols for local bindings. Ignoring that
-it could be written as a function, consider
-the following macro
-
-```lisp
-(defmacro max1
- "Get the max of two values."
- [x y]
- ~(if (> ,x ,y) ,x ,y))
-```
-
-This almost works, but will evaluate both x and y twice. This is because both show up
-in the macro twice. For example, `(max1 (do (print 1) 1) (do (print 2) 2))` will
-print both 1 and 2 twice, which is surprising to a user of this macro.
-
-We can do better:
-
-```lisp
-(defmacro max2
- "Get the max of two values."
- [x y]
- ~(let [x ,x
-        y ,y]
-    (if (> x y) x y)))
-```
-
-Now we have no double evaluation problem! But we now have an even more subtle problem.
-What happens in the following code?
-
-```lisp
-(def x 10)
-(max2 8 (+ x 4))
-```
-
-We want the max to be 14, but this will actually evaluate to 12! This can be understood
-if we expand the macro. You can expand macro once in janet using the `(macex1 x)` function.
-(To expand macros until there are no macros left to expand, use `(macex x)`. Be careful,
- janet has many macros, so the full expansion may be almost unreadable).
-
-```lisp
-(macex1 '(max2 8 (+ x 4)))
-# -> (let (x 8 y (+ x 4)) (if (> x y) x y))
-```
-
-After expansion, y wrongly refers to the x inside the macro (which is bound to 8) rather than the x defined
-to be 10. The problem is the reuse of the symbol x inside the macro, which overshadowed the original
-binding.
-
-Janet provides a general solution to this problem in terms of the `(gensym)` function, which returns
-a symbol which is guaranteed to be unique and not collide with any symbols defined previously. We can define
-our macro once more for a fully correct macro.
-
-```lisp
-(defmacro max3
- "Get the max of two values."
- [x y]
- (def $x (gensym))
- (def $y (gensym))
- ~(let [,$x ,x
-        ,$y ,y]
-    (if (> ,$x ,$y) ,$x ,$y)))
-```
-
-As you can see, macros are very powerful but also are prone to subtle bugs. You must remember that
-at their core, macros are just functions that output code, and the code that they return must
-work in many contexts!

doc/Loop.md

@@ -1,174 +0,0 @@
-# Loops in Janet
-
-A very common and essential operation in all programming is looping. Most
-languages support looping of some kind, either with explicit loops or recursion.
-Janet supports both recursion and a primitive `while` loop. While recursion is
-useful in many cases, sometimes is more convenient to use a explicit loop to
-iterate over a collection like an array.
-
-## An Example - Iterating a Range
-
-Suppose you want to calculate the sum of the first 10 natural numbers
-0 through 9. There are many ways to carry out this explicit calculation
-even with taking shortcuts. A succinct way in janet is
-
-```
-(+ ;(range 10))
-```
-
-We will limit ourselves however to using explicit looping and no functions
-like `(range n)` which generate a list of natural numbers for us.
-
-For our first version, we will use only the while macro to iterate, similar
-to how one might sum natural numbers in a language such as C.
-
-```
-(var sum 0)
-(var i 0)
-(while (< i 10)
-    (+= sum i)
-    (++ i))
-(print sum) # prints 45
-```
-This is a very imperative style program which can grow very large very quickly.
-We are manually updating a counter `i` in a loop. Using the macros `+=` and `++`, this
-style code is similar in density to C code.
-It is recommended to use either macros (such as the loop macro) or a functional
-style in janet.
-
-Since this is such a common pattern, Janet has a macro for this exact purpose. The
-`(for x start end body)` captures exactly this behavior of incrementing a counter
-in a loop.
-
-```
-(var sum 0)
-(for i 0 10 (+= sum i))
-(print sum) # prints 45
-```
-
-We have completely wrapped the imperative counter in a macro. The for macro, while not
-very flexible, is very terse and covers a common case of iteration, iterating over an integer range. The for macro will be expanded to something very similar to our original
-version with a while loop.
-
-We can do something similar with the more flexible `loop` macro.
-
-```
-(var sum 0)
-(loop [i :range [0 10]] (+= sum i))
-(print sum) # prints 45
-```
-
-This is slightly more verbose than the for macro, but can be more easily extended.
-Let's say that we wanted to only count even numbers towards the sum. We can do this
-easily with the loop macro.
-
-```
-(var sum 0)
-(loop [i :range [0 10] :when (even? i)] (+= sum i))
-(print sum) # prints 20
-```
-
-The loop macro has several verbs (:range) and modifiers (:when) that let
-the programmer more easily generate common looping idioms. The loop macro
-is similar to the Common Lips loop macro, but smaller in scope and with a much
-simpler syntax. As with the `for` macro, the loop macro expands to similar
-code as our original while expression.
-
-## Another Example - Iterating an Indexed Data Structure
-
-Another common usage for iteration in any language is iterating over the items in
-some data structure, like items in an array, characters in a string, or key value
-pairs in a table.
-
-Say we have an array of names that we want to print out. We will
-again start with a simple while loop which we will refine into
-more idiomatic expressions.
-
-First, we will define our array of names
-```
-(def names @["Jean-Paul Sartre" "Bob Dylan" "Augusta Ada King" "Frida Kahlo" "Harriet Tubman")
-```
-
-With our array of names, we can use a while loop to iterate through the indices of names, get the
-values, and the print them.
-
-```
-(var i 0)
-(def len (length names))
-(while (< i len)
-    (print (get names i))
-    (++ i))
-```
-
-This is rather verbose. janet provides the `each` macro for iterating through the items in a tuple or
-array, or the bytes in a buffer, symbol, or string.
-
-```
-(each name names (print name))
-```
-
-We can also use the `loop` macro for this case as well using the `:in` verb.
-
-```
-(loop [name :in names] (print name))
-```
-
-## Iterating a Dictionary
-
-In the previous example, we iterated over the values in an array. Another common
-use of looping in a Janet program is iterating over the keys or values in a table.
-We cannot use the same method as iterating over an array because a table or struct does
-not contain a known integer range of keys. Instead we rely on a function `next`, which allows
-us to visit each of the keys in a struct or table. Note that iterating over a table will not
-visit the prototype table.
-
-As an example, lets iterate over a table of letters to a word that starts with that letter. We
-will print out the words to our simple children's book.
-
-```
-(def alphabook
-  @{"A" "Apple"
-    "B" "Banana"
-    "C" "Cat"
-    "D" "Dog"
-    "E" "Elephant" })
-```
-
-As before, we can evaluate this loop using only a while loop and the `next` function.
-
-```
-(var key (next alphabook nil))
-(while (not= nil key)
-  (print key " is for " (get alphabook key))
-  (set key (next alphabook key))
-```
-
-However, we can do better than this with the loop macro using the `:pairs` or `:keys` verbs.
-
-```
-(loop [[letter word] :pairs alphabook]
-  (print letter " is for " word))
-```
-
-Using the `:keys` verb and the dot syntax for indexing
-
-```
-(loop [letter :keys alphabook]
-  (print letter " is for " alphabook.letter))
-```
-
-The symbol `alphabook.letter` is shorthand for `(get alphabook letter)`.
-Note that the dot syntax of `alphabook.letter` is different than in many languages. In C or
-ALGOL like languages, it is more akin to the indexing operator, and would be written `alphabook[letter]`.
-The `.` character is part of the symbol and is recognized by the compiler.
-
-We can also use the core library functions `keys` and `pairs` to get arrays of the keys and
-pairs respectively of the alphabook.
-
-```
-(loop [[letter word] :in (pairs alphabook)]
-  (print letter " is for " word))
-
-(loop [letter :in (keys alphabook)]
-  (print letter " is for " alphabook.letter))
-```

doc/Parser.md

@@ -1,244 +0,0 @@
-# The Parser
-
-A Janet program begins life as a text file, just a sequence of byte like
-any other on your system. Janet source files should be UTF-8 or ASCII
-encoded. Before Janet can compile or run your program, it must transform
-your source code into a data structure. Janet is a lisp, which means it is
-homoiconic - code is data, so all of the facilities in the language for
-manipulating arrays, tuples, strings, and tables can be used for manipulating
-your source code as well.
-
-But before janet code is represented as a data structure, it must be read, or parsed,
-by the janet parser. Called the reader in many other lisps, the parser is a machine
-that takes in plain text and outputs data structures which can be used by both
-the compiler and macros. In janet, it is a parser rather than a reader because
-there is no code execution at read time. This is safer and simpler, and also
-lets janet syntax serve as a robust data interchange format. While a parser
-is not extensible, in janet the philosophy is to extend the language via macros
-rather than reader macros.
-
-## Nil, True and False
-
-Nil, true and false are all literals than can be entered as such
-in the parser.
-
-```
-nil
-true
-false
-```
-
-## Symbols
-
-Janet symbols are represented a sequence of alphanumeric characters
-not starting with a digit or a colon. They can also contain the characters
-\!, @, $, \%, \^, \&, \*, -, \_, +, =, \|, \~, :, \<, \>, ., \?, \\, /, as
-well as any Unicode codepoint not in the ASCII range.
-
-By convention, most symbols should be all lower case and use dashes to connect words
-(sometimes called kebab case).
-
-Symbols that come from another module often contain a forward slash that separates
-the name of the module from the name of the definition in the module
-
-```
-symbol
-kebab-case-symbol
-snake_case_symbol
-my-module/my-fuction
-*****
-!%$^*__--__._+++===~-crazy-symbol
-*global-var*
-你好
-```
-
-## Keywords
-
-Janet keywords are like symbols that begin with the character :. However, they
-are used differently and treated by the compiler as a constant rather than a name for
-something. Keywords are used mostly for keys in tables and structs, or pieces of syntax
-in macros.
-
-```
-:keyword
-:range
-:0x0x0x0
-:a-keyword
-::
-:
-```
-
-## Numbers
-
-Janet numbers are represented by IEEE-754 floating point numbers.
-The syntax is similar to that of many other languages
-as well. Numbers can be written in base 10, with
-underscores used to separate digits into groups. A decimal point can be used for floating
-point numbers. Numbers can also be written in other bases by prefixing the number with the desired
-base and the character 'r'. For example, 16 can be written as `16`, `1_6`, `16r10`, `4r100`, or `0x10`. The
-`0x` prefix can be used for hexadecimal as it is so common. The radix must be themselves written in base 10, and
-can be any integer from 2 to 36. For any radix above 10, use the letters as digits (not case sensitive).
-
-```
-0
-12
--65912
-4.98
-1.3e18
-1.3E18
-18r123C
-11raaa&a
-1_000_000
-0xbeef
-```
-
-## Strings
-
-Strings in janet are surrounded by double quotes. Strings are 8bit clean, meaning
-meaning they can contain any arbitrary sequence of bytes, including embedded
-0s. To insert a double quote into a string itself, escape
-the double quote with a backslash. For unprintable characters, you can either use
-one of a few common escapes, use the `\xHH` escape to escape a single byte in
-hexidecimal. The supported escapes are:
-
-    - \\xHH Escape a single arbitrary byte in hexidecimal.
-    - \\n Newline (ASCII 10)
-    - \\t Tab character (ASCII 9)
-    - \\r Carriage Return (ASCII 13)
-    - \\0 Null (ASCII 0)
-    - \\z Null (ASCII 0)
-    - \\f Form Feed (ASCII 12)
-    - \\e Escape (ASCII 27)
-    - \\" Double Quote (ASCII 34)
-    - \\\\ Backslash (ASCII 92)
-
-Strings can also contain literal newline characters that will be ignore.
-This lets one define a multiline string that does not contain newline characters.
-
-An alternative way of representing strings in janet is the long string, or the backquote
-delimited string. A string can also be define to start with a certain number of
-backquotes, and will end the same number of backquotes. Long strings
-do not contain escape sequences; all bytes will be parsed literally until
-ending delimiter is found. This is useful
-for defining multi-line strings with literal newline characters, unprintable
-characters, or strings that would otherwise require many escape sequences.
-
-```
-"This is a string."
-"This\nis\na\nstring."
-"This
-is
-a
-string."
-``
-This
-is
-a
-string
-``
-```
-
-## Buffers
-
-Buffers are similar strings except they are mutable data structures. Strings in janet
-cannot be mutated after created, where a buffer can be changed after creation.
-The syntax for a buffer is the same as that for a string or long string, but
-the buffer must be prefixed with the '@' character.
-
-```
-@""
-@"Buffer."
-@``Another buffer``
-```
-
-## Tuples
-
-Tuples are a sequence of white space separated values surrounded by either parentheses
-or brackets. The parser considers any of the characters ASCII 32, \\0, \\f, \\n, \\r or \\t
-to be white-space.
-
-```
-(do 1 2 3)
-[do 1 2 3]
-```
-
-## Arrays
-
-Arrays are the same as tuples, but have a leading @ to indicate mutability.
-
-```
-@(:one :two :three)
-@[:one :two :three]
-```
-
-## Structs
-
-Structs are represented by a sequence of white-space delimited key value pairs
-surrounded by curly braces. The sequence is defined as key1, value1, key2, value2, etc.
-There must be an even number of items between curly braces or the parser will
-signal a parse error. Any value can be a key or value. Using nil as a key or
-value, however, will drop that pair from the parsed struct.
-
-```
-{}
-{:key1 "value1" :key2 :value2 :key3 3}
-{(1 2 3) (4 5 6)}
-{@[] @[]}
-{1 2 3 4 5 6}
-```
-## Tables
-
-Table have the same syntax as structs, except they have the @ prefix to indicate
-that they are mutable.
-
-```
-@{}
-@{:key1 "value1" :key2 :value2 :key3 3}
-@{(1 2 3) (4 5 6)}
-@{@[] @[]}
-@{1 2 3 4 5 6}
-```
-
-## Comments
-
-Comments begin with a \# character and continue until the end of the line.
-There are no multi-line comments.
-
-## Shorthand
-
-Often called reader macros in other lisps, Janet provides several shorthand
-notations for some forms.
-
-### 'x
-
-Shorthand for `(quote x)`
-
-### ;x
-
-Shorthand for `(splice x)`
-
-### ~x
-
-Shorthand for `(quasiquote x)`
-
-### ,x
-
-Shorthand for `(unquote x)`
-
-These shorthand notations can be combined in any order, allowing
-forms like `''x` (`(quote (quote x))`), or `,;x` (`(unquote (splice x))`).
-
-## API
-
-The parser contains the following functions which exposes
-the parser state machine as a janet abstract object.
-
-- `parser/byte`
-- `parser/consume`
-- `parser/error`
-- `parser/flush`
-- `parser/new`
-- `parser/produce`
-- `parser/state`
-- `parser/status`
-- `parser/where`

doc/Specials.md

@@ -1,206 +0,0 @@
-# Special Forms
-
-Janet is a lisp and so is defined in terms of mostly S-expressions, or
-in terms of Janet, tuples. Tuples are used to represent function calls, macros,
-and special forms. Most functionality is exposed through functions, some
-through macros, and a minimal amount through special forms. Special forms
-are neither functions nor macros -- they are used by the compiler to directly
-express a low level construct that can not be expressed through macros or functions.
-Special forms can be thought of as forming the real 'core' language of janet.
-
-Below is a reference for all of the special forms in Janet.
-
-## (def name meta... value)
-
-This special form binds a value to a symbol. The symbol can the be substituted
-for the value in subsequent expression for the same result. A binding made by def
-is a constant and cannot be updated. A symbol can be redefined to a new value, but previous
-uses of the binding will refer to the previous value of the binding.
-
-```lisp
-(def anumber (+ 1 2 3 4 5))
-
-(print anumber) # prints 15
-```
-
-Def can also take a tuple, array, table or struct to perform destructuring
-on the value. This allows us to do multiple assignments in one def.
-
-```lisp
-(def [a b c] (range 10))
-(print a " " b " " c) # prints 0 1 2
-
-(def {:x x} @{:x (+ 1 2)})
-(print x) # prints 3
-
-(def [y {:x x}] @[:hi @{:x (+ 1 2)}])
-(print y x) # prints hi3
-```
-
-Def can also append metadata and a docstring to the symbol when in the global scope.
-If not in the global scope, the extra metadata will be ignored.
-
-```lisp
-(def mydef :private 3) # Adds the :private key to the metadata table.
-(def mydef2 :private "A docstring" 4) # Add a docstring
-
-# The metadata will be ignored here because mydef is
-# accessible outside of the do form.
-(do
- (def mydef :private 3)
- (+ mydef 1))
-```
-
-## (var name meta... value)
-
-Similar to def, but bindings set in this manner can be updated using set. In all other respects is the
-same as def.
-
-```lisp
-(var a 1)
-(defn printa [] (print a))
-
-(printa) # prints 1
-(++ a)
-(printa) # prints 2
-(set a :hi)
-(printa) # prints hi
-```
-
-## (fn name? args body...)
-
-Compile a function literal (closure). A function literal consists of an optional name, an
-argument list, and a function body. The optional name is allowed so that functions can
-more easily be recursive. The argument list is a tuple of named parameters, and the body
-is 0 or more forms. The function will evaluate to the last form in the body. The other forms
-will only be evaluated for side effects.
-
-Functions also introduced a new lexical scope, meaning the defs and vars inside a function
-body will not escape outside the body.
-
-```lisp
-(fn []) # The simplest function literal. Takes no arguments and returns nil.
-(fn [x] x) # The identity function
-(fn identity [x] x) # The identity function - the name will also make stacktraces nicer.
-(fn [] 1 2 3 4 5) # A function that returns 5
-(fn [x y] (+ x y)) # A function that adds its two arguments.
-
-(fn [& args] (length args)) # A variadic function that counts its arguments.
-
-# A function that doesn't strictly check the number of arguments.
-# Extra arguments are ignored, and arguments not passed are nil.
-(fn [w x y z &] (tuple w w x x y y z z))
-```
-
-## (do body...)
-
-Execute a series of forms for side effects and evaluates to the final form. Also
-introduces a new lexical scope without creating or calling a function.
-
-```lisp
-(do 1 2 3 4) # Evaluates to 4
-
-# Prints 1, 2 and 3, then evaluates to (print 3), which is nil
-(do (print 1) (print 2) (print 3))
-
-# Prints 1
-(do
- (def a 1)
- (print a))
-
-# a is not defined here, so fails
-a
-```
-
-## (quote x)
-
-Evaluates to the literal value of the first argument. The argument is not compiled
-and is simply used as a constant value in the compiled code. Preceding a form with a
-single quote is shorthand for `(quote expression)`.
-
-```lisp
-(quote 1) # evaluates to 1
-(quote hi) # evaluates to the symbol hi
-(quote quote) # evaluates to the symbol quote
-
-`(1 2 3) # Evaluates to a tuple (1 2 3)
-`(print 1 2 3) # Evaluates to a tuple (print 1 2 3)
-```
-
-## (if condition when-true when-false?)
-
-Introduce a branching construct. The first form is the condition, the second
-form is the form to evaluate when the condition is true, and the optional
-third form is the form to evaluate when the condition is false. If no third
-form is provided it defaults to nil.
-
-The if special form will not evaluate the when-true or when-false forms unless
-it needs to - it is a lazy form, which is why it cannot be a function or macro.
-
-The condition is considered false only if it evaluates to nil or false - all other values
-are considered true.
-
-```lisp
-(if true 10) # evaluates to 10
-(if false 10) # evaluates to nil
-(if true (print 1) (print 2)) # prints 1 but not 2
-```
-
-## (splice x)
-
-The splice special form is an interesting form that doesn't have an analog in most lisps.
-It only has an effect in two places - as an argument in a function call, or as the argument
-to the unquote form. Outside of these two settings, the splice special form simply evaluates
-directly to it's argument x. The shorthand for splice is prefixing a form with a semicolon.
-
-In the context of a function call, splice will insert *the contents* of x in the parameter list.
-
-```lisp
-(+ 1 2 3) # evaluates to 6
-
-(+ @[1 2 3]) # bad
-
-(+ (splice @[1 2 3])) # also evaluates to 6
-
-(+ ;@[1 2 3]) # Same as above
-
-(+ ;(range 100)) # Sum the first 100 natural numbers
-
-(+ ;(range 100) 1000) # Sum the first 100 natural numbers and 1000
-```
-
-Notice that this means we rarely will need the `apply` function, as the splice operator is more flexible.
-
-The splice operator can also be used inside an unquote form, where it will behave like
-an `unquote-splicing` special in other lisps.
-
-## (while condition body...)
-
-The while special form compiles to a C-like while loop. The body of the form will be continuously evaluated
-until the condition is false or nil. Therefor, it is expected that the body will contain some side effects
-of the loop will go on for ever. The while loop always evaluates to nil.
-
-```lisp
-(var i 0)
-(while (< i 10)
- (print i)
- (++ i))
-```
-
-## (set l-value r-value)
-
-Update the value of a var l-value to a new value r-value. The set special form will then evaluate to r-value.
-
-The r-value can be any expression, and the l-value should be a bound var.
-
-## (quasiquote x)
-
-Similar to `(quote x)`, but allows for unquoting within x. This makes quasiquote useful for
-writing macros, as a macro definition often generates a lot of templated code with a
-few custom values. The shorthand for quasiquote is a leading tilde `~` before a form. With
-that form, `(unquote x)` will evaluate and insert x into the unquote form. The shorthand for
-`(unquote x)` is `,x`.
-
-## (unquote x)
-
-Unquote a form within a quasiquote. Outside of a quasiquote, unquote is invalid.

doc/The-Janet-Abstract-Machine-Bytecode.md

@@ -1,224 +0,0 @@
-The Janet language is implemented on top of an abstract machine (AM). The compiler
-converts Janet data structures to this bytecode, which can then be efficiently executed
-from inside a C program. To understand the janet bytecode, it is useful to understand
-the abstractions used inside the Janet AM, as well as the C types used to implement these
-features.
-
-## The Stack = The Fiber
-
-A Janet Fiber is the type used to represent multiple concurrent processes
-in janet. It is basically a wrapper around the idea of a stack. The stack is
-divided into a number of stack frames (`JanetStackFrame *` in C), each of which
-contains information such as the function that created the stack frame,
-the program counter for the stack frame, a pointer to the previous frame,
-and the size of the frame. Each stack frame also is paired with a number
-registers.
-
-```
-X: Slot
-
-X
-X - Stack Top, for next function call.
------
-Frame next
------
-X
-X
-X
-X
-X
-X
-X - Stack 0
------
-Frame 0
------
-X
-X
-X - Stack -1
------
-Frame -1
------
-X
-X
-X
-X
-X - Stack -2
------
-Frame -2
------
-...
-...
-...
------
-Bottom of stack
-```
-
-Fibers also have an incomplete stack frame for the next function call on top
-of their stacks. Making a function call involves pushing arguments to this
-temporary stack, and then invoking either the CALL or TCALL instructions.
-Arguments for the next function call are pushed via the PUSH, PUSH2, PUSH3, and
-PUSHA instructions. The stack of a fiber will grow as large as needed, although by
-default janet will limit the maximum size of a fiber's stack.
-The maximum stack size can be modified on a per fiber basis.
-
-The slots in the stack are exposed as virtual registers to instructions. They
-can hold any Janet value.
-
-## Closures
-
-All functions in janet are closures; they combine some bytecode instructions
-with 0 or more environments. In the C source, a closure (hereby the same as
-a function) is represented by the type `JanetFunction *`. The bytecode instruction
-part of the function is represented by `JanetFuncDef *`, and a function environment
-is represented with `JanetFuncEnv *`.
-
-The function definition part of a function (the 'bytecode' part, `JanetFuncDef *`),
-we also store various metadata about the function which is useful for debugging,
-as well as constants referenced by the function.
-
-## C Functions
-
-Janet uses C functions to bridge to native code. A C function
-(`JanetCFunction *` in C) is a C function pointer that can be called like
-a normal janet closure. From the perspective of the bytecode instruction set, there is no difference
-in invoking a C function and invoking a normal janet function.
-
-## Bytecode Format
-
-Janet bytecode presents an interface to a virtual machine with a large number
-of identical registers that can hold any Janet value (`Janet *` in C). Most instructions
-have a destination register, and 1 or 2 source register. Registers are simply
-named with positive integers.
-
-Each instruction is a 32 bit integer, meaning that the instruction set is a constant
-width RISC instruction set like MIPS. The opcode of each instruction is the least significant
-byte of the instruction. The highest bit of
-this leading byte is reserved for debugging purpose, so there are 128 possible opcodes encodable
-with this scheme. Not all of these possible opcode are defined, and will trap the interpreter
-and emit a debug signal. Note that this mean an unknown opcode is still valid bytecode, it will
-just put the interpreter into a debug state when executed.
-
-```
-X - Payload bits
-O - Opcode bits
-
-   4    3    2    1
-+----+----+----+----+
-| XX | XX | XX | OO |
-+----+----+----+----+
-```
-
-8 bits for the opcode leaves 24 bits for the payload, which may or may not be utilized.
-There are a few instruction variants that divide these payload bits.
-
-* 0 arg - Used for noops, returning nil, or other instructions that take no
-  arguments. The payload is essentially ignored.
-* 1 arg - All payload bits correspond to a single value, usually a signed or unsigned integer.
-  Used for instructions of 1 argument, like returning a value, yielding a value to the parent fiber,
-  or doing a (relative) jump.
-* 2 arg - Payload is split into byte 2 and bytes 3 and 4.
-  The first argument is the 8 bit value from byte 2, and the second argument is the 16 bit value
-  from bytes 3 and 4 (`instruction >> 16`). Used for instructions of two arguments, like move, normal
-  function calls, conditionals, etc.
-* 3 arg - Bytes 2, 3, and 4 each correspond to an 8 bit argument.
-  Used for arithmetic operations, emitting a signal, etc.
-
-These instruction variants can be further refined based on the semantics of the arguments.
-Some instructions may treat an argument as a slot index, while other instructions
-will treat the argument as a signed integer literal, and index for a constant, an index
-for an environment, or an unsigned integer.
-
-## Instruction Reference
-
-A listing of all opcode values can be found in src/include/janet/janetopcodes.h. The janet assembly
-short names can be found src/assembler/asm.c. In this document, we will refer to the instructions
-by their short names as presented to the assembler rather than their numerical values.
-
-Each instruction is also listed with a signature, which are the arguments the instruction
-expects. There are a handful of instruction signatures, which combine the arity and type
-of the instruction. The assembler does not
-do any type-checking per closure, but does prevent jumping to invalid instructions and
-failure to return or error.
-
-### Notation
-
-* The $ prefix indicates that a instruction parameter is acting as a virtual register (slot).
-  If a parameter does not have the $ suffix in the description, it is acting as some kind
-  of literal (usually an unsigned integer for indexes, and a signed integer for literal integers).
-
-* Some operators in the description have the suffix 'i' or 'r'. These indicate
-  that these operators correspond to integers or real numbers only, respectively. All
-  bit-wise operators and bit shifts only work with integers.
-
-* The `>>>` indicates unsigned right shift, as in Java. Because all integers in janet are
-  signed, we differentiate the two kinds of right bit shift.
-
-* The 'im' suffix in the instruction name is short for immediate.
-
-### Reference Table
-
-| Instruction | Signature                   | Description                       |
-| ----------- | --------------------------- | --------------------------------- |
-| `add`       | `(add dest lhs rhs)`        | $dest = $lhs + $rhs               |
-| `addim`     | `(addim dest lhs im)`       | $dest = $lhs + im                 |
-| `band`      | `(band dest lhs rhs)`       | $dest = $lhs & $rhs               |
-| `bnot`      | `(bnot dest operand)`       | $dest = ~$operand                 |
-| `bor`       | `(bor dest lhs rhs)`        | $dest = $lhs | $rhs               |
-| `bxor`      | `(bxor dest lhs rhs)`       | $dest = $lhs ^ $rhs               |
-| `call`      | `(call dest callee)`        | $dest = call($callee, args)       |
-| `clo`       | `(clo dest index)`          | $dest = closure(defs[$index])     |
-| `cmp`       | `(cmp dest lhs rhs)`        | $dest = janet\_compare($lhs, $rhs)|
-| `div`       | `(div dest lhs rhs)`        | $dest = $lhs / $rhs               |
-| `divim`     | `(divim dest lhs im)`       | $dest = $lhs / im                 |
-| `eq`        | `(eq dest lhs rhs)`         | $dest = $lhs == $rhs              |
-| `eqim`      | `(eqim dest lhs im)`        | $dest = $lhs == im                |
-| `err`       | `(err message)`             | Throw error $message.             |
-| `get`       | `(get dest ds key)`         | $dest = $ds[$key]                 |
-| `geti`      | `(geti dest ds index)`      | $dest = $ds[index]                |
-| `gt`        | `(gt dest lhs rhs)`         | $dest = $lhs \> $rhs              |
-| `gtim`      | `(gtim dest lhs im)`        | $dest = $lhs \> im                |
-| `jmp`       | `(jmp label)`               | pc = label, pc += offset          |
-| `jmpif`     | `(jmpif cond label)`        | if $cond pc = label else pc++     |
-| `jmpno`     | `(jmpno cond label)`        | if $cond pc++ else pc = label     |
-| `ldc`       | `(ldc dest index)`          | $dest = constants[index]          |
-| `ldf`       | `(ldf dest)`                | $dest = false                     |
-| `ldi`       | `(ldi dest integer)`        | $dest = integer                   |
-| `ldn`       | `(ldn dest)`                | $dest = nil                       |
-| `lds`       | `(lds dest)`                | $dest = current closure (self)    |
-| `ldt`       | `(ldt dest)`                | $dest = true                      |
-| `ldu`       | `(ldu dest env index)`      | $dest = envs[env][index]          |
-| `len`       | `(len dest ds)`             | $dest = length(ds)                |
-| `lt`        | `(lt dest lhs rhs)`         | $dest = $lhs \< $rhs              |
-| `ltim`      | `(ltim dest lhs im)`        | $dest = $lhs \< im                |
-| `mkarr`     | `(mkarr dest)`              | $dest = call(array, args)         |
-| `mkbuf`     | `(mkbuf dest)`              | $dest = call(buffer, args)        |
-| `mktab`     | `(mktab dest)`              | $dest = call(table, args)         |
-| `mkstr`     | `(mkstr dest)`              | $dest = call(string, args)        |
-| `mkstu`     | `(mkstu dest)`              | $dest = call(struct, args)        |
-| `mktup`     | `(mktup dest)`              | $dest = call(tuple, args)         |
-| `movf`      | `(movf src dest)`           | $dest = $src                      |
-| `movn`      | `(movn dest src)`           | $dest = $src                      |
-| `mul`       | `(mul dest lhs rhs)`        | $dest = $lhs \* $rhs              |
-| `mulim`     | `(mulim dest lhs im)`       | $dest = $lhs \* im                |
-| `noop`      | `(noop)`                    | Does nothing.                     |
-| `push`      | `(push val)`                | Push $val on arg                  |
-| `push2`     | `(push2 val1 val3)`         | Push $val1, $val2 on args         |
-| `push3`     | `(push3 val1 val2 val3)`    | Push $val1, $val2, $val3, on args |
-| `pusha`     | `(pusha array)`             | Push values in $array on args     |
-| `put`       | `(put ds key val)`          | $ds[$key] = $val                  |
-| `puti`      | `(puti ds index val)`       | $ds[index] = $val                 |
-| `res`       | `(res dest fiber val)`      | $dest = resume $fiber with $val   |
-| `ret`       | `(ret val)`                 | Return $val                       |
-| `retn`      | `(retn)`                    | Return nil                        |
-| `setu`      | `(setu env index val)`      | envs[env][index] = $val           |
-| `sig`       | `(sig dest value sigtype)`  | $dest = emit $value as sigtype    |
-| `sl`        | `(sl dest lhs rhs)`         | $dest = $lhs << $rhs              |
-| `slim`      | `(slim dest lhs shamt)`     | $dest = $lhs << shamt             |
-| `sr`        | `(sr dest lhs rhs)`         | $dest = $lhs >> $rhs              |
-| `srim`      | `(srim dest lhs shamt)`     | $dest = $lhs >> shamt             |
-| `sru`       | `(sru dest lhs rhs)`        | $dest = $lhs >>> $rhs             |
-| `sruim`     | `(sruim dest lhs shamt)`    | $dest = $lhs >>> shamt            |
-| `sub`       | `(sub dest lhs rhs)`        | $dest = $lhs - $rhs               |
-| `tcall`     | `(tcall callee)`            | Return call($callee, args)        |
-| `tchck`     | `(tcheck slot types)`       | Assert $slot does matches types   |
-

examples/3sum.janet

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

examples/assembly.janet

@@ -1,23 +1,22 @@
 # Example of dst bytecode assembly
 
 # Fibonacci sequence, implemented with naive recursion.
-(def fibasm (asm '{
-  arity 1
-  bytecode [
-    (ltim 1 0 0x2)      # $1 = $0 < 2
-    (jmpif 1 :done)     # if ($1) goto :done
-    (lds 1)             # $1 = self
-    (addim 0 0 -0x1)    # $0 = $0 - 1
-    (push 0)            # push($0), push argument for next function call
-    (call 2 1)          # $2 = call($1)
-    (addim 0 0 -0x1)    # $0 = $0 - 1
-    (push 0)            # push($0)
-    (call 0 1)          # $0 = call($1)
-    (add 0 0 2)        # $0 = $0 + $2 (integers)
-    :done
-    (ret 0)             # return $0
-  ]
-}))
+(def fibasm
+  (asm
+    '{:arity 1
+      :bytecode @[(ltim 1 0 0x2)   # $1 = $0 < 2
+                  (jmpif 1 :done)  # if ($1) goto :done
+                  (lds 1)          # $1 = self
+                  (addim 0 0 -0x1) # $0 = $0 - 1
+                  (push 0)         # push($0), push argument for next function call
+                  (call 2 1)       # $2 = call($1)
+                  (addim 0 0 -0x1) # $0 = $0 - 1
+                  (push 0)         # push($0)
+                  (call 0 1)       # $0 = call($1)
+                  (add 0 0 2)      # $0 = $0 + $2 (integers)
+                  :done
+                  (ret 0)          # return $0
+]}))
 
 # Test it
 

examples/async-execute.janet

@@ -0,0 +1,22 @@
+(defn dowork [name n]
+  (print name " starting work...")
+  (os/execute [(dyn :executable) "-e" (string "(os/sleep " n ")")] :p)
+  (print name " finished work!"))
+
+# Will be done in parallel
+(print "starting group A")
+(ev/call dowork "A 2" 2)
+(ev/call dowork "A 1" 1)
+(ev/call dowork "A 3" 3)
+
+(ev/sleep 4)
+
+# Will also be done in parallel
+(print "starting group B")
+(ev/call dowork "B 2" 2)
+(ev/call dowork "B 1" 1)
+(ev/call dowork "B 3" 3)
+
+(ev/sleep 4)
+
+(print "all work done")

examples/channel.janet

@@ -0,0 +1,15 @@
+(def c (ev/chan 4))
+
+(defn writer []
+  (for i 0 10
+    (ev/sleep 0.1)
+    (print "writer giving item " i "...")
+    (ev/give c (string "item " i))))
+
+(defn reader [name]
+  (forever
+    (print "reader " name " got " (ev/take c))))
+
+(ev/call writer)
+(each letter [:a :b :c :d :e :f :g]
+  (ev/call reader letter))

examples/debug.janet

@@ -0,0 +1,11 @@
+# Load this file and run (myfn) to see the debugger
+
+(defn myfn
+  []
+  (debug)
+  (for i 0 10 (print i)))
+
+(debug/fbreak myfn 3)
+
+# Enable debugging in repl with
+# (setdyn :debug true)

examples/debugger.janet

@@ -0,0 +1,151 @@
+###
+### A useful debugger library for Janet. Should be used
+### inside a debug repl. This has been moved into the core.
+###
+
+(defn .fiber
+  "Get the current fiber being debugged."
+  []
+  (dyn :fiber))
+
+(defn .stack
+  "Print the current fiber stack"
+  []
+  (print)
+  (with-dyns [:err-color false] (debug/stacktrace (.fiber) ""))
+  (print))
+
+(defn .frame
+  "Show a stack frame"
+  [&opt n]
+  (def stack (debug/stack (.fiber)))
+  (in stack (or n 0)))
+
+(defn .fn
+  "Get the current function"
+  [&opt n]
+  (in (.frame n) :function))
+
+(defn .slots
+  "Get an array of slots in a stack frame"
+  [&opt n]
+  (in (.frame n) :slots))
+
+(defn .slot
+  "Get the value of the nth slot."
+  [&opt nth frame-idx]
+  (in (.slots frame-idx) (or nth 0)))
+
+(defn .quit
+  "Resume (dyn :fiber) with the value passed to it after exiting the debugger."
+  [&opt val]
+  (setdyn :exit true)
+  (setdyn :resume-value val)
+  nil)
+
+(defn .disasm
+  "Gets the assembly for the current function."
+  [&opt n]
+  (def frame (.frame n))
+  (def func (frame :function))
+  (disasm func))
+
+(defn .bytecode
+  "Get the bytecode for the current function."
+  [&opt n]
+  ((.disasm n) 'bytecode))
+
+(defn .ppasm
+  "Pretty prints the assembly for the current function"
+  [&opt n]
+  (def frame (.frame n))
+  (def func (frame :function))
+  (def dasm (disasm func))
+  (def bytecode (dasm 'bytecode))
+  (def pc (frame :pc))
+  (def sourcemap (dasm 'sourcemap))
+  (var last-loc [-2 -2])
+  (print "\n  function:   " (dasm 'name) " [" (in dasm 'source "") "]")
+  (when-let [constants (dasm 'constants)]
+    (printf "  constants:  %.4Q" constants))
+  (printf "  slots:      %.4Q\n" (frame :slots))
+  (def padding (string/repeat " " 20))
+  (loop [i :range [0 (length bytecode)]
+         :let [instr (bytecode i)]]
+    (prin (if (= (tuple/type instr) :brackets) "*" " "))
+    (prin (if (= i pc) "> " "  "))
+    (prinf "\e[33m%.20s\e[0m" (string (string/join (map string instr) " ") padding))
+    (when sourcemap
+      (let [[sl sc] (sourcemap i)
+            loc [sl sc]]
+        (when (not= loc last-loc)
+          (set last-loc loc)
+          (prin " # line " sl ", column " sc))))
+    (print))
+  (print))
+
+(defn .source
+  "Show the source code for the function being debugged."
+  [&opt n]
+  (def frame (.frame n))
+  (def s (frame :source))
+  (def all-source (slurp s))
+  (print "\n\e[33m" all-source "\e[0m\n"))
+
+(defn .breakall
+  "Set breakpoints on all instructions in the current function."
+  [&opt n]
+  (def fun (.fn n))
+  (def bytecode (.bytecode n))
+  (for i 0 (length bytecode)
+    (debug/fbreak fun i))
+  (print "Set " (length bytecode) " breakpoints in " fun))
+
+(defn .clearall
+  "Clear all breakpoints on the current function."
+  [&opt n]
+  (def fun (.fn n))
+  (def bytecode (.bytecode n))
+  (for i 0 (length bytecode)
+    (debug/unfbreak fun i))
+  (print "Cleared " (length bytecode) " breakpoints in " fun))
+
+(defn .break
+  "Set breakpoint at the current pc."
+  []
+  (def frame (.frame))
+  (def fun (frame :function))
+  (def pc (frame :pc))
+  (debug/fbreak fun pc)
+  (print "Set breakpoint in " fun " at pc=" pc))
+
+(defn .clear
+  "Clear the current breakpoint"
+  []
+  (def frame (.frame))
+  (def fun (frame :function))
+  (def pc (frame :pc))
+  (debug/unfbreak fun pc)
+  (print "Cleared breakpoint in " fun " at pc=" pc))
+
+(defn .next
+  "Go to the next breakpoint."
+  [&opt n]
+  (var res nil)
+  (for i 0 (or n 1)
+    (set res (resume (.fiber))))
+  res)
+
+(defn .nextc
+  "Go to the next breakpoint, clearing the current breakpoint."
+  [&opt n]
+  (.clear)
+  (.next n))
+
+(defn .step
+  "Execute the next n instructions."
+  [&opt n]
+  (var res nil)
+  (for i 0 (or n 1)
+    (set res (debug/step (.fiber))))
+  res)

examples/echoclient.janet

@@ -0,0 +1,5 @@
+(with [conn (net/connect "127.0.0.1" 8000)]
+  (print "writing abcdefg...")
+  (:write conn "abcdefg")
+  (print "reading...")
+  (printf "got: %v" (:read conn 1024)))

examples/echoserve.janet

@@ -0,0 +1,15 @@
+(defn handler
+  "Simple handler for connections."
+  [stream]
+  (defer (:close stream)
+    (def id (gensym))
+    (def b @"")
+    (print "Connection " id "!")
+    (while (:read stream 1024 b)
+      (printf " %v -> %v" id b)
+      (:write stream b)
+      (buffer/clear b))
+    (printf "Done %v!" id)
+    (ev/sleep 0.5)))
+
+(net/server "127.0.0.1" "8000" handler)

examples/evlocks.janet

@@ -0,0 +1,45 @@
+(defn sleep
+  "Sleep the entire thread, not just a single fiber."
+  [n]
+  (os/sleep (* 0.1 n)))
+
+(defn work [lock n]
+  (ev/acquire-lock lock)
+  (print "working " n "...")
+  (sleep n)
+  (print "done working...")
+  (ev/release-lock lock))
+
+(defn reader
+  [rwlock n]
+  (ev/acquire-rlock rwlock)
+  (print "reading " n "...")
+  (sleep n)
+  (print "done reading " n "...")
+  (ev/release-rlock rwlock))
+
+(defn writer
+  [rwlock n]
+  (ev/acquire-wlock rwlock)
+  (print "writing " n "...")
+  (sleep n)
+  (print "done writing...")
+  (ev/release-wlock rwlock))
+
+(defn test-lock
+  []
+  (def lock (ev/lock))
+  (for i 3 7
+    (ev/spawn-thread
+      (work lock i))))
+
+(defn test-rwlock
+  []
+  (def rwlock (ev/rwlock))
+  (for i 0 20
+    (if (> 0.1 (math/random))
+      (ev/spawn-thread (writer rwlock i))
+      (ev/spawn-thread (reader rwlock i)))))
+
+(test-rwlock)
+(test-lock)

examples/evsleep.janet

@@ -0,0 +1,22 @@
+(defn worker
+  "Run for a number of iterations."
+  [name iterations]
+  (for i 0 iterations
+    (ev/sleep 1)
+    (print "worker " name " iteration " i)))
+
+(ev/call worker :a 10)
+(ev/sleep 0.2)
+(ev/call worker :b 5)
+(ev/sleep 0.3)
+(ev/call worker :c 12)
+
+(defn worker2
+  [name]
+  (repeat 10
+    (ev/sleep 0.2)
+    (print name " working")))
+
+(ev/go worker2 :bob)
+(ev/go worker2 :joe)
+(ev/go worker2 :sally)

examples/ffi/gtk.janet

@@ -0,0 +1,71 @@
+# :lazy true needed for jpm quickbin
+# lazily loads library on first function use
+# so the `main` function
+# can be marshalled.
+(ffi/context "/usr/lib/libgtk-3.so" :lazy true)
+
+(ffi/defbind
+  gtk-application-new :ptr
+  "Add docstrings as needed."
+  [title :string flags :uint])
+
+(ffi/defbind
+  g-signal-connect-data :ulong
+  [a :ptr b :ptr c :ptr d :ptr e :ptr f :int])
+
+(ffi/defbind
+  g-application-run :int
+  [app :ptr argc :int argv :ptr])
+
+(ffi/defbind
+  gtk-application-window-new :ptr
+  [a :ptr])
+
+(ffi/defbind
+  gtk-button-new-with-label :ptr
+  [a :ptr])
+
+(ffi/defbind
+  gtk-container-add :void
+  [a :ptr b :ptr])
+
+(ffi/defbind
+  gtk-widget-show-all :void
+  [a :ptr])
+
+(ffi/defbind
+  gtk-button-set-label :void
+  [a :ptr b :ptr])
+
+(def cb (delay (ffi/trampoline :default)))
+
+(defn ffi/array
+  ``Convert a janet array to a buffer that can be passed to FFI functions.
+  For example, to create an array of type `char *` (array of c strings), one
+  could use `(ffi/array ["hello" "world"] :ptr)`. One needs to be careful that
+  array elements are not garbage collected though - the GC can't follow references
+  inside an arbitrary byte buffer.``
+  [arr ctype &opt buf]
+  (default buf @"")
+  (each el arr
+    (ffi/write ctype el buf))
+  buf)
+
+(defn on-active
+  [app]
+  (def window (gtk-application-window-new app))
+  (def btn (gtk-button-new-with-label "Click Me!"))
+  (g-signal-connect-data btn "clicked" (cb)
+                         (fn [btn] (gtk-button-set-label btn "Hello World"))
+                         nil 1)
+  (gtk-container-add window btn)
+  (gtk-widget-show-all window))
+
+(defn main
+  [&]
+  (def app (gtk-application-new "org.janet-lang.example.HelloApp" 0))
+  (g-signal-connect-data app "activate" (cb) on-active nil 1)
+  # manually build an array with ffi/write
+  # - we are responsible for preventing gc when the arg array is used
+  (def argv (ffi/array (dyn *args*) :string))
+  (g-application-run app (length (dyn *args*)) argv))

examples/ffi/so.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+int int_fn(int a, int b) {
+    return (a << 2) + b;
+}
+
+double my_fn(int64_t a, int64_t b, const char *x) {
+    return (double)(a + b) + 0.5 + strlen(x);
+}
+
+double double_fn(double x, double y, double z) {
+    return (x + y) * z * 3;
+}
+
+double double_many(double x, double y, double z, double w, double a, double b) {
+    return x + y + z + w + a + b;
+}
+
+double double_lots(
+    double a,
+    double b,
+    double c,
+    double d,
+    double e,
+    double f,
+    double g,
+    double h,
+    double i,
+    double j) {
+    return i + j;
+}
+
+double float_fn(float x, float y, float z) {
+    return (x + y) * z;
+}
+
+typedef struct {
+    int a;
+    int b;
+} intint;
+
+typedef struct {
+    int a;
+    int b;
+    int c;
+} intintint;
+
+int intint_fn(double x, intint ii) {
+    printf("double: %g\n", x);
+    return ii.a + ii.b;
+}
+
+int intintint_fn(double x, intintint iii) {
+    printf("double: %g\n", x);
+    return iii.a + iii.b + iii.c;
+}
+
+intint return_struct(int i) {
+    intint ret;
+    ret.a = i;
+    ret.b = i * i;
+    return ret;
+}
+
+typedef struct {
+    int64_t a;
+    int64_t b;
+    int64_t c;
+} big;
+
+big struct_big(int i, double d) {
+    big ret;
+    ret.a = i;
+    ret.b = (int64_t) d;
+    ret.c = ret.a + ret.b + 1000;
+    return ret;
+}
+
+void void_fn(void) {
+    printf("void fn ran\n");
+}
+
+void void_ret_fn(int x) {
+    printf("void fn ran: %d\n", x);
+}

examples/ffi/test.janet

@@ -0,0 +1,132 @@
+#
+# Simple FFI test script that tests against a simple shared object
+#
+
+(def ffi/loc "examples/ffi/so.so")
+(def ffi/source-loc "examples/ffi/so.c")
+
+(os/execute ["cc" ffi/source-loc "-shared" "-o" ffi/loc] :px)
+(def module (ffi/native ffi/loc))
+
+(def int-fn-sig (ffi/signature :default :int :int :int))
+(def int-fn-pointer (ffi/lookup module "int_fn"))
+(defn int-fn
+  [x y]
+  (ffi/call int-fn-pointer int-fn-sig x y))
+
+(def double-fn-sig (ffi/signature :default :double :double :double :double))
+(def double-fn-pointer (ffi/lookup module "double_fn"))
+(defn double-fn
+  [x y z]
+  (ffi/call double-fn-pointer double-fn-sig x y z))
+
+(def double-many-sig (ffi/signature :default :double :double :double :double :double :double :double))
+(def double-many-pointer (ffi/lookup module "double_many"))
+(defn double-many
+  [x y z w a b]
+  (ffi/call double-many-pointer double-many-sig x y z w a b))
+
+(def double-lots-sig (ffi/signature :default :double
+                                    :double :double :double :double :double
+                                    :double :double :double :double :double))
+(def double-lots-pointer (ffi/lookup module "double_lots"))
+(defn double-lots
+  [a b c d e f g h i j]
+  (ffi/call double-lots-pointer double-lots-sig a b c d e f g h i j))
+
+(def float-fn-sig (ffi/signature :default :double :float :float :float))
+(def float-fn-pointer (ffi/lookup module "float_fn"))
+(defn float-fn
+  [x y z]
+  (ffi/call float-fn-pointer float-fn-sig x y z))
+
+(def intint-fn-sig (ffi/signature :default :int :double [:int :int]))
+(def intint-fn-pointer (ffi/lookup module "intint_fn"))
+(defn intint-fn
+  [x ii]
+  (ffi/call intint-fn-pointer intint-fn-sig x ii))
+
+(def return-struct-sig (ffi/signature :default [:int :int] :int))
+(def return-struct-pointer (ffi/lookup module "return_struct"))
+(defn return-struct-fn
+  [i]
+  (ffi/call return-struct-pointer return-struct-sig i))
+
+(def intintint (ffi/struct :int :int :int))
+(def intintint-fn-sig (ffi/signature :default :int :double intintint))
+(def intintint-fn-pointer (ffi/lookup module "intintint_fn"))
+(defn intintint-fn
+  [x iii]
+  (ffi/call intintint-fn-pointer intintint-fn-sig x iii))
+
+(def big (ffi/struct :s64 :s64 :s64))
+(def struct-big-fn-sig (ffi/signature :default big :int :double))
+(def struct-big-fn-pointer (ffi/lookup module "struct_big"))
+(defn struct-big-fn
+  [i d]
+  (ffi/call struct-big-fn-pointer struct-big-fn-sig i d))
+
+(def void-fn-pointer (ffi/lookup module "void_fn"))
+(def void-fn-sig (ffi/signature :default :void))
+(defn void-fn
+  []
+  (ffi/call void-fn-pointer void-fn-sig))
+
+#
+# Call functions
+#
+
+(pp (void-fn))
+(pp (int-fn 10 20))
+(pp (double-fn 1.5 2.5 3.5))
+(pp (double-many 1 2 3 4 5 6))
+(pp (double-lots 1 2 3 4 5 6 7 8 9 10))
+(pp (float-fn 8 4 17))
+(pp (intint-fn 123.456 [10 20]))
+(pp (intintint-fn 123.456 [10 20 30]))
+(pp (return-struct-fn 42))
+(pp (struct-big-fn 11 99.5))
+
+(assert (= 60 (int-fn 10 20)))
+(assert (= 42 (double-fn 1.5 2.5 3.5)))
+(assert (= 21 (double-many 1 2 3 4 5 6)))
+(assert (= 19 (double-lots 1 2 3 4 5 6 7 8 9 10)))
+(assert (= 204 (float-fn 8 4 17)))
+
+#
+# Struct reading and writing
+#
+
+(defn check-round-trip
+  [t value]
+  (def buf (ffi/write t value))
+  (def same-value (ffi/read t buf))
+  (assert (deep= value same-value)
+          (string/format "round trip %j (got %j)" value same-value)))
+
+(check-round-trip :bool true)
+(check-round-trip :bool false)
+(check-round-trip :void nil)
+(check-round-trip :void nil)
+(check-round-trip :s8 10)
+(check-round-trip :s8 0)
+(check-round-trip :s8 -10)
+(check-round-trip :u8 10)
+(check-round-trip :u8 0)
+(check-round-trip :s16 10)
+(check-round-trip :s16 0)
+(check-round-trip :s16 -12312)
+(check-round-trip :u16 10)
+(check-round-trip :u16 0)
+(check-round-trip :u32 0)
+(check-round-trip :u32 10)
+(check-round-trip :u32 0xFFFF7777)
+(check-round-trip :s32 0x7FFF7777)
+(check-round-trip :s32 0)
+(check-round-trip :s32 -1234567)
+
+(def s (ffi/struct :s8 :s8 :s8 :float))
+(check-round-trip s [1 3 5 123.5])
+(check-round-trip s [-1 -3 -5 -123.5])
+
+(print "Done.")

examples/iterate-fiber.janet

@@ -0,0 +1,19 @@
+(def f
+  (coro
+    (for i 0 10
+      (yield (string "yield " i))
+      (os/sleep 0))))
+
+(print "simple yielding")
+(each item f (print "got: " item ", now " (fiber/status f)))
+
+(def f
+  (coro
+    (for i 0 10
+      (yield (string "yield " i))
+      (ev/sleep 0))))
+
+(print "complex yielding")
+(each item f (print "got: " item ", now " (fiber/status f)))
+
+(print (fiber/status f))

examples/life.janet

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

examples/maxtriangle.janet

@@ -2,10 +2,8 @@
 # of the triangle to the leaves of the triangle.
 
 (defn myfold [xs ys]
-  (let [xs1 (tuple/prepend xs 0)
-        xs2 (tuple/append xs 0)
-        m1 (map + xs1 ys)
-        m2 (map + xs2 ys)]
+  (let [m1 (map + [;xs 0] ys)
+        m2 (map + [0 ;xs] ys)]
     (map max m1 m2)))
 
 (defn maxpath [t]

examples/numarray/.gitignore

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

examples/numarray/numarray.c

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

examples/numarray/project.janet

@@ -0,0 +1,7 @@
+(declare-project
+  :name "numarray"
+  :description "Example c lib with abstract type")
+
+(declare-native
+  :name "numarray"
+  :source @["numarray.c"])

examples/numarray/test/numarray_tests.janet

@@ -0,0 +1,17 @@
+(import /build/numarray)
+
+(def a (numarray/new 30))
+(print (get a 20))
+(print (a 20))
+
+(put a 5 3.14)
+(print (a 5))
+(set (a 5) 100)
+(print (a 5))
+
+# (numarray/scale a 5))
+# ((a :scale) a 5)
+(:scale a 5)
+(for i 0 10 (print (a i)))
+
+(print "sum=" (:sum a))

examples/primes.janet

@@ -13,4 +13,4 @@
     (if isprime? (array/push list i)))
   list)
 
-(print (string/pretty (primes 100)))
+(pp (primes 100))

examples/rtest.janet

@@ -0,0 +1,11 @@
+# How random is the RNG really?
+
+(def counts (seq [_ :range [0 100]] 0))
+
+(for i 0 1000000
+  (let [x (math/random)
+        intrange (math/floor (* 100 x))
+        oldcount (counts intrange)]
+    (put counts intrange (if oldcount (+ 1 oldcount) 1))))
+
+(pp counts)

examples/select.janet

@@ -0,0 +1,23 @@
+(def channels
+  (seq [:repeat 5] (ev/chan 4)))
+
+(defn writer [c]
+  (for i 0 3
+    (def item (string i ":" (mod (hash c) 999)))
+    (ev/sleep 0.1)
+    (print "writer giving item " item " to " c "...")
+    (ev/give c item))
+  (print "Done!"))
+
+(defn reader [name]
+  (forever
+    (def [_ c x] (ev/rselect ;channels))
+    (print "reader " name " got " x " from " c)))
+
+# Readers
+(each letter [:a :b :c :d :e :f :g]
+  (ev/call reader letter))
+
+# Writers
+(each c channels
+  (ev/call writer c))

examples/select2.janet

@@ -0,0 +1,37 @@
+###
+### examples/select2.janet
+###
+### Mix reads and writes in select.
+###
+
+(def c1 (ev/chan 40))
+(def c2 (ev/chan 40))
+(def c3 (ev/chan 40))
+(def c4 (ev/chan 40))
+
+(def c5 (ev/chan 4))
+
+(defn worker
+  [c n x]
+  (forever
+    (ev/sleep n)
+    (ev/give c x)))
+
+(defn writer-worker
+  [c]
+  (forever
+    (ev/sleep 0.2)
+    (print "writing " (ev/take c))))
+
+(ev/call worker c1 1 :item1)
+(ev/sleep 0.2)
+(ev/call worker c2 1 :item2)
+(ev/sleep 0.1)
+(ev/call worker c3 1 :item3)
+(ev/sleep 0.2)
+(ev/call worker c4 1 :item4)
+(ev/sleep 0.1)
+(ev/call worker c4 1 :item5)
+(ev/call writer-worker c5)
+
+(forever (pp (ev/rselect c1 c2 c3 c4 [c5 :thing])))

examples/tcpclient.janet

@@ -0,0 +1,6 @@
+(with [conn (net/connect "127.0.0.1" "8000")]
+  (printf "Connected to %q!" conn)
+  (:write conn "Echo...")
+  (print "Wrote to connection...")
+  (def res (:read conn 1024))
+  (pp res))

examples/tcpserver.janet

@@ -0,0 +1,20 @@
+(defn handler
+  "Simple handler for connections."
+  [stream]
+  (defer (:close stream)
+    (def id (gensym))
+    (def b @"")
+    (print "Connection " id "!")
+    (while (:read stream 1024 b)
+      (repeat 10 (print "work for " id " ...") (ev/sleep 0.1))
+      (:write stream b)
+      (buffer/clear b))
+    (printf "Done %v!" id)))
+
+# Run server.
+(let [server (net/server "127.0.0.1" "8000")]
+  (print "Starting echo server on 127.0.0.1:8000")
+  (forever
+    (if-let [conn (:accept server)]
+      (ev/call handler conn)
+      (print "no new connections"))))

examples/threaded-channels.janet

@@ -0,0 +1,22 @@
+(def chan (ev/thread-chan 10))
+
+(ev/spawn
+  (ev/sleep 0)
+  (print "started fiber!")
+  (ev/give chan (math/random))
+  (ev/give chan (math/random))
+  (ev/give chan (math/random))
+  (ev/sleep 0.5)
+  (for i 0 10
+    (print "giving to channel...")
+    (ev/give chan (math/random))
+    (ev/sleep 1))
+  (print "finished fiber!")
+  (:close chan))
+
+(ev/do-thread
+  (print "started thread!")
+  (ev/sleep 1)
+  (while (def x (do (print "taking from channel...") (ev/take chan)))
+    (print "got " x " from thread!"))
+  (print "finished thread!"))

examples/udpclient.janet

@@ -0,0 +1,5 @@
+(def conn (net/connect "127.0.0.1" "8009" :datagram))
+(:write conn (string/format "%q" (os/cryptorand 16)))
+(def x (:read conn 1024))
+(pp x)
+

examples/udpserver.janet

@@ -0,0 +1,6 @@
+(def server (net/listen "127.0.0.1" "8009" :datagram))
+(while true
+  (def buf @"")
+  (def who (:recv-from server 1024 buf))
+  (printf "got %q from %v, echoing!" buf who)
+  (:send-to server who buf))

examples/urlloader.janet

@@ -0,0 +1,29 @@
+# An example of using Janet's extensible module system to import files from
+# URL. To try this, run `janet -l ./examples/urlloader.janet` from the command
+# line, and then at the REPL type:
+#
+# (import https://raw.githubusercontent.com/janet-lang/janet/master/examples/colors.janet :as c)
+#
+# This will import a file using curl. You can then try:
+#
+# (print (c/color :green "Hello!"))
+#
+# This is a bit of a toy example (it just shells out to curl), but it is very
+# powerful and will work well in many cases.
+
+(defn- load-url
+  [url args]
+  (def p (os/spawn ["curl" url "-s"] :p {:out :pipe}))
+  (def res (dofile (p :out) :source url ;args))
+  (:wait p)
+  res)
+
+(defn- check-http-url
+  [path]
+  (if (or (string/has-prefix? "http://" path)
+          (string/has-prefix? "https://" path))
+    path))
+
+# Add the module loader and path tuple to right places
+(array/push module/paths [check-http-url :janet-http])
+(put module/loaders :janet-http load-url)

grammar/janet.tmLanguage

@@ -1,335 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>fileTypes</key>
-	<array>
-		<string>janet</string>
-	</array>
-	<key>foldingStartMarker</key>
-	<string>\{</string>
-	<key>foldingStopMarker</key>
-	<string>\}</string>
-	<key>foldingStartMarker</key>
-	<string>\[</string>
-	<key>foldingStopMarker</key>
-	<string>\]</string>
-	<key>foldingStartMarker</key>
-	<string>\(</string>
-	<key>foldingStopMarker</key>
-	<string>\)</string>
-	<key>keyEquivalent</key>
-	<string>^~L</string>
-	<key>name</key>
-	<string>Janet</string>
-	<key>patterns</key>
-	<array>
-		<dict>
-			<key>include</key>
-			<string>#all</string>
-		</dict>
-    </array>
-	<key>repository</key>
-	<dict>
-		<key>all</key>
-		<dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#comment</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#parens</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#brackets</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#braces</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#readermac</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#string</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#longstring</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#literal</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#corelib</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#r-number</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#dec-number</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#hex-number</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#keysym</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#symbol</string>
-				</dict>
-			</array>
-		</dict>
-		<key>comment</key>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.comment.janet</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>(#).*$</string>
-			<key>name</key>
-			<string>comment.line.janet</string>
-		</dict>
-		<key>braces</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?{)</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.braces.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(})</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.braces.end.janet</string>
-				</dict>
-			</dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#all</string>
-				</dict>
-			</array>
-		</dict>
-		<key>brackets</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?\[)</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.brackets.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(\])</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.brackets.end.janet</string>
-				</dict>
-			</dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#all</string>
-				</dict>
-			</array>
-		</dict>
-		<key>parens</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?\()</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.parens.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(\))</string>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.parens.end.janet</string>
-				</dict>
-			</dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#all</string>
-				</dict>
-			</array>
-		</dict>
-		<key>readermac</key>
-		<dict>
-			<key>match</key>
-			<string>[\'\~\;\,]</string>
-			<key>name</key>
-			<string>punctuation.other.janet</string>
-		</dict>
-		<!-- string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]) token match here (?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string -->
-		<key>literal</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])(true|false|nil)(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>constant.language.janet</string>
-		</dict>
-		<key>corelib</key>
-		<dict>
-			<key>match</key>
-            <string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])(%|%=|\*|\*=|\*doc\-width\*|\*env\*|\+|\+\+|\+=|\-|\-\-|\-=|\-&gt;|\-&gt;&gt;|\-\?&gt;|\-\?&gt;&gt;|&#47;|&#47;=|&lt;|&lt;=|=|==|&gt;|&gt;=|_env|abstract\?|all|all\-symbols|allsyms|and|apply|array|array&#47;concat|array&#47;ensure|array&#47;insert|array&#47;new|array&#47;peek|array&#47;pop|array&#47;push|array&#47;slice|array\?|as\-&gt;|as\?\-&gt;|asm|band|blshift|bnot|boolean\?|bor|brshift|brushift|buffer|buffer&#47;clear|buffer&#47;new|buffer&#47;popn|buffer&#47;push\-byte|buffer&#47;push\-string|buffer&#47;push\-word|buffer&#47;slice|buffer\?|bxor|bytes\?|callable\?|case|cfunction\?|comment|comp|compile|complement|cond|coro|count|debug|debug&#47;arg\-stack|debug&#47;break|debug&#47;fbreak|debug&#47;lineage|debug&#47;stack|debug&#47;unbreak|debug&#47;unfbreak|dec|deep\-not=|deep=|def\-|default|defglobal|defmacro|defmacro\-|defn|defn\-|describe|dictionary\?|disasm|distinct|doc|doc\*|doc\-format|drop\-until|drop\-while|each|empty\?|env\-lookup|error|eval|eval\-string|even\?|every\?|extreme|false\?|fiber&#47;current|fiber&#47;maxstack|fiber&#47;new|fiber&#47;setmaxstack|fiber&#47;status|fiber\?|file&#47;close|file&#47;flush|file&#47;open|file&#47;popen|file&#47;read|file&#47;seek|file&#47;write|filter|find|find\-index|first|flatten|flatten\-into|for|frequencies|function\?|gccollect|gcinterval|gcsetinterval|generate|gensym|get|getline|hash|idempotent\?|identity|if\-let|if\-not|import|import\*|inc|indexed\?|interleave|interpose|invert|janet&#47;build|janet&#47;version|juxt|juxt\*|keep|keys|keyword|keyword\?|kvs|last|length|let|loop|macex|macex1|make\-env|map|mapcat|marshal|match|match\-1|math&#47;acos|math&#47;asin|math&#47;atan|math&#47;ceil|math&#47;cos|math&#47;e|math&#47;exp|math&#47;floor|math&#47;inf|math&#47;log|math&#47;log10|math&#47;pi|math&#47;pow|math&#47;random|math&#47;seedrandom|math&#47;sin|math&#47;sqrt|math&#47;tan|max|max\-order|merge|merge\-into|min|min\-order|module&#47;find|module&#47;native\-paths|module&#47;paths|native|neg\?|next|nil\?|not|not=|not==|number\?|odd\?|one\?|or|order&lt;|order&lt;=|order&gt;|order&gt;=|os&#47;clock|os&#47;cwd|os&#47;execute|os&#47;exit|os&#47;getenv|os&#47;setenv|os&#47;shell|os&#47;sleep|os&#47;time|os&#47;which|pairs|parser&#47;byte|parser&#47;consume|parser&#47;error|parser&#47;flush|parser&#47;has\-more|parser&#47;new|parser&#47;produce|parser&#47;state|parser&#47;status|parser&#47;where|partial|pos\?|postwalk|prewalk|print|process&#47;args|product|put|range|reduce|repl|require|resume|reverse|run\-context|scan\-number|sentinel|seq|some|sort|sorted|status\-pp|stderr|stdin|stdout|string|string&#47;ascii\-lower|string&#47;ascii\-upper|string&#47;bytes|string&#47;check\-set|string&#47;find|string&#47;find\-all|string&#47;from\-bytes|string&#47;join|string&#47;number|string&#47;pretty|string&#47;repeat|string&#47;replace|string&#47;replace\-all|string&#47;reverse|string&#47;slice|string&#47;split|string\?|struct|struct\?|sum|symbol|symbol\?|table|table&#47;getproto|table&#47;new|table&#47;rawget|table&#47;setproto|table&#47;to\-struct|table\?|take\-until|take\-while|true\?|try|tuple|tuple&#47;append|tuple&#47;prepend|tuple&#47;slice|tuple\?|type|unless|unmarshal|update|values|varglobal|walk|when|when\-let|with\-idemp|yield|zero\?|zipcoll)(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>keyword.control.janet</string>
-		</dict>
-		<key>keysym</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]):[\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]*</string>
-			<key>name</key>
-			<string>constant.keyword.janet</string>
-		</dict>
-		<key>symbol</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[\.a-zA-Z_\-=!@\$%^&amp;?|\\/&lt;&gt;*][\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*]*</string>
-			<key>name</key>
-			<string>variable.other.janet</string>
-		</dict>
-		<key>hex-number</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?0x([_\da-fA-F]+|[_\da-fA-F]+\.[_\da-fA-F]*|\.[_\da-fA-F]+)(&amp;[+-]?[\da-fA-F]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>constant.numeric.hex.janet</string>
-		</dict>
-		<key>dec-number</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?([_\d]+|[_\d]+\.[_\d]*|\.[_\d]+)([eE&amp;][+-]?[\d]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>constant.numeric.decimal.janet</string>
-		</dict>
-		<key>r-number</key>
-		<dict>
-			<key>match</key>
-			<string>(?&lt;![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])[-+]?\d\d?r([_\w]+|[_\w]+\.[_\w]*|\.[_\w]+)(&amp;[+-]?[\w]+)?(?![\.:\w_\-=!@\$%^&amp;?|\\/&lt;&gt;*])</string>
-			<key>name</key>
-			<string>constant.numeric.decimal.janet</string>
-		</dict>
-		<key>string</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?")</string>
-			<key>beginCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(")</string>
-			<key>endCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.end.janet</string>
-				</dict>
-			</dict>
-			<key>name</key>
-			<string>string.quoted.double.janet</string>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>match</key>
-					<string>(\\[ne0zft"\\']|\\x[0-9a-fA-F][0-9a-fA-f])</string>
-					<key>name</key>
-					<string>constant.character.escape.janet</string>
-				</dict>
-			</array>
-		</dict>
-		<key>longstring</key>
-		<dict>
-			<key>begin</key>
-			<string>(@?)(`+)</string>
-			<key>beginCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.janet</string>
-				</dict>
-				<key>2</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.janet</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>\2</string>
-			<key>endCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.end.janet</string>
-				</dict>
-			</dict>
-			<key>name</key>
-			<string>string.quoted.triple.janet</string>
-		</dict>
-		<key>nomatch</key>
-		<dict>
-			<key>match</key>
-			<string>\S+</string>
-			<key>name</key>
-			<string>invalid.illegal.janet</string>
-		</dict>
-	</dict>
-    <key>scopeName</key>
-    <string>source.janet</string>
-    <key>uuid</key>
-    <string>3743190f-20c4-44d0-8640-6611a983296b</string>
-</dict>
-</plist>

janet-installer.nsi

@@ -1,55 +0,0 @@
-!define MULTIUSER_EXECUTIONLEVEL Highest
-!define MULTIUSER_MUI
-!define MULTIUSER_INSTALLMODE_COMMANDLINE
-!define MULTIUSER_INSTALLMODE_INSTDIR "janet"
-!include "MultiUser.nsh"
-!include "MUI2.nsh"
- 
-Name "Janet"
-OutFile "janet-install.exe"
- 
-!define MUI_ABORTWARNING
- 
-!insertmacro MUI_PAGE_WELCOME
-!insertmacro MUI_PAGE_LICENSE "LICENSE"
-!insertmacro MUI_PAGE_COMPONENTS
-!insertmacro MULTIUSER_PAGE_INSTALLMODE
-!insertmacro MUI_PAGE_DIRECTORY
-
-!insertmacro MUI_PAGE_INSTFILES
-
-!insertmacro MUI_PAGE_FINISH
-
-!insertmacro MUI_UNPAGE_CONFIRM
-!insertmacro MUI_UNPAGE_INSTFILES
- 
-!insertmacro MUI_LANGUAGE "English"
- 
-Section "Janet" BfWSection
-  SetOutPath $INSTDIR
-  File "janet.exe"
-  WriteUninstaller "$INSTDIR\janet-uninstall.exe"
-  
-  # Start Menu
-  CreateShortCut "$SMPROGRAMS\Janet.lnk" "$INSTDIR\janet.exe" "" ""
-SectionEnd
-
-Function .onInit
-  !insertmacro MULTIUSER_INIT
-  !insertmacro MUI_LANGDLL_DISPLAY
-FunctionEnd
-
-!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
-  !insertmacro MUI_DESCRIPTION_TEXT ${BfWSection} "The Janet programming language."
-!insertmacro MUI_FUNCTION_DESCRIPTION_END
- 
-Section "Uninstall"
-  Delete "$INSTDIR\janet.exe"
-  Delete "$INSTDIR\janet-uninstall.exe"
-  RMDir "$INSTDIR"
-SectionEnd
- 
-Function un.onInit
-  !insertmacro MULTIUSER_UNINIT
-  !insertmacro MUI_UNGETLANGUAGE
-FunctionEnd

janet.1

@@ -1,26 +1,145 @@
 .TH JANET 1
 .SH NAME
-janet \- run the janet language abstract machine
+janet \- run the Janet language abstract machine
 .SH SYNOPSIS
 .B janet
-[\fB\-hvsrp\fR]
-[\fB\-e\fR \fIJANET SOURCE\fR]
+[\fB\-hvsrpnqik\fR]
+[\fB\-e\fR \fISOURCE\fR]
+[\fB\-E\fR \fISOURCE ...ARGUMENTS\fR]
+[\fB\-l\fR \fIMODULE\fR]
+[\fB\-m\fR \fIPATH\fR]
+[\fB\-c\fR \fIMODULE JIMAGE\fR]
+[\fB\-w\fR \fILEVEL\fR]
+[\fB\-x\fR \fILEVEL\fR]
 [\fB\-\-\fR]
-.IR files ...
+.BR script
+.BR args ...
 .SH DESCRIPTION
 Janet is a functional and imperative programming language and bytecode interpreter.
-It is a modern lisp, but lists are replaced by other data structures with better utility
-and performance (arrays, tables, structs, tuples). The language also bridging bridging
+It is a Lisp-like language, but lists are replaced by other data structures
+(arrays, tables, structs, tuples). The language also features bridging
 to native code written in C, meta-programming with macros, and bytecode assembly.
 
 There is a repl for trying out the language, as well as the ability to run script files.
-This client program is separate from the core runtime, so janet could be embedded
-into other programs. Try janet in your browser at https://janet-lang.org.
+This client program is separate from the core runtime, so Janet could be embedded
+into other programs. Try Janet in your browser at https://janet-lang.org.
 
-Implemented in mostly standard C99, janet runs on Windows, Linux and macOS.
+Implemented in mostly standard C99, Janet runs on Windows, Linux and macOS.
 The few features that are not standard C99 (dynamic library loading, compiler
 specific optimizations), are fairly straight forward. Janet can be easily ported to
 most new platforms.
+
+.SH REPL KEY-BINDINGS
+
+.TP 16
+.BR Home
+Move cursor to the beginning of input line.
+
+.TP 16
+.BR End
+Move cursor to the end of input line.
+
+.TP 16
+.BR Left/Right
+Move cursor in input line.
+
+.TP 16
+.BR Up/Down
+Go backwards and forwards through history.
+
+.TP 16
+.BR Tab
+Complete current symbol, or show available completions.
+
+.TP 16
+.BR Delete
+Delete one character after the cursor.
+
+.TP 16
+.BR Backspace
+Delete one character before the cursor.
+
+.TP 16
+.BR Ctrl\-A
+Move cursor to the beginning of input line.
+
+.TP 16
+.BR Ctrl\-B
+Move cursor one character to the left.
+
+.TP 16
+.BR Ctrl\-D
+If on a newline, indicate end of stream and exit the repl.
+
+.TP 16
+.BR Ctrl\-E
+Move cursor to the end of input line.
+
+.TP 16
+.BR Ctrl\-F
+Move cursor one character to the right.
+
+.TP 16
+.BR Ctrl\-H
+Delete one character before the cursor.
+
+.TP 16
+.BR Ctrl\-K
+Delete everything after the cursor on the input line.
+
+.TP 16
+.BR Ctrl\-L
+Clear the screen.
+
+.TP 16
+.BR Ctrl\-N/Ctrl\-P
+Go forwards and backwards through history.
+
+.TP 16
+.BR Ctrl\-U
+Delete everything before the cursor on the input line.
+
+.TP 16
+.BR Ctrl\-W
+Delete one word before the cursor.
+
+.TP 16
+.BR Ctrl\-G
+Show documentation for the current symbol under the cursor.
+
+.TP 16
+.BR Ctrl\-Q
+Clear the current command, including already typed lines.
+
+.TP 16
+.BR Alt\-B/Alt\-F
+Move cursor backwards and forwards one word.
+
+.TP 16
+.BR Alt\-D
+Delete one word after the cursor.
+
+.TP 16
+.BR Alt\-,
+Go to earliest item in history.
+
+.TP 16
+.BR Alt\-.
+Go to last item in history.
+
+.LP
+
+The repl keybindings are loosely based on a subset of GNU readline, although
+Janet does not use GNU readline internally for the repl. It is a limited
+substitute for GNU readline, and does not handle
+utf-8 input or other mutlibyte input well.
+
+To disable the built-in repl input handling, pass the \fB\-s\fR option to Janet, and
+use a program like rlwrap with Janet to provide input.
+
+For key bindings that operate on words, a word is considered to be a sequence
+of characters that does not contain whitespace.
+
 .SH DOCUMENTATION
 
 For more complete API documentation, run a REPL (Read Eval Print Loop), and use the doc macro to
@@ -37,37 +156,111 @@ Shows the version text and exits immediately.
 
 .TP
 .BR \-s
-Read raw input from stdin, such as from a pipe without printing a prompt.
+Read raw input from stdin and forgo prompt history and other readline-like features.
 
 .TP
-.BR \-r
-Open a REPL (Read Eval Print Loop) after executing all sources. By default, if janet is called with no
-arguments, a REPL is opened.
-
-.TP
-.BR \-p
-Turn on the persistent flag. By default, when janet is executing commands from a file and encounters an error,
-it will immediately exit after printing the error message. In persistent mode, janet will keep executing commands
-after an error. Persistent mode can be good for debugging and testing.
-
-.TP
-.BR \-e
-Execute a string of janet source. Source code is executed in the order it is encountered, so earlier
+.BR \-e\ code
+Execute a string of Janet source. Source code is executed in the order it is encountered, so earlier
 arguments are executed before later ones.
 
+.TP
+.BR \-E\ code arguments
+Execute a single Janet expression as a Janet short-fn, passing the remaining command line arguments to the expression. This allows
+more concise one-liners with command line arguments.
+
+.TP
+.BR \-d
+Enable debug mode. On all terminating signals as well the debug signal, this will
+cause the debugger to come up in the REPL. Same as calling (setdyn :debug true) in a
+default repl.
+
+.TP
+.BR \-n
+Disable ANSI colors in the repl. Has no effect if no repl is run.
+
+.TP
+.BR \-r
+Open a REPL (Read Eval Print Loop) after executing all sources. By default, if Janet is called with no
+arguments, a REPL is opened.
+
+.TP
+.BR \-R
+If using the REPL, disable loading the user profile from the JANET_PROFILE environment variable.
+
+.TP
+.BR \-p
+Turn on the persistent flag. By default, when Janet is executing commands from a file and encounters an error,
+it will immediately exit after printing the error message. In persistent mode, Janet will keep executing commands
+after an error. Persistent mode can be good for debugging and testing.
+
+.TP
+.BR \-q
+Hide the logo in the repl.
+
+.TP
+.BR \-k
+Don't execute a script, only compile it to check for errors. Useful for linting scripts.
+
+.TP
+.BR \-m\ syspath
+Set the dynamic binding :syspath to the string syspath so that Janet will load system modules
+from a directory different than the default. The default is set when Janet is built, and defaults to
+/usr/local/lib/janet on Linux/Posix, and C:/Janet/Library on Windows. This option supersedes JANET_PATH.
+
+.TP
+.BR \-c\ source\ output
+Precompiles Janet source code into an image, a binary dump that can be efficiently loaded later.
+Source should be a path to the Janet module to compile, and output should be the file path of
+resulting image. Output should usually end with the .jimage extension.
+
+.TP
+.BR \-i
+When this flag is passed, a script passed to the interpreter will be treated as a janet image file
+rather than a janet source file.
+
+.TP
+.BR \-l\ lib
+Import a Janet module before running a script or repl. Multiple files can be loaded
+in this manner, and exports from each file will be made available to the script
+or repl.
+.TP
+.BR \-w\ level
+Set the warning linting level for Janet.
+This linting level should be one of :relaxed, :none, :strict, :normal, or a
+Janet number. Any linting message that is of a greater lint level than this setting will be displayed as
+a warning, but not stop compilation or execution.
+.TP
+.BR \-x\ level
+Set the error linting level for Janet.
+This linting level should be one of :relaxed, :none, :strict, :normal, or a
+Janet number. Any linting message that is of a greater lint level will cause a compilation error
+and stop compilation.
 .TP
 .BR \-\-
-Stop parsing command line arguments. All arguments after this one will be considered file names.
+Stop parsing command line arguments. All arguments after this one will be considered file names
+and then arguments to the script.
 
 .SH ENVIRONMENT
 
 .B JANET_PATH
 .RS
-The location to look for janet libraries. This is the only environment variable janet needs to
-find native and source code modules. If no JANET_PATH is set, janet will look in
-/usr/local/lib/janet for modules.
-To make janet search multiple locations, modify the module.paths
-array in janet.
+The location to look for Janet libraries. This is the only environment variable Janet needs to
+find native and source code modules. If no JANET_PATH is set, Janet will look in
+the default location set at compile time.
+.RE
+
+.B JANET_PROFILE
+.RS
+Path to a profile file that the interpreter will load before entering the REPL. This profile file will
+not run for scripts, though. This behavior can be disabled with the -R option.
+.RE
+
+.B JANET_HASHSEED
+.RS
+To disable randomization of Janet's PRF on start up, one can set this variable. This can have the
+effect of making programs deterministic that otherwise would depend on the random seed chosen at program start.
+This variable does nothing in the default configuration of Janet, as PRF is disabled by default. Also, JANET_REDUCED_OS
+cannot be defined for this variable to have an effect.
 .RE
 
 .SH AUTHOR

janet_win.rc

@@ -0,0 +1 @@
+IDI_MYICON ICON "assets\icon.ico"

meson.build

@@ -0,0 +1,273 @@
+# Copyright (c) 2021 Calvin Rose and contributors
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+project('janet', 'c',
+  default_options : ['c_std=c99', 'build.c_std=c99', 'b_lundef=false', 'default_library=both'],
+  version : '1.23.1')
+
+# Global settings
+janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
+header_path = join_paths(get_option('prefix'), get_option('includedir'), 'janet')
+
+# Link math library on all systems
+cc = meson.get_compiler('c')
+m_dep = cc.find_library('m', required : false)
+dl_dep = cc.find_library('dl', required : false)
+android_spawn_dep = cc.find_library('android-spawn', required : false)
+thread_dep = dependency('threads')
+
+# Link options
+if get_option('default_library') != 'static' and build_machine.system() != 'windows'
+    add_project_link_arguments('-rdynamic', language : 'c')
+endif
+
+# Generate custom janetconf.h
+conf = configuration_data()
+version_parts = meson.project_version().split('.')
+last_parts = version_parts[2].split('-')
+if last_parts.length() > 1
+  conf.set_quoted('JANET_VERSION_EXTRA', '-' + last_parts[1])
+else
+  conf.set_quoted('JANET_VERSION_EXTRA', '')
+endif
+conf.set('JANET_VERSION_MAJOR', version_parts[0].to_int())
+conf.set('JANET_VERSION_MINOR', version_parts[1].to_int())
+conf.set('JANET_VERSION_PATCH', last_parts[0].to_int())
+conf.set_quoted('JANET_VERSION', meson.project_version())
+# Use options
+conf.set_quoted('JANET_BUILD', get_option('git_hash'))
+conf.set('JANET_NO_NANBOX', not get_option('nanbox'))
+conf.set('JANET_SINGLE_THREADED', get_option('single_threaded'))
+conf.set('JANET_NO_DYNAMIC_MODULES', not get_option('dynamic_modules'))
+conf.set('JANET_NO_DOCSTRINGS', not get_option('docstrings'))
+conf.set('JANET_NO_SOURCEMAPS', not get_option('sourcemaps'))
+conf.set('JANET_NO_ASSEMBLER', not get_option('assembler'))
+conf.set('JANET_NO_PEG', not get_option('peg'))
+conf.set('JANET_NO_NET', not get_option('net'))
+conf.set('JANET_NO_EV', not get_option('ev') or get_option('single_threaded'))
+conf.set('JANET_REDUCED_OS', get_option('reduced_os'))
+conf.set('JANET_NO_INT_TYPES', not get_option('int_types'))
+conf.set('JANET_PRF', get_option('prf'))
+conf.set('JANET_RECURSION_GUARD', get_option('recursion_guard'))
+conf.set('JANET_MAX_PROTO_DEPTH', get_option('max_proto_depth'))
+conf.set('JANET_MAX_MACRO_EXPAND', get_option('max_macro_expand'))
+conf.set('JANET_STACK_MAX', get_option('stack_max'))
+conf.set('JANET_NO_UMASK', not get_option('umask'))
+conf.set('JANET_NO_REALPATH', not get_option('realpath'))
+conf.set('JANET_NO_PROCESSES', not get_option('processes'))
+conf.set('JANET_SIMPLE_GETLINE', get_option('simple_getline'))
+conf.set('JANET_EV_NO_EPOLL', not get_option('epoll'))
+conf.set('JANET_EV_NO_KQUEUE', not get_option('kqueue'))
+conf.set('JANET_NO_INTERPRETER_INTERRUPT', not get_option('interpreter_interrupt'))
+conf.set('JANET_NO_FFI', not get_option('ffi'))
+if get_option('os_name') != ''
+  conf.set('JANET_OS_NAME', get_option('os_name'))
+endif
+if get_option('arch_name') != ''
+  conf.set('JANET_ARCH_NAME', get_option('arch_name'))
+endif
+jconf = configure_file(output : 'janetconf.h',
+  configuration : conf)
+
+# Include directories
+incdir = include_directories(['src/include', '.'])
+
+# Order is important here, as some headers
+# depend on other headers for the amalg target
+core_headers = [
+  'src/core/features.h',
+  'src/core/util.h',
+  'src/core/state.h',
+  'src/core/gc.h',
+  'src/core/vector.h',
+  'src/core/fiber.h',
+  'src/core/regalloc.h',
+  'src/core/compile.h',
+  'src/core/emit.h',
+  'src/core/symcache.h'
+]
+
+core_src = [
+  'src/core/abstract.c',
+  'src/core/array.c',
+  'src/core/asm.c',
+  'src/core/buffer.c',
+  'src/core/bytecode.c',
+  'src/core/capi.c',
+  'src/core/cfuns.c',
+  'src/core/compile.c',
+  'src/core/corelib.c',
+  'src/core/debug.c',
+  'src/core/emit.c',
+  'src/core/ev.c',
+  'src/core/ffi.c',
+  'src/core/fiber.c',
+  'src/core/gc.c',
+  'src/core/inttypes.c',
+  'src/core/io.c',
+  'src/core/marsh.c',
+  'src/core/math.c',
+  'src/core/net.c',
+  'src/core/os.c',
+  'src/core/parse.c',
+  'src/core/peg.c',
+  'src/core/pp.c',
+  'src/core/regalloc.c',
+  'src/core/run.c',
+  'src/core/specials.c',
+  'src/core/state.c',
+  'src/core/string.c',
+  'src/core/strtod.c',
+  'src/core/struct.c',
+  'src/core/symcache.c',
+  'src/core/table.c',
+  'src/core/tuple.c',
+  'src/core/util.c',
+  'src/core/value.c',
+  'src/core/vector.c',
+  'src/core/vm.c',
+  'src/core/wrap.c'
+]
+
+boot_src = [
+  'src/boot/array_test.c',
+  'src/boot/boot.c',
+  'src/boot/buffer_test.c',
+  'src/boot/number_test.c',
+  'src/boot/system_test.c',
+  'src/boot/table_test.c',
+]
+
+mainclient_src = [
+  'src/mainclient/shell.c'
+]
+
+# Build boot binary
+janet_boot = executable('janet-boot', core_src, boot_src,
+  include_directories : incdir,
+  c_args : '-DJANET_BOOTSTRAP',
+  dependencies : [m_dep, dl_dep, thread_dep, android_spawn_dep],
+  native : true)
+
+# Build janet.c
+janetc = custom_target('janetc',
+  input : [janet_boot],
+  output : 'janet.c',
+  capture : true,
+  command : [
+    janet_boot, meson.current_source_dir(),
+    'JANET_PATH', janet_path
+  ])
+
+janet_dependencies = [m_dep, dl_dep, android_spawn_dep]
+if not get_option('single_threaded')
+  janet_dependencies += thread_dep
+endif
+
+libjanet = library('janet', janetc,
+  include_directories : incdir,
+  dependencies : janet_dependencies,
+  version: meson.project_version(),
+  soversion: version_parts[0] + '.' + version_parts[1],
+  install : true)
+
+# Extra c flags - adding -fvisibility=hidden matches the Makefile and
+# shaves off about 10k on linux x64, likely similar on other platforms.
+if cc.has_argument('-fvisibility=hidden')
+  extra_cflags = ['-fvisibility=hidden']
+else
+  extra_cflags = []
+endif
+janet_mainclient = executable('janet', janetc, mainclient_src,
+  include_directories : incdir,
+  dependencies : janet_dependencies,
+  c_args : extra_cflags,
+  install : true)
+
+if meson.is_cross_build()
+  native_cc = meson.get_compiler('c', native: true)
+  if native_cc.has_argument('-fvisibility=hidden')
+    extra_native_cflags = ['-fvisibility=hidden']
+  else
+    extra_native_cflags = []
+  endif
+  janet_nativeclient = executable('janet-native', janetc, mainclient_src,
+    include_directories : incdir,
+    dependencies : janet_dependencies,
+    c_args : extra_native_cflags,
+    native : true)
+else
+  janet_nativeclient = janet_mainclient
+endif
+
+# Documentation
+docs = custom_target('docs',
+  input : ['tools/gendoc.janet'],
+  output : ['doc.html'],
+  capture : true,
+  command : [janet_nativeclient, '@INPUT@'])
+
+# Tests
+test_files = [
+  'test/suite0000.janet',
+  'test/suite0001.janet',
+  'test/suite0002.janet',
+  'test/suite0003.janet',
+  'test/suite0004.janet',
+  'test/suite0005.janet',
+  'test/suite0006.janet',
+  'test/suite0007.janet',
+  'test/suite0008.janet',
+  'test/suite0009.janet',
+  'test/suite0010.janet'
+]
+foreach t : test_files
+  test(t, janet_nativeclient, args : files([t]), workdir : meson.current_source_dir())
+endforeach
+
+# Repl
+run_target('repl', command : [janet_nativeclient])
+
+# For use as meson subproject (wrap)
+janet_dep = declare_dependency(include_directories : incdir,
+  link_with : libjanet)
+
+# pkgconfig
+pkg = import('pkgconfig')
+pkg.generate(libjanet,
+  subdirs: 'janet',
+  description: 'Library for the Janet programming language.')
+
+# Installation
+install_man('janet.1')
+install_data(sources : ['tools/.keep'], install_dir : join_paths(get_option('libdir'), 'janet'))
+patched_janet = custom_target('patched-janeth',
+  input : ['tools/patch-header.janet', 'src/include/janet.h', jconf],
+  install : true,
+  install_dir : join_paths(get_option('includedir'), 'janet'),
+  build_by_default : true,
+  output : ['janet.h'],
+  command : [janet_nativeclient, '@INPUT@', '@OUTPUT@'])
+
+# Create a version of the janet.h header that matches what jpm often expects
+if meson.version().version_compare('>=0.61')
+  install_symlink('janet.h', pointing_to: 'janet/janet.h', install_dir: get_option('includedir'))
+endif
+

meson_options.txt

@@ -0,0 +1,30 @@
+option('git_hash', type : 'string', value : 'meson')
+
+option('single_threaded', type : 'boolean', value : false)
+option('nanbox', type : 'boolean', value : true)
+option('dynamic_modules', type : 'boolean', value : true)
+option('docstrings', type : 'boolean', value : true)
+option('sourcemaps', type : 'boolean', value : true)
+option('reduced_os', type : 'boolean', value : false)
+option('assembler', type : 'boolean', value : true)
+option('peg', type : 'boolean', value : true)
+option('int_types', type : 'boolean', value : true)
+option('prf', type : 'boolean', value : false)
+option('net', type : 'boolean', value : true)
+option('ev', type : 'boolean', value : true)
+option('processes', type : 'boolean', value : true)
+option('umask', type : 'boolean', value : true)
+option('realpath', type : 'boolean', value : true)
+option('simple_getline', type : 'boolean', value : false)
+option('epoll', type : 'boolean', value : false)
+option('kqueue', type : 'boolean', value : false)
+option('interpreter_interrupt', type : 'boolean', value : false)
+option('ffi', type : 'boolean', value : true)
+
+option('recursion_guard', type : 'integer', min : 10, max : 8000, value : 1024)
+option('max_proto_depth', type : 'integer', min : 10, max : 8000, value : 200)
+option('max_macro_expand', type : 'integer', min : 1, max : 8000, value : 200)
+option('stack_max', type : 'integer', min : 8096, max : 0x7fffffff, value : 0x7fffffff)
+
+option('arch_name', type : 'string', value: '')
+option('os_name', type : 'string', value: '')

src/boot/array_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,16 +20,16 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <assert.h>
 
-int main() {
+#include "tests.h"
+
+int array_test() {
 
     int i;
     JanetArray *array1, *array2;
 
-    janet_init();
-
     array1 = janet_array(10);
     array2 = janet_array(0);
 
@@ -62,7 +62,5 @@ int main() {
 
     assert(array1->count == 5);
 
-    janet_deinit();
-
     return 0;
 }

src/boot/boot.c

@@ -0,0 +1,114 @@
+/*
+* Copyright (c) 2022 Calvin Rose
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to
+* 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.
+*/
+
+#include <janet.h>
+#include "tests.h"
+
+#ifdef JANET_WINDOWS
+#include <direct.h>
+#define chdir(x) _chdir(x)
+#else
+#include <unistd.h>
+#endif
+
+extern const unsigned char *janet_gen_boot;
+extern int32_t janet_gen_boot_size;
+
+int main(int argc, const char **argv) {
+
+    /* Init janet */
+    janet_init();
+
+    /* Run tests */
+    array_test();
+    buffer_test();
+    number_test();
+    system_test();
+    table_test();
+
+    /* C tests passed */
+
+    /* Set up VM */
+    int status;
+    JanetTable *env;
+
+    env = janet_core_env(NULL);
+
+    /* Create args tuple */
+    JanetArray *args = janet_array(argc);
+    for (int i = 0; i < argc; i++)
+        janet_array_push(args, janet_cstringv(argv[i]));
+    janet_def(env, "boot/args", janet_wrap_array(args), "Command line arguments.");
+
+    /* Add in options from janetconf.h so boot.janet can configure the image as needed. */
+    JanetTable *opts = janet_table(0);
+#ifdef JANET_NO_DOCSTRINGS
+    janet_table_put(opts, janet_ckeywordv("no-docstrings"), janet_wrap_true());
+#endif
+#ifdef JANET_NO_SOURCEMAPS
+    janet_table_put(opts, janet_ckeywordv("no-sourcemaps"), janet_wrap_true());
+#endif
+    janet_def(env, "boot/config", janet_wrap_table(opts), "Boot options");
+
+    /* Run bootstrap script to generate core image */
+    const char *boot_filename;
+#ifdef JANET_NO_SOURCEMAPS
+    boot_filename = NULL;
+#else
+    boot_filename = "boot.janet";
+#endif
+
+    int chdir_status = chdir(argv[1]);
+    if (chdir_status) {
+        fprintf(stderr, "Could not change to directory %s\n", argv[1]);
+        exit(1);
+    }
+
+    FILE *boot_file = fopen("src/boot/boot.janet", "rb");
+    if (NULL == boot_file) {
+        fprintf(stderr, "Could not open src/boot/boot.janet\n");
+        exit(1);
+    }
+
+    /* Slurp file into buffer */
+    fseek(boot_file, 0, SEEK_END);
+    size_t boot_size = ftell(boot_file);
+    fseek(boot_file, 0, SEEK_SET);
+    unsigned char *boot_buffer = janet_malloc(boot_size);
+    if (NULL == boot_buffer) {
+        fprintf(stderr, "Failed to allocate boot buffer\n");
+        exit(1);
+    }
+    if (!fread(boot_buffer, 1, boot_size, boot_file)) {
+        fprintf(stderr, "Failed to read into boot buffer\n");
+        exit(1);
+    }
+    fclose(boot_file);
+
+    status = janet_dobytes(env, boot_buffer, (int32_t) boot_size, boot_filename, NULL);
+    janet_free(boot_buffer);
+
+    /* Deinitialize vm */
+    janet_deinit();
+
+    return status;
+}

src/boot/buffer_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,16 +20,16 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <assert.h>
 
-int main() {
+#include "tests.h"
+
+int buffer_test() {
 
     int i;
     JanetBuffer *buffer1, *buffer2;
 
-    janet_init();
-
     buffer1 = janet_buffer(100);
     buffer2 = janet_buffer(0);
 
@@ -58,7 +58,5 @@ int main() {
         assert(buffer1->data[i] == buffer2->data[i]);
     }
 
-    janet_deinit();
-
     return 0;
 }

src/boot/number_test.c

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

src/boot/system_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2018 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,11 +20,14 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <assert.h>
 #include <stdio.h>
+#include <math.h>
 
-int main() {
+#include "tests.h"
+
+int system_test() {
 
 #ifdef JANET_32
     assert(sizeof(void *) == 4);
@@ -32,8 +35,6 @@ int main() {
     assert(sizeof(void *) == 8);
 #endif
 
-    janet_init();
-
     /* Reflexive testing and nanbox testing */
     assert(janet_equals(janet_wrap_nil(), janet_wrap_nil()));
     assert(janet_equals(janet_wrap_false(), janet_wrap_false()));
@@ -44,11 +45,31 @@ int main() {
     assert(janet_equals(janet_wrap_integer(INT32_MIN), janet_wrap_integer(INT32_MIN)));
     assert(janet_equals(janet_wrap_number(1.4), janet_wrap_number(1.4)));
     assert(janet_equals(janet_wrap_number(3.14159265), janet_wrap_number(3.14159265)));
+#ifdef NAN
+    assert(janet_checktype(janet_wrap_number(NAN), JANET_NUMBER));
+#else
+    assert(janet_checktype(janet_wrap_number(0.0 / 0.0), JANET_NUMBER));
+#endif
+
+    assert(NULL != &janet_wrap_nil);
 
     assert(janet_equals(janet_cstringv("a string."), janet_cstringv("a string.")));
     assert(janet_equals(janet_csymbolv("sym"), janet_csymbolv("sym")));
 
-    janet_deinit();
+    Janet *t1 = janet_tuple_begin(3);
+    t1[0] = janet_wrap_nil();
+    t1[1] = janet_wrap_integer(4);
+    t1[2] = janet_cstringv("hi");
+    Janet tuple1 = janet_wrap_tuple(janet_tuple_end(t1));
+
+    Janet *t2 = janet_tuple_begin(3);
+    t2[0] = janet_wrap_nil();
+    t2[1] = janet_wrap_integer(4);
+    t2[2] = janet_cstringv("hi");
+    Janet tuple2 = janet_wrap_tuple(janet_tuple_end(t2));
+
+    assert(janet_equals(tuple1, tuple2));
+
 
     return 0;
 }

src/boot/table_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,15 +20,15 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#include <janet.h>
 #include <assert.h>
 
-int main() {
+#include "tests.h"
+
+int table_test() {
 
     JanetTable *t1, *t2;
 
-    janet_init();
-
     t1 = janet_table(10);
     t2 = janet_table(0);
 
@@ -61,7 +61,11 @@ int main() {
     assert(janet_equals(janet_table_get(t2, janet_csymbolv("t2key1")), janet_wrap_integer(10)));
     assert(janet_equals(janet_table_get(t2, janet_csymbolv("t2key2")), janet_wrap_integer(100)));
 
-    janet_deinit();
+    assert(t2->count == 4);
+    assert(janet_equals(janet_table_remove(t2, janet_csymbolv("t2key1")), janet_wrap_integer(10)));
+    assert(t2->count == 3);
+    assert(janet_equals(janet_table_remove(t2, janet_csymbolv("t2key2")), janet_wrap_integer(100)));
+    assert(t2->count == 2);
 
     return 0;
 }

src/boot/tests.h

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

src/conf/janetconf.h

@@ -0,0 +1,64 @@
+/* This will be generated by the build system if this file is not used */
+
+#ifndef JANETCONF_H
+#define JANETCONF_H
+
+#define JANET_VERSION_MAJOR 1
+#define JANET_VERSION_MINOR 23
+#define JANET_VERSION_PATCH 1
+#define JANET_VERSION_EXTRA "-dev"
+#define JANET_VERSION "1.23.1-dev"
+
+/* #define JANET_BUILD "local" */
+
+/* These settings all affect linking, so use cautiously. */
+/* #define JANET_SINGLE_THREADED */
+/* #define JANET_NO_DYNAMIC_MODULES */
+/* #define JANET_NO_NANBOX */
+/* #define JANET_API __attribute__((visibility ("default"))) */
+
+/* These settings should be specified before amalgamation is
+ * built. Any build with these set should be considered non-standard, and
+ * certain Janet libraries should be expected not to work. */
+/* #define JANET_NO_DOCSTRINGS */
+/* #define JANET_NO_SOURCEMAPS */
+/* #define JANET_REDUCED_OS */
+/* #define JANET_NO_PROCESSES */
+/* #define JANET_NO_ASSEMBLER */
+/* #define JANET_NO_PEG */
+/* #define JANET_NO_NET */
+/* #define JANET_NO_INT_TYPES */
+/* #define JANET_NO_EV */
+/* #define JANET_NO_REALPATH */
+/* #define JANET_NO_SYMLINKS */
+/* #define JANET_NO_UMASK */
+/* #define JANET_NO_THREADS */
+
+/* Other settings */
+/* #define JANET_DEBUG */
+/* #define JANET_PRF */
+/* #define JANET_NO_UTC_MKTIME */
+/* #define JANET_OUT_OF_MEMORY do { printf("janet out of memory\n"); exit(1); } while (0) */
+/* #define JANET_EXIT(msg) do { printf("C assert failed executing janet: %s\n", msg); exit(1); } while (0) */
+/* #define JANET_TOP_LEVEL_SIGNAL(msg) call_my_function((msg), stderr) */
+/* #define JANET_RECURSION_GUARD 1024 */
+/* #define JANET_MAX_PROTO_DEPTH 200 */
+/* #define JANET_MAX_MACRO_EXPAND 200 */
+/* #define JANET_STACK_MAX 16384 */
+/* #define JANET_OS_NAME my-custom-os */
+/* #define JANET_ARCH_NAME pdp-8 */
+/* #define JANET_EV_NO_EPOLL */
+/* #define JANET_EV_NO_KQUEUE */
+/* #define JANET_NO_INTERPRETER_INTERRUPT */
+
+/* Custom vm allocator support */
+/* #include <mimalloc.h> */
+/* #define janet_malloc(X) mi_malloc((X)) */
+/* #define janet_realloc(X, Y) mi_realloc((X), (Y)) */
+/* #define janet_calloc(X, Y) mi_calloc((X), (Y)) */
+/* #define janet_free(X) mi_free((X)) */
+
+/* Main client settings, does not affect library code */
+/* #define JANET_SIMPLE_GETLINE */
+
+#endif /* end of include guard: JANETCONF_H */

src/core/abstract.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,15 +20,201 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
+#include "util.h"
 #include "gc.h"
+#include "state.h"
+#endif
+
+#ifdef JANET_EV
+#ifdef JANET_WINDOWS
+#include <windows.h>
+#endif
+#endif
 
 /* Create new userdata */
-void *janet_abstract(const JanetAbstractType *atype, size_t size) {
-    char *data = janet_gcalloc(JANET_MEMORY_ABSTRACT, sizeof(JanetAbstractHeader) + size);
-    JanetAbstractHeader *header = (JanetAbstractHeader *)data;
-    void *a = data + sizeof(JanetAbstractHeader);
+void *janet_abstract_begin(const JanetAbstractType *atype, size_t size) {
+    JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_NONE,
+                                sizeof(JanetAbstractHead) + size);
     header->size = size;
     header->type = atype;
-    return a;
+    return (void *) & (header->data);
 }
+
+void *janet_abstract_end(void *x) {
+    janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_ABSTRACT);
+    return x;
+}
+
+void *janet_abstract(const JanetAbstractType *atype, size_t size) {
+    return janet_abstract_end(janet_abstract_begin(atype, size));
+}
+
+#ifdef JANET_EV
+
+/*
+ * Threaded abstracts
+ */
+
+void *janet_abstract_begin_threaded(const JanetAbstractType *atype, size_t size) {
+    JanetAbstractHead *header = janet_malloc(sizeof(JanetAbstractHead) + size);
+    if (NULL == header) {
+        JANET_OUT_OF_MEMORY;
+    }
+    janet_vm.next_collection += size + sizeof(JanetAbstractHead);
+    header->gc.flags = JANET_MEMORY_THREADED_ABSTRACT;
+    header->gc.data.next = NULL; /* Clear memory for address sanitizers */
+    header->gc.data.refcount = 1;
+    header->size = size;
+    header->type = atype;
+    void *abstract = (void *) & (header->data);
+    janet_table_put(&janet_vm.threaded_abstracts, janet_wrap_abstract(abstract), janet_wrap_false());
+    return abstract;
+}
+
+void *janet_abstract_end_threaded(void *x) {
+    janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_THREADED_ABSTRACT);
+    return x;
+}
+
+void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size) {
+    return janet_abstract_end_threaded(janet_abstract_begin_threaded(atype, size));
+}
+
+/* Refcounting primitives and sync primitives */
+
+#ifdef JANET_WINDOWS
+
+size_t janet_os_mutex_size(void) {
+    return sizeof(CRITICAL_SECTION);
+}
+
+size_t janet_os_rwlock_size(void) {
+    return sizeof(void *);
+}
+
+static int32_t janet_incref(JanetAbstractHead *ab) {
+    return InterlockedIncrement(&ab->gc.data.refcount);
+}
+
+static int32_t janet_decref(JanetAbstractHead *ab) {
+    return InterlockedDecrement(&ab->gc.data.refcount);
+}
+
+void janet_os_mutex_init(JanetOSMutex *mutex) {
+    InitializeCriticalSection((CRITICAL_SECTION *) mutex);
+}
+
+void janet_os_mutex_deinit(JanetOSMutex *mutex) {
+    DeleteCriticalSection((CRITICAL_SECTION *) mutex);
+}
+
+void janet_os_mutex_lock(JanetOSMutex *mutex) {
+    EnterCriticalSection((CRITICAL_SECTION *) mutex);
+}
+
+void janet_os_mutex_unlock(JanetOSMutex *mutex) {
+    /* error handling? May want to keep counter */
+    LeaveCriticalSection((CRITICAL_SECTION *) mutex);
+}
+
+void janet_os_rwlock_init(JanetOSRWLock *rwlock) {
+    InitializeSRWLock((PSRWLOCK) rwlock);
+}
+
+void janet_os_rwlock_deinit(JanetOSRWLock *rwlock) {
+    /* no op? */
+    (void) rwlock;
+}
+
+void janet_os_rwlock_rlock(JanetOSRWLock *rwlock) {
+    AcquireSRWLockShared((PSRWLOCK) rwlock);
+}
+
+void janet_os_rwlock_wlock(JanetOSRWLock *rwlock) {
+    AcquireSRWLockExclusive((PSRWLOCK) rwlock);
+}
+
+void janet_os_rwlock_runlock(JanetOSRWLock *rwlock) {
+    ReleaseSRWLockShared((PSRWLOCK) rwlock);
+}
+
+void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock) {
+    ReleaseSRWLockExclusive((PSRWLOCK) rwlock);
+}
+
+#else
+
+size_t janet_os_mutex_size(void) {
+    return sizeof(pthread_mutex_t);
+}
+
+size_t janet_os_rwlock_size(void) {
+    return sizeof(pthread_rwlock_t);
+}
+
+static int32_t janet_incref(JanetAbstractHead *ab) {
+    return __atomic_add_fetch(&ab->gc.data.refcount, 1, __ATOMIC_RELAXED);
+}
+
+static int32_t janet_decref(JanetAbstractHead *ab) {
+    return __atomic_add_fetch(&ab->gc.data.refcount, -1, __ATOMIC_RELAXED);
+}
+
+void janet_os_mutex_init(JanetOSMutex *mutex) {
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init((pthread_mutex_t *) mutex, &attr);
+}
+
+void janet_os_mutex_deinit(JanetOSMutex *mutex) {
+    pthread_mutex_destroy((pthread_mutex_t *) mutex);
+}
+
+void janet_os_mutex_lock(JanetOSMutex *mutex) {
+    pthread_mutex_lock((pthread_mutex_t *) mutex);
+}
+
+void janet_os_mutex_unlock(JanetOSMutex *mutex) {
+    int ret = pthread_mutex_unlock((pthread_mutex_t *) mutex);
+    if (ret) janet_panic("cannot release lock");
+}
+
+void janet_os_rwlock_init(JanetOSRWLock *rwlock) {
+    pthread_rwlock_init((pthread_rwlock_t *) rwlock, NULL);
+}
+
+void janet_os_rwlock_deinit(JanetOSRWLock *rwlock) {
+    pthread_rwlock_destroy((pthread_rwlock_t *) rwlock);
+}
+
+void janet_os_rwlock_rlock(JanetOSRWLock *rwlock) {
+    pthread_rwlock_rdlock((pthread_rwlock_t *) rwlock);
+}
+
+void janet_os_rwlock_wlock(JanetOSRWLock *rwlock) {
+    pthread_rwlock_wrlock((pthread_rwlock_t *) rwlock);
+}
+
+void janet_os_rwlock_runlock(JanetOSRWLock *rwlock) {
+    pthread_rwlock_unlock((pthread_rwlock_t *) rwlock);
+}
+
+void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock) {
+    pthread_rwlock_unlock((pthread_rwlock_t *) rwlock);
+}
+
+#endif
+
+int32_t janet_abstract_incref(void *abst) {
+    return janet_incref(janet_abstract_head(abst));
+}
+
+int32_t janet_abstract_decref(void *abst) {
+    return janet_decref(janet_abstract_head(abst));
+}
+
+#endif

src/core/array.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,16 +20,23 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "gc.h"
 #include "util.h"
+#include "state.h"
+#endif
+
 #include <string.h>
 
-/* Initializes an array */
-JanetArray *janet_array_init(JanetArray *array, int32_t capacity) {
+/* Creates a new array */
+JanetArray *janet_array(int32_t capacity) {
+    JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
     Janet *data = NULL;
     if (capacity > 0) {
-        data = (Janet *) malloc(sizeof(Janet) * capacity);
+        janet_vm.next_collection += capacity * sizeof(Janet);
+        data = (Janet *) janet_malloc(sizeof(Janet) * (size_t) capacity);
         if (NULL == data) {
             JANET_OUT_OF_MEMORY;
         }
@@ -40,26 +47,16 @@ JanetArray *janet_array_init(JanetArray *array, int32_t capacity) {
     return array;
 }
 
-void janet_array_deinit(JanetArray *array) {
-    free(array->data);
-}
-
-/* Creates a new array */
-JanetArray *janet_array(int32_t capacity) {
-    JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
-    return janet_array_init(array, capacity);
-}
-
 /* Creates a new array from n elements. */
 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 = malloc(sizeof(Janet) * n);
+    array->data = janet_malloc(sizeof(Janet) * (size_t) n);
     if (!array->data) {
         JANET_OUT_OF_MEMORY;
     }
-    memcpy(array->data, elements, sizeof(Janet) * n);
+    safe_memcpy(array->data, elements, sizeof(Janet) * n);
     return array;
 }
 
@@ -68,11 +65,14 @@ void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) {
     Janet *newData;
     Janet *old = array->data;
     if (capacity <= array->capacity) return;
-    capacity *= growth;
-    newData = realloc(old, capacity * sizeof(Janet));
+    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;
     }
+    janet_vm.next_collection += (capacity - array->capacity) * sizeof(Janet);
     array->data = newData;
     array->capacity = capacity;
 }
@@ -93,6 +93,9 @@ void janet_array_setcount(JanetArray *array, int32_t count) {
 
 /* Push a value to the top of the array */
 void janet_array_push(JanetArray *array, Janet x) {
+    if (array->count == INT32_MAX) {
+        janet_panic("array overflow");
+    }
     int32_t newcount = array->count + 1;
     janet_array_ensure(array, newcount, 2);
     array->data[array->count] = x;
@@ -119,36 +122,81 @@ Janet janet_array_peek(JanetArray *array) {
 
 /* C Functions */
 
-static Janet cfun_new(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_array_new,
+              "(array/new capacity)",
+              "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);
     int32_t cap = janet_getinteger(argv, 0);
     JanetArray *array = janet_array(cap);
     return janet_wrap_array(array);
 }
 
-static Janet cfun_pop(int32_t argc, Janet *argv) {
+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);
+    int32_t count = janet_getnat(argv, 0);
+    Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
+    JanetArray *array = janet_array(count);
+    for (int32_t i = 0; i < count; i++) {
+        array->data[i] = x;
+    }
+    array->count = count;
+    return janet_wrap_array(array);
+}
+
+JANET_CORE_FN(cfun_array_fill,
+              "(array/fill arr &opt value)",
+              "Replace all elements of an array with `value` (defaulting to nil) without changing the length of the array. "
+              "Returns the modified array.") {
+    janet_arity(argc, 1, 2);
+    JanetArray *array = janet_getarray(argv, 0);
+    Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
+    for (int32_t i = 0; i < array->count; i++) {
+        array->data[i] = x;
+    }
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_array_pop,
+              "(array/pop arr)",
+              "Remove the last element of the array and return it. If the array is empty, will return nil. Modifies "
+              "the input array.") {
     janet_fixarity(argc, 1);
     JanetArray *array = janet_getarray(argv, 0);
     return janet_array_pop(array);
 }
 
-static Janet cfun_peek(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_array_peek,
+              "(array/peek arr)",
+              "Returns the last element of the array. Does not modify the array.") {
     janet_fixarity(argc, 1);
     JanetArray *array = janet_getarray(argv, 0);
     return janet_array_peek(array);
 }
 
-static Janet cfun_push(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_array_push,
+              "(array/push arr x)",
+              "Insert an element in the end of an array. Modifies the input array and returns it.") {
     janet_arity(argc, 1, -1);
     JanetArray *array = janet_getarray(argv, 0);
+    if (INT32_MAX - argc + 1 <= array->count) {
+        janet_panic("array overflow");
+    }
     int32_t newcount = array->count - 1 + argc;
     janet_array_ensure(array, newcount, 2);
-    if (argc > 1) memcpy(array->data + array->count, argv + 1, (argc - 1) * sizeof(Janet));
+    if (argc > 1) memcpy(array->data + array->count, argv + 1, (size_t)(argc - 1) * sizeof(Janet));
     array->count = newcount;
     return argv[0];
 }
 
-static Janet cfun_ensure(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_array_ensure,
+              "(array/ensure arr capacity growth)",
+              "Ensures that the memory backing the array is large enough for `capacity` "
+              "items at the given rate of growth. `capacity` and `growth` must be integers. "
+              "If the backing capacity is already enough, then this function does nothing. "
+              "Otherwise, the backing memory will be reallocated so that there is enough space.") {
     janet_fixarity(argc, 3);
     JanetArray *array = janet_getarray(argv, 0);
     int32_t newcount = janet_getinteger(argv, 1);
@@ -158,16 +206,28 @@ static Janet cfun_ensure(int32_t argc, Janet *argv) {
     return argv[0];
 }
 
-static Janet cfun_slice(int32_t argc, Janet *argv) {
-    JanetRange range = janet_getslice(argc, argv);
+JANET_CORE_FN(cfun_array_slice,
+              "(array/slice arrtup &opt start end)",
+              "Takes a slice of array or tuple from `start` to `end`. The range is half open, "
+              "[start, end). Indexes can also be negative, indicating indexing from the "
+              "end of the array. By default, `start` is 0 and `end` is the length of the array. "
+              "Note that index -1 is synonymous with index `(length arrtup)` to allow a full "
+              "negative slice range. Returns a new array.") {
     JanetView view = janet_getindexed(argv, 0);
+    JanetRange range = janet_getslice(argc, argv);
     JanetArray *array = janet_array(range.end - range.start);
-    memcpy(array->data, view.items + range.start, sizeof(Janet) * (range.end - range.start));
+    if (array->data)
+        memcpy(array->data, view.items + range.start, sizeof(Janet) * (range.end - range.start));
     array->count = range.end - range.start;
     return janet_wrap_array(array);
 }
 
-static Janet cfun_concat(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_array_concat,
+              "(array/concat arr & parts)",
+              "Concatenates a variable number of arrays (and tuples) into the first argument, "
+              "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);
@@ -177,21 +237,30 @@ static Janet cfun_concat(int32_t argc, Janet *argv) {
                 janet_array_push(array, argv[i]);
                 break;
             case JANET_ARRAY:
-            case JANET_TUPLE:
-                {
-                    int32_t j, len;
-                    const Janet *vals;
+            case JANET_TUPLE: {
+                int32_t j, len = 0;
+                const Janet *vals = NULL;
+                janet_indexed_view(argv[i], &vals, &len);
+                if (array->data == vals) {
+                    int32_t newcount = array->count + len;
+                    janet_array_ensure(array, newcount, 2);
                     janet_indexed_view(argv[i], &vals, &len);
-                    for (j = 0; j < len; j++)
-                        janet_array_push(array, vals[j]);
                 }
-                break;
+                for (j = 0; j < len; j++)
+                    janet_array_push(array, vals[j]);
+            }
+            break;
         }
     }
     return janet_wrap_array(array);
 }
 
-static Janet cfun_insert(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_array_insert,
+              "(array/insert arr at & xs)",
+              "Insert all `xs` into array `arr` at index `at`. `at` should be an integer between "
+              "0 and the length of the array. A negative value for `at` will index backwards from "
+              "the end of the array, such that inserting at -1 appends to the array. "
+              "Returns the array.") {
     size_t chunksize, restsize;
     janet_arity(argc, 2, -1);
     JanetArray *array = janet_getarray(argv, 0);
@@ -203,66 +272,99 @@ static Janet cfun_insert(int32_t argc, Janet *argv) {
         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 (INT32_MAX - (argc - 2) < array->count) {
+        janet_panic("array overflow");
+    }
     janet_array_ensure(array, array->count + argc - 2, 2);
-    memmove(array->data + at + argc - 2,
-            array->data + at,
-            restsize);
-    memcpy(array->data + at, argv + 2, chunksize);
+    if (restsize) {
+        memmove(array->data + at + argc - 2,
+                array->data + at,
+                restsize);
+    }
+    safe_memcpy(array->data + at, argv + 2, chunksize);
     array->count += (argc - 2);
-    return janet_wrap_array(array);
+    return argv[0];
 }
 
-static const JanetReg cfuns[] = {
-    {"array/new", cfun_new,
-        JDOC("(array/new capacity)\n\n"
-                "Creates a new empty array with a pre-allocated capacity. The same as "
-                "(array) but can be more efficient if the maximum size of an array is known.")
-    },
-    {"array/pop", cfun_pop,
-        JDOC("(array/pop arr)\n\n"
-                "Remove the last element of the array and return it. If the array is empty, will return nil. Modifies "
-                "the input array.")
-    },
-    {"array/peek", cfun_peek,
-        JDOC("(array/peek arr)\n\n"
-                "Returns the last element of the array. Does not modify the array.")
-    },
-    {"array/push", cfun_push,
-        JDOC("(array/push arr x)\n\n"
-                "Insert an element in the end of an array. Modifies the input array and returns it.")
-    },
-    {"array/ensure", cfun_ensure,
-        JDOC("(array/ensure arr capacity)\n\n"
-                "Ensures that the memory backing the array has enough memory for capacity "
-                "items. Capacity must be an integer. If the backing capacity is already enough, "
-                "then this function does nothing. Otherwise, the backing memory will be reallocated "
-                "so that there is enough space.")
-    },
-    {"array/slice", cfun_slice,
-        JDOC("(array/slice arrtup [, start=0 [, end=(length arrtup)]])\n\n"
-                "Takes a slice of array or tuple from start to end. The range is half open, "
-                "[start, end). Indexes can also be negative, indicating indexing from the end of the "
-                "end of the array. By default, start is 0 and end is the length of the array. "
-                "Returns a new array.")
-    },
-    {"array/concat", cfun_concat,
-        JDOC("(array/concat arr & parts)\n\n"
-                "Concatenates a variadic number of arrays (and tuples) into the first argument "
-                "which must an array. If any of the parts are arrays or tuples, their elements will "
-                "be inserted into the array. Otherwise, each part in parts will be appended to arr in order. "
-                "Return the modified array arr.")
-    },
-    {"array/insert", cfun_insert,
-        JDOC("(array/insert arr at & xs)\n\n"
-                "Insert all of xs into array arr at index at. at should be an integer "
-                "0 and the length of the array. A negative value for at will index from "
-                "the end of the array, such that inserting at -1 appends to the array. "
-                "Returns the array.")
-    },
-    {NULL, NULL, NULL}
-};
+JANET_CORE_FN(cfun_array_remove,
+              "(array/remove arr at &opt n)",
+              "Remove up to `n` elements starting at index `at` in array `arr`. `at` can index from "
+              "the end of the array with a negative index, and `n` must be a non-negative integer. "
+              "By default, `n` is 1. "
+              "Returns the array.") {
+    janet_arity(argc, 2, 3);
+    JanetArray *array = janet_getarray(argv, 0);
+    int32_t at = janet_getinteger(argv, 1);
+    int32_t n = 1;
+    if (at < 0) {
+        at = array->count + at + 1;
+    }
+    if (at < 0 || at > array->count)
+        janet_panicf("removal index %d out of range [0,%d]", at, array->count);
+    if (argc == 3) {
+        n = janet_getinteger(argv, 2);
+        if (n < 0)
+            janet_panicf("expected non-negative integer for argument n, got %v", argv[2]);
+    }
+    if (at + n > array->count) {
+        n = array->count - at;
+    }
+    memmove(array->data + at,
+            array->data + at + n,
+            (array->count - at - n) * sizeof(Janet));
+    array->count -= n;
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_array_trim,
+              "(array/trim arr)",
+              "Set the backing capacity of an array to its current length. Returns the modified array.") {
+    janet_fixarity(argc, 1);
+    JanetArray *array = janet_getarray(argv, 0);
+    if (array->count) {
+        if (array->count < array->capacity) {
+            Janet *newData = janet_realloc(array->data, array->count * sizeof(Janet));
+            if (NULL == newData) {
+                JANET_OUT_OF_MEMORY;
+            }
+            array->data = newData;
+            array->capacity = array->count;
+        }
+    } else {
+        array->capacity = 0;
+        janet_free(array->data);
+        array->data = NULL;
+    }
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_array_clear,
+              "(array/clear arr)",
+              "Empties an array, setting it's count to 0 but does not free the backing capacity. "
+              "Returns the modified array.") {
+    janet_fixarity(argc, 1);
+    JanetArray *array = janet_getarray(argv, 0);
+    array->count = 0;
+    return argv[0];
+}
 
 /* Load the array module */
 void janet_lib_array(JanetTable *env) {
-    janet_cfuns(env, NULL, cfuns);
+    JanetRegExt array_cfuns[] = {
+        JANET_CORE_REG("array/new", cfun_array_new),
+        JANET_CORE_REG("array/new-filled", cfun_array_new_filled),
+        JANET_CORE_REG("array/fill", cfun_array_fill),
+        JANET_CORE_REG("array/pop", cfun_array_pop),
+        JANET_CORE_REG("array/peek", cfun_array_peek),
+        JANET_CORE_REG("array/push", cfun_array_push),
+        JANET_CORE_REG("array/ensure", cfun_array_ensure),
+        JANET_CORE_REG("array/slice", cfun_array_slice),
+        JANET_CORE_REG("array/concat", cfun_array_concat),
+        JANET_CORE_REG("array/insert", cfun_array_insert),
+        JANET_CORE_REG("array/remove", cfun_array_remove),
+        JANET_CORE_REG("array/trim", cfun_array_trim),
+        JANET_CORE_REG("array/clear", cfun_array_clear),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, array_cfuns);
 }

src/core/asm.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,9 +20,13 @@
 * IN THE SOFTWARE.
 */
 
-#include <setjmp.h>
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "util.h"
+#endif
+
+#include <setjmp.h>
 
 /* Conditionally compile this file */
 #ifdef JANET_ASSEMBLER
@@ -49,7 +53,6 @@ struct JanetAssembler {
 
     Janet name;
     JanetTable labels; /* keyword -> bytecode index */
-    JanetTable constants; /* symbol -> constant index */
     JanetTable slots; /* symbol -> slot index */
     JanetTable envs; /* symbol -> environment index */
     JanetTable defs; /* symbol -> funcdefs index */
@@ -70,20 +73,22 @@ static const JanetInstructionDef janet_ops[] = {
     {"call", JOP_CALL},
     {"clo", JOP_CLOSURE},
     {"cmp", JOP_COMPARE},
+    {"cncl", JOP_CANCEL},
     {"div", JOP_DIVIDE},
     {"divim", JOP_DIVIDE_IMMEDIATE},
     {"eq", JOP_EQUALS},
     {"eqim", JOP_EQUALS_IMMEDIATE},
-    {"eqn", JOP_NUMERIC_EQUAL},
     {"err", JOP_ERROR},
     {"get", JOP_GET},
     {"geti", JOP_GET_INDEX},
     {"gt", JOP_GREATER_THAN},
+    {"gte", JOP_GREATER_THAN_EQUAL},
     {"gtim", JOP_GREATER_THAN_IMMEDIATE},
-    {"gtn", JOP_NUMERIC_GREATER_THAN},
-    {"gten", JOP_NUMERIC_GREATER_THAN_EQUAL},
+    {"in", JOP_IN},
     {"jmp", JOP_JUMP},
     {"jmpif", JOP_JUMP_IF},
+    {"jmpni", JOP_JUMP_IF_NIL},
+    {"jmpnn", JOP_JUMP_IF_NOT_NIL},
     {"jmpno", JOP_JUMP_IF_NOT},
     {"ldc", JOP_LOAD_CONSTANT},
     {"ldf", JOP_LOAD_FALSE},
@@ -94,26 +99,32 @@ static const JanetInstructionDef janet_ops[] = {
     {"ldu", JOP_LOAD_UPVALUE},
     {"len", JOP_LENGTH},
     {"lt", JOP_LESS_THAN},
-    {"lten", JOP_NUMERIC_LESS_THAN_EQUAL},
+    {"lte", JOP_LESS_THAN_EQUAL},
     {"ltim", JOP_LESS_THAN_IMMEDIATE},
-    {"ltn", JOP_NUMERIC_LESS_THAN},
     {"mkarr", JOP_MAKE_ARRAY},
+    {"mkbtp", JOP_MAKE_BRACKET_TUPLE},
     {"mkbuf", JOP_MAKE_BUFFER},
     {"mkstr", JOP_MAKE_STRING},
     {"mkstu", JOP_MAKE_STRUCT},
     {"mktab", JOP_MAKE_TABLE},
     {"mktup", JOP_MAKE_TUPLE},
+    {"mod", JOP_MODULO},
     {"movf", JOP_MOVE_FAR},
     {"movn", JOP_MOVE_NEAR},
     {"mul", JOP_MULTIPLY},
     {"mulim", JOP_MULTIPLY_IMMEDIATE},
+    {"neq", JOP_NOT_EQUALS},
+    {"neqim", JOP_NOT_EQUALS_IMMEDIATE},
+    {"next", JOP_NEXT},
     {"noop", JOP_NOOP},
+    {"prop", JOP_PROPAGATE},
     {"push", JOP_PUSH},
     {"push2", JOP_PUSH_2},
     {"push3", JOP_PUSH_3},
     {"pusha", JOP_PUSH_ARRAY},
     {"put", JOP_PUT},
     {"puti", JOP_PUT_INDEX},
+    {"rem", JOP_REMAINDER},
     {"res", JOP_RESUME},
     {"ret", JOP_RETURN},
     {"retn", JOP_RETURN_NIL},
@@ -144,19 +155,18 @@ static const TypeAlias type_aliases[] = {
     {"callable", JANET_TFLAG_CALLABLE},
     {"cfunction", JANET_TFLAG_CFUNCTION},
     {"dictionary", JANET_TFLAG_DICTIONARY},
-    {"false", JANET_TFLAG_FALSE},
     {"fiber", JANET_TFLAG_FIBER},
     {"function", JANET_TFLAG_FUNCTION},
     {"indexed", JANET_TFLAG_INDEXED},
+    {"keyword", JANET_TFLAG_KEYWORD},
     {"nil", JANET_TFLAG_NIL},
     {"number", JANET_TFLAG_NUMBER},
+    {"pointer", JANET_TFLAG_POINTER},
     {"string", JANET_TFLAG_STRING},
     {"struct", JANET_TFLAG_STRUCT},
     {"symbol", JANET_TFLAG_SYMBOL},
-    {"keyword", JANET_TFLAG_KEYWORD},
-    {"table", JANET_TFLAG_BOOLEAN},
-    {"true", JANET_TFLAG_TRUE},
-    {"tuple", JANET_TFLAG_BOOLEAN}
+    {"table", JANET_TFLAG_TABLE},
+    {"tuple", JANET_TFLAG_TUPLE}
 };
 
 /* Deinitialize an Assembler. Does not deinitialize the parents. */
@@ -164,21 +174,28 @@ static void janet_asm_deinit(JanetAssembler *a) {
     janet_table_deinit(&a->slots);
     janet_table_deinit(&a->labels);
     janet_table_deinit(&a->envs);
-    janet_table_deinit(&a->constants);
     janet_table_deinit(&a->defs);
 }
 
+static void janet_asm_longjmp(JanetAssembler *a) {
+#if defined(JANET_BSD) || defined(JANET_APPLE)
+    _longjmp(a->on_error, 1);
+#else
+    longjmp(a->on_error, 1);
+#endif
+}
+
 /* Throw some kind of assembly error */
 static void janet_asm_error(JanetAssembler *a, const char *message) {
     a->errmessage = janet_formatc("%s, instruction %d", message, a->errindex);
-    longjmp(a->on_error, 1);
+    janet_asm_longjmp(a);
 }
 #define janet_asm_assert(a, c, m) do { if (!(c)) janet_asm_error((a), (m)); } while (0)
 
 /* Throw some kind of assembly error */
 static void janet_asm_errorv(JanetAssembler *a, const uint8_t *m) {
     a->errmessage = m;
-    longjmp(a->on_error, 1);
+    janet_asm_longjmp(a);
 }
 
 /* Add a closure environment to the assembler. Sub funcdefs may need
@@ -207,7 +224,7 @@ static int32_t janet_asm_addenv(JanetAssembler *a, Janet envname) {
     janet_table_put(&a->envs, envname, janet_wrap_number(envindex));
     if (envindex >= a->environments_capacity) {
         int32_t newcap = 2 * envindex;
-        def->environments = realloc(def->environments, newcap * sizeof(int32_t));
+        def->environments = janet_realloc(def->environments, newcap * sizeof(int32_t));
         if (NULL == def->environments) {
             JANET_OUT_OF_MEMORY;
         }
@@ -221,9 +238,9 @@ static int32_t janet_asm_addenv(JanetAssembler *a, Janet envname) {
 /* Parse an argument to an assembly instruction, and return the result as an
  * integer. This integer will need to be bounds checked. */
 static int32_t doarg_1(
-        JanetAssembler *a,
-        enum JanetOpArgType argtype,
-        Janet x) {
+    JanetAssembler *a,
+    enum JanetOpArgType argtype,
+    Janet x) {
     int32_t ret = -1;
     JanetTable *c;
     switch (argtype) {
@@ -236,9 +253,6 @@ static int32_t doarg_1(
         case JANET_OAT_ENVIRONMENT:
             c = &a->envs;
             break;
-        case JANET_OAT_CONSTANT:
-            c = &a->constants;
-            break;
         case JANET_OAT_LABEL:
             c = &a->labels;
             break;
@@ -250,8 +264,7 @@ static int32_t doarg_1(
         default:
             goto error;
             break;
-        case JANET_NUMBER:
-        {
+        case JANET_NUMBER: {
             double y = janet_unwrap_number(x);
             if (janet_checkintrange(y)) {
                 ret = (int32_t) y;
@@ -260,8 +273,7 @@ static int32_t doarg_1(
             }
             break;
         }
-        case JANET_TUPLE:
-        {
+        case JANET_TUPLE: {
             const Janet *t = janet_unwrap_tuple(x);
             if (argtype == JANET_OAT_TYPE) {
                 int32_t i = 0;
@@ -274,8 +286,7 @@ static int32_t doarg_1(
             }
             break;
         }
-        case JANET_KEYWORD:
-        {
+        case JANET_KEYWORD: {
             if (NULL != c && argtype == JANET_OAT_LABEL) {
                 Janet result = janet_table_get(c, x);
                 if (janet_checktype(result, JANET_NUMBER)) {
@@ -285,10 +296,10 @@ static int32_t doarg_1(
                 }
             } else if (argtype == JANET_OAT_TYPE || argtype == JANET_OAT_SIMPLETYPE) {
                 const TypeAlias *alias = janet_strbinsearch(
-                            &type_aliases,
-                            sizeof(type_aliases)/sizeof(TypeAlias),
-                            sizeof(TypeAlias),
-                            janet_unwrap_keyword(x));
+                                             &type_aliases,
+                                             sizeof(type_aliases) / sizeof(TypeAlias),
+                                             sizeof(TypeAlias),
+                                             janet_unwrap_keyword(x));
                 if (alias) {
                     ret = alias->mask;
                 } else {
@@ -299,8 +310,7 @@ static int32_t doarg_1(
             }
             break;
         }
-        case JANET_SYMBOL:
-        {
+        case JANET_SYMBOL: {
             if (NULL != c) {
                 Janet result = janet_table_get(c, x);
                 if (janet_checktype(result, JANET_NUMBER)) {
@@ -325,7 +335,7 @@ static int32_t doarg_1(
         a->def->slotcount = (int32_t) ret + 1;
     return ret;
 
-    error:
+error:
     janet_asm_errorv(a, janet_formatc("error parsing instruction argument %v", x));
     return 0;
 }
@@ -333,12 +343,12 @@ static int32_t doarg_1(
 /* Parse a single argument to an instruction. Trims it as well as
  * try to convert arguments to bit patterns */
 static uint32_t doarg(
-        JanetAssembler *a,
-        enum JanetOpArgType argtype,
-        int nth,
-        int nbytes,
-        int hassign,
-        Janet x) {
+    JanetAssembler *a,
+    enum JanetOpArgType argtype,
+    int nth,
+    int nbytes,
+    int hassign,
+    Janet x) {
     int32_t arg = doarg_1(a, argtype, x);
     /* Calculate the min and max values that can be stored given
      * nbytes, and whether or not the storage is signed */
@@ -346,59 +356,53 @@ static uint32_t doarg(
     int32_t min = hassign ? -max - 1 : 0;
     if (arg < min)
         janet_asm_errorv(a, janet_formatc("instruction argument %v is too small, must be %d byte%s",
-                    x, nbytes, nbytes > 1 ? "s" : ""));
+                                          x, nbytes, nbytes > 1 ? "s" : ""));
     if (arg > max)
         janet_asm_errorv(a, janet_formatc("instruction argument %v is too large, must be %d byte%s",
-                    x, nbytes, nbytes > 1 ? "s" : ""));
+                                          x, nbytes, nbytes > 1 ? "s" : ""));
     return ((uint32_t) arg) << (nth << 3);
 }
 
 /* Provide parsing methods for the different kinds of arguments */
 static uint32_t read_instruction(
-        JanetAssembler *a,
-        const JanetInstructionDef *idef,
-        const Janet *argt) {
+    JanetAssembler *a,
+    const JanetInstructionDef *idef,
+    const Janet *argt) {
     uint32_t instr = idef->opcode;
     enum JanetInstructionType type = janet_instructions[idef->opcode];
     switch (type) {
-        case JINT_0:
-        {
+        case JINT_0: {
             if (janet_tuple_length(argt) != 1)
                 janet_asm_error(a, "expected 0 arguments: (op)");
             break;
         }
-        case JINT_S:
-        {
+        case JINT_S: {
             if (janet_tuple_length(argt) != 2)
                 janet_asm_error(a, "expected 1 argument: (op, slot)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 2, 0, argt[1]);
             break;
         }
-        case JINT_L:
-        {
+        case JINT_L: {
             if (janet_tuple_length(argt) != 2)
                 janet_asm_error(a, "expected 1 argument: (op, label)");
             instr |= doarg(a, JANET_OAT_LABEL, 1, 3, 1, argt[1]);
             break;
         }
-        case JINT_SS:
-        {
+        case JINT_SS: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, slot)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
             instr |= doarg(a, JANET_OAT_SLOT, 2, 2, 0, argt[2]);
             break;
         }
-        case JINT_SL:
-        {
+        case JINT_SL: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, label)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
             instr |= doarg(a, JANET_OAT_LABEL, 2, 2, 1, argt[2]);
             break;
         }
-        case JINT_ST:
-        {
+        case JINT_ST: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, type)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
@@ -406,24 +410,21 @@ static uint32_t read_instruction(
             break;
         }
         case JINT_SI:
-        case JINT_SU:
-        {
+        case JINT_SU: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, integer)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
             instr |= doarg(a, JANET_OAT_INTEGER, 2, 2, type == JINT_SI, argt[2]);
             break;
         }
-        case JINT_SD:
-        {
+        case JINT_SD: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, funcdef)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
             instr |= doarg(a, JANET_OAT_FUNCDEF, 2, 2, 0, argt[2]);
             break;
         }
-        case JINT_SSS:
-        {
+        case JINT_SSS: {
             if (janet_tuple_length(argt) != 4)
                 janet_asm_error(a, "expected 3 arguments: (op, slot, slot, slot)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
@@ -432,8 +433,7 @@ static uint32_t read_instruction(
             break;
         }
         case JINT_SSI:
-        case JINT_SSU:
-        {
+        case JINT_SSU: {
             if (janet_tuple_length(argt) != 4)
                 janet_asm_error(a, "expected 3 arguments: (op, slot, slot, integer)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
@@ -441,8 +441,7 @@ static uint32_t read_instruction(
             instr |= doarg(a, JANET_OAT_INTEGER, 3, 1, type == JINT_SSI, argt[3]);
             break;
         }
-        case JINT_SES:
-        {
+        case JINT_SES: {
             JanetAssembler *b = a;
             uint32_t env;
             if (janet_tuple_length(argt) != 4)
@@ -458,8 +457,7 @@ static uint32_t read_instruction(
             instr |= doarg(b, JANET_OAT_SLOT, 3, 1, 0, argt[3]);
             break;
         }
-        case JINT_SC:
-        {
+        case JINT_SC: {
             if (janet_tuple_length(argt) != 3)
                 janet_asm_error(a, "expected 2 arguments: (op, slot, constant)");
             instr |= doarg(a, JANET_OAT_SLOT, 1, 1, 0, argt[1]);
@@ -506,16 +504,19 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     a.defs_capacity = 0;
     a.name = janet_wrap_nil();
     janet_table_init(&a.labels, 0);
-    janet_table_init(&a.constants, 0);
     janet_table_init(&a.slots, 0);
     janet_table_init(&a.envs, 0);
     janet_table_init(&a.defs, 0);
 
     /* Set error jump */
+#if defined(JANET_BSD) || defined(JANET_APPLE)
+    if (_setjmp(a.on_error)) {
+#else
     if (setjmp(a.on_error)) {
+#endif
         if (NULL != a.parent) {
             janet_asm_deinit(&a);
-            longjmp(a.parent->on_error, 1);
+            janet_asm_longjmp(a.parent);
         }
         result.funcdef = NULL;
         result.error = a.errmessage;
@@ -525,34 +526,43 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     }
 
     janet_asm_assert(&a,
-            janet_checktype(s, JANET_STRUCT) ||
-            janet_checktype(s, JANET_TABLE),
-            "expected struct or table for assembly source");
+                     janet_checktype(s, JANET_STRUCT) ||
+                     janet_checktype(s, JANET_TABLE),
+                     "expected struct or table for assembly source");
 
     /* Check for function name */
-    a.name = janet_get1(s, janet_csymbolv("name"));
+    a.name = janet_get1(s, janet_ckeywordv("name"));
     if (!janet_checktype(a.name, JANET_NIL)) {
         def->name = janet_to_string(a.name);
     }
 
     /* Set function arity */
-    x = janet_get1(s, janet_csymbolv("arity"));
+    x = janet_get1(s, janet_ckeywordv("arity"));
     def->arity = janet_checkint(x) ? janet_unwrap_integer(x) : 0;
+    janet_asm_assert(&a, def->arity >= 0, "arity must be non-negative");
+
+    x = janet_get1(s, janet_ckeywordv("max-arity"));
+    def->max_arity = janet_checkint(x) ? janet_unwrap_integer(x) : def->arity;
+    janet_asm_assert(&a, def->max_arity >= def->arity, "max-arity must be greater than or equal to arity");
+
+    x = janet_get1(s, janet_ckeywordv("min-arity"));
+    def->min_arity = janet_checkint(x) ? janet_unwrap_integer(x) : def->arity;
+    janet_asm_assert(&a, def->min_arity <= def->arity, "min-arity must be less than or equal to arity");
 
     /* Check vararg */
-    x = janet_get1(s, janet_csymbolv("vararg"));
+    x = janet_get1(s, janet_ckeywordv("vararg"));
     if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_VARARG;
 
-    /* Check strict arity */
-    x = janet_get1(s, janet_csymbolv("fix-arity"));
-    if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_FIXARITY;
+    /* Check structarg */
+    x = janet_get1(s, janet_ckeywordv("structarg"));
+    if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG;
 
     /* Check source */
-    x = janet_get1(s, janet_csymbolv("source"));
+    x = janet_get1(s, janet_ckeywordv("source"));
     if (janet_checktype(x, JANET_STRING)) def->source = janet_unwrap_string(x);
 
     /* Create slot aliases */
-    x = janet_get1(s, janet_csymbolv("slots"));
+    x = janet_get1(s, janet_ckeywordv("slots"));
     if (janet_indexed_view(x, &arr, &count)) {
         for (i = 0; i < count; i++) {
             Janet v = arr[i];
@@ -573,34 +583,16 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     }
 
     /* Parse constants */
-    x = janet_get1(s, janet_csymbolv("constants"));
+    x = janet_get1(s, janet_ckeywordv("constants"));
     if (janet_indexed_view(x, &arr, &count)) {
         def->constants_length = count;
-        def->constants = malloc(sizeof(Janet) * count);
+        def->constants = janet_malloc(sizeof(Janet) * (size_t) count);
         if (NULL == def->constants) {
             JANET_OUT_OF_MEMORY;
         }
         for (i = 0; i < count; i++) {
             Janet ct = arr[i];
-            if (janet_checktype(ct, JANET_TUPLE) &&
-                janet_tuple_length(janet_unwrap_tuple(ct)) > 1 &&
-                janet_checktype(janet_unwrap_tuple(ct)[0], JANET_SYMBOL)) {
-                const Janet *t = janet_unwrap_tuple(ct);
-                int32_t tcount = janet_tuple_length(t);
-                const uint8_t *macro = janet_unwrap_symbol(t[0]);
-                if (0 == janet_cstrcmp(macro, "quote")) {
-                    def->constants[i] = t[1];
-                } else if (tcount == 3 &&
-                        janet_checktype(t[1], JANET_SYMBOL) &&
-                        0 == janet_cstrcmp(macro, "def")) {
-                    def->constants[i] = t[2];
-                    janet_table_put(&a.constants, t[1], janet_wrap_integer(i));
-                } else {
-                    janet_asm_errorv(&a, janet_formatc("could not parse constant \"%v\"", ct));
-                }
-            } else {
-                def->constants[i] = ct;
-            }
+            def->constants[i] = ct;
         }
     } else {
         def->constants = NULL;
@@ -608,7 +600,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     }
 
     /* Parse sub funcdefs */
-    x = janet_get1(s, janet_csymbolv("closures"));
+    x = janet_get1(s, janet_ckeywordv("closures"));
     if (janet_indexed_view(x, &arr, &count)) {
         int32_t i;
         for (i = 0; i < count; i++) {
@@ -619,14 +611,14 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
             if (subres.status != JANET_ASSEMBLE_OK) {
                 janet_asm_errorv(&a, subres.error);
             }
-            subname = janet_get1(arr[i], janet_csymbolv("name"));
+            subname = janet_get1(arr[i], janet_ckeywordv("name"));
             if (!janet_checktype(subname, JANET_NIL)) {
                 janet_table_put(&a.defs, subname, janet_wrap_integer(def->defs_length));
             }
             newlen = def->defs_length + 1;
             if (a.defs_capacity < newlen) {
                 int32_t newcap = newlen;
-                def->defs = realloc(def->defs, newcap * sizeof(JanetFuncDef *));
+                def->defs = janet_realloc(def->defs, newcap * sizeof(JanetFuncDef *));
                 if (NULL == def->defs) {
                     JANET_OUT_OF_MEMORY;
                 }
@@ -638,7 +630,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     }
 
     /* Parse bytecode and labels */
-    x = janet_get1(s, janet_csymbolv("bytecode"));
+    x = janet_get1(s, janet_ckeywordv("bytecode"));
     if (janet_indexed_view(x, &arr, &count)) {
         /* Do labels and find length */
         int32_t blength = 0;
@@ -655,7 +647,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
         }
         /* Allocate bytecode array */
         def->bytecode_length = blength;
-        def->bytecode = malloc(sizeof(int32_t) * blength);
+        def->bytecode = janet_malloc(sizeof(uint32_t) * (size_t) blength);
         if (NULL == def->bytecode) {
             JANET_OUT_OF_MEMORY;
         }
@@ -675,12 +667,12 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
                     op = 0;
                 } else {
                     janet_asm_assert(&a, janet_checktype(t[0], JANET_SYMBOL),
-                            "expected symbol in assembly instruction");
+                                     "expected symbol in assembly instruction");
                     idef = janet_strbinsearch(
-                            &janet_ops,
-                            sizeof(janet_ops)/sizeof(JanetInstructionDef),
-                            sizeof(JanetInstructionDef),
-                            janet_unwrap_symbol(t[0]));
+                               &janet_ops,
+                               sizeof(janet_ops) / sizeof(JanetInstructionDef),
+                               sizeof(JanetInstructionDef),
+                               janet_unwrap_symbol(t[0]));
                     if (NULL == idef)
                         janet_asm_errorv(&a, janet_formatc("unknown instruction %v", t[0]));
                     op = read_instruction(&a, idef, t);
@@ -694,10 +686,13 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     a.errindex = -1;
 
     /* Check for source mapping */
-    x = janet_get1(s, janet_csymbolv("sourcemap"));
+    x = janet_get1(s, janet_ckeywordv("sourcemap"));
     if (janet_indexed_view(x, &arr, &count)) {
         janet_asm_assert(&a, count == def->bytecode_length, "sourcemap must have the same length as the bytecode");
-        def->sourcemap = malloc(sizeof(JanetSourceMapping) * count);
+        def->sourcemap = janet_malloc(sizeof(JanetSourceMapping) * (size_t) count);
+        if (NULL == def->sourcemap) {
+            JANET_OUT_OF_MEMORY;
+        }
         for (i = 0; i < count; i++) {
             const Janet *tup;
             Janet entry = arr[i];
@@ -712,21 +707,27 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
             if (!janet_checkint(tup[1])) {
                 janet_asm_error(&a, "expected integer");
             }
-            mapping.start = janet_unwrap_integer(tup[0]);
-            mapping.end = janet_unwrap_integer(tup[1]);
+            mapping.line = janet_unwrap_integer(tup[0]);
+            mapping.column = janet_unwrap_integer(tup[1]);
             def->sourcemap[i] = mapping;
         }
     }
 
     /* Set environments */
     def->environments =
-        realloc(def->environments, def->environments_length * sizeof(int32_t));
+        janet_realloc(def->environments, def->environments_length * sizeof(int32_t));
+    if (NULL == def->environments) {
+        JANET_OUT_OF_MEMORY;
+    }
 
     /* Verify the func def */
     if (janet_verify(def)) {
         janet_asm_error(&a, "invalid assembly");
     }
 
+    /* Add final flags */
+    janet_def_addflags(def);
+
     /* Finish everything and return funcdef */
     janet_asm_deinit(&a);
     result.error = NULL;
@@ -747,7 +748,7 @@ JanetAssembleResult janet_asm(Janet source, int flags) {
 static const JanetInstructionDef *janet_asm_reverse_lookup(uint32_t instr) {
     size_t i;
     uint32_t opcode = instr & 0x7F;
-    for (i = 0; i < sizeof(janet_ops)/sizeof(JanetInstructionDef); i++) {
+    for (i = 0; i < sizeof(janet_ops) / sizeof(JanetInstructionDef); i++) {
         const JanetInstructionDef *def = janet_ops + i;
         if (def->opcode == opcode)
             return def;
@@ -756,31 +757,31 @@ static const JanetInstructionDef *janet_asm_reverse_lookup(uint32_t instr) {
 }
 
 /* Create some constant sized tuples */
-static Janet tup1(Janet x) {
+static const Janet *tup1(Janet x) {
     Janet *tup = janet_tuple_begin(1);
     tup[0] = x;
-    return janet_wrap_tuple(janet_tuple_end(tup));
+    return janet_tuple_end(tup);
 }
-static Janet tup2(Janet x, Janet y) {
+static const Janet *tup2(Janet x, Janet y) {
     Janet *tup = janet_tuple_begin(2);
     tup[0] = x;
     tup[1] = y;
-    return janet_wrap_tuple(janet_tuple_end(tup));
+    return janet_tuple_end(tup);
 }
-static Janet tup3(Janet x, Janet y, Janet z) {
+static const Janet *tup3(Janet x, Janet y, Janet z) {
     Janet *tup = janet_tuple_begin(3);
     tup[0] = x;
     tup[1] = y;
     tup[2] = z;
-    return janet_wrap_tuple(janet_tuple_end(tup));
+    return janet_tuple_end(tup);
 }
-static Janet tup4(Janet w, Janet x, Janet y, Janet z) {
+static const Janet *tup4(Janet w, Janet x, Janet y, Janet z) {
     Janet *tup = janet_tuple_begin(4);
     tup[0] = w;
     tup[1] = x;
     tup[2] = y;
     tup[3] = z;
-    return janet_wrap_tuple(janet_tuple_end(tup));
+    return janet_tuple_end(tup);
 }
 
 /* Given an argument, convert it to the appropriate integer or symbol */
@@ -791,131 +792,172 @@ Janet janet_asm_decode_instruction(uint32_t instr) {
         return janet_wrap_integer((int32_t)instr);
     }
     name = janet_csymbolv(def->name);
+    const Janet *ret = NULL;
 #define oparg(shift, mask) ((instr >> ((shift) << 3)) & (mask))
     switch (janet_instructions[def->opcode]) {
         case JINT_0:
-            return tup1(name);
+            ret = tup1(name);
+            break;
         case JINT_S:
-            return tup2(name, janet_wrap_integer(oparg(1, 0xFFFFFF)));
+            ret = tup2(name, janet_wrap_integer(oparg(1, 0xFFFFFF)));
+            break;
         case JINT_L:
-            return tup2(name, janet_wrap_integer((int32_t)instr >> 8));
+            ret = tup2(name, janet_wrap_integer((int32_t)instr >> 8));
+            break;
         case JINT_SS:
         case JINT_ST:
         case JINT_SC:
         case JINT_SU:
         case JINT_SD:
-            return tup3(name,
-                    janet_wrap_integer(oparg(1, 0xFF)),
-                    janet_wrap_integer(oparg(2, 0xFFFF)));
+            ret = tup3(name,
+                       janet_wrap_integer(oparg(1, 0xFF)),
+                       janet_wrap_integer(oparg(2, 0xFFFF)));
+            break;
         case JINT_SI:
         case JINT_SL:
-            return tup3(name,
-                    janet_wrap_integer(oparg(1, 0xFF)),
-                    janet_wrap_integer((int32_t)instr >> 16));
+            ret =  tup3(name,
+                        janet_wrap_integer(oparg(1, 0xFF)),
+                        janet_wrap_integer((int32_t)instr >> 16));
+            break;
         case JINT_SSS:
         case JINT_SES:
         case JINT_SSU:
-            return tup4(name,
-                    janet_wrap_integer(oparg(1, 0xFF)),
-                    janet_wrap_integer(oparg(2, 0xFF)),
-                    janet_wrap_integer(oparg(3, 0xFF)));
+            ret = tup4(name,
+                       janet_wrap_integer(oparg(1, 0xFF)),
+                       janet_wrap_integer(oparg(2, 0xFF)),
+                       janet_wrap_integer(oparg(3, 0xFF)));
+            break;
         case JINT_SSI:
-            return tup4(name,
-                    janet_wrap_integer(oparg(1, 0xFF)),
-                    janet_wrap_integer(oparg(2, 0xFF)),
-                    janet_wrap_integer((int32_t)instr >> 24));
+            ret = tup4(name,
+                       janet_wrap_integer(oparg(1, 0xFF)),
+                       janet_wrap_integer(oparg(2, 0xFF)),
+                       janet_wrap_integer((int32_t)instr >> 24));
+            break;
     }
 #undef oparg
+    if (ret) {
+        /* Check if break point set */
+        if (instr & 0x80) {
+            janet_tuple_flag(ret) |= JANET_TUPLE_FLAG_BRACKETCTOR;
+        }
+        return janet_wrap_tuple(ret);
+    }
     return janet_wrap_nil();
 }
 
-Janet janet_disasm(JanetFuncDef *def) {
-    int32_t i;
+/*
+ * Disasm sections
+ */
+
+static Janet janet_disasm_arity(JanetFuncDef *def) {
+    return janet_wrap_integer(def->arity);
+}
+
+static Janet janet_disasm_min_arity(JanetFuncDef *def) {
+    return janet_wrap_integer(def->min_arity);
+}
+
+static Janet janet_disasm_max_arity(JanetFuncDef *def) {
+    return janet_wrap_integer(def->max_arity);
+}
+
+static Janet janet_disasm_slotcount(JanetFuncDef *def) {
+    return janet_wrap_integer(def->slotcount);
+}
+
+static Janet janet_disasm_bytecode(JanetFuncDef *def) {
     JanetArray *bcode = janet_array(def->bytecode_length);
-    JanetArray *constants;
-    JanetTable *ret = janet_table(10);
-    janet_table_put(ret, janet_csymbolv("arity"), janet_wrap_integer(def->arity));
-    janet_table_put(ret, janet_csymbolv("bytecode"), janet_wrap_array(bcode));
-    if (NULL != def->source) {
-        janet_table_put(ret, janet_csymbolv("source"), janet_wrap_string(def->source));
-    }
-    if (def->flags & JANET_FUNCDEF_FLAG_VARARG) {
-        janet_table_put(ret, janet_csymbolv("vararg"), janet_wrap_true());
-    }
-    if (def->flags & JANET_FUNCDEF_FLAG_FIXARITY) {
-        janet_table_put(ret, janet_csymbolv("fix-arity"), janet_wrap_true());
-    }
-    if (NULL != def->name) {
-        janet_table_put(ret, janet_csymbolv("name"), janet_wrap_string(def->name));
-    }
-
-    /* Add constants */
-    if (def->constants_length > 0) {
-        constants = janet_array(def->constants_length);
-        janet_table_put(ret, janet_csymbolv("constants"), janet_wrap_array(constants));
-        for (i = 0; i < def->constants_length; i++) {
-            Janet src = def->constants[i];
-            Janet dest;
-            if (janet_checktype(src, JANET_TUPLE)) {
-                dest = tup2(janet_csymbolv("quote"), src);
-            } else {
-                dest = src;
-            }
-            constants->data[i] = dest;
-        }
-        constants->count = def->constants_length;
-    }
-
-    /* Add bytecode */
-    for (i = 0; i < def->bytecode_length; i++) {
+    for (int32_t i = 0; i < def->bytecode_length; i++) {
         bcode->data[i] = janet_asm_decode_instruction(def->bytecode[i]);
     }
     bcode->count = def->bytecode_length;
+    return janet_wrap_array(bcode);
+}
 
-    /* Add source map */
-    if (NULL != def->sourcemap) {
-        JanetArray *sourcemap = janet_array(def->bytecode_length);
-        for (i = 0; i < def->bytecode_length; i++) {
-            Janet *t = janet_tuple_begin(2);
-            JanetSourceMapping mapping = def->sourcemap[i];
-            t[0] = janet_wrap_integer(mapping.start);
-            t[1] = janet_wrap_integer(mapping.end);
-            sourcemap->data[i] = janet_wrap_tuple(janet_tuple_end(t));
-        }
-        sourcemap->count = def->bytecode_length;
-        janet_table_put(ret, janet_csymbolv("sourcemap"), janet_wrap_array(sourcemap));
+static Janet janet_disasm_source(JanetFuncDef *def) {
+    if (def->source != NULL) return janet_wrap_string(def->source);
+    return janet_wrap_nil();
+}
+
+static Janet janet_disasm_name(JanetFuncDef *def) {
+    if (def->name != NULL) return janet_wrap_string(def->name);
+    return janet_wrap_nil();
+}
+
+static Janet janet_disasm_vararg(JanetFuncDef *def) {
+    return janet_wrap_boolean(def->flags & JANET_FUNCDEF_FLAG_VARARG);
+}
+
+static Janet janet_disasm_structarg(JanetFuncDef *def) {
+    return janet_wrap_boolean(def->flags & JANET_FUNCDEF_FLAG_STRUCTARG);
+}
+
+static Janet janet_disasm_constants(JanetFuncDef *def) {
+    JanetArray *constants = janet_array(def->constants_length);
+    for (int32_t i = 0; i < def->constants_length; i++) {
+        constants->data[i] = def->constants[i];
     }
+    constants->count = def->constants_length;
+    return janet_wrap_array(constants);
+}
 
-    /* Add environments */
-    if (NULL != def->environments) {
-        JanetArray *envs = janet_array(def->environments_length);
-        for (i = 0; i < def->environments_length; i++) {
-            envs->data[i] = janet_wrap_integer(def->environments[i]);
-        }
-        envs->count = def->environments_length;
-        janet_table_put(ret, janet_csymbolv("environments"), janet_wrap_array(envs));
+static Janet janet_disasm_sourcemap(JanetFuncDef *def) {
+    if (NULL == def->sourcemap) return janet_wrap_nil();
+    JanetArray *sourcemap = janet_array(def->bytecode_length);
+    for (int32_t i = 0; i < def->bytecode_length; i++) {
+        Janet *t = janet_tuple_begin(2);
+        JanetSourceMapping mapping = def->sourcemap[i];
+        t[0] = janet_wrap_integer(mapping.line);
+        t[1] = janet_wrap_integer(mapping.column);
+        sourcemap->data[i] = janet_wrap_tuple(janet_tuple_end(t));
     }
+    sourcemap->count = def->bytecode_length;
+    return janet_wrap_array(sourcemap);
+}
 
-    /* Add closures */
-    /* Funcdefs cannot be recursive */
-    if (NULL != def->defs) {
-        JanetArray *defs = janet_array(def->defs_length);
-        for (i = 0; i < def->defs_length; i++) {
-            defs->data[i] = janet_disasm(def->defs[i]);
-        }
-        defs->count = def->defs_length;
-        janet_table_put(ret, janet_csymbolv("defs"), janet_wrap_array(defs));
+static Janet janet_disasm_environments(JanetFuncDef *def) {
+    JanetArray *envs = janet_array(def->environments_length);
+    for (int32_t i = 0; i < def->environments_length; i++) {
+        envs->data[i] = janet_wrap_integer(def->environments[i]);
     }
+    envs->count = def->environments_length;
+    return janet_wrap_array(envs);
+}
 
-    /* Add slotcount */
-    janet_table_put(ret, janet_csymbolv("slotcount"), janet_wrap_integer(def->slotcount));
+static Janet janet_disasm_defs(JanetFuncDef *def) {
+    JanetArray *defs = janet_array(def->defs_length);
+    for (int32_t i = 0; i < def->defs_length; i++) {
+        defs->data[i] = janet_disasm(def->defs[i]);
+    }
+    defs->count = def->defs_length;
+    return janet_wrap_array(defs);
+}
 
+Janet janet_disasm(JanetFuncDef *def) {
+    JanetTable *ret = janet_table(10);
+    janet_table_put(ret, janet_ckeywordv("arity"), janet_disasm_arity(def));
+    janet_table_put(ret, janet_ckeywordv("min-arity"), janet_disasm_min_arity(def));
+    janet_table_put(ret, janet_ckeywordv("max-arity"), janet_disasm_max_arity(def));
+    janet_table_put(ret, janet_ckeywordv("bytecode"), janet_disasm_bytecode(def));
+    janet_table_put(ret, janet_ckeywordv("source"), janet_disasm_source(def));
+    janet_table_put(ret, janet_ckeywordv("vararg"), janet_disasm_vararg(def));
+    janet_table_put(ret, janet_ckeywordv("structarg"), janet_disasm_structarg(def));
+    janet_table_put(ret, janet_ckeywordv("name"), janet_disasm_name(def));
+    janet_table_put(ret, janet_ckeywordv("slotcount"), janet_disasm_slotcount(def));
+    janet_table_put(ret, janet_ckeywordv("constants"), janet_disasm_constants(def));
+    janet_table_put(ret, janet_ckeywordv("sourcemap"), janet_disasm_sourcemap(def));
+    janet_table_put(ret, janet_ckeywordv("environments"), janet_disasm_environments(def));
+    janet_table_put(ret, janet_ckeywordv("defs"), janet_disasm_defs(def));
     return janet_wrap_struct(janet_table_to_struct(ret));
 }
 
-/* C Function for assembly */
-static Janet cfun_asm(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+JANET_CORE_FN(cfun_asm,
+              "(asm assembly)",
+              "Returns a new function that is the compiled result of the assembly.\n"
+              "The syntax for the assembly can be found on the Janet website, and should correspond\n"
+              "to the return value of disasm. Will throw an\n"
+              "error on invalid assembly.") {
+    janet_fixarity(argc, 1);
     JanetAssembleResult res;
     res = janet_asm(argv[0], 0);
     if (res.status != JANET_ASSEMBLE_OK) {
@@ -924,31 +966,55 @@ static Janet cfun_asm(int32_t argc, Janet *argv) {
     return janet_wrap_function(janet_thunk(res.funcdef));
 }
 
-static Janet cfun_disasm(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+JANET_CORE_FN(cfun_disasm,
+              "(disasm func &opt field)",
+              "Returns assembly that could be used to compile the given function. "
+              "func must be a function, not a c function. Will throw on error on a badly "
+              "typed argument. If given a field name, will only return that part of the function assembly. "
+              "Possible fields are:\n\n"
+              "* :arity - number of required and optional arguments.\n"
+              "* :min-arity - minimum number of arguments function can be called with.\n"
+              "* :max-arity - maximum number of arguments function can be called with.\n"
+              "* :vararg - true if function can take a variable number of arguments.\n"
+              "* :bytecode - array of parsed bytecode instructions. Each instruction is a tuple.\n"
+              "* :source - name of source file that this function was compiled from.\n"
+              "* :name - name of function.\n"
+              "* :slotcount - how many virtual registers, or slots, this function uses. Corresponds to stack space used by function.\n"
+              "* :constants - an array of constants referenced by this function.\n"
+              "* :sourcemap - a mapping of each bytecode instruction to a line and column in the source file.\n"
+              "* :environments - an internal mapping of which enclosing functions are referenced for bindings.\n"
+              "* :defs - other function definitions that this function may instantiate.\n") {
+    janet_arity(argc, 1, 2);
     JanetFunction *f = janet_getfunction(argv, 0);
-    return janet_disasm(f->def);
+    if (argc == 2) {
+        JanetKeyword kw = janet_getkeyword(argv, 1);
+        if (!janet_cstrcmp(kw, "arity")) return janet_disasm_arity(f->def);
+        if (!janet_cstrcmp(kw, "min-arity")) return janet_disasm_min_arity(f->def);
+        if (!janet_cstrcmp(kw, "max-arity")) return janet_disasm_max_arity(f->def);
+        if (!janet_cstrcmp(kw, "bytecode")) return janet_disasm_bytecode(f->def);
+        if (!janet_cstrcmp(kw, "source")) return janet_disasm_source(f->def);
+        if (!janet_cstrcmp(kw, "name")) return janet_disasm_name(f->def);
+        if (!janet_cstrcmp(kw, "vararg")) return janet_disasm_vararg(f->def);
+        if (!janet_cstrcmp(kw, "structarg")) return janet_disasm_structarg(f->def);
+        if (!janet_cstrcmp(kw, "slotcount")) return janet_disasm_slotcount(f->def);
+        if (!janet_cstrcmp(kw, "constants")) return janet_disasm_constants(f->def);
+        if (!janet_cstrcmp(kw, "sourcemap")) return janet_disasm_sourcemap(f->def);
+        if (!janet_cstrcmp(kw, "environments")) return janet_disasm_environments(f->def);
+        if (!janet_cstrcmp(kw, "defs")) return janet_disasm_defs(f->def);
+        janet_panicf("unknown disasm key %v", argv[1]);
+    } else {
+        return janet_disasm(f->def);
+    }
 }
 
-static const JanetReg cfuns[] = {
-    {"asm", cfun_asm,
-        JDOC("(asm assembly)\n\n"
-                "Returns a new function that is the compiled result of the assembly.\n"
-                "The syntax for the assembly can be found on the janet wiki. Will throw an\n"
-                "error on invalid assembly.")
-    },
-    {"disasm", cfun_disasm,
-        JDOC("(disasm func)\n\n"
-                "Returns assembly that could be used be compile the given function.\n"
-                "func must be a function, not a c function. Will throw on error on a badly\n"
-                "typed argument.")
-    },
-    {NULL, NULL, NULL}
-};
-
 /* Load the library */
 void janet_lib_asm(JanetTable *env) {
-    janet_cfuns(env, NULL, cfuns);
+    JanetRegExt asm_cfuns[] = {
+        JANET_CORE_REG("asm", cfun_asm),
+        JANET_CORE_REG("disasm", cfun_disasm),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, asm_cfuns);
 }
 
 #endif

src/core/buffer.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,18 +20,22 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "gc.h"
 #include "util.h"
+#include "state.h"
+#endif
 
 /* Initialize a buffer */
 JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) {
     uint8_t *data = NULL;
-    if (capacity > 0) {
-        data = malloc(sizeof(uint8_t) * capacity);
-        if (NULL == data) {
-            JANET_OUT_OF_MEMORY;
-        }
+    if (capacity < 4) capacity = 4;
+    janet_gcpressure(capacity);
+    data = janet_malloc(sizeof(uint8_t) * (size_t) capacity);
+    if (NULL == data) {
+        JANET_OUT_OF_MEMORY;
     }
     buffer->count = 0;
     buffer->capacity = capacity;
@@ -41,7 +45,7 @@ JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) {
 
 /* Deinitialize a buffer (free data memory) */
 void janet_buffer_deinit(JanetBuffer *buffer) {
-    free(buffer->data);
+    janet_free(buffer->data);
 }
 
 /* Initialize a buffer */
@@ -55,8 +59,10 @@ 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;
-    capacity *= growth;
-    new_data = realloc(old, capacity * sizeof(uint8_t));
+    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, (size_t) capacity * sizeof(uint8_t));
     if (NULL == new_data) {
         JANET_OUT_OF_MEMORY;
     }
@@ -85,8 +91,9 @@ void janet_buffer_extra(JanetBuffer *buffer, int32_t n) {
     }
     int32_t new_size = buffer->count + n;
     if (new_size > buffer->capacity) {
-        int32_t new_capacity = new_size * 2;
-        uint8_t *new_data = realloc(buffer->data, new_capacity * sizeof(uint8_t));
+        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) {
             JANET_OUT_OF_MEMORY;
         }
@@ -104,6 +111,7 @@ void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) {
 
 /* Push multiple bytes into the buffer */
 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);
     buffer->count += length;
@@ -154,56 +162,158 @@ void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x) {
 
 /* C functions */
 
-static Janet cfun_new(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_buffer_new,
+              "(buffer/new capacity)",
+              "Creates a new, empty buffer with enough backing memory for `capacity` bytes. "
+              "Returns a new buffer of length 0.") {
     janet_fixarity(argc, 1);
     int32_t cap = janet_getinteger(argv, 0);
     JanetBuffer *buffer = janet_buffer(cap);
     return janet_wrap_buffer(buffer);
 }
 
-static Janet cfun_u8(int32_t argc, Janet *argv) {
-    int32_t i;
-    janet_arity(argc, 1, -1);
+JANET_CORE_FN(cfun_buffer_new_filled,
+              "(buffer/new-filled count &opt byte)",
+              "Creates a new buffer of length `count` filled with `byte`. By default, `byte` is 0. "
+              "Returns the new buffer.") {
+    janet_arity(argc, 1, 2);
+    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;
+    }
+    JanetBuffer *buffer = janet_buffer(count);
+    if (buffer->data && count > 0)
+        memset(buffer->data, byte, count);
+    buffer->count = count;
+    return janet_wrap_buffer(buffer);
+}
+
+JANET_CORE_FN(cfun_buffer_fill,
+              "(buffer/fill buffer &opt byte)",
+              "Fill up a buffer with bytes, defaulting to 0s. Does not change the buffer's length. "
+              "Returns the modified buffer.") {
+    janet_arity(argc, 1, 2);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    for (i = 1; i < argc; i++) {
-        janet_buffer_push_u8(buffer, (uint8_t) (janet_getinteger(argv, i) & 0xFF));
+    int32_t byte = 0;
+    if (argc == 2) {
+        byte = janet_getinteger(argv, 1) & 0xFF;
+    }
+    if (buffer->count) {
+        memset(buffer->data, byte, buffer->count);
     }
     return argv[0];
 }
 
-static Janet cfun_word(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_buffer_trim,
+              "(buffer/trim buffer)",
+              "Set the backing capacity of the buffer to the current length of the buffer. Returns the "
+              "modified buffer.") {
+    janet_fixarity(argc, 1);
+    JanetBuffer *buffer = janet_getbuffer(argv, 0);
+    if (buffer->count < buffer->capacity) {
+        int32_t newcap = buffer->count > 4 ? buffer->count : 4;
+        uint8_t *newData = janet_realloc(buffer->data, newcap);
+        if (NULL == newData) {
+            JANET_OUT_OF_MEMORY;
+        }
+        buffer->data = newData;
+        buffer->capacity = newcap;
+    }
+    return argv[0];
+}
+
+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 (i = 1; i < argc; i++) {
-        double number = janet_getnumber(argv, 0);
+        janet_buffer_push_u8(buffer, (uint8_t)(janet_getinteger(argv, i) & 0xFF));
+    }
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_buffer_word,
+              "(buffer/push-word buffer & xs)",
+              "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 (i = 1; i < argc; i++) {
+        double number = janet_getnumber(argv, i);
         uint32_t word = (uint32_t) number;
         if (word != number)
-            janet_panicf("cannot convert %v to machine word", argv[0]);
+            janet_panicf("cannot convert %v to machine word", argv[i]);
         janet_buffer_push_u32(buffer, word);
     }
     return argv[0];
 }
 
-static Janet cfun_chars(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_buffer_chars,
+              "(buffer/push-string buffer & xs)",
+              "Push byte sequences onto the end of a buffer. "
+              "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 (i = 1; i < argc; i++) {
         JanetByteView view = janet_getbytes(argv, i);
+        if (view.bytes == buffer->data) {
+            janet_buffer_ensure(buffer, buffer->count + view.len, 2);
+            view.bytes = buffer->data;
+        }
         janet_buffer_push_bytes(buffer, view.bytes, view.len);
     }
     return argv[0];
 }
 
-static Janet cfun_clear(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_buffer_push,
+              "(buffer/push buffer & xs)",
+              "Push both individual bytes and byte sequences to a buffer. For each x in xs, "
+              "push the byte if x is an integer, otherwise push the bytesequence to the buffer. "
+              "Thus, this function behaves like both `buffer/push-string` and `buffer/push-byte`. "
+              "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 (i = 1; i < argc; i++) {
+        if (janet_checktype(argv[i], JANET_NUMBER)) {
+            janet_buffer_push_u8(buffer, (uint8_t)(janet_getinteger(argv, i) & 0xFF));
+        } else {
+            JanetByteView view = janet_getbytes(argv, i);
+            if (view.bytes == buffer->data) {
+                janet_buffer_ensure(buffer, buffer->count + view.len, 2);
+                view.bytes = buffer->data;
+            }
+            janet_buffer_push_bytes(buffer, view.bytes, view.len);
+        }
+    }
+    return argv[0];
+}
+
+
+JANET_CORE_FN(cfun_buffer_clear,
+              "(buffer/clear buffer)",
+              "Sets the size of a buffer to 0 and empties it. The buffer retains "
+              "its memory so it can be efficiently refilled. Returns the modified buffer.") {
     janet_fixarity(argc, 1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     buffer->count = 0;
     return argv[0];
 }
 
-static Janet cfun_popn(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_buffer_popn,
+              "(buffer/popn buffer n)",
+              "Removes the last `n` bytes from the buffer. Returns the modified buffer.") {
     janet_fixarity(argc, 2);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     int32_t n = janet_getinteger(argv, 1);
@@ -216,57 +326,150 @@ static Janet cfun_popn(int32_t argc, Janet *argv) {
     return argv[0];
 }
 
-static Janet cfun_slice(int32_t argc, Janet *argv) {
-    JanetRange range = janet_getslice(argc, argv);
+JANET_CORE_FN(cfun_buffer_slice,
+              "(buffer/slice bytes &opt start end)",
+              "Takes a slice of a byte sequence from `start` to `end`. The range is half open, "
+              "[start, end). Indexes can also be negative, indicating indexing from the end of the "
+              "end of the array. By default, `start` is 0 and `end` is the length of the buffer. "
+              "Returns a new buffer.") {
     JanetByteView view = janet_getbytes(argv, 0);
+    JanetRange range = janet_getslice(argc, argv);
     JanetBuffer *buffer = janet_buffer(range.end - range.start);
-    memcpy(buffer->data, view.bytes + range.start, range.end - range.start);
+    if (buffer->data)
+        memcpy(buffer->data, view.bytes + range.start, range.end - range.start);
     buffer->count = range.end - range.start;
     return janet_wrap_buffer(buffer);
 }
 
-static const JanetReg cfuns[] = {
-    {"buffer/new", cfun_new,
-        JDOC("(buffer/new capacity)\n\n"
-                "Creates a new, empty buffer with enough memory for capacity bytes. "
-                "Returns a new buffer.")
-    },
-    {"buffer/push-byte", cfun_u8,
-        JDOC("(buffer/push-byte buffer x)\n\n"
-                "Append a byte to a buffer. Will expand the buffer as necessary. "
-                "Returns the modified buffer. Will throw an error if the buffer overflows.")
-    },
-    {"buffer/push-word", cfun_word,
-        JDOC("(buffer/push-word buffer x)\n\n"
-                "Append a machine word to a buffer. The 4 bytes of the integer are appended "
-                "in twos complement, big endian order, unsigned. Returns the modified buffer. Will "
-                "throw an error if the buffer overflows.")
-    },
-    {"buffer/push-string", cfun_chars,
-        JDOC("(buffer/push-string buffer str)\n\n"
-                "Push a string onto the end of a buffer. Non string values will be converted "
-                "to strings before being pushed. Returns the modified buffer. "
-                "Will throw an error if the buffer overflows.")
-    },
-    {"buffer/popn", cfun_popn,
-        JDOC("(buffer/popn buffer n)\n\n"
-                "Removes the last n bytes from the buffer. Returns the modified buffer.")
-    },
-    {"buffer/clear", cfun_clear,
-        JDOC("(buffer/clear buffer)\n\n"
-                "Sets the size of a buffer to 0 and empties it. The buffer retains "
-                "its memory so it can be efficiently refilled. Returns the modified buffer.")
-    },
-    {"buffer/slice", cfun_slice,
-        JDOC("(buffer/slice bytes [, start=0 [, end=(length bytes)]])\n\n"
-                "Takes a slice of a byte sequence from start to end. The range is half open, "
-                "[start, end). Indexes can also be negative, indicating indexing from the end of the "
-                "end of the array. By default, start is 0 and end is the length of the buffer. "
-                "Returns a new buffer.")
-    },
-    {NULL, NULL, NULL}
-};
+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 || byteindex >= buffer->count)
+        janet_panicf("invalid bit index %v", argv[1]);
+    *b = buffer;
+    *index = (int32_t) byteindex;
+    *bit = which_bit;
+}
+
+JANET_CORE_FN(cfun_buffer_bitset,
+              "(buffer/bit-set buffer index)",
+              "Sets the bit at the given bit-index. Returns the buffer.") {
+    int bit;
+    int32_t index;
+    JanetBuffer *buffer;
+    bitloc(argc, argv, &buffer, &index, &bit);
+    buffer->data[index] |= 1 << bit;
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_buffer_bitclear,
+              "(buffer/bit-clear buffer index)",
+              "Clears the bit at the given bit-index. Returns the buffer.") {
+    int bit;
+    int32_t index;
+    JanetBuffer *buffer;
+    bitloc(argc, argv, &buffer, &index, &bit);
+    buffer->data[index] &= ~(1 << bit);
+    return argv[0];
+}
+
+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;
+    int32_t index;
+    JanetBuffer *buffer;
+    bitloc(argc, argv, &buffer, &index, &bit);
+    return janet_wrap_boolean(buffer->data[index] & (1 << bit));
+}
+
+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;
+    int32_t index;
+    JanetBuffer *buffer;
+    bitloc(argc, argv, &buffer, &index, &bit);
+    buffer->data[index] ^= (1 << bit);
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_buffer_blit,
+              "(buffer/blit dest src &opt dest-start src-start src-end)",
+              "Insert the contents of `src` into `dest`. Can optionally take indices that "
+              "indicate which part of `src` to copy into which part of `dest`. Indices can be "
+              "negative in order to index from the end of `src` or `dest`. Returns `dest`.") {
+    janet_arity(argc, 2, 5);
+    JanetBuffer *dest = janet_getbuffer(argv, 0);
+    JanetByteView src = janet_getbytes(argv, 1);
+    int same_buf = src.bytes == dest->data;
+    int32_t offset_dest = 0;
+    int32_t offset_src = 0;
+    if (argc > 2)
+        offset_dest = janet_gethalfrange(argv, 2, dest->count, "dest-start");
+    if (argc > 3)
+        offset_src = janet_gethalfrange(argv, 3, src.len, "src-start");
+    int32_t length_src;
+    if (argc > 4) {
+        int32_t 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;
+    }
+    int64_t last = (int64_t) offset_dest + length_src;
+    if (last > INT32_MAX)
+        janet_panic("buffer blit out of range");
+    int32_t last32 = (int32_t) last;
+    janet_buffer_ensure(dest, last32, 2);
+    if (last32 > dest->count) dest->count = last32;
+    if (length_src) {
+        if (same_buf) {
+            /* janet_buffer_ensure may have invalidated src */
+            src.bytes = dest->data;
+            memmove(dest->data + offset_dest, src.bytes + offset_src, length_src);
+        } else {
+            memcpy(dest->data + offset_dest, src.bytes + offset_src, length_src);
+        }
+    }
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_buffer_format,
+              "(buffer/format buffer 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);
+    const char *strfrmt = (const char *) janet_getstring(argv, 1);
+    janet_buffer_format(buffer, strfrmt, 1, argc, argv);
+    return argv[0];
+}
 
 void janet_lib_buffer(JanetTable *env) {
-    janet_cfuns(env, NULL, cfuns);
+    JanetRegExt buffer_cfuns[] = {
+        JANET_CORE_REG("buffer/new", cfun_buffer_new),
+        JANET_CORE_REG("buffer/new-filled", cfun_buffer_new_filled),
+        JANET_CORE_REG("buffer/fill", cfun_buffer_fill),
+        JANET_CORE_REG("buffer/trim", cfun_buffer_trim),
+        JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8),
+        JANET_CORE_REG("buffer/push-word", cfun_buffer_word),
+        JANET_CORE_REG("buffer/push-string", cfun_buffer_chars),
+        JANET_CORE_REG("buffer/push", cfun_buffer_push),
+        JANET_CORE_REG("buffer/popn", cfun_buffer_popn),
+        JANET_CORE_REG("buffer/clear", cfun_buffer_clear),
+        JANET_CORE_REG("buffer/slice", cfun_buffer_slice),
+        JANET_CORE_REG("buffer/bit-set", cfun_buffer_bitset),
+        JANET_CORE_REG("buffer/bit-clear", cfun_buffer_bitclear),
+        JANET_CORE_REG("buffer/bit", cfun_buffer_bitget),
+        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_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, buffer_cfuns);
 }

src/core/bytecode.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,8 +20,12 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "gc.h"
+#include "util.h"
+#endif
 
 /* Look up table for instructions */
 enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = {
@@ -37,6 +41,8 @@ enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = {
     JINT_SSS, /* JOP_MULTIPLY, */
     JINT_SSI, /* JOP_DIVIDE_IMMEDIATE, */
     JINT_SSS, /* JOP_DIVIDE, */
+    JINT_SSS, /* JOP_MODULO, */
+    JINT_SSS, /* JOP_REMAINDER, */
     JINT_SSS, /* JOP_BAND, */
     JINT_SSS, /* JOP_BOR, */
     JINT_SSS, /* JOP_BXOR, */
@@ -52,6 +58,8 @@ enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = {
     JINT_L, /* JOP_JUMP, */
     JINT_SL, /* JOP_JUMP_IF, */
     JINT_SL, /* JOP_JUMP_IF_NOT, */
+    JINT_SL, /* JOP_JUMP_IF_NIL, */
+    JINT_SL, /* JOP_JUMP_IF_NOT_NIL, */
     JINT_SSS, /* JOP_GREATER_THAN, */
     JINT_SSI, /* JOP_GREATER_THAN_IMMEDIATE, */
     JINT_SSS, /* JOP_LESS_THAN, */
@@ -76,6 +84,8 @@ enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = {
     JINT_S, /* JOP_TAILCALL, */
     JINT_SSS, /* JOP_RESUME, */
     JINT_SSU, /* JOP_SIGNAL, */
+    JINT_SSS, /* JOP_PROPAGATE */
+    JINT_SSS, /* JOP_IN, */
     JINT_SSS, /* JOP_GET, */
     JINT_SSS, /* JOP_PUT, */
     JINT_SSU, /* JOP_GET_INDEX, */
@@ -83,19 +93,21 @@ enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = {
     JINT_SS, /* JOP_LENGTH */
     JINT_S, /* JOP_MAKE_ARRAY */
     JINT_S, /* JOP_MAKE_BUFFER */
-    JINT_S, /* JOP_MAKE_TUPLE */
+    JINT_S, /* JOP_MAKE_STRING */
     JINT_S, /* JOP_MAKE_STRUCT */
     JINT_S, /* JOP_MAKE_TABLE */
-    JINT_S, /* JOP_MAKE_STRING */
-    JINT_SSS, /* JOP_NUMERIC_LESS_THAN */
-    JINT_SSS, /* JOP_NUMERIC_LESS_THAN_EQUAL */
-    JINT_SSS, /* JOP_NUMERIC_GREATER_THAN */
-    JINT_SSS, /* JOP_NUMERIC_GREATER_THAN_EQUAL */
-    JINT_SSS /* JOP_NUMERIC_EQUAL */
+    JINT_S, /* JOP_MAKE_TUPLE */
+    JINT_S, /* JOP_MAKE_BRACKET_TUPLE */
+    JINT_SSS, /* JOP_GREATER_THAN_EQUAL */
+    JINT_SSS, /* JOP_LESS_THAN_EQUAL */
+    JINT_SSS, /* JOP_NEXT */
+    JINT_SSS, /* JOP_NOT_EQUALS, */
+    JINT_SSI, /* JOP_NOT_EQUALS_IMMEDIATE, */
+    JINT_SSS /* JOP_CANCEL, */
 };
 
 /* Verify some bytecode */
-int32_t janet_verify(JanetFuncDef *def) {
+int janet_verify(JanetFuncDef *def) {
     int vargs = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG);
     int32_t i;
     int32_t maxslot = def->arity + vargs;
@@ -116,72 +128,62 @@ int32_t janet_verify(JanetFuncDef *def) {
         switch (type) {
             case JINT_0:
                 continue;
-            case JINT_S:
-                {
-                    if ((int32_t)(instr >> 8) >= sc) return 4;
-                    continue;
-                }
+            case JINT_S: {
+                if ((int32_t)(instr >> 8) >= sc) return 4;
+                continue;
+            }
             case JINT_SI:
             case JINT_SU:
-            case JINT_ST:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    continue;
-                }
-            case JINT_L:
-                {
-                    int32_t jumpdest = i + (((int32_t)instr) >> 8);
-                    if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5;
-                    continue;
-                }
-            case JINT_SS:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc ||
+            case JINT_ST: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                continue;
+            }
+            case JINT_L: {
+                int32_t jumpdest = i + (((int32_t)instr) >> 8);
+                if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5;
+                continue;
+            }
+            case JINT_SS: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc ||
                         (int32_t)(instr >> 16) >= sc) return 4;
-                    continue;
-                }
+                continue;
+            }
             case JINT_SSI:
-            case JINT_SSU:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc ||
+            case JINT_SSU: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc ||
                         (int32_t)((instr >> 16) & 0xFF) >= sc) return 4;
-                    continue;
-                }
-            case JINT_SL:
-                {
-                    int32_t jumpdest = i + (((int32_t)instr) >> 16);
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5;
-                    continue;
-                }
-            case JINT_SSS:
-                {
-                    if (((int32_t)(instr >> 8) & 0xFF) >= sc ||
+                continue;
+            }
+            case JINT_SL: {
+                int32_t jumpdest = i + (((int32_t)instr) >> 16);
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5;
+                continue;
+            }
+            case JINT_SSS: {
+                if (((int32_t)(instr >> 8) & 0xFF) >= sc ||
                         ((int32_t)(instr >> 16) & 0xFF) >= sc ||
                         ((int32_t)(instr >> 24) & 0xFF) >= sc) return 4;
-                    continue;
-                }
-            case JINT_SD:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    if ((int32_t)(instr >> 16) >= def->defs_length) return 6;
-                    continue;
-                }
-            case JINT_SC:
-                {
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    if ((int32_t)(instr >> 16) >= def->constants_length) return 7;
-                    continue;
-                }
-            case JINT_SES:
-                {
-                    /* How can we check the last slot index? We need info parent funcdefs. Resort
-                     * to runtime checks for now. Maybe invalid upvalue references could be defaulted
-                     * to nil? (don't commit to this in the long term, though) */
-                    if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
-                    if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8;
-                    continue;
-                }
+                continue;
+            }
+            case JINT_SD: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                if ((int32_t)(instr >> 16) >= def->defs_length) return 6;
+                continue;
+            }
+            case JINT_SC: {
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                if ((int32_t)(instr >> 16) >= def->constants_length) return 7;
+                continue;
+            }
+            case JINT_SES: {
+                /* How can we check the last slot index? We need info parent funcdefs. Resort
+                 * to runtime checks for now. Maybe invalid upvalue references could be defaulted
+                 * to nil? (don't commit to this in the long term, though) */
+                if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4;
+                if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8;
+                continue;
+            }
         }
     }
 
@@ -208,14 +210,17 @@ int32_t janet_verify(JanetFuncDef *def) {
 
 /* Allocate an empty funcdef. This function may have added functionality
  * as commonalities between asm and compile arise. */
-JanetFuncDef *janet_funcdef_alloc() {
+JanetFuncDef *janet_funcdef_alloc(void) {
     JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef));
     def->environments = NULL;
     def->constants = NULL;
     def->bytecode = NULL;
+    def->closure_bitset = NULL;
     def->flags = 0;
     def->slotcount = 0;
     def->arity = 0;
+    def->min_arity = 0;
+    def->max_arity = INT32_MAX;
     def->source = NULL;
     def->sourcemap = NULL;
     def->name = NULL;

src/core/capi.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,18 +20,70 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "state.h"
 #include "fiber.h"
+#endif
+
+#ifndef JANET_SINGLE_THREADED
+#ifndef JANET_WINDOWS
+#include <pthread.h>
+#else
+#include <windows.h>
+#endif
+#endif
+
+JANET_NO_RETURN static void janet_top_level_signal(const char *msg) {
+#ifdef JANET_TOP_LEVEL_SIGNAL
+    JANET_TOP_LEVEL_SIGNAL(msg);
+#else
+    fputs(msg, stdout);
+# ifdef JANET_SINGLE_THREADED
+    exit(-1);
+# elif defined(JANET_WINDOWS)
+    ExitThread(-1);
+# else
+    pthread_exit(NULL);
+# endif
+#endif
+}
+
+void janet_signalv(JanetSignal sig, Janet message) {
+    if (janet_vm.return_reg != NULL) {
+        *janet_vm.return_reg = message;
+        if (NULL != janet_vm.fiber) {
+            janet_vm.fiber->flags |= JANET_FIBER_DID_LONGJUMP;
+        }
+#if defined(JANET_BSD) || defined(JANET_APPLE)
+        _longjmp(*janet_vm.signal_buf, sig);
+#else
+        longjmp(*janet_vm.signal_buf, sig);
+#endif
+    } else {
+        const char *str = (const char *)janet_formatc("janet top level signal - %v\n", message);
+        janet_top_level_signal(str);
+    }
+}
 
 void janet_panicv(Janet message) {
-    if (janet_vm_fiber != NULL) {
-        janet_fiber_push(janet_vm_fiber, message);
-        longjmp(janet_vm_fiber->buf, 1);
-    } else {
-        fputs((const char *)janet_formatc("janet top level panic - %v\n", message), stdout);
-        exit(1);
-    }
+    janet_signalv(JANET_SIGNAL_ERROR, message);
+}
+
+void janet_panicf(const char *format, ...) {
+    va_list args;
+    const uint8_t *ret;
+    JanetBuffer buffer;
+    int32_t len = 0;
+    while (format[len]) len++;
+    janet_buffer_init(&buffer, len);
+    va_start(args, format);
+    janet_formatbv(&buffer, format, args);
+    va_end(args);
+    ret = janet_string(buffer.data, buffer.count);
+    janet_buffer_deinit(&buffer);
+    janet_panics(ret);
 }
 
 void janet_panic(const char *message) {
@@ -71,6 +123,49 @@ type janet_get##name(const Janet *argv, int32_t n) { \
     return janet_unwrap_##name(x); \
 }
 
+#define DEFINE_OPT(name, NAME, type) \
+type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, type dflt) { \
+    if (n >= argc) return dflt; \
+    if (janet_checktype(argv[n], JANET_NIL)) return dflt; \
+    return janet_get##name(argv, n); \
+}
+
+#define DEFINE_OPTLEN(name, NAME, type) \
+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); \
+    }\
+    return janet_get##name(argv, n); \
+}
+
+int janet_getmethod(const uint8_t *method, const JanetMethod *methods, Janet *out) {
+    while (methods->name) {
+        if (!janet_cstrcmp(method, methods->name)) {
+            *out = janet_wrap_cfunction(methods->cfun);
+            return 1;
+        }
+        methods++;
+    }
+    return 0;
+}
+
+Janet janet_nextmethod(const JanetMethod *methods, Janet key) {
+    if (!janet_checktype(key, JANET_NIL)) {
+        while (methods->name) {
+            if (janet_keyeq(key, methods->name)) {
+                methods++;
+                break;
+            }
+            methods++;
+        }
+    }
+    if (methods->name) {
+        return janet_ckeywordv(methods->name);
+    } else {
+        return janet_wrap_nil();
+    }
+}
+
 DEFINE_GETTER(number, NUMBER, double)
 DEFINE_GETTER(array, ARRAY, JanetArray *)
 DEFINE_GETTER(tuple, TUPLE, const Janet *)
@@ -83,31 +178,135 @@ DEFINE_GETTER(buffer, BUFFER, JanetBuffer *)
 DEFINE_GETTER(fiber, FIBER, JanetFiber *)
 DEFINE_GETTER(function, FUNCTION, JanetFunction *)
 DEFINE_GETTER(cfunction, CFUNCTION, JanetCFunction)
+DEFINE_GETTER(boolean, BOOLEAN, int)
+DEFINE_GETTER(pointer, POINTER, void *)
 
-int janet_getboolean(const Janet *argv, int32_t n) {
-    Janet x = argv[n];
-    if (janet_checktype(x, JANET_TRUE)) {
-        return 1;
-    } else if (!janet_checktype(x, JANET_FALSE)) {
-        janet_panicf("bad slot #%d, expected boolean, got %v", n, x);
+DEFINE_OPT(number, NUMBER, double)
+DEFINE_OPT(tuple, TUPLE, const Janet *)
+DEFINE_OPT(struct, STRUCT, const JanetKV *)
+DEFINE_OPT(string, STRING, const uint8_t *)
+DEFINE_OPT(keyword, KEYWORD, const uint8_t *)
+DEFINE_OPT(symbol, SYMBOL, const uint8_t *)
+DEFINE_OPT(fiber, FIBER, JanetFiber *)
+DEFINE_OPT(function, FUNCTION, JanetFunction *)
+DEFINE_OPT(cfunction, CFUNCTION, JanetCFunction)
+DEFINE_OPT(boolean, BOOLEAN, int)
+DEFINE_OPT(pointer, POINTER, void *)
+
+DEFINE_OPTLEN(buffer, BUFFER, JanetBuffer *)
+DEFINE_OPTLEN(table, TABLE, JanetTable *)
+DEFINE_OPTLEN(array, ARRAY, JanetArray *)
+
+const char *janet_optcstring(const Janet *argv, int32_t argc, int32_t n, const char *dflt) {
+    if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {
+        return dflt;
     }
-    return 0;
+    return janet_getcstring(argv, n);
+}
+
+#undef DEFINE_GETTER
+#undef DEFINE_OPT
+#undef DEFINE_OPTLEN
+
+const char *janet_getcstring(const Janet *argv, int32_t n) {
+    const uint8_t *jstr = janet_getstring(argv, n);
+    const char *cstr = (const char *)jstr;
+    if (strlen(cstr) != (size_t) janet_string_length(jstr)) {
+        janet_panic("string contains embedded 0s");
+    }
+    return cstr;
+}
+
+int32_t janet_getnat(const Janet *argv, int32_t n) {
+    Janet x = argv[n];
+    if (!janet_checkint(x)) goto bad;
+    int32_t ret = janet_unwrap_integer(x);
+    if (ret < 0) goto bad;
+    return ret;
+bad:
+    janet_panicf("bad slot #%d, expected non-negative 32 bit signed integer, got %v", n, x);
+}
+
+JanetAbstract janet_checkabstract(Janet x, const JanetAbstractType *at) {
+    if (!janet_checktype(x, JANET_ABSTRACT)) return NULL;
+    JanetAbstract a = janet_unwrap_abstract(x);
+    if (janet_abstract_type(a) != at) return NULL;
+    return a;
+}
+
+static int janet_strlike_cmp(JanetType type, Janet x, const char *cstring) {
+    if (janet_type(x) != type) return 0;
+    return !janet_cstrcmp(janet_unwrap_string(x), cstring);
+}
+
+int janet_keyeq(Janet x, const char *cstring) {
+    return janet_strlike_cmp(JANET_KEYWORD, x, cstring);
+}
+
+int janet_streq(Janet x, const char *cstring) {
+    return janet_strlike_cmp(JANET_STRING, x, cstring);
+}
+
+int janet_symeq(Janet x, const char *cstring) {
+    return janet_strlike_cmp(JANET_SYMBOL, x, cstring);
 }
 
 int32_t janet_getinteger(const Janet *argv, int32_t n) {
     Janet x = argv[n];
     if (!janet_checkint(x)) {
-        janet_panicf("bad slot #%d, expected integer, got %v", n, x);
+        janet_panicf("bad slot #%d, expected 32 bit signed integer, got %v", n, x);
     }
     return janet_unwrap_integer(x);
 }
 
 int64_t janet_getinteger64(const Janet *argv, int32_t n) {
+#ifdef JANET_INTTYPES
+    return janet_unwrap_s64(argv[n]);
+#else
     Janet x = argv[n];
     if (!janet_checkint64(x)) {
-        janet_panicf("bad slot #%d, expected 64 bit integer, got %v", n, x);
+        janet_panicf("bad slot #%d, expected 64 bit signed integer, got %v", n, x);
     }
     return (int64_t) janet_unwrap_number(x);
+#endif
+}
+
+uint64_t janet_getuinteger64(const Janet *argv, int32_t n) {
+#ifdef JANET_INTTYPES
+    return janet_unwrap_u64(argv[n]);
+#else
+    Janet x = argv[n];
+    if (!janet_checkint64(x)) {
+        janet_panicf("bad slot #%d, expected 64 bit unsigned integer, got %v", n, x);
+    }
+    return (uint64_t) janet_unwrap_number(x);
+#endif
+}
+
+size_t janet_getsize(const Janet *argv, int32_t n) {
+    Janet x = argv[n];
+    if (!janet_checksize(x)) {
+        janet_panicf("bad slot #%d, expected size, got %v", n, x);
+    }
+    return (size_t) janet_unwrap_number(x);
+}
+
+int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which) {
+    int32_t raw = janet_getinteger(argv, n);
+    int32_t not_raw = raw;
+    if (not_raw < 0) not_raw += length + 1;
+    if (not_raw < 0 || not_raw > length)
+        janet_panicf("%s index %d out of range [%d,%d]", which, raw, -length - 1, length);
+    return not_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 || not_raw > length)
+        janet_panicf("%s index %d out of range [%d,%d)", which, raw, -length, length);
+    return not_raw;
 }
 
 JanetView janet_getindexed(const Janet *argv, int32_t n) {
@@ -157,32 +356,113 @@ JanetRange janet_getslice(int32_t argc, const Janet *argv) {
         range.start = 0;
         range.end = length;
     } else if (argc == 2) {
-        range.start = janet_getinteger(argv, 1);
+        range.start = janet_checktype(argv[1], JANET_NIL)
+                      ? 0
+                      : janet_gethalfrange(argv, 1, length, "start");
         range.end = length;
-        if (range.start < 0) {
-            range.start += length + 1;
-        }
-        if (range.start < 0 || range.start > length) {
-            janet_panicf("slice start: index %d out of range [0,%d]", range.start, length);
-        }
     } else {
-        range.start = janet_getinteger(argv, 1);
-        range.end = janet_getinteger(argv, 2);
-        if (range.start < 0) {
-            range.start += length + 1;
-        }
-        if (range.end < 0) {
-            range.end += length + 1;
-        }
-        if (range.start < 0 || range.start > length) {
-            janet_panicf("slice start: index %d out of range [0,%d]", range.start, length);
-        }
-        if (range.end < 0 || range.end > length) {
-            janet_panicf("slice end: index %d out of range [0,%d]", range.end, length);
-        }
-        if (range.end < range.start) {
+        range.start = janet_checktype(argv[1], JANET_NIL)
+                      ? 0
+                      : janet_gethalfrange(argv, 1, length, "start");
+        range.end = janet_checktype(argv[2], JANET_NIL)
+                    ? length
+                    : janet_gethalfrange(argv, 2, length, "end");
+        if (range.end < range.start)
             range.end = range.start;
-        }
     }
     return range;
 }
+
+Janet janet_dyn(const char *name) {
+    if (!janet_vm.fiber) {
+        if (!janet_vm.top_dyns) return janet_wrap_nil();
+        return janet_table_get(janet_vm.top_dyns, janet_ckeywordv(name));
+    }
+    if (janet_vm.fiber->env) {
+        return janet_table_get(janet_vm.fiber->env, janet_ckeywordv(name));
+    } else {
+        return janet_wrap_nil();
+    }
+}
+
+void janet_setdyn(const char *name, Janet value) {
+    if (!janet_vm.fiber) {
+        if (!janet_vm.top_dyns) janet_vm.top_dyns = janet_table(10);
+        janet_table_put(janet_vm.top_dyns, janet_ckeywordv(name), value);
+    } else {
+        if (!janet_vm.fiber->env) {
+            janet_vm.fiber->env = janet_table(1);
+        }
+        janet_table_put(janet_vm.fiber->env, janet_ckeywordv(name), 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);
+    int32_t klen = janet_string_length(keyw);
+    int32_t flen = (int32_t) strlen(flags);
+    if (flen > 64) {
+        flen = 64;
+    }
+    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;
+            }
+        }
+        janet_panicf("unexpected flag %c, expected one of \"%s\"", (char) keyw[j], flags);
+    found:
+        ;
+    }
+    return ret;
+}
+
+int32_t janet_optnat(const Janet *argv, int32_t argc, int32_t n, int32_t dflt) {
+    if (argc <= n) return dflt;
+    if (janet_checktype(argv[n], JANET_NIL)) return dflt;
+    return janet_getnat(argv, n);
+}
+
+int32_t janet_optinteger(const Janet *argv, int32_t argc, int32_t n, int32_t dflt) {
+    if (argc <= n) return dflt;
+    if (janet_checktype(argv[n], JANET_NIL)) return dflt;
+    return janet_getinteger(argv, n);
+}
+
+int64_t janet_optinteger64(const Janet *argv, int32_t argc, int32_t n, int64_t dflt) {
+    if (argc <= n) return dflt;
+    if (janet_checktype(argv[n], JANET_NIL)) return dflt;
+    return janet_getinteger64(argv, n);
+}
+
+size_t janet_optsize(const Janet *argv, int32_t argc, int32_t n, size_t dflt) {
+    if (argc <= n) return dflt;
+    if (janet_checktype(argv[n], JANET_NIL)) return dflt;
+    return janet_getsize(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;
+    return janet_getabstract(argv, n, at);
+}
+
+/* Some definitions for function-like macros */
+
+JANET_API JanetStructHead *(janet_struct_head)(const JanetKV *st) {
+    return janet_struct_head(st);
+}
+
+JANET_API JanetAbstractHead *(janet_abstract_head)(const void *abstract) {
+    return janet_abstract_head(abstract);
+}
+
+JANET_API JanetStringHead *(janet_string_head)(const uint8_t *s) {
+    return janet_string_head(s);
+}
+
+JANET_API JanetTupleHead *(janet_tuple_head)(const Janet *tuple) {
+    return janet_tuple_head(tuple);
+}

src/core/cfuns.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,19 +20,32 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "compile.h"
 #include "emit.h"
 #include "vector.h"
+#endif
 
-static int fixarity0(JanetFopts opts, JanetSlot *args) {
+static int arity1or2(JanetFopts opts, JanetSlot *args) {
     (void) opts;
-    return janet_v_count(args) == 0;
+    int32_t arity = janet_v_count(args);
+    return arity == 1 || arity == 2;
+}
+static int arity2or3(JanetFopts opts, JanetSlot *args) {
+    (void) opts;
+    int32_t arity = janet_v_count(args);
+    return arity == 2 || arity == 3;
 }
 static int fixarity1(JanetFopts opts, JanetSlot *args) {
     (void) opts;
     return janet_v_count(args) == 1;
 }
+static int maxarity1(JanetFopts opts, JanetSlot *args) {
+    (void) opts;
+    return janet_v_count(args) <= 1;
+}
 static int minarity2(JanetFopts opts, JanetSlot *args) {
     (void) opts;
     return janet_v_count(args) >= 2;
@@ -60,65 +73,175 @@ static JanetSlot genericSSI(JanetFopts opts, int op, JanetSlot s, int32_t imm) {
     return target;
 }
 
+/* Emit an insruction that implements a form by itself. */
+static JanetSlot opfunction(
+    JanetFopts opts,
+    JanetSlot *args,
+    int op,
+    Janet defaultArg2) {
+    JanetCompiler *c = opts.compiler;
+    int32_t len;
+    len = janet_v_count(args);
+    JanetSlot t;
+    if (len == 1) {
+        t = janetc_gettarget(opts);
+        janetc_emit_sss(c, op, t, args[0], janetc_cslot(defaultArg2), 1);
+        return t;
+    } else {
+        /* len == 2 */
+        t = janetc_gettarget(opts);
+        janetc_emit_sss(c, op, t, args[0], args[1], 1);
+    }
+    return t;
+}
+
+/* Check if a value can be coerced to an immediate value */
+static int can_be_imm(Janet x, int8_t *out) {
+    if (!janet_checkint(x)) return 0;
+    int32_t integer = janet_unwrap_integer(x);
+    if (integer > 127 || integer < -127) return 0;
+    *out = (int8_t) integer;
+    return 1;
+}
+
+/* Check if a slot can be coerced to an immediate value */
+static int can_slot_be_imm(JanetSlot s, int8_t *out) {
+    if (!(s.flags & JANET_SLOT_CONSTANT)) return 0;
+    return can_be_imm(s.constant, out);
+}
+
 /* Emit a series of instructions instead of a function call to a math op */
 static JanetSlot opreduce(
-        JanetFopts opts,
-        JanetSlot *args,
-        int op,
-        Janet nullary) {
+    JanetFopts opts,
+    JanetSlot *args,
+    int op,
+    int opim,
+    Janet nullary) {
     JanetCompiler *c = opts.compiler;
     int32_t i, len;
+    int8_t imm = 0;
+    int neg = opim < 0;
+    if (opim < 0) opim = -opim;
     len = janet_v_count(args);
     JanetSlot t;
     if (len == 0) {
         return janetc_cslot(nullary);
     } else if (len == 1) {
         t = janetc_gettarget(opts);
-        janetc_emit_sss(c, op, t, janetc_cslot(nullary), args[0], 1);
+        /* Special case subtract to be times -1 */
+        if (op == JOP_SUBTRACT) {
+            janetc_emit_ssi(c, JOP_MULTIPLY_IMMEDIATE, t, args[0], -1, 1);
+        } else {
+            janetc_emit_sss(c, op, t, janetc_cslot(nullary), args[0], 1);
+        }
         return t;
     }
     t = janetc_gettarget(opts);
-    janetc_emit_sss(c, op, t, args[0], args[1], 1);
-    for (i = 2; i < len; i++)
-        janetc_emit_sss(c, op, t, t, args[i], 1);
+    if (opim && can_slot_be_imm(args[1], &imm)) {
+        janetc_emit_ssi(c, opim, t, args[0], neg ? -imm : imm, 1);
+    } else {
+        janetc_emit_sss(c, op, t, args[0], args[1], 1);
+    }
+    for (i = 2; i < len; i++) {
+        if (opim && can_slot_be_imm(args[i], &imm)) {
+            janetc_emit_ssi(c, opim, t, t, neg ? -imm : imm, 1);
+        } else {
+            janetc_emit_sss(c, op, t, t, args[i], 1);
+        }
+    }
     return t;
 }
 
 /* Function optimizers */
 
+static JanetSlot do_propagate(JanetFopts opts, JanetSlot *args) {
+    return opreduce(opts, args, JOP_PROPAGATE, 0, janet_wrap_nil());
+}
 static JanetSlot do_error(JanetFopts opts, JanetSlot *args) {
     janetc_emit_s(opts.compiler, JOP_ERROR, args[0], 0);
     return janetc_cslot(janet_wrap_nil());
 }
 static JanetSlot do_debug(JanetFopts opts, JanetSlot *args) {
     (void)args;
-    janetc_emit(opts.compiler, JOP_SIGNAL | (2 << 24));
-    return janetc_cslot(janet_wrap_nil());
+    int32_t len = janet_v_count(args);
+    JanetSlot t = janetc_gettarget(opts);
+    janetc_emit_ssu(opts.compiler, JOP_SIGNAL, t,
+                    (len == 1) ? args[0] : janetc_cslot(janet_wrap_nil()),
+                    JANET_SIGNAL_DEBUG,
+                    1);
+    return t;
+}
+static JanetSlot do_in(JanetFopts opts, JanetSlot *args) {
+    return opreduce(opts, args, JOP_IN, 0, janet_wrap_nil());
 }
 static JanetSlot do_get(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_GET, janet_wrap_nil());
+    if (janet_v_count(args) == 3) {
+        JanetCompiler *c = opts.compiler;
+        JanetSlot t = janetc_gettarget(opts);
+        int target_is_default = janetc_sequal(t, args[2]);
+        JanetSlot dflt_slot = args[2];
+        if (target_is_default) {
+            dflt_slot = janetc_farslot(c);
+            janetc_copy(c, dflt_slot, t);
+        }
+        janetc_emit_sss(c, JOP_GET, t, args[0], args[1], 1);
+        int32_t label = janetc_emit_si(c, JOP_JUMP_IF_NOT_NIL, t, 0, 0);
+        janetc_copy(c, t, dflt_slot);
+        if (target_is_default) janetc_freeslot(c, dflt_slot);
+        int32_t current = janet_v_count(c->buffer);
+        c->buffer[label] |= (current - label) << 16;
+        return t;
+    } else {
+        return opreduce(opts, args, JOP_GET, 0, janet_wrap_nil());
+    }
+}
+static JanetSlot do_next(JanetFopts opts, JanetSlot *args) {
+    return opfunction(opts, args, JOP_NEXT, janet_wrap_nil());
+}
+static JanetSlot do_modulo(JanetFopts opts, JanetSlot *args) {
+    return opreduce(opts, args, JOP_MODULO, 0, janet_wrap_nil());
+}
+static JanetSlot do_remainder(JanetFopts opts, JanetSlot *args) {
+    return opreduce(opts, args, JOP_REMAINDER, 0, janet_wrap_nil());
+}
+static JanetSlot do_cmp(JanetFopts opts, JanetSlot *args) {
+    return opreduce(opts, args, JOP_COMPARE, 0, janet_wrap_nil());
 }
 static JanetSlot do_put(JanetFopts opts, JanetSlot *args) {
-    janetc_emit_sss(opts.compiler, JOP_PUT, args[0], args[1], args[2], 0);
-    return args[0];
+    if (opts.flags & JANET_FOPTS_DROP) {
+        janetc_emit_sss(opts.compiler, JOP_PUT, args[0], args[1], args[2], 0);
+        return janetc_cslot(janet_wrap_nil());
+    } else {
+        JanetSlot t = janetc_gettarget(opts);
+        janetc_copy(opts.compiler, t, args[0]);
+        janetc_emit_sss(opts.compiler, JOP_PUT, t, args[1], args[2], 0);
+        return t;
+    }
 }
 static JanetSlot do_length(JanetFopts opts, JanetSlot *args) {
     return genericSS(opts, JOP_LENGTH, args[0]);
 }
 static JanetSlot do_yield(JanetFopts opts, JanetSlot *args) {
-    return genericSSI(opts, JOP_SIGNAL, args[0], 3);
+    if (janet_v_count(args) == 0) {
+        return genericSSI(opts, JOP_SIGNAL, janetc_cslot(janet_wrap_nil()), 3);
+    } else {
+        return genericSSI(opts, JOP_SIGNAL, args[0], 3);
+    }
 }
 static JanetSlot do_resume(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_RESUME, janet_wrap_nil());
+    return opfunction(opts, args, JOP_RESUME, janet_wrap_nil());
+}
+static JanetSlot do_cancel(JanetFopts opts, JanetSlot *args) {
+    return opfunction(opts, args, JOP_CANCEL, janet_wrap_nil());
 }
 static JanetSlot do_apply(JanetFopts opts, JanetSlot *args) {
     /* Push phase */
     JanetCompiler *c = opts.compiler;
     int32_t i;
     for (i = 1; i < janet_v_count(args) - 3; i += 3)
-        janetc_emit_sss(c, JOP_PUSH_3, args[i], args[i+1], args[i+2], 0);
+        janetc_emit_sss(c, JOP_PUSH_3, args[i], args[i + 1], args[i + 2], 0);
     if (i == janet_v_count(args) - 3)
-        janetc_emit_ss(c, JOP_PUSH_2, args[i], args[i+1], 0);
+        janetc_emit_ss(c, JOP_PUSH_2, args[i], args[i + 1], 0);
     else if (i == janet_v_count(args) - 2)
         janetc_emit_s(c, JOP_PUSH, args[i], 0);
     /* Push array phase */
@@ -139,34 +262,34 @@ static JanetSlot do_apply(JanetFopts opts, JanetSlot *args) {
 /* Variadic operators specialization */
 
 static JanetSlot do_add(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_ADD, janet_wrap_integer(0));
+    return opreduce(opts, args, JOP_ADD, JOP_ADD_IMMEDIATE, janet_wrap_integer(0));
 }
 static JanetSlot do_sub(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_SUBTRACT, janet_wrap_integer(0));
+    return opreduce(opts, args, JOP_SUBTRACT, -JOP_ADD_IMMEDIATE, janet_wrap_integer(0));
 }
 static JanetSlot do_mul(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_MULTIPLY, janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_MULTIPLY, JOP_MULTIPLY_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_div(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_DIVIDE, janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_DIVIDE, JOP_DIVIDE_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_band(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_BAND, janet_wrap_integer(-1));
+    return opreduce(opts, args, JOP_BAND, 0, janet_wrap_integer(-1));
 }
 static JanetSlot do_bor(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_BOR, janet_wrap_integer(0));
+    return opreduce(opts, args, JOP_BOR, 0, janet_wrap_integer(0));
 }
 static JanetSlot do_bxor(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_BXOR, janet_wrap_integer(0));
+    return opreduce(opts, args, JOP_BXOR, 0, janet_wrap_integer(0));
 }
 static JanetSlot do_lshift(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_SHIFT_LEFT, janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_SHIFT_LEFT, JOP_SHIFT_LEFT_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_rshift(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_SHIFT_RIGHT, janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_SHIFT_RIGHT, JOP_SHIFT_RIGHT_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_rshiftu(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_SHIFT_RIGHT, janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_SHIFT_RIGHT_UNSIGNED, JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_bnot(JanetFopts opts, JanetSlot *args) {
     return genericSS(opts, JOP_BNOT, args[0]);
@@ -174,35 +297,35 @@ static JanetSlot do_bnot(JanetFopts opts, JanetSlot *args) {
 
 /* Specialization for comparators */
 static JanetSlot compreduce(
-        JanetFopts opts,
-        JanetSlot *args,
-        int op,
-        int invert) {
+    JanetFopts opts,
+    JanetSlot *args,
+    int op,
+    int opim,
+    int invert) {
     JanetCompiler *c = opts.compiler;
     int32_t i, len;
+    int8_t imm = 0;
     len = janet_v_count(args);
     int32_t *labels = NULL;
     JanetSlot t;
     if (len < 2) {
         return invert
-            ? janetc_cslot(janet_wrap_false())
-            : janetc_cslot(janet_wrap_true());
+               ? janetc_cslot(janet_wrap_false())
+               : janetc_cslot(janet_wrap_true());
     }
     t = janetc_gettarget(opts);
     for (i = 1; i < len; i++) {
-        janetc_emit_sss(c, op, t, args[i - 1], args[i], 1);
+        if (opim && can_slot_be_imm(args[i], &imm)) {
+            janetc_emit_ssi(c, opim, t, args[i - 1], imm, 1);
+        } else {
+            janetc_emit_sss(c, op, t, args[i - 1], args[i], 1);
+        }
         if (i != (len - 1)) {
-            int32_t label = janetc_emit_si(c, JOP_JUMP_IF_NOT, t, 0, 1);
+            int32_t label = janetc_emit_si(c, invert ? JOP_JUMP_IF : JOP_JUMP_IF_NOT, t, 0, 1);
             janet_v_push(labels, label);
         }
     }
     int32_t end = janet_v_count(c->buffer);
-    if (invert) {
-        janetc_emit_si(c, JOP_JUMP_IF, t, 3, 0);
-        janetc_emit_s(c, JOP_LOAD_TRUE, t, 1);
-        janetc_emit(c, JOP_JUMP | (2 << 8));
-        janetc_emit_s(c, JOP_LOAD_FALSE, t, 1);
-    }
     for (i = 0; i < janet_v_count(labels); i++) {
         int32_t label = labels[i];
         c->buffer[label] |= ((end - label) << 16);
@@ -211,51 +334,33 @@ static JanetSlot compreduce(
     return t;
 }
 
-static JanetSlot do_order_gt(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_GREATER_THAN, 0);
-}
-static JanetSlot do_order_lt(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_LESS_THAN, 0);
-}
-static JanetSlot do_order_gte(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_LESS_THAN, 1);
-}
-static JanetSlot do_order_lte(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_GREATER_THAN, 1);
-}
-static JanetSlot do_order_eq(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_EQUALS, 0);
-}
-static JanetSlot do_order_neq(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_EQUALS, 1);
-}
 static JanetSlot do_gt(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_NUMERIC_GREATER_THAN, 0);
+    return compreduce(opts, args, JOP_GREATER_THAN, JOP_GREATER_THAN_IMMEDIATE, 0);
 }
 static JanetSlot do_lt(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_NUMERIC_LESS_THAN, 0);
+    return compreduce(opts, args, JOP_LESS_THAN, JOP_LESS_THAN_IMMEDIATE, 0);
 }
 static JanetSlot do_gte(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_NUMERIC_GREATER_THAN_EQUAL, 0);
+    return compreduce(opts, args, JOP_GREATER_THAN_EQUAL, 0, 0);
 }
 static JanetSlot do_lte(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_NUMERIC_LESS_THAN_EQUAL, 0);
+    return compreduce(opts, args, JOP_LESS_THAN_EQUAL, 0, 0);
 }
 static JanetSlot do_eq(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_NUMERIC_EQUAL, 0);
+    return compreduce(opts, args, JOP_EQUALS, JOP_EQUALS_IMMEDIATE, 0);
 }
 static JanetSlot do_neq(JanetFopts opts, JanetSlot *args) {
-    return compreduce(opts, args, JOP_NUMERIC_EQUAL, 1);
+    return compreduce(opts, args, JOP_NOT_EQUALS, JOP_NOT_EQUALS_IMMEDIATE, 1);
 }
 
 /* Arranged by tag */
 static const JanetFunOptimizer optimizers[] = {
-    {fixarity0, do_debug},
+    {maxarity1, do_debug},
     {fixarity1, do_error},
     {minarity2, do_apply},
-    {fixarity1, do_yield},
-    {fixarity2, do_resume},
-    {fixarity2, do_get},
+    {maxarity1, do_yield},
+    {arity1or2, do_resume},
+    {fixarity2, do_in},
     {fixarity3, do_put},
     {fixarity1, do_length},
     {NULL, do_add},
@@ -269,18 +374,19 @@ static const JanetFunOptimizer optimizers[] = {
     {NULL, do_rshift},
     {NULL, do_rshiftu},
     {fixarity1, do_bnot},
-    {NULL, do_order_gt},
-    {NULL, do_order_lt},
-    {NULL, do_order_gte},
-    {NULL, do_order_lte},
-    {NULL, do_order_eq},
-    {NULL, do_order_neq},
     {NULL, do_gt},
     {NULL, do_lt},
     {NULL, do_gte},
     {NULL, do_lte},
     {NULL, do_eq},
-    {NULL, do_neq}
+    {NULL, do_neq},
+    {fixarity2, do_propagate},
+    {arity2or3, do_get},
+    {arity1or2, do_next},
+    {fixarity2, do_modulo},
+    {fixarity2, do_remainder},
+    {fixarity2, do_cmp},
+    {fixarity2, do_cancel},
 };
 
 const JanetFunOptimizer *janetc_funopt(uint32_t flags) {
@@ -288,7 +394,7 @@ const JanetFunOptimizer *janetc_funopt(uint32_t flags) {
     if (tag == 0)
         return NULL;
     uint32_t index = tag - 1;
-    if (index >= (sizeof(optimizers)/sizeof(optimizers[0])))
+    if (index >= (sizeof(optimizers) / sizeof(optimizers[0])))
         return NULL;
     return optimizers + index;
 }

src/core/compile.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,11 +20,15 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "compile.h"
 #include "emit.h"
 #include "vector.h"
 #include "util.h"
+#include "state.h"
+#endif
 
 JanetFopts janetc_fopts_default(JanetCompiler *c) {
     JanetFopts ret;
@@ -49,6 +53,36 @@ void janetc_cerror(JanetCompiler *c, const char *m) {
     janetc_error(c, janet_cstring(m));
 }
 
+static const char *janet_lint_level_names[] = {
+    "relaxed",
+    "normal",
+    "strict"
+};
+
+/* Emit compiler linter messages */
+void janetc_lintf(JanetCompiler *c, JanetCompileLintLevel level, const char *format, ...) {
+    if (NULL != c->lints) {
+        /* format message */
+        va_list args;
+        JanetBuffer buffer;
+        int32_t len = 0;
+        while (format[len]) len++;
+        janet_buffer_init(&buffer, len);
+        va_start(args, format);
+        janet_formatbv(&buffer, format, args);
+        va_end(args);
+        const uint8_t *str = janet_string(buffer.data, buffer.count);
+        janet_buffer_deinit(&buffer);
+        /* construct linting payload */
+        Janet *payload = janet_tuple_begin(4);
+        payload[0] = janet_ckeywordv(janet_lint_level_names[level]);
+        payload[1] = c->current_mapping.line == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.line);
+        payload[2] = c->current_mapping.column == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.column);
+        payload[3] = janet_wrap_string(str);
+        janet_array_push(c->lints, janet_wrap_tuple(janet_tuple_end(payload)));
+    }
+}
+
 /* Free a slot */
 void janetc_freeslot(JanetCompiler *c, JanetSlot s) {
     if (s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF | JANET_SLOT_NAMED)) return;
@@ -95,10 +129,10 @@ void janetc_scope(JanetScope *s, JanetCompiler *c, int flags, const char *name)
     scope.syms = NULL;
     scope.envs = NULL;
     scope.defs = NULL;
-    scope.selfconst = -1;
     scope.bytecode_start = janet_v_count(c->buffer);
     scope.flags = flags;
     scope.parent = c->scope;
+    janetc_regalloc_init(&scope.ua);
     /* Inherit slots */
     if ((!(flags & JANET_SCOPE_FUNCTION)) && c->scope) {
         janetc_regalloc_clone(&scope.ra, &(c->scope->ra));
@@ -146,6 +180,7 @@ void janetc_popscope(JanetCompiler *c) {
     janet_v_free(oldscope->envs);
     janet_v_free(oldscope->defs);
     janetc_regalloc_deinit(&oldscope->ra);
+    janetc_regalloc_deinit(&oldscope->ua);
     /* Update pointer */
     if (newscope)
         newscope->child = NULL;
@@ -162,10 +197,43 @@ void janetc_popscope_keepslot(JanetCompiler *c, JanetSlot retslot) {
     }
 }
 
+static int lookup_missing(
+    JanetCompiler *c,
+    const uint8_t *sym,
+    JanetFunction *handler,
+    JanetBinding *out) {
+    int32_t minar = handler->def->min_arity;
+    int32_t maxar = handler->def->max_arity;
+    if (minar > 1 || maxar < 1) {
+        janetc_error(c, janet_cstring("missing symbol lookup handler must take 1 argument"));
+        return 0;
+    }
+    Janet args[1] = { janet_wrap_symbol(sym) };
+    JanetFiber *fiberp = janet_fiber(handler, 64, 1, args);
+    if (NULL == fiberp) {
+        janetc_error(c, janet_cstring("failed to call missing symbol lookup handler"));
+        return 0;
+    }
+    fiberp->env = c->env;
+    int lock = janet_gclock();
+    Janet tempOut;
+    JanetSignal status = janet_continue(fiberp, janet_wrap_nil(), &tempOut);
+    janet_gcunlock(lock);
+    if (status != JANET_SIGNAL_OK) {
+        janetc_error(c, janet_formatc("(lookup) %V", tempOut));
+        return 0;
+    }
+
+    /* Convert return value as entry. */
+    /* Alternative could use janet_resolve_ext(c->env, sym) to read result from environment. */
+    *out = janet_binding_from_entry(tempOut);
+    return 1;
+}
+
 /* Allow searching for symbols. Return information about the symbol */
 JanetSlot janetc_resolve(
-        JanetCompiler *c,
-        const uint8_t *sym) {
+    JanetCompiler *c,
+    const uint8_t *sym) {
 
     JanetSlot ret = janetc_cslot(janet_wrap_nil());
     JanetScope *scope = c->scope;
@@ -194,29 +262,66 @@ JanetSlot janetc_resolve(
 
     /* Symbol not found - check for global */
     {
-        Janet check;
-        JanetBindingType btype = janet_resolve(c->env, sym, &check);
-        switch (btype) {
+        JanetBinding binding = janet_resolve_ext(c->env, sym);
+        if (binding.type == JANET_BINDING_NONE) {
+            Janet handler = janet_table_get(c->env, janet_ckeywordv("missing-symbol"));
+            switch (janet_type(handler)) {
+                case JANET_NIL:
+                    break;
+                case JANET_FUNCTION:
+                    if (!lookup_missing(c, sym, janet_unwrap_function(handler), &binding))
+                        return janetc_cslot(janet_wrap_nil());
+                    break;
+                default:
+                    janetc_error(c, janet_formatc("invalid lookup handler %V", handler));
+                    return janetc_cslot(janet_wrap_nil());
+            }
+        }
+
+        switch (binding.type) {
             default:
             case JANET_BINDING_NONE:
-                janetc_error(c, janet_formatc("unknown symbol %q", sym));
+                janetc_error(c, janet_formatc("unknown symbol %q", janet_wrap_symbol(sym)));
                 return janetc_cslot(janet_wrap_nil());
             case JANET_BINDING_DEF:
             case JANET_BINDING_MACRO: /* Macro should function like defs when not in calling pos */
-                return janetc_cslot(check);
-            case JANET_BINDING_VAR:
-            {
-                JanetSlot ret = janetc_cslot(check);
-                /* TODO save type info */
+                ret = janetc_cslot(binding.value);
+                break;
+            case JANET_BINDING_DYNAMIC_DEF:
+            case JANET_BINDING_DYNAMIC_MACRO:
+                ret = janetc_cslot(binding.value);
+                ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOTTYPE_ANY;
+                ret.flags &= ~JANET_SLOT_CONSTANT;
+                break;
+            case JANET_BINDING_VAR: {
+                ret = janetc_cslot(binding.value);
                 ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOT_MUTABLE | JANET_SLOTTYPE_ANY;
                 ret.flags &= ~JANET_SLOT_CONSTANT;
-                return ret;
+                break;
             }
         }
+        JanetCompileLintLevel depLevel = JANET_C_LINT_RELAXED;
+        switch (binding.deprecation) {
+            case JANET_BINDING_DEP_NONE:
+                break;
+            case JANET_BINDING_DEP_RELAXED:
+                depLevel = JANET_C_LINT_RELAXED;
+                break;
+            case JANET_BINDING_DEP_NORMAL:
+                depLevel = JANET_C_LINT_NORMAL;
+                break;
+            case JANET_BINDING_DEP_STRICT:
+                depLevel = JANET_C_LINT_STRICT;
+                break;
+        }
+        if (binding.deprecation != JANET_BINDING_DEP_NONE) {
+            janetc_lintf(c, depLevel, "%q is deprecated", janet_wrap_symbol(sym));
+        }
+        return ret;
     }
 
     /* Symbol was found */
-    found:
+found:
 
     /* Constants can be returned immediately (they are stateless) */
     if (ret.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF))
@@ -234,6 +339,11 @@ JanetSlot janetc_resolve(
         scope = scope->parent;
     janet_assert(scope, "invalid scopes");
     scope->flags |= JANET_SCOPE_ENV;
+
+    /* In the function scope, allocate the slot as an upvalue */
+    janetc_regalloc_touch(&scope->ua, ret.index);
+
+    /* Iterate through child scopes and make sure environment is propagated */
     scope = scope->child;
 
     /* Propagate env up to current scope */
@@ -281,8 +391,8 @@ JanetSlot janetc_return(JanetCompiler *c, JanetSlot s) {
 JanetSlot janetc_gettarget(JanetFopts opts) {
     JanetSlot slot;
     if ((opts.flags & JANET_FOPTS_HINT) &&
-        (opts.hint.envindex < 0) &&
-        (opts.hint.index >= 0 && opts.hint.index <= 0xFF)) {
+            (opts.hint.envindex < 0) &&
+            (opts.hint.index >= 0 && opts.hint.index <= 0xFF)) {
         slot = opts.hint;
     } else {
         slot.envindex = -1;
@@ -309,9 +419,9 @@ JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds) {
     JanetSlot *ret = NULL;
     JanetFopts subopts = janetc_fopts_default(c);
     const JanetKV *kvs = NULL;
-    int32_t cap, i, len;
+    int32_t cap = 0, len = 0;
     janet_dictionary_view(ds, &kvs, &len, &cap);
-    for (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));
@@ -319,33 +429,46 @@ JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds) {
     return ret;
 }
 
-/* Push slots load via janetc_toslots. */
-void janetc_pushslots(JanetCompiler *c, JanetSlot *slots) {
+/* Push slots loaded via janetc_toslots. Return the minimum number of slots pushed,
+ * or -1 - min_arity if there is a splice. (if there is no splice, min_arity is also
+ * the maximum possible arity). */
+int32_t janetc_pushslots(JanetCompiler *c, JanetSlot *slots) {
     int32_t i;
     int32_t count = janet_v_count(slots);
+    int32_t min_arity = 0;
+    int has_splice = 0;
     for (i = 0; i < count;) {
         if (slots[i].flags & JANET_SLOT_SPLICED) {
             janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i], 0);
             i++;
+            has_splice = 1;
         } else if (i + 1 == count) {
             janetc_emit_s(c, JOP_PUSH, slots[i], 0);
             i++;
+            min_arity++;
         } else if (slots[i + 1].flags & JANET_SLOT_SPLICED) {
             janetc_emit_s(c, JOP_PUSH, slots[i], 0);
-            janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i+1], 0);
+            janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i + 1], 0);
             i += 2;
+            min_arity++;
+            has_splice = 1;
         } else if (i + 2 == count) {
-            janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i+1], 0);
+            janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0);
             i += 2;
+            min_arity += 2;
         } else if (slots[i + 2].flags & JANET_SLOT_SPLICED) {
-            janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i+1], 0);
-            janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i+2], 0);
+            janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0);
+            janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i + 2], 0);
             i += 3;
+            min_arity += 2;
+            has_splice = 1;
         } else {
-            janetc_emit_sss(c, JOP_PUSH_3, slots[i], slots[i+1], slots[i+2], 0);
+            janetc_emit_sss(c, JOP_PUSH_3, slots[i], slots[i + 1], slots[i + 2], 0);
             i += 3;
+            min_arity += 3;
         }
     }
+    return has_splice ? (-1 - min_arity) : min_arity;
 }
 
 /* Check if a list of slots has any spliced slots */
@@ -377,6 +500,7 @@ void janetc_throwaway(JanetFopts opts, Janet x) {
     int32_t mapbufstart = janet_v_count(c->mapbuffer);
     janetc_scope(&unusedScope, c, JANET_SCOPE_UNUSED, "unusued");
     janetc_value(opts, x);
+    janetc_lintf(c, JANET_C_LINT_STRICT, "dead code, consider removing %.2q", x);
     janetc_popscope(c);
     if (c->buffer) {
         janet_v__cnt(c->buffer) = bufstart;
@@ -402,8 +526,71 @@ static JanetSlot janetc_call(JanetFopts opts, JanetSlot *slots, JanetSlot fun) {
         /* TODO janet function inlining (no c functions)*/
     }
     if (!specialized) {
-        janetc_pushslots(c, slots);
-        if (opts.flags & JANET_FOPTS_TAIL) {
+        int32_t min_arity = janetc_pushslots(c, slots);
+        /* Check for provably incorrect function calls */
+        if (fun.flags & JANET_SLOT_CONSTANT) {
+
+            /* Check for bad arity type if fun is a constant */
+            switch (janet_type(fun.constant)) {
+                case JANET_FUNCTION: {
+                    JanetFunction *f = janet_unwrap_function(fun.constant);
+                    int32_t min = f->def->min_arity;
+                    int32_t max = f->def->max_arity;
+                    if (min_arity < 0) {
+                        /* Call has splices */
+                        min_arity = -1 - min_arity;
+                        if (min_arity > max && max >= 0) {
+                            const uint8_t *es = janet_formatc(
+                                                    "%v expects at most %d argument%s, got at least %d",
+                                                    fun.constant, max, max == 1 ? "" : "s", min_arity);
+                            janetc_error(c, es);
+                        }
+                    } else {
+                        /* Call has no splices */
+                        if (min_arity > max && max >= 0) {
+                            const uint8_t *es = janet_formatc(
+                                                    "%v expects at most %d argument%s, got %d",
+                                                    fun.constant, max, max == 1 ? "" : "s", min_arity);
+                            janetc_error(c, es);
+                        }
+                        if (min_arity < min) {
+                            const uint8_t *es = janet_formatc(
+                                                    "%v expects at least %d argument%s, got %d",
+                                                    fun.constant, min, min == 1 ? "" : "s", min_arity);
+                            janetc_error(c, es);
+                        }
+                    }
+                }
+                break;
+                case JANET_CFUNCTION:
+                case JANET_ABSTRACT:
+                case JANET_NIL:
+                    break;
+                case JANET_KEYWORD:
+                    if (min_arity == 0) {
+                        const uint8_t *es = janet_formatc("%v expects at least 1 argument, got 0",
+                                                          fun.constant);
+                        janetc_error(c, es);
+                    }
+                    break;
+                default:
+                    if (min_arity > 1 || min_arity == 0) {
+                        const uint8_t *es = janet_formatc("%v expects 1 argument, got %d",
+                                                          fun.constant, min_arity);
+                        janetc_error(c, es);
+                    }
+                    if (min_arity < -2) {
+                        const uint8_t *es = janet_formatc("%v expects 1 argument, got at least %d",
+                                                          fun.constant, -1 - min_arity);
+                        janetc_error(c, es);
+                    }
+                    break;
+            }
+        }
+
+        if ((opts.flags & JANET_FOPTS_TAIL) &&
+                /* Prevent top level tail calls for better errors */
+                !(c->scope->flags & JANET_SCOPE_TOP)) {
             janetc_emit_s(c, JOP_TAILCALL, fun, 0);
             retslot = janetc_cslot(janet_wrap_nil());
             retslot.flags = JANET_SLOT_RETURNED;
@@ -419,10 +606,40 @@ static JanetSlot janetc_call(JanetFopts opts, JanetSlot *slots, JanetSlot fun) {
 static JanetSlot janetc_maker(JanetFopts opts, JanetSlot *slots, int op) {
     JanetCompiler *c = opts.compiler;
     JanetSlot retslot;
-    janetc_pushslots(c, slots);
-    janetc_freeslots(c, slots);
-    retslot = janetc_gettarget(opts);
-    janetc_emit_s(c, op, retslot, 1);
+
+    /* Check if this structure is composed entirely of constants */
+    int can_inline = 1;
+    for (int32_t i = 0; i < janet_v_count(slots); i++) {
+        if (!(slots[i].flags & JANET_SLOT_CONSTANT) ||
+                (slots[i].flags & JANET_SLOT_SPLICED)) {
+            can_inline = 0;
+            break;
+        }
+    }
+
+    if (can_inline && (op == JOP_MAKE_STRUCT)) {
+        JanetKV *st = janet_struct_begin(janet_v_count(slots) / 2);
+        for (int32_t i = 0; i < janet_v_count(slots); i += 2) {
+            Janet k = slots[i].constant;
+            Janet v = slots[i + 1].constant;
+            janet_struct_put(st, k, v);
+        }
+        retslot = janetc_cslot(janet_wrap_struct(janet_struct_end(st)));
+        janetc_freeslots(c, slots);
+    } else if (can_inline && (op == JOP_MAKE_TUPLE)) {
+        Janet *tup = janet_tuple_begin(janet_v_count(slots));
+        for (int32_t i = 0; i < janet_v_count(slots); i++) {
+            tup[i] = slots[i].constant;
+        }
+        retslot = janetc_cslot(janet_wrap_tuple(janet_tuple_end(tup)));
+        janetc_freeslots(c, slots);
+    } else {
+        janetc_pushslots(c, slots);
+        janetc_freeslots(c, slots);
+        retslot = janetc_gettarget(opts);
+        janetc_emit_s(c, op, retslot, 1);
+    }
+
     return retslot;
 }
 
@@ -430,15 +647,23 @@ static JanetSlot janetc_array(JanetFopts opts, Janet x) {
     JanetCompiler *c = opts.compiler;
     JanetArray *a = janet_unwrap_array(x);
     return janetc_maker(opts,
-            janetc_toslots(c, a->data, a->count),
-            JOP_MAKE_ARRAY);
+                        janetc_toslots(c, a->data, a->count),
+                        JOP_MAKE_ARRAY);
+}
+
+static JanetSlot janetc_tuple(JanetFopts opts, Janet x) {
+    JanetCompiler *c = opts.compiler;
+    const Janet *t = janet_unwrap_tuple(x);
+    return janetc_maker(opts,
+                        janetc_toslots(c, t, janet_tuple_length(t)),
+                        JOP_MAKE_TUPLE);
 }
 
 static JanetSlot janetc_tablector(JanetFopts opts, Janet x, int op) {
     JanetCompiler *c = opts.compiler;
     return janetc_maker(opts,
-            janetc_toslotskv(c, x),
-            op);
+                        janetc_toslotskv(c, x),
+                        op);
 }
 
 static JanetSlot janetc_bufferctor(JanetFopts opts, Janet x) {
@@ -446,27 +671,30 @@ static JanetSlot janetc_bufferctor(JanetFopts opts, Janet x) {
     JanetBuffer *b = janet_unwrap_buffer(x);
     Janet onearg = janet_stringv(b->data, b->count);
     return janetc_maker(opts,
-            janetc_toslots(c, &onearg, 1),
-            JOP_MAKE_BUFFER);
+                        janetc_toslots(c, &onearg, 1),
+                        JOP_MAKE_BUFFER);
 }
 
 /* Expand a macro one time. Also get the special form compiler if we
  * find that instead. */
 static int macroexpand1(
-        JanetCompiler *c,
-        Janet x,
-        Janet *out,
-        const JanetSpecial **spec) {
+    JanetCompiler *c,
+    Janet x,
+    Janet *out,
+    const JanetSpecial **spec) {
     if (!janet_checktype(x, JANET_TUPLE))
         return 0;
     const Janet *form = janet_unwrap_tuple(x);
     if (janet_tuple_length(form) == 0)
         return 0;
     /* Source map - only set when we get a tuple */
-    if (janet_tuple_sm_start(form) >= 0) {
-        c->current_mapping.start = janet_tuple_sm_start(form);
-        c->current_mapping.end = janet_tuple_sm_end(form);
+    if (janet_tuple_sm_line(form) >= 0) {
+        c->current_mapping.line = janet_tuple_sm_line(form);
+        c->current_mapping.column = janet_tuple_sm_column(form);
     }
+    /* Bracketed tuples are not specials or macros! */
+    if (janet_tuple_flag(form) & JANET_TUPLE_FLAG_BRACKETCTOR)
+        return 0;
     if (!janet_checktype(form[0], JANET_SYMBOL))
         return 0;
     const uint8_t *name = janet_unwrap_symbol(form[0]);
@@ -477,27 +705,45 @@ static int macroexpand1(
     }
     Janet macroval;
     JanetBindingType btype = janet_resolve(c->env, name, &macroval);
-    if (btype != JANET_BINDING_MACRO ||
+    if (!(btype == JANET_BINDING_MACRO || btype == JANET_BINDING_DYNAMIC_MACRO) ||
             !janet_checktype(macroval, JANET_FUNCTION))
         return 0;
 
     /* Evaluate macro */
-    JanetFiber *fiberp;
     JanetFunction *macro = janet_unwrap_function(macroval);
+    int32_t arity = janet_tuple_length(form) - 1;
+    JanetFiber *fiberp = janet_fiber(macro, 64, arity, form + 1);
+    if (NULL == fiberp) {
+        int32_t minar = macro->def->min_arity;
+        int32_t maxar = macro->def->max_arity;
+        const uint8_t *es = NULL;
+        if (minar >= 0 && arity < minar)
+            es = janet_formatc("macro arity mismatch, expected at least %d, got %d", minar, arity);
+        if (maxar >= 0 && arity > maxar)
+            es = janet_formatc("macro arity mismatch, expected at most %d, got %d", maxar, arity);
+        c->result.macrofiber = NULL;
+        janetc_error(c, es);
+        return 0;
+    }
+    /* Set env */
+    fiberp->env = c->env;
     int lock = janet_gclock();
-    JanetSignal status = janet_call(
-            macro,
-            janet_tuple_length(form) - 1,
-            form + 1,
-            &x,
-            &fiberp);
+    Janet mf_kw = janet_ckeywordv("macro-form");
+    janet_table_put(c->env, mf_kw, x);
+    Janet tempOut;
+    JanetSignal status = janet_continue(fiberp, janet_wrap_nil(), &tempOut);
+    janet_table_put(c->env, mf_kw, janet_wrap_nil());
+    if (c->lints) {
+        janet_table_put(c->env, janet_ckeywordv("macro-lints"), janet_wrap_array(c->lints));
+    }
     janet_gcunlock(lock);
     if (status != JANET_SIGNAL_OK) {
-        const uint8_t *es = janet_formatc("(macro) %V", x);
+        const uint8_t *es = janet_formatc("(macro) %V", tempOut);
         c->result.macrofiber = fiberp;
         janetc_error(c, es);
+        return 0;
     } else {
-        *out = x;
+        *out = tempOut;
     }
 
     return 1;
@@ -536,24 +782,25 @@ JanetSlot janetc_value(JanetFopts opts, Janet x) {
         ret = spec->compile(opts, janet_tuple_length(tup) - 1, tup + 1);
     } else {
         switch (janet_type(x)) {
-            case JANET_TUPLE:
-                {
-                    JanetFopts subopts = janetc_fopts_default(c);
-                    const Janet *tup = janet_unwrap_tuple(x);
-                    /* Empty tuple is tuple literal */
-                    if (janet_tuple_length(tup) == 0) {
-                        ret = janetc_cslot(x);
-                    } else {
-                        JanetSlot head = janetc_value(subopts, tup[0]);
-                        subopts.flags = JANET_FUNCTION | JANET_CFUNCTION;
-                        ret = janetc_call(opts, janetc_toslots(c, tup + 1, janet_tuple_length(tup) - 1), head);
-                        janetc_freeslot(c, head);
-                    }
-                    ret.flags &= ~JANET_SLOT_SPLICED;
+            case JANET_TUPLE: {
+                JanetFopts subopts = janetc_fopts_default(c);
+                const Janet *tup = janet_unwrap_tuple(x);
+                /* Empty tuple is tuple literal */
+                if (janet_tuple_length(tup) == 0) {
+                    ret = janetc_cslot(janet_wrap_tuple(janet_tuple_n(NULL, 0)));
+                } else if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { /* [] tuples are not function call */
+                    ret = janetc_tuple(opts, x);
+                } else {
+                    JanetSlot head = janetc_value(subopts, tup[0]);
+                    subopts.flags = JANET_FUNCTION | JANET_CFUNCTION;
+                    ret = janetc_call(opts, janetc_toslots(c, tup + 1, janet_tuple_length(tup) - 1), head);
+                    janetc_freeslot(c, head);
                 }
-                break;
+                ret.flags &= ~JANET_SLOT_SPLICED;
+            }
+            break;
             case JANET_SYMBOL:
-                ret = janetc_resolve(opts.compiler, janet_unwrap_symbol(x));
+                ret = janetc_resolve(c, janet_unwrap_symbol(x));
                 break;
             case JANET_ARRAY:
                 ret = janetc_array(opts, x);
@@ -576,17 +823,42 @@ JanetSlot janetc_value(JanetFopts opts, Janet x) {
     if (c->result.status == JANET_COMPILE_ERROR)
         return janetc_cslot(janet_wrap_nil());
     if (opts.flags & JANET_FOPTS_TAIL)
-        ret = janetc_return(opts.compiler, ret);
+        ret = janetc_return(c, ret);
     if (opts.flags & JANET_FOPTS_HINT) {
-        janetc_copy(opts.compiler, opts.hint, ret);
+        janetc_copy(c, opts.hint, ret);
         ret = opts.hint;
     }
     c->current_mapping = last_mapping;
-    opts.compiler->recursion_guard++;
+    c->recursion_guard++;
     return ret;
 }
 
+/* Add function flags to janet functions */
+void janet_def_addflags(JanetFuncDef *def) {
+    int32_t set_flags = 0;
+    int32_t unset_flags = 0;
+    /* pos checks */
+    if (def->name)            set_flags |= JANET_FUNCDEF_FLAG_HASNAME;
+    if (def->source)          set_flags |= JANET_FUNCDEF_FLAG_HASSOURCE;
+    if (def->defs)            set_flags |= JANET_FUNCDEF_FLAG_HASDEFS;
+    if (def->environments)    set_flags |= JANET_FUNCDEF_FLAG_HASENVS;
+    if (def->sourcemap)       set_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP;
+    if (def->closure_bitset)  set_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET;
+    /* negative checks */
+    if (!def->name)           unset_flags |= JANET_FUNCDEF_FLAG_HASNAME;
+    if (!def->source)         unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCE;
+    if (!def->defs)           unset_flags |= JANET_FUNCDEF_FLAG_HASDEFS;
+    if (!def->environments)   unset_flags |= JANET_FUNCDEF_FLAG_HASENVS;
+    if (!def->sourcemap)      unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP;
+    if (!def->closure_bitset) unset_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET;
+    /* Update flags */
+    def->flags |= set_flags;
+    def->flags &= ~unset_flags;
+}
+
 /* Compile a funcdef */
+/* Once the various other settings of the FuncDef have been tweaked,
+ * call janet_def_addflags to set the proper flags for the funcdef */
 JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
     JanetScope *scope = c->scope;
     JanetFuncDef *def = janet_funcdef_alloc();
@@ -607,20 +879,20 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
     /* Copy bytecode (only last chunk) */
     def->bytecode_length = janet_v_count(c->buffer) - scope->bytecode_start;
     if (def->bytecode_length) {
-        size_t s = sizeof(int32_t) * def->bytecode_length;
-        def->bytecode = malloc(s);
+        size_t s = sizeof(int32_t) * (size_t) def->bytecode_length;
+        def->bytecode = janet_malloc(s);
         if (NULL == def->bytecode) {
             JANET_OUT_OF_MEMORY;
         }
-        memcpy(def->bytecode, c->buffer + scope->bytecode_start, s);
+        safe_memcpy(def->bytecode, c->buffer + scope->bytecode_start, s);
         janet_v__cnt(c->buffer) = scope->bytecode_start;
-        if (NULL != c->mapbuffer) {
-            size_t s = sizeof(JanetSourceMapping) * def->bytecode_length;
-            def->sourcemap = malloc(s);
+        if (NULL != c->mapbuffer && c->source) {
+            size_t s = sizeof(JanetSourceMapping) * (size_t) def->bytecode_length;
+            def->sourcemap = janet_malloc(s);
             if (NULL == def->sourcemap) {
                 JANET_OUT_OF_MEMORY;
             }
-            memcpy(def->sourcemap, c->mapbuffer + scope->bytecode_start, s);
+            safe_memcpy(def->sourcemap, c->mapbuffer + scope->bytecode_start, s);
             janet_v__cnt(c->mapbuffer) = scope->bytecode_start;
         }
     }
@@ -629,11 +901,28 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
     def->source = c->source;
 
     def->arity = 0;
+    def->min_arity = 0;
     def->flags = 0;
     if (scope->flags & JANET_SCOPE_ENV) {
         def->flags |= JANET_FUNCDEF_FLAG_NEEDSENV;
     }
 
+    /* Copy upvalue bitset */
+    if (scope->ua.count) {
+        /* Number of u32s we need to create a bitmask for all slots */
+        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);
+        if (NULL == chunks) {
+            JANET_OUT_OF_MEMORY;
+        }
+        memcpy(chunks, scope->ua.chunks, sizeof(uint32_t) * numchunks);
+        /* Register allocator preallocates some registers [240-255, high 16 bits of chunk index 7], we can ignore those. */
+        if (scope->ua.count > 7) chunks[7] &= 0xFFFFU;
+        def->closure_bitset = chunks;
+    }
+
     /* Pop the scope */
     janetc_popscope(c);
 
@@ -641,22 +930,23 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
 }
 
 /* Initialize a compiler */
-static void janetc_init(JanetCompiler *c, JanetTable *env, const uint8_t *where) {
+static void janetc_init(JanetCompiler *c, JanetTable *env, const uint8_t *where, JanetArray *lints) {
     c->scope = NULL;
     c->buffer = NULL;
     c->mapbuffer = NULL;
     c->recursion_guard = JANET_RECURSION_GUARD;
     c->env = env;
     c->source = where;
-    c->current_mapping.start = -1;
-    c->current_mapping.end = -1;
+    c->current_mapping.line = -1;
+    c->current_mapping.column = -1;
+    c->lints = lints;
     /* Init result */
     c->result.error = NULL;
     c->result.status = JANET_COMPILE_OK;
     c->result.funcdef = NULL;
     c->result.macrofiber = NULL;
-    c->result.error_mapping.start = -1;
-    c->result.error_mapping.end = -1;
+    c->result.error_mapping.line = -1;
+    c->result.error_mapping.column = -1;
 }
 
 /* Deinitialize a compiler struct */
@@ -667,12 +957,13 @@ static void janetc_deinit(JanetCompiler *c) {
 }
 
 /* Compile a form. */
-JanetCompileResult janet_compile(Janet source, JanetTable *env, const uint8_t *where) {
+JanetCompileResult janet_compile_lint(Janet source,
+                                      JanetTable *env, const uint8_t *where, JanetArray *lints) {
     JanetCompiler c;
     JanetScope rootscope;
     JanetFopts fopts;
 
-    janetc_init(&c, env, where);
+    janetc_init(&c, env, where, lints);
 
     /* Push a function scope */
     janetc_scope(&rootscope, &c, JANET_SCOPE_FUNCTION | JANET_SCOPE_TOP, "root");
@@ -688,6 +979,7 @@ JanetCompileResult janet_compile(Janet source, JanetTable *env, const uint8_t *w
     if (c.result.status == JANET_COMPILE_OK) {
         JanetFuncDef *def = janetc_pop_funcdef(&c);
         def->name = janet_cstring("_thunk");
+        janet_def_addflags(def);
         c.result.funcdef = def;
     } else {
         c.result.error_mapping = c.current_mapping;
@@ -699,22 +991,49 @@ JanetCompileResult janet_compile(Janet source, JanetTable *env, const uint8_t *w
     return c.result;
 }
 
+JanetCompileResult janet_compile(Janet source, JanetTable *env, const uint8_t *where) {
+    return janet_compile_lint(source, env, where, NULL);
+}
+
 /* C Function for compiling */
-static Janet cfun(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 3);
-    JanetTable *env = janet_gettable(argv, 1);
-    const uint8_t *source = NULL;
-    if (argc == 3) {
-        source = janet_getstring(argv, 2);
+JANET_CORE_FN(cfun,
+              "(compile ast &opt env source lints)",
+              "Compiles an Abstract Syntax Tree (ast) into a function. "
+              "Pair the compile function with parsing functionality to implement "
+              "eval. Returns a new function and does not modify ast. Returns an error "
+              "struct with keys :line, :column, and :error if compilation fails. "
+              "If a `lints` array is given, linting messages will be appended to the array. "
+              "Each message will be a tuple of the form `(level line col message)`.") {
+    janet_arity(argc, 1, 4);
+    JanetTable *env = argc > 1 ? janet_gettable(argv, 1) : janet_vm.fiber->env;
+    if (NULL == env) {
+        env = janet_table(0);
+        janet_vm.fiber->env = env;
     }
-    JanetCompileResult res = janet_compile(argv[0], env, source);
+    const uint8_t *source = NULL;
+    if (argc >= 3) {
+        Janet x = argv[2];
+        if (janet_checktype(x, JANET_STRING)) {
+            source = janet_unwrap_string(x);
+        } else if (janet_checktype(x, JANET_KEYWORD)) {
+            source = janet_unwrap_keyword(x);
+        } else {
+            janet_panic_type(x, 2, JANET_TFLAG_STRING | JANET_TFLAG_KEYWORD);
+        }
+    }
+    JanetArray *lints = (argc >= 4) ? janet_getarray(argv, 3) : NULL;
+    JanetCompileResult res = janet_compile_lint(argv[0], env, source, lints);
     if (res.status == JANET_COMPILE_OK) {
         return janet_wrap_function(janet_thunk(res.funcdef));
     } else {
         JanetTable *t = janet_table(4);
         janet_table_put(t, janet_ckeywordv("error"), janet_wrap_string(res.error));
-        janet_table_put(t, janet_ckeywordv("start"), janet_wrap_integer(res.error_mapping.start));
-        janet_table_put(t, janet_ckeywordv("end"), janet_wrap_integer(res.error_mapping.end));
+        if (res.error_mapping.line > 0) {
+            janet_table_put(t, janet_ckeywordv("line"), janet_wrap_integer(res.error_mapping.line));
+        }
+        if (res.error_mapping.column > 0) {
+            janet_table_put(t, janet_ckeywordv("column"), janet_wrap_integer(res.error_mapping.column));
+        }
         if (res.macrofiber) {
             janet_table_put(t, janet_ckeywordv("fiber"), janet_wrap_fiber(res.macrofiber));
         }
@@ -722,17 +1041,10 @@ static Janet cfun(int32_t argc, Janet *argv) {
     }
 }
 
-static const JanetReg cfuns[] = {
-    {"compile", cfun,
-        JDOC("(compile ast env [, source])\n\n"
-                "Compiles an Abstract Syntax Tree (ast) into a janet function. "
-                "Pair the compile function with parsing functionality to implement "
-                "eval. Returns a janet function and does not modify ast. Throws an "
-                "error if the ast cannot be compiled.")
-    },
-    {NULL, NULL, NULL}
-};
-
 void janet_lib_compile(JanetTable *env) {
-    janet_cfuns(env, NULL, cfuns);
+    JanetRegExt cfuns[] = {
+        JANET_CORE_REG("compile", cfun),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, cfuns);
 }

src/core/compile.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -23,8 +23,18 @@
 #ifndef JANET_COMPILE_H
 #define JANET_COMPILE_H
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "regalloc.h"
+#endif
+
+/* Levels for compiler warnings */
+typedef enum {
+    JANET_C_LINT_RELAXED,
+    JANET_C_LINT_NORMAL,
+    JANET_C_LINT_STRICT
+} JanetCompileLintLevel;
 
 /* Tags for some functions for the prepared inliner */
 #define JANET_FUN_DEBUG 1
@@ -32,7 +42,7 @@
 #define JANET_FUN_APPLY 3
 #define JANET_FUN_YIELD 4
 #define JANET_FUN_RESUME 5
-#define JANET_FUN_GET 6
+#define JANET_FUN_IN 6
 #define JANET_FUN_PUT 7
 #define JANET_FUN_LENGTH 8
 #define JANET_FUN_ADD 9
@@ -46,18 +56,19 @@
 #define JANET_FUN_RSHIFT 17
 #define JANET_FUN_RSHIFTU 18
 #define JANET_FUN_BNOT 19
-#define JANET_FUN_ORDER_GT 20
-#define JANET_FUN_ORDER_LT 21
-#define JANET_FUN_ORDER_GTE 22
-#define JANET_FUN_ORDER_LTE 23
-#define JANET_FUN_ORDER_EQ 24
-#define JANET_FUN_ORDER_NEQ 25
-#define JANET_FUN_GT 26
-#define JANET_FUN_LT 27
-#define JANET_FUN_GTE 28
-#define JANET_FUN_LTE 29
-#define JANET_FUN_EQ 30
-#define JANET_FUN_NEQ 31
+#define JANET_FUN_GT 20
+#define JANET_FUN_LT 21
+#define JANET_FUN_GTE 22
+#define JANET_FUN_LTE 23
+#define JANET_FUN_EQ 24
+#define JANET_FUN_NEQ 25
+#define JANET_FUN_PROP 26
+#define JANET_FUN_GET 27
+#define JANET_FUN_NEXT 28
+#define JANET_FUN_MODULO 29
+#define JANET_FUN_REMAINDER 30
+#define JANET_FUN_CMP 31
+#define JANET_FUN_CANCEL 32
 
 /* Compiler typedefs */
 typedef struct JanetCompiler JanetCompiler;
@@ -74,10 +85,10 @@ typedef struct JanetSpecial JanetSpecial;
 #define JANET_SLOT_MUTABLE 0x40000
 #define JANET_SLOT_REF 0x80000
 #define JANET_SLOT_RETURNED 0x100000
-/* Needed for handling single element arrays as global vars. */
-
-/* Used for unquote-splicing */
-#define JANET_SLOT_SPLICED 0x200000
+#define JANET_SLOT_DEP_NOTE 0x200000
+#define JANET_SLOT_DEP_WARN 0x400000
+#define JANET_SLOT_DEP_ERROR 0x800000
+#define JANET_SLOT_SPLICED 0x1000000
 
 #define JANET_SLOTTYPE_ANY 0xFFFF
 
@@ -94,6 +105,7 @@ struct JanetSlot {
 #define JANET_SCOPE_TOP 4
 #define JANET_SCOPE_UNUSED 8
 #define JANET_SCOPE_CLOSURE 16
+#define JANET_SCOPE_WHILE 32
 
 /* A symbol and slot pair */
 typedef struct SymPair {
@@ -124,14 +136,14 @@ struct JanetScope {
     /* Regsiter allocator */
     JanetcRegisterAllocator ra;
 
-    /* Referenced closure environents. The values at each index correspond
+    /* Upvalue allocator */
+    JanetcRegisterAllocator ua;
+
+    /* Referenced closure environments. The values at each index correspond
      * to which index to get the environment from in the parent. The environment
      * that corresponds to the direct parent's stack will always have value 0. */
     int32_t *envs;
 
-    /* Where to add reference to self in constants */
-    int32_t selfconst;
-
     int32_t bytecode_start;
     int flags;
 };
@@ -159,6 +171,9 @@ struct JanetCompiler {
 
     /* Prevent unbounded recursion */
     int recursion_guard;
+
+    /* Collect linting results */
+    JanetArray *lints;
 };
 
 #define JANET_FOPTS_TAIL 0x10000
@@ -178,13 +193,13 @@ JanetFopts janetc_fopts_default(JanetCompiler *c);
 /* For optimizing builtin normal functions. */
 struct JanetFunOptimizer {
     int (*can_optimize)(JanetFopts opts, JanetSlot *args);
-    JanetSlot (*optimize)(JanetFopts opts, JanetSlot *args);
+    JanetSlot(*optimize)(JanetFopts opts, JanetSlot *args);
 };
 
 /* A grouping of a named special and the corresponding compiler fragment */
 struct JanetSpecial {
     const char *name;
-    JanetSlot (*compile)(JanetFopts opts, int32_t argn, const Janet *argv);
+    JanetSlot(*compile)(JanetFopts opts, int32_t argn, const Janet *argv);
 };
 
 /****************************************************/
@@ -213,7 +228,7 @@ JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len);
 JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds);
 
 /* Push slots load via janetc_toslots. */
-void janetc_pushslots(JanetCompiler *c, JanetSlot *slots);
+int32_t janetc_pushslots(JanetCompiler *c, JanetSlot *slots);
 
 /* Free slots loaded via janetc_toslots */
 void janetc_freeslots(JanetCompiler *c, JanetSlot *slots);
@@ -225,6 +240,9 @@ JanetSlot janetc_return(JanetCompiler *c, JanetSlot s);
 void janetc_error(JanetCompiler *c, const uint8_t *m);
 void janetc_cerror(JanetCompiler *c, const char *m);
 
+/* Linting */
+void janetc_lintf(JanetCompiler *C, JanetCompileLintLevel level, const char *format, ...);
+
 /* Dispatch to correct form compiler */
 JanetSlot janetc_value(JanetFopts opts, Janet x);
 

src/core/debug.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,10 +20,14 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "gc.h"
 #include "state.h"
 #include "util.h"
+#include "vector.h"
+#endif
 
 /* Implements functionality to build a debugger from within janet.
  * The repl should also be able to serve as pretty featured debugger
@@ -48,37 +52,41 @@ void janet_debug_unbreak(JanetFuncDef *def, int32_t pc) {
  * location.
  */
 void janet_debug_find(
-        JanetFuncDef **def_out, int32_t *pc_out,
-        const uint8_t *source, int32_t offset) {
+    JanetFuncDef **def_out, int32_t *pc_out,
+    const uint8_t *source, int32_t sourceLine, int32_t sourceColumn) {
     /* Scan the heap for right func def */
-    JanetGCMemoryHeader *current = janet_vm_blocks;
+    JanetGCObject *current = janet_vm.blocks;
     /* Keep track of the best source mapping we have seen so far */
     int32_t besti = -1;
-    int32_t best_range = INT32_MAX;
+    int32_t best_line = -1;
+    int32_t best_column = -1;
     JanetFuncDef *best_def = NULL;
     while (NULL != current) {
         if ((current->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_FUNCDEF) {
-            JanetFuncDef *def = (JanetFuncDef *)(current + 1);
+            JanetFuncDef *def = (JanetFuncDef *)(current);
             if (def->sourcemap &&
                     def->source &&
                     !janet_string_compare(source, def->source)) {
                 /* Correct source file, check mappings. The chosen
-                 * pc index is the first match with the smallest range. */
+                 * pc index is the instruction closest to the given line column, but
+                 * not after. */
                 int32_t i;
                 for (i = 0; i < def->bytecode_length; i++) {
-                    int32_t start = def->sourcemap[i].start;
-                    int32_t end = def->sourcemap[i].end;
-                    if (end - start < best_range &&
-                            start <= offset &&
-                            end >= offset) {
-                        best_range = end - start;
-                        besti = i;
-                        best_def = def;
+                    int32_t line = def->sourcemap[i].line;
+                    int32_t column = def->sourcemap[i].column;
+                    if (line <= sourceLine && line >= best_line) {
+                        if (column <= sourceColumn &&
+                                (line > best_line || column > best_column)) {
+                            best_line = line;
+                            best_column = column;
+                            besti = i;
+                            best_def = def;
+                        }
                     }
                 }
             }
         }
-        current = current->next;
+        current = current->data.next;
     }
     if (best_def) {
         *def_out = best_def;
@@ -88,6 +96,98 @@ void janet_debug_find(
     }
 }
 
+void janet_stacktrace(JanetFiber *fiber, Janet err) {
+    const char *prefix = janet_checktype(err, JANET_NIL) ? NULL : "";
+    janet_stacktrace_ext(fiber, err, prefix);
+}
+
+/* Error reporting. This can be emulated from within Janet, but for
+ * consitency with the top level code it is defined once. */
+void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix) {
+
+    int32_t fi;
+    const char *errstr = (const char *)janet_to_string(err);
+    JanetFiber **fibers = NULL;
+    int wrote_error = !prefix;
+
+    int print_color = janet_truthy(janet_dyn("err-color"));
+    if (print_color) janet_eprintf("\x1b[31m");
+
+    while (fiber) {
+        janet_v_push(fibers, fiber);
+        fiber = fiber->child;
+    }
+
+    for (fi = janet_v_count(fibers) - 1; fi >= 0; fi--) {
+        fiber = fibers[fi];
+        int32_t i = fiber->frame;
+        while (i > 0) {
+            JanetCFunRegistry *reg = NULL;
+            JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE);
+            JanetFuncDef *def = NULL;
+            i = frame->prevframe;
+
+            /* Print prelude to stack frame */
+            if (!wrote_error) {
+                JanetFiberStatus status = janet_fiber_status(fiber);
+                janet_eprintf("%s%s: %s\n",
+                              prefix,
+                              janet_status_names[status],
+                              errstr);
+                wrote_error = 1;
+            }
+
+            janet_eprintf("  in");
+
+            if (frame->func) {
+                def = frame->func->def;
+                janet_eprintf(" %s", def->name ? (const char *)def->name : "<anonymous>");
+                if (def->source) {
+                    janet_eprintf(" [%s]", (const char *)def->source);
+                }
+            } else {
+                JanetCFunction cfun = (JanetCFunction)(frame->pc);
+                if (cfun) {
+                    reg = janet_registry_get(cfun);
+                    if (NULL != reg && NULL != reg->name) {
+                        if (reg->name_prefix) {
+                            janet_eprintf(" %s/%s", reg->name_prefix, reg->name);
+                        } else {
+                            janet_eprintf(" %s", reg->name);
+                        }
+                        if (NULL != reg->source_file) {
+                            janet_eprintf(" [%s]", reg->source_file);
+                        }
+                    } else {
+                        janet_eprintf(" <cfunction>");
+                    }
+                }
+            }
+            if (frame->flags & JANET_STACKFRAME_TAILCALL)
+                janet_eprintf(" (tailcall)");
+            if (frame->func && frame->pc) {
+                int32_t off = (int32_t)(frame->pc - def->bytecode);
+                if (def->sourcemap) {
+                    JanetSourceMapping mapping = def->sourcemap[off];
+                    janet_eprintf(" on line %d, column %d", mapping.line, mapping.column);
+                } else {
+                    janet_eprintf(" pc=%d", off);
+                }
+            } else if (NULL != reg) {
+                /* C Function */
+                if (reg->source_line > 0) {
+                    janet_eprintf(" on line %d", (long) reg->source_line);
+                }
+            }
+            janet_eprintf("\n");
+        }
+    }
+
+    if (print_color) janet_eprintf("\x1b[0m");
+
+    janet_v_free(fibers);
+}
+
 /*
  * CFuns
  */
@@ -95,10 +195,11 @@ void janet_debug_find(
 /* Helper to find funcdef and bytecode offset to insert or remove breakpoints.
  * Takes a source file name and byte offset. */
 static void helper_find(int32_t argc, Janet *argv, JanetFuncDef **def, int32_t *bytecode_offset) {
-    janet_fixarity(argc, 2);
+    janet_fixarity(argc, 3);
     const uint8_t *source = janet_getstring(argv, 0);
-    int32_t source_offset = janet_getinteger(argv, 1);
-    janet_debug_find(def, bytecode_offset, source, source_offset);
+    int32_t line = janet_getinteger(argv, 1);
+    int32_t col = janet_getinteger(argv, 2);
+    janet_debug_find(def, bytecode_offset, source, line, col);
 }
 
 /* Helper to find funcdef and bytecode offset to insert or remove breakpoints.
@@ -111,7 +212,13 @@ static void helper_find_fun(int32_t argc, Janet *argv, JanetFuncDef **def, int32
     *bytecode_offset = offset;
 }
 
-static Janet cfun_break(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_debug_break,
+              "(debug/break source line col)",
+              "Sets a breakpoint in `source` at a given line and column. "
+              "Will throw an error if the breakpoint location "
+              "cannot be found. For example\n\n"
+              "\t(debug/break \"core.janet\" 10 4)\n\n"
+              "will set a breakpoint at line 10, 4th column of the file core.janet.") {
     JanetFuncDef *def;
     int32_t offset;
     helper_find(argc, argv, &def, &offset);
@@ -119,23 +226,33 @@ static Janet cfun_break(int32_t argc, Janet *argv) {
     return janet_wrap_nil();
 }
 
-static Janet cfun_unbreak(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_debug_unbreak,
+              "(debug/unbreak source line column)",
+              "Remove a breakpoint with a source key at a given line and column. "
+              "Will throw an error if the breakpoint "
+              "cannot be found.") {
     JanetFuncDef *def;
-    int32_t offset;
+    int32_t offset = 0;
     helper_find(argc, argv, &def, &offset);
     janet_debug_unbreak(def, offset);
     return janet_wrap_nil();
 }
 
-static Janet cfun_fbreak(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_debug_fbreak,
+              "(debug/fbreak fun &opt pc)",
+              "Set a breakpoint in a given function. pc is an optional offset, which "
+              "is in bytecode instructions. fun is a function value. Will throw an error "
+              "if the offset is too large or negative.") {
     JanetFuncDef *def;
-    int32_t offset;
+    int32_t offset = 0;
     helper_find_fun(argc, argv, &def, &offset);
     janet_debug_break(def, offset);
     return janet_wrap_nil();
 }
 
-static Janet cfun_unfbreak(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_debug_unfbreak,
+              "(debug/unfbreak fun &opt pc)",
+              "Unset a breakpoint set with debug/fbreak.") {
     JanetFuncDef *def;
     int32_t offset;
     helper_find_fun(argc, argv, &def, &offset);
@@ -143,7 +260,12 @@ static Janet cfun_unfbreak(int32_t argc, Janet *argv) {
     return janet_wrap_nil();
 }
 
-static Janet cfun_lineage(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_debug_lineage,
+              "(debug/lineage fib)",
+              "Returns an array of all child fibers from a root fiber. This function "
+              "is useful when a fiber signals or errors to an ancestor fiber. Using this function, "
+              "the fiber handling the error can see which fiber raised the signal. This function should "
+              "be used mostly for debugging purposes.") {
     janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     JanetArray *array = janet_array(0);
@@ -168,9 +290,20 @@ static Janet doframe(JanetStackFrame *frame) {
     } else {
         JanetCFunction cfun = (JanetCFunction)(frame->pc);
         if (cfun) {
-            Janet name = janet_table_get(janet_vm_registry, janet_wrap_cfunction(cfun));
-            if (!janet_checktype(name, JANET_NIL)) {
-                janet_table_put(t, janet_ckeywordv("name"), name);
+            JanetCFunRegistry *reg = janet_registry_get(cfun);
+            if (NULL != reg->name) {
+                if (NULL != reg->name_prefix) {
+                    janet_table_put(t, janet_ckeywordv("name"), janet_wrap_string(janet_formatc("%s/%s", reg->name_prefix, reg->name)));
+                } else {
+                    janet_table_put(t, janet_ckeywordv("name"), janet_cstringv(reg->name));
+                }
+                if (NULL != reg->source_file) {
+                    janet_table_put(t, janet_ckeywordv("source"), janet_cstringv(reg->source_file));
+                }
+                if (reg->source_line > 0) {
+                    janet_table_put(t, janet_ckeywordv("source-line"), janet_wrap_integer(reg->source_line));
+                    janet_table_put(t, janet_ckeywordv("source-column"), janet_wrap_integer(1));
+                }
             }
         }
         janet_table_put(t, janet_ckeywordv("c"), janet_wrap_true());
@@ -181,26 +314,40 @@ static Janet doframe(JanetStackFrame *frame) {
     if (frame->func && frame->pc) {
         Janet *stack = (Janet *)frame + JANET_FRAME_SIZE;
         JanetArray *slots;
-        off = (int32_t) (frame->pc - def->bytecode);
+        off = (int32_t)(frame->pc - def->bytecode);
         janet_table_put(t, janet_ckeywordv("pc"), janet_wrap_integer(off));
         if (def->sourcemap) {
             JanetSourceMapping mapping = def->sourcemap[off];
-            janet_table_put(t, janet_ckeywordv("source-start"), janet_wrap_integer(mapping.start));
-            janet_table_put(t, janet_ckeywordv("source-end"), janet_wrap_integer(mapping.end));
+            janet_table_put(t, janet_ckeywordv("source-line"), janet_wrap_integer(mapping.line));
+            janet_table_put(t, janet_ckeywordv("source-column"), janet_wrap_integer(mapping.column));
         }
         if (def->source) {
             janet_table_put(t, janet_ckeywordv("source"), janet_wrap_string(def->source));
         }
         /* Add stack arguments */
         slots = janet_array(def->slotcount);
-        memcpy(slots->data, stack, sizeof(Janet) * def->slotcount);
+        safe_memcpy(slots->data, stack, sizeof(Janet) * def->slotcount);
         slots->count = def->slotcount;
         janet_table_put(t, janet_ckeywordv("slots"), janet_wrap_array(slots));
     }
     return janet_wrap_table(t);
 }
 
-static Janet cfun_stack(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_debug_stack,
+              "(debug/stack fib)",
+              "Gets information about the stack as an array of tables. Each table "
+              "in the array contains information about a stack frame. The top-most, current "
+              "stack frame is the first table in the array, and the bottom-most stack frame "
+              "is the last value. Each stack frame contains some of the following attributes:\n\n"
+              "* :c - true if the stack frame is a c function invocation\n\n"
+              "* :source-column - the current source column of the stack frame\n\n"
+              "* :function - the function that the stack frame represents\n\n"
+              "* :source-line - the current source line of the stack frame\n\n"
+              "* :name - the human-friendly name of the function\n\n"
+              "* :pc - integer indicating the location of the program counter\n\n"
+              "* :source - string with the file path or other identifier for the source code\n\n"
+              "* :slots - array of all values in each slot\n\n"
+              "* :tail - boolean indicating a tail call") {
     janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     JanetArray *array = janet_array(0);
@@ -216,7 +363,24 @@ static Janet cfun_stack(int32_t argc, Janet *argv) {
     return janet_wrap_array(array);
 }
 
-static Janet cfun_argstack(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_debug_stacktrace,
+              "(debug/stacktrace fiber &opt err prefix)",
+              "Prints a nice looking stacktrace for a fiber. Can optionally provide "
+              "an error value to print the stack trace with. If `err` is nil or not "
+              "provided, and no prefix is given, will skip the error line. Returns the fiber.") {
+    janet_arity(argc, 1, 3);
+    JanetFiber *fiber = janet_getfiber(argv, 0);
+    Janet x = argc == 1 ? janet_wrap_nil() : argv[1];
+    const char *prefix = janet_optcstring(argv, argc, 2, NULL);
+    janet_stacktrace_ext(fiber, x, prefix);
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_debug_argstack,
+              "(debug/arg-stack fiber)",
+              "Gets all values currently on the fiber's argument stack. Normally, "
+              "this should be empty unless the fiber signals while pushing arguments "
+              "to make a function call. Returns a new array.") {
     janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     JanetArray *array = janet_array(fiber->stacktop - fiber->stackstart);
@@ -225,71 +389,31 @@ static Janet cfun_argstack(int32_t argc, Janet *argv) {
     return janet_wrap_array(array);
 }
 
-static const JanetReg cfuns[] = {
-    {
-        "debug/break", cfun_break,
-        JDOC("(debug/break source byte-offset)\n\n"
-                "Sets a breakpoint with source a key at a given byte offset. An offset "
-                "of 0 is the first byte in a file. Will throw an error if the breakpoint location "
-                "cannot be found. For example\n\n"
-                "\t(debug/break \"core.janet\" 1000)\n\n"
-                "wil set a breakpoint at the 1000th byte of the file core.janet.")
-    },
-    {
-        "debug/unbreak", cfun_unbreak,
-        JDOC("(debug/unbreak source byte-offset)\n\n"
-                "Remove a breakpoint with a source key at a given byte offset. An offset "
-                "of 0 is the first byte in a file. Will throw an error if the breakpoint "
-                "cannot be found.")
-    },
-    {
-        "debug/fbreak", cfun_fbreak,
-        JDOC("(debug/fbreak fun [,pc=0])\n\n"
-                "Set a breakpoint in a given function. pc is an optional offset, which "
-                "is in bytecode instructions. fun is a function value. Will throw an error "
-                "if the offset is too large or negative.")
-    },
-    {
-        "debug/unfbreak", cfun_unfbreak,
-        JDOC("(debug/unfbreak fun [,pc=0])\n\n"
-                "Unset a breakpoint set with debug/fbreak.")
-    },
-    {
-        "debug/arg-stack", cfun_argstack,
-        JDOC("(debug/arg-stack fiber)\n\n"
-                "Gets all values currently on the fiber's argument stack. Normally, "
-                "this should be empty unless the fiber signals while pushing arguments "
-                "to make a function call. Returns a new array.")
-    },
-    {
-        "debug/stack", cfun_stack,
-        JDOC("(debug/stack fib)\n\n"
-                "Gets information about the stack as an array of tables. Each table "
-                "in the array contains information about a stack frame. The top most, current "
-                "stack frame is the first table in the array, and the bottom most stack frame "
-                "is the last value. Each stack frame contains some of the following attributes:\n\n"
-                "\t:c - true if the stack frame is a c function invocation\n"
-                "\t:column - the current source column of the stack frame\n"
-                "\t:function - the function that the stack frame represents\n"
-                "\t:line - the current source line of the stack frame\n"
-                "\t:name - the human friendly name of the function\n"
-                "\t:pc - integer indicating the location of the program counter\n"
-                "\t:source - string with the file path or other identifier for the source code\n"
-                "\t:slots - array of all values in each slot\n"
-                "\t:tail - boolean indicating a tail call")
-    },
-    {
-        "debug/lineage", cfun_lineage,
-        JDOC("(debug/lineage fib)\n\n"
-                "Returns an array of all child fibers from a root fiber. This function "
-                "is useful when a fiber signals or errors to an ancestor fiber. Using this function, "
-                "the fiber handling the error can see which fiber raised the signal. This function should "
-                "be used mostly for debugging purposes.")
-    },
-    {NULL, NULL, NULL}
-};
+JANET_CORE_FN(cfun_debug_step,
+              "(debug/step fiber &opt x)",
+              "Run a fiber for one virtual instruction of the Janet machine. Can optionally "
+              "pass in a value that will be passed as the resuming value. Returns the signal value, "
+              "which will usually be nil, as breakpoints raise nil signals.") {
+    janet_arity(argc, 1, 2);
+    JanetFiber *fiber = janet_getfiber(argv, 0);
+    Janet out = janet_wrap_nil();
+    janet_step(fiber, argc == 1 ? janet_wrap_nil() : argv[1], &out);
+    return out;
+}
 
 /* Module entry point */
 void janet_lib_debug(JanetTable *env) {
-    janet_cfuns(env, NULL, cfuns);
+    JanetRegExt debug_cfuns[] = {
+        JANET_CORE_REG("debug/break", cfun_debug_break),
+        JANET_CORE_REG("debug/unbreak", cfun_debug_unbreak),
+        JANET_CORE_REG("debug/fbreak", cfun_debug_fbreak),
+        JANET_CORE_REG("debug/unfbreak", cfun_debug_unfbreak),
+        JANET_CORE_REG("debug/arg-stack", cfun_debug_argstack),
+        JANET_CORE_REG("debug/stack", cfun_debug_stack),
+        JANET_CORE_REG("debug/stacktrace", cfun_debug_stacktrace),
+        JANET_CORE_REG("debug/lineage", cfun_debug_lineage),
+        JANET_CORE_REG("debug/step", cfun_debug_step),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, debug_cfuns);
 }

src/core/emit.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,10 +20,13 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "emit.h"
 #include "vector.h"
 #include "regalloc.h"
+#endif
 
 /* Get a register */
 int32_t janetc_allocfar(JanetCompiler *c) {
@@ -34,7 +37,7 @@ int32_t janetc_allocfar(JanetCompiler *c) {
     return reg;
 }
 
-/* Get a register less than 256 */
+/* Get a register less than 256 for temporary use. */
 int32_t janetc_allocnear(JanetCompiler *c, JanetcRegisterTemp tag) {
     return janetc_regalloc_temp(&c->scope->ra, tag);
 }
@@ -76,32 +79,31 @@ static void janetc_loadconst(JanetCompiler *c, Janet k, int32_t reg) {
         case JANET_NIL:
             janetc_emit(c, (reg << 8) | JOP_LOAD_NIL);
             break;
-        case JANET_TRUE:
-            janetc_emit(c, (reg << 8) | JOP_LOAD_TRUE);
+        case JANET_BOOLEAN:
+            janetc_emit(c, (reg << 8) |
+                        (janet_unwrap_boolean(k) ? JOP_LOAD_TRUE : JOP_LOAD_FALSE));
             break;
-        case JANET_FALSE:
-            janetc_emit(c, (reg << 8) | JOP_LOAD_FALSE);
-            break;
-        case JANET_NUMBER:
-            {
-                double dval = janet_unwrap_number(k);
-                int32_t i = (int32_t) dval;
-                if (dval != i || !(dval >= INT16_MIN && dval <= INT16_MAX))
-                    goto do_constant;
-                janetc_emit(c,
-                        (i << 16) |
+        case JANET_NUMBER: {
+            double dval = janet_unwrap_number(k);
+            if (dval < INT16_MIN || dval > INT16_MAX)
+                goto do_constant;
+            int32_t i = (int32_t) dval;
+            if (dval != i)
+                goto do_constant;
+            uint32_t iu = (uint32_t)i;
+            janetc_emit(c,
+                        (iu << 16) |
                         (reg << 8) |
                         JOP_LOAD_INTEGER);
-                break;
-            }
+            break;
+        }
         default:
-        do_constant:
-            {
+        do_constant: {
                 int32_t cindex = janetc_const(c, k);
                 janetc_emit(c,
-                        (cindex << 16) |
-                        (reg << 8) |
-                        JOP_LOAD_CONSTANT);
+                            (cindex << 16) |
+                            (reg << 8) |
+                            JOP_LOAD_CONSTANT);
                 break;
             }
     }
@@ -109,53 +111,53 @@ static void janetc_loadconst(JanetCompiler *c, Janet k, int32_t reg) {
 
 /* Move a slot to a near register */
 static void janetc_movenear(JanetCompiler *c,
-        int32_t dest,
-        JanetSlot src) {
+                            int32_t dest,
+                            JanetSlot src) {
     if (src.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) {
         janetc_loadconst(c, src.constant, dest);
         /* If we also are a reference, deref the one element array */
         if (src.flags & JANET_SLOT_REF) {
             janetc_emit(c,
-                    (dest << 16) |
-                    (dest << 8) |
-                    JOP_GET_INDEX);
+                        (dest << 16) |
+                        (dest << 8) |
+                        JOP_GET_INDEX);
         }
     } else if (src.envindex >= 0) {
         janetc_emit(c,
-                ((uint32_t)(src.index) << 24) |
-                ((uint32_t)(src.envindex) << 16) |
-                ((uint32_t)(dest) << 8) |
-                JOP_LOAD_UPVALUE);
+                    ((uint32_t)(src.index) << 24) |
+                    ((uint32_t)(src.envindex) << 16) |
+                    ((uint32_t)(dest) << 8) |
+                    JOP_LOAD_UPVALUE);
     } else if (src.index > 0xFF || src.index != dest) {
         janetc_emit(c,
-                ((uint32_t)(src.index) << 16) |
-                ((uint32_t)(dest) << 8) |
+                    ((uint32_t)(src.index) << 16) |
+                    ((uint32_t)(dest) << 8) |
                     JOP_MOVE_NEAR);
     }
 }
 
 /* Move a near register to a Slot. */
 static void janetc_moveback(JanetCompiler *c,
-        JanetSlot dest,
-        int32_t src) {
+                            JanetSlot dest,
+                            int32_t src) {
     if (dest.flags & JANET_SLOT_REF) {
         int32_t refreg = janetc_regalloc_temp(&c->scope->ra, JANETC_REGTEMP_5);
         janetc_loadconst(c, dest.constant, refreg);
         janetc_emit(c,
-               (src << 16) |
-               (refreg << 8) |
-               JOP_PUT_INDEX);
+                    (src << 16) |
+                    (refreg << 8) |
+                    JOP_PUT_INDEX);
         janetc_regalloc_freetemp(&c->scope->ra, refreg, JANETC_REGTEMP_5);
     } else if (dest.envindex >= 0) {
         janetc_emit(c,
-                ((uint32_t)(dest.index) << 24) |
-                ((uint32_t)(dest.envindex) << 16) |
-                ((uint32_t)(src) << 8) |
-                JOP_SET_UPVALUE);
+                    ((uint32_t)(dest.index) << 24) |
+                    ((uint32_t)(dest.envindex) << 16) |
+                    ((uint32_t)(src) << 8) |
+                    JOP_SET_UPVALUE);
     } else if (dest.index != src) {
         janetc_emit(c,
-                ((uint32_t)(dest.index) << 16) |
-                ((uint32_t)(src) << 8) |
+                    ((uint32_t)(dest.index) << 16) |
+                    ((uint32_t)(src) << 8) |
                     JOP_MOVE_FAR);
     }
 }
@@ -203,7 +205,7 @@ static int32_t janetc_regnear(JanetCompiler *c, JanetSlot s, JanetcRegisterTemp
 }
 
 /* Check if two slots are equal */
-static int janetc_sequal(JanetSlot lhs, JanetSlot rhs) {
+int janetc_sequal(JanetSlot lhs, JanetSlot rhs) {
     if ((lhs.flags & ~JANET_SLOTTYPE_ANY) == (rhs.flags & ~JANET_SLOTTYPE_ANY) &&
             lhs.index == rhs.index &&
             lhs.envindex == rhs.envindex) {
@@ -219,9 +221,9 @@ static int janetc_sequal(JanetSlot lhs, JanetSlot rhs) {
 /* Move values from one slot to another. The destination must
  * be writeable (not a literal). */
 void janetc_copy(
-        JanetCompiler *c,
-        JanetSlot dest,
-        JanetSlot src) {
+    JanetCompiler *c,
+    JanetSlot dest,
+    JanetSlot src) {
     if (dest.flags & JANET_SLOT_CONSTANT) {
         janetc_cerror(c, "cannot write to constant");
         return;
@@ -238,19 +240,19 @@ void janetc_copy(
         return;
     }
     /* Process: src -> near -> dest */
-    int32_t near = janetc_allocnear(c, JANETC_REGTEMP_3);
-    janetc_movenear(c, near, src);
-    janetc_moveback(c, dest, near);
+    int32_t nearreg = janetc_allocnear(c, JANETC_REGTEMP_3);
+    janetc_movenear(c, nearreg, src);
+    janetc_moveback(c, dest, nearreg);
     /* Cleanup */
-    janetc_regalloc_freetemp(&c->scope->ra, near, JANETC_REGTEMP_3);
-
+    janetc_regalloc_freetemp(&c->scope->ra, nearreg, JANETC_REGTEMP_3);
 }
+
 /* Instruction templated emitters */
 
 static int32_t emit1s(JanetCompiler *c, uint8_t op, JanetSlot s, int32_t rest, int wr) {
     int32_t reg = janetc_regnear(c, s, JANETC_REGTEMP_0);
     int32_t label = janet_v_count(c->buffer);
-    janetc_emit(c, op | (reg << 8) | (rest << 16));
+    janetc_emit(c, op | (reg << 8) | ((uint32_t)rest << 16));
     if (wr)
         janetc_moveback(c, s, reg);
     janetc_free_regnear(c, s, reg, JANETC_REGTEMP_0);
@@ -292,7 +294,7 @@ static int32_t emit2s(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2,
     int32_t reg1 = janetc_regnear(c, s1, JANETC_REGTEMP_0);
     int32_t reg2 = janetc_regnear(c, s2, JANETC_REGTEMP_1);
     int32_t label = janet_v_count(c->buffer);
-    janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | (rest << 24));
+    janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | ((uint32_t)rest << 24));
     janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1);
     if (wr)
         janetc_moveback(c, s1, reg1);
@@ -325,7 +327,7 @@ int32_t janetc_emit_sss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2
     int32_t reg2 = janetc_regnear(c, s2, JANETC_REGTEMP_1);
     int32_t reg3 = janetc_regnear(c, s3, JANETC_REGTEMP_2);
     int32_t label = janet_v_count(c->buffer);
-    janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | (reg3 << 24));
+    janetc_emit(c, op | (reg1 << 8) | (reg2 << 16) | ((uint32_t)reg3 << 24));
     janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1);
     janetc_free_regnear(c, s3, reg3, JANETC_REGTEMP_2);
     if (wr)

src/core/emit.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -23,7 +23,9 @@
 #ifndef JANET_EMIT_H
 #define JANET_EMIT_H
 
+#ifndef JANET_AMALG
 #include "compile.h"
+#endif
 
 void janetc_emit(JanetCompiler *c, uint32_t instr);
 
@@ -40,6 +42,9 @@ int32_t janetc_emit_ssi(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2
 int32_t janetc_emit_ssu(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, uint8_t immediate, int wr);
 int32_t janetc_emit_sss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, JanetSlot s3, int wr);
 
+/* Check if two slots are equivalent */
+int janetc_sequal(JanetSlot x, JanetSlot y);
+
 /* Move value from one slot to another. Cannot copy to constant slots. */
 void janetc_copy(JanetCompiler *c, JanetSlot dest, JanetSlot src);
 

src/core/features.h

@@ -0,0 +1,64 @@
+/*
+* Copyright (c) 2022 Calvin Rose
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to
+* 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.
+*/
+
+/* Feature test macros */
+
+#ifndef JANET_FEATURES_H_defined
+#define JANET_FEATURES_H_defined
+
+#if defined(__NetBSD__) || defined(__APPLE__) || defined(__OpenBSD__) \
+    || defined(__bsdi__) || defined(__DragonFly__)
+/* Use BSD source on any BSD systems, include OSX */
+# define _BSD_SOURCE
+#else
+/* Use POSIX feature flags */
+# ifndef _POSIX_C_SOURCE
+# define _POSIX_C_SOURCE 200809L
+# endif
+#endif
+
+/* Needed for sched.h for cpu count */
+#ifdef __linux__
+#define _GNU_SOURCE
+#endif
+
+#if defined(WIN32) || defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+/* Needed for realpath on linux, as well as pthread rwlocks. */
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 600
+#endif
+#if _XOPEN_SOURCE < 600
+#undef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 600
+#endif
+
+/* Needed for timegm and other extensions when building with -std=c99.
+ * It also defines realpath, etc, which would normally require
+ * _XOPEN_SOURCE >= 500. */
+#if !defined(_NETBSD_SOURCE) && defined(__NetBSD__)
+#define _NETBSD_SOURCE
+#endif
+
+#endif

src/core/fiber.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,78 +20,131 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "fiber.h"
 #include "state.h"
 #include "gc.h"
 #include "util.h"
+#endif
 
-static JanetFiber *make_fiber(int32_t capacity) {
+static void fiber_reset(JanetFiber *fiber) {
+    fiber->maxstack = JANET_STACK_MAX;
+    fiber->frame = 0;
+    fiber->stackstart = JANET_FRAME_SIZE;
+    fiber->stacktop = JANET_FRAME_SIZE;
+    fiber->child = NULL;
+    fiber->flags = JANET_FIBER_MASK_YIELD | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
+    fiber->env = NULL;
+    fiber->last_value = janet_wrap_nil();
+#ifdef JANET_EV
+    fiber->waiting = NULL;
+    fiber->sched_id = 0;
+    fiber->supervisor_channel = NULL;
+#endif
+    janet_fiber_set_status(fiber, JANET_STATUS_NEW);
+}
+
+static JanetFiber *fiber_alloc(int32_t capacity) {
     Janet *data;
     JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber));
     if (capacity < 32) {
         capacity = 32;
     }
     fiber->capacity = capacity;
-    data = malloc(sizeof(Janet) * capacity);
+    data = janet_malloc(sizeof(Janet) * (size_t) capacity);
     if (NULL == data) {
         JANET_OUT_OF_MEMORY;
     }
+    janet_vm.next_collection += sizeof(Janet) * capacity;
     fiber->data = data;
-    fiber->maxstack = JANET_STACK_MAX;
-    fiber->frame = 0;
-    fiber->stackstart = JANET_FRAME_SIZE;
-    fiber->stacktop = JANET_FRAME_SIZE;
-    fiber->child = NULL;
-    fiber->flags = JANET_FIBER_MASK_YIELD;
-    janet_fiber_set_status(fiber, JANET_STATUS_NEW);
     return fiber;
 }
 
-/* Initialize a new fiber */
-JanetFiber *janet_fiber(JanetFunction *callee, int32_t capacity) {
-    JanetFiber *fiber = make_fiber(capacity);
-    if (janet_fiber_funcframe(fiber, callee)) return NULL;
-    return fiber;
-}
-
-/* Clear a fiber (reset it) with argn values on the stack. */
-JanetFiber *janet_fiber_n(JanetFunction *callee, int32_t capacity, const Janet *argv, int32_t argn) {
+/* Create a new fiber with argn values on the stack by reusing a fiber. */
+JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t argc, const Janet *argv) {
     int32_t newstacktop;
-    JanetFiber *fiber = make_fiber(capacity);
-    newstacktop = fiber->stacktop + argn;
-    if (newstacktop >= fiber->capacity) {
-        janet_fiber_setcapacity(fiber, 2 * newstacktop);
+    fiber_reset(fiber);
+    if (argc) {
+        newstacktop = fiber->stacktop + argc;
+        if (newstacktop >= fiber->capacity) {
+            janet_fiber_setcapacity(fiber, 2 * newstacktop);
+        }
+        if (argv) {
+            memcpy(fiber->data + fiber->stacktop, argv, argc * sizeof(Janet));
+        } else {
+            /* If argv not given, fill with nil */
+            for (int32_t i = 0; i < argc; i++) {
+                fiber->data[fiber->stacktop + i] = janet_wrap_nil();
+            }
+        }
+        fiber->stacktop = newstacktop;
     }
-    memcpy(fiber->data + fiber->stacktop, argv, argn * sizeof(Janet));
-    fiber->stacktop = newstacktop;
     if (janet_fiber_funcframe(fiber, callee)) return NULL;
+    janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE;
+#ifdef JANET_EV
+    fiber->waiting = NULL;
+    fiber->supervisor_channel = NULL;
+#endif
     return fiber;
 }
 
+/* Create a new fiber with argn values on the stack. */
+JanetFiber *janet_fiber(JanetFunction *callee, int32_t capacity, int32_t argc, const Janet *argv) {
+    return janet_fiber_reset(fiber_alloc(capacity), callee, argc, argv);
+}
+
+#ifdef JANET_DEBUG
+/* Test for memory issues by reallocating fiber every time we push a stack frame */
+static void janet_fiber_refresh_memory(JanetFiber *fiber) {
+    int32_t n = fiber->capacity;
+    if (n) {
+        Janet *newData = janet_malloc(sizeof(Janet) * n);
+        if (NULL == newData) {
+            JANET_OUT_OF_MEMORY;
+        }
+        memcpy(newData, fiber->data, fiber->capacity * sizeof(Janet));
+        janet_free(fiber->data);
+        fiber->data = newData;
+    }
+}
+#endif
+
 /* Ensure that the fiber has enough extra capacity */
 void janet_fiber_setcapacity(JanetFiber *fiber, int32_t n) {
-    Janet *newData = realloc(fiber->data, sizeof(Janet) * n);
+    int32_t old_size = fiber->capacity;
+    int32_t diff = n - old_size;
+    Janet *newData = janet_realloc(fiber->data, sizeof(Janet) * n);
     if (NULL == newData) {
         JANET_OUT_OF_MEMORY;
     }
     fiber->data = newData;
     fiber->capacity = n;
+    janet_vm.next_collection += sizeof(Janet) * diff;
+}
+
+/* Grow fiber if needed */
+static void janet_fiber_grow(JanetFiber *fiber, int32_t needed) {
+    int32_t cap = needed > (INT32_MAX / 2) ? INT32_MAX : 2 * needed;
+    janet_fiber_setcapacity(fiber, cap);
 }
 
 /* Push a value on the next stack frame */
 void janet_fiber_push(JanetFiber *fiber, Janet x) {
+    if (fiber->stacktop == INT32_MAX) janet_panic("stack overflow");
     if (fiber->stacktop >= fiber->capacity) {
-        janet_fiber_setcapacity(fiber, 2 * fiber->stacktop);
+        janet_fiber_grow(fiber, fiber->stacktop);
     }
     fiber->data[fiber->stacktop++] = x;
 }
 
 /* Push 2 values on the next stack frame */
 void janet_fiber_push2(JanetFiber *fiber, Janet x, Janet y) {
+    if (fiber->stacktop >= INT32_MAX - 1) janet_panic("stack overflow");
     int32_t newtop = fiber->stacktop + 2;
     if (newtop > fiber->capacity) {
-        janet_fiber_setcapacity(fiber, 2 * newtop);
+        janet_fiber_grow(fiber, newtop);
     }
     fiber->data[fiber->stacktop] = x;
     fiber->data[fiber->stacktop + 1] = y;
@@ -100,9 +153,10 @@ void janet_fiber_push2(JanetFiber *fiber, Janet x, Janet y) {
 
 /* Push 3 values on the next stack frame */
 void janet_fiber_push3(JanetFiber *fiber, Janet x, Janet y, Janet z) {
+    if (fiber->stacktop >= INT32_MAX - 2) janet_panic("stack overflow");
     int32_t newtop = fiber->stacktop + 3;
     if (newtop > fiber->capacity) {
-        janet_fiber_setcapacity(fiber, 2 * newtop);
+        janet_fiber_grow(fiber, newtop);
     }
     fiber->data[fiber->stacktop] = x;
     fiber->data[fiber->stacktop + 1] = y;
@@ -112,14 +166,25 @@ void janet_fiber_push3(JanetFiber *fiber, Janet x, Janet y, Janet z) {
 
 /* Push an array on the next stack frame */
 void janet_fiber_pushn(JanetFiber *fiber, const Janet *arr, int32_t n) {
+    if (fiber->stacktop > INT32_MAX - n) janet_panic("stack overflow");
     int32_t newtop = fiber->stacktop + n;
     if (newtop > fiber->capacity) {
-        janet_fiber_setcapacity(fiber, 2 * newtop);
+        janet_fiber_grow(fiber, newtop);
     }
-    memcpy(fiber->data + fiber->stacktop, arr, n * sizeof(Janet));
+    safe_memcpy(fiber->data + fiber->stacktop, arr, n * sizeof(Janet));
     fiber->stacktop = newtop;
 }
 
+/* Create a struct with n values. If n is odd, the last value is ignored. */
+static Janet make_struct_n(const Janet *args, int32_t n) {
+    int32_t i = 0;
+    JanetKV *st = janet_struct_begin(n & (~1));
+    for (; i < n; i += 2) {
+        janet_struct_put(st, args[i], args[i + 1]);
+    }
+    return janet_wrap_struct(janet_struct_end(st));
+}
+
 /* Push a stack frame to a fiber */
 int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
     JanetStackFrame *newframe;
@@ -132,14 +197,15 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
     int32_t next_arity = fiber->stacktop - fiber->stackstart;
 
     /* Check strict arity before messing with state */
-    if (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) {
-        if (func->def->arity != next_arity) {
-            return 1;
-        }
-    }
+    if (next_arity < func->def->min_arity) return 1;
+    if (next_arity > func->def->max_arity) return 1;
 
     if (fiber->capacity < nextstacktop) {
         janet_fiber_setcapacity(fiber, 2 * nextstacktop);
+#ifdef JANET_DEBUG
+    } else {
+        janet_fiber_refresh_memory(fiber);
+#endif
     }
 
     /* Nil unset stack arguments (Needed for gc correctness) */
@@ -160,12 +226,19 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
     /* Check varargs */
     if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) {
         int32_t tuplehead = fiber->frame + func->def->arity;
+        int st = func->def->flags & JANET_FUNCDEF_FLAG_STRUCTARG;
         if (tuplehead >= oldtop) {
-            fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(NULL, 0));
+            fiber->data[tuplehead] = st
+                                     ? make_struct_n(NULL, 0)
+                                     : janet_wrap_tuple(janet_tuple_n(NULL, 0));
         } else {
-            fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(
-                fiber->data + tuplehead,
-                oldtop - tuplehead));
+            fiber->data[tuplehead] = st
+                                     ? make_struct_n(
+                                         fiber->data + tuplehead,
+                                         oldtop - tuplehead)
+                                     : janet_wrap_tuple(janet_tuple_n(
+                                                 fiber->data + tuplehead,
+                                                 oldtop - tuplehead));
         }
     }
 
@@ -178,17 +251,79 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
 static void janet_env_detach(JanetFuncEnv *env) {
     /* Check for closure environment */
     if (env) {
-        size_t s = sizeof(Janet) * env->length;
-        Janet *vmem = malloc(s);
+        janet_env_valid(env);
+        int32_t len = env->length;
+        size_t s = sizeof(Janet) * (size_t) len;
+        Janet *vmem = janet_malloc(s);
+        janet_vm.next_collection += (uint32_t) s;
         if (NULL == vmem) {
             JANET_OUT_OF_MEMORY;
         }
-        memcpy(vmem, env->as.fiber->data + env->offset, s);
+        Janet *values = env->as.fiber->data + env->offset;
+        safe_memcpy(vmem, values, s);
+        uint32_t *bitset = janet_stack_frame(values)->func->def->closure_bitset;
+        if (bitset) {
+            /* Clear unneeded references in closure environment */
+            for (int32_t i = 0; i < len; i += 32) {
+                uint32_t mask = ~(bitset[i >> 5]);
+                int32_t maxj = i + 32 > len ? len : i + 32;
+                for (int32_t j = i; j < maxj; j++) {
+                    if (mask & 1) vmem[j] = janet_wrap_nil();
+                    mask >>= 1;
+                }
+            }
+        }
         env->offset = 0;
         env->as.values = vmem;
     }
 }
 
+/* Validate potentially untrusted func env (unmarshalled envs are difficult to verify) */
+int janet_env_valid(JanetFuncEnv *env) {
+    if (env->offset < 0) {
+        int32_t real_offset = -(env->offset);
+        JanetFiber *fiber = env->as.fiber;
+        int32_t i = fiber->frame;
+        while (i > 0) {
+            JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE);
+            if (real_offset == i &&
+                    frame->env == env &&
+                    frame->func &&
+                    frame->func->def->slotcount == env->length) {
+                env->offset = real_offset;
+                return 1;
+            }
+            i = frame->prevframe;
+        }
+        /* Invalid, set to empty off-stack variant. */
+        env->offset = 0;
+        env->length = 0;
+        env->as.values = NULL;
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+/* Detach a fiber from the env if the target fiber has stopped mutating */
+void janet_env_maybe_detach(JanetFuncEnv *env) {
+    /* Check for detachable closure envs */
+    janet_env_valid(env);
+    if (env->offset > 0) {
+        JanetFiberStatus s = janet_fiber_status(env->as.fiber);
+        int isFinished = s == JANET_STATUS_DEAD ||
+                         s == JANET_STATUS_ERROR ||
+                         s == JANET_STATUS_USER0 ||
+                         s == JANET_STATUS_USER1 ||
+                         s == JANET_STATUS_USER2 ||
+                         s == JANET_STATUS_USER3 ||
+                         s == JANET_STATUS_USER4;
+        if (isFinished) {
+            janet_env_detach(env);
+        }
+    }
+}
+
 /* Create a tail frame for a function */
 int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) {
     int32_t i;
@@ -198,14 +333,15 @@ int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) {
     int32_t stacksize;
 
     /* Check strict arity before messing with state */
-    if (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) {
-        if (func->def->arity != next_arity) {
-            return 1;
-        }
-    }
+    if (next_arity < func->def->min_arity) return 1;
+    if (next_arity > func->def->max_arity) return 1;
 
     if (fiber->capacity < nextstacktop) {
         janet_fiber_setcapacity(fiber, 2 * nextstacktop);
+#ifdef JANET_DEBUG
+    } else {
+        janet_fiber_refresh_memory(fiber);
+#endif
     }
 
     Janet *stack = fiber->data + fiber->frame;
@@ -219,14 +355,21 @@ int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) {
     /* Check varargs */
     if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) {
         int32_t tuplehead = fiber->stackstart + func->def->arity;
+        int st = func->def->flags & JANET_FUNCDEF_FLAG_STRUCTARG;
         if (tuplehead >= fiber->stacktop) {
             if (tuplehead >= fiber->capacity) janet_fiber_setcapacity(fiber, 2 * (tuplehead + 1));
             for (i = fiber->stacktop; i < tuplehead; ++i) fiber->data[i] = janet_wrap_nil();
-            fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(NULL, 0));
+            fiber->data[tuplehead] = st
+                                     ? make_struct_n(NULL, 0)
+                                     : janet_wrap_tuple(janet_tuple_n(NULL, 0));
         } else {
-            fiber->data[tuplehead] = janet_wrap_tuple(janet_tuple_n(
-                fiber->data + tuplehead,
-                fiber->stacktop - tuplehead));
+            fiber->data[tuplehead] = st
+                                     ? make_struct_n(
+                                         fiber->data + tuplehead,
+                                         fiber->stacktop - tuplehead)
+                                     : janet_wrap_tuple(janet_tuple_n(
+                                                 fiber->data + tuplehead,
+                                                 fiber->stacktop - tuplehead));
         }
         stacksize = tuplehead - fiber->stackstart + 1;
     } else {
@@ -261,6 +404,10 @@ void janet_fiber_cframe(JanetFiber *fiber, JanetCFunction cfun) {
 
     if (fiber->capacity < nextstacktop) {
         janet_fiber_setcapacity(fiber, 2 * nextstacktop);
+#ifdef JANET_DEBUG
+    } else {
+        janet_fiber_refresh_memory(fiber);
+#endif
     }
 
     /* Set the next frame */
@@ -276,8 +423,7 @@ void janet_fiber_cframe(JanetFiber *fiber, JanetCFunction cfun) {
     newframe->flags = 0;
 }
 
-/* Pop a stack frame from the fiber. Returns the new stack frame, or
- * NULL if there are no more frames */
+/* Pop a stack frame from the fiber. */
 void janet_fiber_popframe(JanetFiber *fiber) {
     JanetStackFrame *frame = janet_fiber_frame(fiber);
     if (fiber->frame == 0) return;
@@ -291,22 +437,80 @@ void janet_fiber_popframe(JanetFiber *fiber) {
     fiber->frame = frame->prevframe;
 }
 
+JanetFiberStatus janet_fiber_status(JanetFiber *f) {
+    return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET;
+}
+
+JanetFiber *janet_current_fiber(void) {
+    return janet_vm.fiber;
+}
+
+JanetFiber *janet_root_fiber(void) {
+    return janet_vm.root_fiber;
+}
+
 /* CFuns */
 
-static Janet cfun_new(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_fiber_getenv,
+              "(fiber/getenv fiber)",
+              "Gets the environment for a fiber. Returns nil if no such table is "
+              "set yet.") {
+    janet_fixarity(argc, 1);
+    JanetFiber *fiber = janet_getfiber(argv, 0);
+    return fiber->env ?
+           janet_wrap_table(fiber->env) :
+           janet_wrap_nil();
+}
+
+JANET_CORE_FN(cfun_fiber_setenv,
+              "(fiber/setenv fiber table)",
+              "Sets the environment table for a fiber. Set to nil to remove the current "
+              "environment.") {
+    janet_fixarity(argc, 2);
+    JanetFiber *fiber = janet_getfiber(argv, 0);
+    if (janet_checktype(argv[1], JANET_NIL)) {
+        fiber->env = NULL;
+    } else {
+        fiber->env = janet_gettable(argv, 1);
+    }
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_fiber_new,
+              "(fiber/new func &opt sigmask)",
+              "Create a new fiber with function body func. Can optionally "
+              "take a set of signals to block from the current parent fiber "
+              "when called. The mask is specified as a keyword where each character "
+              "is used to indicate a signal to block. If the ev module is enabled, and "
+              "this fiber is used as an argument to `ev/go`, these \"blocked\" signals "
+              "will result in messages being sent to the supervisor channel. "
+              "The default sigmask is :y. "
+              "For example,\n\n"
+              "    (fiber/new myfun :e123)\n\n"
+              "blocks error signals and user signals 1, 2 and 3. The signals are "
+              "as follows:\n\n"
+              "* :a - block all signals\n"
+              "* :d - block debug signals\n"
+              "* :e - block error signals\n"
+              "* :t - block termination signals: error + user[0-4]\n"
+              "* :u - block user signals\n"
+              "* :y - block yield signals\n"
+              "* :0-9 - block a specific user signal\n\n"
+              "The sigmask argument also can take environment flags. If any mutually "
+              "exclusive flags are present, the last flag takes precedence.\n\n"
+              "* :i - inherit the environment from the current fiber\n"
+              "* :p - the environment table's prototype is the current environment table") {
     janet_arity(argc, 1, 2);
     JanetFunction *func = janet_getfunction(argv, 0);
     JanetFiber *fiber;
-    if (func->def->flags & JANET_FUNCDEF_FLAG_FIXARITY) {
-        if (func->def->arity != 0) {
-            janet_panic("expected nullary function in fiber constructor");
-        }
+    if (func->def->min_arity > 1) {
+        janet_panicf("fiber function must accept 0 or 1 arguments");
     }
-    fiber = janet_fiber(func, 64);
+    fiber = janet_fiber(func, 64, func->def->min_arity, NULL);
     if (argc == 2) {
         int32_t i;
         JanetByteView view = janet_getbytes(argv, 1);
-        fiber->flags = 0;
+        fiber->flags = JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
         janet_fiber_set_status(fiber, JANET_STATUS_NEW);
         for (i = 0; i < view.len; i++) {
             if (view.bytes[i] >= '0' && view.bytes[i] <= '9') {
@@ -314,7 +518,7 @@ static Janet cfun_new(int32_t argc, Janet *argv) {
             } else {
                 switch (view.bytes[i]) {
                     default:
-                        janet_panicf("invalid flag %c, expected a, d, e, u, or y", view.bytes[i]);
+                        janet_panicf("invalid flag %c, expected a, t, d, e, u, y, i, or p", view.bytes[i]);
                         break;
                     case 'a':
                         fiber->flags |=
@@ -323,6 +527,15 @@ static Janet cfun_new(int32_t argc, Janet *argv) {
                             JANET_FIBER_MASK_USER |
                             JANET_FIBER_MASK_YIELD;
                         break;
+                    case 't':
+                        fiber->flags |=
+                            JANET_FIBER_MASK_ERROR |
+                            JANET_FIBER_MASK_USER0 |
+                            JANET_FIBER_MASK_USER1 |
+                            JANET_FIBER_MASK_USER2 |
+                            JANET_FIBER_MASK_USER3 |
+                            JANET_FIBER_MASK_USER4;
+                        break;
                     case 'd':
                         fiber->flags |= JANET_FIBER_MASK_DEBUG;
                         break;
@@ -335,6 +548,19 @@ static Janet cfun_new(int32_t argc, Janet *argv) {
                     case 'y':
                         fiber->flags |= JANET_FIBER_MASK_YIELD;
                         break;
+                    case 'i':
+                        if (!janet_vm.fiber->env) {
+                            janet_vm.fiber->env = janet_table(0);
+                        }
+                        fiber->env = janet_vm.fiber->env;
+                        break;
+                    case 'p':
+                        if (!janet_vm.fiber->env) {
+                            janet_vm.fiber->env = janet_table(0);
+                        }
+                        fiber->env = janet_table(0);
+                        fiber->env->proto = janet_vm.fiber->env;
+                        break;
                 }
             }
         }
@@ -342,27 +568,53 @@ static Janet cfun_new(int32_t argc, Janet *argv) {
     return janet_wrap_fiber(fiber);
 }
 
-static Janet cfun_status(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_fiber_status,
+              "(fiber/status fib)",
+              "Get the status of a fiber. The status will be one of:\n\n"
+              "* :dead - the fiber has finished\n"
+              "* :error - the fiber has errored out\n"
+              "* :debug - the fiber is suspended in debug mode\n"
+              "* :pending - the fiber has been yielded\n"
+              "* :user(0-9) - the fiber is suspended by a user signal\n"
+              "* :alive - the fiber is currently running and cannot be resumed\n"
+              "* :new - the fiber has just been created and not yet run") {
     janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
-    uint32_t s = (fiber->flags & JANET_FIBER_STATUS_MASK) >>
-        JANET_FIBER_STATUS_OFFSET;
+    uint32_t s = janet_fiber_status(fiber);
     return janet_ckeywordv(janet_status_names[s]);
 }
 
-static Janet cfun_current(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_fiber_current,
+              "(fiber/current)",
+              "Returns the currently running fiber.") {
     (void) argv;
     janet_fixarity(argc, 0);
-    return janet_wrap_fiber(janet_vm_fiber);
+    return janet_wrap_fiber(janet_vm.fiber);
 }
 
-static Janet cfun_maxstack(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_fiber_root,
+              "(fiber/root)",
+              "Returns the current root fiber. The root fiber is the oldest ancestor "
+              "that does not have a parent.") {
+    (void) argv;
+    janet_fixarity(argc, 0);
+    return janet_wrap_fiber(janet_vm.root_fiber);
+}
+
+JANET_CORE_FN(cfun_fiber_maxstack,
+              "(fiber/maxstack fib)",
+              "Gets the maximum stack size in janet values allowed for a fiber. While memory for "
+              "the fiber's stack is not allocated up front, the fiber will not allocated more "
+              "than this amount and will throw a stack-overflow error if more memory is needed. ") {
     janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     return janet_wrap_integer(fiber->maxstack);
 }
 
-static Janet cfun_setmaxstack(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_fiber_setmaxstack,
+              "(fiber/setmaxstack fib maxstack)",
+              "Sets the maximum stack size in janet values for a fiber. By default, the "
+              "maximum stack size is usually 8192.") {
     janet_fixarity(argc, 2);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     int32_t maxs = janet_getinteger(argv, 1);
@@ -373,59 +625,44 @@ static Janet cfun_setmaxstack(int32_t argc, Janet *argv) {
     return argv[0];
 }
 
-static const JanetReg cfuns[] = {
-    {
-        "fiber/new", cfun_new,
-        JDOC("(fiber/new func [,sigmask])\n\n"
-                "Create a new fiber with function body func. Can optionally "
-                "take a set of signals to block from the current parent fiber "
-                "when called. The mask is specified as a keyword where each character "
-                "is used to indicate a signal to block. The default sigmask is :y. "
-                "For example, \n\n"
-                "\t(fiber/new myfun :e123)\n\n"
-                "blocks error signals and user signals 1, 2 and 3. The signals are "
-                "as follows: \n\n"
-                "\ta - block all signals\n"
-                "\td - block debug signals\n"
-                "\te - block error signals\n"
-                "\tu - block user signals\n"
-                "\ty - block yield signals\n"
-                "\t0-9 - block a specific user signal")
-    },
-    {
-        "fiber/status", cfun_status,
-        JDOC("(fiber/status fib)\n\n"
-                "Get the status of a fiber. The status will be one of:\n\n"
-                "\t:dead - the fiber has finished\n"
-                "\t:error - the fiber has errored out\n"
-                "\t:debug - the fiber is suspended in debug mode\n"
-                "\t:pending - the fiber has been yielded\n"
-                "\t:user(0-9) - the fiber is suspended by a user signal\n"
-                "\t:alive - the fiber is currently running and cannot be resumed\n"
-                "\t:new - the fiber has just been created and not yet run")
-    },
-    {
-        "fiber/current", cfun_current,
-        JDOC("(fiber/current)\n\n"
-                "Returns the currently running fiber.")
-    },
-    {
-        "fiber/maxstack", cfun_maxstack,
-        JDOC("(fiber/maxstack fib)\n\n"
-                "Gets the maximum stack size in janet values allowed for a fiber. While memory for "
-                "the fiber's stack is not allocated up front, the fiber will not allocated more "
-                "than this amount and will throw a stack-overflow error if more memory is needed. ")
-    },
-    {
-        "fiber/setmaxstack", cfun_setmaxstack,
-        JDOC("(fiber/setmaxstack fib maxstack)\n\n"
-                "Sets the maximum stack size in janet values for a fiber. By default, the "
-                "maximum stack size is usually 8192.")
-    },
-    {NULL, NULL, NULL}
-};
+JANET_CORE_FN(cfun_fiber_can_resume,
+              "(fiber/can-resume? fiber)",
+              "Check if a fiber is finished and cannot be resumed.") {
+    janet_fixarity(argc, 1);
+    JanetFiber *fiber = janet_getfiber(argv, 0);
+    JanetFiberStatus s = janet_fiber_status(fiber);
+    int isFinished = s == JANET_STATUS_DEAD ||
+                     s == JANET_STATUS_ERROR ||
+                     s == JANET_STATUS_USER0 ||
+                     s == JANET_STATUS_USER1 ||
+                     s == JANET_STATUS_USER2 ||
+                     s == JANET_STATUS_USER3 ||
+                     s == JANET_STATUS_USER4;
+    return janet_wrap_boolean(!isFinished);
+}
+
+JANET_CORE_FN(cfun_fiber_last_value,
+              "(fiber/last-value)",
+              "Get the last value returned or signaled from the fiber.") {
+    janet_fixarity(argc, 1);
+    JanetFiber *fiber = janet_getfiber(argv, 0);
+    return fiber->last_value;
+}
 
 /* Module entry point */
 void janet_lib_fiber(JanetTable *env) {
-    janet_cfuns(env, NULL, cfuns);
+    JanetRegExt fiber_cfuns[] = {
+        JANET_CORE_REG("fiber/new", cfun_fiber_new),
+        JANET_CORE_REG("fiber/status", cfun_fiber_status),
+        JANET_CORE_REG("fiber/root", cfun_fiber_root),
+        JANET_CORE_REG("fiber/current", cfun_fiber_current),
+        JANET_CORE_REG("fiber/maxstack", cfun_fiber_maxstack),
+        JANET_CORE_REG("fiber/setmaxstack", cfun_fiber_setmaxstack),
+        JANET_CORE_REG("fiber/getenv", cfun_fiber_getenv),
+        JANET_CORE_REG("fiber/setenv", cfun_fiber_setenv),
+        JANET_CORE_REG("fiber/can-resume?", cfun_fiber_can_resume),
+        JANET_CORE_REG("fiber/last-value", cfun_fiber_last_value),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, fiber_cfuns);
 }

src/core/fiber.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -23,9 +23,42 @@
 #ifndef JANET_FIBER_H_defined
 #define JANET_FIBER_H_defined
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include <janet.h>
+#endif
 
-extern JANET_THREAD_LOCAL JanetFiber *janet_vm_fiber;
+/* Fiber signal masks. */
+#define JANET_FIBER_MASK_ERROR 2
+#define JANET_FIBER_MASK_DEBUG 4
+#define JANET_FIBER_MASK_YIELD 8
+
+#define JANET_FIBER_MASK_USER0 (16 << 0)
+#define JANET_FIBER_MASK_USER1 (16 << 1)
+#define JANET_FIBER_MASK_USER2 (16 << 2)
+#define JANET_FIBER_MASK_USER3 (16 << 3)
+#define JANET_FIBER_MASK_USER4 (16 << 4)
+#define JANET_FIBER_MASK_USER5 (16 << 5)
+#define JANET_FIBER_MASK_USER6 (16 << 6)
+#define JANET_FIBER_MASK_USER7 (16 << 7)
+#define JANET_FIBER_MASK_USER8 (16 << 8)
+#define JANET_FIBER_MASK_USER9 (16 << 9)
+
+#define JANET_FIBER_MASK_USERN(N) (16 << (N))
+#define JANET_FIBER_MASK_USER 0x3FF0
+
+#define JANET_FIBER_STATUS_MASK 0x3F0000
+#define JANET_FIBER_RESUME_SIGNAL 0x400000
+#define JANET_FIBER_STATUS_OFFSET 16
+
+#define JANET_FIBER_BREAKPOINT       0x1000000
+#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000
+#define JANET_FIBER_RESUME_NO_SKIP   0x4000000
+#define JANET_FIBER_DID_LONGJUMP     0x8000000
+#define JANET_FIBER_FLAG_MASK        0xF000000
+
+#define JANET_FIBER_EV_FLAG_CANCELED 0x10000
+#define JANET_FIBER_EV_FLAG_SUSPENDED 0x20000
+#define JANET_FIBER_FLAG_ROOT 0x40000
 
 #define janet_fiber_set_status(f, s) do {\
     (f)->flags &= ~JANET_FIBER_STATUS_MASK;\
@@ -43,5 +76,11 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func);
 int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func);
 void janet_fiber_cframe(JanetFiber *fiber, JanetCFunction cfun);
 void janet_fiber_popframe(JanetFiber *fiber);
+void janet_env_maybe_detach(JanetFuncEnv *env);
+int janet_env_valid(JanetFuncEnv *env);
+
+#ifdef JANET_EV
+void janet_fiber_did_resume(JanetFiber *fiber);
+#endif
 
 #endif

src/core/gc.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,21 +20,16 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
 #include "state.h"
 #include "symcache.h"
 #include "gc.h"
-
-/* GC State */
-JANET_THREAD_LOCAL void *janet_vm_blocks;
-JANET_THREAD_LOCAL uint32_t janet_vm_gc_interval;
-JANET_THREAD_LOCAL uint32_t janet_vm_next_collection;
-JANET_THREAD_LOCAL int janet_vm_gc_suspend = 0;
-
-/* Roots */
-JANET_THREAD_LOCAL Janet *janet_vm_roots;
-JANET_THREAD_LOCAL uint32_t janet_vm_root_count;
-JANET_THREAD_LOCAL uint32_t janet_vm_root_capacity;
+#include "util.h"
+#include "fiber.h"
+#include "vector.h"
+#endif
 
 /* Helpers for marking the various gc types */
 static void janet_mark_funcenv(JanetFuncEnv *env);
@@ -49,27 +44,51 @@ static void janet_mark_string(const uint8_t *str);
 static void janet_mark_fiber(JanetFiber *fiber);
 static void janet_mark_abstract(void *adata);
 
-/* Local state that is only temporary */
+/* Local state that is only temporary for gc */
 static JANET_THREAD_LOCAL uint32_t depth = JANET_RECURSION_GUARD;
-static JANET_THREAD_LOCAL uint32_t orig_rootcount;
+static JANET_THREAD_LOCAL size_t orig_rootcount;
+
+/* Hint to the GC that we may need to collect */
+void janet_gcpressure(size_t s) {
+    janet_vm.next_collection += s;
+}
 
 /* Mark a value */
 void janet_mark(Janet x) {
     if (depth) {
         depth--;
         switch (janet_type(x)) {
-            default: break;
+            default:
+                break;
             case JANET_STRING:
             case JANET_KEYWORD:
-            case JANET_SYMBOL: janet_mark_string(janet_unwrap_string(x)); break;
-            case JANET_FUNCTION: janet_mark_function(janet_unwrap_function(x)); break;
-            case JANET_ARRAY: janet_mark_array(janet_unwrap_array(x)); break;
-            case JANET_TABLE: janet_mark_table(janet_unwrap_table(x)); break;
-            case JANET_STRUCT: janet_mark_struct(janet_unwrap_struct(x)); break;
-            case JANET_TUPLE: janet_mark_tuple(janet_unwrap_tuple(x)); break;
-            case JANET_BUFFER: janet_mark_buffer(janet_unwrap_buffer(x)); break;
-            case JANET_FIBER: janet_mark_fiber(janet_unwrap_fiber(x)); break;
-            case JANET_ABSTRACT: janet_mark_abstract(janet_unwrap_abstract(x)); break;
+            case JANET_SYMBOL:
+                janet_mark_string(janet_unwrap_string(x));
+                break;
+            case JANET_FUNCTION:
+                janet_mark_function(janet_unwrap_function(x));
+                break;
+            case JANET_ARRAY:
+                janet_mark_array(janet_unwrap_array(x));
+                break;
+            case JANET_TABLE:
+                janet_mark_table(janet_unwrap_table(x));
+                break;
+            case JANET_STRUCT:
+                janet_mark_struct(janet_unwrap_struct(x));
+                break;
+            case JANET_TUPLE:
+                janet_mark_tuple(janet_unwrap_tuple(x));
+                break;
+            case JANET_BUFFER:
+                janet_mark_buffer(janet_unwrap_buffer(x));
+                break;
+            case JANET_FIBER:
+                janet_mark_fiber(janet_unwrap_fiber(x));
+                break;
+            case JANET_ABSTRACT:
+                janet_mark_abstract(janet_unwrap_abstract(x));
+                break;
         }
         depth++;
     } else {
@@ -78,7 +97,7 @@ void janet_mark(Janet x) {
 }
 
 static void janet_mark_string(const uint8_t *str) {
-    janet_gc_mark(janet_string_raw(str));
+    janet_gc_mark(janet_string_head(str));
 }
 
 static void janet_mark_buffer(JanetBuffer *buffer) {
@@ -86,16 +105,26 @@ static void janet_mark_buffer(JanetBuffer *buffer) {
 }
 
 static void janet_mark_abstract(void *adata) {
-    if (janet_gc_reachable(janet_abstract_header(adata)))
+#ifdef JANET_EV
+    /* Check if abstract type is a threaded abstract type. If it is, marking means
+     * updating the threaded_abstract table. */
+    if ((janet_abstract_head(adata)->gc.flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_THREADED_ABSTRACT) {
+        janet_table_put(&janet_vm.threaded_abstracts, janet_wrap_abstract(adata), janet_wrap_true());
         return;
-    janet_gc_mark(janet_abstract_header(adata));
-    if (janet_abstract_header(adata)->type->gcmark) {
-        janet_abstract_header(adata)->type->gcmark(adata, janet_abstract_size(adata));
+    }
+#endif
+    if (janet_gc_reachable(janet_abstract_head(adata)))
+        return;
+    janet_gc_mark(janet_abstract_head(adata));
+    if (janet_abstract_head(adata)->type->gcmark) {
+        janet_abstract_head(adata)->type->gcmark(adata, janet_abstract_size(adata));
     }
 }
 
 /* Mark a bunch of items in memory */
 static void janet_mark_many(const Janet *values, int32_t n) {
+    if (values == NULL)
+        return;
     const Janet *end = values + n;
     while (values < end) {
         janet_mark(*values);
@@ -121,7 +150,7 @@ static void janet_mark_array(JanetArray *array) {
 }
 
 static void janet_mark_table(JanetTable *table) {
-    recur: /* Manual tail recursion */
+recur: /* Manual tail recursion */
     if (janet_gc_reachable(table))
         return;
     janet_gc_mark(table);
@@ -133,16 +162,19 @@ static void janet_mark_table(JanetTable *table) {
 }
 
 static void janet_mark_struct(const JanetKV *st) {
-    if (janet_gc_reachable(janet_struct_raw(st)))
+recur:
+    if (janet_gc_reachable(janet_struct_head(st)))
         return;
-    janet_gc_mark(janet_struct_raw(st));
+    janet_gc_mark(janet_struct_head(st));
     janet_mark_kvs(st, janet_struct_capacity(st));
+    st = janet_struct_proto(st);
+    if (st) goto recur;
 }
 
 static void janet_mark_tuple(const Janet *tuple) {
-    if (janet_gc_reachable(janet_tuple_raw(tuple)))
+    if (janet_gc_reachable(janet_tuple_head(tuple)))
         return;
-    janet_gc_mark(janet_tuple_raw(tuple));
+    janet_gc_mark(janet_tuple_head(tuple));
     janet_mark_many(tuple, janet_tuple_length(tuple));
 }
 
@@ -151,7 +183,10 @@ static void janet_mark_funcenv(JanetFuncEnv *env) {
     if (janet_gc_reachable(env))
         return;
     janet_gc_mark(env);
-    if (env->offset) {
+    /* If closure env references a dead fiber, we can just copy out the stack frame we need so
+     * we don't need to keep around the whole dead fiber. */
+    janet_env_maybe_detach(env);
+    if (env->offset > 0) {
         /* On stack */
         janet_mark_fiber(env->as.fiber);
     } else {
@@ -182,11 +217,14 @@ static void janet_mark_function(JanetFunction *func) {
     if (janet_gc_reachable(func))
         return;
     janet_gc_mark(func);
-    numenvs = func->def->environments_length;
-    for (i = 0; i < numenvs; ++i) {
-        janet_mark_funcenv(func->envs[i]);
+    if (NULL != func->def) {
+        /* this should always be true, except if function is only partially constructed */
+        numenvs = func->def->environments_length;
+        for (i = 0; i < numenvs; ++i) {
+            janet_mark_funcenv(func->envs[i]);
+        }
+        janet_mark_funcdef(func->def);
     }
-    janet_mark_funcdef(func->def);
 }
 
 static void janet_mark_fiber(JanetFiber *fiber) {
@@ -197,9 +235,11 @@ recur:
         return;
     janet_gc_mark(fiber);
 
+    janet_mark(fiber->last_value);
+
     /* Mark values on the argument stack */
     janet_mark_many(fiber->data + fiber->stackstart,
-            fiber->stacktop - fiber->stackstart);
+                    fiber->stacktop - fiber->stackstart);
 
     i = fiber->frame;
     j = fiber->stackstart - JANET_FRAME_SIZE;
@@ -215,6 +255,15 @@ recur:
         i = frame->prevframe;
     }
 
+    if (fiber->env)
+        janet_mark_table(fiber->env);
+
+#ifdef JANET_EV
+    if (fiber->supervisor_channel) {
+        janet_mark_abstract(fiber->supervisor_channel);
+    }
+#endif
+
     /* Explicit tail recursion */
     if (fiber->child) {
         fiber = fiber->child;
@@ -223,136 +272,203 @@ recur:
 }
 
 /* Deinitialize a block of memory */
-static void janet_deinit_block(JanetGCMemoryHeader *block) {
-    void *mem = ((char *)(block + 1));
-    JanetAbstractHeader *h = (JanetAbstractHeader *)mem;
-    switch (block->flags & JANET_MEM_TYPEBITS) {
+static void janet_deinit_block(JanetGCObject *mem) {
+    switch (mem->flags & JANET_MEM_TYPEBITS) {
         default:
         case JANET_MEMORY_FUNCTION:
             break; /* Do nothing for non gc types */
         case JANET_MEMORY_SYMBOL:
-            janet_symbol_deinit((const uint8_t *)mem + 2 * sizeof(int32_t));
+            janet_symbol_deinit(((JanetStringHead *) mem)->data);
             break;
         case JANET_MEMORY_ARRAY:
-            janet_array_deinit((JanetArray*) mem);
+            janet_free(((JanetArray *) mem)->data);
             break;
         case JANET_MEMORY_TABLE:
-            janet_table_deinit((JanetTable*) mem);
+            janet_free(((JanetTable *) mem)->data);
             break;
         case JANET_MEMORY_FIBER:
-            free(((JanetFiber *)mem)->data);
+            janet_free(((JanetFiber *)mem)->data);
             break;
         case JANET_MEMORY_BUFFER:
             janet_buffer_deinit((JanetBuffer *) mem);
             break;
-        case JANET_MEMORY_ABSTRACT:
-            if (h->type->gc) {
-                janet_assert(!h->type->gc((void *)(h + 1), h->size), "finalizer failed");
+        case JANET_MEMORY_ABSTRACT: {
+            JanetAbstractHead *head = (JanetAbstractHead *)mem;
+            if (head->type->gc) {
+                janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
             }
-            break;
-        case JANET_MEMORY_FUNCENV:
-            {
-                JanetFuncEnv *env = (JanetFuncEnv *)mem;
-                if (0 == env->offset)
-                    free(env->as.values);
-            }
-            break;
-        case JANET_MEMORY_FUNCDEF:
-            {
-                JanetFuncDef *def = (JanetFuncDef *)mem;
-                /* TODO - get this all with one alloc and one free */
-                free(def->defs);
-                free(def->environments);
-                free(def->constants);
-                free(def->bytecode);
-                free(def->sourcemap);
-            }
-            break;
+        }
+        break;
+        case JANET_MEMORY_FUNCENV: {
+            JanetFuncEnv *env = (JanetFuncEnv *)mem;
+            if (0 == env->offset)
+                janet_free(env->as.values);
+        }
+        break;
+        case JANET_MEMORY_FUNCDEF: {
+            JanetFuncDef *def = (JanetFuncDef *)mem;
+            /* TODO - get this all with one alloc and one free */
+            janet_free(def->defs);
+            janet_free(def->environments);
+            janet_free(def->constants);
+            janet_free(def->bytecode);
+            janet_free(def->sourcemap);
+            janet_free(def->closure_bitset);
+        }
+        break;
     }
 }
 
 /* Iterate over all allocated memory, and free memory that is not
  * marked as reachable. Flip the gc color flag for next sweep. */
 void janet_sweep() {
-    JanetGCMemoryHeader *previous = NULL;
-    JanetGCMemoryHeader *current = janet_vm_blocks;
-    JanetGCMemoryHeader *next;
+    JanetGCObject *previous = NULL;
+    JanetGCObject *current = janet_vm.blocks;
+    JanetGCObject *next;
     while (NULL != current) {
-        next = current->next;
+        next = current->data.next;
         if (current->flags & (JANET_MEM_REACHABLE | JANET_MEM_DISABLED)) {
             previous = current;
             current->flags &= ~JANET_MEM_REACHABLE;
         } else {
+            janet_vm.block_count--;
             janet_deinit_block(current);
             if (NULL != previous) {
-                previous->next = next;
+                previous->data.next = next;
             } else {
-                janet_vm_blocks = next;
+                janet_vm.blocks = next;
             }
-            free(current);
+            janet_free(current);
         }
         current = next;
     }
+#ifdef JANET_EV
+    /* Sweep threaded abstract types for references to decrement */
+    JanetKV *items = janet_vm.threaded_abstracts.data;
+    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
+             * abstract type isn't present in the heap and needs its refcount
+             * decremented, and shouuld be removed from table. If the refcount is
+             * then 0, the item will be collected. This ensures that only one interpreter
+             * will clean up the threaded abstract. */
+
+            /* If not visited... */
+            if (!janet_truthy(items[i].value)) {
+                void *abst = janet_unwrap_abstract(items[i].key);
+                if (0 == janet_abstract_decref(abst)) {
+                    /* Run finalizer */
+                    JanetAbstractHead *head = janet_abstract_head(abst);
+                    if (head->type->gc) {
+                        janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
+                    }
+                    /* Mark as tombstone in place */
+                    items[i].key = janet_wrap_nil();
+                    items[i].value = janet_wrap_false();
+                    janet_vm.threaded_abstracts.deleted++;
+                    janet_vm.threaded_abstracts.count--;
+                    /* Free memory */
+                    janet_free(janet_abstract_head(abst));
+                }
+            }
+
+            /* Reset for next sweep */
+            items[i].value = janet_wrap_false();
+        }
+    }
+#endif
 }
 
 /* Allocate some memory that is tracked for garbage collection */
 void *janet_gcalloc(enum JanetMemoryType type, size_t size) {
-    JanetGCMemoryHeader *mdata;
-    size_t total = size + sizeof(JanetGCMemoryHeader);
+    JanetGCObject *mem;
 
     /* Make sure everything is inited */
-    janet_assert(NULL != janet_vm_cache, "please initialize janet before use");
-    void *mem = malloc(total);
+    janet_assert(NULL != janet_vm.cache, "please initialize janet before use");
+    mem = janet_malloc(size);
 
     /* Check for bad malloc */
     if (NULL == mem) {
         JANET_OUT_OF_MEMORY;
     }
 
-    mdata = (JanetGCMemoryHeader *)mem;
-
     /* Configure block */
-    mdata->flags = type;
+    mem->flags = type;
 
     /* Prepend block to heap list */
-    janet_vm_next_collection += (int32_t) size;
-    mdata->next = janet_vm_blocks;
-    janet_vm_blocks = mdata;
+    janet_vm.next_collection += size;
+    mem->data.next = janet_vm.blocks;
+    janet_vm.blocks = mem;
+    janet_vm.block_count++;
 
-    return (char *) mem + sizeof(JanetGCMemoryHeader);
+    return (void *)mem;
+}
+
+static void free_one_scratch(JanetScratch *s) {
+    if (NULL != s->finalize) {
+        s->finalize((char *) s->mem);
+    }
+    janet_free(s);
+}
+
+/* Free all allocated scratch memory */
+static void janet_free_all_scratch(void) {
+    for (size_t i = 0; i < janet_vm.scratch_len; i++) {
+        free_one_scratch(janet_vm.scratch_mem[i]);
+    }
+    janet_vm.scratch_len = 0;
+}
+
+static JanetScratch *janet_mem2scratch(void *mem) {
+    JanetScratch *s = (JanetScratch *)mem;
+    return s - 1;
 }
 
 /* Run garbage collection */
 void janet_collect(void) {
     uint32_t i;
-    if (janet_vm_gc_suspend) return;
+    if (janet_vm.gc_suspend) return;
     depth = JANET_RECURSION_GUARD;
-    orig_rootcount = janet_vm_root_count;
+    /* Try and prevent many major collections back to back.
+     * A full collection will take O(janet_vm.block_count) time.
+     * If we have a large heap, make sure our interval is not too
+     * small so we won't make many collections over it. This is just a
+     * heuristic for automatically changing the gc interval */
+    if (janet_vm.block_count * 8 > janet_vm.gc_interval) {
+        janet_vm.gc_interval = janet_vm.block_count * sizeof(JanetGCObject);
+    }
+    orig_rootcount = janet_vm.root_count;
+#ifdef JANET_EV
+    janet_ev_mark();
+#endif
+    janet_mark_fiber(janet_vm.root_fiber);
     for (i = 0; i < orig_rootcount; i++)
-        janet_mark(janet_vm_roots[i]);
-    while (orig_rootcount < janet_vm_root_count) {
-        Janet x = janet_vm_roots[--janet_vm_root_count];
+        janet_mark(janet_vm.roots[i]);
+    while (orig_rootcount < janet_vm.root_count) {
+        Janet x = janet_vm.roots[--janet_vm.root_count];
         janet_mark(x);
     }
     janet_sweep();
-    janet_vm_next_collection = 0;
+    janet_vm.next_collection = 0;
+    janet_free_all_scratch();
 }
 
 /* Add a root value to the GC. This prevents the GC from removing a value
  * and all of its children. If gcroot is called on a value n times, unroot
  * must also be called n times to remove it as a gc root. */
 void janet_gcroot(Janet root) {
-    uint32_t newcount = janet_vm_root_count + 1;
-    if (newcount > janet_vm_root_capacity) {
-        uint32_t newcap = 2 * newcount;
-        janet_vm_roots = realloc(janet_vm_roots, sizeof(Janet) * newcap);
-        if (NULL == janet_vm_roots) {
+    size_t newcount = janet_vm.root_count + 1;
+    if (newcount > janet_vm.root_capacity) {
+        size_t newcap = 2 * newcount;
+        janet_vm.roots = janet_realloc(janet_vm.roots, sizeof(Janet) * newcap);
+        if (NULL == janet_vm.roots) {
             JANET_OUT_OF_MEMORY;
         }
-        janet_vm_root_capacity = newcap;
+        janet_vm.root_capacity = newcap;
     }
-    janet_vm_roots[janet_vm_root_count] = root;
-    janet_vm_root_count = newcount;
+    janet_vm.roots[janet_vm.root_count] = root;
+    janet_vm.root_count = newcount;
 }
 
 /* Identity equality for GC purposes */
@@ -360,8 +476,7 @@ static int janet_gc_idequals(Janet lhs, Janet rhs) {
     if (janet_type(lhs) != janet_type(rhs))
         return 0;
     switch (janet_type(lhs)) {
-        case JANET_TRUE:
-        case JANET_FALSE:
+        case JANET_BOOLEAN:
         case JANET_NIL:
         case JANET_NUMBER:
             /* These values don't really matter to the gc so returning 1 all the time is fine. */
@@ -374,12 +489,11 @@ static int janet_gc_idequals(Janet lhs, Janet rhs) {
 /* Remove a root value from the GC. This allows the gc to potentially reclaim
  * a value and all its children. */
 int janet_gcunroot(Janet root) {
-    Janet *vtop = janet_vm_roots + janet_vm_root_count;
-    Janet *v = janet_vm_roots;
+    Janet *vtop = janet_vm.roots + janet_vm.root_count;
     /* Search from top to bottom as access is most likely LIFO */
-    for (v = janet_vm_roots; v < vtop; v++) {
+    for (Janet *v = janet_vm.roots; v < vtop; v++) {
         if (janet_gc_idequals(root, *v)) {
-            *v = janet_vm_roots[--janet_vm_root_count];
+            *v = janet_vm.roots[--janet_vm.root_count];
             return 1;
         }
     }
@@ -388,13 +502,12 @@ int janet_gcunroot(Janet root) {
 
 /* Remove a root value from the GC. This sets the effective reference count to 0. */
 int janet_gcunrootall(Janet root) {
-    Janet *vtop = janet_vm_roots + janet_vm_root_count;
-    Janet *v = janet_vm_roots;
+    Janet *vtop = janet_vm.roots + janet_vm.root_count;
     int ret = 0;
     /* Search from top to bottom as access is most likely LIFO */
-    for (v = janet_vm_roots; v < vtop; v++) {
+    for (Janet *v = janet_vm.roots; v < vtop; v++) {
         if (janet_gc_idequals(root, *v)) {
-            *v = janet_vm_roots[--janet_vm_root_count];
+            *v = janet_vm.roots[--janet_vm.root_count];
             vtop--;
             ret = 1;
         }
@@ -404,16 +517,108 @@ int janet_gcunrootall(Janet root) {
 
 /* Free all allocated memory */
 void janet_clear_memory(void) {
-    JanetGCMemoryHeader *current = janet_vm_blocks;
+#ifdef JANET_EV
+    JanetKV *items = janet_vm.threaded_abstracts.data;
+    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)) {
+                JanetAbstractHead *head = janet_abstract_head(abst);
+                if (head->type->gc) {
+                    janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
+                }
+                janet_free(janet_abstract_head(abst));
+            }
+        }
+    }
+#endif
+    JanetGCObject *current = janet_vm.blocks;
     while (NULL != current) {
         janet_deinit_block(current);
-        JanetGCMemoryHeader *next = current->next;
-        free(current);
+        JanetGCObject *next = current->data.next;
+        janet_free(current);
         current = next;
     }
-    janet_vm_blocks = NULL;
+    janet_vm.blocks = NULL;
+    janet_free_all_scratch();
+    janet_free(janet_vm.scratch_mem);
 }
 
 /* Primitives for suspending GC. */
-int janet_gclock(void) { return janet_vm_gc_suspend++; }
-void janet_gcunlock(int handle) { janet_vm_gc_suspend = handle; }
+int janet_gclock(void) {
+    return janet_vm.gc_suspend++;
+}
+void janet_gcunlock(int handle) {
+    janet_vm.gc_suspend = handle;
+}
+
+/* Scratch memory API */
+
+void *janet_smalloc(size_t size) {
+    JanetScratch *s = janet_malloc(sizeof(JanetScratch) + size);
+    if (NULL == s) {
+        JANET_OUT_OF_MEMORY;
+    }
+    s->finalize = NULL;
+    if (janet_vm.scratch_len == janet_vm.scratch_cap) {
+        size_t newcap = 2 * janet_vm.scratch_cap + 2;
+        JanetScratch **newmem = (JanetScratch **) janet_realloc(janet_vm.scratch_mem, newcap * sizeof(JanetScratch));
+        if (NULL == newmem) {
+            JANET_OUT_OF_MEMORY;
+        }
+        janet_vm.scratch_cap = newcap;
+        janet_vm.scratch_mem = newmem;
+    }
+    janet_vm.scratch_mem[janet_vm.scratch_len++] = s;
+    return (char *)(s->mem);
+}
+
+void *janet_scalloc(size_t nmemb, size_t size) {
+    if (nmemb && size > SIZE_MAX / nmemb) {
+        JANET_OUT_OF_MEMORY;
+    }
+    size_t n = nmemb * size;
+    void *p = janet_smalloc(n);
+    memset(p, 0, n);
+    return p;
+}
+
+void *janet_srealloc(void *mem, size_t size) {
+    if (NULL == mem) return janet_smalloc(size);
+    JanetScratch *s = janet_mem2scratch(mem);
+    if (janet_vm.scratch_len) {
+        for (size_t i = janet_vm.scratch_len - 1; ; i--) {
+            if (janet_vm.scratch_mem[i] == s) {
+                JanetScratch *news = janet_realloc(s, size + sizeof(JanetScratch));
+                if (NULL == news) {
+                    JANET_OUT_OF_MEMORY;
+                }
+                janet_vm.scratch_mem[i] = news;
+                return (char *)(news->mem);
+            }
+            if (i == 0) break;
+        }
+    }
+    JANET_EXIT("invalid janet_srealloc");
+}
+
+void janet_sfinalizer(void *mem, JanetScratchFinalizer finalizer) {
+    JanetScratch *s = janet_mem2scratch(mem);
+    s->finalize = finalizer;
+}
+
+void janet_sfree(void *mem) {
+    if (NULL == mem) return;
+    JanetScratch *s = janet_mem2scratch(mem);
+    if (janet_vm.scratch_len) {
+        for (size_t i = janet_vm.scratch_len - 1; ; i--) {
+            if (janet_vm.scratch_mem[i] == s) {
+                janet_vm.scratch_mem[i] = janet_vm.scratch_mem[--janet_vm.scratch_len];
+                free_one_scratch(s);
+                return;
+            }
+            if (i == 0) break;
+        }
+    }
+    JANET_EXIT("invalid janet_sfree");
+}

src/core/gc.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -23,10 +23,13 @@
 #ifndef JANET_GC_H
 #define JANET_GC_H
 
-#include <janet/janet.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
+#endif
 
 /* The metadata header associated with an allocated block of memory */
-#define janet_gc_header(mem) ((JanetGCMemoryHeader *)(mem) - 1)
+#define janet_gc_header(mem) ((JanetGCObject *)(mem))
 
 #define JANET_MEM_TYPEBITS 0xFF
 #define JANET_MEM_REACHABLE 0x100
@@ -36,16 +39,8 @@
 #define janet_gc_type(m) (janet_gc_header(m)->flags & 0xFF)
 
 #define janet_gc_mark(m) (janet_gc_header(m)->flags |= JANET_MEM_REACHABLE)
-#define janet_gc_unmark(m) (janet_gc_header(m)->flags &= ~JANET_MEM_COLOR)
 #define janet_gc_reachable(m) (janet_gc_header(m)->flags & JANET_MEM_REACHABLE)
 
-/* Memory header struct. Node of a linked list of memory blocks. */
-typedef struct JanetGCMemoryHeader JanetGCMemoryHeader;
-struct JanetGCMemoryHeader {
-    JanetGCMemoryHeader *next;
-    uint32_t flags;
-};
-
 /* Memory types for the GC. Different from JanetType to include funcenv and funcdef. */
 enum JanetMemoryType {
     JANET_MEMORY_NONE,
@@ -60,10 +55,11 @@ enum JanetMemoryType {
     JANET_MEMORY_FUNCTION,
     JANET_MEMORY_ABSTRACT,
     JANET_MEMORY_FUNCENV,
-    JANET_MEMORY_FUNCDEF
+    JANET_MEMORY_FUNCDEF,
+    JANET_MEMORY_THREADED_ABSTRACT,
 };
 
-/* To allocate collectable memory, one must calk janet_alloc, initialize the memory,
+/* 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) */
 void *janet_gcalloc(enum JanetMemoryType type, size_t size);
 

src/core/inttypes.c

@@ -0,0 +1,612 @@
+/*
+* Copyright (c) 2022 Calvin Rose & contributors
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to
+* deal in the Software without restriction, including without limitation the
+* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+* sell copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+* IN THE SOFTWARE.
+*/
+
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
+#include "util.h"
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <inttypes.h>
+#include <math.h>
+
+/* Conditional compilation */
+#ifdef JANET_INT_TYPES
+
+#define MAX_INT_IN_DBL 9007199254740992ULL /* 2^53 */
+
+static int it_s64_get(void *p, Janet key, Janet *out);
+static int it_u64_get(void *p, Janet key, Janet *out);
+static Janet janet_int64_next(void *p, Janet key);
+static Janet janet_uint64_next(void *p, Janet key);
+
+static int32_t janet_int64_hash(void *p1, size_t size) {
+    (void) size;
+    int32_t *words = p1;
+    return words[0] ^ words[1];
+}
+
+static int janet_int64_compare(void *p1, void *p2) {
+    int64_t x = *((int64_t *)p1);
+    int64_t y = *((int64_t *)p2);
+    return x == y ? 0 : x < y ? -1 : 1;
+}
+
+static int janet_uint64_compare(void *p1, void *p2) {
+    uint64_t x = *((uint64_t *)p1);
+    uint64_t y = *((uint64_t *)p2);
+    return x == y ? 0 : x < y ? -1 : 1;
+}
+
+static void int64_marshal(void *p, JanetMarshalContext *ctx) {
+    janet_marshal_abstract(ctx, p);
+    janet_marshal_int64(ctx, *((int64_t *)p));
+}
+
+static void *int64_unmarshal(JanetMarshalContext *ctx) {
+    int64_t *p = janet_unmarshal_abstract(ctx, sizeof(int64_t));
+    p[0] = janet_unmarshal_int64(ctx);
+    return p;
+}
+
+static void it_s64_tostring(void *p, JanetBuffer *buffer) {
+    char str[32];
+    sprintf(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));
+    janet_buffer_push_cstring(buffer, str);
+}
+
+const JanetAbstractType janet_s64_type = {
+    "core/s64",
+    NULL,
+    NULL,
+    it_s64_get,
+    NULL,
+    int64_marshal,
+    int64_unmarshal,
+    it_s64_tostring,
+    janet_int64_compare,
+    janet_int64_hash,
+    janet_int64_next,
+    JANET_ATEND_NEXT
+};
+
+const JanetAbstractType janet_u64_type = {
+    "core/u64",
+    NULL,
+    NULL,
+    it_u64_get,
+    NULL,
+    int64_marshal,
+    int64_unmarshal,
+    it_u64_tostring,
+    janet_uint64_compare,
+    janet_int64_hash,
+    janet_uint64_next,
+    JANET_ATEND_NEXT
+};
+
+int64_t janet_unwrap_s64(Janet x) {
+    switch (janet_type(x)) {
+        default:
+            break;
+        case JANET_NUMBER : {
+            double dbl = janet_unwrap_number(x);
+            if (fabs(dbl) <=  MAX_INT_IN_DBL)
+                return (int64_t)dbl;
+            break;
+        }
+        case JANET_STRING: {
+            int64_t value;
+            const uint8_t *str = janet_unwrap_string(x);
+            if (janet_scan_int64(str, janet_string_length(str), &value))
+                return value;
+            break;
+        }
+        case JANET_ABSTRACT: {
+            void *abst = janet_unwrap_abstract(x);
+            if (janet_abstract_type(abst) == &janet_s64_type ||
+                    (janet_abstract_type(abst) == &janet_u64_type))
+                return *(int64_t *)abst;
+            break;
+        }
+    }
+    janet_panicf("bad s64 initializer: %t", x);
+    return 0;
+}
+
+uint64_t janet_unwrap_u64(Janet x) {
+    switch (janet_type(x)) {
+        default:
+            break;
+        case JANET_NUMBER : {
+            double dbl = janet_unwrap_number(x);
+            /* Allow negative values to be cast to "wrap around".
+             * This let's addition and subtraction work as expected. */
+            if (fabs(dbl) <=  MAX_INT_IN_DBL)
+                return (uint64_t)dbl;
+            break;
+        }
+        case JANET_STRING: {
+            uint64_t value;
+            const uint8_t *str = janet_unwrap_string(x);
+            if (janet_scan_uint64(str, janet_string_length(str), &value))
+                return value;
+            break;
+        }
+        case JANET_ABSTRACT: {
+            void *abst = janet_unwrap_abstract(x);
+            if (janet_abstract_type(abst) == &janet_s64_type ||
+                    (janet_abstract_type(abst) == &janet_u64_type))
+                return *(uint64_t *)abst;
+            break;
+        }
+    }
+    janet_panicf("bad u64 initializer: %t", x);
+    return 0;
+}
+
+JanetIntType janet_is_int(Janet x) {
+    if (!janet_checktype(x, JANET_ABSTRACT)) return JANET_INT_NONE;
+    const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(x));
+    return (at == &janet_s64_type) ? JANET_INT_S64 :
+           ((at == &janet_u64_type) ? JANET_INT_U64 :
+            JANET_INT_NONE);
+}
+
+Janet janet_wrap_s64(int64_t x) {
+    int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
+    *box = (int64_t)x;
+    return janet_wrap_abstract(box);
+}
+
+Janet janet_wrap_u64(uint64_t x) {
+    uint64_t *box = janet_abstract(&janet_u64_type, sizeof(uint64_t));
+    *box = (uint64_t)x;
+    return janet_wrap_abstract(box);
+}
+
+JANET_CORE_FN(cfun_it_s64_new,
+              "(int/s64 value)",
+              "Create a boxed signed 64 bit integer from a string value.") {
+    janet_fixarity(argc, 1);
+    return janet_wrap_s64(janet_unwrap_s64(argv[0]));
+}
+
+JANET_CORE_FN(cfun_it_u64_new,
+              "(int/u64 value)",
+              "Create a boxed unsigned 64 bit integer from a string value.") {
+    janet_fixarity(argc, 1);
+    return janet_wrap_u64(janet_unwrap_u64(argv[0]));
+}
+
+JANET_CORE_FN(cfun_to_number,
+              "(int/to-number value)",
+              "Convert an int/u64 or int/s64 to a number. Fails if the number is out of range for an int32.") {
+    janet_fixarity(argc, 1);
+    if (janet_type(argv[0]) == JANET_ABSTRACT) {
+        void *abst = janet_unwrap_abstract(argv[0]);
+
+        if (janet_abstract_type(abst) == &janet_s64_type) {
+            int64_t value = *((int64_t *)abst);
+            if (value > JANET_INTMAX_INT64) {
+                janet_panicf("cannot convert %q to a number, must be in the range [%q, %q]", argv[0], janet_wrap_number(JANET_INTMIN_DOUBLE), janet_wrap_number(JANET_INTMAX_DOUBLE));
+            }
+            if (value < -JANET_INTMAX_INT64) {
+                janet_panicf("cannot convert %q to a number, must be in the range [%q, %q]", argv[0], janet_wrap_number(JANET_INTMIN_DOUBLE), janet_wrap_number(JANET_INTMAX_DOUBLE));
+            }
+            return janet_wrap_number((double)value);
+        }
+
+        if (janet_abstract_type(abst) == &janet_u64_type) {
+            uint64_t value = *((uint64_t *)abst);
+            if (value > JANET_INTMAX_INT64) {
+                janet_panicf("cannot convert %q to a number, must be in the range [%q, %q]", argv[0], janet_wrap_number(JANET_INTMIN_DOUBLE), janet_wrap_number(JANET_INTMAX_DOUBLE));
+            }
+
+            return janet_wrap_number((double)value);
+        }
+    }
+
+    janet_panicf("expected int/u64 or int/s64, got %q", argv[0]);
+}
+
+JANET_CORE_FN(cfun_to_bytes,
+              "(int/to-bytes value &opt endianness buffer)",
+              "Write the bytes of an `int/s64` or `int/u64` into a buffer.\n"
+              "The `buffer` parameter specifies an existing buffer to write to, if unset a new buffer will be created.\n"
+              "Returns the modified buffer.\n"
+              "The `endianness` paramater indicates the byte order:\n"
+              "- `nil` (unset): system byte order\n"
+              "- `:le`: little-endian, least significant byte first\n"
+              "- `:be`: big-endian, most significant byte first\n") {
+    janet_arity(argc, 1, 3);
+    if (janet_is_int(argv[0]) == JANET_INT_NONE) {
+        janet_panicf("int/to-bytes: expected an int/s64 or int/u64, got %q", argv[0]);
+    }
+
+    int reverse = 0;
+    if (argc > 1 && !janet_checktype(argv[1], JANET_NIL)) {
+        JanetKeyword endianness_kw = janet_getkeyword(argv, 1);
+        if (!janet_cstrcmp(endianness_kw, "le")) {
+#if JANET_BIG_ENDIAN
+            reverse = 1;
+#endif
+        } else if (!janet_cstrcmp(endianness_kw, "be")) {
+#if JANET_LITTLE_ENDIAN
+            reverse = 1;
+#endif
+        } else {
+            janet_panicf("int/to-bytes: expected endianness :le, :be or nil, got %v", argv[1]);
+        }
+    }
+
+    JanetBuffer *buffer = NULL;
+    if (argc > 2 && !janet_checktype(argv[2], JANET_NIL)) {
+        if (!janet_checktype(argv[2], JANET_BUFFER)) {
+            janet_panicf("int/to-bytes: expected buffer or nil, got %q", argv[2]);
+        }
+
+        buffer = janet_unwrap_buffer(argv[2]);
+        janet_buffer_extra(buffer, 8);
+    } else {
+        buffer = janet_buffer(8);
+    }
+
+    uint8_t *bytes = janet_unwrap_abstract(argv[0]);
+    if (reverse) {
+        for (int i = 0; i < 8; ++i) {
+            buffer->data[buffer->count + 7 - i] = bytes[i];
+        }
+    } else {
+        memcpy(buffer->data + buffer->count, bytes, 8);
+    }
+    buffer->count += 8;
+
+    return janet_wrap_buffer(buffer);
+}
+
+/*
+ * Code to support polymorphic comparison.
+ * int/u64 and int/s64 support a "compare" method that allows
+ * comparison to each other, and to Janet numbers, using the
+ * "compare" "compare<" ... functions.
+ * In the following code explicit casts are sometimes used to help
+ * make it clear when int/float conversions are happening.
+ */
+static int compare_double_double(double x, double y) {
+    return (x < y) ? -1 : ((x > y) ? 1 : 0);
+}
+
+static int compare_int64_double(int64_t x, double y) {
+    if (isnan(y)) {
+        return 0; // clojure and python do this
+    } else if ((y > (- ((double) MAX_INT_IN_DBL))) && (y < ((double) MAX_INT_IN_DBL))) {
+        double dx = (double) x;
+        return compare_double_double(dx, y);
+    } else if (y > ((double) INT64_MAX)) {
+        return -1;
+    } else if (y < ((double) INT64_MIN)) {
+        return 1;
+    } else {
+        int64_t yi = (int64_t) y;
+        return (x < yi) ? -1 : ((x > yi) ? 1 : 0);
+    }
+}
+
+static int compare_uint64_double(uint64_t x, double y) {
+    if (isnan(y)) {
+        return 0; // clojure and python do this
+    } else if (y < 0) {
+        return 1;
+    } else if ((y >= 0) && (y < ((double) MAX_INT_IN_DBL))) {
+        double dx = (double) x;
+        return compare_double_double(dx, y);
+    } else if (y > ((double) UINT64_MAX)) {
+        return -1;
+    } else {
+        uint64_t yi = (uint64_t) y;
+        return (x < yi) ? -1 : ((x > yi) ? 1 : 0);
+    }
+}
+
+static Janet cfun_it_s64_compare(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    if (janet_is_int(argv[0]) != JANET_INT_S64)
+        janet_panic("compare method requires int/s64 as first argument");
+    int64_t x = janet_unwrap_s64(argv[0]);
+    switch (janet_type(argv[1])) {
+        default:
+            break;
+        case JANET_NUMBER : {
+            double y = janet_unwrap_number(argv[1]);
+            return janet_wrap_number(compare_int64_double(x, y));
+        }
+        case JANET_ABSTRACT: {
+            void *abst = janet_unwrap_abstract(argv[1]);
+            if (janet_abstract_type(abst) == &janet_s64_type) {
+                int64_t y = *(int64_t *)abst;
+                return janet_wrap_number((x < y) ? -1 : (x > y ? 1 : 0));
+            } else if (janet_abstract_type(abst) == &janet_u64_type) {
+                // comparing signed to unsigned -- be careful!
+                uint64_t y = *(uint64_t *)abst;
+                if (x < 0) {
+                    return janet_wrap_number(-1);
+                } else if (y > INT64_MAX) {
+                    return janet_wrap_number(-1);
+                } else {
+                    int64_t y2 = (int64_t) y;
+                    return janet_wrap_number((x < y2) ? -1 : (x > y2 ? 1 : 0));
+                }
+            }
+            break;
+        }
+    }
+    return janet_wrap_nil();
+}
+
+static Janet cfun_it_u64_compare(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    if (janet_is_int(argv[0]) != JANET_INT_U64)  // is this needed?
+        janet_panic("compare method requires int/u64 as first argument");
+    uint64_t x = janet_unwrap_u64(argv[0]);
+    switch (janet_type(argv[1])) {
+        default:
+            break;
+        case JANET_NUMBER : {
+            double y = janet_unwrap_number(argv[1]);
+            return janet_wrap_number(compare_uint64_double(x, y));
+        }
+        case JANET_ABSTRACT: {
+            void *abst = janet_unwrap_abstract(argv[1]);
+            if (janet_abstract_type(abst) == &janet_u64_type) {
+                uint64_t y = *(uint64_t *)abst;
+                return janet_wrap_number((x < y) ? -1 : (x > y ? 1 : 0));
+            } else if (janet_abstract_type(abst) == &janet_s64_type) {
+                // comparing unsigned to signed -- be careful!
+                int64_t y = *(int64_t *)abst;
+                if (y < 0) {
+                    return janet_wrap_number(1);
+                } else if (x > INT64_MAX) {
+                    return janet_wrap_number(1);
+                } else {
+                    int64_t x2 = (int64_t) x;
+                    return janet_wrap_number((x2 < y) ? -1 : (x2 > y ? 1 : 0));
+                }
+            }
+            break;
+        }
+    }
+    return janet_wrap_nil();
+}
+
+#define OPMETHOD(T, type, name, oper) \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+    janet_arity(argc, 2, -1); \
+    T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
+    *box = janet_unwrap_##type(argv[0]); \
+    for (int32_t i = 1; i < argc; i++) \
+        *box oper##= janet_unwrap_##type(argv[i]); \
+    return janet_wrap_abstract(box); \
+} \
+
+#define OPMETHODINVERT(T, type, name, oper) \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+    janet_fixarity(argc, 2); \
+    T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
+    *box = janet_unwrap_##type(argv[1]); \
+    *box oper##= janet_unwrap_##type(argv[0]); \
+    return janet_wrap_abstract(box); \
+} \
+
+#define DIVMETHOD(T, type, name, oper) \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+    janet_arity(argc, 2, -1);                       \
+    T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
+    *box = janet_unwrap_##type(argv[0]); \
+    for (int32_t i = 1; i < argc; i++) { \
+      T value = janet_unwrap_##type(argv[i]); \
+      if (value == 0) janet_panic("division by zero"); \
+      *box oper##= value; \
+    } \
+    return janet_wrap_abstract(box); \
+} \
+
+#define DIVMETHODINVERT(T, type, name, oper) \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+    janet_fixarity(argc, 2);                       \
+    T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
+    *box = janet_unwrap_##type(argv[1]); \
+    T value = janet_unwrap_##type(argv[0]); \
+    if (value == 0) janet_panic("division by zero"); \
+    *box oper##= value; \
+    return janet_wrap_abstract(box); \
+} \
+
+#define DIVMETHOD_SIGNED(T, type, name, oper) \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+    janet_arity(argc, 2, -1);                       \
+    T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
+    *box = janet_unwrap_##type(argv[0]); \
+    for (int32_t i = 1; i < argc; i++) { \
+      T value = janet_unwrap_##type(argv[i]); \
+      if (value == 0) janet_panic("division by zero"); \
+      if ((value == -1) && (*box == INT64_MIN)) janet_panic("INT64_MIN divided by -1"); \
+      *box oper##= value; \
+    } \
+    return janet_wrap_abstract(box); \
+} \
+
+#define DIVMETHODINVERT_SIGNED(T, type, name, oper) \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
+    janet_fixarity(argc, 2);                       \
+    T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
+    *box = janet_unwrap_##type(argv[1]); \
+    T value = janet_unwrap_##type(argv[0]); \
+    if (value == 0) janet_panic("division by zero"); \
+    if ((value == -1) && (*box == INT64_MIN)) janet_panic("INT64_MIN divided by -1"); \
+    *box oper##= value; \
+    return janet_wrap_abstract(box); \
+} \
+
+static Janet cfun_it_s64_mod(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
+    int64_t op1 = janet_unwrap_s64(argv[0]);
+    int64_t op2 = janet_unwrap_s64(argv[1]);
+    int64_t x = op1 % op2;
+    *box = (op1 > 0)
+           ? ((op2 > 0) ? x : (0 == x ? x : x + op2))
+           : ((op2 > 0) ? (0 == x ? x : x + op2) : x);
+    return janet_wrap_abstract(box);
+}
+
+OPMETHOD(int64_t, s64, add, +)
+OPMETHOD(int64_t, s64, sub, -)
+OPMETHODINVERT(int64_t, s64, subi, -)
+OPMETHOD(int64_t, s64, mul, *)
+DIVMETHOD_SIGNED(int64_t, s64, div, /)
+DIVMETHOD_SIGNED(int64_t, s64, rem, %)
+DIVMETHODINVERT_SIGNED(int64_t, s64, divi, /)
+OPMETHOD(int64_t, s64, and, &)
+OPMETHOD(int64_t, s64, or, |)
+OPMETHOD(int64_t, s64, xor, ^)
+OPMETHOD(int64_t, s64, lshift, <<)
+OPMETHOD(int64_t, s64, rshift, >>)
+OPMETHOD(uint64_t, u64, add, +)
+OPMETHOD(uint64_t, u64, sub, -)
+OPMETHODINVERT(uint64_t, u64, subi, -)
+OPMETHOD(uint64_t, u64, mul, *)
+DIVMETHOD(uint64_t, u64, div, /)
+DIVMETHOD(uint64_t, u64, mod, %)
+DIVMETHODINVERT(uint64_t, u64, divi, /)
+OPMETHOD(uint64_t, u64, and, &)
+OPMETHOD(uint64_t, u64, or, |)
+OPMETHOD(uint64_t, u64, xor, ^)
+OPMETHOD(uint64_t, u64, lshift, <<)
+OPMETHOD(uint64_t, u64, rshift, >>)
+
+#undef OPMETHOD
+#undef DIVMETHOD
+#undef DIVMETHOD_SIGNED
+#undef COMPMETHOD
+
+
+static JanetMethod it_s64_methods[] = {
+    {"+", cfun_it_s64_add},
+    {"r+", cfun_it_s64_add},
+    {"-", cfun_it_s64_sub},
+    {"r-", cfun_it_s64_subi},
+    {"*", cfun_it_s64_mul},
+    {"r*", cfun_it_s64_mul},
+    {"/", cfun_it_s64_div},
+    {"r/", cfun_it_s64_divi},
+    {"mod", cfun_it_s64_mod},
+    {"rmod", cfun_it_s64_mod},
+    {"%", cfun_it_s64_rem},
+    {"r%", cfun_it_s64_rem},
+    {"&", cfun_it_s64_and},
+    {"r&", cfun_it_s64_and},
+    {"|", cfun_it_s64_or},
+    {"r|", cfun_it_s64_or},
+    {"^", cfun_it_s64_xor},
+    {"r^", cfun_it_s64_xor},
+    {"<<", cfun_it_s64_lshift},
+    {">>", cfun_it_s64_rshift},
+    {"compare", cfun_it_s64_compare},
+
+    {NULL, NULL}
+};
+
+static JanetMethod it_u64_methods[] = {
+    {"+", cfun_it_u64_add},
+    {"r+", cfun_it_u64_add},
+    {"-", cfun_it_u64_sub},
+    {"r-", cfun_it_u64_subi},
+    {"*", cfun_it_u64_mul},
+    {"r*", cfun_it_u64_mul},
+    {"/", cfun_it_u64_div},
+    {"r/", cfun_it_u64_divi},
+    {"mod", cfun_it_u64_mod},
+    {"rmod", cfun_it_u64_mod},
+    {"%", cfun_it_u64_mod},
+    {"r%", cfun_it_u64_mod},
+    {"&", cfun_it_u64_and},
+    {"r&", cfun_it_u64_and},
+    {"|", cfun_it_u64_or},
+    {"r|", cfun_it_u64_or},
+    {"^", cfun_it_u64_xor},
+    {"r^", cfun_it_u64_xor},
+    {"<<", cfun_it_u64_lshift},
+    {">>", cfun_it_u64_rshift},
+    {"compare", cfun_it_u64_compare},
+
+    {NULL, NULL}
+};
+
+static Janet janet_int64_next(void *p, Janet key) {
+    (void) p;
+    return janet_nextmethod(it_s64_methods, key);
+}
+
+static Janet janet_uint64_next(void *p, Janet key) {
+    (void) p;
+    return janet_nextmethod(it_u64_methods, key);
+}
+
+static int it_s64_get(void *p, Janet key, Janet *out) {
+    (void) p;
+    if (!janet_checktype(key, JANET_KEYWORD))
+        return 0;
+    return janet_getmethod(janet_unwrap_keyword(key), it_s64_methods, out);
+}
+
+static int it_u64_get(void *p, Janet key, Janet *out) {
+    (void) p;
+    if (!janet_checktype(key, JANET_KEYWORD))
+        return 0;
+    return janet_getmethod(janet_unwrap_keyword(key), it_u64_methods, out);
+}
+
+/* Module entry point */
+void janet_lib_inttypes(JanetTable *env) {
+    JanetRegExt it_cfuns[] = {
+        JANET_CORE_REG("int/s64", cfun_it_s64_new),
+        JANET_CORE_REG("int/u64", cfun_it_u64_new),
+        JANET_CORE_REG("int/to-number", cfun_to_number),
+        JANET_CORE_REG("int/to-bytes", cfun_to_bytes),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, it_cfuns);
+    janet_register_abstract_type(&janet_s64_type);
+    janet_register_abstract_type(&janet_u64_type);
+}
+
+#endif

src/core/io.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,138 +20,145 @@
 * IN THE SOFTWARE.
 */
 
-/* Compiler feature test macros for things */
-#define _DEFAULT_SOURCE
-#define _BSD_SOURCE
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
+#include "util.h"
+#endif
 
 #include <stdio.h>
-#include <janet/janet.h>
 #include <errno.h>
-#include "util.h"
 
-#define IO_WRITE 1
-#define IO_READ 2
-#define IO_APPEND 4
-#define IO_UPDATE 8
-#define IO_NOT_CLOSEABLE 16
-#define IO_CLOSED 32
-#define IO_BINARY 64
-#define IO_SERIALIZABLE 128
-#define IO_PIPED 256
+#ifndef JANET_WINDOWS
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
 
-typedef struct IOFile IOFile;
-struct IOFile {
-    FILE *file;
-    int flags;
-};
+static int cfun_io_gc(void *p, size_t len);
+static int io_file_get(void *p, Janet key, Janet *out);
+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);
 
-static int janet_io_gc(void *p, size_t len);
-
-JanetAbstractType janet_io_filetype = {
+const JanetAbstractType janet_file_type = {
     "core/file",
-    janet_io_gc,
-    NULL
+    cfun_io_gc,
+    NULL,
+    io_file_get,
+    NULL,
+    io_file_marshal,
+    io_file_unmarshal,
+    NULL, /* tostring */
+    NULL, /* compare */
+    NULL, /* hash */
+    io_file_next,
+    JANET_ATEND_NEXT
 };
 
 /* Check arguments to fopen */
-static int checkflags(const uint8_t *str) {
-    int flags = 0;
+static int32_t checkflags(const uint8_t *str) {
+    int32_t flags = 0;
     int32_t i;
     int32_t len = janet_string_length(str);
-    if (!len || len > 3)
-        janet_panic("file mode must have a length between 1 and 3");
+    if (!len || len > 10)
+        janet_panic("file mode must have a length between 1 and 10");
     switch (*str) {
         default:
             janet_panicf("invalid flag %c, expected w, a, or r", *str);
             break;
         case 'w':
-            flags |= IO_WRITE;
+            flags |= JANET_FILE_WRITE;
             break;
         case 'a':
-            flags |= IO_APPEND;
+            flags |= JANET_FILE_APPEND;
             break;
         case 'r':
-            flags |= IO_READ;
+            flags |= JANET_FILE_READ;
             break;
     }
     for (i = 1; i < len; i++) {
         switch (str[i]) {
             default:
-                janet_panicf("invalid flag %c, expected + or b", str[i]);
+                janet_panicf("invalid flag %c, expected +, b, or n", str[i]);
                 break;
             case '+':
-                if (flags & IO_UPDATE) return -1;
-                flags |= IO_UPDATE;
+                if (flags & JANET_FILE_UPDATE) return -1;
+                flags |= JANET_FILE_UPDATE;
                 break;
             case 'b':
-                if (flags & IO_BINARY) return -1;
-                flags |= IO_BINARY;
+                if (flags & JANET_FILE_BINARY) return -1;
+                flags |= JANET_FILE_BINARY;
+                break;
+            case 'n':
+                if (flags & JANET_FILE_NONIL) return -1;
+                flags |= JANET_FILE_NONIL;
                 break;
         }
     }
     return flags;
 }
 
-static Janet makef(FILE *f, int flags) {
-    IOFile *iof = (IOFile *) janet_abstract(&janet_io_filetype, sizeof(IOFile));
+static void *makef(FILE *f, int32_t flags) {
+    JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile));
     iof->file = f;
     iof->flags = flags;
-    return janet_wrap_abstract(iof);
+#ifndef JANET_WINDOWS
+    /* While we would like fopen to set cloexec by default (like O_CLOEXEC) with the e flag, that is
+     * not standard. */
+    if (!(flags & JANET_FILE_NOT_CLOSEABLE))
+        fcntl(fileno(f), F_SETFD, FD_CLOEXEC);
+#endif
+    return iof;
 }
 
-/* Open a process */
-#ifdef __EMSCRIPTEN__
-static Janet janet_io_popen(int32_t argc, Janet *argv) {
-    (void) argc;
-    (void) argv;
-    janet_panic("not implemented on this platform");
-    return janet_wrap_nil();
+JANET_CORE_FN(cfun_io_temp,
+              "(file/temp)",
+              "Open an anonymous temporary file that is removed on close. "
+              "Raises an error on failure.") {
+    (void)argv;
+    janet_fixarity(argc, 0);
+    // 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));
+    return janet_makefile(tmp, JANET_FILE_WRITE | JANET_FILE_READ | JANET_FILE_BINARY);
 }
-#else
-static Janet janet_io_popen(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 2);
-    const uint8_t *fname = janet_getstring(argv, 0);
-    const uint8_t *fmode = NULL;
-    if (argc == 2) {
-        fmode = janet_getkeyword(argv, 1);
-        if (janet_string_length(fmode) != 1 ||
-            !(fmode[0] == 'r' || fmode[0] == 'w')) {
-            janet_panicf("invalid file mode :%S, expected :r or :w", fmode);
-        }
-    }
-    int flags = (fmode && fmode[0] == '2')
-        ? IO_PIPED | IO_WRITE
-        : IO_PIPED | IO_READ;
-#ifdef JANET_WINDOWS
-#define popen _popen
-#endif
-    FILE *f = popen((const char *)fname, (const char *)fmode);
-    if (!f) {
-        return janet_wrap_nil();
-    }
-    return makef(f, flags);
-}
-#endif
 
-static Janet janet_io_fopen(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_io_fopen,
+              "(file/open path &opt mode)",
+              "Open a file. `path` is an absolute or relative path, and "
+              "`mode` is a set of flags indicating the mode to open the file in. "
+              "`mode` is a keyword where each character represents a flag. If the file "
+              "cannot be opened, returns nil, otherwise returns the new file handle. "
+              "Mode flags:\n\n"
+              "* r - allow reading from the file\n\n"
+              "* w - allow writing to the file\n\n"
+              "* a - append to the file\n\n"
+              "Following one of the initial flags, 0 or more of the following flags can be appended:\n\n"
+              "* b - open the file in binary mode (rather than text mode)\n\n"
+              "* + - append to the file instead of overwriting it\n\n"
+              "* n - error if the file cannot be opened instead of returning nil") {
     janet_arity(argc, 1, 2);
     const uint8_t *fname = janet_getstring(argv, 0);
     const uint8_t *fmode;
-    int flags;
+    int32_t flags;
     if (argc == 2) {
         fmode = janet_getkeyword(argv, 1);
         flags = checkflags(fmode);
     } else {
         fmode = (const uint8_t *)"r";
-        flags = IO_READ;
+        flags = JANET_FILE_READ;
     }
     FILE *f = fopen((const char *)fname, (const char *)fmode);
-    return f ? makef(f, flags) : janet_wrap_nil();
+    return f ? janet_makefile(f, flags)
+           : (flags & JANET_FILE_NONIL) ? (janet_panicf("failed to open file %s: %s", fname, strerror(errno)), janet_wrap_nil())
+           : janet_wrap_nil();
 }
 
-/* Read up to n bytes into buffer. Return error string if error. */
-static void read_chunk(IOFile *iof, JanetBuffer *buffer, int32_t nBytesMax) {
-    if (!(iof->flags & (IO_READ | IO_UPDATE)))
+/* Read up to n bytes into buffer. */
+static void read_chunk(JanetFile *iof, JanetBuffer *buffer, int32_t nBytesMax) {
+    if (!(iof->flags & (JANET_FILE_READ | JANET_FILE_UPDATE)))
         janet_panic("file is not readable");
     janet_buffer_extra(buffer, nBytesMax);
     size_t ntoread = nBytesMax;
@@ -162,34 +169,36 @@ static void read_chunk(IOFile *iof, JanetBuffer *buffer, int32_t nBytesMax) {
 }
 
 /* Read a certain number of bytes into memory */
-static Janet janet_io_fread(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_io_fread,
+              "(file/read f what &opt buf)",
+              "Read a number of bytes from a file `f` into a buffer. A buffer `buf` can "
+              "be provided as an optional third argument, otherwise a new buffer "
+              "is created. `what` can either be an integer or a keyword. Returns the "
+              "buffer with file contents. "
+              "Values for `what`:\n\n"
+              "* :all - read the whole file\n\n"
+              "* :line - read up to and including the next newline character\n\n"
+              "* n (integer) - read up to n bytes from the file") {
     janet_arity(argc, 2, 3);
-    IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
-    if (iof->flags & IO_CLOSED) janet_panic("file is closed");
+    JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
+    if (iof->flags & JANET_FILE_CLOSED) janet_panic("file is closed");
     JanetBuffer *buffer;
     if (argc == 2) {
         buffer = janet_buffer(0);
     } else {
         buffer = janet_getbuffer(argv, 2);
     }
+    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")) {
-            /* Read whole file */
-            int status = fseek(iof->file, 0, SEEK_SET);
-            if (status) {
-                /* backwards fseek did not work (stream like popen) */
-                int32_t sizeBefore;
-                do {
-                    sizeBefore = buffer->count;
-                    read_chunk(iof, buffer, 1024);
-                } while (sizeBefore < buffer->count);
-            } else {
-                fseek(iof->file, 0, SEEK_END);
-                long fsize = ftell(iof->file);
-                fseek(iof->file, 0, SEEK_SET);
-                read_chunk(iof, buffer, (int32_t) fsize);
-            }
+            int32_t sizeBefore;
+            do {
+                sizeBefore = buffer->count;
+                read_chunk(iof, buffer, 4096);
+            } while (sizeBefore < buffer->count);
+            /* Never return nil for :all */
+            return janet_wrap_buffer(buffer);
         } else if (!janet_cstrcmp(sym, "line")) {
             for (;;) {
                 int x = fgetc(iof->file);
@@ -204,16 +213,20 @@ static Janet janet_io_fread(int32_t argc, Janet *argv) {
         if (len < 0) janet_panic("expected positive integer");
         read_chunk(iof, buffer, len);
     }
+    if (bufstart == buffer->count) return janet_wrap_nil();
     return janet_wrap_buffer(buffer);
 }
 
 /* Write bytes to a file */
-static Janet janet_io_fwrite(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_io_fwrite,
+              "(file/write f bytes)",
+              "Writes to a file. 'bytes' must be string, buffer, or symbol. Returns the "
+              "file.") {
     janet_arity(argc, 1, -1);
-    IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
-    if (iof->flags & IO_CLOSED)
+    JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
+    if (iof->flags & JANET_FILE_CLOSED)
         janet_panic("file is closed");
-    if (!(iof->flags & (IO_WRITE | IO_APPEND | IO_UPDATE)))
+    if (!(iof->flags & (JANET_FILE_WRITE | JANET_FILE_APPEND | JANET_FILE_UPDATE)))
         janet_panic("file is not writeable");
     int32_t i;
     /* Verify all arguments before writing to file */
@@ -231,53 +244,77 @@ static Janet janet_io_fwrite(int32_t argc, Janet *argv) {
 }
 
 /* Flush the bytes in the file */
-static Janet janet_io_fflush(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_io_fflush,
+              "(file/flush f)",
+              "Flush any buffered bytes to the file system. In most files, writes are "
+              "buffered for efficiency reasons. Returns the file handle.") {
     janet_fixarity(argc, 1);
-    IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
-    if (iof->flags & IO_CLOSED)
+    JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
+    if (iof->flags & JANET_FILE_CLOSED)
         janet_panic("file is closed");
-    if (!(iof->flags & (IO_WRITE | IO_APPEND | IO_UPDATE)))
+    if (!(iof->flags & (JANET_FILE_WRITE | JANET_FILE_APPEND | JANET_FILE_UPDATE)))
         janet_panic("file is not writeable");
     if (fflush(iof->file))
         janet_panic("could not flush file");
     return argv[0];
 }
 
-/* Cleanup a file */
-static int janet_io_gc(void *p, size_t len) {
-    (void) len;
-    IOFile *iof = (IOFile *)p;
-    if (!(iof->flags & (IO_NOT_CLOSEABLE | IO_CLOSED))) {
-        return fclose(iof->file);
+#ifdef JANET_WINDOWS
+#define WEXITSTATUS(x) x
+#endif
+
+/* For closing files from C API */
+int janet_file_close(JanetFile *file) {
+    int ret = 0;
+    if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) {
+        ret = fclose(file->file);
+        file->flags |= JANET_FILE_CLOSED;
+        return ret;
     }
     return 0;
 }
 
+/* Cleanup a file */
+static int cfun_io_gc(void *p, size_t len) {
+    (void) len;
+    JanetFile *iof = (JanetFile *)p;
+    janet_file_close(iof);
+    return 0;
+}
+
 /* Close a file */
-static Janet janet_io_fclose(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_io_fclose,
+              "(file/close f)",
+              "Close a file and release all related resources. When you are "
+              "done reading a file, close it to prevent a resource leak and let "
+              "other processes read the file.") {
     janet_fixarity(argc, 1);
-    IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
-    if (iof->flags & IO_CLOSED)
-        janet_panic("file is closed");
-    if (iof->flags & (IO_NOT_CLOSEABLE))
+    JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
+    if (iof->flags & JANET_FILE_CLOSED)
+        return janet_wrap_nil();
+    if (iof->flags & (JANET_FILE_NOT_CLOSEABLE))
         janet_panic("file not closable");
-    if (iof->flags & IO_PIPED) {
-#ifdef JANET_WINDOWS
-#define pclose _pclose
-#endif
-        if (pclose(iof->file)) janet_panic("could not close file");
-    } else {
-        if (fclose(iof->file)) janet_panic("could not close file");
+    if (fclose(iof->file)) {
+        iof->flags |= JANET_FILE_NOT_CLOSEABLE;
+        janet_panic("could not close file");
     }
-    iof->flags |= IO_CLOSED;
-    return argv[0];
+    iof->flags |= JANET_FILE_CLOSED;
+    return janet_wrap_nil();
 }
 
 /* Seek a file */
-static Janet janet_io_fseek(int32_t argc, Janet *argv) {
+JANET_CORE_FN(cfun_io_fseek,
+              "(file/seek f &opt whence n)",
+              "Jump to a relative location in the file `f`. `whence` must be one of:\n\n"
+              "* :cur - jump relative to the current file location\n\n"
+              "* :set - jump relative to the beginning of the file\n\n"
+              "* :end - jump relative to the end of the file\n\n"
+              "By default, `whence` is :cur. Optionally a value `n` may be passed "
+              "for the relative number of bytes to seek in the file. `n` may be a real "
+              "number to handle large files of more than 4GB. Returns the file handle.") {
     janet_arity(argc, 2, 3);
-    IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
-    if (iof->flags & IO_CLOSED)
+    JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
+    if (iof->flags & JANET_FILE_CLOSED)
         janet_panic("file is closed");
     long int offset = 0;
     int whence = SEEK_CUR;
@@ -300,87 +337,451 @@ static Janet janet_io_fseek(int32_t argc, Janet *argv) {
     return argv[0];
 }
 
-static const JanetReg cfuns[] = {
-    {
-        "file/open", janet_io_fopen,
-        JDOC("(file/open path [,mode])\n\n"
-                "Open a file. path is an absolute or relative path, and "
-                "mode is a set of flags indicating the mode to open the file in. "
-                "mode is a keyword where each character represents a flag. If the file "
-                "cannot be opened, returns nil, otherwise returns the new file handle. "
-                "Mode flags:\n\n"
-                "\tr - allow reading from the file\n"
-                "\tw - allow writing to the file\n"
-                "\ta - append to the file\n"
-                "\tb - open the file in binary mode (rather than text mode)\n"
-                "\t+ - append to the file instead of overwriting it")
-    },
-    {
-        "file/close", janet_io_fclose,
-        JDOC("(file/close f)\n\n"
-                "Close a file and release all related resources. When you are "
-                "done reading a file, close it to prevent a resource leak and let "
-                "other processes read the file.")
-    },
-    {
-        "file/read", janet_io_fread,
-        JDOC("(file/read f what [,buf])\n\n"
-                "Read a number of bytes from a file into a buffer. A buffer can "
-                "be provided as an optional fourth argument, otherwise a new buffer "
-                "is created. 'what' can either be an integer or a keyword. Returns the "
-                "buffer with file contents. "
-                "Values for 'what':\n\n"
-                "\t:all - read the whole file\n"
-                "\t:line - read up to and including the next newline character\n"
-                "\tn (integer) - read up to n bytes from the file")
-    },
-    {
-        "file/write", janet_io_fwrite,
-        JDOC("(file/write f bytes)\n\n"
-                "Writes to a file. 'bytes' must be string, buffer, or symbol. Returns the "
-                "file.")
-    },
-    {
-        "file/flush", janet_io_fflush,
-        JDOC("(file/flush f)\n\n"
-                "Flush any buffered bytes to the file system. In most files, writes are "
-                "buffered for efficiency reasons. Returns the file handle.")
-    },
-    {
-        "file/seek", janet_io_fseek,
-        JDOC("(file/seek f [,whence [,n]])\n\n"
-                "Jump to a relative location in the file. 'whence' must be one of\n\n"
-                "\t:cur - jump relative to the current file location\n"
-                "\t:set - jump relative to the beginning of the file\n"
-                "\t:end - jump relative to the end of the file\n\n"
-                "By default, 'whence' is :cur. Optionally a value n may be passed "
-                "for the relative number of bytes to seek in the file. n may be a real "
-                "number to handle large files of more the 4GB. Returns the file handle.")
-    },
-    {
-        "file/popen", janet_io_popen,
-        JDOC("(file/popen path [,mode])\n\n"
-                "Open a file that is backed by a process. The file must be opened in either "
-                "the :r (read) or the :w (write) mode. In :r mode, the stdout of the "
-                "process can be read from the file. In :w mode, the stdin of the process "
-                "can be written to. Returns the new file.")
-    },
-    {NULL, NULL, NULL}
+static JanetMethod io_file_methods[] = {
+    {"close", cfun_io_fclose},
+    {"flush", cfun_io_fflush},
+    {"read", cfun_io_fread},
+    {"seek", cfun_io_fseek},
+    {"write", cfun_io_fwrite},
+    {NULL, NULL}
 };
 
+static int io_file_get(void *p, Janet key, Janet *out) {
+    (void) p;
+    if (!janet_checktype(key, JANET_KEYWORD))
+        return 0;
+    return janet_getmethod(janet_unwrap_keyword(key), io_file_methods, out);
+}
+
+static Janet io_file_next(void *p, Janet key) {
+    (void) p;
+    return janet_nextmethod(io_file_methods, key);
+}
+
+static void io_file_marshal(void *p, JanetMarshalContext *ctx) {
+    JanetFile *iof = (JanetFile *)p;
+    if (ctx->flags & JANET_MARSHAL_UNSAFE) {
+        janet_marshal_abstract(ctx, p);
+#ifdef JANET_WINDOWS
+        janet_marshal_int(ctx, _fileno(iof->file));
+#else
+        janet_marshal_int(ctx, fileno(iof->file));
+#endif
+        janet_marshal_int(ctx, iof->flags);
+    } else {
+        janet_panic("cannot marshal file in safe mode");
+    }
+}
+
+static void *io_file_unmarshal(JanetMarshalContext *ctx) {
+    if (ctx->flags & JANET_MARSHAL_UNSAFE) {
+        JanetFile *iof = janet_unmarshal_abstract(ctx, sizeof(JanetFile));
+        int32_t fd = janet_unmarshal_int(ctx);
+        int32_t flags = janet_unmarshal_int(ctx);
+        char fmt[4] = {0};
+        int index = 0;
+        if (flags & JANET_FILE_READ) fmt[index++] = 'r';
+        if (flags & JANET_FILE_APPEND) {
+            fmt[index++] = 'a';
+        } else if (flags & JANET_FILE_WRITE) {
+            fmt[index++] = 'w';
+        }
+#ifdef JANET_WINDOWS
+        iof->file = _fdopen(fd, fmt);
+#else
+        iof->file = fdopen(fd, fmt);
+#endif
+        if (iof->file == NULL) {
+            iof->flags = JANET_FILE_CLOSED;
+        } else {
+            iof->flags = flags;
+        }
+        return iof;
+    } else {
+        janet_panic("cannot unmarshal file in safe mode");
+    }
+}
+
+FILE *janet_dynfile(const char *name, FILE *def) {
+    Janet x = janet_dyn(name);
+    if (!janet_checktype(x, JANET_ABSTRACT)) return def;
+    void *abstract = janet_unwrap_abstract(x);
+    if (janet_abstract_type(abstract) != &janet_file_type) return def;
+    JanetFile *iofile = abstract;
+    return iofile->file;
+}
+
+static Janet cfun_io_print_impl_x(int32_t argc, Janet *argv, int newline,
+                                  FILE *dflt_file, int32_t offset, Janet x) {
+    FILE *f;
+    switch (janet_type(x)) {
+        default:
+            janet_panicf("cannot print to %v", x);
+        case JANET_BUFFER: {
+            /* Special case buffer */
+            JanetBuffer *buf = janet_unwrap_buffer(x);
+            for (int32_t i = offset; i < argc; ++i) {
+                janet_to_string_b(buf, argv[i]);
+            }
+            if (newline)
+                janet_buffer_push_u8(buf, '\n');
+            return janet_wrap_nil();
+        }
+        case JANET_FUNCTION: {
+            /* Special case function */
+            JanetFunction *fun = janet_unwrap_function(x);
+            JanetBuffer *buf = janet_buffer(0);
+            for (int32_t i = offset; i < argc; ++i) {
+                janet_to_string_b(buf, argv[i]);
+            }
+            if (newline)
+                janet_buffer_push_u8(buf, '\n');
+            Janet args[1] = { janet_wrap_buffer(buf) };
+            janet_call(fun, 1, args);
+            return janet_wrap_nil();
+        }
+        case JANET_NIL:
+            f = dflt_file;
+            if (f == NULL) janet_panic("cannot print to nil");
+            break;
+        case JANET_ABSTRACT: {
+            void *abstract = janet_unwrap_abstract(x);
+            if (janet_abstract_type(abstract) != &janet_file_type)
+                return janet_wrap_nil();
+            JanetFile *iofile = abstract;
+            f = iofile->file;
+            break;
+        }
+    }
+    for (int32_t i = offset; i < argc; ++i) {
+        int32_t len;
+        const uint8_t *vstr;
+        if (janet_checktype(argv[i], JANET_BUFFER)) {
+            JanetBuffer *b = janet_unwrap_buffer(argv[i]);
+            vstr = b->data;
+            len = b->count;
+        } else {
+            vstr = janet_to_string(argv[i]);
+            len = janet_string_length(vstr);
+        }
+        if (len) {
+            if (1 != fwrite(vstr, len, 1, f)) {
+                if (f == dflt_file) {
+                    janet_panicf("cannot print %d bytes", len);
+                } else {
+                    janet_panicf("cannot print %d bytes to %v", len, x);
+                }
+            }
+        }
+    }
+    if (newline)
+        putc('\n', f);
+    return janet_wrap_nil();
+}
+
+
+static Janet cfun_io_print_impl(int32_t argc, Janet *argv,
+                                int newline, const char *name, FILE *dflt_file) {
+    Janet x = janet_dyn(name);
+    return cfun_io_print_impl_x(argc, argv, newline, dflt_file, 0, x);
+}
+
+JANET_CORE_FN(cfun_io_print,
+              "(print & xs)",
+              "Print values to the console (standard out). Value are converted "
+              "to strings if they are not already. After printing all values, a "
+              "newline character is printed. Use the value of `(dyn :out stdout)` to determine "
+              "what to push characters to. Expects `(dyn :out stdout)` to be either a core/file or "
+              "a buffer. Returns nil.") {
+    return cfun_io_print_impl(argc, argv, 1, "out", stdout);
+}
+
+JANET_CORE_FN(cfun_io_prin,
+              "(prin & xs)",
+              "Same as `print`, but does not add trailing newline.") {
+    return cfun_io_print_impl(argc, argv, 0, "out", stdout);
+}
+
+JANET_CORE_FN(cfun_io_eprint,
+              "(eprint & xs)",
+              "Same as `print`, but uses `(dyn :err stderr)` instead of `(dyn :out stdout)`.") {
+    return cfun_io_print_impl(argc, argv, 1, "err", stderr);
+}
+
+JANET_CORE_FN(cfun_io_eprin,
+              "(eprin & xs)",
+              "Same as `prin`, but uses `(dyn :err stderr)` instead of `(dyn :out stdout)`.") {
+    return cfun_io_print_impl(argc, argv, 0, "err", stderr);
+}
+
+JANET_CORE_FN(cfun_io_xprint,
+              "(xprint to & xs)",
+              "Print to a file or other value explicitly (no dynamic bindings) with a trailing "
+              "newline character. The value to print "
+              "to is the first argument, and is otherwise the same as `print`. Returns nil.") {
+    janet_arity(argc, 1, -1);
+    return cfun_io_print_impl_x(argc, argv, 1, NULL, 1, argv[0]);
+}
+
+JANET_CORE_FN(cfun_io_xprin,
+              "(xprin to & xs)",
+              "Print to a file or other value explicitly (no dynamic bindings). The value to print "
+              "to is the first argument, and is otherwise the same as `prin`. Returns nil.") {
+    janet_arity(argc, 1, -1);
+    return cfun_io_print_impl_x(argc, argv, 0, NULL, 1, argv[0]);
+}
+
+static Janet cfun_io_printf_impl_x(int32_t argc, Janet *argv, int newline,
+                                   FILE *dflt_file, int32_t offset, Janet x) {
+    FILE *f;
+    const char *fmt = janet_getcstring(argv, offset);
+    switch (janet_type(x)) {
+        default:
+            janet_panicf("cannot print to %v", x);
+        case JANET_BUFFER: {
+            /* Special case buffer */
+            JanetBuffer *buf = janet_unwrap_buffer(x);
+            janet_buffer_format(buf, fmt, offset, argc, argv);
+            if (newline) janet_buffer_push_u8(buf, '\n');
+            return janet_wrap_nil();
+        }
+        case JANET_FUNCTION: {
+            /* Special case function */
+            JanetFunction *fun = janet_unwrap_function(x);
+            JanetBuffer *buf = janet_buffer(0);
+            janet_buffer_format(buf, fmt, offset, argc, argv);
+            if (newline) janet_buffer_push_u8(buf, '\n');
+            Janet args[1] = { janet_wrap_buffer(buf) };
+            janet_call(fun, 1, args);
+            return janet_wrap_nil();
+        }
+        case JANET_NIL:
+            f = dflt_file;
+            if (f == NULL) janet_panic("cannot print to nil");
+            break;
+        case JANET_ABSTRACT: {
+            void *abstract = janet_unwrap_abstract(x);
+            if (janet_abstract_type(abstract) != &janet_file_type)
+                return janet_wrap_nil();
+            JanetFile *iofile = abstract;
+            f = iofile->file;
+            break;
+        }
+    }
+    JanetBuffer *buf = janet_buffer(10);
+    janet_buffer_format(buf, fmt, offset, argc, argv);
+    if (newline) janet_buffer_push_u8(buf, '\n');
+    if (buf->count) {
+        if (1 != fwrite(buf->data, buf->count, 1, f)) {
+            janet_panicf("could not print %d bytes to file", buf->count);
+        }
+    }
+    /* Clear buffer to make things easier for GC */
+    buf->count = 0;
+    buf->capacity = 0;
+    janet_free(buf->data);
+    buf->data = NULL;
+    return janet_wrap_nil();
+}
+
+static Janet cfun_io_printf_impl(int32_t argc, Janet *argv, int newline,
+                                 const char *name, FILE *dflt_file) {
+    janet_arity(argc, 1, -1);
+    Janet x = janet_dyn(name);
+    return cfun_io_printf_impl_x(argc, argv, newline, dflt_file, 0, x);
+
+}
+
+JANET_CORE_FN(cfun_io_printf,
+              "(printf fmt & xs)",
+              "Prints output formatted as if with `(string/format fmt ;xs)` to `(dyn :out stdout)` with a trailing newline.") {
+    return cfun_io_printf_impl(argc, argv, 1, "out", stdout);
+}
+
+JANET_CORE_FN(cfun_io_prinf,
+              "(prinf fmt & xs)",
+              "Like `printf` but with no trailing newline.") {
+    return cfun_io_printf_impl(argc, argv, 0, "out", stdout);
+}
+
+JANET_CORE_FN(cfun_io_eprintf,
+              "(eprintf fmt & xs)",
+              "Prints output formatted as if with `(string/format fmt ;xs)` to `(dyn :err stderr)` with a trailing newline.") {
+    return cfun_io_printf_impl(argc, argv, 1, "err", stderr);
+}
+
+JANET_CORE_FN(cfun_io_eprinf,
+              "(eprinf fmt & xs)",
+              "Like `eprintf` but with no trailing newline.") {
+    return cfun_io_printf_impl(argc, argv, 0, "err", stderr);
+}
+
+JANET_CORE_FN(cfun_io_xprintf,
+              "(xprintf to fmt & xs)",
+              "Like `printf` but prints to an explicit file or value `to`. Returns nil.") {
+    janet_arity(argc, 2, -1);
+    return cfun_io_printf_impl_x(argc, argv, 1, NULL, 1, argv[0]);
+}
+
+JANET_CORE_FN(cfun_io_xprinf,
+              "(xprinf to fmt & xs)",
+              "Like `prinf` but prints to an explicit file or value `to`. Returns nil.") {
+    janet_arity(argc, 2, -1);
+    return cfun_io_printf_impl_x(argc, argv, 0, NULL, 1, argv[0]);
+}
+
+static void janet_flusher(const char *name, FILE *dflt_file) {
+    Janet x = janet_dyn(name);
+    switch (janet_type(x)) {
+        default:
+            break;
+        case JANET_NIL:
+            fflush(dflt_file);
+            break;
+        case JANET_ABSTRACT: {
+            void *abstract = janet_unwrap_abstract(x);
+            if (janet_abstract_type(abstract) != &janet_file_type) break;
+            JanetFile *iofile = abstract;
+            fflush(iofile->file);
+            break;
+        }
+    }
+}
+
+JANET_CORE_FN(cfun_io_flush,
+              "(flush)",
+              "Flush `(dyn :out stdout)` if it is a file, otherwise do nothing.") {
+    janet_fixarity(argc, 0);
+    (void) argv;
+    janet_flusher("out", stdout);
+    return janet_wrap_nil();
+}
+
+JANET_CORE_FN(cfun_io_eflush,
+              "(eflush)",
+              "Flush `(dyn :err stderr)` if it is a file, otherwise do nothing.") {
+    janet_fixarity(argc, 0);
+    (void) argv;
+    janet_flusher("err", stderr);
+    return janet_wrap_nil();
+}
+
+void janet_dynprintf(const char *name, FILE *dflt_file, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    Janet x = janet_dyn(name);
+    JanetType xtype = janet_type(x);
+    switch (xtype) {
+        default:
+            /* Other values simply do nothing */
+            break;
+        case JANET_NIL:
+        case JANET_ABSTRACT: {
+            FILE *f = dflt_file;
+            JanetBuffer buffer;
+            int32_t len = 0;
+            while (format[len]) len++;
+            janet_buffer_init(&buffer, len);
+            janet_formatbv(&buffer, format, args);
+            if (xtype == JANET_ABSTRACT) {
+                void *abstract = janet_unwrap_abstract(x);
+                if (janet_abstract_type(abstract) != &janet_file_type)
+                    break;
+                JanetFile *iofile = abstract;
+                f = iofile->file;
+            }
+            fwrite(buffer.data, buffer.count, 1, f);
+            janet_buffer_deinit(&buffer);
+            break;
+        }
+        case JANET_FUNCTION: {
+            JanetFunction *fun = janet_unwrap_function(x);
+            int32_t len = 0;
+            while (format[len]) len++;
+            JanetBuffer *buf = janet_buffer(len);
+            janet_formatbv(buf, format, args);
+            Janet args[1] = { janet_wrap_buffer(buf) };
+            janet_call(fun, 1, args);
+            break;
+        }
+        case JANET_BUFFER:
+            janet_formatbv(janet_unwrap_buffer(x), format, args);
+            break;
+    }
+    va_end(args);
+    return;
+}
+
+/* C API */
+
+JanetFile *janet_getjfile(const Janet *argv, int32_t n) {
+    return janet_getabstract(argv, n, &janet_file_type);
+}
+
+FILE *janet_getfile(const Janet *argv, int32_t n, int *flags) {
+    JanetFile *iof = janet_getabstract(argv, n, &janet_file_type);
+    if (NULL != flags) *flags = iof->flags;
+    return iof->file;
+}
+
+JanetFile *janet_makejfile(FILE *f, int flags) {
+    return makef(f, flags);
+}
+
+Janet janet_makefile(FILE *f, int flags) {
+    return janet_wrap_abstract(makef(f, flags));
+}
+
+JanetAbstract janet_checkfile(Janet j) {
+    return janet_checkabstract(j, &janet_file_type);
+}
+
+FILE *janet_unwrapfile(Janet j, int *flags) {
+    JanetFile *iof = janet_unwrap_abstract(j);
+    if (NULL != flags) *flags = iof->flags;
+    return iof->file;
+}
+
 /* Module entry point */
 void janet_lib_io(JanetTable *env) {
-    janet_cfuns(env, NULL, cfuns);
+    JanetRegExt io_cfuns[] = {
+        JANET_CORE_REG("print", cfun_io_print),
+        JANET_CORE_REG("prin", cfun_io_prin),
+        JANET_CORE_REG("printf", cfun_io_printf),
+        JANET_CORE_REG("prinf", cfun_io_prinf),
+        JANET_CORE_REG("eprin", cfun_io_eprin),
+        JANET_CORE_REG("eprint", cfun_io_eprint),
+        JANET_CORE_REG("eprintf", cfun_io_eprintf),
+        JANET_CORE_REG("eprinf", cfun_io_eprinf),
+        JANET_CORE_REG("xprint", cfun_io_xprint),
+        JANET_CORE_REG("xprin", cfun_io_xprin),
+        JANET_CORE_REG("xprintf", cfun_io_xprintf),
+        JANET_CORE_REG("xprinf", cfun_io_xprinf),
+        JANET_CORE_REG("flush", cfun_io_flush),
+        JANET_CORE_REG("eflush", cfun_io_eflush),
+        JANET_CORE_REG("file/temp", cfun_io_temp),
+        JANET_CORE_REG("file/open", cfun_io_fopen),
+        JANET_CORE_REG("file/close", cfun_io_fclose),
+        JANET_CORE_REG("file/read", cfun_io_fread),
+        JANET_CORE_REG("file/write", cfun_io_fwrite),
+        JANET_CORE_REG("file/flush", cfun_io_fflush),
+        JANET_CORE_REG("file/seek", cfun_io_fseek),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, io_cfuns);
+    janet_register_abstract_type(&janet_file_type);
+    int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE;
     /* stdout */
-    janet_def(env, "stdout",
-            makef(stdout, IO_APPEND | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
-            JDOC("The standard output file."));
+    JANET_CORE_DEF(env, "stdout",
+                   janet_makefile(stdout, JANET_FILE_APPEND | default_flags),
+                   "The standard output file.");
     /* stderr */
-    janet_def(env, "stderr",
-            makef(stderr, IO_APPEND | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
-            JDOC("The standard error file."));
+    JANET_CORE_DEF(env, "stderr",
+                   janet_makefile(stderr, JANET_FILE_APPEND | default_flags),
+                   "The standard error file.");
     /* stdin */
-    janet_def(env, "stdin",
-            makef(stdin, IO_READ | IO_NOT_CLOSEABLE | IO_SERIALIZABLE),
-            JDOC("The standard input file."));
+    JANET_CORE_DEF(env, "stdin",
+                   janet_makefile(stdin, JANET_FILE_READ | default_flags),
+                   "The standard input file.");
+
 }

src/core/math.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019 Calvin Rose
+* Copyright (c) 2022 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -20,171 +20,404 @@
 * IN THE SOFTWARE.
 */
 
-#include <janet/janet.h>
-#include <math.h>
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
+#include "state.h"
 #include "util.h"
+#endif
+
+#include <math.h>
+
+static int janet_rng_get(void *p, Janet key, Janet *out);
+static Janet janet_rng_next(void *p, Janet key);
+
+static void janet_rng_marshal(void *p, JanetMarshalContext *ctx) {
+    JanetRNG *rng = (JanetRNG *)p;
+    janet_marshal_abstract(ctx, p);
+    janet_marshal_int(ctx, (int32_t) rng->a);
+    janet_marshal_int(ctx, (int32_t) rng->b);
+    janet_marshal_int(ctx, (int32_t) rng->c);
+    janet_marshal_int(ctx, (int32_t) rng->d);
+    janet_marshal_int(ctx, (int32_t) rng->counter);
+}
+
+static void *janet_rng_unmarshal(JanetMarshalContext *ctx) {
+    JanetRNG *rng = janet_unmarshal_abstract(ctx, sizeof(JanetRNG));
+    rng->a = (uint32_t) janet_unmarshal_int(ctx);
+    rng->b = (uint32_t) janet_unmarshal_int(ctx);
+    rng->c = (uint32_t) janet_unmarshal_int(ctx);
+    rng->d = (uint32_t) janet_unmarshal_int(ctx);
+    rng->counter = (uint32_t) janet_unmarshal_int(ctx);
+    return rng;
+}
+
+const JanetAbstractType janet_rng_type = {
+    "core/rng",
+    NULL,
+    NULL,
+    janet_rng_get,
+    NULL,
+    janet_rng_marshal,
+    janet_rng_unmarshal,
+    NULL, /* tostring */
+    NULL, /* compare */
+    NULL, /* hash */
+    janet_rng_next,
+    JANET_ATEND_NEXT
+};
+
+JanetRNG *janet_default_rng(void) {
+    return &janet_vm.rng;
+}
+
+void janet_rng_seed(JanetRNG *rng, uint32_t seed) {
+    rng->a = seed;
+    rng->b = 0x97654321u;
+    rng->c = 123871873u;
+    rng->d = 0xf23f56c8u;
+    rng->counter = 0u;
+    /* First several numbers aren't that random. */
+    for (int i = 0; i < 16; i++) janet_rng_u32(rng);
+}
+
+void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len) {
+    uint8_t state[16] = {0};
+    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);
+    rng->c = state[8] + (state[9] << 8) + (state[10] << 16) + (state[11] << 24);
+    rng->d = state[12] + (state[13] << 8) + (state[14] << 16) + (state[15] << 24);
+    rng->counter = 0u;
+    /* a, b, c, d can't all be 0 */
+    if (rng->a == 0) rng->a = 1u;
+    for (int i = 0; i < 16; i++) janet_rng_u32(rng);
+}
+
+uint32_t janet_rng_u32(JanetRNG *rng) {
+    /* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */
+    uint32_t t = rng->d;
+    uint32_t const s = rng->a;
+    rng->d = rng->c;
+    rng->c = rng->b;
+    rng->b = s;
+    t ^= t >> 2;
+    t ^= t << 1;
+    t ^= s ^ (s << 4);
+    rng->a = t;
+    rng->counter += 362437;
+    return t + rng->counter;
+}
+
+double janet_rng_double(JanetRNG *rng) {
+    uint32_t hi = janet_rng_u32(rng);
+    uint32_t lo = janet_rng_u32(rng);
+    uint64_t big = (uint64_t)(lo) | (((uint64_t) hi) << 32);
+    return ldexp((double)(big >> (64 - 52)), -52);
+}
+
+JANET_CORE_FN(cfun_rng_make,
+              "(math/rng &opt seed)",
+              "Creates a Psuedo-Random number generator, with an optional seed. "
+              "The seed should be an unsigned 32 bit integer or a buffer. "
+              "Do not use this for cryptography. Returns a core/rng abstract type."
+             ) {
+    janet_arity(argc, 0, 1);
+    JanetRNG *rng = janet_abstract(&janet_rng_type, sizeof(JanetRNG));
+    if (argc == 1) {
+        if (janet_checkint(argv[0])) {
+            uint32_t seed = (uint32_t)(janet_getinteger(argv, 0));
+            janet_rng_seed(rng, seed);
+        } else {
+            JanetByteView bytes = janet_getbytes(argv, 0);
+            janet_rng_longseed(rng, bytes.bytes, bytes.len);
+        }
+    } else {
+        janet_rng_seed(rng, 0);
+    }
+    return janet_wrap_abstract(rng);
+}
+
+JANET_CORE_FN(cfun_rng_uniform,
+              "(math/rng-uniform rng)",
+              "Extract a random number in the range [0, 1) from the RNG."
+             ) {
+    janet_fixarity(argc, 1);
+    JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type);
+    return janet_wrap_number(janet_rng_double(rng));
+}
+
+JANET_CORE_FN(cfun_rng_int,
+              "(math/rng-int rng &opt max)",
+              "Extract a random random integer in the range [0, max] from the RNG. If "
+              "no max is given, the default is 2^31 - 1."
+             ) {
+    janet_arity(argc, 1, 2);
+    JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type);
+    if (argc == 1) {
+        uint32_t word = janet_rng_u32(rng) >> 1;
+        return janet_wrap_integer(word);
+    } else {
+        int32_t max = janet_optnat(argv, argc, 1, INT32_MAX);
+        if (max == 0) return janet_wrap_number(0.0);
+        uint32_t modulo = (uint32_t) max;
+        uint32_t maxgen = INT32_MAX;
+        uint32_t maxword = maxgen - (maxgen % modulo);
+        uint32_t word;
+        do {
+            word = janet_rng_u32(rng) >> 1;
+        } while (word > maxword);
+        return janet_wrap_integer(word % modulo);
+    }
+}
+
+static void rng_get_4bytes(JanetRNG *rng, uint8_t *buf) {
+    uint32_t word = janet_rng_u32(rng);
+    buf[0] = word & 0xFF;
+    buf[1] = (word >> 8) & 0xFF;
+    buf[2] = (word >> 16) & 0xFF;
+    buf[3] = (word >> 24) & 0xFF;
+}
+
+JANET_CORE_FN(cfun_rng_buffer,
+              "(math/rng-buffer rng n &opt buf)",
+              "Get n random bytes and put them in a buffer. Creates a new buffer if no buffer is "
+              "provided, otherwise appends to the given buffer. Returns the buffer."
+             ) {
+    janet_arity(argc, 2, 3);
+    JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type);
+    int32_t n = janet_getnat(argv, 1);
+    JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, n);
+
+    /* Split into first part (that is divisible by 4), and rest */
+    int32_t first_part = n & ~3;
+    int32_t second_part = n - first_part;
+
+    /* Get first part in chunks of 4 bytes */
+    janet_buffer_extra(buffer, n);
+    uint8_t *buf = buffer->data + buffer->count;
+    for (int32_t i = 0; i < first_part; i += 4) rng_get_4bytes(rng, buf + i);
+    buffer->count += first_part;
+
+    /* Get remaining 0 - 3 bytes */
+    if (second_part) {
+        uint8_t wordbuf[4] = {0};
+        rng_get_4bytes(rng, wordbuf);
+        janet_buffer_push_bytes(buffer, wordbuf, second_part);
+    }
+
+    return janet_wrap_buffer(buffer);
+}
+
+static const JanetMethod rng_methods[] = {
+    {"uniform", cfun_rng_uniform},
+    {"int", cfun_rng_int},
+    {"buffer", cfun_rng_buffer},
+    {NULL, NULL}
+};
+
+static int janet_rng_get(void *p, Janet key, Janet *out) {
+    (void) p;
+    if (!janet_checktype(key, JANET_KEYWORD)) return 0;
+    return janet_getmethod(janet_unwrap_keyword(key), rng_methods, out);
+}
+
+static Janet janet_rng_next(void *p, Janet key) {
+    (void) p;
+    return janet_nextmethod(rng_methods, key);
+}
 
 /* Get a random number */
-Janet janet_rand(int32_t argc, Janet *argv) {
+JANET_CORE_FN(janet_rand,
+              "(math/random)",
+              "Returns a uniformly distributed random number between 0 and 1.") {
     (void) argv;
     janet_fixarity(argc, 0);
-    double r = (rand() % RAND_MAX) / ((double) RAND_MAX);
-    return janet_wrap_number(r);
+    return janet_wrap_number(janet_rng_double(&janet_vm.rng));
 }
 
 /* Seed the random number generator */
-Janet janet_srand(int32_t argc, Janet *argv) {
+JANET_CORE_FN(janet_srand,
+              "(math/seedrandom seed)",
+              "Set the seed for the random number generator. `seed` should be "
+              "an integer or a buffer."
+             ) {
     janet_fixarity(argc, 1);
-    int32_t x = janet_getinteger(argv, 0);
-    srand((unsigned) x);
+    if (janet_checkint(argv[0])) {
+        uint32_t seed = (uint32_t)(janet_getinteger(argv, 0));
+        janet_rng_seed(&janet_vm.rng, seed);
+    } else {
+        JanetByteView bytes = janet_getbytes(argv, 0);
+        janet_rng_longseed(&janet_vm.rng, bytes.bytes, bytes.len);
+    }
     return janet_wrap_nil();
 }
 
-Janet janet_remainder(int32_t argc, Janet *argv) {
-    janet_fixarity(argc, 2);
-    double x = janet_getnumber(argv, 0);
-    double y = janet_getnumber(argv, 1);
-    return janet_wrap_number(fmod(x, y));
-}
-
-#define JANET_DEFINE_MATHOP(name, fop)\
-Janet janet_##name(int32_t argc, Janet *argv) {\
+#define JANET_DEFINE_MATHOP(name, fop, doc)\
+JANET_CORE_FN(janet_##name, "(math/" #name " x)", doc) {\
     janet_fixarity(argc, 1); \
     double x = janet_getnumber(argv, 0); \
     return janet_wrap_number(fop(x)); \
 }
 
-JANET_DEFINE_MATHOP(acos, acos)
-JANET_DEFINE_MATHOP(asin, asin)
-JANET_DEFINE_MATHOP(atan, atan)
-JANET_DEFINE_MATHOP(cos, cos)
-JANET_DEFINE_MATHOP(cosh, cosh)
-JANET_DEFINE_MATHOP(sin, sin)
-JANET_DEFINE_MATHOP(sinh, sinh)
-JANET_DEFINE_MATHOP(tan, tan)
-JANET_DEFINE_MATHOP(tanh, tanh)
-JANET_DEFINE_MATHOP(exp, exp)
-JANET_DEFINE_MATHOP(log, log)
-JANET_DEFINE_MATHOP(log10, log10)
-JANET_DEFINE_MATHOP(sqrt, sqrt)
-JANET_DEFINE_MATHOP(ceil, ceil)
-JANET_DEFINE_MATHOP(fabs, fabs)
-JANET_DEFINE_MATHOP(floor, floor)
+JANET_DEFINE_MATHOP(acos, acos, "Returns the arccosine of x.")
+JANET_DEFINE_MATHOP(asin, asin, "Returns the arcsin of x.")
+JANET_DEFINE_MATHOP(atan, atan, "Returns the arctangent of x.")
+JANET_DEFINE_MATHOP(cos, cos, "Returns the cosine of x.")
+JANET_DEFINE_MATHOP(cosh, cosh, "Returns the hyperbolic cosine of x.")
+JANET_DEFINE_MATHOP(acosh, acosh, "Returns the hyperbolic arccosine of x.")
+JANET_DEFINE_MATHOP(sin, sin, "Returns the sine of x.")
+JANET_DEFINE_MATHOP(sinh, sinh, "Returns the hyperbolic sine of x.")
+JANET_DEFINE_MATHOP(asinh, asinh, "Returns the hypberbolic arcsine of x.")
+JANET_DEFINE_MATHOP(tan, tan, "Returns the tangent of x.")
+JANET_DEFINE_MATHOP(tanh, tanh, "Returns the hyperbolic tangent of x.")
+JANET_DEFINE_MATHOP(atanh, atanh, "Returns the hyperbolic arctangent of x.")
+JANET_DEFINE_MATHOP(exp, exp, "Returns e to the power of x.")
+JANET_DEFINE_MATHOP(exp2, exp2, "Returns 2 to the power of x.")
+JANET_DEFINE_MATHOP(expm1, expm1, "Returns e to the power of x minus 1.")
+JANET_DEFINE_MATHOP(log, log, "Returns the natural logarithm of x.")
+JANET_DEFINE_MATHOP(log10, log10, "Returns the log base 10 of x.")
+JANET_DEFINE_MATHOP(log2, log2, "Returns the log base 2 of x.")
+JANET_DEFINE_MATHOP(sqrt, sqrt, "Returns the square root of x.")
+JANET_DEFINE_MATHOP(cbrt, cbrt, "Returns the cube root of x.")
+JANET_DEFINE_MATHOP(ceil, ceil, "Returns the smallest integer value number that is not less than x.")
+JANET_DEFINE_MATHOP(fabs, fabs, "Return the absolute value of x.")
+JANET_DEFINE_MATHOP(floor, floor, "Returns the largest integer value number that is not greater than x.")
+JANET_DEFINE_MATHOP(trunc, trunc, "Returns the integer between x and 0 nearest to x.")
+JANET_DEFINE_MATHOP(round, round, "Returns the integer nearest to x.")
+JANET_DEFINE_MATHOP(gamma, tgamma, "Returns gamma(x).")
+JANET_DEFINE_MATHOP(lgamma, lgamma, "Returns log-gamma(x).")
+JANET_DEFINE_MATHOP(log1p, log1p, "Returns (log base e of x) + 1 more accurately than (+ (math/log x) 1)")
+JANET_DEFINE_MATHOP(erf, erf, "Returns the error function of x.")
+JANET_DEFINE_MATHOP(erfc, erfc, "Returns the complementary error function of x.")
 
-#define JANET_DEFINE_MATH2OP(name, fop)\
-Janet janet_##name(int32_t argc, Janet *argv) {\
+#define JANET_DEFINE_MATH2OP(name, fop, signature, doc)\
+JANET_CORE_FN(janet_##name, signature, doc) {\
     janet_fixarity(argc, 2); \
     double lhs = janet_getnumber(argv, 0); \
     double rhs = janet_getnumber(argv, 1); \
     return janet_wrap_number(fop(lhs, rhs)); \
-}\
+}
 
-JANET_DEFINE_MATH2OP(atan2, atan2)
-JANET_DEFINE_MATH2OP(pow, pow)
+JANET_DEFINE_MATH2OP(atan2, atan2, "(math/atan2 y x)", "Returns the arctangent of y/x. Works even when x is 0.")
+JANET_DEFINE_MATH2OP(pow, pow, "(math/pow a x)", "Returns a to the power of x.")
+JANET_DEFINE_MATH2OP(hypot, hypot, "(math/hypot a b)", "Returns c from the equation c^2 = a^2 + b^2.")
+JANET_DEFINE_MATH2OP(nextafter, nextafter,  "(math/next x y)", "Returns the next representable floating point vaue after x in the direction of y.")
 
-static Janet janet_not(int32_t argc, Janet *argv) {
+JANET_CORE_FN(janet_not, "(not x)", "Returns the boolean inverse of x.") {
     janet_fixarity(argc, 1);
     return janet_wrap_boolean(!janet_truthy(argv[0]));
 }
 
-static const JanetReg cfuns[] = {
-    {
-        "%", janet_remainder,
-        JDOC("(% dividend divisor)\n\n"
-                "Returns the remainder of dividend / divisor.")
-    },
-    {
-        "not", janet_not,
-        JDOC("(not x)\n\nReturns the boolean inverse of x.")
-    },
-    {
-        "math/random", janet_rand,
-        JDOC("(math/random)\n\n"
-                "Returns a uniformly distributed random number between 0 and 1.")
-    },
-    {
-        "math/seedrandom", janet_srand,
-        JDOC("(math/seedrandom seed)\n\n"
-                "Set the seed for the random number generator. 'seed' should be an "
-                "an integer.")
-    },
-    {
-        "math/cos", janet_cos,
-        JDOC("(math/cos x)\n\n"
-                "Returns the cosine of x.")
-    },
-    {
-        "math/sin", janet_sin,
-        JDOC("(math/sin x)\n\n"
-                "Returns the sine of x.")
-    },
-    {
-        "math/tan", janet_tan,
-        JDOC("(math/tan x)\n\n"
-                "Returns the tangent of x.")
-    },
-    {
-        "math/acos", janet_acos,
-        JDOC("(math/acos x)\n\n"
-                "Returns the arccosine of x.")
-    },
-    {
-        "math/asin", janet_asin,
-        JDOC("(math/asin x)\n\n"
-                "Returns the arcsine of x.")
-    },
-    {
-        "math/atan", janet_atan,
-        JDOC("(math/atan x)\n\n"
-                "Returns the arctangent of x.")
-    },
-    {
-        "math/exp", janet_exp,
-        JDOC("(math/exp x)\n\n"
-                "Returns e to the power of x.")
-    },
-    {
-        "math/log", janet_log,
-        JDOC("(math/log x)\n\n"
-                "Returns log base 2 of x.")
-    },
-    {
-        "math/log10", janet_log10,
-        JDOC("(math/log10 x)\n\n"
-                "Returns log base 10 of x.")
-    },
-    {
-        "math/sqrt", janet_sqrt,
-        JDOC("(math/sqrt x)\n\n"
-                "Returns the square root of x.")
-    },
-    {
-        "math/floor", janet_floor,
-        JDOC("(math/floor x)\n\n"
-                "Returns the largest integer value number that is not greater than x.")
-    },
-    {
-        "math/ceil", janet_ceil,
-        JDOC("(math/ceil x)\n\n"
-                "Returns the smallest integer value number that is not less than x.")
-    },
-    {
-        "math/pow", janet_pow,
-        JDOC("(math/pow a x)\n\n"
-                "Return a to the power of x.")
-    },
-    {NULL, NULL, NULL}
-};
+static double janet_gcd(double x, double y) {
+    if (isnan(x) || isnan(y)) {
+#ifdef NAN
+        return NAN;
+#else
+        return 0.0 \ 0.0;
+#endif
+    }
+    if (isinf(x) || isinf(y)) return INFINITY;
+    while (y != 0) {
+        double temp = y;
+        y = fmod(x, y);
+        x = temp;
+    }
+    return x;
+}
+
+static double janet_lcm(double x, double y) {
+    return (x / janet_gcd(x, y)) * y;
+}
+
+JANET_CORE_FN(janet_cfun_gcd, "(math/gcd x y)",
+              "Returns the greatest common divisor between x and y.") {
+    janet_fixarity(argc, 2);
+    double x = janet_getnumber(argv, 0);
+    double y = janet_getnumber(argv, 1);
+    return janet_wrap_number(janet_gcd(x, y));
+}
+
+JANET_CORE_FN(janet_cfun_lcm, "(math/lcm x y)",
+              "Returns the least common multiple of x and y.") {
+    janet_fixarity(argc, 2);
+    double x = janet_getnumber(argv, 0);
+    double y = janet_getnumber(argv, 1);
+    return janet_wrap_number(janet_lcm(x, y));
+}
 
 /* Module entry point */
 void janet_lib_math(JanetTable *env) {
-    janet_cfuns(env, NULL, cfuns);
-#ifndef JANET_NO_BOOTSTRAP
-    janet_def(env, "math/pi", janet_wrap_number(3.1415926535897931),
-            JDOC("The value pi."));
-    janet_def(env, "math/e", janet_wrap_number(2.7182818284590451),
-            JDOC("The base of the natural log."));
-    janet_def(env, "math/inf", janet_wrap_number(INFINITY),
-            JDOC("The number representing positive infinity"));
+    JanetRegExt math_cfuns[] = {
+        JANET_CORE_REG("not", janet_not),
+        JANET_CORE_REG("math/random", janet_rand),
+        JANET_CORE_REG("math/seedrandom", janet_srand),
+        JANET_CORE_REG("math/cos", janet_cos),
+        JANET_CORE_REG("math/sin", janet_sin),
+        JANET_CORE_REG("math/tan", janet_tan),
+        JANET_CORE_REG("math/acos", janet_acos),
+        JANET_CORE_REG("math/asin", janet_asin),
+        JANET_CORE_REG("math/atan", janet_atan),
+        JANET_CORE_REG("math/exp", janet_exp),
+        JANET_CORE_REG("math/log", janet_log),
+        JANET_CORE_REG("math/log10", janet_log10),
+        JANET_CORE_REG("math/log2", janet_log2),
+        JANET_CORE_REG("math/sqrt", janet_sqrt),
+        JANET_CORE_REG("math/cbrt", janet_cbrt),
+        JANET_CORE_REG("math/floor", janet_floor),
+        JANET_CORE_REG("math/ceil", janet_ceil),
+        JANET_CORE_REG("math/pow", janet_pow),
+        JANET_CORE_REG("math/abs", janet_fabs),
+        JANET_CORE_REG("math/sinh", janet_sinh),
+        JANET_CORE_REG("math/cosh", janet_cosh),
+        JANET_CORE_REG("math/tanh", janet_tanh),
+        JANET_CORE_REG("math/atanh", janet_atanh),
+        JANET_CORE_REG("math/asinh", janet_asinh),
+        JANET_CORE_REG("math/acosh", janet_acosh),
+        JANET_CORE_REG("math/atan2", janet_atan2),
+        JANET_CORE_REG("math/rng", cfun_rng_make),
+        JANET_CORE_REG("math/rng-uniform", cfun_rng_uniform),
+        JANET_CORE_REG("math/rng-int", cfun_rng_int),
+        JANET_CORE_REG("math/rng-buffer", cfun_rng_buffer),
+        JANET_CORE_REG("math/hypot", janet_hypot),
+        JANET_CORE_REG("math/exp2", janet_exp2),
+        JANET_CORE_REG("math/log1p", janet_log1p),
+        JANET_CORE_REG("math/gamma", janet_gamma),
+        JANET_CORE_REG("math/log-gamma", janet_lgamma),
+        JANET_CORE_REG("math/erfc", janet_erfc),
+        JANET_CORE_REG("math/erf", janet_erf),
+        JANET_CORE_REG("math/expm1", janet_expm1),
+        JANET_CORE_REG("math/trunc", janet_trunc),
+        JANET_CORE_REG("math/round", janet_round),
+        JANET_CORE_REG("math/next", janet_nextafter),
+        JANET_CORE_REG("math/gcd", janet_cfun_gcd),
+        JANET_CORE_REG("math/lcm", janet_cfun_lcm),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, math_cfuns);
+    janet_register_abstract_type(&janet_rng_type);
+#ifdef JANET_BOOTSTRAP
+    JANET_CORE_DEF(env, "math/pi", janet_wrap_number(3.1415926535897931),
+                   "The value pi.");
+    JANET_CORE_DEF(env, "math/e", janet_wrap_number(2.7182818284590451),
+                   "The base of the natural log.");
+    JANET_CORE_DEF(env, "math/inf", janet_wrap_number(INFINITY),
+                   "The number representing positive infinity");
+    JANET_CORE_DEF(env, "math/-inf", janet_wrap_number(-INFINITY),
+                   "The number representing negative infinity");
+    JANET_CORE_DEF(env, "math/int32-min", janet_wrap_number(INT32_MIN),
+                   "The minimum contiguous integer representable by a 32 bit signed integer");
+    JANET_CORE_DEF(env, "math/int32-max", janet_wrap_number(INT32_MAX),
+                   "The maximum contiguous integer represtenable by a 32 bit signed integer");
+    JANET_CORE_DEF(env, "math/int-min", janet_wrap_number(JANET_INTMIN_DOUBLE),
+                   "The minimum contiguous integer representable by a double (2^53)");
+    JANET_CORE_DEF(env, "math/int-max", janet_wrap_number(JANET_INTMAX_DOUBLE),
+                   "The maximum contiguous integer represtenable by a double (-(2^53))");
+#ifdef NAN
+    JANET_CORE_DEF(env, "math/nan", janet_wrap_number(NAN), "Not a number (IEEE-754 NaN)");
+#else
+    JANET_CORE_DEF(env, "math/nan", janet_wrap_number(0.0 / 0.0), "Not a number (IEEE-754 NaN)");
+#endif
 #endif
 }

src/core/net.c

@@ -0,0 +1,922 @@
+/*
+* Copyright (c) 2022 Calvin Rose and contributors.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to
+* deal in the Software without restriction, including without limitation the
+* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+* sell copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+* IN THE SOFTWARE.
+*/
+
+#ifndef JANET_AMALG
+#include "features.h"
+#include <janet.h>
+#include "util.h"
+#endif
+
+#ifdef JANET_NET
+
+#include <math.h>
+#ifdef JANET_WINDOWS
+#include <winsock2.h>
+#include <windows.h>
+#include <ws2tcpip.h>
+#include <mswsock.h>
+#pragma comment (lib, "Ws2_32.lib")
+#pragma comment (lib, "Mswsock.lib")
+#pragma comment (lib, "Advapi32.lib")
+#else
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+#include <fcntl.h>
+#endif
+
+const JanetAbstractType janet_address_type = {
+    "core/socket-address",
+    JANET_ATEND_NAME
+};
+
+#ifdef JANET_WINDOWS
+#define JSOCKCLOSE(x) closesocket((SOCKET) x)
+#define JSOCKDEFAULT INVALID_SOCKET
+#define JSOCKVALID(x) ((x) != INVALID_SOCKET)
+#define JSock SOCKET
+#define JSOCKFLAGS 0
+#else
+#define JSOCKCLOSE(x) close(x)
+#define JSOCKDEFAULT 0
+#define JSOCKVALID(x) ((x) >= 0)
+#define JSock int
+#ifdef SOCK_CLOEXEC
+#define JSOCKFLAGS SOCK_CLOEXEC
+#else
+#define JSOCKFLAGS 0
+#endif
+#endif
+
+/* maximum number of bytes in a socket address host (post name resolution) */
+#ifdef JANET_WINDOWS
+#define SA_ADDRSTRLEN (INET6_ADDRSTRLEN + 1)
+typedef unsigned short in_port_t;
+#else
+#define JANET_SA_MAX(a, b) (((a) > (b))? (a) : (b))
+#define SA_ADDRSTRLEN JANET_SA_MAX(INET6_ADDRSTRLEN + 1, (sizeof ((struct sockaddr_un *)0)->sun_path) + 1)
+#endif
+
+static JanetStream *make_stream(JSock handle, uint32_t flags);
+
+/* We pass this flag to all send calls to prevent sigpipe */
+#ifndef MSG_NOSIGNAL
+#define MSG_NOSIGNAL 0
+#endif
+
+/* Make sure a socket doesn't block */
+static void janet_net_socknoblock(JSock s) {
+#ifdef JANET_WINDOWS
+    unsigned long arg = 1;
+    ioctlsocket(s, FIONBIO, &arg);
+#else
+#if !defined(SOCK_CLOEXEC) && defined(O_CLOEXEC)
+    int extra = O_CLOEXEC;
+#else
+    int extra = 0;
+#endif
+    fcntl(s, F_SETFL, fcntl(s, F_GETFL, 0) | O_NONBLOCK | extra);
+#ifdef SO_NOSIGPIPE
+    int enable = 1;
+    setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, &enable, sizeof(int));
+#endif
+#endif
+}
+
+/* State machine for accepting connections. */
+
+#ifdef JANET_WINDOWS
+
+typedef struct {
+    JanetListenerState head;
+    WSAOVERLAPPED overlapped;
+    JanetFunction *function;
+    JanetStream *lstream;
+    JanetStream *astream;
+    char buf[1024];
+} NetStateAccept;
+
+static int net_sched_accept_impl(NetStateAccept *state, Janet *err);
+
+JanetAsyncStatus net_machine_accept(JanetListenerState *s, JanetAsyncEvent event) {
+    NetStateAccept *state = (NetStateAccept *)s;
+    switch (event) {
+        default:
+            break;
+        case JANET_ASYNC_EVENT_MARK: {
+            if (state->lstream) janet_mark(janet_wrap_abstract(state->lstream));
+            if (state->astream) janet_mark(janet_wrap_abstract(state->astream));
+            if (state->function) janet_mark(janet_wrap_function(state->function));
+            break;
+        }
+        case JANET_ASYNC_EVENT_CLOSE:
+            janet_schedule(s->fiber, janet_wrap_nil());
+            return JANET_ASYNC_STATUS_DONE;
+        case JANET_ASYNC_EVENT_COMPLETE: {
+            if (state->astream->flags & JANET_STREAM_CLOSED) {
+                janet_cancel(s->fiber, janet_cstringv("failed to accept connection"));
+                return JANET_ASYNC_STATUS_DONE;
+            }
+            SOCKET lsock = (SOCKET) state->lstream->handle;
+            if (NO_ERROR != setsockopt((SOCKET) state->astream->handle, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
+                                       (char *) &lsock, sizeof(lsock))) {
+                janet_cancel(s->fiber, janet_cstringv("failed to accept connection"));
+                return JANET_ASYNC_STATUS_DONE;
+            }
+
+            Janet streamv = janet_wrap_abstract(state->astream);
+            if (state->function) {
+                /* Schedule worker */
+                JanetFiber *fiber = janet_fiber(state->function, 64, 1, &streamv);
+                fiber->supervisor_channel = s->fiber->supervisor_channel;
+                janet_schedule(fiber, janet_wrap_nil());
+                /* Now listen again for next connection */
+                Janet err;
+                if (net_sched_accept_impl(state, &err)) {
+                    janet_cancel(s->fiber, err);
+                    return JANET_ASYNC_STATUS_DONE;
+                }
+            } else {
+                janet_schedule(s->fiber, streamv);
+                return JANET_ASYNC_STATUS_DONE;
+            }
+        }
+    }
+    return JANET_ASYNC_STATUS_NOT_DONE;
+}
+
+JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunction *fun) {
+    Janet err;
+    SOCKET lsock = (SOCKET) stream->handle;
+    JanetListenerState *s = janet_listen(stream, net_machine_accept, JANET_ASYNC_LISTEN_READ, sizeof(NetStateAccept), NULL);
+    NetStateAccept *state = (NetStateAccept *)s;
+    memset(&state->overlapped, 0, sizeof(WSAOVERLAPPED));
+    memset(&state->buf, 0, 1024);
+    state->function = fun;
+    state->lstream = stream;
+    s->tag = &state->overlapped;
+    if (net_sched_accept_impl(state, &err)) janet_panicv(err);
+    janet_await();
+}
+
+static int net_sched_accept_impl(NetStateAccept *state, Janet *err) {
+    SOCKET lsock = (SOCKET) state->lstream->handle;
+    SOCKET asock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
+    if (asock == INVALID_SOCKET) {
+        *err = janet_ev_lasterr();
+        return 1;
+    }
+    JanetStream *astream = make_stream(asock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE);
+    state->astream = astream;
+    int socksize = sizeof(SOCKADDR_STORAGE) + 16;
+    if (FALSE == AcceptEx(lsock, asock, state->buf, 0, socksize, socksize, NULL, &state->overlapped)) {
+        int code = WSAGetLastError();
+        if (code == WSA_IO_PENDING) return 0; /* indicates io is happening async */
+        *err = janet_ev_lasterr();
+        return 1;
+    }
+    return 0;
+}
+
+#else
+
+typedef struct {
+    JanetListenerState head;
+    JanetFunction *function;
+} NetStateAccept;
+
+JanetAsyncStatus net_machine_accept(JanetListenerState *s, JanetAsyncEvent event) {
+    NetStateAccept *state = (NetStateAccept *)s;
+    switch (event) {
+        default:
+            break;
+        case JANET_ASYNC_EVENT_MARK: {
+            if (state->function) janet_mark(janet_wrap_function(state->function));
+            break;
+        }
+        case JANET_ASYNC_EVENT_CLOSE:
+            janet_schedule(s->fiber, janet_wrap_nil());
+            return JANET_ASYNC_STATUS_DONE;
+        case JANET_ASYNC_EVENT_READ: {
+            JSock connfd = accept(s->stream->handle, NULL, NULL);
+            if (JSOCKVALID(connfd)) {
+                janet_net_socknoblock(connfd);
+                JanetStream *stream = make_stream(connfd, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE);
+                Janet streamv = janet_wrap_abstract(stream);
+                if (state->function) {
+                    JanetFiber *fiber = janet_fiber(state->function, 64, 1, &streamv);
+                    fiber->supervisor_channel = s->fiber->supervisor_channel;
+                    janet_schedule(fiber, janet_wrap_nil());
+                } else {
+                    janet_schedule(s->fiber, streamv);
+                    return JANET_ASYNC_STATUS_DONE;
+                }
+            }
+            break;
+        }
+    }
+    return JANET_ASYNC_STATUS_NOT_DONE;
+}
+
+JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunction *fun) {
+    NetStateAccept *state = (NetStateAccept *) janet_listen(stream, net_machine_accept, JANET_ASYNC_LISTEN_READ, sizeof(NetStateAccept), NULL);
+    state->function = fun;
+    janet_await();
+}
+
+
+#endif
+
+/* Adress info */
+
+static int janet_get_sockettype(Janet *argv, int32_t argc, int32_t n) {
+    JanetKeyword stype = janet_optkeyword(argv, argc, n, NULL);
+    int socktype = SOCK_DGRAM;
+    if ((NULL == stype) || !janet_cstrcmp(stype, "stream")) {
+        socktype = SOCK_STREAM;
+    } else if (janet_cstrcmp(stype, "datagram")) {
+        janet_panicf("expected socket type as :stream or :datagram, got %v", argv[n]);
+    }
+    return socktype;
+}
+
+/* Needs argc >= offset + 2 */
+/* For unix paths, just rertuns a single sockaddr and sets *is_unix to 1,
+ * otherwise 0. Also, ignores is_bind when is a unix socket. */
+static struct addrinfo *janet_get_addrinfo(Janet *argv, int32_t offset, int socktype, int passive, int *is_unix) {
+    /* Unix socket support - not yet supported on windows. */
+#ifndef JANET_WINDOWS
+    if (janet_keyeq(argv[offset], "unix")) {
+        const char *path = janet_getcstring(argv, offset + 1);
+        struct sockaddr_un *saddr = janet_calloc(1, sizeof(struct sockaddr_un));
+        if (saddr == NULL) {
+            JANET_OUT_OF_MEMORY;
+        }
+        saddr->sun_family = AF_UNIX;
+        size_t path_size = sizeof(saddr->sun_path);
+#ifdef JANET_LINUX
+        if (path[0] == '@') {
+            saddr->sun_path[0] = '\0';
+            snprintf(saddr->sun_path + 1, path_size - 1, "%s", path + 1);
+        } else
+#endif
+        {
+            snprintf(saddr->sun_path, path_size, "%s", path);
+        }
+        *is_unix = 1;
+        return (struct addrinfo *) saddr;
+    }
+#endif
+    /* Get host and port */
+    char *host = (char *)janet_getcstring(argv, offset);
+    char *port = NULL;
+    if (janet_checkint(argv[offset + 1])) {
+        port = (char *)janet_to_string(argv[offset + 1]);
+    } else {
+        port = (char *)janet_optcstring(argv, offset + 2, offset + 1, NULL);
+    }
+    /* getaddrinfo */
+    struct addrinfo *ai = NULL;
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = socktype;
+    hints.ai_flags = passive ? AI_PASSIVE : 0;
+    int status = getaddrinfo(host, port, &hints, &ai);
+    if (status) {
+        janet_panicf("could not get address info: %s", gai_strerror(status));
+    }
+    *is_unix = 0;
+    return ai;
+}
+
+/*
+ * C Funs
+ */
+
+JANET_CORE_FN(cfun_net_sockaddr,
+              "(net/address host port &opt type multi)",
+              "Look up the connection information for a given hostname, port, and connection type. Returns "
+              "a handle that can be used to send datagrams over network without establishing a connection. "
+              "On Posix platforms, you can use :unix for host to connect to a unix domain socket, where the name is "
+              "given in the port argument. On Linux, abstract "
+              "unix domain sockets are specified with a leading '@' character in port. If `multi` is truthy, will "
+              "return all address that match in an array instead of just the first.") {
+    janet_arity(argc, 2, 4);
+    int socktype = janet_get_sockettype(argv, argc, 2);
+    int is_unix = 0;
+    int make_arr = (argc >= 3 && janet_truthy(argv[3]));
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix);
+#ifndef JANET_WINDOWS
+    /* no unix domain socket support on windows yet */
+    if (is_unix) {
+        void *abst = janet_abstract(&janet_address_type, sizeof(struct sockaddr_un));
+        memcpy(abst, ai, sizeof(struct sockaddr_un));
+        Janet ret = janet_wrap_abstract(abst);
+        return make_arr ? janet_wrap_array(janet_array_n(&ret, 1)) : ret;
+    }
+#endif
+    if (make_arr) {
+        /* Select all */
+        JanetArray *arr = janet_array(10);
+        struct addrinfo *iter = ai;
+        while (NULL != iter) {
+            void *abst = janet_abstract(&janet_address_type, iter->ai_addrlen);
+            memcpy(abst, iter->ai_addr, iter->ai_addrlen);
+            janet_array_push(arr, janet_wrap_abstract(abst));
+            iter = iter->ai_next;
+        }
+        freeaddrinfo(ai);
+        return janet_wrap_array(arr);
+    } else {
+        /* Select first */
+        if (NULL == ai) {
+            janet_panic("no data for given address");
+        }
+        void *abst = janet_abstract(&janet_address_type, ai->ai_addrlen);
+        memcpy(abst, ai->ai_addr, ai->ai_addrlen);
+        freeaddrinfo(ai);
+        return janet_wrap_abstract(abst);
+    }
+}
+
+JANET_CORE_FN(cfun_net_connect,
+              "(net/connect host port &opt type bindhost bindport)",
+              "Open a connection to communicate with a server. Returns a duplex stream "
+              "that can be used to communicate with the server. Type is an optional keyword "
+              "to specify a connection type, either :stream or :datagram. The default is :stream. "
+              "Bindhost is an optional string to select from what address to make the outgoing "
+              "connection, with the default being the same as using the OS's preferred address. ") {
+    janet_arity(argc, 2, 5);
+
+    /* Check arguments */
+    int socktype = janet_get_sockettype(argv, argc, 2);
+    int is_unix = 0;
+    char *bindhost = (char *) janet_optcstring(argv, argc, 3, NULL);
+    char *bindport = NULL;
+    if (argc >= 5 && janet_checkint(argv[4])) {
+        bindport = (char *)janet_to_string(argv[4]);
+    } else {
+        bindport = (char *)janet_optcstring(argv, argc, 4, NULL);
+    }
+
+    /* Where we're connecting to */
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix);
+
+    /* Check if we're binding address */
+    struct addrinfo *binding = NULL;
+    if (bindhost != NULL) {
+        if (is_unix) {
+            freeaddrinfo(ai);
+            janet_panic("bindhost not supported for unix domain sockets");
+        }
+        /* getaddrinfo */
+        struct addrinfo hints;
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = socktype;
+        hints.ai_flags = 0;
+        int status = getaddrinfo(bindhost, bindport, &hints, &binding);
+        if (status) {
+            freeaddrinfo(ai);
+            janet_panicf("could not get address info for bindhost: %s", gai_strerror(status));
+        }
+    }
+
+
+    /* Create socket */
+    JSock sock = JSOCKDEFAULT;
+    void *addr = NULL;
+    socklen_t addrlen = 0;
+#ifndef JANET_WINDOWS
+    if (is_unix) {
+        sock = socket(AF_UNIX, socktype | JSOCKFLAGS, 0);
+        if (!JSOCKVALID(sock)) {
+            Janet v = janet_ev_lasterr();
+            janet_free(ai);
+            janet_panicf("could not create socket: %V", v);
+        }
+        addr = (void *) ai;
+        addrlen = sizeof(struct sockaddr_un);
+    } else
+#endif
+    {
+        struct addrinfo *rp = NULL;
+        for (rp = ai; rp != NULL; rp = rp->ai_next) {
+#ifdef JANET_WINDOWS
+            sock = WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
+#else
+            sock = socket(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol);
+#endif
+            if (JSOCKVALID(sock)) {
+                addr = rp->ai_addr;
+                addrlen = (socklen_t) rp->ai_addrlen;
+                break;
+            }
+        }
+        if (NULL == addr) {
+            Janet v = janet_ev_lasterr();
+            if (binding) freeaddrinfo(binding);
+            freeaddrinfo(ai);
+            janet_panicf("could not create socket: %V", v);
+        }
+    }
+
+    /* Bind to bindhost and bindport if given */
+    if (binding) {
+        struct addrinfo *rp = NULL;
+        int did_bind = 0;
+        for (rp = ai; rp != NULL; rp = rp->ai_next) {
+            if (bind(sock, rp->ai_addr, (int) rp->ai_addrlen) == 0) {
+                did_bind = 1;
+                break;
+            }
+        }
+        if (!did_bind) {
+            Janet v = janet_ev_lasterr();
+            freeaddrinfo(binding);
+            freeaddrinfo(ai);
+            JSOCKCLOSE(sock);
+            janet_panicf("could not bind outgoing address: %V", v);
+        } else {
+            freeaddrinfo(binding);
+        }
+    }
+
+    /* Connect to socket */
+#ifdef JANET_WINDOWS
+    int status = WSAConnect(sock, addr, addrlen, NULL, NULL, NULL, NULL);
+    Janet lasterr = janet_ev_lasterr();
+    freeaddrinfo(ai);
+#else
+    int status = connect(sock, addr, addrlen);
+    Janet lasterr = janet_ev_lasterr();
+    if (is_unix) {
+        janet_free(ai);
+    } else {
+        freeaddrinfo(ai);
+    }
+#endif
+
+    if (status == -1) {
+        JSOCKCLOSE(sock);
+        janet_panicf("could not connect socket: %V", lasterr);
+    }
+
+    /* Set up the socket for non-blocking IO after connect - TODO - non-blocking connect? */
+    janet_net_socknoblock(sock);
+
+    /* Wrap socket in abstract type JanetStream */
+    JanetStream *stream = make_stream(sock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE);
+    return janet_wrap_abstract(stream);
+}
+
+static const char *serverify_socket(JSock sfd) {
+    /* Set various socket options */
+    int enable = 1;
+    if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (char *) &enable, sizeof(int)) < 0) {
+        return "setsockopt(SO_REUSEADDR) failed";
+    }
+#ifdef SO_REUSEPORT
+    if (setsockopt(sfd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int)) < 0) {
+        return "setsockopt(SO_REUSEPORT) failed";
+    }
+#endif
+    janet_net_socknoblock(sfd);
+    return NULL;
+}
+
+#ifdef JANET_WINDOWS
+#define JANET_SHUTDOWN_RW SD_BOTH
+#define JANET_SHUTDOWN_R SD_RECEIVE
+#define JANET_SHUTDOWN_W SD_SEND
+#else
+#define JANET_SHUTDOWN_RW SHUT_RDWR
+#define JANET_SHUTDOWN_R SHUT_RD
+#define JANET_SHUTDOWN_W SHUT_WR
+#endif
+
+JANET_CORE_FN(cfun_net_shutdown,
+              "(net/shutdown stream &opt mode)",
+              "Stop communication on this socket in a graceful manner, either in both directions or just "
+              "reading/writing from the stream. The `mode` parameter controls which communication to stop on the socket. "
+              "\n\n* `:wr` is the default and prevents both reading new data from the socket and writing new data to the socket.\n"
+              "* `:r` disables reading new data from the socket.\n"
+              "* `:w` disable writing data to the socket.\n\n"
+              "Returns the original socket.") {
+    janet_arity(argc, 1, 2);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_SOCKET);
+    int shutdown_type = JANET_SHUTDOWN_RW;
+    if (argc == 2) {
+        const uint8_t *kw = janet_getkeyword(argv, 1);
+        if (0 == janet_cstrcmp(kw, "rw")) {
+            shutdown_type = JANET_SHUTDOWN_RW;
+        } else if (0 == janet_cstrcmp(kw, "r")) {
+            shutdown_type = JANET_SHUTDOWN_R;
+        } else if (0 == janet_cstrcmp(kw, "w")) {
+            shutdown_type = JANET_SHUTDOWN_W;
+        } else {
+            janet_panicf("unexpected keyword %v", argv[1]);
+        }
+    }
+    int status;
+#ifdef JANET_WINDOWS
+    status = shutdown((SOCKET) stream->handle, shutdown_type);
+#else
+    do {
+        status = shutdown(stream->handle, shutdown_type);
+    } while (status == -1 && errno == EINTR);
+#endif
+    if (status) {
+        janet_panicf("could not shutdown socket: %V", janet_ev_lasterr());
+    }
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_net_listen,
+              "(net/listen host port &opt type)",
+              "Creates a server. Returns a new stream that is neither readable nor "
+              "writeable. Use net/accept or net/accept-loop be to handle connections and start the server. "
+              "The type parameter specifies the type of network connection, either "
+              "a :stream (usually tcp), or :datagram (usually udp). If not specified, the default is "
+              ":stream. The host and port arguments are the same as in net/address.") {
+    janet_arity(argc, 2, 3);
+
+    /* Get host, port, and handler*/
+    int socktype = janet_get_sockettype(argv, argc, 2);
+    int is_unix = 0;
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 1, &is_unix);
+
+    JSock sfd = JSOCKDEFAULT;
+#ifndef JANET_WINDOWS
+    if (is_unix) {
+        sfd = socket(AF_UNIX, socktype | JSOCKFLAGS, 0);
+        if (!JSOCKVALID(sfd)) {
+            janet_free(ai);
+            janet_panicf("could not create socket: %V", janet_ev_lasterr());
+        }
+        const char *err = serverify_socket(sfd);
+        if (NULL != err || bind(sfd, (struct sockaddr *)ai, sizeof(struct sockaddr_un))) {
+            JSOCKCLOSE(sfd);
+            janet_free(ai);
+            if (err) {
+                janet_panic(err);
+            } else {
+                janet_panicf("could not bind socket: %V", janet_ev_lasterr());
+            }
+        }
+        janet_free(ai);
+    } else
+#endif
+    {
+        /* Check all addrinfos in a loop for the first that we can bind to. */
+        struct addrinfo *rp = NULL;
+        for (rp = ai; rp != NULL; rp = rp->ai_next) {
+#ifdef JANET_WINDOWS
+            sfd = WSASocketW(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
+#else
+            sfd = socket(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol);
+#endif
+            if (!JSOCKVALID(sfd)) continue;
+            const char *err = serverify_socket(sfd);
+            if (NULL != err) {
+                JSOCKCLOSE(sfd);
+                continue;
+            }
+            /* Bind */
+            if (bind(sfd, rp->ai_addr, (int) rp->ai_addrlen) == 0) break;
+            JSOCKCLOSE(sfd);
+        }
+        freeaddrinfo(ai);
+        if (NULL == rp) {
+            janet_panic("could not bind to any sockets");
+        }
+    }
+
+    if (socktype == SOCK_DGRAM) {
+        /* Datagram server (UDP) */
+        JanetStream *stream = make_stream(sfd, JANET_STREAM_UDPSERVER | JANET_STREAM_READABLE);
+        return janet_wrap_abstract(stream);
+    } else {
+        /* Stream server (TCP) */
+
+        /* listen */
+        int status = listen(sfd, 1024);
+        if (status) {
+            JSOCKCLOSE(sfd);
+            janet_panicf("could not listen on file descriptor: %V", janet_ev_lasterr());
+        }
+
+        /* Put sfd on our loop */
+        JanetStream *stream = make_stream(sfd, JANET_STREAM_ACCEPTABLE);
+        return janet_wrap_abstract(stream);
+    }
+}
+
+/* Types of socket's we need to deal with - relevant type puns below.
+struct sockaddr *sa;           // Common base structure
+struct sockaddr_storage *ss;   // Size of largest socket address type
+struct sockaddr_in *sin;       // IPv4 address + port
+struct sockaddr_in6 *sin6;     // IPv6 address + port
+struct sockaddr_un *sun;       // Unix Domain Socket Address
+*/
+
+/* Turn a socket address into a host, port pair.
+ * For unix domain sockets, returned tuple will have only a single element, the path string. */
+static Janet janet_so_getname(const void *sa_any) {
+    const struct sockaddr *sa = sa_any;
+    char buffer[SA_ADDRSTRLEN];
+    switch (sa->sa_family) {
+        default:
+            janet_panic("unknown address family");
+        case AF_INET: {
+            const struct sockaddr_in *sai = sa_any;
+            if (!inet_ntop(AF_INET, &(sai->sin_addr), buffer, sizeof(buffer))) {
+                janet_panic("unable to decode ipv4 host address");
+            }
+            Janet pair[2] = {janet_cstringv(buffer), janet_wrap_integer(ntohs(sai->sin_port))};
+            return janet_wrap_tuple(janet_tuple_n(pair, 2));
+        }
+        case AF_INET6: {
+            const struct sockaddr_in6 *sai6 = sa_any;
+            if (!inet_ntop(AF_INET6, &(sai6->sin6_addr), buffer, sizeof(buffer))) {
+                janet_panic("unable to decode ipv4 host address");
+            }
+            Janet pair[2] = {janet_cstringv(buffer), janet_wrap_integer(ntohs(sai6->sin6_port))};
+            return janet_wrap_tuple(janet_tuple_n(pair, 2));
+        }
+#ifndef JANET_WINDOWS
+        case AF_UNIX: {
+            const struct sockaddr_un *sun = sa_any;
+            Janet pathname;
+            if (sun->sun_path[0] == '\0') {
+                memcpy(buffer, sun->sun_path, sizeof(sun->sun_path));
+                buffer[0] = '@';
+                pathname = janet_cstringv(buffer);
+            } else {
+                pathname = janet_cstringv(sun->sun_path);
+            }
+            return janet_wrap_tuple(janet_tuple_n(&pathname, 1));
+        }
+#endif
+    }
+}
+
+JANET_CORE_FN(cfun_net_getsockname,
+              "(net/localname stream)",
+              "Gets the local address and port in a tuple in that order.") {
+    janet_fixarity(argc, 1);
+    JanetStream *js = janet_getabstract(argv, 0, &janet_stream_type);
+    if (js->flags & JANET_STREAM_CLOSED) janet_panic("stream closed");
+    struct sockaddr_storage ss;
+    socklen_t slen = sizeof(ss);
+    memset(&ss, 0, slen);
+    if (getsockname((JSock)js->handle, (struct sockaddr *) &ss, &slen)) {
+        janet_panicf("Failed to get localname on %v: %V", argv[0], janet_ev_lasterr());
+    }
+    janet_assert(slen <= sizeof(ss), "socket address truncated");
+    return janet_so_getname(&ss);
+}
+
+JANET_CORE_FN(cfun_net_getpeername,
+              "(net/peername stream)",
+              "Gets the remote peer's address and port in a tuple in that order.") {
+    janet_fixarity(argc, 1);
+    JanetStream *js = janet_getabstract(argv, 0, &janet_stream_type);
+    if (js->flags & JANET_STREAM_CLOSED) janet_panic("stream closed");
+    struct sockaddr_storage ss;
+    socklen_t slen = sizeof(ss);
+    memset(&ss, 0, slen);
+    if (getpeername((JSock)js->handle, (struct sockaddr *)&ss, &slen)) {
+        janet_panicf("Failed to get peername on %v: %V", argv[0], janet_ev_lasterr());
+    }
+    janet_assert(slen <= sizeof(ss), "socket address truncated");
+    return janet_so_getname(&ss);
+}
+
+JANET_CORE_FN(cfun_net_address_unpack,
+              "(net/address-unpack address)",
+              "Given an address returned by net/adress, return a host, port pair. Unix domain sockets "
+              "will have only the path in the returned tuple.") {
+    janet_fixarity(argc, 1);
+    struct sockaddr *sa = janet_getabstract(argv, 0, &janet_address_type);
+    return janet_so_getname(sa);
+}
+
+JANET_CORE_FN(cfun_stream_accept_loop,
+              "(net/accept-loop stream handler)",
+              "Shorthand for running a server stream that will continuously accept new connections. "
+              "Blocks the current fiber until the stream is closed, and will return the stream.") {
+    janet_fixarity(argc, 2);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_ACCEPTABLE | JANET_STREAM_SOCKET);
+    JanetFunction *fun = janet_getfunction(argv, 1);
+    janet_sched_accept(stream, fun);
+}
+
+JANET_CORE_FN(cfun_stream_accept,
+              "(net/accept stream &opt timeout)",
+              "Get the next connection on a server stream. This would usually be called in a loop in a dedicated fiber. "
+              "Takes an optional timeout in seconds, after which will return nil. "
+              "Returns a new duplex stream which represents a connection to the client.") {
+    janet_arity(argc, 1, 2);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_ACCEPTABLE | JANET_STREAM_SOCKET);
+    double to = janet_optnumber(argv, argc, 1, INFINITY);
+    if (to != INFINITY) janet_addtimeout(to);
+    janet_sched_accept(stream, NULL);
+}
+
+JANET_CORE_FN(cfun_stream_read,
+              "(net/read stream nbytes &opt buf timeout)",
+              "Read up to n bytes from a stream, suspending the current fiber until the bytes are available. "
+              "`n` can also be the keyword `:all` to read into the buffer until end of stream. "
+              "If less than n bytes are available (and more than 0), will push those bytes and return early. "
+              "Takes an optional timeout in seconds, after which will return nil. "
+              "Returns a buffer with up to n more bytes in it, or raises an error if the read failed.") {
+    janet_arity(argc, 2, 4);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_READABLE | JANET_STREAM_SOCKET);
+    JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, 10);
+    double to = janet_optnumber(argv, argc, 3, INFINITY);
+    if (janet_keyeq(argv[1], "all")) {
+        if (to != INFINITY) janet_addtimeout(to);
+        janet_ev_recvchunk(stream, buffer, INT32_MAX, MSG_NOSIGNAL);
+    } else {
+        int32_t n = janet_getnat(argv, 1);
+        if (to != INFINITY) janet_addtimeout(to);
+        janet_ev_recv(stream, buffer, n, MSG_NOSIGNAL);
+    }
+    janet_await();
+}
+
+JANET_CORE_FN(cfun_stream_chunk,
+              "(net/chunk stream nbytes &opt buf timeout)",
+              "Same a net/read, but will wait for all n bytes to arrive rather than return early. "
+              "Takes an optional timeout in seconds, after which will return nil.") {
+    janet_arity(argc, 2, 4);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_READABLE | JANET_STREAM_SOCKET);
+    int32_t n = janet_getnat(argv, 1);
+    JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, 10);
+    double to = janet_optnumber(argv, argc, 3, INFINITY);
+    if (to != INFINITY) janet_addtimeout(to);
+    janet_ev_recvchunk(stream, buffer, n, MSG_NOSIGNAL);
+    janet_await();
+}
+
+JANET_CORE_FN(cfun_stream_recv_from,
+              "(net/recv-from stream nbytes buf &opt timoeut)",
+              "Receives data from a server stream and puts it into a buffer. Returns the socket-address the "
+              "packet came from. Takes an optional timeout in seconds, after which will return nil.") {
+    janet_arity(argc, 3, 4);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_UDPSERVER | JANET_STREAM_SOCKET);
+    int32_t n = janet_getnat(argv, 1);
+    JanetBuffer *buffer = janet_getbuffer(argv, 2);
+    double to = janet_optnumber(argv, argc, 3, INFINITY);
+    if (to != INFINITY) janet_addtimeout(to);
+    janet_ev_recvfrom(stream, buffer, n, MSG_NOSIGNAL);
+    janet_await();
+}
+
+JANET_CORE_FN(cfun_stream_write,
+              "(net/write stream data &opt timeout)",
+              "Write data to a stream, suspending the current fiber until the write "
+              "completes. Takes an optional timeout in seconds, after which will return nil. "
+              "Returns nil, or raises an error if the write failed.") {
+    janet_arity(argc, 2, 3);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_WRITABLE | JANET_STREAM_SOCKET);
+    double to = janet_optnumber(argv, argc, 2, INFINITY);
+    if (janet_checktype(argv[1], JANET_BUFFER)) {
+        if (to != INFINITY) janet_addtimeout(to);
+        janet_ev_send_buffer(stream, janet_getbuffer(argv, 1), MSG_NOSIGNAL);
+    } else {
+        JanetByteView bytes = janet_getbytes(argv, 1);
+        if (to != INFINITY) janet_addtimeout(to);
+        janet_ev_send_string(stream, bytes.bytes, MSG_NOSIGNAL);
+    }
+    janet_await();
+}
+
+JANET_CORE_FN(cfun_stream_send_to,
+              "(net/send-to stream dest data &opt timeout)",
+              "Writes a datagram to a server stream. dest is a the destination address of the packet. "
+              "Takes an optional timeout in seconds, after which will return nil. "
+              "Returns stream.") {
+    janet_arity(argc, 3, 4);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_UDPSERVER | JANET_STREAM_SOCKET);
+    void *dest = janet_getabstract(argv, 1, &janet_address_type);
+    double to = janet_optnumber(argv, argc, 3, INFINITY);
+    if (janet_checktype(argv[2], JANET_BUFFER)) {
+        if (to != INFINITY) janet_addtimeout(to);
+        janet_ev_sendto_buffer(stream, janet_getbuffer(argv, 2), dest, MSG_NOSIGNAL);
+    } else {
+        JanetByteView bytes = janet_getbytes(argv, 2);
+        if (to != INFINITY) janet_addtimeout(to);
+        janet_ev_sendto_string(stream, bytes.bytes, dest, MSG_NOSIGNAL);
+    }
+    janet_await();
+}
+
+JANET_CORE_FN(cfun_stream_flush,
+              "(net/flush stream)",
+              "Make sure that a stream is not buffering any data. This temporarily disables Nagle's algorithm. "
+              "Use this to make sure data is sent without delay. Returns stream.") {
+    janet_fixarity(argc, 1);
+    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
+    janet_stream_flags(stream, JANET_STREAM_WRITABLE | JANET_STREAM_SOCKET);
+    /* Toggle no delay flag */
+    int flag = 1;
+    setsockopt((JSock) stream->handle, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int));
+    flag = 0;
+    setsockopt((JSock) stream->handle, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int));
+    return argv[0];
+}
+
+static const JanetMethod net_stream_methods[] = {
+    {"chunk", cfun_stream_chunk},
+    {"close", janet_cfun_stream_close},
+    {"read", cfun_stream_read},
+    {"write", cfun_stream_write},
+    {"flush", cfun_stream_flush},
+    {"accept", cfun_stream_accept},
+    {"accept-loop", cfun_stream_accept_loop},
+    {"send-to", cfun_stream_send_to},
+    {"recv-from", cfun_stream_recv_from},
+    {"evread", janet_cfun_stream_read},
+    {"evchunk", janet_cfun_stream_chunk},
+    {"evwrite", janet_cfun_stream_write},
+    {"shutdown", cfun_net_shutdown},
+    {NULL, NULL}
+};
+
+static JanetStream *make_stream(JSock handle, uint32_t flags) {
+    return janet_stream((JanetHandle) handle, flags | JANET_STREAM_SOCKET, net_stream_methods);
+}
+
+void janet_lib_net(JanetTable *env) {
+    JanetRegExt net_cfuns[] = {
+        JANET_CORE_REG("net/address", cfun_net_sockaddr),
+        JANET_CORE_REG("net/listen", cfun_net_listen),
+        JANET_CORE_REG("net/accept", cfun_stream_accept),
+        JANET_CORE_REG("net/accept-loop", cfun_stream_accept_loop),
+        JANET_CORE_REG("net/read", cfun_stream_read),
+        JANET_CORE_REG("net/chunk", cfun_stream_chunk),
+        JANET_CORE_REG("net/write", cfun_stream_write),
+        JANET_CORE_REG("net/send-to", cfun_stream_send_to),
+        JANET_CORE_REG("net/recv-from", cfun_stream_recv_from),
+        JANET_CORE_REG("net/flush", cfun_stream_flush),
+        JANET_CORE_REG("net/connect", cfun_net_connect),
+        JANET_CORE_REG("net/shutdown", cfun_net_shutdown),
+        JANET_CORE_REG("net/peername", cfun_net_getpeername),
+        JANET_CORE_REG("net/localname", cfun_net_getsockname),
+        JANET_CORE_REG("net/address-unpack", cfun_net_address_unpack),
+        JANET_REG_END
+    };
+    janet_core_cfuns_ext(env, NULL, net_cfuns);
+}
+
+void janet_net_init(void) {
+#ifdef JANET_WINDOWS
+    WSADATA wsaData;
+    janet_assert(!WSAStartup(MAKEWORD(2, 2), &wsaData), "could not start winsock");
+#endif
+}
+
+void janet_net_deinit(void) {
+#ifdef JANET_WINDOWS
+    WSACleanup();
+#endif
+}
+
+#endif