Distinguish between subprocess when testing.

This reverts commit 566b45ea44.

Makefile

@@ -308,7 +308,7 @@ build/janet.pc: $(JANET_TARGET)
 install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc build/janet.h
 	mkdir -p '$(DESTDIR)$(BINDIR)'
 	cp $(JANET_TARGET) '$(DESTDIR)$(BINDIR)/janet'
-	strip -x -S '$(DESTDIR)$(BINDIR)/janet'
+	strip '$(DESTDIR)$(BINDIR)/janet'
 	mkdir -p '$(DESTDIR)$(INCLUDEDIR)/janet'
 	cp -r build/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet'
 	ln -sf ./janet/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet.h'
@@ -357,7 +357,7 @@ uninstall:
 #################
 
 format:
-	sh tools/format.sh
+	tools/format.sh
 
 grammar: build/janet.tmLanguage
 build/janet.tmLanguage: tools/tm_lang_gen.janet $(JANET_TARGET)

src/boot/boot.janet

@@ -151,7 +151,7 @@
 (defmacro -= "Decrements the var x by n." [x & ns] ~(set ,x (,- ,x ,;ns)))
 (defmacro *= "Shorthand for (set x (\\* x n))." [x & ns] ~(set ,x (,* ,x ,;ns)))
 (defmacro /= "Shorthand for (set x (/ x n))." [x & ns] ~(set ,x (,/ ,x ,;ns)))
