Fix some valgrind errors.

A null pointer dereference and a memory leak with the line/col mapping.

.builds/epoll.yml

@@ -0,0 +1,15 @@
+image: archlinux
+sources:
+- https://git.sr.ht/~bakpakin/janet
+packages:
+- meson
+tasks:
+- build: |
+    cd janet
+    meson setup build --buildtype=release
+    cd build
+    meson configure -Depoll=false
+    ninja
+    ninja test
+    sudo ninja install
+    sudo jpm --verbose install circlet

.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,28 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## Unreleased - ???
+- 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 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.

Makefile

@@ -67,7 +67,7 @@ ifeq ($(UNAME), Haiku)
 endif
 
 $(shell mkdir -p build/core build/mainclient build/webclient build/boot)
-all: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY)
+all: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.h
 
 ######################
 ##### Name Files #####
@@ -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)
@@ -161,16 +162,16 @@ SONAME=libjanet.so.1.12
 build/shell.c: src/mainclient/shell.c
 	cp $< $@
 
-build/janet.h: src/include/janet.h
-	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/janet.c build/janet.h build/janetconf.h
+build/janet.o: build/janet.c src/include/janet.h src/conf/janetconf.h
 	$(HOSTCC) $(BUILD_CFLAGS) -c $< -o $@ -I build
 
-build/shell.o: build/shell.c build/janet.h build/janetconf.h
+build/shell.o: build/shell.c src/include/janet.h src/conf/janetconf.h
 	$(HOSTCC) $(BUILD_CFLAGS) -c $< -o $@ -I build
 
 $(JANET_TARGET): build/janet.o build/shell.o
@@ -221,7 +222,7 @@ callgrind: $(JANET_TARGET)
 dist: build/janet-dist.tar.gz
 
 build/janet-%.tar.gz: $(JANET_TARGET) \
-	src/include/janet.h src/conf/janetconf.h \
+	build/janet.h \
 	jpm.1 janet.1 LICENSE CONTRIBUTING.md $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) \
 	build/doc.html README.md build/janet.c build/shell.c jpm
 	$(eval JANET_DIST_DIR = "janet-$(shell basename $*)")
@@ -261,11 +262,11 @@ 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 build/janet.h
 	mkdir -p '$(DESTDIR)$(BINDIR)'
 	cp $(JANET_TARGET) '$(DESTDIR)$(BINDIR)/janet'
 	mkdir -p '$(DESTDIR)$(INCLUDEDIR)/janet'
-	cp -rf $(JANET_HEADERS) '$(DESTDIR)$(INCLUDEDIR)/janet'
+	cp -r build/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet'
 	mkdir -p '$(DESTDIR)$(JANET_PATH)'
 	mkdir -p '$(DESTDIR)$(LIBDIR)'
 	cp $(JANET_LIBRARY) '$(DESTDIR)$(LIBDIR)/libjanet.so.$(shell $(JANET_TARGET) -e '(print janet/version)')'
@@ -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.
 

appveyor.yml

@@ -35,9 +35,6 @@ artifacts:
     - name: janet.h
       path: dist\janet.h
       type: File
-    - name: janetconf.h
-      path: dist\janetconf.h
-      type: File
     - name: shell.c
       path: dist\shell.c
       type: File

build_win.bat

@@ -28,10 +28,10 @@ if not "%JANET_BUILD%" == "" (
     @set JANET_COMPILE=%JANET_COMPILE% /DJANET_BUILD="\"%JANET_BUILD%\""
 )
 
-mkdir build
-mkdir build\core
-mkdir build\mainclient
-mkdir build\boot
+if not exist build mkdir build
+if not exist build\core mkdir build\core
+if not exist build\mainclient mkdir build\mainclient
+if not exist build\boot mkdir build\boot
 
 @rem Build the bootstrap interpreter
 for %%f in (src\core\*.c) do (
@@ -113,8 +113,8 @@ copy README.md dist\README.md
 copy janet.lib dist\janet.lib
 copy janet.exp dist\janet.exp
 
-copy src\include\janet.h dist\janet.h
-copy src\conf\janetconf.h dist\janetconf.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
 
 copy .\jpm dist\jpm

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))

meson.build

