Remove word.

Still leave open the possibity for AI / tool usage for static analysis
and bug repots. However, the 5-15 lines of code limitation is fuzzy and
arbitrary. We can just say no.

CHANGELOG.md

@@ -2,7 +2,6 @@
 All notable changes to this project will be documented in this file.
 
 ## Unreleased - ???
-- Add `file/sync` as a wrapper around fsync.
 - Documentation fixes
 - ev/thread-chan deadlock bug fixed
 - Re-add removed support for non-blocking net/connect on windows.

CONTRIBUTING.md

@@ -37,6 +37,12 @@ may require changes before being merged.
   do this indentation, or approximate as close as possible. There is a janet formatter
   in [spork](https://github.com/janet-lang/spork.git) that can be used to format code as well.
 
+Bot pull requests will not be accepted, and anonymous submissions, including
+new accounts, unknown emails, and first time contributors will be subjected
+to greater scrutiny and code reivew. Automatically generated and filed bug
+reports MAY be ok, if they are of consistent and good quality, such as
+OSSFuzz or well constructed CI pipelines.
+
 ## C style
 
 For changes to the VM and Core code, you will probably need to know C. Janet is programmed with
@@ -90,3 +96,18 @@ timely manner. In short, if you want extra functionality now, then build it.
 
 * Include a good description of the problem that is being solved
 * Include descriptions of potential solutions if you have some in mind.
+
+## LLMs, Tool Usage, and Transparency
+
+All usage of Large Language Models (LLMs), Neural Networks, "AI" tools, and
+other tools such as software fuzzers or static analyzers must be disclosed.
+This applies to pull requests, email patches, bug reports, and any other
+meaningful contribution to Janet's source code. Please also refrain from using
+generative AI for code that will be embedded in the Janet runtime, which include
+all C source files as well as boot.janet. All code should be well
+and completely understood by the human author, including test cases. Large and
+obviously AI-driven changes will be rejected. Be mindful and transparent on the
+copyright implications of any submitted code. We will use discretion when
+accepting generated test cases for bug reproductions, one-line bug
+fixes, or typo fixes. Often, these can be trivially rewritten by a human to
+avoid the problem.

build_win.bat

@@ -29,16 +29,14 @@ if DEFINED CLANG (
     @set COMPILER=cl.exe
 )
 if DEFINED SANITIZE (
-    @set "SANITIZERS=/fsanitize=address /Zi"
-    @set "LINK_SAN=/DEBUG"
+    @set "SANITIZERS=/fsanitize=address"
 ) else (
     @set "SANITIZERS="
-    @set "LINK_SAN=/DEBUG"
 )
 @set JANET_COMPILE=%COMPILER% /nologo /Isrc\include /Isrc\conf /c /O2 /W3 /D_CRT_SECURE_NO_WARNINGS /MD %SANITIZERS%
-@set JANET_LINK=link /nologo %LINK_SAN%
+@set JANET_LINK=link /nologo
 
-@set JANET_LINK_STATIC=lib /nologo %LINK_SAN%
+@set JANET_LINK_STATIC=lib /nologo
 
 @rem Add janet build tag
 if not "%JANET_BUILD%" == "" (

src/boot/boot.janet

@@ -443,11 +443,36 @@
      (def ,binding ,ctor)
      ,(defer-impl :with [(or dtor :close) binding] body)))
 
+# declare ahead of time
+(var- macexvar nil)
+
+(defmacro if-let
+  ``Make multiple bindings, and if all are truthy,
+  evaluate the `tru` form. If any are false or nil, evaluate
+  the `fal` form. Bindings have the same syntax as the `let` macro.``
+  [bindings tru &opt fal]
+  (def len (length bindings))
+  (if (= 0 len) (error "expected at least 1 binding"))
+  (if (odd? len) (error "expected an even number of bindings"))
+  (def fal2 (if macexvar (macexvar fal) fal))
+  (defn aux [i]
+    (if (>= i len)
+      tru
+      (do
+        (def bl (in bindings i))
+        (def br (in bindings (+ 1 i)))
+        (if (symbol? bl)
+          ~(if (def ,bl ,br) ,(aux (+ 2 i)) ,fal2)
+          ~(if (def ,(def sym (gensym)) ,br)
+             (do (def ,bl ,sym) ,(aux (+ 2 i)))
+             ,fal2)))))
+  (aux 0))
+
 (defmacro when-with
   ``Similar to with, but if binding is false or nil, returns
   nil without evaluating the body. Otherwise, the same as `with`.``
   [[binding ctor dtor] & body]
-  ~(if-let [,binding ,ctor]
+  ~(as-macro ,if-let [,binding ,ctor]
      ,(defer-impl :when-with [(or dtor :close) binding] body)))
 
 (defmacro if-with
@@ -455,7 +480,7 @@
   the falsey path. Otherwise, evaluates the truthy path. In both cases,
   `ctor` is bound to binding.``
   [[binding ctor dtor] truthy &opt falsey]
-  ~(if-let [,binding ,ctor]
+  ~(as-macro ,if-let [,binding ,ctor]
      ,(defer-impl :if-with [(or dtor :close) binding] [truthy])
      ,falsey))
 
@@ -539,13 +564,13 @@
         (case binding
           :until ~(do (if ,verb (break) nil) ,rest)
           :while ~(do (if ,verb nil (break)) ,rest)
-          :let ~(let ,verb (do ,rest))
+          :let ~(as-macro ,let ,verb (do ,rest))
           :after ~(do ,rest ,verb nil)
           :before ~(do ,verb ,rest nil)
           :repeat (with-syms [iter]
-                    ~(do (var ,iter ,verb) (while (> ,iter 0) ,rest (-- ,iter))))
-          :when ~(when ,verb ,rest)
-          :unless ~(unless ,verb ,rest)
+                    ~(do (var ,iter ,verb) (while (,> ,iter 0) ,rest (as-macro ,-- ,iter))))
+          :when ~(as-macro ,when ,verb ,rest)
+          :unless ~(as-macro ,unless ,verb ,rest)
           (error (string "unexpected loop modifier " binding))))))
 
   # 3 term expression
