Add some fixes for serializing complex grammars.

src/boot/boot.janet

@@ -1579,8 +1579,8 @@
   (unmarshal image (env-lookup _env)))
 
 (def- nati (if (= :windows (os/which)) ".dll" ".so"))
-(defn- check-. [x] (string/has-prefix? "." x))
-(defn- not-check-. [x] (not (string/has-prefix? "." x)))
+(defn- check-. [x] (if (string/has-prefix? "." x) x))
+(defn- not-check-. [x] (unless (string/has-prefix? "." x) x))
 
 (def module/paths
   "The list of paths to look for modules, templated for module/expand-path.

src/core/corelib.c

@@ -119,24 +119,37 @@ static Janet janet_core_expand_path(int32_t argc, Janet *argv) {
     janet_fixarity(argc, 2);
     const char *input = janet_getcstring(argv, 0);
     const char *template = janet_getcstring(argv, 1);
-    const char *curfile = janet_dyncstring("current-file", "./.");
+    const char *curfile = janet_dyncstring("current-file", "");
     const char *syspath = janet_dyncstring("syspath", "");
     JanetBuffer *out = janet_buffer(0);
     size_t tlen = strlen(template);
 
     /* Calculate name */
-    const char *name = input + strlen(input) - 1;
+    const char *name = input + strlen(input);
     while (name > input) {
         if (is_path_sep(*(name - 1))) break;
         name--;
     }
 
     /* Calculate dirpath from current file */
-    const char *curname = curfile + strlen(curfile) - 1;
+    const char *curname = curfile + strlen(curfile);
     while (curname > curfile) {
         if (is_path_sep(*curname)) break;
         curname--;
     }
+    const char *curdir;
+    int32_t curlen;
+    if (curname == curfile) {
+        /* Current file has one or zero path segments, so
+         * we are in the . directory. */
+        curdir = ".";
+        curlen = 1;
+    } else {
+        /* Current file has 2 or more segments, so we
+         * can cut off the last segment. */
+        curdir = curfile;
+        curlen = (int32_t)(curname - curfile);
+    }
 
     for (size_t i = 0; i < tlen; i++) {
         if (template[i] == ':') {
@@ -144,12 +157,11 @@ static Janet janet_core_expand_path(int32_t argc, Janet *argv) {
                 janet_buffer_push_cstring(out, input);
                 i += 4;
             } else if (strncmp(template + i, ":cur:", 5) == 0) {
-                janet_buffer_push_bytes(out, (const uint8_t *) curfile,
-                        (int32_t)(curname - curfile));
+                janet_buffer_push_bytes(out, (const uint8_t *)curdir, curlen);
                 i += 4;
             } else if (strncmp(template + i, ":dir:", 5) == 0) {
-                janet_buffer_push_bytes(out, (const uint8_t *) input,
-                        (int32_t)(name - input));
+                janet_buffer_push_bytes(out, (const uint8_t *)input,
+                                        (int32_t)(name - input));
                 i += 4;
             } else if (strncmp(template + i, ":sys:", 5) == 0) {
                 janet_buffer_push_cstring(out, syspath);

src/core/marsh.c

@@ -328,11 +328,11 @@ static void marshal_one_abstract(MarshalState *st, Janet x, int flags) {
     void *abstract = janet_unwrap_abstract(x);
     const JanetAbstractType *at = janet_abstract_type(abstract);
     if (at->marshal) {
-        MARK_SEEN();
         JanetMarshalContext context = {st, NULL, flags, NULL};
         pushbyte(st, LB_ABSTRACT);
         marshal_one(st, janet_csymbolv(at->name), flags + 1);
         push64(st, (uint64_t) janet_abstract_size(abstract));
+        MARK_SEEN();
         at->marshal(abstract, &context);
     } else {
         janet_panicf("try to marshal unregistered abstract type, cannot marshal %p", x);
@@ -1008,10 +1008,11 @@ static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *
     if (at == NULL) return NULL;
     if (at->unmarshal) {
         void *p = janet_abstract(at, (size_t) read64(st, &data));
-        JanetMarshalContext context = {NULL, st, flags, data};
-        at->unmarshal(p, &context);
         *out = janet_wrap_abstract(p);
-        return data;
+        JanetMarshalContext context = {NULL, st, flags, data};
+        janet_v_push(st->lookup, *out);
+        at->unmarshal(p, &context);
+        return context.data;
     }
     return NULL;
 }

src/core/peg.c

@@ -952,8 +952,9 @@ typedef struct {
 static int peg_mark(void *p, size_t size) {
     (void) size;
     Peg *peg = (Peg *)p;
-    for (uint32_t i = 0; i < peg->num_constants; i++)
-        janet_mark(peg->constants[i]);
+    if (NULL != peg->constants)
+        for (uint32_t i = 0; i < peg->num_constants; i++)
+            janet_mark(peg->constants[i]);
     return 0;
 }
 
@@ -986,8 +987,8 @@ static void peg_unmarshal(void *p, JanetMarshalContext *ctx) {
     size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet));
     uint32_t *bytecode = (uint32_t *)(mem + bytecode_start);
     Janet *constants = (Janet *)(mem + constants_start);
-    peg->bytecode = bytecode;
-    peg->constants = constants;
+    peg->bytecode = NULL;
+    peg->constants = NULL;
 
     for (size_t i = 0; i < peg->bytecode_len; i++)
         bytecode[i] = (uint32_t) janet_unmarshal_int(ctx);
@@ -1087,7 +1088,7 @@ static void peg_unmarshal(void *p, JanetMarshalContext *ctx) {
                 if (rule[1] >= blen) goto bad;
                 if (rule[2] >= clen) goto bad;
                 op_flags[rule[1]] |= 0x01;
-                i += 2;
+                i += 4;
                 break;
             case RULE_ERROR:
             case RULE_DROP:
@@ -1111,6 +1112,8 @@ static void peg_unmarshal(void *p, JanetMarshalContext *ctx) {
         if (op_flags[i] == 0x01) goto bad;
 
     /* Good return */
+    peg->bytecode = bytecode;
+    peg->constants = constants;
     free(op_flags);
     return;