@@ -20,7 +20,7 @@
 
 project('janet', 'c',
   default_options : ['c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.12.2')
+  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'))
@@ -72,6 +73,7 @@ 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_EPOLL', get_option('epoll'))
 if get_option('os_name') != ''
   conf.set('JANET_OS_NAME', get_option('os_name'))
 endif
@@ -111,6 +113,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',
@@ -245,8 +248,14 @@ pkg.generate(libjanet,
 
 # Installation
 install_man('janet.1')
-install_headers(['src/include/janet.h', jconf], subdir: 'janet')
 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@'])
 if get_option('peg') and not get_option('reduced_os') and get_option('processes')
   install_man('jpm.1')
   patched_jpm = custom_target('patched-jpm',

meson_options.txt

@@ -12,10 +12,12 @@ 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)
 option('simple_getline', type : 'boolean', value : false)
+option('epoll', type : 'boolean', value : false)
 
 option('recursion_guard', type : 'integer', min : 10, max : 8000, value : 1024)
 option('max_proto_depth', type : 'integer', min : 10, max : 8000, value : 200)

src/conf/janetconf.h

@@ -1,36 +1,13 @@
-/*
-* Copyright (c) 2020 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.
-*/
-
-/* This is an example janetconf.h file. This will be usually generated
- * by the build system. */
+/* 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 12
-#define JANET_VERSION_PATCH 2
-#define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.12.2"
+#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 +29,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 +47,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/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,9 @@ 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;
+#ifdef JANET_EV
+    fiber->waiting = NULL;
+#endif
     return fiber;
 }
 
@@ -103,12 +110,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 "

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

@@ -328,9 +328,15 @@ typedef struct {
     int pid;
 #endif
     int return_code;
+#ifdef JANET_EV
+    JanetStream *in;
+    JanetStream *out;
+    JanetStream *err;
+#else
     JanetFile *in;
     JanetFile *out;
     JanetFile *err;
+#endif
 } JanetProc;
 
 static int janet_proc_gc(void *p, size_t s) {
@@ -434,48 +440,28 @@ static void close_handle(JanetHandle handle) {
    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) {
+static JanetHandle 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 (!CreatePipe(handles, handles + 1, &saAttr, 0)) goto error;
     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;
+    if (!SetHandleInformation(handles[0], HANDLE_FLAG_INHERIT, 0)) goto error;
     *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;
+    return handles[0];
 #else
-    if (pipe(handles)) goto error_pipe;
+    if (pipe(handles)) goto error;
     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;
+    return handles[0];
 #endif
+error:
+    *errflag = 1;
+    return JANET_HANDLE_NONE;
 }
 
 static const JanetMethod proc_methods[] = {
@@ -514,6 +500,81 @@ static const JanetAbstractType ProcAT = {
     JANET_ATEND_GET
 };
 
+static JanetHandle janet_getjstream(Janet *argv, int32_t n, void **orig) {
+#ifdef JANET_EV
+    JanetStream *stream = janet_checkabstract(argv[0], &janet_stream_type);
+    if (stream != NULL) {
+        if (stream->flags & JANET_STREAM_CLOSED)
+            janet_panic("stream is closed");
+        *orig = stream;
+        return stream->handle;
+    }
+#endif
+    JanetFile *f = janet_checkabstract(argv[0], &janet_file_type);
+    if (f != NULL) {
+        if (f->flags & JANET_FILE_CLOSED) {
+            janet_panic("file is closed");
+        }
+        *orig = f;
+#ifdef JANET_WINDOWS
+        return (HANDLE) _get_osfhandle(_fileno(f->file));
+#else
+        return fileno(f->file);
+#endif
+    }
+    janet_panicf("expected file|stream, got %v", argv[n]);
+}
+
+#ifdef JANET_EV
+static JanetStream *get_stdio_for_handle(JanetHandle handle, void *orig, int iswrite) {
+    if (orig == NULL) {
+        return janet_stream(handle, iswrite ? JANET_STREAM_WRITABLE : JANET_STREAM_READABLE, NULL);
+    } else if (janet_abstract_type(orig) == &janet_file_type) {
+        JanetFile *jf = (JanetFile *)orig;
+        uint32_t flags = 0;
+        if (jf->flags & JANET_FILE_WRITE) {
+            flags |= JANET_STREAM_WRITABLE;
+        }
+        if (jf->flags & JANET_FILE_READ) {
+            flags |= JANET_STREAM_READABLE;
+        }
+        /* duplicate handle when converting file to stream */
+#ifdef JANET_WINDOWS
+        HANDLE prochandle = GetCurrentProcess();
+        HANDLE newHandle = INVALID_HANDLE_VALUE;
+        if (!DuplicateHandle(prochandle, handle, prochandle, &newHandle, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+            return NULL;
+        }
+#else
+        int newHandle = dup(handle);
+        if (newHandle < 0) {
+            return NULL;
+        }
+#endif
+        return janet_stream(newHandle, flags, NULL);
+    } else {
+        return orig;
+    }
+}
+#else
+static JanetFile *get_stdio_for_handle(JanetHandle handle, void *orig, int iswrite) {
+    if (NULL != orig) return (JanetFile *) orig;
+#ifdef JANET_WINDOWS
+    int fd = _open_osfhandle((intptr_t) handle, iswrite ? _O_WRONLY : _O_RDONLY);
+    if (-1 == fd) return NULL;
+    FILE *f = _fdopen(fd, iswrite ? "w" : "r");
+    if (NULL == f) {
+        _close(fd);
+        return NULL;
+    }
+#else
+    FILE *f = fdopen(handle, iswrite ? "w" : "r");
+    if (NULL == f) return NULL;
+#endif
+    return janet_makejfile(f, iswrite ? JANET_FILE_WRITE : JANET_FILE_READ);
+}
+#endif
+
 static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
     janet_arity(argc, 1, 3);
 
@@ -534,7 +595,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;
+    JanetAbstract orig_in = NULL, orig_out = NULL, orig_err = NULL;
+    JanetHandle new_in = JANET_HANDLE_NONE, new_out = JANET_HANDLE_NONE, new_err = JANET_HANDLE_NONE;
     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 */
 
@@ -547,17 +609,17 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
         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);