@@ -587,7 +612,7 @@
   "Evaluate body n times. If n is negative, body will be evaluated 0 times. Evaluates to nil."
   [n & body]
   (with-syms [iter]
-    ~(do (var ,iter ,n) (while (> ,iter 0) ,;body (-- ,iter)))))
+    ~(do (var ,iter ,n) (while (,> ,iter 0) ,;body (as-macro ,-- ,iter)))))
 
 (defmacro forever
   "Evaluate body forever in a loop, or until a break statement."
@@ -683,7 +708,7 @@
   [head & body]
   (def $accum (gensym))
   (check-empty-body body)
-  ~(do (def ,$accum @[]) (loop ,head (,array/push ,$accum (do ,;body))) ,$accum))
+  ~(do (def ,$accum @[]) (as-macro ,loop ,head (,array/push ,$accum (do ,;body))) ,$accum))
 
 (defmacro catseq
   ``Similar to `loop`, but concatenates each element from the loop body into an array and returns that.
@@ -691,21 +716,21 @@
   [head & body]
   (def $accum (gensym))
   (check-empty-body body)
-  ~(do (def ,$accum @[]) (loop ,head (,array/concat ,$accum (do ,;body))) ,$accum))
+  ~(do (def ,$accum @[]) (as-macro ,loop ,head (,array/concat ,$accum (do ,;body))) ,$accum))
 
 (defmacro tabseq
   ``Similar to `loop`, but accumulates key value pairs into a table.
   See `loop` for details.``
   [head key-body & value-body]
   (def $accum (gensym))
-  ~(do (def ,$accum @{}) (loop ,head (,put ,$accum ,key-body (do ,;value-body))) ,$accum))
+  ~(do (def ,$accum @{}) (as-macro ,loop ,head (,put ,$accum ,key-body (do ,;value-body))) ,$accum))
 
 (defmacro generate
   ``Create a generator expression using the `loop` syntax. Returns a fiber
   that yields all values inside the loop in order. See `loop` for details.``
   [head & body]
   (check-empty-body body)
-  ~(,fiber/new (fn :generate [] (loop ,head (yield (do ,;body)))) :yi))
+  ~(,fiber/new (fn :generate [] (as-macro ,loop ,head (,yield (do ,;body)))) :yi))
 
 (defmacro coro
   "A wrapper for making fibers that may yield multiple values (coroutine). Same as `(fiber/new (fn [] ;body) :yi)`."
@@ -754,35 +779,10 @@
   (each x xs (*= accum x))
   accum)
 