-(defmacro %= "Shorthand for (set x (% x n))." [x & ns] ~(set ,x (,% ,x ,;ns)))
+(defmacro %= "Shorthand for (set x (% x n))." [x n] ~(set ,x (,% ,x ,n)))
 
 (defmacro assert
   "Throw an error if x is not truthy. Will not evaluate `err` if x is truthy."

src/core/asm.c

@@ -75,7 +75,6 @@ static const JanetInstructionDef janet_ops[] = {
     {"cmp", JOP_COMPARE},
     {"cncl", JOP_CANCEL},
     {"div", JOP_DIVIDE},
-    {"divf", JOP_DIVIDE_FLOOR},
     {"divim", JOP_DIVIDE_IMMEDIATE},
     {"eq", JOP_EQUALS},
     {"eqim", JOP_EQUALS_IMMEDIATE},

src/core/bytecode.c

@@ -42,7 +42,6 @@ enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT] = {
     JINT_SSS, /* JOP_MULTIPLY, */
     JINT_SSI, /* JOP_DIVIDE_IMMEDIATE, */
     JINT_SSS, /* JOP_DIVIDE, */
-    JINT_SSS, /* JOP_DIVIDE_FLOOR */
     JINT_SSS, /* JOP_MODULO, */
     JINT_SSS, /* JOP_REMAINDER, */
     JINT_SSS, /* JOP_BAND, */
@@ -302,7 +301,6 @@ void janet_bytecode_movopt(JanetFuncDef *def) {
                 case JOP_SUBTRACT:
                 case JOP_MULTIPLY:
                 case JOP_DIVIDE:
-                case JOP_DIVIDE_FLOOR:
                 case JOP_MODULO:
                 case JOP_REMAINDER:
                 case JOP_SHIFT_LEFT:

src/core/capi.c

@@ -216,32 +216,12 @@ const char *janet_getcstring(const Janet *argv, int32_t n) {
 }
 
 const char *janet_getcbytes(const Janet *argv, int32_t n) {
-    /* Ensure buffer 0-padded */
-    if (janet_checktype(argv[n], JANET_BUFFER)) {
-        JanetBuffer *b = janet_unwrap_buffer(argv[n]);
-        if ((b->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) && b->count == b->capacity) {
-            /* Make a copy with janet_smalloc in the rare case we have a buffer that
-             * cannot be realloced and pushing a 0 byte would panic. */
-            char *new_string = janet_smalloc(b->count + 1);
-            memcpy(new_string, b->data, b->count);
-            new_string[b->count] = 0;
-            if (strlen(new_string) != (size_t) b->count) goto badzeros;
-            return new_string;
-        } else {
-            /* Ensure trailing 0 */
-            janet_buffer_push_u8(b, 0);
-            b->count--;
-            if (strlen((char *)b->data) != (size_t) b->count) goto badzeros;
-            return (const char *) b->data;
-        }
-    }
     JanetByteView view = janet_getbytes(argv, n);
     const char *cstr = (const char *)view.bytes;
-    if (strlen(cstr) != (size_t) view.len) goto badzeros;
+    if (strlen(cstr) != (size_t) view.len) {
+        janet_panic("bytes contain embedded 0s");
+    }
     return cstr;
-
-badzeros:
-    janet_panic("bytes contain embedded 0s");
 }
 
 const char *janet_optcbytes(const Janet *argv, int32_t argc, int32_t n, const char *dflt) {

src/core/cfuns.c

@@ -116,8 +116,7 @@ static JanetSlot opreduce(
     JanetSlot *args,
     int op,
     int opim,
-    Janet nullary,
-    Janet unary) {
+    Janet nullary) {
     JanetCompiler *c = opts.compiler;
     int32_t i, len;
     int8_t imm = 0;
@@ -133,7 +132,7 @@ static JanetSlot opreduce(
         if (op == JOP_SUBTRACT) {
             janetc_emit_ssi(c, JOP_MULTIPLY_IMMEDIATE, t, args[0], -1, 1);
         } else {
-            janetc_emit_sss(c, op, t, janetc_cslot(unary), args[0], 1);
+            janetc_emit_sss(c, op, t, janetc_cslot(nullary), args[0], 1);
         }
         return t;
     }
@@ -156,7 +155,7 @@ static JanetSlot opreduce(
 /* Function optimizers */
 
 static JanetSlot do_propagate(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_PROPAGATE, 0, janet_wrap_nil(), janet_wrap_nil());
+    return opreduce(opts, args, JOP_PROPAGATE, 0, janet_wrap_nil());
 }
 static JanetSlot do_error(JanetFopts opts, JanetSlot *args) {
     janetc_emit_s(opts.compiler, JOP_ERROR, args[0], 0);
@@ -173,7 +172,7 @@ static JanetSlot do_debug(JanetFopts opts, JanetSlot *args) {
     return t;
 }
 static JanetSlot do_in(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_IN, 0, janet_wrap_nil(), janet_wrap_nil());
+    return opreduce(opts, args, JOP_IN, 0, janet_wrap_nil());
 }
 static JanetSlot do_get(JanetFopts opts, JanetSlot *args) {
     if (janet_v_count(args) == 3) {
@@ -193,14 +192,20 @@ static JanetSlot do_get(JanetFopts opts, JanetSlot *args) {
         c->buffer[label] |= (current - label) << 16;
         return t;
     } else {
-        return opreduce(opts, args, JOP_GET, 0, janet_wrap_nil(), janet_wrap_nil());
+        return opreduce(opts, args, JOP_GET, 0, janet_wrap_nil());
     }
 }
 static JanetSlot do_next(JanetFopts opts, JanetSlot *args) {
     return opfunction(opts, args, JOP_NEXT, janet_wrap_nil());
 }
+static JanetSlot do_modulo(JanetFopts opts, JanetSlot *args) {
+    return opreduce(opts, args, JOP_MODULO, 0, janet_wrap_nil());
+}
+static JanetSlot do_remainder(JanetFopts opts, JanetSlot *args) {
+    return opreduce(opts, args, JOP_REMAINDER, 0, janet_wrap_nil());
+}
 static JanetSlot do_cmp(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_COMPARE, 0, janet_wrap_nil(), janet_wrap_nil());
+    return opreduce(opts, args, JOP_COMPARE, 0, janet_wrap_nil());
 }
 static JanetSlot do_put(JanetFopts opts, JanetSlot *args) {
     if (opts.flags & JANET_FOPTS_DROP) {
@@ -257,43 +262,34 @@ static JanetSlot do_apply(JanetFopts opts, JanetSlot *args) {
 /* Variadic operators specialization */
 
 static JanetSlot do_add(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_ADD, JOP_ADD_IMMEDIATE, janet_wrap_integer(0), janet_wrap_integer(0));
+    return opreduce(opts, args, JOP_ADD, JOP_ADD_IMMEDIATE, janet_wrap_integer(0));
 }
 static JanetSlot do_sub(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_SUBTRACT, -JOP_ADD_IMMEDIATE, janet_wrap_integer(0), janet_wrap_integer(0));
+    return opreduce(opts, args, JOP_SUBTRACT, -JOP_ADD_IMMEDIATE, janet_wrap_integer(0));
 }
 static JanetSlot do_mul(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_MULTIPLY, JOP_MULTIPLY_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_MULTIPLY, JOP_MULTIPLY_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_div(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_DIVIDE, JOP_DIVIDE_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1));
-}
-static JanetSlot do_divf(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_DIVIDE_FLOOR, 0, janet_wrap_integer(1), janet_wrap_integer(1));
-}
-static JanetSlot do_modulo(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_MODULO, 0, janet_wrap_integer(0), janet_wrap_integer(1));
-}
-static JanetSlot do_remainder(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_REMAINDER, 0, janet_wrap_integer(0), janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_DIVIDE, JOP_DIVIDE_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_band(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_BAND, 0, janet_wrap_integer(-1), janet_wrap_integer(-1));
+    return opreduce(opts, args, JOP_BAND, 0, janet_wrap_integer(-1));
 }
 static JanetSlot do_bor(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_BOR, 0, janet_wrap_integer(0), janet_wrap_integer(0));
+    return opreduce(opts, args, JOP_BOR, 0, janet_wrap_integer(0));
 }
 static JanetSlot do_bxor(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_BXOR, 0, janet_wrap_integer(0), janet_wrap_integer(0));
+    return opreduce(opts, args, JOP_BXOR, 0, janet_wrap_integer(0));
 }
 static JanetSlot do_lshift(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_SHIFT_LEFT, JOP_SHIFT_LEFT_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_SHIFT_LEFT, JOP_SHIFT_LEFT_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_rshift(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_SHIFT_RIGHT, JOP_SHIFT_RIGHT_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_SHIFT_RIGHT, JOP_SHIFT_RIGHT_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_rshiftu(JanetFopts opts, JanetSlot *args) {
-    return opreduce(opts, args, JOP_SHIFT_RIGHT_UNSIGNED, JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1));
+    return opreduce(opts, args, JOP_SHIFT_RIGHT_UNSIGNED, JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE, janet_wrap_integer(1));
 }
 static JanetSlot do_bnot(JanetFopts opts, JanetSlot *args) {
     return genericSS(opts, JOP_BNOT, args[0]);
@@ -387,11 +383,10 @@ static const JanetFunOptimizer optimizers[] = {
     {fixarity2, do_propagate},
     {arity2or3, do_get},
     {arity1or2, do_next},
-    {NULL, do_modulo},
-    {NULL, do_remainder},
+    {fixarity2, do_modulo},
+    {fixarity2, do_remainder},
     {fixarity2, do_cmp},
     {fixarity2, do_cancel},
-    {NULL, do_divf}
 };
 
 const JanetFunOptimizer *janetc_funopt(uint32_t flags) {

src/core/compile.h

@@ -69,7 +69,6 @@ typedef enum {
 #define JANET_FUN_REMAINDER 30
 #define JANET_FUN_CMP 31
 #define JANET_FUN_CANCEL 32
-#define JANET_FUN_DIVIDE_FLOOR 33
 
 /* Compiler typedefs */
 typedef struct JanetCompiler JanetCompiler;

src/core/corelib.c

@@ -985,6 +985,14 @@ static const uint32_t next_asm[] = {
     JOP_NEXT | (1 << 24),
     JOP_RETURN
 };
+static const uint32_t modulo_asm[] = {
+    JOP_MODULO | (1 << 24),
+    JOP_RETURN
+};
+static const uint32_t remainder_asm[] = {
+    JOP_REMAINDER | (1 << 24),
+    JOP_RETURN
+};
 static const uint32_t cmp_asm[] = {
     JOP_COMPARE | (1 << 24),
     JOP_RETURN
@@ -1069,6 +1077,14 @@ static void janet_load_libs(JanetTable *env) {
 
 JanetTable *janet_core_env(JanetTable *replacements) {
     JanetTable *env = (NULL != replacements) ? replacements : janet_table(0);
+    janet_quick_asm(env, JANET_FUN_MODULO,
+                    "mod", 2, 2, 2, 2, modulo_asm, sizeof(modulo_asm),
+                    JDOC("(mod dividend divisor)\n\n"
+                         "Returns the modulo of dividend / divisor."));
+    janet_quick_asm(env, JANET_FUN_REMAINDER,
+                    "%", 2, 2, 2, 2, remainder_asm, sizeof(remainder_asm),
+                    JDOC("(% dividend divisor)\n\n"
+                         "Returns the remainder of dividend / divisor."));
     janet_quick_asm(env, JANET_FUN_CMP,
                     "cmp", 2, 2, 2, 2, cmp_asm, sizeof(cmp_asm),
                     JDOC("(cmp x y)\n\n"
@@ -1167,18 +1183,6 @@ JanetTable *janet_core_env(JanetTable *replacements) {
                           "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns "
                           "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
                           "values."));
-    templatize_varop(env, JANET_FUN_DIVIDE_FLOOR, "div", 1, 1, JOP_DIVIDE_FLOOR,
-                     JDOC("(div & xs)\n\n"
-                          "Returns the floored division of xs. If xs is empty, returns 1. If xs has one value x, returns "
-                          "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
-                          "values."));
-    templatize_varop(env, JANET_FUN_MODULO, "mod", 0, 1, JOP_MODULO,
-                     JDOC("(mod & xs)\n\n"
-                         "Returns the result of applying the modulo operator on the first value of xs with each remaining value. "
-                         "`(mod x 0)` is defined to be `x`."));
-    templatize_varop(env, JANET_FUN_REMAINDER, "%", 0, 1, JOP_REMAINDER,
-                     JDOC("(% & xs)\n\n"
-                         "Returns the remainder of dividing the first value of xs by each remaining value."));
     templatize_varop(env, JANET_FUN_BAND, "band", -1, -1, JOP_BAND,
                      JDOC("(band & xs)\n\n"
                           "Returns the bit-wise and of all values in xs. Each x in xs must be an integer."));

src/core/ev.c

@@ -405,7 +405,7 @@ static void janet_stream_marshal(void *p, JanetMarshalContext *ctx) {
 #ifdef JANET_WINDOWS
     /* TODO - ref counting to avoid situation where a handle is closed or GCed
      * while in transit, and it's value gets reused. DuplicateHandle does not work
-     * for network sockets, and in general for winsock it is better to not duplicate
+     * for network sockets, and in general for winsock it is better to nipt duplicate
      * unless there is a need to. */
     HANDLE duph = INVALID_HANDLE_VALUE;
     if (s->flags & JANET_STREAM_SOCKET) {
@@ -1224,7 +1224,6 @@ static Janet janet_chanat_next(void *p, Janet key) {
 
 static void janet_chanat_marshal(void *p, JanetMarshalContext *ctx) {
     JanetChannel *channel = (JanetChannel *)p;
-    janet_marshal_abstract(ctx, channel);
     janet_marshal_byte(ctx, channel->closed);
     janet_marshal_int(ctx, channel->limit);
     int32_t count = janet_q_count(&channel->items);

src/core/ffi.c

@@ -1530,22 +1530,6 @@ JANET_CORE_FN(cfun_ffi_pointer_buffer,
     return janet_wrap_buffer(janet_pointer_buffer_unsafe(offset_pointer, capacity, count));
 }
 
-JANET_CORE_FN(cfun_ffi_pointer_cfunction,
-              "(ffi/pointer-cfunction pointer &opt name source-file source-line)",
-              "Create a C Function from a raw pointer. Optionally give the cfunction a name and "
-              "source location for stack traces and debugging.") {
-    janet_sandbox_assert(JANET_SANDBOX_FFI_USE);
-    janet_arity(argc, 1, 4);
-    void *pointer = janet_getpointer(argv, 0);
-    const char *name = janet_optcstring(argv, argc, 1, NULL);
-    const char *source = janet_optcstring(argv, argc, 2, NULL);
-    int32_t line = janet_optinteger(argv, argc, 3, -1);
-    if ((name != NULL) || (source != NULL) || (line != -1)) {
-        janet_registry_put((JanetCFunction) pointer, name, NULL, source, line);
-    }
-    return janet_wrap_cfunction((JanetCFunction) pointer);
-}
-
 JANET_CORE_FN(cfun_ffi_supported_calling_conventions,
               "(ffi/calling-conventions)",
               "Get an array of all supported calling conventions on the current arhcitecture. Some architectures may have some FFI "
@@ -1583,7 +1567,6 @@ void janet_lib_ffi(JanetTable *env) {
         JANET_CORE_REG("ffi/malloc", cfun_ffi_malloc),
         JANET_CORE_REG("ffi/free", cfun_ffi_free),
         JANET_CORE_REG("ffi/pointer-buffer", cfun_ffi_pointer_buffer),
-        JANET_CORE_REG("ffi/pointer-cfunction", cfun_ffi_pointer_cfunction),
         JANET_CORE_REG("ffi/calling-conventions", cfun_ffi_supported_calling_conventions),
         JANET_REG_END
     };

src/core/inttypes.c

@@ -431,7 +431,7 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
 } \
 
 #define OPMETHODINVERT(T, type, name, oper) \
-static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     janet_fixarity(argc, 2); \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[1]); \
@@ -440,19 +440,6 @@ static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
     return janet_wrap_abstract(box); \
 } \
 
-#define UNARYMETHOD(T, type, name, oper) \
-static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
-    janet_fixarity(argc, 1); \
-    T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
-    *box = oper(janet_unwrap_##type(argv[0])); \
-    return janet_wrap_abstract(box); \
-} \
-
-#define DIVZERO(name) DIVZERO_##name
-#define DIVZERO_div janet_panic("division by zero")
-#define DIVZERO_rem janet_panic("division by zero")
-#define DIVZERO_mod return janet_wrap_abstract(box)
-
 #define DIVMETHOD(T, type, name, oper) \
 static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     janet_arity(argc, 2, -1);                       \
@@ -460,19 +447,19 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     *box = janet_unwrap_##type(argv[0]); \
     for (int32_t i = 1; i < argc; i++) { \
       T value = janet_unwrap_##type(argv[i]); \
-      if (value == 0) DIVZERO(name); \
+      if (value == 0) janet_panic("division by zero"); \
       *box oper##= value; \
     } \
     return janet_wrap_abstract(box); \
 } \
 
 #define DIVMETHODINVERT(T, type, name, oper) \
-static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     janet_fixarity(argc, 2);                       \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[1]); \
     T value = janet_unwrap_##type(argv[0]); \
-    if (value == 0) DIVZERO(name); \
+    if (value == 0) janet_panic("division by zero"); \
     *box oper##= value; \
     return janet_wrap_abstract(box); \
 } \
@@ -484,7 +471,7 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     *box = janet_unwrap_##type(argv[0]); \
     for (int32_t i = 1; i < argc; i++) { \
       T value = janet_unwrap_##type(argv[i]); \
-      if (value == 0) DIVZERO(name); \
+      if (value == 0) janet_panic("division by zero"); \
       if ((value == -1) && (*box == INT64_MIN)) janet_panic("INT64_MIN divided by -1"); \
       *box oper##= value; \
     } \
@@ -492,50 +479,26 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
 } \
 
 #define DIVMETHODINVERT_SIGNED(T, type, name, oper) \
-static Janet cfun_it_##type##_##name##i(int32_t argc, Janet *argv) { \
+static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
     janet_fixarity(argc, 2);                       \
     T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
     *box = janet_unwrap_##type(argv[1]); \
     T value = janet_unwrap_##type(argv[0]); \
-    if (value == 0) DIVZERO(name); \
+    if (value == 0) janet_panic("division by zero"); \
     if ((value == -1) && (*box == INT64_MIN)) janet_panic("INT64_MIN divided by -1"); \
     *box oper##= value; \
     return janet_wrap_abstract(box); \
 } \
 
-static Janet cfun_it_s64_divf(int32_t argc, Janet *argv) {
-    janet_fixarity(argc, 2);
-    int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
-    int64_t op1 = janet_unwrap_s64(argv[0]);
-    int64_t op2 = janet_unwrap_s64(argv[1]);
-    if (op2 == 0) janet_panic("division by zero");
-    int64_t x = op1 / op2;
-    *box = x - (((op1 ^ op2) < 0) && (x * op2 != op1));
-    return janet_wrap_abstract(box);
-}
-
-static Janet cfun_it_s64_divfi(int32_t argc, Janet *argv) {
-    janet_fixarity(argc, 2);
-    int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
-    int64_t op2 = janet_unwrap_s64(argv[0]);
-    int64_t op1 = janet_unwrap_s64(argv[1]);
-    if (op2 == 0) janet_panic("division by zero");
-    int64_t x = op1 / op2;
-    *box = x - (((op1 ^ op2) < 0) && (x * op2 != op1));
-    return janet_wrap_abstract(box);
-}
-
 static Janet cfun_it_s64_mod(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
     int64_t op1 = janet_unwrap_s64(argv[0]);
     int64_t op2 = janet_unwrap_s64(argv[1]);
-    if (op2 == 0) {
-        *box = op1;
-    } else {
-        int64_t x = op1 % op2;
-        *box = (((op1 ^ op2) < 0) && (x != 0)) ? x + op2 : x;
-    }
+    int64_t x = op1 % op2;
+    *box = (op1 > 0)
+           ? ((op2 > 0) ? x : (0 == x ? x : x + op2))
+           : ((op2 > 0) ? (0 == x ? x : x + op2) : x);
     return janet_wrap_abstract(box);
 }
 
@@ -544,43 +507,37 @@ static Janet cfun_it_s64_modi(int32_t argc, Janet *argv) {
     int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
     int64_t op2 = janet_unwrap_s64(argv[0]);
     int64_t op1 = janet_unwrap_s64(argv[1]);
-    if (op2 == 0) {
-        *box = op1;
-    } else {
-        int64_t x = op1 % op2;
-        *box = (((op1 ^ op2) < 0) && (x != 0)) ? x + op2 : x;
-    }
+    int64_t x = op1 % op2;
+    *box = (op1 > 0)
+           ? ((op2 > 0) ? x : (0 == x ? x : x + op2))
+           : ((op2 > 0) ? (0 == x ? x : x + op2) : x);
     return janet_wrap_abstract(box);
 }
 
 OPMETHOD(int64_t, s64, add, +)
 OPMETHOD(int64_t, s64, sub, -)
-OPMETHODINVERT(int64_t, s64, sub, -)
+OPMETHODINVERT(int64_t, s64, subi, -)
 OPMETHOD(int64_t, s64, mul, *)
 DIVMETHOD_SIGNED(int64_t, s64, div, /)
 DIVMETHOD_SIGNED(int64_t, s64, rem, %)
-DIVMETHODINVERT_SIGNED(int64_t, s64, div, /)
-DIVMETHODINVERT_SIGNED(int64_t, s64, rem, %)
+DIVMETHODINVERT_SIGNED(int64_t, s64, divi, /)
+DIVMETHODINVERT_SIGNED(int64_t, s64, remi, %)
 OPMETHOD(int64_t, s64, and, &)
 OPMETHOD(int64_t, s64, or, |)
 OPMETHOD(int64_t, s64, xor, ^)
-UNARYMETHOD(int64_t, s64, not, ~)
 OPMETHOD(int64_t, s64, lshift, <<)
 OPMETHOD(int64_t, s64, rshift, >>)
 OPMETHOD(uint64_t, u64, add, +)
 OPMETHOD(uint64_t, u64, sub, -)
-OPMETHODINVERT(uint64_t, u64, sub, -)
+OPMETHODINVERT(uint64_t, u64, subi, -)
 OPMETHOD(uint64_t, u64, mul, *)
 DIVMETHOD(uint64_t, u64, div, /)
-DIVMETHOD(uint64_t, u64, rem, %)
 DIVMETHOD(uint64_t, u64, mod, %)
-DIVMETHODINVERT(uint64_t, u64, div, /)
-DIVMETHODINVERT(uint64_t, u64, rem, %)
-DIVMETHODINVERT(uint64_t, u64, mod, %)
+DIVMETHODINVERT(uint64_t, u64, divi, /)
+DIVMETHODINVERT(uint64_t, u64, modi, %)
 OPMETHOD(uint64_t, u64, and, &)
 OPMETHOD(uint64_t, u64, or, |)
 OPMETHOD(uint64_t, u64, xor, ^)
-UNARYMETHOD(uint64_t, u64, not, ~)
 OPMETHOD(uint64_t, u64, lshift, <<)
 OPMETHOD(uint64_t, u64, rshift, >>)
 
@@ -598,8 +555,6 @@ static JanetMethod it_s64_methods[] = {
     {"r*", cfun_it_s64_mul},
     {"/", cfun_it_s64_div},
     {"r/", cfun_it_s64_divi},
-    {"div", cfun_it_s64_divf},
-    {"rdiv", cfun_it_s64_divfi},
     {"mod", cfun_it_s64_mod},
     {"rmod", cfun_it_s64_modi},
     {"%", cfun_it_s64_rem},
@@ -610,7 +565,6 @@ static JanetMethod it_s64_methods[] = {
     {"r|", cfun_it_s64_or},
     {"^", cfun_it_s64_xor},
     {"r^", cfun_it_s64_xor},
-    {"~", cfun_it_s64_not},
     {"<<", cfun_it_s64_lshift},
     {">>", cfun_it_s64_rshift},
     {"compare", cfun_it_s64_compare},
@@ -626,19 +580,16 @@ static JanetMethod it_u64_methods[] = {
     {"r*", cfun_it_u64_mul},
     {"/", cfun_it_u64_div},
     {"r/", cfun_it_u64_divi},
-    {"div", cfun_it_u64_div},
-    {"rdiv", cfun_it_u64_divi},
     {"mod", cfun_it_u64_mod},
     {"rmod", cfun_it_u64_modi},
-    {"%", cfun_it_u64_rem},
-    {"r%", cfun_it_u64_remi},
+    {"%", cfun_it_u64_mod},
+    {"r%", cfun_it_u64_modi},
     {"&", cfun_it_u64_and},
     {"r&", cfun_it_u64_and},
     {"|", cfun_it_u64_or},
     {"r|", cfun_it_u64_or},
     {"^", cfun_it_u64_xor},
     {"r^", cfun_it_u64_xor},
-    {"~", cfun_it_u64_not},
     {"<<", cfun_it_u64_lshift},
     {">>", cfun_it_u64_rshift},
     {"compare", cfun_it_u64_compare},

src/core/marsh.c

@@ -154,7 +154,7 @@ static void pushbytes(MarshalState *st, const uint8_t *bytes, int32_t len) {
     janet_buffer_push_bytes(st->buf, bytes, len);
 }
 
-static void pushpointer(MarshalState *st, const void *ptr) {
+static void pushpointer(MarshalState *st, void *ptr) {
     janet_buffer_push_bytes(st->buf, (const uint8_t *) &ptr, sizeof(ptr));
 }
 
@@ -246,7 +246,6 @@ static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags) {
     }
     /* Add to lookup */
     janet_v_push(st->seen_defs, def);
-
     pushint(st, def->flags);
     pushint(st, def->slotcount);
     pushint(st, def->arity);
@@ -267,14 +266,14 @@ static void marshal_one_def(MarshalState *st, JanetFuncDef *def, int flags) {
 
     /* marshal constants */
     for (int32_t i = 0; i < def->constants_length; i++)
-        marshal_one(st, def->constants[i], flags + 1);
+        marshal_one(st, def->constants[i], flags);
 
     /* Marshal symbol map, if needed */
     for (int32_t i = 0; i < def->symbolmap_length; i++) {
         pushint(st, (int32_t) def->symbolmap[i].birth_pc);
         pushint(st, (int32_t) def->symbolmap[i].death_pc);
         pushint(st, (int32_t) def->symbolmap[i].slot_index);
-        marshal_one(st, janet_wrap_symbol(def->symbolmap[i].symbol), flags + 1);
+        marshal_one(st, janet_wrap_symbol(def->symbolmap[i].symbol), flags);
     }
 
     /* marshal the bytecode */
@@ -365,11 +364,11 @@ void janet_marshal_int(JanetMarshalContext *ctx, int32_t value) {
 
 /* Only use in unsafe - don't marshal pointers otherwise */
 void janet_marshal_ptr(JanetMarshalContext *ctx, const void *ptr) {
-    if (!(ctx->flags & JANET_MARSHAL_UNSAFE)) {
-        janet_panic("can only marshal pointers in unsafe mode");
-    }
-    MarshalState *st = (MarshalState *)(ctx->m_state);
-    pushpointer(st, ptr);
+#ifdef JANET_32
+    janet_marshal_int(ctx, (intptr_t) ptr);
+#else
+    janet_marshal_int64(ctx, (intptr_t) ptr);
+#endif
 }
 
 void janet_marshal_byte(JanetMarshalContext *ctx, uint8_t value) {
@@ -388,27 +387,18 @@ void janet_marshal_janet(JanetMarshalContext *ctx, Janet x) {
     marshal_one(st, x, ctx->flags + 1);
 }
 
-#ifdef JANET_MARSHAL_DEBUG
-#define MARK_SEEN() \
-    do { if (st->maybe_cycles) { \
-        Janet _check = janet_table_get(&st->seen, x); \
-        if (!janet_checktype(_check, JANET_NIL)) janet_eprintf("double MARK_SEEN on %v\n", x); \
-        janet_eprintf("made reference %d (%t) to %v\n", st->nextid, x, x); \
-        janet_table_put(&st->seen, x, janet_wrap_integer(st->nextid++)); \
-    } } while (0)
-#else
-#define MARK_SEEN() \
-    do { if (st->maybe_cycles) { \
-        janet_table_put(&st->seen, x, janet_wrap_integer(st->nextid++)); \
-    } } while (0)
-#endif
-
 void janet_marshal_abstract(JanetMarshalContext *ctx, void *abstract) {
     MarshalState *st = (MarshalState *)(ctx->m_state);
-    Janet x = janet_wrap_abstract(abstract);
-    MARK_SEEN();
+    if (st->maybe_cycles) {
+        janet_table_put(&st->seen,
+                        janet_wrap_abstract(abstract),
+                        janet_wrap_integer(st->nextid++));
+    }
 }
 
+#define MARK_SEEN() \
+    do { if (st->maybe_cycles) janet_table_put(&st->seen, x, janet_wrap_integer(st->nextid++)); } while (0)
+
 static void marshal_one_abstract(MarshalState *st, Janet x, int flags) {
     void *abstract = janet_unwrap_abstract(x);
 #ifdef JANET_EV
@@ -430,7 +420,7 @@ static void marshal_one_abstract(MarshalState *st, Janet x, int flags) {
     if (at->marshal) {
         pushbyte(st, LB_ABSTRACT);
         marshal_one(st, janet_csymbolv(at->name), flags + 1);
-        JanetMarshalContext context = {st, NULL, flags + 1, NULL, at};
+        JanetMarshalContext context = {st, NULL, flags, NULL, at};
         at->marshal(abstract, &context);
     } else {
         janet_panicf("cannot marshal %p", x);
@@ -747,22 +737,9 @@ static uint64_t read64(UnmarshalState *st, const uint8_t **atdata) {
     return ret;
 }
 
-#ifdef JANET_MARSHAL_DEBUG
-static void dump_reference_table(UnmarshalState *st) {
-    for (int32_t i = 0; i < janet_v_count(st->lookup); i++) {
-        janet_eprintf("  reference %d (%t) = %v\n", i, st->lookup[i], st->lookup[i]);
-    }
-}
-#endif
-
 /* Assert a janet type */
-static void janet_asserttype(Janet x, JanetType t, UnmarshalState *st) {
+static void janet_asserttype(Janet x, JanetType t) {
     if (!janet_checktype(x, t)) {
-#ifdef JANET_MARSHAL_DEBUG
-        dump_reference_table(st);
-#else
-        (void) st;
-#endif
         janet_panicf("expected type %T, got %v", 1 << t, x);
     }
 }
@@ -814,7 +791,7 @@ static const uint8_t *unmarshal_one_env(
             Janet fiberv;
             /* On stack variant */
             data = unmarshal_one(st, data, &fiberv, flags);
-            janet_asserttype(fiberv, JANET_FIBER, st);
+            janet_asserttype(fiberv, JANET_FIBER);
             env->as.fiber = janet_unwrap_fiber(fiberv);
             /* Negative offset indicates untrusted input */
             env->offset = -offset;
@@ -912,13 +889,13 @@ static const uint8_t *unmarshal_one_def(
         if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) {
             Janet x;
             data = unmarshal_one(st, data, &x, flags + 1);
-            janet_asserttype(x, JANET_STRING, st);
+            janet_asserttype(x, JANET_STRING);
             def->name = janet_unwrap_string(x);
         }
         if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) {
             Janet x;
             data = unmarshal_one(st, data, &x, flags + 1);
-            janet_asserttype(x, JANET_STRING, st);
+            janet_asserttype(x, JANET_STRING);
             def->source = janet_unwrap_string(x);
         }
 
@@ -948,9 +925,8 @@ static const uint8_t *unmarshal_one_def(
                 def->symbolmap[i].slot_index = (uint32_t) readint(st, &data);
                 Janet value;
                 data = unmarshal_one(st, data, &value, flags + 1);
-                if (!janet_checktype(value, JANET_SYMBOL)) {
-                    janet_panicf("corrupted symbolmap when unmarshalling debug info, got %v", value);
-                }
+                if (!janet_checktype(value, JANET_SYMBOL))
+                    janet_panic("expected symbol in symbol map");
                 def->symbolmap[i].symbol = janet_unwrap_symbol(value);
             }
             def->symbolmap_length = (uint32_t) symbolmap_length;
@@ -1099,7 +1075,7 @@ static const uint8_t *unmarshal_one_fiber(
         /* Get function */
         Janet funcv;
         data = unmarshal_one(st, data, &funcv, flags + 1);
-        janet_asserttype(funcv, JANET_FUNCTION, st);
+        janet_asserttype(funcv, JANET_FUNCTION);
         func = janet_unwrap_function(funcv);
         def = func->def;
 
@@ -1145,7 +1121,7 @@ static const uint8_t *unmarshal_one_fiber(
         Janet envv;
         fiber_flags &= ~JANET_FIBER_FLAG_HASENV;
         data = unmarshal_one(st, data, &envv, flags + 1);
-        janet_asserttype(envv, JANET_TABLE, st);
+        janet_asserttype(envv, JANET_TABLE);
         fiber_env = janet_unwrap_table(envv);
     }
 
@@ -1154,7 +1130,7 @@ static const uint8_t *unmarshal_one_fiber(
         Janet fiberv;
         fiber_flags &= ~JANET_FIBER_FLAG_HASCHILD;
         data = unmarshal_one(st, data, &fiberv, flags + 1);
-        janet_asserttype(fiberv, JANET_FIBER, st);
+        janet_asserttype(fiberv, JANET_FIBER);
         fiber->child = janet_unwrap_fiber(fiberv);
     }
 
@@ -1199,15 +1175,12 @@ int64_t janet_unmarshal_int64(JanetMarshalContext *ctx) {
 }
 
 void *janet_unmarshal_ptr(JanetMarshalContext *ctx) {
-    if (!(ctx->flags & JANET_MARSHAL_UNSAFE)) {
-        janet_panic("can only unmarshal pointers in unsafe mode");
-    }
     UnmarshalState *st = (UnmarshalState *)(ctx->u_state);
-    void *ptr;
-    MARSH_EOS(st, ctx->data + sizeof(void *) - 1);
-    memcpy((char *) &ptr, ctx->data, sizeof(void *));
-    ctx->data += sizeof(void *);
-    return ptr;
+#ifdef JANET_32
+    return (void *) ((intptr_t) readint(st, &(ctx->data)));
+#else
+    return (void *) ((intptr_t) read64(st, &(ctx->data)));
+#endif
 }
 
 uint8_t janet_unmarshal_byte(JanetMarshalContext *ctx) {
@@ -1252,9 +1225,7 @@ static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *
     if (at == NULL) janet_panic("unknown abstract type");
     if (at->unmarshal) {
         JanetMarshalContext context = {NULL, st, flags, data, at};
-        void *abst = at->unmarshal(&context);
-        janet_assert(abst != NULL, "null pointer abstract");
-        *out = janet_wrap_abstract(abst);
+        *out = janet_wrap_abstract(at->unmarshal(&context));
         if (context.at != NULL) {
             janet_panic("janet_unmarshal_abstract not called");
         }
@@ -1355,7 +1326,7 @@ static const uint8_t *unmarshal_one(
         }
         case LB_FIBER: {
             JanetFiber *fiber;
-            data = unmarshal_one_fiber(st, data + 1, &fiber, flags + 1);
+            data = unmarshal_one_fiber(st, data + 1, &fiber, flags);
             *out = janet_wrap_fiber(fiber);
             return data;
         }
@@ -1370,9 +1341,6 @@ static const uint8_t *unmarshal_one(
             func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) +
                                  len * sizeof(JanetFuncEnv));
             func->def = NULL;
-            for (int32_t i = 0; i < len; i++) {
-                func->envs[i] = NULL;
-            }
             *out = janet_wrap_function(func);
             janet_v_push(st->lookup, *out);
             data = unmarshal_one_def(st, data, &def, flags + 1);
@@ -1426,7 +1394,7 @@ static const uint8_t *unmarshal_one(
                 if (lead == LB_STRUCT_PROTO) {
                     Janet proto;
                     data = unmarshal_one(st, data, &proto, flags + 1);
-                    janet_asserttype(proto, JANET_STRUCT, st);
+                    janet_asserttype(proto, JANET_STRUCT);
                     janet_struct_proto(struct_) = janet_unwrap_struct(proto);
                 }
                 for (int32_t i = 0; i < len; i++) {
@@ -1449,7 +1417,7 @@ static const uint8_t *unmarshal_one(
                 if (lead == LB_TABLE_PROTO) {
                     Janet proto;
                     data = unmarshal_one(st, data, &proto, flags + 1);
-                    janet_asserttype(proto, JANET_TABLE, st);
+                    janet_asserttype(proto, JANET_TABLE);
                     t->proto = janet_unwrap_table(proto);
                 }
                 for (int32_t i = 0; i < len; i++) {

src/core/parse.c

@@ -259,14 +259,6 @@ static int checkescape(uint8_t c) {
             return '\f';
         case 'v':
             return '\v';
-        case 'a':
-            return '\a';
-        case 'b':
-            return '\b';
-        case '\'':
-            return '\'';
-        case '?':
-            return '?';
         case 'e':
             return 27;
         case '"':

src/core/pp.c

@@ -152,12 +152,6 @@ static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, in
             case '\v':
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2);
                 break;
-            case '\a':
-                janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2);
-                break;
-            case '\b':
-                janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2);
-                break;
             case 27:
                 janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2);
                 break;
@@ -250,10 +244,6 @@ void janet_to_string_b(JanetBuffer *buffer, Janet x) {
         case JANET_FUNCTION: {
             JanetFunction *fun = janet_unwrap_function(x);
             JanetFuncDef *def = fun->def;
-            if (def == NULL) {
-                janet_buffer_push_cstring(buffer, "<incomplete function>");
-                break;
-            }
             if (def->name) {
                 const uint8_t *n = def->name;
                 janet_buffer_push_cstring(buffer, "<function ");

src/core/value.c

@@ -703,7 +703,7 @@ Janet janet_lengthv(Janet x) {
                 return janet_wrap_number(len);
 #else
                 if (len < (size_t) JANET_INTMAX_INT64) {
-                    return janet_wrap_number((double) len);
+                    return janet_wrap_number(len);
                 } else {
                     janet_panicf("integer length %u too large", len);
                 }

src/core/vm.c

@@ -301,16 +301,6 @@ static Janet janet_method_lookup(Janet x, const char *name) {
     return method_to_fun(janet_ckeywordv(name), x);
 }
 
-static Janet janet_unary_call(const char *method, Janet arg) {
-    Janet m = janet_method_lookup(arg, method);
-    if (janet_checktype(m, JANET_NIL)) {
-        janet_panicf("could not find method :%s for %v", method, arg);
-    } else {
-        Janet argv[1] = { arg };
-        return janet_method_invoke(m, 1, argv);
-    }
-}
-
 /* Call a method first on the righthand side, and then on the left hand side with a prefix */
 static Janet janet_binop_call(const char *lmethod, const char *rmethod, Janet lhs, Janet rhs) {
     Janet lm = janet_method_lookup(lhs, lmethod);
@@ -352,7 +342,6 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
         &&label_JOP_MULTIPLY,
         &&label_JOP_DIVIDE_IMMEDIATE,
         &&label_JOP_DIVIDE,
-        &&label_JOP_DIVIDE_FLOOR,
         &&label_JOP_MODULO,
         &&label_JOP_REMAINDER,
         &&label_JOP_BAND,
@@ -594,6 +583,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
         &&label_unknown_op,
         &&label_unknown_op,
         &&label_unknown_op,
+        &&label_unknown_op,
         &&label_unknown_op
     };
 #endif
@@ -698,33 +688,14 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
     VM_OP(JOP_DIVIDE)
     vm_binop( /);
 
-    VM_OP(JOP_DIVIDE_FLOOR) {
-        Janet op1 = stack[B];
-        Janet op2 = stack[C];
-        if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {
-            double x1 = janet_unwrap_number(op1);
-            double x2 = janet_unwrap_number(op2);
-            stack[A] = janet_wrap_number(floor(x1 / x2));
-            vm_pcnext();
-        } else {
-            vm_commit();
-            stack[A] = janet_binop_call("div", "rdiv", op1, op2);
-            vm_checkgc_pcnext();
-        }
-    }
-
     VM_OP(JOP_MODULO) {
         Janet op1 = stack[B];
         Janet op2 = stack[C];
         if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {
             double x1 = janet_unwrap_number(op1);
             double x2 = janet_unwrap_number(op2);
-            if (x2 == 0) {
-              stack[A] = janet_wrap_number(x1);
-            } else {
-              double intres = x2 * floor(x1 / x2);
-              stack[A] = janet_wrap_number(x1 - intres);
-            }
+            double intres = x2 * floor(x1 / x2);
+            stack[A] = janet_wrap_number(x1 - intres);
             vm_pcnext();
         } else {
             vm_commit();
@@ -759,14 +730,9 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
 
     VM_OP(JOP_BNOT) {
         Janet op = stack[E];
-        if (janet_checktype(op, JANET_NUMBER)) {
-            stack[A] = janet_wrap_integer(~janet_unwrap_integer(op));
-            vm_pcnext();
-        } else {
-            vm_commit();
-            stack[A] = janet_unary_call("~", op);
-            vm_checkgc_pcnext();
-        }
+        vm_assert_type(op, JANET_NUMBER);
+        stack[A] = janet_wrap_integer(~janet_unwrap_integer(op));
+        vm_pcnext();
     }
 
     VM_OP(JOP_SHIFT_RIGHT_UNSIGNED)

src/include/janet.h

@@ -1267,7 +1267,6 @@ enum JanetOpCode {
     JOP_MULTIPLY,
     JOP_DIVIDE_IMMEDIATE,
     JOP_DIVIDE,
-    JOP_DIVIDE_FLOOR,
     JOP_MODULO,
     JOP_REMAINDER,
     JOP_BAND,

test/suite-corelib.janet

@@ -46,28 +46,8 @@
 (assert (<= 1.0 2.0 3.0 3.0 4.0 5.0 6.0) "less than or equal to reals")
 (assert (>= 6 5 4 4 3 2 1) "greater than or equal to integers")
 (assert (>= 6.0 5.0 4.0 4.0 3.0 2.0 1.0) "greater than or equal to reals")
-
-(assert (= 7 (% 20 13)) "rem 1")
-(assert (= -7 (% -20 13)) "rem 2")
-(assert (= 7 (% 20 -13)) "rem 3")
-(assert (= -7 (% -20 -13)) "rem 4")
-(assert (nan? (% 20 0)) "rem 5")
-
-(assert (= 7 (mod 20 13)) "mod 1")
-(assert (= 6 (mod -20 13)) "mod 2")
-(assert (= -6 (mod 20 -13)) "mod 3")
-(assert (= -7 (mod -20 -13)) "mod 4")
-(assert (= 20 (mod 20 0)) "mod 5")
-
-(assert (= 1 (div 20 13)) "div 1")
-(assert (= -2 (div -20 13)) "div 2")
-(assert (= -2 (div 20 -13)) "div 3")
-(assert (= 1 (div -20 -13)) "div 4")
-(assert (= math/inf (div 20 0)) "div 5")
-
-(assert (all = (seq [n :range [0 10]] (mod n 5 3))
-               (seq [n :range [0 10]] (% n 5 3))
-               [0 1 2 0 1 0 1 2 0 1]) "variadic mod")
+(assert (= 7 (% 20 13)) "modulo 1")
+(assert (= -7 (% -20 13)) "modulo 2")
 
 (assert (< 1.0 nil false true
            (fiber/new (fn [] 1))

test/suite-inttypes.janet

@@ -171,43 +171,22 @@
 (assert (not (even? (int/s64 "-1001"))) "even? 6")
 
 # integer type operations
-(defn opcheck [int x y]
-  (each op [mod % div]
-    (assert (compare= (op x y) (op (int x) y))
-            (string int " (" op " " x " " y ") expected " (op x y)
-                    ", got " (op (int x) y)))
-    (assert (compare= (op x y) (op x (int y)))
-            (string int " (" op " " x " " y ") expected " (op x y)
-                    ", got " (op x (int y))))
-    (assert (compare= (op x y) (op (int x) (int y)))
-            (string int " (" op " " x " " y ") expected " (op x y)
-                    ", got " (op (int x) (int y))))))
+(defn modcheck [x y]
+  (assert (= (string (mod x y)) (string (mod (int/s64 x) y)))
+          (string "int/s64 (mod " x " " y ") expected " (mod x y) ", got "
+                  (mod (int/s64 x) y)))
+  (assert (= (string (% x y)) (string (% (int/s64 x) y)))
+          (string "int/s64 (% " x " " y ") expected " (% x y) ", got "
+                  (% (int/s64 x) y))))
 
-(loop [x :in [-5 -3 0 3 5]
-       y :in [-4 -3 3 4]]
-  (opcheck int/s64 x y)
-  (if (and (>= x 0) (>= y 0))
-    (opcheck int/u64 x y)))
-
-(each int [int/s64 int/u64]
-  (each op [% / div]
-    (assert-error "division by zero" (op (int 7) 0))
-    (assert-error "division by zero" (op 7 (int 0)))
-    (assert-error "division by zero" (op (int 7) (int 0)))))
-
-(each int [int/s64 int/u64]
-  (loop [x :in [-5 -3 0 3 5]]
-    (assert (= (int x) (mod (int x) 0)) (string int " mod 0"))
-    (assert (= (int x) (mod x (int 0))) (string int " mod 0"))
-    (assert (= (int x) (mod (int x) (int 0))) (string int " mod 0"))))
-
-(loop [x :in [-5 -3 0 3 5]]
-  (assert (compare= (bnot x) (bnot (int/s64 x))) "int/s64 bnot"))
-
-(loop [x :range [0 10]]
-  (assert (= (int/u64 "0xFFFF_FFFF_FFFF_FFFF")
-          (bxor (int/u64 x) (bnot (int/u64 x))))
-          "int/u64 bnot"))
+(modcheck 1 2)
+(modcheck 1 3)
+(modcheck 4 2)
+(modcheck 4 1)
+(modcheck 10 3)
+(modcheck 10 -3)
+(modcheck -10 3)
+(modcheck -10 -3)
 
 # Check for issue #1130
 # 7e65c2bda
@@ -274,11 +253,6 @@
 (assert (= (compare (i64 -1) (u64 1)) -1) "compare 11")
 (assert (= (compare (i64 -1) (u64 -1)) -1) "compare 12")
 
-# off by 1 error in inttypes
-# a3e812b86
-(assert (= (int/s64 "-0x8000_0000_0000_0000")
-           (+ (int/s64 "0x7FFF_FFFF_FFFF_FFFF") 1)) "int types wrap around")
-(assert (= (int/s64 "0x7FFF_FFFF_FFFF_FFFF")
-           (- (int/s64 "-0x8000_0000_0000_0000") 1)) "int types wrap around")
 
 (end-suite)
+

test/suite-marsh.janet

@@ -138,13 +138,5 @@ neldb\0\0\0\xD8\x05printG\x01\0\xDE\xDE\xDE'\x03\0marshal_tes/\x02
 # XXX: still needed? see 72beeeea
 (gccollect)
 
-# ev/chan marshalling
-(compwhen (dyn 'ev/chan)
-  (def chan (ev/chan 10))
-  (ev/give chan chan)
-  (def newchan (unmarshal (marshal chan)))
-  (def item (ev/take newchan))
-  (assert (= item newchan) "ev/chan marshalling"))
-
 (end-suite)
 

test/suite-peg.janet

@@ -307,12 +307,12 @@
 (check-deep '(uint 2) "\xff\x7f" @[0x7fff])
 (check-deep '(uint-be 2) "\x7f\xff" @[0x7fff])
 (check-deep '(uint-be 2) "\x7f\xff" @[0x7fff])
-(when-let [u64 int/u64
-           i64 int/s64]
-  (check-deep '(uint 8) "\xff\x7f\x00\x00\x00\x00\x00\x00" @[(u64 0x7fff)])
-  (check-deep '(int 8) "\xff\x7f\x00\x00\x00\x00\x00\x00" @[(i64 0x7fff)])
-  (check-deep '(uint 7) "\xff\x7f\x00\x00\x00\x00\x00" @[(u64 0x7fff)])
-  (check-deep '(int 7) "\xff\x7f\x00\x00\x00\x00\x00" @[(i64 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)
 

test/suite-strtod.janet

@@ -35,5 +35,10 @@
 # c876e63
 0xf&1fffFFFF
 
+# off by 1 error in inttypes
+# a3e812b86
+(assert (= (int/s64 "-0x8000_0000_0000_0000")
+           (+ (int/s64 "0x7FFF_FFFF_FFFF_FFFF") 1)) "int types wrap around")
+
 (end-suite)
 

tools/format.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env sh
+#!/usr/bin/env bash
 
 # Format all code with astyle