+            new_in = janet_getjstream(&maybe_stdin, 0, &orig_in);
         }
         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);
+            new_out = janet_getjstream(&maybe_stdout, 0, &orig_out);
         }
         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);
+            new_err = janet_getjstream(&maybe_stderr, 0, &orig_err);
         }
     }
 
@@ -596,8 +658,8 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
 
     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 if (new_in != JANET_HANDLE_NONE) {
+        startupInfo.hStdInput = new_in;
     } else {
         startupInfo.hStdInput = (HANDLE) _get_osfhandle(0);
     }
@@ -605,8 +667,8 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
 
     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 if (new_out != JANET_HANDLE_NONE) {
+        startupInfo.hStdOutput = new_out;
     } else {
         startupInfo.hStdOutput = (HANDLE) _get_osfhandle(1);
     }
@@ -614,7 +676,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
     if (pipe_err != JANET_HANDLE_NONE) {
         startupInfo.hStdError = pipe_err;
     } else if (new_err != NULL) {
-        startupInfo.hStdError = (HANDLE) _get_osfhandle(_fileno(new_err->file));
+        startupInfo.hStdError = new_err;
     } else {
         startupInfo.hStdError = (HANDLE) _get_osfhandle(2);
     }
@@ -680,18 +742,18 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
     posix_spawn_file_actions_init(&actions);
     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);
+    } else if (new_in != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, new_in, 0);
     }
     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);
+    } else if (new_out != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, new_out, 1);
     }
     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);
+    } else if (new_err != JANET_HANDLE_NONE) {
+        posix_spawn_file_actions_adddup2(&actions, new_err, 2);
     }
 
     pid_t pid;
