Broken Pipe error on windows should just be end of stream.

Also adds a lot to the C API and changes things up.

.gitattributes

@@ -1 +1,10 @@
 *.janet linguist-language=Clojure
+
+*.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

.gitignore

@@ -32,6 +32,9 @@ lockfile.janet
 # Local directory for testing
 local
 
+# Common test file I use.
+temp.janet
+
 # Emscripten
 *.bc
 janet.js
@@ -43,6 +46,7 @@ janet.wasm
 
 # Generate test files
 *.out
+.orig
 
 # Tools
 xxd
@@ -50,6 +54,7 @@ xxd.exe
 
 # VSCode
 .vs
+.clangd
 
 # Swap files
 *.swp

CHANGELOG.md

@@ -1,6 +1,21 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## Unreleased - ???
+- 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 asynchornous 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 furter improvements to these utility functions.
+
+## 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.

Makefile

@@ -97,6 +97,7 @@ JANET_CORE_SOURCES=src/core/abstract.c \
 				   src/core/corelib.c \
 				   src/core/debug.c \
 				   src/core/emit.c \
+				   src/core/ev.c \
 				   src/core/fiber.c \
 				   src/core/gc.c \
 				   src/core/inttypes.c \
@@ -141,7 +142,7 @@ JANET_BOOT_OBJECTS=$(patsubst src/%.c,build/%.boot.o,$(JANET_CORE_SOURCES) $(JAN
 
 $(JANET_BOOT_OBJECTS): $(JANET_BOOT_HEADERS)
 
-build/%.boot.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS)
+build/%.boot.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 	$(CC) $(BOOT_CFLAGS) -o $@ -c $<
 
 build/janet_boot: $(JANET_BOOT_OBJECTS)
@@ -261,7 +262,7 @@ build/janet.pc: $(JANET_TARGET)
 	echo 'Libs: -L$${libdir} -ljanet' >> $@
 	echo 'Libs.private: $(CLIBS)' >> $@
 
-install: $(JANET_TARGET) build/janet.pc build/jpm
+install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc build/jpm
 	mkdir -p '$(DESTDIR)$(BINDIR)'
 	cp $(JANET_TARGET) '$(DESTDIR)$(BINDIR)/janet'
 	mkdir -p '$(DESTDIR)$(INCLUDEDIR)/janet'
@@ -301,6 +302,10 @@ 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
@@ -342,4 +347,4 @@ help:
 	@echo
 
 .PHONY: clean install repl debug valgrind test \
-	valtest dist uninstall docs grammar format help
+	valtest dist uninstall docs grammar format help compile-commands

README.md

@@ -14,9 +14,9 @@ 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 can 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).
 
 <br>
@@ -30,23 +30,23 @@ Lua, but smaller than GNU Guile or Python.
 ## Features
 
 * 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)
 * Macros
 * 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
-* Parsing Expression Grammars built in to 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
@@ -56,7 +56,7 @@ Lua, but smaller than GNU Guile or Python.
 * For a quick tutorial, see [the introduction](https://janet-lang.org/docs/index.html) for more details.
 * For the full API for all functions in the core library, see [the core API doc](https://janet-lang.org/api/index.html)
 
-Documentation is also available locally in the repl.
+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,
 ```
@@ -66,7 +66,7 @@ Shows documentation for the doc macro.
 
 To get a list of all bindings in the default
 environment, use the `(all-bindings)` function. You
-can also use the `(doc)` macro with no arguments if you are in the repl
+can also use the `(doc)` macro with no arguments if you are in the REPL
 to show bound symbols.
 
 ## Source
@@ -92,7 +92,7 @@ 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,
+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`.
 
 ```
@@ -104,7 +104,7 @@ make repl
 
 ### FreeBSD
 
-FreeBSD build instructions are the same as the unix-like build instuctions,
+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`.
 
@@ -117,7 +117,7 @@ gmake repl
 
 ### NetBSD
 
-NetBSD build instructions are the same as the FreeBSD build instuctions.
+NetBSD build instructions are the same as the FreeBSD build instructions.
 Alternatively, install directly from packages, using `pkgin install janet`.
 
 ### Windows
@@ -136,11 +136,11 @@ Now you should have an `.msi`. You can run `build_win install` to install the `.
 
 ### 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
+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 cross-compilation.
 
 For the impatient, building with Meson is as follows. The options provided to
 `meson setup` below emulate Janet's Makefile.
@@ -177,11 +177,11 @@ to try out the language, you don't need to install anything. You can also move t
 
 ## 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-bindings)` into the repl.
+by entering the command `(all-bindings)` into the REPL.
 
 ```
 $ janet
@@ -199,13 +199,13 @@ Options are:
   -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)
+  -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
+  -n : Disable ANSI color output in the REPL
   -l path : Execute code in a file before running the main script
   -- : Stop handling options
 ```
@@ -232,16 +232,16 @@ See the examples directory for some example janet code.
 
 ## Discussion
 
-Feel free to ask questions and join discussion on the [Janet Gitter Channel](https://gitter.im/janet-language/community).
+Feel free to ask questions and join the discussion on the [Janet Gitter Channel](https://gitter.im/janet-language/community).
 Alternatively, check out [the #janet channel on Freenode](https://webchat.freenode.net/)
 
 ## FAQ
 
-### Why is my terminal spitting out junk when I run the repl?
+### 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
+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.
 

build_win.bat

@@ -102,6 +102,7 @@ exit /b 0
 mkdir dist
 janet.exe tools\gendoc.janet > dist\doc.html
 janet.exe tools\removecr.janet dist\doc.html
+janet.exe tools\removecr.janet build\janet.c
 
 copy build\janet.c dist\janet.c
 copy src\mainclient\shell.c dist\shell.c

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/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/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/evsleep.janet

@@ -0,0 +1,12 @@
+(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)

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/tcpserver.janet

@@ -6,8 +6,15 @@
     (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)))
 
-(net/server "127.0.0.1" "8000" handler)
+# 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/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/server "127.0.0.1" "8009" nil :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))

jpm.1

@@ -74,6 +74,7 @@ $JANET_LIBPATH, or a reasonable default. See JANET_LIBPATH for more.
 Sets the C compiler used for compiling native modules and standalone executables. Defaults
 to cc.
 
+.TP
 .BR \-\-cpp\-compiler=$CXX
 Sets the C++ compiler used for compiling native modules and standalone executables. Defaults
 to c++..
@@ -105,7 +106,6 @@ be created in the ./build/ directory.
 
 .TP
 .BR install\ [\fBrepo...\fR]
-
 When run with no arguments, installs all installable artifacts in the current project to
 the current JANET_MODPATH for modules and JANET_BINPATH for executables and scripts. Can also
 take an optional git repository URL and will install all artifacts in that repository instead.
@@ -115,7 +115,7 @@ install multiple dependencies in one command.
 .TP
 .BR uninstall\ [\fBname...\fR]
 Uninstall a project installed with install. uninstall expects the name of the project, not the
-repository url, path to installed file or executable name. The name of the project must be specified
+repository url, path to installed file, or executable name. The name of the project must be specified
 at the top of the project.janet file in the declare-project form. If no name is given, uninstalls
 the current project if installed. Will also uninstall multiple packages in one command.
 
@@ -148,7 +148,7 @@ required.
 List all installed packages in the current syspath.
 
 .TP
-.BR list-pkgs [\fBsearch\fR]
+.BR list-pkgs\ [\fBsearch\fR]
 List all package aliases in the current package listing that contain the given search string.
 If no search string is given, prints the entire listing.
 
@@ -172,7 +172,7 @@ like make. run will run a single rule or build a single file.
 List all rules that can be run via run. This is useful for exploring rules in the project.
 
 .TP
-.BR rule-tree\ [\fBroot\fR] [\fdepth\fR]
+.BR rule-tree\ [\fBroot\fR]\ [\fBdepth\fR]
 Show rule dependency tree in a pretty format. Optionally provide a rule to use as the tree
 root, as well as a max depth to print. By default, prints the full tree for all rules. This
 can be quite long, so it is recommended to give a root rule.
@@ -186,7 +186,7 @@ Show all of the paths used when installing and building artifacts.
 Update the package listing by installing the 'pkgs' package. Same as jpm install pkgs
 
 .TP
-.BR quickbin [\fBentry\fR] [\fBexecutable\fR]
+.BR quickbin\ [\fBentry\fR]\ [\fBexecutable\fR]
 Create a standalone, statically linked executable from a Janet source file that contains a main function.
 The main function is the entry point of the program and will receive command line arguments
 as function arguments. The entry file can import other modules, including native C modules, and
@@ -222,7 +222,7 @@ the default location set at compile time, which can be determined with (dyn :sys
 .RS
 The location that jpm will use to install libraries to. Defaults to JANET_PATH, but you could
 set this to a different directory if you want to. Doing so would let you import Janet modules
-on the normal system path (JANET_PATH or (dyn :syspath)), but install to a different directory. It is also a more reliable way to install
+on the normal system path (JANET_PATH or (dyn :syspath)), but install to a different directory. It is also a more reliable way to install.
 This variable is overwritten by the --modpath=/some/path if it is provided.
 .RE
 
@@ -238,7 +238,7 @@ variable.
 .B JANET_LIBPATH
 .RS
 Similar to JANET_HEADERPATH, this path is where jpm will look for
-libjanet.a for creating standalong executables. This does not need to be
+libjanet.a for creating standalone executables. This does not need to be
 set on a normal install. 
 If not provided, this will default to <jpm script location>/../lib.
 The --libpath=/some/path option will override this variable.
@@ -257,11 +257,13 @@ The --binpath=/some/path will override this variable.
 The git repository URL that contains a listing of packages. This allows installing packages with shortnames, which
 is mostly a convenience. However, package dependencies can use short names, package listings
 can be used to choose a particular set of dependency versions for a whole project.
+.RE
 
 .B JANET_GIT
 .RS
 An optional path to a git executable to use to clone git dependencies. By default, uses "git" on the current $PATH. You shouldn't need to set this
 if you have a normal install of git.
+.RE
 
 .SH AUTHOR
 Written by Calvin Rose <calsrose@gmail.com>

meson.build

@@ -20,7 +20,7 @@
 
 project('janet', 'c',
   default_options : ['c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.12.1')
+  version : '1.13.0')
 
 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -60,6 +60,7 @@ 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'))
 conf.set('JANET_REDUCED_OS', get_option('reduced_os'))
 conf.set('JANET_NO_TYPED_ARRAY', not get_option('typed_array'))
 conf.set('JANET_NO_INT_TYPES', not get_option('int_types'))
@@ -111,6 +112,7 @@ core_src = [
   'src/core/corelib.c',
   'src/core/debug.c',
   'src/core/emit.c',
+  'src/core/ev.c',
   'src/core/fiber.c',
   'src/core/gc.c',
   'src/core/inttypes.c',

meson_options.txt

@@ -12,6 +12,7 @@ option('typed_array', 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)

src/boot/boot.janet

@@ -1141,7 +1141,10 @@
     :table (walk-dict f form)
     :struct (table/to-struct (walk-dict f form))
     :array (walk-ind f form)
-    :tuple (tuple/slice (walk-ind f form))
+    :tuple (let [x (walk-ind f form)]
+             (if (= :parens (tuple/type form))
+               (tuple/slice x)
+               (tuple/brackets ;x)))
     form))
 
 (undef walk-ind)
@@ -1389,7 +1392,7 @@
   arr)
 
 (defn pairs
-  "Get the values of an associative data structure."
+  "Get the key-value pairs of an associative data structure."
   [x]
   (def arr (array/new (length x)))
   (var k (next x nil))
@@ -1702,7 +1705,7 @@
   (print (doc-format (string "Bindings:\n\n" (string/join bindings " "))))
   (print)
   (print (doc-format (string "Dynamics:\n\n" (string/join dynamics " "))))
-  (print))
+  (print "\n    Use (doc sym) for more information on a binding.\n"))
 
 (defn doc*
   "Get the documentation for a symbol in a given environment. Function form of doc."
@@ -2485,7 +2488,7 @@
   (tuple import* (string path) ;argm))
 
 (defmacro use
-  "Similar to import, but imported bindings are not prefixed with a namespace
+  "Similar to import, but imported bindings are not prefixed with a module
   identifier. Can also import multiple modules in one shot."
   [& modules]
   ~(do ,;(map |~(,import* ,(string $) :prefix "") modules)))
@@ -2719,6 +2722,37 @@
                 :on-status (or onsignal (make-onsignal env 1))
                 :source "repl"}))
 