-# declare ahead of time
-(var- macexvar nil)
-
-(defmacro if-let
-  ``Make multiple bindings, and if all are truthy,
-  evaluate the `tru` form. If any are false or nil, evaluate
-  the `fal` form. Bindings have the same syntax as the `let` macro.``
-  [bindings tru &opt fal]
-  (def len (length bindings))
-  (if (= 0 len) (error "expected at least 1 binding"))
-  (if (odd? len) (error "expected an even number of bindings"))
-  (def fal2 (if macexvar (macexvar fal) fal))
-  (defn aux [i]
-    (if (>= i len)
-      tru
-      (do
-        (def bl (in bindings i))
-        (def br (in bindings (+ 1 i)))
-        (if (symbol? bl)
-          ~(if (def ,bl ,br) ,(aux (+ 2 i)) ,fal2)
-          ~(if (def ,(def sym (gensym)) ,br)
-             (do (def ,bl ,sym) ,(aux (+ 2 i)))
-             ,fal2)))))
-  (aux 0))
-
 (defmacro when-let
   "Same as `(if-let bindings (do ;body))`."
   [bindings & body]
-  ~(if-let ,bindings (do ,;body)))
+  ~(as-macro ,if-let ,bindings (do ,;body)))
 
 (defn comp
   `Takes multiple functions and returns a function that is the composition
@@ -1432,7 +1432,7 @@
                  (tuple n @[])))
     (def sym (gensym))
     (def parts (array/concat @[h sym] t))
-    ~(let [,sym ,last] (if ,sym ,(keep-syntax! n parts))))
+    ~(as-macro ,let [,sym ,last] (if ,sym ,(keep-syntax! n parts))))
   (reduce fop x forms))
 
 (defmacro -?>>
@@ -1448,7 +1448,7 @@
                  (tuple n @[])))
     (def sym (gensym))
     (def parts (array/concat @[h] t @[sym]))
-    ~(let [,sym ,last] (if ,sym ,(keep-syntax! n parts))))
+    ~(as-macro ,let [,sym ,last] (if ,sym ,(keep-syntax! n parts))))
   (reduce fop x forms))
 
 (defn- walk-ind [f form]
@@ -2411,8 +2411,8 @@
       (dictionary? m) (merge-into metadata m)
       (error (string "invalid metadata " m))))
   (with-syms [entry old-entry f]
-    ~(let [,old-entry (,dyn ',name)]
-       (def ,entry (or ,old-entry @{:ref @[nil]}))
+    ~(as-macro ,let [,old-entry (,dyn ',name)]
+       (def ,entry (as-macro ,or ,old-entry @{:ref @[nil]}))
        (,setdyn ',name ,entry)
        (def ,f ,fbody)
        (,put-in ,entry [:ref 0] ,f)
@@ -3953,7 +3953,7 @@
     ``
     [sec & body]
     (with-syms [f]
-      ~(let [,f (coro ,;body)]
+      ~(as-macro ,let [,f (as-macro ,coro ,;body)]
          (,ev/deadline ,sec nil ,f)
          (,resume ,f))))
 
@@ -4085,15 +4085,15 @@
     (defn make-ptr []
       (assertf (ffi/lookup (if lazy (llib) lib) raw-symbol) "failed to find ffi symbol %v" raw-symbol))
     (if lazy
-      ~(defn ,alias ,;meta [,;formal-args]
+      ~(as-macro ,defn ,alias ,;meta [,;formal-args]
          (,ffi/call (,(delay (make-ptr))) (,(delay (make-sig))) ,;formal-args))
-      ~(defn ,alias ,;meta [,;formal-args]
+      ~(as-macro ,defn ,alias ,;meta [,;formal-args]
          (,ffi/call ,(make-ptr) ,(make-sig) ,;formal-args))))
 
   (defmacro ffi/defbind :flycheck
     "Generate bindings for native functions in a convenient manner."
     [name ret-type & body]
-    ~(ffi/defbind-alias ,name ,name ,ret-type ,;body)))
+    ~(as-macro ,ffi/defbind-alias ,name ,name ,ret-type ,;body)))
 
 ###
 ###

src/core/asm.c

@@ -1110,6 +1110,7 @@ JANET_CORE_FN(cfun_disasm,
         if (!janet_cstrcmp(kw, "structarg")) return janet_disasm_structarg(f->def);
         if (!janet_cstrcmp(kw, "namedargs")) return janet_disasm_namedargs(f->def);
         if (!janet_cstrcmp(kw, "slotcount")) return janet_disasm_slotcount(f->def);
+        if (!janet_cstrcmp(kw, "symbolmap")) return janet_disasm_symbolslots(f->def);
         if (!janet_cstrcmp(kw, "constants")) return janet_disasm_constants(f->def);
         if (!janet_cstrcmp(kw, "sourcemap")) return janet_disasm_sourcemap(f->def);
         if (!janet_cstrcmp(kw, "environments")) return janet_disasm_environments(f->def);

src/core/ev.c

@@ -968,7 +968,7 @@ static void janet_thread_chan_cb(JanetEVGenericMessage msg) {
             while (!janet_q_pop(&channel->read_pending, &reader, sizeof(reader))) {
                 JanetVM *vm = reader.thread;
                 if (!vm) continue;
-                JanetEVGenericMessage msg = {0};
+                JanetEVGenericMessage msg;
                 msg.tag = reader.mode;
                 msg.fiber = reader.fiber;
                 msg.argi = (int32_t) reader.sched_id;
@@ -986,7 +986,7 @@ static void janet_thread_chan_cb(JanetEVGenericMessage msg) {
             while (!janet_q_pop(&channel->write_pending, &writer, sizeof(writer))) {
                 JanetVM *vm = writer.thread;
                 if (!vm) continue;
-                JanetEVGenericMessage msg = {0};
+                JanetEVGenericMessage msg;
                 msg.tag = writer.mode;
                 msg.fiber = writer.fiber;
                 msg.argi = (int32_t) writer.sched_id;
@@ -1052,7 +1052,7 @@ static int janet_channel_push_with_lock(JanetChannel *channel, Janet x, int mode
         /* Pending reader */
         if (is_threaded) {
             JanetVM *vm = reader.thread;
-            JanetEVGenericMessage msg = {0};
+            JanetEVGenericMessage msg;
             msg.tag = reader.mode;
             msg.fiber = reader.fiber;
             msg.argi = (int32_t) reader.sched_id;
@@ -1112,7 +1112,7 @@ static int janet_channel_pop_with_lock(JanetChannel *channel, Janet *item, int i
         /* Pending writer */
         if (is_threaded) {
             JanetVM *vm = writer.thread;
-            JanetEVGenericMessage msg = {0};
+            JanetEVGenericMessage msg;
             msg.tag = writer.mode;
             msg.fiber = writer.fiber;
             msg.argi = (int32_t) writer.sched_id;
@@ -1172,7 +1172,7 @@ JanetChannel *janet_channel_make(uint32_t limit) {
 JanetChannel *janet_channel_make_threaded(uint32_t limit) {
     janet_assert(limit <= INT32_MAX, "bad limit");
     JanetChannel *channel = janet_abstract_threaded(&janet_channel_type, sizeof(JanetChannel));
-    janet_chan_init(channel, (int32_t) limit, 0);
+    janet_chan_init(channel, (int32_t) limit, 1);
     return channel;
 }
 
@@ -1364,7 +1364,7 @@ JANET_CORE_FN(cfun_channel_close,
         while (!janet_q_pop(&channel->write_pending, &writer, sizeof(writer))) {
             if (writer.thread != &janet_vm) {
                 JanetVM *vm = writer.thread;
-                JanetEVGenericMessage msg = {0};
+                JanetEVGenericMessage msg;
                 msg.fiber = writer.fiber;
                 msg.argp = channel;
                 msg.tag = JANET_CP_MODE_CLOSE;
@@ -1387,7 +1387,7 @@ JANET_CORE_FN(cfun_channel_close,
         while (!janet_q_pop(&channel->read_pending, &reader, sizeof(reader))) {
             if (reader.thread != &janet_vm) {
                 JanetVM *vm = reader.thread;
-                JanetEVGenericMessage msg = {0};
+                JanetEVGenericMessage msg;
                 msg.fiber = reader.fiber;
                 msg.argp = channel;
                 msg.tag = JANET_CP_MODE_CLOSE;
@@ -1722,7 +1722,7 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
             }
             if (fiber != NULL) {
                 fiber->flags &= ~JANET_FIBER_EV_FLAG_IN_FLIGHT;
-                jo->bytes_transferred = (ULONG_PTR) num_bytes_transferred;
+                jo->bytes_transfered = (ULONG_PTR) num_bytes_transferred;
                 fiber->ev_callback(fiber, result ? JANET_ASYNC_EVENT_COMPLETE : JANET_ASYNC_EVENT_FAILED);
             } else {
                 janet_free((void *) jo);
@@ -2257,14 +2257,11 @@ static DWORD WINAPI janet_thread_body(LPVOID ptr) {
     /* Reuse memory from thread init for returning data */
     init->msg = subr(msg);
     init->cb = cb;
-    BOOL result = PostQueuedCompletionStatus(iocp,
+    janet_assert(PostQueuedCompletionStatus(iocp,
                                             sizeof(JanetSelfPipeEvent),
                                             0,
-                                            (LPOVERLAPPED) init);
-    if (!result) {
-        JanetString x = janet_formatc("failed to post completion event: %V", janet_ev_lasterr());
-        janet_assert(0, (const char *)x);
-    }
+                                            (LPOVERLAPPED) init),
+                 "failed to post completion event");
     return 0;
 }
 #else
@@ -2366,7 +2363,8 @@ void janet_ev_default_threaded_callback(JanetEVGenericMessage return_value) {
 /* Convenience method for common case */
 JANET_NO_RETURN
 void janet_ev_threaded_await(JanetThreadedSubroutine fp, int tag, int argi, void *argp) {
-    JanetEVGenericMessage arguments = {0};
+    JanetEVGenericMessage arguments;
+    memset(&arguments, 0, sizeof(arguments));
     arguments.tag = tag;
     arguments.argi = argi;
     arguments.argp = argp;
@@ -2474,7 +2472,7 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
         case JANET_ASYNC_EVENT_FAILED:
         case JANET_ASYNC_EVENT_COMPLETE: {
             /* Called when read finished */
-            uint32_t ev_bytes = (uint32_t) state->overlapped.bytes_transferred;
+            uint32_t ev_bytes = (uint32_t) state->overlapped.bytes_transfered;
             state->bytes_read += ev_bytes;
             if (state->bytes_read == 0 && (state->mode != JANET_ASYNC_READMODE_RECVFROM)) {
                 janet_schedule(fiber, janet_wrap_nil());
@@ -2724,7 +2722,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
         case JANET_ASYNC_EVENT_FAILED:
         case JANET_ASYNC_EVENT_COMPLETE: {
             /* Called when write finished */
-            uint32_t ev_bytes = (uint32_t) state->overlapped.bytes_transferred;
+            uint32_t ev_bytes = (uint32_t) state->overlapped.bytes_transfered;
             if (ev_bytes == 0 && (state->mode != JANET_ASYNC_WRITEMODE_SENDTO)) {
                 janet_cancel(fiber, janet_cstringv("disconnect"));
                 janet_async_end(fiber);
@@ -3208,7 +3206,8 @@ JANET_CORE_FN(cfun_ev_thread,
     janet_marshal(buffer, value, NULL, JANET_MARSHAL_UNSAFE);
     if (flags & 0x1) {
         /* Return immediately */
-        JanetEVGenericMessage arguments = {0};
+        JanetEVGenericMessage arguments;
+        memset(&arguments, 0, sizeof(arguments));
         arguments.tag = (uint32_t) flags;
         arguments.argi = (uint32_t) janet_vm.sandbox_flags;
         arguments.argp = buffer;

src/core/io.c

@@ -320,41 +320,6 @@ static int cfun_io_gc(void *p, size_t len) {
     return 0;
 }
 
-/* Cross-platform fsync binding for Janet */
-JANET_CORE_FN(cfun_io_fsync,
-              "(file/sync f)",
-              "Flushes all operating system buffers to disk for file `f`. Guarantees data is physically "
-              "written to disk in a platform-dependent way. Returns the file handle if successful, raises error if not.") {
-    janet_fixarity(argc, 1);
-    JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
-    if (iof->flags & JANET_FILE_CLOSED)
-        janet_panic("file is closed");
-#ifdef JANET_WINDOWS
-    {
-        int fd = _fileno(iof->file);
-        if (fd < 0)
-            janet_panic("invalid file descriptor");
-        HANDLE hFile = (HANDLE)_get_osfhandle(fd);
-        if (hFile == INVALID_HANDLE_VALUE)
-            janet_panic("invalid file handle");
-        if (!FlushFileBuffers(hFile))
-            janet_panic("could not flush file buffers");
-    }
-#elif defined(_POSIX_VERSION)
-    {
-        int fd = fileno(iof->file);
-        if (fd < 0)
-            janet_panic("invalid file descriptor");
-        if (fsync(fd) != 0)
-            janet_panic("could not fsync file");
-    }
-#else
-    janet_panic("fsync not supported on this platform");
-#endif
-    return argv[0];
-}
-
-
 /* Close a file */
 JANET_CORE_FN(cfun_io_fclose,
               "(file/close f)",
@@ -429,7 +394,6 @@ static JanetMethod io_file_methods[] = {
     {"seek", cfun_io_fseek},
     {"tell", cfun_io_ftell},
     {"write", cfun_io_fwrite},
-    {"sync", cfun_io_fsync},
     {NULL, NULL}
 };
 
@@ -882,7 +846,6 @@ void janet_lib_io(JanetTable *env) {
         JANET_CORE_REG("file/flush", cfun_io_fflush),
         JANET_CORE_REG("file/seek", cfun_io_fseek),
         JANET_CORE_REG("file/tell", cfun_io_ftell),
-        JANET_CORE_REG("file/sync", cfun_io_fsync),
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, io_cfuns);

src/core/pp.c

@@ -72,7 +72,7 @@ static int count_dig10(int32_t x) {
     }
 }
 
-static void integer_to_string_b(JanetBuffer *buffer, int32_t x) {
+static int32_t integer_to_string_b(JanetBuffer *buffer, int32_t x) {
     janet_buffer_extra(buffer, BUFSIZE);
     uint8_t *buf = buffer->data + buffer->count;
     int32_t neg = 0;
@@ -80,7 +80,7 @@ static void integer_to_string_b(JanetBuffer *buffer, int32_t x) {
     if (x == 0) {
         buf[0] = '0';
         buffer->count++;
-        return;
+        return 1;
     }
     if (x > 0) {
         x = -x;
@@ -96,6 +96,7 @@ static void integer_to_string_b(JanetBuffer *buffer, int32_t x) {
         x /= 10;
     }
     buffer->count += len + neg;
+    return len + neg;
 }
 
 #define HEX(i) (((uint8_t *) janet_base64)[(i)])
@@ -134,43 +135,55 @@ static void string_description_b(JanetBuffer *buffer, const char *title, void *p
 #undef POINTSIZE
 }
 
-static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) {
+static int janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) {
     janet_buffer_push_u8(buffer, '"');
+    int align = 1;
     for (int32_t i = 0; i < len; ++i) {
         uint8_t c = str[i];
         switch (c) {
             case '"':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\"", 2);
+                align += 2;
                 break;
             case '\n':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\n", 2);
+                align += 2;
                 break;
             case '\r':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\r", 2);
+                align += 2;
                 break;
             case '\0':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2);
+                align += 2;
                 break;
             case '\f':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2);
+                align += 2;
                 break;
             case '\v':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2);
+                align += 2;
                 break;
             case '\a':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2);
+                align += 2;
                 break;
             case '\b':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2);
+                align += 2;
                 break;
             case 27:
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2);
+                align += 2;
                 break;
             case '\\':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2);
+                align += 2;
                 break;
             case '\t':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\t", 2);
+                align += 2;
                 break;
             default:
                 if (c < 32 || c > 126) {
@@ -180,13 +193,16 @@ static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, in
                     buf[2] = janet_base64[(c >> 4) & 0xF];
                     buf[3] = janet_base64[c & 0xF];
                     janet_buffer_push_bytes(buffer, buf, 4);
+                    align += 4;
                 } else {
                     janet_buffer_push_u8(buffer, c);
+                    align++;
                 }
                 break;
         }
     }
     janet_buffer_push_u8(buffer, '"');
+    return align + 1;
 }
 
 static void janet_escape_string_b(JanetBuffer *buffer, const uint8_t *str) {
@@ -358,7 +374,7 @@ const uint8_t *janet_to_string(Janet x) {
 struct pretty {
     JanetBuffer *buffer;
     int depth;
-    int indent;
+    int align;
     int flags;
     int32_t bufstartlen;
     int32_t *keysort_buffer;
@@ -450,14 +466,15 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
     return 0;
 }
 
-static void print_newline(struct pretty *S, int just_a_space) {
+static void print_newline(struct pretty *S, int align) {
     int i;
-    if (just_a_space || (S->flags & JANET_PRETTY_ONELINE)) {
+    S->align = align;
+    if (S->flags & JANET_PRETTY_ONELINE) {
         janet_buffer_push_u8(S->buffer, ' ');
         return;
     }
     janet_buffer_push_u8(S->buffer, '\n');
-    for (i = 0; i < S->indent; i++) {
+    for (i = 0; i < S->align; i++) {
         janet_buffer_push_u8(S->buffer, ' ');
     }
 }
@@ -484,14 +501,12 @@ static const char *janet_pretty_colors[] = {
     "\x1B[36m"
 };
 
-#define JANET_PRETTY_DICT_ONELINE 4
-#define JANET_PRETTY_IND_ONELINE 10
 #define JANET_PRETTY_DICT_LIMIT 30
 #define JANET_PRETTY_DICT_KEYSORT_LIMIT 2000
 #define JANET_PRETTY_ARRAY_LIMIT 160
 
 /* Helper for pretty printing */
-static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
+static void janet_pretty_one(struct pretty *S, Janet x) {
     /* Add to seen */
     switch (janet_type(x)) {
         case JANET_NIL:
@@ -506,7 +521,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                     janet_buffer_push_cstring(S->buffer, janet_cycle_color);
                 }
                 janet_buffer_push_cstring(S->buffer, "<cycle ");
-                integer_to_string_b(S->buffer, janet_unwrap_integer(seenid));
+                S->align += 8 + integer_to_string_b(S->buffer, janet_unwrap_integer(seenid));
                 janet_buffer_push_u8(S->buffer, '>');
                 if (S->flags & JANET_PRETTY_COLOR) {
                     janet_buffer_push_cstring(S->buffer, "\x1B[0m");
@@ -528,9 +543,11 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
             if (janet_checktype(x, JANET_BUFFER) && janet_unwrap_buffer(x) == S->buffer) {
                 janet_buffer_ensure(S->buffer, S->buffer->count + S->bufstartlen * 4 + 3, 1);
                 janet_buffer_push_u8(S->buffer, '@');
-                janet_escape_string_impl(S->buffer, S->buffer->data, S->bufstartlen);
+                S->align += 1 + janet_escape_string_impl(S->buffer, S->buffer->data, S->bufstartlen);
             } else {
+                S->align -= S->buffer->count;
                 janet_description_b(S->buffer, x);
+                S->align += S->buffer->count;
             }
             if (color && (S->flags & JANET_PRETTY_COLOR)) {
                 janet_buffer_push_cstring(S->buffer, "\x1B[0m");
@@ -547,35 +564,34 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
             const char *startstr = isarray ? "@[" : hasbrackets ? "[" : "(";
             const char endchar = isarray ? ']' : hasbrackets ? ']' : ')';
             janet_buffer_push_cstring(S->buffer, startstr);
+            const int align = S->align += strlen(startstr);
             S->depth--;
-            S->indent += 2;
             if (S->depth == 0) {
                 janet_buffer_push_cstring(S->buffer, "...");
+                S->align += 3;
             } else {
-                if (!isarray && !(S->flags & JANET_PRETTY_ONELINE) && len >= JANET_PRETTY_IND_ONELINE)
-                    janet_buffer_push_u8(S->buffer, ' ');
-                if (is_dict_value && len >= JANET_PRETTY_IND_ONELINE) print_newline(S, 0);
                 if (len > JANET_PRETTY_ARRAY_LIMIT && !(S->flags & JANET_PRETTY_NOTRUNC)) {
                     for (i = 0; i < 3; i++) {
-                        if (i) print_newline(S, 0);
-                        janet_pretty_one(S, arr[i], 0);
+                        if (i) print_newline(S, align);
+                        janet_pretty_one(S, arr[i]);
                     }
-                    print_newline(S, 0);
+                    print_newline(S, align);
                     janet_buffer_push_cstring(S->buffer, "...");
-                    for (i = 0; i < 3; i++) {
-                        print_newline(S, 0);
-                        janet_pretty_one(S, arr[len - 3 + i], 0);
+                    S->align += 3;
+                    for (i = len - 3; i < len; i++) {
+                        print_newline(S, align);
+                        janet_pretty_one(S, arr[i]);
                     }
                 } else {
                     for (i = 0; i < len; i++) {
-                        if (i) print_newline(S, len < JANET_PRETTY_IND_ONELINE);
-                        janet_pretty_one(S, arr[i], 0);
+                        if (i) print_newline(S, align);
+                        janet_pretty_one(S, arr[i]);
                     }
                 }
             }
-            S->indent -= 2;
             S->depth++;
             janet_buffer_push_u8(S->buffer, endchar);
+            S->align++;
             break;
         }
         case JANET_STRUCT:
@@ -586,6 +602,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
             if (istable) {
                 JanetTable *t = janet_unwrap_table(x);
                 JanetTable *proto = t->proto;
+                S->align++;
                 janet_buffer_push_cstring(S->buffer, "@");
                 if (NULL != proto) {
                     Janet name = janet_table_get(proto, janet_ckeywordv("_name"));
@@ -596,6 +613,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                             janet_buffer_push_cstring(S->buffer, janet_class_color);
                         }
                         janet_buffer_push_bytes(S->buffer, n, len);
+                        S->align += len;
                         if (S->flags & JANET_PRETTY_COLOR) {
                             janet_buffer_push_cstring(S->buffer, "\x1B[0m");
                         }
@@ -613,25 +631,24 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                             janet_buffer_push_cstring(S->buffer, janet_class_color);
                         }
                         janet_buffer_push_bytes(S->buffer, n, len);
+                        S->align += len;
                         if (S->flags & JANET_PRETTY_COLOR) {
                             janet_buffer_push_cstring(S->buffer, "\x1B[0m");
                         }
                     }
                 }
             }
-            janet_buffer_push_cstring(S->buffer, "{");
+            janet_buffer_push_u8(S->buffer, '{');
+            const int align = ++S->align;
 
             S->depth--;
-            S->indent += 2;
             if (S->depth == 0) {
                 janet_buffer_push_cstring(S->buffer, "...");
+                S->align += 3;
             } else {
                 int32_t len = 0, cap = 0;
                 const JanetKV *kvs = NULL;
                 janet_dictionary_view(x, &kvs, &len, &cap);
-                if (!istable && !(S->flags & JANET_PRETTY_ONELINE) && len >= JANET_PRETTY_DICT_ONELINE)
-                    janet_buffer_push_u8(S->buffer, ' ');
-                if (is_dict_value && len >= JANET_PRETTY_DICT_ONELINE) print_newline(S, 0);
                 int32_t ks_start = S->keysort_start;
                 int truncated = 0;
 
@@ -644,15 +661,17 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                     int32_t j = 0;
                     for (int32_t i = 0; i < len; i++) {
                         while (janet_checktype(kvs[j].key, JANET_NIL)) j++;
-                        if (i) print_newline(S, len < JANET_PRETTY_DICT_ONELINE);
-                        janet_pretty_one(S, kvs[j].key, 0);
+                        if (i) print_newline(S, align);
+                        janet_pretty_one(S, kvs[j].key);
                         janet_buffer_push_u8(S->buffer, ' ');
-                        janet_pretty_one(S, kvs[j].value, 1);
+                        S->align++;
+                        janet_pretty_one(S, kvs[j].value);
                         j++;
                     }
                     if (truncated) {
-                        print_newline(S, 0);
+                        print_newline(S, align);
                         janet_buffer_push_cstring(S->buffer, "...");
+                        S->align += 3;
                     }
                 } else {
                     /* Sorted keys dictionaries */
@@ -685,24 +704,26 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                     }
 
                     for (int32_t i = 0; i < len; i++) {
-                        if (i) print_newline(S, len < JANET_PRETTY_DICT_ONELINE);
+                        if (i) print_newline(S, align);
                         int32_t j = S->keysort_buffer[i + ks_start];
-                        janet_pretty_one(S, kvs[j].key, 0);
+                        janet_pretty_one(S, kvs[j].key);
                         janet_buffer_push_u8(S->buffer, ' ');
-                        janet_pretty_one(S, kvs[j].value, 1);
+                        S->align++;
+                        janet_pretty_one(S, kvs[j].value);
                     }
 
                     if (truncated) {
-                        print_newline(S, 0);
+                        print_newline(S, align);
                         janet_buffer_push_cstring(S->buffer, "...");
+                        S->align += 3;
                     }
 
                 }
                 S->keysort_start = ks_start;
             }
-            S->indent -= 2;
             S->depth++;
             janet_buffer_push_u8(S->buffer, '}');
+            S->align++;
             break;
         }
     }
@@ -718,14 +739,14 @@ static JanetBuffer *janet_pretty_(JanetBuffer *buffer, int depth, int flags, Jan
     }
     S.buffer = buffer;
     S.depth = depth;
-    S.indent = 0;
+    S.align = 0;
     S.flags = flags;
     S.bufstartlen = startlen;
     S.keysort_capacity = 0;
     S.keysort_buffer = NULL;
     S.keysort_start = 0;
     janet_table_init(&S.seen, 10);
-    janet_pretty_one(&S, x, 0);
+    janet_pretty_one(&S, x);
     janet_table_deinit(&S.seen);
     return S.buffer;
 }
@@ -743,7 +764,7 @@ static JanetBuffer *janet_jdn_(JanetBuffer *buffer, int depth, Janet x, int32_t
     }
     S.buffer = buffer;
     S.depth = depth;
-    S.indent = 0;
+    S.align = 0;
     S.flags = 0;
     S.bufstartlen = startlen;
     S.keysort_capacity = 0;

src/core/util.h

@@ -213,7 +213,7 @@ typedef struct {
         OVERLAPPED overlapped;
         WSAOVERLAPPED wsaoverlapped;
     } as;
-    uint32_t bytes_transferred;
+    uint32_t bytes_transfered;
 } JanetOverlapped;
 #endif
 #endif

src/include/janet.h

@@ -1531,9 +1531,6 @@ JANET_API Janet janet_ev_lasterr(void);
  * We could just use a pointer but this prevents malloc/free in the common case
  * of only a handful of arguments. */
 typedef struct {
-#ifdef JANET_WINDOWS
-    char padding[48]; /* On windows, used for OVERLAPPED storage */
-#endif
     int tag;
     int argi;
     void *argp;

src/mainclient/shell.c

@@ -26,6 +26,7 @@
 
 #include <janet.h>
 #include <errno.h>
+#include <assert.h>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -362,33 +363,50 @@ static void clear(void) {
     }
 }
 
+static int getplen(void) {
+    int _plen = gbl_plen;
+    /* Ensure at least 16 characters of data entry; */
+    while (_plen && (_plen + 16 > gbl_cols)) {
+        _plen--;
+    }
+    return _plen;
+}
+
 static void refresh(void) {
     char seq[64];
     JanetBuffer b;
 
+    /* If prompt is too long, truncate */
+    int _plen = getplen();
+
     /* Keep cursor position on screen */
     char *_buf = gbl_buf;
     int _len = gbl_len;
     int _pos = gbl_pos;
-    while ((gbl_plen + _pos) >= gbl_cols) {
+
+    while ((_plen + _pos) >= gbl_cols) {
         _buf++;
         _len--;
         _pos--;
     }
-    while ((gbl_plen + _len) > gbl_cols) {
+
+    while ((_plen + _len) > gbl_cols) {
         _len--;
     }
 
+
     janet_buffer_init(&b, 0);
     /* Cursor to left edge, gbl_prompt and buffer */
     janet_buffer_push_u8(&b, '\r');
-    janet_buffer_push_cstring(&b, gbl_prompt);
-    janet_buffer_push_bytes(&b, (uint8_t *) _buf, _len);
+    janet_buffer_push_bytes(&b, (const uint8_t *) gbl_prompt, _plen);
+    if (_len > 0) {
+        janet_buffer_push_bytes(&b, (uint8_t *) _buf, _len);
+    }
     /* Erase to right */
     janet_buffer_push_cstring(&b, "\x1b[0K\r");
     /* Move cursor to original position. */
-    if (_pos + gbl_plen) {
-        snprintf(seq, 64, "\x1b[%dC", (int)(_pos + gbl_plen));
+    if (_pos + _plen) {
+        snprintf(seq, 64, "\x1b[%dC", (int)(_pos + _plen));
         janet_buffer_push_cstring(&b, seq);
     }
     if (write_console((char *) b.data, b.count) == -1) {
@@ -414,7 +432,8 @@ static int insert(char c, int draw) {
             gbl_buf[gbl_pos++] = c;
             gbl_buf[++gbl_len] = '\0';
             if (draw) {
-                if (gbl_plen + gbl_len < gbl_cols) {
+                int _plen = getplen();
+                if (_plen + gbl_len < gbl_cols) {
                     /* Avoid a full update of the line in the
                      * trivial case. */
                     if (write_console(&c, 1) == -1) return -1;
@@ -925,11 +944,12 @@ static int line() {
     gbl_len = 0;
     gbl_pos = 0;
     while (gbl_prompt[gbl_plen]) gbl_plen++;
+    int _plen = getplen();
     gbl_buf[0] = '\0';
 
     addhistory();
 
-    if (write_console((char *) gbl_prompt, gbl_plen) == -1) return -1;
+    if (write_console((char *) gbl_prompt, _plen) == -1) return -1;
     for (;;) {
         char c;
         char seq[5];

test/suite-io.janet

@@ -55,8 +55,7 @@
   (file/flush f)
   (file/seek f :set 0)
   (assert (= 0 (file/tell f)) "start of file again")
-  (assert (= (string (file/read f :all)) "foo\n") "temp files work")
-  (assert-no-error "fsync" (file/sync f)))
+  (assert (= (string (file/read f :all)) "foo\n") "temp files work"))
 
 # issue #1055 - 2c927ea76
 (let [b @""]
@@ -75,13 +74,9 @@
 (defn to-b [a] (buffer/push b a))
 (xprintf to-b "123")
 (assert (deep= b @"123\n") "xprintf to buffer")
-(assert-error "cannot print to 3" (xprintf 3 "123"))
 
-# file/sync
-(with [f (file/temp)]
-  (file/write f "123abc")
-  (file/flush f)
-  (file/sync f))
+
+(assert-error "cannot print to 3" (xprintf 3 "123"))
 
 (end-suite)
 

test/suite-pp.janet

@@ -61,5 +61,68 @@
 (check-jdn "a string")
 (check-jdn @"a buffer")
 
+# Test multiline pretty specifiers
+(let [tup [:keyword "string" @"buffer"]
+      tab @{true (table/setproto @{:bar tup
+                                   :baz 42}
+                                 @{:_name "Foo"})}]
+  (set (tab tup) tab)
+  (assert (= (string/format "%m" {tup @[tup tab]
+                                  'symbol tup})
+          `
+{symbol (:keyword
+         "string"
+         @"buffer")
+ (:keyword
+  "string"
+  @"buffer") @[(:keyword
+                "string"
+                @"buffer")
+               @{true @Foo{:bar (:keyword
+                                 "string"
+                                 @"buffer")
+                           :baz 42}
+                 (:keyword
+                  "string"
+                  @"buffer") <cycle 2>}]}`))
+  (assert (= (string/format "%p" {(freeze (zipcoll (range 42)
+                                                   (range -42 0))) tab})
+             `
+{{0 -42
+  1 -41
+  2 -40
+  3 -39
+  4 -38
+  5 -37
+  6 -36
+  7 -35
+  8 -34
+  9 -33
+  10 -32
+  11 -31
+  12 -30
+  13 -29
+  14 -28
+  15 -27
+  16 -26
+  17 -25
+  18 -24
+  19 -23
+  20 -22
+  21 -21
+  22 -20
+  23 -19
+  24 -18
+  25 -17
+  26 -16
+  27 -15
+  28 -14
+  29 -13
+  ...} @{true @Foo{:bar (:keyword
+                         "string"
+                         @"buffer")
+                   :baz 42}
+         (:keyword
+          "string"
+          @"buffer") <cycle 1>}}`)))
 (end-suite)
-