@@ -746,10 +808,13 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_async) {
 #else
         proc->pid = pid;
 #endif
-        proc->in = new_in;
-        proc->out = new_out;
-        proc->err = new_err;
+        proc->in = get_stdio_for_handle(new_in, orig_in, 0);
+        proc->out = get_stdio_for_handle(new_out, orig_out, 1);
+        proc->err = get_stdio_for_handle(new_err, orig_err, 1);
         proc->flags = 0;
+        if (proc->in == NULL || proc->out == NULL || proc->err == NULL) {
+            janet_panic("failed to construct proc");
+        }
         return janet_wrap_abstract(proc);
     } else if (janet_flag_at(flags, 2) && status) {
         janet_panicf("command failed with non-zero exit code %d", status);
@@ -1529,6 +1594,172 @@ static Janet os_permission_int(int32_t argc, Janet *argv) {
     return janet_wrap_integer(os_get_unix_mode(argv, 0));
 }
 
+#ifdef JANET_EV
+
+/*
+ * Define a few functions on streams the require JANET_EV to be defined.
+ */
+
+static jmode_t os_optmode(int32_t argc, const Janet *argv, int32_t n, int32_t dflt) {
+    if (argc > n) return os_getmode(argv, n);
+    return janet_perm_from_unix(dflt);
+}
+
+static Janet os_open(int32_t argc, Janet *argv) {
+    janet_arity(argc, 1, 3);
+    const char *path = janet_getcstring(argv, 0);
+    const uint8_t *opt_flags = janet_optkeyword(argv, argc, 1, (const uint8_t *) "r");
+    jmode_t mode = os_optmode(argc, argv, 2, 0666);
+    uint32_t stream_flags = 0;
+    JanetHandle fd;
+#ifdef JANET_WINDOWS
+    DWORD desiredAccess = 0;
+    DWORD shareMode = 0;
+    DWORD creationDisp = 0;
+    DWORD flagsAndAttributes = FILE_FLAG_OVERLAPPED;
+    /* We map unix-like open flags to the creationDisp parameter */
+    int creatUnix = 0;
+#define OCREAT 1
+#define OEXCL 2
+#define OTRUNC 4
+    for (const uint8_t *c = opt_flags; *c; c++) {
+        switch (*c) {
+            default:
+                break;
+            case 'r':
+                desiredAccess |= GENERIC_READ;
+                stream_flags |= JANET_STREAM_READABLE;
+                break;
+            case 'w':
+                desiredAccess |= GENERIC_WRITE;
+                stream_flags |= JANET_STREAM_WRITABLE;
+                break;
+            case 'c':
+                creatUnix |= OCREAT;
+                break;
+            case 'e':
+                creatUnix |= OEXCL;
+                break;
+            case 't':
+                creatUnix |= OTRUNC;
+                break;
+            /* Windows only flags */
+            case 'D':
+                shareMode |= FILE_SHARE_DELETE;
+                break;
+            case 'R':
+                shareMode |= FILE_SHARE_READ;
+                break;
+            case 'W':
+                shareMode |= FILE_SHARE_WRITE;
+                break;
+            case 'H':
+                flagsAndAttributes |= FILE_ATTRIBUTE_HIDDEN;
+                break;
+            case 'O':
+                flagsAndAttributes |= FILE_ATTRIBUTE_READONLY;
+                break;
+            case 'F':
+                flagsAndAttributes |= FILE_ATTRIBUTE_OFFLINE;
+                break;
+            case 'T':
+                flagsAndAttributes |= FILE_ATTRIBUTE_TEMPORARY;
+                break;
+            case 'd':
+                flagsAndAttributes |= FILE_FLAG_DELETE_ON_CLOSE;
+                break;
+            case 'b':
+                flagsAndAttributes |= FILE_FLAG_NO_BUFFERING;
+                break;
+                /* we could potentially add more here -
+                 * https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
+                 */
+        }
+    }
+    switch (creatUnix) {
+        default:
+            janet_panic("invalid creation flags");
+        case 0:
+            creationDisp = OPEN_EXISTING;
+            break;
+        case OCREAT:
+            creationDisp = OPEN_ALWAYS;
+            break;
+        case OCREAT + OEXCL:
+            creationDisp = CREATE_NEW;
+            break;
+        case OCREAT + OTRUNC:
+            creationDisp = CREATE_ALWAYS;
+            break;
+        case OTRUNC:
+            creationDisp = TRUNCATE_EXISTING;
+            break;
+    }
+    fd = CreateFileA(path, desiredAccess, shareMode, NULL, creationDisp, flagsAndAttributes, NULL);
+    if (fd == INVALID_HANDLE_VALUE) janet_panicv(janet_ev_lasterr());
+#else
+    int open_flags = O_NONBLOCK;
+#ifdef JANET_LINUX
+    open_flags |= O_CLOEXEC;
+#endif
+    for (const uint8_t *c = opt_flags; *c; c++) {
+        switch (*c) {
+            default:
+                break;
+            case 'r':
+                open_flags = (open_flags & O_WRONLY)
+                             ? ((open_flags & ~O_WRONLY) | O_RDWR)
+                             : (open_flags | O_RDONLY);
+                stream_flags |= JANET_STREAM_READABLE;
+                break;
+            case 'w':
+                open_flags = (open_flags & O_RDONLY)
+                             ? ((open_flags & ~O_RDONLY) | O_RDWR)
+                             : (open_flags | O_WRONLY);
+                stream_flags |= JANET_STREAM_WRITABLE;
+                break;
+            case 'c':
+                open_flags |= O_CREAT;
+                break;
+            case 'e':
+                open_flags |= O_EXCL;
+                break;
+            case 't':
+                open_flags |= O_TRUNC;
+                break;
+            /* posix only */
+            case 'x':
+                open_flags |= O_SYNC;
+                break;
+            case 'C':
+                open_flags |= O_NOCTTY;
+                break;
+            case 'a':
+                open_flags |= O_APPEND;
+                break;
+        }
+    }
+    do {
+        fd = open(path, open_flags, mode);
+    } while (fd == -1 && errno == EINTR);
+    if (fd == -1) janet_panicv(janet_ev_lasterr());
+#endif
+    return janet_wrap_abstract(janet_stream(fd, stream_flags, NULL));
+}
+
+static Janet os_pipe(int32_t argc, Janet *argv) {
+    (void) argv;
+    janet_fixarity(argc, 0);
+    JanetHandle fds[2];
+    if (janet_make_pipe(fds)) janet_panicv(janet_ev_lasterr());
+    JanetStream *reader = janet_stream(fds[0], JANET_STREAM_READABLE, NULL);
+    JanetStream *writer = janet_stream(fds[1], JANET_STREAM_WRITABLE, NULL);
+    Janet tup[2] = {janet_wrap_abstract(reader), janet_wrap_abstract(writer)};
+    return janet_wrap_tuple(janet_tuple_n(tup, 2));
+}
+
+#endif
+
 #endif /* JANET_REDUCED_OS */
 
 static const JanetReg os_cfuns[] = {
@@ -1743,8 +1974,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.")
     },
     {
@@ -1798,6 +2029,42 @@ static const JanetReg os_cfuns[] = {
         JDOC("(os/perm-int bytes)\n\n"
              "Parse a 9 character permission string and return an integer that can be used by chmod.")
     },
+#ifdef JANET_EV
+    {
+        "os/open", os_open,
+        JDOC("(os/open path &opt flags mode)\n\n"
+             "Create a stream from a file, like the POSIX open system call. Returns a new stream. "
+             "mode should be a file mode as passed to os/chmod, but only if the create flag is given. "
+             "The default mode is 8r666. "
+             "Allowed flags are as follows:\n\n"
+             "\t:r - open this file for reading\n"
+             "\t:w - open this file for writing\n"
+             "\t:c - create a new file (O_CREATE)\n"
+             "\t:e - fail if the file exists (O_EXCL)\n"
+             "\t:t - shorten an existing file to length 0 (O_TRUNC)\n\n"
+             "Posix only flags:\n"
+             "\t:a - append to a file (O_APPEND)\n"
+             "\t:x - O_SYNC\n"
+             "\t:C - O_NOCTTY\n\n"
+             "Windows only flags:\n"
+             "\t:R - share reads (FILE_SHARE_READ)\n"
+             "\t:W - share writes (FILE_SHARE_WRITE)\n"
+             "\t:D - share deletes (FILE_SHARE_DELETE)\n"
+             "\t:H - FILE_ATTRIBUTE_HIDDEN\n"
+             "\t:O - FILE_ATTRIBUTE_READONLY\n"
+             "\t:F - FILE_ATTRIBUTE_OFFLINE\n"
+             "\t:T - FILE_ATTRIBUTE_TEMPORARY\n"
+             "\t:d - FILE_FLAG_DELETE_ON_CLOSE\n"
+             "\t:b - FILE_FLAG_NO_BUFFERING\n")
+    },
+    {
+        "os/pipe", os_pipe,
+        JDOC("(os/pipe)\n\n"
+             "Create a readable stream and a writable stream that are connected. Returns a two element "
+             "tuple where the first element is a readable stream and the second element is the writable "
+             "stream.")
+    },
+#endif
 #endif
     {NULL, NULL, NULL}
 };

src/core/parse.c

@@ -313,11 +313,48 @@ static int stringend(JanetParser *p, JanetParseState *state) {
     uint8_t *bufstart = p->buf;
     int32_t buflen = (int32_t) p->bufcount;
     if (state->flags & PFLAG_LONGSTRING) {
-        /* Check for leading newline character so we can remove it */
-        if (bufstart[0] == '\n') {
-            bufstart++;
-            buflen--;
+        /* Post process to remove leading whitespace */
+        JanetParseState top = p->states[p->statecount - 1];
+        int32_t indent_col = (int32_t) top.column - 1;
+        uint8_t *r = bufstart, *end = r + buflen;
+        /* Check if there are any characters before the start column -
+         * if so, do not reindent. */
+        int reindent = 1;
+        while (reindent && (r < end)) {
+            if (*r++ == '\n') {
+                for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++) {
+                    if (*r != ' ') {
+                        reindent = 0;
+                        break;
+                    }
+                }
+            }
         }
+        /* Now reindent if able to, otherwise just drop leading newline. */
+        if (!reindent) {
+            if (buflen > 0 && bufstart[0] == '\n') {
+                buflen--;
+                bufstart++;
+            }
+        } else {
+            uint8_t *w = bufstart;
+            r = bufstart;
+            while (r < end) {
+                if (*r == '\n') {
+                    if (r == bufstart) {
+                        /* Skip leading newline */
+                        r++;
+                    } else {
+                        *w++ = *r++;
+                    }
+                    for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++);
+                } else {
+                    *w++ = *r++;
+                }
+            }
+            buflen = (int32_t)(w - bufstart);
+        }
+        /* Check for trailing newline character so we can remove it */
         if (buflen > 0 && bufstart[buflen - 1] == '\n') {
             buflen--;
         }

src/core/peg.c

@@ -45,8 +45,10 @@ typedef struct {
     JanetBuffer *scratch;
     JanetBuffer *tags;
     const Janet *extrav;
+    int32_t *linemap;
     int32_t extrac;
     int32_t depth;
+    int32_t linemaplen;
     enum {
         PEG_MODE_NORMAL,
         PEG_MODE_ACCUMULATE
@@ -87,6 +89,63 @@ static void pushcap(PegState *s, Janet capture, uint32_t tag) {
     }
 }
 
+/* Lazily generate line map to get line and column information for PegState.
+ * line and column are 1-indexed. */
+typedef struct {
+    int32_t line;
+    int32_t col;
+} LineCol;
+static LineCol get_linecol_from_position(PegState *s, int32_t position) {
+    /* Generate if not made yet */
+    if (s->linemaplen < 0) {
+        int32_t newline_count = 0;
+        for (const uint8_t *c = s->text_start; c < s->text_end; c++) {
+            if (*c == '\n') newline_count++;
+        }
+        int32_t *mem = janet_smalloc(sizeof(int32_t) * newline_count);
+        size_t index = 0;
+        for (const uint8_t *c = s->text_start; c < s->text_end; c++) {
+            if (*c == '\n') mem[index++] = (int32_t)(c - s->text_start);
+        }
+        s->linemaplen = newline_count;
+        s->linemap = mem;
+    }
+    /* Do binary search for line. Slightly modified from classic binary search:
+     * - if we find that our current character is a line break, just return immediately.
+     *   a newline character is consider to be on the same line as the character before
+     *   (\n is line terminator, not line separator).
+     * - in the not-found case, we still want to find the greatest-indexed newline that
+     *   is before position. we use that to calcuate the line and column.
+     * - in the case that lo = 0 and s->linemap[0] is still greater than position, we
+     *   are on the first line and our column is position + 1. */
+    int32_t hi = s->linemaplen; /* hi is greater than the actual line */
+    int32_t lo = 0; /* lo is less than or equal to the actual line */
+    LineCol ret;
+    while (lo + 1 < hi) {
+        int32_t mid = lo + (hi - lo) / 2;
+        if (s->linemap[mid] >= position) {
+            hi = mid;
+        } else {
+            lo = mid;
+        }
+    }
+    /* first line case */
+    if (s->linemaplen == 0 || (lo == 0 && s->linemap[0] >= position)) {
+        ret.line = 1;
+        ret.col = position + 1;
+    } else {
+        ret.line = lo + 2;
+        ret.col = position - s->linemap[lo];
+    }
+    return ret;
+}
+
+/* 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"); \
@@ -274,6 +333,18 @@ tail:
             return text;
         }
 
+        case RULE_LINE: {
+            LineCol lc = get_linecol_from_position(s, (int32_t)(text - s->text_start));
+            pushcap(s, janet_wrap_number((double)(lc.line)), rule[1]);
+            return text;
+        }
+
+        case RULE_COLUMN: {
+            LineCol lc = get_linecol_from_position(s, (int32_t)(text - s->text_start));
+            pushcap(s, janet_wrap_number((double)(lc.col)), rule[1]);
+            return text;
+        }
+
         case RULE_ARGUMENT: {
             int32_t index = ((int32_t *)rule)[1];
             Janet capture = (index >= s->extrac) ? janet_wrap_nil() : s->extrav[index];
@@ -414,8 +485,8 @@ tail:
             } else {
                 /* Throw generic error */
                 int32_t start = (int32_t)(text - s->text_start);
-                int32_t end = (int32_t)(result - s->text_start);
-                janet_panicf("match error in range (%d:%d)", start, end);
+                LineCol lc = get_linecol_from_position(s, start);
+                janet_panicf("match error at line %d, column %d", lc.line, lc.col);
             }
             return NULL;
         }
@@ -469,6 +540,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;
+        }
+
     }
 }
 