+###
+###
+### Extras
+###
+###
+
+(defmacro- guarddef
+  [sym form]
+  (if (dyn sym)
+    form))
+
+(guarddef ev/go
+  (defmacro ev/spawn
+    "Run some code in a new fiber. This is shorthand for (ev/call (fn [] ;body))."
+    [& body]
+    ~(,ev/call (fn [] ,;body))))
+
+(guarddef net/listen
+  (defn net/server
+    "Start a server asynchornously with net/listen and net/accept-loop. Returns the new server stream."
+    [host port &opt handler type]
+    (def s (net/listen host port type))
+    (if handler
+      (ev/call (fn [] (net/accept-loop s handler))))
+    s))
+
+(guarddef ev/close
+  (defn net/close "Alias for ev/close." [stream] (ev/close stream)))
+
+(undef guarddef)
+
 ###
 ###
 ### CLI Tool Main
@@ -2726,7 +2760,7 @@
 ###
 
 (defn- no-side-effects
-  "Check if form may have side effects. If returns true, then the src
+  "Check if form may have side effects. If rturns true, then the src
   must not have side effects, such as calling a C function."
   [src]
   (cond
@@ -2783,14 +2817,14 @@
   -v : Print the version string
   -s : Use raw stdin instead of getline like functionality
   -e code : Execute a string of janet
-  -d : Set the debug flag in the repl
-  -r : Enter the repl after running all scripts
-  -p : Keep on executing if there is a top level error (persistent)
+  -d : Set the debug flag in the REPL
+  -r : Enter the REPL after running all scripts
+  -p : Keep on executing if there is a top-level error (persistent)
   -q : Hide logo (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
+  -n : Disable ANSI color output in the REPL
   -l lib : Import a module before processing more arguments
   -- : Stop handling options`)
            (os/exit 0)
@@ -2868,7 +2902,7 @@
 
   (when (and (not *compile-only*) (or *should-repl* *no-file*))
     (if-not *quiet*
-      (print "Janet " janet/version "-" janet/build " " (os/which) "/" (os/arch)))
+      (print "Janet " janet/version "-" janet/build " " (os/which) "/" (os/arch) " - '(doc)' for help"))
     (flush)
     (defn getprompt [p]
       (def [line] (parser/where p))
@@ -2972,6 +3006,7 @@
      "src/core/corelib.c"
      "src/core/debug.c"
      "src/core/emit.c"
+     "src/core/ev.c"
      "src/core/fiber.c"
      "src/core/gc.c"
      "src/core/inttypes.c"

src/conf/janetconf.h

@@ -27,10 +27,10 @@
 #define JANETCONF_H
 
 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 12
-#define JANET_VERSION_PATCH 1
-#define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.12.1"
+#define JANET_VERSION_MINOR 13
+#define JANET_VERSION_PATCH 0
+#define JANET_VERSION_EXTRA "-dev"
+#define JANET_VERSION "1.13.0-dev"
 
 /* #define JANET_BUILD "local" */
 
@@ -52,6 +52,7 @@
 /* #define JANET_NO_NET */
 /* #define JANET_NO_TYPED_ARRAY */
 /* #define JANET_NO_INT_TYPES */
+/* #define JANET_NO_EV */
 /* #define JANET_NO_REALPATH */
 /* #define JANET_NO_SYMLINKS */
 /* #define JANET_NO_UMASK */
@@ -69,6 +70,7 @@
 /* #define JANET_STACK_MAX 16384 */
 /* #define JANET_OS_NAME my-custom-os */
 /* #define JANET_ARCH_NAME pdp-8 */
+/* #define JANET_EV_EPOLL */
 
 /* Main client settings, does not affect library code */
 /* #define JANET_SIMPLE_GETLINE */

src/core/array.c

@@ -344,16 +344,16 @@ static const JanetReg array_cfuns[] = {
     {
         "array/concat", cfun_array_concat,
         JDOC("(array/concat arr & parts)\n\n"
-             "Concatenates a variadic number of arrays (and tuples) into the first argument "
-             "which must an array. If any of the parts are arrays or tuples, their elements will "
+             "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.")
     },
     {
         "array/insert", cfun_array_insert,
         JDOC("(array/insert arr at & xs)\n\n"
-             "Insert all of xs into array arr at index at. at should be an integer "
-             "0 and the length of the array. A negative value for at will index from "
+             "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.")
     },

src/core/asm.c

@@ -988,7 +988,7 @@ static const JanetReg asm_cfuns[] = {
     {
         "disasm", cfun_disasm,
         JDOC("(disasm func &opt field)\n\n"
-             "Returns assembly that could be used be compile the given function.\n"
+             "Returns assembly that could be used to compile the given function.\n"
              "func must be a function, not a c function. Will throw on error on a badly\n"
              "typed argument. If given a field name, will only return that part of the function assembly.\n"
              "Possible fields are:\n\n"

src/core/corelib.c

@@ -1034,6 +1034,9 @@ static void janet_load_libs(JanetTable *env) {
 #ifdef JANET_THREADS
     janet_lib_thread(env);
 #endif
+#ifdef JANET_EV
+    janet_lib_ev(env);
+#endif
 #ifdef JANET_NET
     janet_lib_net(env);
 #endif

src/core/fiber.c

@@ -37,6 +37,10 @@ static void fiber_reset(JanetFiber *fiber) {
     fiber->child = NULL;
     fiber->flags = JANET_FIBER_MASK_YIELD | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
     fiber->env = NULL;
+#ifdef JANET_EV
+    fiber->waiting = NULL;
+    fiber->sched_id = 0;
+#endif
     janet_fiber_set_status(fiber, JANET_STATUS_NEW);
 }
 
@@ -77,6 +81,7 @@ JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t
     }
     if (janet_fiber_funcframe(fiber, callee)) return NULL;
     janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE;
+    fiber->waiting = NULL;
     return fiber;
 }
 
@@ -103,12 +108,15 @@ static void janet_fiber_refresh_memory(JanetFiber *fiber) {
 
 /* Ensure that the fiber has enough extra capacity */
 void janet_fiber_setcapacity(JanetFiber *fiber, int32_t n) {
+    int32_t old_size = fiber->capacity;
+    int32_t diff = n - old_size;
     Janet *newData = 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 */

src/core/fiber.h

@@ -46,8 +46,9 @@
 #define JANET_FIBER_MASK_USERN(N) (16 << (N))
 #define JANET_FIBER_MASK_USER 0x3FF0
 
-#define JANET_FIBER_RESUME_SIGNAL 0x800000
-#define JANET_FIBER_STATUS_MASK 0x7F0000
+#define JANET_FIBER_STATUS_MASK 0x3F0000
+#define JANET_FIBER_FLAG_SCHEDULED 0x800000
+#define JANET_FIBER_RESUME_SIGNAL 0x400000
 #define JANET_FIBER_STATUS_OFFSET 16
 
 #define JANET_FIBER_BREAKPOINT       0x1000000
@@ -77,4 +78,8 @@ 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

@@ -28,6 +28,7 @@
 #include "gc.h"
 #include "util.h"
 #include "fiber.h"
+#include "vector.h"
 #endif
 
 struct JanetScratch {
@@ -400,9 +401,10 @@ void janet_collect(void) {
         janet_vm_gc_interval = janet_vm_block_count * sizeof(JanetGCObject);
     }
     orig_rootcount = janet_vm_root_count;
-#ifdef JANET_NET
-    janet_net_markloop();
+#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) {

src/core/io.c

@@ -299,8 +299,8 @@ static Janet cfun_io_fclose(int32_t argc, Janet *argv) {
             janet_panic("could not close file");
         }
         iof->flags |= JANET_FILE_CLOSED;
-        return janet_wrap_nil();
     }
+    return janet_wrap_nil();
 }
 
 /* Seek a file */
@@ -777,7 +777,7 @@ static const JanetReg io_cfuns[] = {
 #ifndef JANET_NO_PROCESSES
     {
         "file/popen", cfun_io_popen,
-        JDOC("(file/popen path &opt mode)\n\n"
+        JDOC("(file/popen command &opt 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 "
@@ -799,6 +799,10 @@ FILE *janet_getfile(const Janet *argv, int32_t n, int *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));
 }

src/core/marsh.c

@@ -285,8 +285,8 @@ static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags) {
 }
 
 #define JANET_FIBER_FLAG_HASCHILD (1 << 29)
-#define JANET_FIBER_FLAG_HASENV (1 << 28)
-#define JANET_STACKFRAME_HASENV (1 << 30)
+#define JANET_FIBER_FLAG_HASENV   (1 << 30)
+#define JANET_STACKFRAME_HASENV   (1 << 31)
 
 /* Marshal a fiber */
 static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) {
@@ -934,6 +934,10 @@ static const uint8_t *unmarshal_one_fiber(
     fiber->data = NULL;
     fiber->child = NULL;
     fiber->env = NULL;
+#ifdef JANET_EV
+    fiber->waiting = NULL;
+    fiber->sched_id = 0;
+#endif
 
     /* Push fiber to seen stack */
     janet_v_push(st->lookup, janet_wrap_fiber(fiber));
@@ -1048,6 +1052,11 @@ static const uint8_t *unmarshal_one_fiber(
     fiber->maxstack = fiber_maxstack;
     fiber->env = fiber_env;
 
+    int status = janet_fiber_status(fiber);
+    if (status < 0 || status > JANET_STATUS_ALIVE) {
+        janet_panic("invalid fiber status");
+    }
+
     /* Return data */
     *out = fiber;
     return data;

src/core/os.c

@@ -221,7 +221,8 @@ static char **os_execute_env(int32_t argc, const Janet *argv) {
     return envp;
 }
 
-/* Free memory from os_execute */
+/* Free memory from os_execute. Not actually needed, but doesn't pressure the GC
+   in the happy path. */
 static void os_execute_cleanup(char **envp, const char **child_argv) {
 #ifdef JANET_WINDOWS
     (void) child_argv;
@@ -414,6 +415,69 @@ static Janet os_proc_kill(int32_t argc, Janet *argv) {
     }
 }
 
+static void swap_handles(JanetHandle *handles) {
+    JanetHandle temp = handles[0];
+    handles[0] = handles[1];
+    handles[1] = temp;
+}
+
+static void close_handle(JanetHandle handle) {
+#ifdef JANET_WINDOWS
+    CloseHandle(handle);
+#else
+    close(handle);
+#endif
+}
+
+/* Create piped file for os/execute and os/spawn. Need to be careful that we mark
+   the error flag if we can't create pipe and don't leak handles. *handle will be cleaned
+   up by the calling function. If everything goes well, *handle is owned by the calling function,
+   (if it is set) and the returned JanetFile owns the other end of the pipe, which will be closed
+   on GC or fclose. */
+static JanetFile *make_pipes(JanetHandle *handle, int reverse, int *errflag) {
+    JanetHandle handles[2];
+#ifdef JANET_WINDOWS
+    SECURITY_ATTRIBUTES saAttr;
+    memset(&saAttr, 0, sizeof(saAttr));
+    saAttr.nLength = sizeof(saAttr);
+    saAttr.bInheritHandle = TRUE;
+    if (!CreatePipe(handles, handles + 1, &saAttr, 0)) goto error_pipe;
+    if (reverse) swap_handles(handles);
+    /* Don't inherit the side of the pipe owned by this process */
+    if (!SetHandleInformation(handles[0], HANDLE_FLAG_INHERIT, 0)) goto error_set_handle_info;
+    *handle = handles[1];
+    int fd = _open_osfhandle((intptr_t) handles[0], reverse ? _O_WRONLY : _O_RDONLY);
+    if (fd == -1) goto error_open_osfhandle;
+    FILE *f = _fdopen(fd, reverse ? "w" : "r");
+    if (NULL == f) goto error_fdopen;
+    return janet_makejfile(f, reverse ? JANET_FILE_WRITE : JANET_FILE_READ);
+error_fdopen:
+    _close(fd); /* we need to close the fake file descriptor instead of the handle, as ownership has been transfered. */
+    *errflag = 1;
+    return NULL;
+error_set_handle_info:
+error_open_osfhandle:
+    close_handle(handles[0]);
+    /* fallthrough */
+error_pipe:
+    *errflag = 1;
+    return NULL;
+#else
+    if (pipe(handles)) goto error_pipe;
+    if (reverse) swap_handles(handles);
+    *handle = handles[1];
+    FILE *f = fdopen(handles[0], reverse ? "w" : "r");
+    if (NULL == f) goto error_fdopen;
+    return janet_makejfile(f, reverse ? JANET_FILE_WRITE : JANET_FILE_READ);
+error_fdopen:
+    close_handle(handles[0]);
+    /* fallthrough */
+error_pipe:
+    *errflag = 1;
+    return NULL;
+#endif
+}
+
 static const JanetMethod proc_methods[] = {
     {"wait", os_proc_wait},
     {"kill", os_proc_kill},
@@ -460,6 +524,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
     }
 
     /* Get environment */
+    int use_environ = !janet_flag_at(flags, 0);
     char **envp = os_execute_env(argc, argv);
 
     /* Get arguments */
@@ -470,6 +535,8 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
 
     /* Optional stdio redirections */
     JanetFile *new_in = NULL, *new_out = NULL, *new_err = NULL;
+    JanetHandle pipe_in = JANET_HANDLE_NONE, pipe_out = JANET_HANDLE_NONE, pipe_err = JANET_HANDLE_NONE;
+    int pipe_errflag = 0; /* Track errors setting up pipes */
 
     /* Get optional redirections */
     if (argc > 2) {
@@ -477,9 +544,29 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
         Janet maybe_stdin = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("in"));
         Janet maybe_stdout = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("out"));
         Janet maybe_stderr = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("err"));
-        if (!janet_checktype(maybe_stdin, JANET_NIL)) new_in = janet_getjfile(&maybe_stdin, 0);
-        if (!janet_checktype(maybe_stdout, JANET_NIL)) new_out = janet_getjfile(&maybe_stdout, 0);
-        if (!janet_checktype(maybe_stderr, JANET_NIL)) new_err = janet_getjfile(&maybe_stderr, 0);
+        if (janet_keyeq(maybe_stdin, "pipe")) {
+            new_in = make_pipes(&pipe_in, 1, &pipe_errflag);
+        } else if (!janet_checktype(maybe_stdin, JANET_NIL)) {
+            new_in = janet_getjfile(&maybe_stdin, 0);
+        }
+        if (janet_keyeq(maybe_stdout, "pipe")) {
+            new_out = make_pipes(&pipe_out, 0, &pipe_errflag);
+        } else if (!janet_checktype(maybe_stdout, JANET_NIL)) {
+            new_out = janet_getjfile(&maybe_stdout, 0);
+        }
+        if (janet_keyeq(maybe_stderr, "err")) {
+            new_err = make_pipes(&pipe_err, 0, &pipe_errflag);
+        } else if (!janet_checktype(maybe_stderr, JANET_NIL)) {
+            new_err = janet_getjfile(&maybe_stderr, 0);
+        }
+    }
+
+    /* Clean up if any of the pipes have any issues */
+    if (pipe_errflag) {
+        if (pipe_in != JANET_HANDLE_NONE) close_handle(pipe_in);
+        if (pipe_out != JANET_HANDLE_NONE) close_handle(pipe_out);
+        if (pipe_err != JANET_HANDLE_NONE) close_handle(pipe_err);
+        janet_panic("failed to create pipes");
     }
 
     /* Result */
@@ -488,12 +575,16 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
 #ifdef JANET_WINDOWS
 
     HANDLE pHandle, tHandle;
+    SECURITY_ATTRIBUTES saAttr;
     PROCESS_INFORMATION processInfo;
     STARTUPINFO startupInfo;
+    memset(&saAttr, 0, sizeof(saAttr));
     memset(&processInfo, 0, sizeof(processInfo));
     memset(&startupInfo, 0, sizeof(startupInfo));
     startupInfo.cb = sizeof(startupInfo);
     startupInfo.dwFlags |= STARTF_USESTDHANDLES;
+    saAttr.nLength = sizeof(saAttr);
+    saAttr.bInheritHandle = TRUE;
 
     JanetBuffer *buf = os_exec_escape(exargs);
     if (buf->count > 8191) {
@@ -502,33 +593,63 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
     const char *path = (const char *) janet_unwrap_string(exargs.items[0]);
 
     /* Do IO redirection */
-    startupInfo.hStdInput = (HANDLE) _get_osfhandle((new_in == NULL) ? 0 : _fileno(new_in->file));
-    startupInfo.hStdOutput = (HANDLE) _get_osfhandle((new_out == NULL) ? 1 : _fileno(new_out->file));
-    startupInfo.hStdError = (HANDLE) _get_osfhandle((new_err == NULL) ? 2 : _fileno(new_err->file));
+
+    if (pipe_in != JANET_HANDLE_NONE) {
+        startupInfo.hStdInput = pipe_in;
+    } else if (new_in != NULL) {
+        startupInfo.hStdInput = (HANDLE) _get_osfhandle(_fileno(new_in->file));
+    } else {
+        startupInfo.hStdInput = (HANDLE) _get_osfhandle(0);
+    }
+
+
+    if (pipe_out != JANET_HANDLE_NONE) {
+        startupInfo.hStdOutput = pipe_out;
+    } else if (new_out != NULL) {
+        startupInfo.hStdOutput = (HANDLE) _get_osfhandle(_fileno(new_out->file));
+    } else {
+        startupInfo.hStdOutput = (HANDLE) _get_osfhandle(1);
+    }
+
+    if (pipe_err != JANET_HANDLE_NONE) {
+        startupInfo.hStdError = pipe_err;
+    } else if (new_err != NULL) {
+        startupInfo.hStdError = (HANDLE) _get_osfhandle(_fileno(new_err->file));
+    } else {
+        startupInfo.hStdError = (HANDLE) _get_osfhandle(2);
+    }
 
     /* Use _spawn family of functions. */
     /* Windows docs say do this before any spawns. */
     _flushall();
 
-    /* TODO - redirection, :p flag */
-    if (!CreateProcess(janet_flag_at(flags, 1) ? NULL : path, /* NULL? */
+    int cp_failed = 0;
+    if (!CreateProcess(janet_flag_at(flags, 1) ? NULL : path,
                        (char *) buf->data, /* Single CLI argument */
-                       NULL, /* no proc inheritance */
-                       NULL, /* no thread inheritance */
+                       &saAttr, /* no proc inheritance */
+                       &saAttr, /* no thread inheritance */
                        TRUE, /* handle inheritance */
                        0, /* flags */
-                       envp, /* pass in environment */
+                       use_environ ? NULL : envp, /* pass in environment */
                        NULL, /* use parents starting directory */
                        &startupInfo,
-                       &processInfo))  {
+                       &processInfo)) {
+        cp_failed = 1;
+    }
+
+    if (pipe_in != JANET_HANDLE_NONE) CloseHandle(pipe_in);
+    if (pipe_out != JANET_HANDLE_NONE) CloseHandle(pipe_out);
+    if (pipe_err != JANET_HANDLE_NONE) CloseHandle(pipe_err);
+
+    os_execute_cleanup(envp, NULL);
+
+    if (cp_failed)  {
         janet_panic("failed to create process");
     }
 
     pHandle = processInfo.hProcess;
     tHandle = processInfo.hThread;
 
-    os_execute_cleanup(envp, NULL);
-
     /* Wait and cleanup immedaitely */
     if (!is_async) {
         DWORD code;
@@ -550,8 +671,6 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
 
     /* Use posix_spawn to spawn new process */
 
-    int use_environ = !janet_flag_at(flags, 0);
-
     if (use_environ) {
         janet_lock_environ();
     }
@@ -559,13 +678,19 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
     /* Posix spawn setup */
     posix_spawn_file_actions_t actions;
     posix_spawn_file_actions_init(&actions);
-    if (new_in != NULL) {
+    if (pipe_in != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, pipe_in, 0);
+    } else if (new_in != NULL) {
         posix_spawn_file_actions_adddup2(&actions, fileno(new_in->file), 0);
     }
-    if (new_out != NULL) {
+    if (pipe_out != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, pipe_out, 1);
+    } else if (new_out != NULL) {
         posix_spawn_file_actions_adddup2(&actions, fileno(new_out->file), 1);
     }
-    if (new_err != NULL) {
+    if (pipe_err != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, pipe_err, 2);
+    } else if (new_err != NULL) {
         posix_spawn_file_actions_adddup2(&actions, fileno(new_err->file), 2);
     }
 
@@ -582,6 +707,10 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
 
     posix_spawn_file_actions_destroy(&actions);
 
+    if (pipe_in != JANET_HANDLE_NONE) close(pipe_in);
+    if (pipe_out != JANET_HANDLE_NONE) close(pipe_out);
+    if (pipe_err != JANET_HANDLE_NONE) close(pipe_err);
+
     if (use_environ) {
         janet_unlock_environ();
     }
@@ -1554,6 +1683,11 @@ static const JanetReg os_cfuns[] = {
              "env is a table or struct mapping environment variables to values. It can also "
              "contain the keys :in, :out, and :err, which allow redirecting stdio in the subprocess. "
              "These arguments should be core/file values. "
+             "One can also pass in the :pipe keyword "
+             "for these arguments to create files that will read (for :err and :out) or write (for :in) "
+             "to the file descriptor of the subprocess. This is only useful in os/spawn, which takes "
+             "the same parameters as os/execute, but will return an object that contains references to these "
+             "files via (return-value :in), (return-value :out), and (return-value :err). "
              "Returns the exit status of the program.")
     },
     {
@@ -1609,8 +1743,8 @@ static const JanetReg os_cfuns[] = {
     },
     {
         "os/sleep", os_sleep,
-        JDOC("(os/sleep nsec)\n\n"
-             "Suspend the program for nsec seconds. 'nsec' can be a real number. Returns "
+        JDOC("(os/sleep n)\n\n"
+             "Suspend the program for n seconds. 'nsec' can be a real number. Returns "
              "nil.")
     },
     {

src/core/peg.c

@@ -87,6 +87,12 @@ static void pushcap(PegState *s, Janet capture, uint32_t tag) {
     }
 }
 
+/* Convert a uint64_t to a int64_t by wrapping to a maximum number of bytes */
+static int64_t peg_convert_u64_s64(uint64_t from, int width) {
+    int shift = 8 * (8 - width);
+    return ((int64_t)(from << shift)) >> shift;
+}
+
 /* Prevent stack overflow */
 #define down1(s) do { \
     if (0 == --((s)->depth)) janet_panic("peg/match recursed too deeply"); \
@@ -469,6 +475,47 @@ tail:
             return next_text;
         }
 
+        case RULE_READINT: {
+            uint32_t tag = rule[2];
+            uint32_t signedness = rule[1] & 0x10;
+            uint32_t endianess = rule[1] & 0x20;
+            int width = (int)(rule[1] & 0xF);
+            if (text + width > s->text_end) return NULL;
+            uint64_t accum = 0;
+            if (endianess) {
+                /* BE */
+                for (int i = 0; i < width; i++) accum = (accum << 8) | text[i];
+            } else {
+                /* LE */
+                for (int i = width - 1; i >= 0; i--) accum = (accum << 8) | text[i];
+            }
+
+            Janet capture_value;
+            /* We can only parse integeres of greater than 6 bytes reliable if int-types are enabled.
+             * Otherwise, we may lose precision, so 6 is the maximum size when int-types are disabled. */
+#ifdef JANET_INT_TYPES
+            if (width > 6) {
+                if (signedness) {
+                    capture_value = janet_wrap_s64(peg_convert_u64_s64(accum, width));
+                } else {
+                    capture_value = janet_wrap_u64(accum);
+                }
+            } else
+#endif
+            {
+                double double_value;
+                if (signedness) {
+                    double_value = (double)(peg_convert_u64_s64(accum, width));
+                } else {
+                    double_value = (double)accum;
+                }
+                capture_value = janet_wrap_number(double_value);
+            }
+
+            pushcap(s, capture_value, tag);
+            return text + width;
+        }
+
     }
 }
 
@@ -876,6 +923,36 @@ static void spec_matchtime(Builder *b, int32_t argc, const Janet *argv) {
     emit_3(r, RULE_MATCHTIME, subrule, cindex, tag);
 }
 
+#ifdef JANET_INT_TYPES
+#define JANET_MAX_READINT_WIDTH 8
+#else
+#define JANET_MAX_READINT_WIDTH 6
+#endif
+
+static void spec_readint(Builder *b, int32_t argc, const Janet *argv, uint32_t mask) {
+    peg_arity(b, argc, 1, 2);
+    Reserve r = reserve(b, 3);
+    uint32_t tag = (argc == 2) ? emit_tag(b, argv[3]) : 0;
+    int32_t width = peg_getnat(b, argv[0]);
+    if ((width < 0) || (width > JANET_MAX_READINT_WIDTH)) {
+        peg_panicf(b, "width must be between 0 and %d, got %d", JANET_MAX_READINT_WIDTH, width);
+    }
+    emit_2(r, RULE_READINT, mask | ((uint32_t) width), tag);
+}
+
+static void spec_uint_le(Builder *b, int32_t argc, const Janet *argv) {
+    spec_readint(b, argc, argv, 0x0u);
+}
+static void spec_int_le(Builder *b, int32_t argc, const Janet *argv) {
+    spec_readint(b, argc, argv, 0x10u);
+}
+static void spec_uint_be(Builder *b, int32_t argc, const Janet *argv) {
+    spec_readint(b, argc, argv, 0x20u);
+}
+static void spec_int_be(Builder *b, int32_t argc, const Janet *argv) {
+    spec_readint(b, argc, argv, 0x30u);
+}
+
 /* Special compiler form */
 typedef void (*Special)(Builder *b, int32_t argc, const Janet *argv);
 typedef struct {
@@ -912,6 +989,8 @@ static const SpecialPair peg_specials[] = {
     {"group", spec_group},
     {"if", spec_if},
     {"if-not", spec_ifnot},
+    {"int", spec_int_le},
+    {"int-be", spec_int_be},
     {"lenprefix", spec_lenprefix},
     {"look", spec_look},
     {"not", spec_not},
@@ -926,6 +1005,8 @@ static const SpecialPair peg_specials[] = {
     {"some", spec_some},
     {"thru", spec_thru},
     {"to", spec_to},
+    {"uint", spec_uint_le},
+    {"uint-be", spec_uint_be},
 };
 
 /* Compile a janet value into a rule and return the rule index. */
@@ -1226,6 +1307,11 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                 op_flags[rule[1]] |= 0x01;
                 i += 2;
                 break;
+            case RULE_READINT:
+                /* [ width | (endianess << 5) | (signedness << 6), tag ] */
+                if (rule[1] > JANET_MAX_READINT_WIDTH) goto bad;
+                i += 3;
+                break;
             default:
                 goto bad;
         }

src/core/state.h

@@ -101,4 +101,14 @@ void janet_threads_init(void);
 void janet_threads_deinit(void);
 #endif
 
+#ifdef JANET_NET
+void janet_net_init(void);
+void janet_net_deinit(void);
+#endif
+
+#ifdef JANET_EV
+void janet_ev_init(void);
+void janet_ev_deinit(void);
+#endif
+
 #endif /* JANET_STATE_H_defined */

src/core/table.c

@@ -256,7 +256,7 @@ static void janet_table_mergekv(JanetTable *table, const JanetKV *kvs, int32_t c
     }
 }
 
-/* Merge a table other into another table */
+/* Merge a table into another table */
 void janet_table_merge_table(JanetTable *table, JanetTable *other) {
     janet_table_mergekv(table, other->data, other->capacity);
 }

src/core/thread.c

@@ -585,6 +585,14 @@ void janet_threads_deinit(void) {
     janet_vm_thread_decode = NULL;
 }
 
+JanetThread *janet_thread_current(void) {
+    if (NULL == janet_vm_thread_current) {
+        janet_vm_thread_current = janet_make_thread(janet_vm_mailbox, janet_get_core_table("make-image-dict"));
+        janet_gcroot(janet_wrap_abstract(janet_vm_thread_current));
+    }
+    return janet_vm_thread_current;
+}
+
 /*
  * Cfuns
  */
@@ -592,11 +600,7 @@ void janet_threads_deinit(void) {
 static Janet cfun_thread_current(int32_t argc, Janet *argv) {
     (void) argv;
     janet_fixarity(argc, 0);
-    if (NULL == janet_vm_thread_current) {
-        janet_vm_thread_current = janet_make_thread(janet_vm_mailbox, janet_get_core_table("make-image-dict"));
-        janet_gcroot(janet_wrap_abstract(janet_vm_thread_current));
-    }
-    return janet_wrap_abstract(janet_vm_thread_current);
+    return janet_wrap_abstract(janet_thread_current());
 }
 
 static Janet cfun_thread_new(int32_t argc, Janet *argv) {
@@ -724,15 +728,18 @@ static const JanetReg threadlib_cfuns[] = {
     },
     {
         "thread/send", cfun_thread_send,
-        JDOC("(thread/send thread msg)\n\n"
-             "Send a message to the thread. This will never block and returns thread immediately. "
+        JDOC("(thread/send thread msgi &opt timeout)\n\n"
+             "Send a message to the thread. By default, the timeout is 1 second, but an optional timeout "
+             "in seconds can be provided. Use math/inf for no timeout. "
              "Will throw an error if there is a problem sending the message.")
     },
     {
         "thread/receive", cfun_thread_receive,
         JDOC("(thread/receive &opt timeout)\n\n"
-             "Get a message sent to this thread. If timeout is provided, an error will be thrown after the timeout has elapsed but "
-             "no messages are received.")
+             "Get a message sent to this thread. If timeout (in seconds) is provided, an error "
+             "will be thrown after the timeout has elapsed but "
+             "no messages are received. The default timeout is 1 second, and math/inf cam be passed to "
+             "turn off the timeout.")
     },
     {
         "thread/close", cfun_thread_close,

src/core/util.c

@@ -449,7 +449,8 @@ void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns)
 
 void janet_register_abstract_type(const JanetAbstractType *at) {
     Janet sym = janet_csymbolv(at->name);
-    if (!(janet_checktype(janet_table_get(janet_vm_abstract_registry, sym), JANET_NIL))) {
+    Janet check = janet_table_get(janet_vm_abstract_registry, sym);
+    if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) {
         janet_panicf("cannot register abstract type %s, "
                      "a type with the same name exists", at->name);
     }

src/core/util.h

@@ -140,8 +140,11 @@ void janet_lib_thread(JanetTable *env);
 #endif
 #ifdef JANET_NET
 void janet_lib_net(JanetTable *env);
-void janet_net_deinit(void);
-void janet_net_markloop(void);
+extern const JanetAbstractType janet_address_type;
+#endif
+#ifdef JANET_EV
+void janet_lib_ev(JanetTable *env);
+void janet_ev_mark(void);
 #endif
 
 #endif

src/core/vm.c

@@ -1315,11 +1315,32 @@ static JanetSignal janet_check_can_resume(JanetFiber *fiber, Janet *out) {
     return JANET_SIGNAL_OK;
 }
 
+void janet_try_init(JanetTryState *state) {
+    state->stackn = janet_vm_stackn++;
+    state->gc_handle = janet_vm_gc_suspend;
+    state->vm_fiber = janet_vm_fiber;
+    state->vm_jmp_buf = janet_vm_jmp_buf;
+    state->vm_return_reg = janet_vm_return_reg;
+    janet_vm_return_reg = &(state->payload);
+    janet_vm_jmp_buf = &(state->buf);
+}
+
+void janet_restore(JanetTryState *state) {
+    janet_vm_stackn = state->stackn;
+    janet_vm_gc_suspend = state->gc_handle;
+    janet_vm_fiber = state->vm_fiber;
+    janet_vm_jmp_buf = state->vm_jmp_buf;
+    janet_vm_return_reg = state->vm_return_reg;
+}
+
 static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *out) {
-    jmp_buf buf;
 
     JanetFiberStatus old_status = janet_fiber_status(fiber);
 
+#ifdef JANET_EV
+    janet_fiber_did_resume(fiber);
+#endif
+
     /* Continue child fiber if it exists */
     if (fiber->child) {
         if (janet_vm_root_fiber == NULL) janet_vm_root_fiber = fiber;
@@ -1349,45 +1370,21 @@ static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *o
     }
 
     /* Save global state */
-    int32_t oldn = janet_vm_stackn++;
-    int handle = janet_vm_gc_suspend;
-    JanetFiber *old_vm_fiber = janet_vm_fiber;
-    jmp_buf *old_vm_jmp_buf = janet_vm_jmp_buf;
-    Janet *old_vm_return_reg = janet_vm_return_reg;
-
-    /* Setup fiber */
-    if (janet_vm_root_fiber == NULL) janet_vm_root_fiber = fiber;
-    janet_vm_fiber = fiber;
-    janet_gcroot(janet_wrap_fiber(fiber));
-    janet_fiber_set_status(fiber, JANET_STATUS_ALIVE);
-    janet_vm_return_reg = out;
-    janet_vm_jmp_buf = &buf;
-
-    /* Run loop */
-    JanetSignal signal;
-    int jmpsig;
-#if defined(JANET_BSD) || defined(JANET_APPLE)
-    jmpsig = _setjmp(buf);
-#else
-    jmpsig = setjmp(buf);
-#endif
-    if (jmpsig) {
-        signal = (JanetSignal) jmpsig;
-    } else {
+    JanetTryState tstate;
+    JanetSignal signal = janet_try(&tstate);
+    if (!signal) {
+        /* Normal setup */
+        if (janet_vm_root_fiber == NULL) janet_vm_root_fiber = fiber;
+        janet_vm_fiber = fiber;
+        janet_fiber_set_status(fiber, JANET_STATUS_ALIVE);
         signal = run_vm(fiber, in);
     }
 
-    /* Tear down fiber */
-    janet_fiber_set_status(fiber, signal);
-    janet_gcunroot(janet_wrap_fiber(fiber));
-
-    /* Restore global state */
+    /* Restore */
     if (janet_vm_root_fiber == fiber) janet_vm_root_fiber = NULL;
-    janet_vm_gc_suspend = handle;
-    janet_vm_fiber = old_vm_fiber;
-    janet_vm_stackn = oldn;
-    janet_vm_return_reg = old_vm_return_reg;
-    janet_vm_jmp_buf = old_vm_jmp_buf;
+    janet_fiber_set_status(fiber, signal);
+    janet_restore(&tstate);
+    *out = tstate.payload;
 
     return signal;
 }
@@ -1484,6 +1481,12 @@ int janet_init(void) {
     /* Threads */
 #ifdef JANET_THREADS
     janet_threads_init();
+#endif
+#ifdef JANET_EV
+    janet_ev_init();
+#endif
+#ifdef JANET_NET
+    janet_net_init();
 #endif
     return 0;
 }
@@ -1506,6 +1509,9 @@ void janet_deinit(void) {
 #ifdef JANET_THREADS
     janet_threads_deinit();
 #endif
+#ifdef JANET_EV
+    janet_ev_deinit();
+#endif
 #ifdef JANET_NET
     janet_net_deinit();
 #endif

src/include/janet.h

@@ -177,8 +177,13 @@ extern "C" {
 #define JANET_TYPED_ARRAY
 #endif
 
+/* Enable or disable event loop */
+#if !defined(JANET_NO_EV) && !defined(__EMSCRIPTEN__)
+#define JANET_EV
+#endif
+
 /* Enable or disable networking */
-#if !defined(JANET_NO_NET) && !defined(__EMSCRIPTEN__)
+#if defined(JANET_EV) && !defined(JANET_NO_NET) && !defined(__EMSCRIPTEN__)
 #define JANET_NET
 #endif
 
@@ -310,6 +315,15 @@ JANET_API extern const char *const janet_type_names[16];
 JANET_API extern const char *const janet_signal_names[14];
 JANET_API extern const char *const janet_status_names[16];
 
+/* For various IO routines, we want to use an int on posix and HANDLE on windows */
+#ifdef JANET_WINDOWS
+typedef void *JanetHandle;
+#define JANET_HANDLE_NONE NULL
+#else
+typedef int JanetHandle;
+#define JANET_HANDLE_NONE (-1)
+#endif
+
 /* Fiber signals */
 typedef enum {
     JANET_SIGNAL_OK,
@@ -483,6 +497,75 @@ typedef void *JanetAbstract;
 #define JANET_TFLAG_CALLABLE (JANET_TFLAG_FUNCTION | JANET_TFLAG_CFUNCTION | \
         JANET_TFLAG_LENGTHABLE | JANET_TFLAG_ABSTRACT)
 
+/* Event Loop Types */
+#ifdef JANET_EV
+
+#define JANET_STREAM_CLOSED 0x1
+#define JANET_STREAM_SOCKET 0x2
+#define JANET_STREAM_IOCP 0x4
+#define JANET_STREAM_READABLE 0x200
+#define JANET_STREAM_WRITABLE 0x400
+#define JANET_STREAM_ACCEPTABLE 0x800
+#define JANET_STREAM_UDPSERVER 0x1000
+
+typedef enum {
+    JANET_ASYNC_EVENT_INIT,
+    JANET_ASYNC_EVENT_MARK,
+    JANET_ASYNC_EVENT_DEINIT,
+    JANET_ASYNC_EVENT_CLOSE,
+    JANET_ASYNC_EVENT_ERR,
+    JANET_ASYNC_EVENT_HUP,
+    JANET_ASYNC_EVENT_READ,
+    JANET_ASYNC_EVENT_WRITE,
+    JANET_ASYNC_EVENT_TIMEOUT,
+    JANET_ASYNC_EVENT_COMPLETE, /* Used on windows for IOCP */
+    JANET_ASYNC_EVENT_USER
+} JanetAsyncEvent;
+
+#define JANET_ASYNC_LISTEN_READ (1 << JANET_ASYNC_EVENT_READ)
+#define JANET_ASYNC_LISTEN_WRITE (1 << JANET_ASYNC_EVENT_WRITE)
+
+typedef enum {
+    JANET_ASYNC_STATUS_NOT_DONE,
+    JANET_ASYNC_STATUS_DONE
+} JanetAsyncStatus;
+
+/* Typedefs */
+typedef struct JanetListenerState JanetListenerState;
+typedef struct JanetStream JanetStream;
+typedef JanetAsyncStatus(*JanetListener)(JanetListenerState *state, JanetAsyncEvent event);
+
+/* Wrapper around file descriptors and HANDLEs that can be polled. */
+struct JanetStream {
+    JanetHandle handle;
+    uint32_t flags;
+    /* Linked list of all in-flight IO routines for this stream */
+    JanetListenerState *state;
+    const void *methods; /* Methods for this stream */
+    /* internal - used to disallow multiple concurrent reads / writes on the same stream.
+     * this constraint may be lifted later but allowing such would require more internal book keeping
+     * for some implementations. You can read and write at the same time on the same stream, though. */
+    int _mask;
+};
+
+/* Interface for state machine based event loop */
+struct JanetListenerState {
+    JanetListener machine;
+    JanetFiber *fiber;
+    JanetStream *stream;
+    void *event; /* Used to pass data from asynchronous IO event. Contents depend on both
+                    implementation of the event loop and the particular event. */
+#ifdef JANET_WINDOWS
+    void *tag; /* Used to associate listeners with an overlapped structure */
+    int bytes; /* Used to track how many bytes were transfered. */
+#endif
+    /* internal */
+    int _index; /* not used in all implementations */
+    int _mask;
+    JanetListenerState *_next;
+};
+#endif
+
 /* We provide three possible implementations of Janets. The preferred
  * nanboxing approach, for 32 or 64 bits, and the standard C version. Code in the rest of the
  * application must interact through exposed interface. */
@@ -750,11 +833,15 @@ struct JanetFiber {
     int32_t frame; /* Index of the stack frame */
     int32_t stackstart; /* Beginning of next args */
     int32_t stacktop; /* Top of stack. Where values are pushed and popped from. */
-    int32_t capacity;
+    int32_t capacity; /* How big is the stack memory */
     int32_t maxstack; /* Arbitrary defined limit for stack overflow */
     JanetTable *env; /* Dynamic bindings table (usually current environment). */
-    Janet *data;
+    Janet *data; /* Dynamically resized stack memory */
     JanetFiber *child; /* Keep linked list of fibers for restarting pending fibers */
+#ifdef JANET_EV
+    JanetListenerState *waiting;
+    uint32_t sched_id; /* Increment everytime fiber is scheduled by event loop */
+#endif
 };
 
 /* Mark if a stack frame is a tail call for debugging */
@@ -1021,6 +1108,19 @@ struct JanetFile {
     int32_t flags;
 };
 
+/* For janet_try and janet_restore */
+typedef struct {
+    /* old state */
+    int32_t stackn;
+    int gc_handle;
+    JanetFiber *vm_fiber;
+    jmp_buf *vm_jmp_buf;
+    Janet *vm_return_reg;
+    /* new state */
+    jmp_buf buf;
+    Janet payload;
+} JanetTryState;
+
 /* Thread types */
 #ifdef JANET_THREADS
 typedef struct JanetThread JanetThread;
@@ -1153,9 +1253,59 @@ extern enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT];
 
 /***** START SECTION MAIN *****/
 
-/* Event Loop */
-#ifdef JANET_NET
+#ifdef JANET_EV
+
+extern JANET_API const JanetAbstractType janet_stream_type;
+
+/* Run the event loop */
 JANET_API void janet_loop(void);
+
+/* Wrapper around streams */
+JANET_API JanetStream *janet_stream(JanetHandle handle, uint32_t flags, const JanetMethod *methods);
+JANET_API void janet_stream_close(JanetStream *stream);
+JANET_API Janet janet_cfun_stream_close(int32_t argc, Janet *argv);
+JANET_API Janet janet_cfun_stream_read(int32_t argc, Janet *argv);
+JANET_API Janet janet_cfun_stream_chunk(int32_t argc, Janet *argv);
+JANET_API Janet janet_cfun_stream_write(int32_t argc, Janet *argv);
+JANET_API void janet_stream_flags(JanetStream *stream, uint32_t flags);
+
+/* Queue a fiber to run on the event loop */
+JANET_API void janet_schedule(JanetFiber *fiber, Janet value);
+JANET_API void janet_cancel(JanetFiber *fiber, Janet value);
+JANET_API void janet_schedule_signal(JanetFiber *fiber, Janet value, JanetSignal sig);
+
+/* Start a state machine listening for events from a stream */
+JANET_API JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, int mask, size_t size, void *user);
+
+/* Shorthand for yielding to event loop in C */
+JANET_NO_RETURN JANET_API void janet_await(void);
+
+/* For use inside listeners - adds a timeout to the current fiber, such that
+ * it will be resumed after sec seconds if no other event schedules the current fiber. */
+JANET_API void janet_addtimeout(double sec);
+
+/* Get last error from a an IO operation */
+JANET_API Janet janet_ev_lasterr(void);
+
+/* Read async from a stream */
+JANET_API void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
+JANET_API void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
+#ifdef JANET_NET
+JANET_API void janet_ev_recv(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+JANET_API void janet_ev_recvchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+JANET_API void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+#endif
+
+/* Write async to a stream */
+JANET_API void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf);
+JANET_API void janet_ev_write_string(JanetStream *stream, JanetString str);
+#ifdef JANET_NET
+JANET_API void janet_ev_send_buffer(JanetStream *stream, JanetBuffer *buf, int flags);
+JANET_API void janet_ev_send_string(JanetStream *stream, JanetString str, int flags);
+JANET_API void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, int flags);
+JANET_API void janet_ev_sendto_string(JanetStream *stream, JanetString str, void *dest, int flags);
+#endif
+
 #endif
 
 /* Parsing */
@@ -1402,6 +1552,13 @@ JANET_API JanetBuffer *janet_pretty(JanetBuffer *buffer, int depth, int flags, J
 #define JANET_HASH_KEY_SIZE 16
 JANET_API void janet_init_hash_key(uint8_t key[JANET_HASH_KEY_SIZE]);
 #endif
+JANET_API void janet_try_init(JanetTryState *state);
+#if defined(JANET_BSD) || defined(JANET_APPLE)
+#define janet_try(state) (janet_try_init(state), (JanetSignal) _setjmp((state)->buf))
+#else
+#define janet_try(state) (janet_try_init(state), (JanetSignal) setjmp((state)->buf))
+#endif
+JANET_API void janet_restore(JanetTryState *state);
 JANET_API int janet_equals(Janet x, Janet y);
 JANET_API int32_t janet_hash(Janet x);
 JANET_API int janet_compare(Janet x, Janet y);
@@ -1459,6 +1616,9 @@ JANET_API Janet janet_resolve_core(const char *name);
 
 /* New C API */
 
+/* Shorthand for janet C function declarations */
+#define JANET_CFUN(name) Janet name (int32_t argc, Janet *argv)
+
 /* Allow setting entry name for static libraries */
 #ifdef __cplusplus
 #define JANET_MODULE_PREFIX extern "C"
@@ -1560,6 +1720,7 @@ extern JANET_API const JanetAbstractType janet_file_type;
 #define JANET_FILE_NONIL 512
 
 JANET_API Janet janet_makefile(FILE *f, int32_t flags);
+JANET_API JanetFile *janet_makejfile(FILE *f, int32_t flags);
 JANET_API FILE *janet_getfile(const Janet *argv, int32_t n, int32_t *flags);
 JANET_API FILE *janet_dynfile(const char *name, FILE *def);
 JANET_API JanetFile *janet_getjfile(const Janet *argv, int32_t n);
@@ -1622,6 +1783,7 @@ typedef enum {
     RULE_TO,           /* [rule] */
     RULE_THRU,         /* [rule] */
     RULE_LENPREFIX,    /* [rule_a, rule_b (repeat rule_b rule_a times)] */
+    RULE_READINT,      /* [(signedness << 4) | (endianess << 5) | bytewidth, tag] */
 } JanetPegOpcode;
 
 typedef struct {

src/mainclient/shell.c

@@ -1064,7 +1064,7 @@ int main(int argc, char **argv) {
         janet_stacktrace(fiber, out);
     }
 
-#ifdef JANET_NET
+#ifdef JANET_EV
     status = JANET_SIGNAL_OK;
     janet_loop();
 #endif

test/helper.janet

@@ -3,7 +3,6 @@
 (var num-tests-passed 0)
 (var num-tests-run 0)
 (var suite-num 0)
-(var numchecks 0)
 (var start-time 0)
 
 (defn assert
@@ -12,17 +11,12 @@
   (default e "assert error")
   (++ num-tests-run)
   (when x (++ num-tests-passed))
+  (def str (string e))
+  (def truncated
+    (if (> (length e) 40) (string (string/slice e 0 35) "...") (string e)))
   (if x
-    (do
-      (when (= numchecks 25)
-        (set numchecks 0)
-        (print))
-      (++ numchecks)
-      (file/write stdout "\e[32m✔\e[0m"))
-    (do
-      (file/write stdout "\n\e[31m✘\e[0m  ")
-      (set numchecks 0)
-      (print e)))
+    (eprintf "\e[32m✔\e[0m %s: %v" truncated x)
+    (eprintf "\n\e[31m✘\e[0m %s: %v" truncated x))
   x)
 
 (defmacro assert-error
@@ -38,10 +32,10 @@
 (defn start-suite [x]
   (set suite-num x)
   (set start-time (os/clock))
-  (print "\nRunning test suite " x " tests...\n  "))
+  (eprint "\nRunning test suite " x " tests...\n  "))
 
 (defn end-suite []
   (def delta (- (os/clock) start-time))
-  (printf "\n\nTest suite %d finished in %.3f seconds" suite-num delta)
-  (print num-tests-passed " of " num-tests-run " tests passed.\n")
+  (eprintf "\n\nTest suite %d finished in %.3f seconds" suite-num delta)
+  (eprint num-tests-passed " of " num-tests-run " tests passed.\n")
   (if (not= num-tests-passed num-tests-run) (os/exit 1)))

test/suite0003.janet

@@ -443,4 +443,26 @@
 (check-match redef-b "aabeef" false)
 (check-match redef-b "aaaaaa" false)
 
+# Integer parsing
+
+(check-deep '(int 1) "a" @[(chr "a")])
+(check-deep '(uint 1) "a" @[(chr "a")])
+(check-deep '(int-be 1) "a" @[(chr "a")])
+(check-deep '(uint-be 1) "a" @[(chr "a")])
+(check-deep '(int 1) "\xFF" @[-1])
+(check-deep '(uint 1) "\xFF" @[255])
+(check-deep '(int-be 1) "\xFF" @[-1])
+(check-deep '(uint-be 1) "\xFF" @[255])
+(check-deep '(int 2) "\xFF\x7f" @[0x7fff])
+(check-deep '(int-be 2) "\x7f\xff" @[0x7fff])
+(check-deep '(uint 2) "\xff\x7f" @[0x7fff])
+(check-deep '(uint-be 2) "\x7f\xff" @[0x7fff])
+(check-deep '(uint-be 2) "\x7f\xff" @[0x7fff])
+(check-deep '(uint 8) "\xff\x7f\x00\x00\x00\x00\x00\x00" @[(int/u64 0x7fff)])
+(check-deep '(int 8) "\xff\x7f\x00\x00\x00\x00\x00\x00" @[(int/s64 0x7fff)])
+(check-deep '(uint 7) "\xff\x7f\x00\x00\x00\x00\x00" @[(int/u64 0x7fff)])
+(check-deep '(int 7) "\xff\x7f\x00\x00\x00\x00\x00" @[(int/s64 0x7fff)])
+
+(check-deep '(* (int 2) -1) "123" nil)
+
 (end-suite)

test/suite0008.janet

@@ -224,7 +224,7 @@ neldb\0\0\0\xD8\x05printG\x01\0\xDE\xDE\xDE'\x03\0marshal_tes/\x02
 # No segfault, valgrind clean.
 
 (def x @"\xCC\xCD.nd\x80\0\r\x1C\xCDg!\0\x07\xCC\xCD\r\x1Ce\x10\0\r;\xCDb\x04\xFF9\xFF\x80\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04uu\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\0\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04}\x04\x04\x04\x04\x04\x04\x04\x04#\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\0\x01\0\0\x03\x04\x04\x04\xE2\x03\x04\x04\x04\x04\x04\x04\x04\x04\x04\x14\x1A\x04\x04\x04\x04\x04\x18\x04\x04!\x04\xE2\x03\x04\x04\x04\x04\x04\x04$\x04\x04\x04\x04\x04\x04\x04\x04\x04\x80\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04\x04A\0\0\0\x03\0\0!\xBF\xFF")
-(unmarshal x load-image-dict)
+(assert-error "bad fiber status" (unmarshal x load-image-dict))
 (gccollect)
 (marshal x make-image-dict)
 

test/suite0009.janet

@@ -48,4 +48,19 @@
 
 (:close s)
 
+# Create pipe
+
+(var pipe-counter 0)
+(def [reader writer] (ev/pipe))
+(ev/spawn
+  (while (ev/read reader 3)
+    (++ pipe-counter))
+  (assert (= 20 pipe-counter) "ev/pipe 1"))
+
+(for i 0 10
+  (ev/write writer "xxx---"))
+
+(ev/close writer)
+(ev/sleep 0.1)
+
 (end-suite)

test/suite0010.janet

@@ -61,4 +61,8 @@
 (assert-no-error "import macro 1" (macex '(import a :as b :fresh maybe)))
 (assert (deep= ~(,import* "a" :as "b" :fresh maybe) (macex '(import a :as b :fresh maybe))) "import macro 2")
 
+# #477 walk preserving bracket type
+(assert (= :brackets (tuple/type (postwalk identity '[]))) "walk square brackets 1")
+(assert (= :brackets (tuple/type (walk identity '[]))) "walk square brackets 2")
+
 (end-suite)