add a new (til) PEG special

(til term patt) behaves like (sub (to term) patt), but it advances to the end
of (thru term). It's similar to (sequence (sub (to term) patt) (drop term)),
but it doesn't evaluate the term pattern again after evaluating patt (which
may be significant if it contains backreferenced matches).

Author: ianthehenry

src/core/peg.c

@@ -548,6 +548,41 @@ static const uint8_t *peg_rule(
             return text;
         }
 
+        case RULE_TIL: {
+            const uint32_t *rule_terminator = s->bytecode + rule[1];
+            const uint32_t *rule_subpattern = s->bytecode + rule[2];
+
+            const uint8_t *text_start = text;
+            const uint8_t *terminator_end = NULL;
+            CapState cs = cap_save(s);
+            down1(s);
+            while (text <= s->text_end) {
+                terminator_end = peg_rule(s, rule_terminator, text);
+                cap_load(s, cs);
+                if (terminator_end) {
+                    break;
+                }
+                text++;
+            }
+            up1(s);
+
+            if (!terminator_end) {
+                return NULL;
+            }
+            const uint8_t *saved_end = s->text_end;
+            s->text_end = text;
+            down1(s);
+            const uint8_t *subpattern_end = peg_rule(s, rule_subpattern, text_start);
+            up1(s);
+            s->text_end = saved_end;
+
+            if (!subpattern_end) {
+                return NULL;
+            }
+
+            return terminator_end;
+        }
+
         case RULE_REPLACE:
         case RULE_MATCHTIME: {
             uint32_t tag = rule[3];
@@ -1189,6 +1224,14 @@ static void spec_split(Builder *b, int32_t argc, const Janet *argv) {
     emit_2(r, RULE_SPLIT, subrule1, subrule2);
 }
 
+static void spec_til(Builder *b, int32_t argc, const Janet *argv) {
+    peg_fixarity(b, argc, 2);
+    Reserve r = reserve(b, 3);
+    uint32_t subrule1 = peg_compile1(b, argv[0]);
+    uint32_t subrule2 = peg_compile1(b, argv[1]);
+    emit_2(r, RULE_TIL, subrule1, subrule2);
+}
+
 #ifdef JANET_INT_TYPES
 #define JANET_MAX_READINT_WIDTH 8
 #else
@@ -1275,6 +1318,7 @@ static const SpecialPair peg_specials[] = {
     {"split", spec_split},
     {"sub", spec_sub},
     {"thru", spec_thru},
+    {"til", spec_til},
     {"to", spec_to},
     {"uint", spec_uint_le},
     {"uint-be", spec_uint_be},
@@ -1610,6 +1654,7 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                 break;
             case RULE_SUB:
             case RULE_SPLIT:
+            case RULE_TIL:
                 /* [rule, rule] */
                 if (rule[1] >= blen) goto bad;
                 if (rule[2] >= blen) goto bad;

src/include/janet.h

@@ -2142,7 +2142,8 @@ typedef enum {
     RULE_UNREF,        /* [rule, tag] */
     RULE_CAPTURE_NUM,  /* [rule, tag] */
     RULE_SUB,          /* [rule, rule] */
-    RULE_SPLIT         /* [rule, rule] */
+    RULE_SPLIT,        /* [rule, rule] */
+    RULE_TIL           /* [rule, rule] */
 } JanetPegOpcod;
 
 typedef struct {

test/suite-peg.janet

@@ -266,6 +266,7 @@
 (marshpeg '(sub "abcdf" "abc"))
 (marshpeg '(* (sub 1 1)))
 (marshpeg '(split "," (+ "a" "b" "c")))
+(marshpeg '(til :s+ :w+))
 
 # Peg swallowing errors
 # 159651117
@@ -751,5 +752,10 @@
   "a   b      c"
   @["a" "b" "c"])
 
+(test "til: find a separator, match before it, then advance past it"
+  ~(* (til "=" '(to -1)) '(to -1))
+  "word=something"
+  @["word" "something"])
+
 (end-suite)