@@ -783,7 +895,13 @@ static void spec_not(Builder *b, int32_t argc, const Janet *argv) {
     spec_onerule(b, argc, argv, RULE_NOT);
 }
 static void spec_error(Builder *b, int32_t argc, const Janet *argv) {
-    spec_onerule(b, argc, argv, RULE_ERROR);
+    if (argc == 0) {
+        Reserve r = reserve(b, 2);
+        uint32_t rule = peg_compile1(b, janet_wrap_number(0));
+        emit_1(r, RULE_ERROR, rule);
+    } else {
+        spec_onerule(b, argc, argv, RULE_ERROR);
+    }
 }
 static void spec_drop(Builder *b, int32_t argc, const Janet *argv) {
     spec_onerule(b, argc, argv, RULE_DROP);
@@ -833,6 +951,12 @@ static void spec_tag1(Builder *b, int32_t argc, const Janet *argv, uint32_t op)
 static void spec_position(Builder *b, int32_t argc, const Janet *argv) {
     spec_tag1(b, argc, argv, RULE_POSITION);
 }
+static void spec_line(Builder *b, int32_t argc, const Janet *argv) {
+    spec_tag1(b, argc, argv, RULE_LINE);
+}
+static void spec_column(Builder *b, int32_t argc, const Janet *argv) {
+    spec_tag1(b, argc, argv, RULE_COLUMN);
+}
 
 static void spec_backmatch(Builder *b, int32_t argc, const Janet *argv) {
     spec_tag1(b, argc, argv, RULE_BACKMATCH);
@@ -876,6 +1000,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 {
@@ -906,13 +1060,17 @@ static const SpecialPair peg_specials[] = {
     {"capture", spec_capture},
     {"choice", spec_choice},
     {"cmt", spec_matchtime},
+    {"column", spec_column},
     {"constant", spec_constant},
     {"drop", spec_drop},
     {"error", spec_error},
     {"group", spec_group},
     {"if", spec_if},
     {"if-not", spec_ifnot},
+    {"int", spec_int_le},
+    {"int-be", spec_int_be},
     {"lenprefix", spec_lenprefix},
+    {"line", spec_line},
     {"look", spec_look},
     {"not", spec_not},
     {"opt", spec_opt},
@@ -926,6 +1084,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. */
@@ -1148,6 +1308,8 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
             case RULE_NOTNCHAR:
             case RULE_RANGE:
             case RULE_POSITION:
+            case RULE_LINE:
+            case RULE_COLUMN:
             case RULE_BACKMATCH:
                 /* [1 word] */
                 i += 2;
@@ -1226,6 +1388,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;
         }
@@ -1352,6 +1519,8 @@ static PegCall peg_cfun_init(int32_t argc, Janet *argv, int get_replace) {
     ret.s.tags = janet_buffer(10);
     ret.s.constants = ret.peg->constants;
     ret.s.bytecode = ret.peg->bytecode;
+    ret.s.linemap = NULL;
+    ret.s.linemaplen = -1;
     return ret;
 }
 

src/core/specials.c

@@ -336,10 +336,8 @@ static int defleaf(
 
         /* Put value in table when evaulated */
         janetc_emit_sss(c, JOP_PUT, tabslot, valsym, s, 0);
-        return 1;
-    } else {
-        return namelocal(c, sym, 0, s);
     }
+    return namelocal(c, sym, 0, s);
 }
 
 static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) {
@@ -470,6 +468,28 @@ static JanetSlot janetc_do(JanetFopts opts, int32_t argn, const Janet *argv) {
     return ret;
 }
 
+
+/* Compile an upscope form. Upscope forms execute their body sequentially and
+ * evaluate to the last expression in the body, but without lexical scope. */
+static JanetSlot janetc_upscope(JanetFopts opts, int32_t argn, const Janet *argv) {
+    int32_t i;
+    JanetSlot ret = janetc_cslot(janet_wrap_nil());
+    JanetCompiler *c = opts.compiler;
+    JanetFopts subopts = janetc_fopts_default(c);
+    for (i = 0; i < argn; i++) {
+        if (i != argn - 1) {
+            subopts.flags = JANET_FOPTS_DROP;
+        } else {
+            subopts = opts;
+        }
+        ret = janetc_value(subopts, argv[i]);
+        if (i != argn - 1) {
+            janetc_freeslot(c, ret);
+        }
+    }
+    return ret;
+}
+
 /* Add a funcdef to the top most function scope */
 static int32_t janetc_addfuncdef(JanetCompiler *c, JanetFuncDef *def) {
     JanetScope *scope = c->scope;
@@ -854,6 +874,7 @@ static const JanetSpecial janetc_specials[] = {
     {"set", janetc_varset},
     {"splice", janetc_splice},
     {"unquote", janetc_unquote},
+    {"upscope", janetc_upscope},
     {"var", janetc_var},
     {"while", janetc_while}
 };

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/strtod.c

@@ -447,7 +447,7 @@ int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out) {
     int neg;
     uint64_t bi;
     if (scan_uint64(str, len, &bi, &neg)) {
-        if (neg && bi <= (UINT64_MAX / 2)) {
+        if (neg && bi <= ((UINT64_MAX / 2) + 1)) {
             if (bi > INT64_MAX) {
                 *out = INT64_MIN;
             } else {

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) {

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,12 @@ 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);
+int janet_make_pipe(JanetHandle handles[2]);
 #endif
 
 #endif

src/core/vm.c

@@ -1337,6 +1337,10 @@ static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *o
 
     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;
@@ -1372,7 +1376,6 @@ static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *o
         /* Normal setup */
         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);
         signal = run_vm(fiber, in);
     }
@@ -1380,7 +1383,6 @@ static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *o
     /* Restore */
     if (janet_vm_root_fiber == fiber) janet_vm_root_fiber = NULL;
     janet_fiber_set_status(fiber, signal);
-    janet_gcunroot(janet_wrap_fiber(fiber));
     janet_restore(&tstate);
     *out = tstate.payload;
 
@@ -1479,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;
 }
@@ -1501,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

@@ -20,6 +20,8 @@
 * IN THE SOFTWARE.
 */
 
+#include "janetconf.h"
+
 #ifndef JANET_H_defined
 #define JANET_H_defined
 
@@ -35,8 +37,6 @@ extern "C" {
 
 /***** START SECTION CONFIG *****/
 
-#include "janetconf.h"
-
 #ifndef JANET_VERSION
 #define JANET_VERSION "latest"
 #endif
@@ -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
 
@@ -492,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_CANCEL,
+    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 */
+    size_t _index;
+    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. */
@@ -759,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 */
@@ -1175,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 */
@@ -1488,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"
@@ -1652,7 +1783,10 @@ typedef enum {
     RULE_TO,           /* [rule] */
     RULE_THRU,         /* [rule] */
     RULE_LENPREFIX,    /* [rule_a, rule_b (repeat rule_b rule_a times)] */
-} JanetPegOpcode;
+    RULE_READINT,      /* [(signedness << 4) | (endianess << 5) | bytewidth, tag] */
+    RULE_LINE,         /* [tag] */
+    RULE_COLUMN        /* [tag] */
+} JanetPegOpcod;
 
 typedef struct {
     uint32_t *bytecode;
@@ -1743,6 +1877,7 @@ extern JANET_API const JanetAbstractType janet_thread_type;
 
 JANET_API int janet_thread_receive(Janet *msg_out, double timeout);
 JANET_API int janet_thread_send(JanetThread *thread, Janet msg, double timeout);
+JANET_API JanetThread *janet_thread_current(void);
 
 #endif
 

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

@@ -11,9 +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
-    (xprintf stdout "\e[32m✔\e[0m %s: %v" (string e) x)
-    (xprintf stdout "\n\e[31m✘\e[0m %s: %v" (string e) x))
+    (eprintf "\e[32m✔\e[0m %s: %v" truncated x)
+    (eprintf "\n\e[31m✘\e[0m %s: %v" truncated x))
   x)
 
 (defmacro assert-error
@@ -29,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

@@ -360,6 +360,14 @@
 (check-match janet-longstring "``` `` ```" true)
 (check-match janet-longstring "``  ```" false)
 
+# Line and column capture
+
+(def line-col (peg/compile '(any (* (line) (column) 1))))
+(check-deep line-col "abcd" @[1 1 1 2 1 3 1 4])
+(check-deep line-col "" @[])
+(check-deep line-col "abcd\n" @[1 1 1 2 1 3 1 4 1 5])
+(check-deep line-col "abcd\nz" @[1 1 1 2 1 3 1 4 1 5 2 1])
+
 # Backmatch
 
 (def backmatcher-1 '(* (capture (any "x") :1) "y" (backmatch :1) -1))
@@ -443,4 +451,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

@@ -36,6 +36,12 @@
 (def s (net/server "127.0.0.1" "8000" handler))
 (assert s "made server 1")
 
+# We need some sleep for windows to let the server stabilize
+# or else the first read can fail. Might be a strange windows
+# "bug", but needs further investigating. Otherwise, `build_win test`
+# can sometimes fail on windows, leading to flaky testing.
+(ev/sleep 0.2)
+
 (defn test-echo [msg]
   (with [conn (net/connect "127.0.0.1" "8000")]
     (:write conn msg)
@@ -48,4 +54,32 @@
 
 (:close s)
 
+# Create pipe
+
+(var pipe-counter 0)
+(def chan (ev/chan 10))
+(let [[reader writer] (os/pipe)]
+  (ev/spawn
+    (while (ev/read reader 3)
+      (++ pipe-counter))
+    (assert (= 20 pipe-counter) "ev/pipe 1")
+    (ev/give chan 1))
+
+  (for i 0 10
+    (ev/write writer "xxx---"))
+
+  (ev/close writer)
+  (ev/take chan))
+
+(var result nil)
+(def fiber
+  (ev/spawn 
+    (set result (protect (ev/sleep 0.4)))
+    (assert (= result '(false "boop")) "ev/cancel 1")))
+(ev/sleep 0.1)
+(ev/cancel fiber "boop")
+(ev/sleep 0.1)
+
+(assert-error "bad arity to ev/call" (ev/call inc 1 2 3))
+
 (end-suite)

test/suite0010.janet

@@ -61,4 +61,12 @@
 (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")
+
+# # off by 1 error in inttypes
+(assert (= (int/s64 "-0x8000_0000_0000_0000") (+ (int/s64 "0x7FFF_FFFF_FFFF_FFFF") 1)) "int types wrap around")
+
+
 (end-suite)

tools/msi/janet.wxs

@@ -126,9 +126,6 @@
                 <File Source="dist\janet.h"/>
                 <RemoveFolder Id="RemoveCDir" On="uninstall" />
             </Component>
-            <Component Directory="CDir">
-                <File Source="dist\janetconf.h"/>
-            </Component>
             <Component Directory="CDir">
                 <File Source="dist\janet.lib"/>
             </Component>

tools/patch-header.janet

@@ -0,0 +1,3 @@
+# Patch janet.h 
+(def [_ janeth janetconf output] (dyn :args))
+(spit output (string/replace `#include "janetconf.h"` (slurp janetconf) (slurp janeth)))