xbintsc 0.3.14 → 0.3.16

package/runtime/xt_loop.c

@@ -5,12 +5,14 @@
  * `dgram`, `http`, ...) deliver callbacks without baking an OS abstraction
  * into the compiler. Generated `main` calls `xt_run_event_loop()` once the
  * program body (and its microtasks) have finished; the loop returns as soon as
- * no file descriptors remain registered, so programs that never touch I/O are
- * unaffected.
+ * no file descriptors or timers remain registered, so programs that never touch
+ * I/O or timers are unaffected.
  *
  * Extensions register descriptors with `xt_loop_add` and receive readiness
- * callbacks. The loop drains the promise microtask queue after every batch of
- * callbacks so `await`/`.then` chains keep working inside handlers.
+ * callbacks. The timer globals (`setTimeout` / `setInterval`) share the same
+ * wait: the nearest deadline bounds `select(2)`, so a timer-only program sleeps
+ * instead of spinning. The loop drains the promise microtask queue after every
+ * batch of callbacks so `await`/`.then` chains keep working inside handlers.
  */
 
 #include "rt_internal.h"
@@ -18,9 +20,11 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
 #if defined(_WIN32)
 #include <winsock2.h>
+#include <windows.h>
 #else
 #include <sys/select.h>
 #include <sys/time.h>
@@ -48,6 +52,184 @@ static xt_loop_watcher *xt_loop_find(int fd) {
   return NULL;
 }
 
+/* -- timers --------------------------------------------------------------- */
+/*
+ * `setTimeout` / `setInterval` and their `clear*` counterparts are implemented
+ * here, next to the reactor they piggyback on. The pending timers live in a
+ * flat array (the same shape as the watcher table above); before every wait the
+ * reactor looks at the nearest deadline and uses it to bound `select(2)`, so a
+ * program whose only pending work is a timer still sleeps instead of spinning.
+ *
+ * Callbacks are ordinary closure values invoked through `xt_closure_call`, so
+ * they capture their lexical environment like any other JS function.
+ */
+typedef struct {
+  uint64_t id;
+  xt_value callback;
+  xt_value *args;
+  int32_t argc;
+  int64_t due_ms;
+  int64_t interval_ms;
+  int active;
+} xt_timer;
+
+static xt_timer *xt_timers = NULL;
+static uint32_t xt_timer_count = 0;
+static uint32_t xt_timer_capacity = 0;
+static uint64_t xt_timer_next_id = 1;
+
+static int64_t xt_loop_now_ms(void) {
+#if defined(_WIN32)
+  return (int64_t)GetTickCount64();
+#else
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return (int64_t)ts.tv_sec * 1000 + (int64_t)(ts.tv_nsec / 1000000);
+#endif
+}
+
+static void xt_loop_sleep_ms(int ms) {
+  if (ms <= 0) return;
+#if defined(_WIN32)
+  Sleep((DWORD)ms);
+#else
+  struct timespec ts;
+  ts.tv_sec = ms / 1000;
+  ts.tv_nsec = (long)(ms % 1000) * 1000000L;
+  nanosleep(&ts, NULL);
+#endif
+}
+
+/* Coerce a delay argument to a non-negative whole number of milliseconds. */
+static int64_t xt_timer_delay_arg(xt_value value) {
+  double d = xt_to_number(value);
+  if (d != d || d < 0) return 0;
+  if (d > 2147483647.0) return 2147483647;
+  return (int64_t)d;
+}
+
+static uint32_t xt_timer_active_count(void) {
+  uint32_t count = 0;
+  for (uint32_t i = 0; i < xt_timer_count; i++) {
+    if (xt_timers[i].active) count++;
+  }
+  return count;
+}
+
+/* Earliest deadline among the live timers, or -1 when none is pending. */
+static int64_t xt_timer_next_due(void) {
+  int64_t next = -1;
+  for (uint32_t i = 0; i < xt_timer_count; i++) {
+    if (!xt_timers[i].active) continue;
+    if (next < 0 || xt_timers[i].due_ms < next) next = xt_timers[i].due_ms;
+  }
+  return next;
+}
+
+/* Reclaim slots left by cleared/fired one-shot timers. */
+static void xt_timer_compact(void) {
+  uint32_t write = 0;
+  for (uint32_t read = 0; read < xt_timer_count; read++) {
+    if (!xt_timers[read].active) continue;
+    if (write != read) xt_timers[write] = xt_timers[read];
+    write++;
+  }
+  xt_timer_count = write;
+}
+
+static uint64_t xt_timer_add(xt_value callback, int64_t delay_ms, int64_t interval_ms, int32_t argc, xt_value *argv) {
+  if (xt_timer_count >= xt_timer_capacity) {
+    xt_timer_capacity = xt_timer_capacity == 0 ? 16 : xt_timer_capacity * 2;
+    xt_timer *grown = (xt_timer *)realloc(xt_timers, sizeof(xt_timer) * xt_timer_capacity);
+    if (!grown) abort();
+    xt_timers = grown;
+  }
+  xt_timer *timer = &xt_timers[xt_timer_count++];
+  timer->id = xt_timer_next_id++;
+  timer->callback = callback;
+  timer->argc = argc;
+  timer->args = NULL;
+  if (argc > 0) {
+    timer->args = (xt_value *)malloc(sizeof(xt_value) * (size_t)argc);
+    if (!timer->args) abort();
+    for (int32_t i = 0; i < argc; i++) timer->args[i] = argv[i];
+  }
+  timer->due_ms = xt_loop_now_ms() + delay_ms;
+  timer->interval_ms = interval_ms;
+  timer->active = 1;
+  return timer->id;
+}
+
+static int xt_timer_cancel(uint64_t id) {
+  for (uint32_t i = 0; i < xt_timer_count; i++) {
+    if (xt_timers[i].active && xt_timers[i].id == id) {
+      xt_timers[i].active = 0;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+/* Invoke every timer whose deadline has passed. Timers scheduled by a callback
+ * (or by a microtask) are left for the next reactor iteration, so a recursive
+ * `setTimeout(fn, 0)` cannot spin forever inside a single call. */
+static void xt_timer_run_due(void) {
+  xt_timer_compact();
+  int64_t now = xt_loop_now_ms();
+  uint32_t limit = xt_timer_count;
+  for (uint32_t i = 0; i < limit; i++) {
+    xt_timer *timer = &xt_timers[i];
+    if (!timer->active || timer->due_ms > now) continue;
+    xt_value callback = timer->callback;
+    int32_t argc = timer->argc;
+    xt_value *args = timer->args;
+    if (timer->interval_ms > 0) {
+      timer->due_ms = now + timer->interval_ms;
+    } else {
+      timer->active = 0;
+    }
+    if (XT_IS_FUNCTION(callback)) xt_closure_call(callback, argc, args);
+  }
+}
+
+xt_value xt_set_timeout(int32_t argc, xt_value *argv) {
+  xt_value callback = xt_arg_at(argc, argv, 0);
+  if (!XT_IS_FUNCTION(callback)) {
+    xt_throw(xt_string_from_cstr("TypeError: The \"callback\" argument must be of type function"));
+    return XT_UNDEFINED;
+  }
+  int64_t delay = xt_timer_delay_arg(xt_arg_at(argc, argv, 1));
+  int32_t extra = argc > 2 ? argc - 2 : 0;
+  uint64_t id = xt_timer_add(callback, delay, 0, extra, extra > 0 ? argv + 2 : NULL);
+  return xt_number((double)id);
+}
+
+xt_value xt_set_interval(int32_t argc, xt_value *argv) {
+  xt_value callback = xt_arg_at(argc, argv, 0);
+  if (!XT_IS_FUNCTION(callback)) {
+    xt_throw(xt_string_from_cstr("TypeError: The \"callback\" argument must be of type function"));
+    return XT_UNDEFINED;
+  }
+  int64_t delay = xt_timer_delay_arg(xt_arg_at(argc, argv, 1));
+  /* Intervals are clamped to at least 1ms so an interval can never busy-spin. */
+  int64_t interval = delay > 0 ? delay : 1;
+  int32_t extra = argc > 2 ? argc - 2 : 0;
+  uint64_t id = xt_timer_add(callback, delay, interval, extra, extra > 0 ? argv + 2 : NULL);
+  return xt_number((double)id);
+}
+
+xt_value xt_clear_timeout(int32_t argc, xt_value *argv) {
+  double id = xt_to_number(xt_arg_at(argc, argv, 0));
+  if (id >= 1) xt_timer_cancel((uint64_t)id);
+  return XT_UNDEFINED;
+}
+
+xt_value xt_clear_interval(int32_t argc, xt_value *argv) {
+  double id = xt_to_number(xt_arg_at(argc, argv, 0));
+  if (id >= 1) xt_timer_cancel((uint64_t)id);
+  return XT_UNDEFINED;
+}
+
 int xt_loop_add(int fd, int events, xt_io_handler handler, void *userdata) {
   if (fd < 0 || !handler) return -1;
   xt_loop_watcher *existing = xt_loop_find(fd);
@@ -81,26 +263,67 @@ void xt_loop_remove(int fd) {
   xt_loop_active_count--;
 }
 
-void xt_run_event_loop(void) {
-  while (xt_loop_active_count > 0) {
-    fd_set readSet;
-    fd_set writeSet;
-    FD_ZERO(&readSet);
-    FD_ZERO(&writeSet);
-    int maxFd = -1;
-    for (int i = 0; i < xt_loop_watcher_count; i++) {
-      xt_loop_watcher *watcher = &xt_loop_watchers[i];
-      if (!watcher->active) continue;
-      if (watcher->events & XT_IO_READ) FD_SET(watcher->fd, &readSet);
-      if (watcher->events & XT_IO_WRITE) FD_SET(watcher->fd, &writeSet);
-      if (watcher->fd > maxFd) maxFd = watcher->fd;
-    }
-    if (maxFd < 0) break;
+/* A host (GUI toolkit, embedder) can take over the main loop; see
+ * `xt_loop_set_main`. `NULL` keeps the default blocking behaviour. */
+static xt_main_loop_fn xt_loop_main = NULL;
+
+void xt_loop_set_main(xt_main_loop_fn fn) { xt_loop_main = fn; }
+
+int xt_loop_poll(int timeout_ms) {
+  int has_fds = xt_loop_active_count > 0;
+  int64_t next_due = xt_timer_next_due();
+  if (!has_fds && next_due < 0) {
+    xt_drain_microtasks();
+    return 0;
+  }
+
+  /* Bound the wait by the nearest timer deadline when one is pending. */
+  int wait_ms = timeout_ms;
+  if (next_due >= 0) {
+    int64_t delta = next_due - xt_loop_now_ms();
+    if (delta < 0) delta = 0;
+    if (delta > 100000000) delta = 100000000;
+    if (wait_ms < 0 || delta < (int64_t)wait_ms) wait_ms = (int)delta;
+  }
+
+  /* Timers only: sleep, then run whatever is due. */
+  if (!has_fds) {
+    xt_loop_sleep_ms(wait_ms);
+    xt_timer_run_due();
+    xt_drain_microtasks();
+    return (int)(xt_loop_active_count + xt_timer_active_count());
+  }
+
+  fd_set readSet;
+  fd_set writeSet;
+  FD_ZERO(&readSet);
+  FD_ZERO(&writeSet);
+  int maxFd = -1;
+  for (int i = 0; i < xt_loop_watcher_count; i++) {
+    xt_loop_watcher *watcher = &xt_loop_watchers[i];
+    if (!watcher->active) continue;
+    if (watcher->events & XT_IO_READ) FD_SET(watcher->fd, &readSet);
+    if (watcher->events & XT_IO_WRITE) FD_SET(watcher->fd, &writeSet);
+    if (watcher->fd > maxFd) maxFd = watcher->fd;
+  }
+  if (maxFd < 0) {
+    xt_timer_run_due();
+    xt_drain_microtasks();
+    return (int)(xt_loop_active_count + xt_timer_active_count());
+  }
+
+  struct timeval timeout;
+  struct timeval *timeoutPtr = NULL;
+  if (wait_ms >= 0) {
+    timeout.tv_sec = wait_ms / 1000;
+    timeout.tv_usec = (wait_ms % 1000) * 1000;
+    timeoutPtr = &timeout;
+  }
 
-    int ready = select(maxFd + 1, &readSet, &writeSet, NULL, NULL);
-    if (ready < 0) break;
-    if (ready == 0) continue;
+  int ready = select(maxFd + 1, &readSet, &writeSet, NULL, timeoutPtr);
+  if (ready < 0) return -1;
 
+  if (ready > 0) {
     /* Collect the ready watchers first: handlers may add/remove descriptors. */
     for (int i = 0; i < xt_loop_watcher_count; i++) {
       xt_loop_watcher *watcher = &xt_loop_watchers[i];
@@ -110,8 +333,23 @@ void xt_run_event_loop(void) {
       if ((watcher->events & XT_IO_WRITE) && FD_ISSET(watcher->fd, &writeSet)) events |= XT_IO_WRITE;
       if (events) watcher->handler(watcher->userdata, events);
     }
-    xt_drain_microtasks();
+  }
+
+  xt_timer_run_due();
+  xt_drain_microtasks();
+  return (int)(xt_loop_active_count + xt_timer_active_count());
+}
+
+void xt_run_event_loop(void) {
+  /* A host that owns the main loop (GUI toolkit) takes precedence: it is
+     responsible for calling `xt_loop_poll` while it runs. */
+  if (xt_loop_main != NULL) {
+    xt_loop_main();
+    return;
+  }
+  while (xt_loop_has_work()) {
+    if (xt_loop_poll(-1) < 0) break;
   }
 }
 
-int xt_loop_has_work(void) { return xt_loop_active_count > 0; }
+int xt_loop_has_work(void) { return xt_loop_active_count > 0 || xt_timer_active_count() > 0; }

package/runtime/xt_regex/api.inc

@@ -0,0 +1,58 @@
+/* -- public API ----------------------------------------------------------- */
+
+static int regcomp(regex_t *preg, const char *pattern, int cflags) {
+  xt_re_parser p;
+  xt_re_alt *root;
+  if (!preg || !pattern) return 1;
+  memset(preg, 0, sizeof(*preg));
+  p.s = pattern;
+  p.i = 0;
+  p.error = 0;
+  p.groupCount = 0;
+  root = xt_re_parse_alt(&p);
+  if (!root || p.error || p.s[p.i] != '\0') {
+    if (root) xt_re_free_alt(root);
+    return 1;
+  }
+  preg->root = root;
+  preg->icase = (cflags & REG_ICASE) ? 1 : 0;
+  return 0;
+}
+
+static int regexec(const regex_t *preg, const char *string, size_t nmatch,
+                   regmatch_t pmatch[], int eflags) {
+  xt_re_input in;
+  size_t start;
+  size_t i;
+  (void)eflags;
+  if (!preg || !preg->root || !string) return 1;
+  if (pmatch) {
+    for (i = 0; i < nmatch; i++) {
+      pmatch[i].rm_so = -1;
+      pmatch[i].rm_eo = -1;
+    }
+  }
+  in.text = string;
+  in.len = strlen(string);
+  in.icase = preg->icase;
+  for (start = 0; start <= in.len; start++) {
+    xt_re_match_result result;
+    result.end = 0;
+    result.pmatch = pmatch;
+    result.nmatch = nmatch;
+    if (xt_re_match_alt(preg->root, &in, start, xt_re_record_match, &result, NULL)) {
+      if (nmatch > 0 && pmatch) {
+        pmatch[0].rm_so = (int)start;
+        pmatch[0].rm_eo = (int)result.end;
+      }
+      return 0;
+    }
+  }
+  return 1;
+}
+
+static void regfree(regex_t *preg) {
+  if (!preg) return;
+  xt_re_free_alt(preg->root);
+  preg->root = NULL;
+}

package/runtime/xt_regex/helpers.inc

@@ -0,0 +1,68 @@
+/* -- small helpers -------------------------------------------------------- */
+
+static void xt_re_set_bit(unsigned char *bits, unsigned char c) {
+  bits[c >> 3] |= (unsigned char)(1u << (c & 7));
+}
+
+static int xt_re_bit_test(const unsigned char *bits, unsigned char c) {
+  return (bits[c >> 3] >> (c & 7)) & 1;
+}
+
+static unsigned char xt_re_lower(unsigned char c) {
+  if (c >= 'A' && c <= 'Z') return (unsigned char)(c - 'A' + 'a');
+  return c;
+}
+
+static void xt_re_add_range(unsigned char *bits, unsigned char lo, unsigned char hi) {
+  unsigned int c;
+  if (hi < lo) {
+    unsigned char t = lo;
+    lo = hi;
+    hi = t;
+  }
+  for (c = lo; c <= hi; c++) xt_re_set_bit(bits, (unsigned char)c);
+}
+
+/* Adds a predefined class such as \d or \w. Returns 1 when handled. */
+static int xt_re_add_predefined(unsigned char *bits, char e) {
+  int c;
+  switch (e) {
+    case 'd':
+      xt_re_add_range(bits, '0', '9');
+      return 1;
+    case 'D':
+      for (c = 0; c < 256; c++)
+        if (!(c >= '0' && c <= '9')) xt_re_set_bit(bits, (unsigned char)c);
+      return 1;
+    case 'w':
+      xt_re_add_range(bits, 'a', 'z');
+      xt_re_add_range(bits, 'A', 'Z');
+      xt_re_add_range(bits, '0', '9');
+      xt_re_set_bit(bits, '_');
+      return 1;
+    case 'W':
+      for (c = 0; c < 256; c++) {
+        int is_word = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+                      (c >= '0' && c <= '9') || c == '_';
+        if (!is_word) xt_re_set_bit(bits, (unsigned char)c);
+      }
+      return 1;
+    case 's':
+      xt_re_set_bit(bits, ' ');
+      xt_re_set_bit(bits, '\t');
+      xt_re_set_bit(bits, '\n');
+      xt_re_set_bit(bits, '\r');
+      xt_re_set_bit(bits, '\f');
+      xt_re_set_bit(bits, '\v');
+      return 1;
+    case 'S':
+      for (c = 0; c < 256; c++) {
+        int is_space = c == ' ' || c == '\t' || c == '\n' || c == '\r' ||
+                       c == '\f' || c == '\v';
+        if (!is_space) xt_re_set_bit(bits, (unsigned char)c);
+      }
+      return 1;
+    default:
+      return 0;
+  }
+}

package/runtime/xt_regex/matcher.inc

@@ -0,0 +1,248 @@
+/* -- matching ------------------------------------------------------------- */
+
+typedef struct {
+  const char *text;
+  size_t len;
+  int icase;
+} xt_re_input;
+
+/* One capture on the immutable chain of the current search path. `parent`
+ * points to the captures that were live when the group was entered, so an
+ * abandoned backtrack simply drops the frame instead of restoring it. */
+typedef struct xt_re_cap {
+  const struct xt_re_cap *parent;
+  int index; /* 1-based capture group number */
+  int start;
+  int end;
+} xt_re_cap;
+
+typedef int (*xt_re_cont)(void *ctx, size_t pos, const xt_re_cap *caps);
+
+static void xt_re_free_alt(xt_re_alt *alt);
+
+static void xt_re_free_node(xt_re_node *n) {
+  if (!n) return;
+  if (n->type == XT_RE_GROUP) xt_re_free_alt(n->group);
+  free(n->classbits);
+  free(n);
+}
+
+static void xt_re_free_alt(xt_re_alt *alt) {
+  int i;
+  if (!alt) return;
+  for (i = 0; i < alt->count; i++) {
+    int j;
+    for (j = 0; j < alt->branches[i].count; j++)
+      xt_re_free_node(alt->branches[i].pieces[j].node);
+    free(alt->branches[i].pieces);
+  }
+  free(alt->branches);
+  free(alt);
+}
+
+static int xt_re_char_eq(const xt_re_input *in, unsigned char a, unsigned char b) {
+  if (a == b) return 1;
+  if (in->icase && xt_re_lower(a) == xt_re_lower(b)) return 1;
+  return 0;
+}
+
+static int xt_re_class_match(const unsigned char *bits, unsigned char c, int icase) {
+  if (xt_re_bit_test(bits, c)) return 1;
+  if (icase) {
+    unsigned char l = xt_re_lower(c);
+    if (xt_re_bit_test(bits, l)) return 1;
+    if (l >= 'a' && l <= 'z' && xt_re_bit_test(bits, (unsigned char)(l - 'a' + 'A'))) return 1;
+  }
+  return 0;
+}
+
+static int xt_re_match_alt(xt_re_alt *alt, const xt_re_input *in, size_t pos,
+                           xt_re_cont cont, void *ctx, const xt_re_cap *caps);
+
+/* Resumes the outer continuation once a group's body has matched, recording
+ * where the group ended on the frame it pushed. */
+typedef struct {
+  xt_re_cap *frame;
+  xt_re_cont cont;
+  void *ctx;
+} xt_re_group_state;
+
+static int xt_re_group_next(void *v, size_t pos, const xt_re_cap *caps) {
+  xt_re_group_state *s = (xt_re_group_state *)v;
+  /* `caps` already heads the chain that includes this group's own frame (and
+   * any groups nested inside it), so forward it as-is. */
+  s->frame->end = (int)pos;
+  return s->cont(s->ctx, pos, caps);
+}
+
+static int xt_re_match_atom(xt_re_node *node, const xt_re_input *in, size_t pos,
+                            xt_re_cont cont, void *ctx, const xt_re_cap *caps) {
+  switch (node->type) {
+    case XT_RE_CHAR:
+      if (pos < in->len && xt_re_char_eq(in, (unsigned char)in->text[pos], node->ch))
+        return cont(ctx, pos + 1, caps);
+      return 0;
+    case XT_RE_ANY:
+      if (pos < in->len && in->text[pos] != '\n') return cont(ctx, pos + 1, caps);
+      return 0;
+    case XT_RE_CLASS:
+      if (pos < in->len && xt_re_class_match(node->classbits, (unsigned char)in->text[pos], in->icase))
+        return cont(ctx, pos + 1, caps);
+      return 0;
+    case XT_RE_BOL:
+      return pos == 0 ? cont(ctx, pos, caps) : 0;
+    case XT_RE_EOL:
+      return pos == in->len ? cont(ctx, pos, caps) : 0;
+    case XT_RE_GROUP: {
+      xt_re_cap frame;
+      xt_re_group_state state;
+      frame.parent = caps;
+      frame.index = node->groupIndex;
+      frame.start = (int)pos;
+      frame.end = -1;
+      state.frame = &frame;
+      state.cont = cont;
+      state.ctx = ctx;
+      return xt_re_match_alt(node->group, in, pos, xt_re_group_next, &state, &frame);
+    }
+    default:
+      return 0;
+  }
+}
+
+typedef struct {
+  xt_re_node *atom;
+  const xt_re_input *in;
+  int min;
+  int max; /* -1 == unbounded */
+  xt_re_cont cont;
+  void *ctx;
+} xt_re_repeat;
+
+typedef struct {
+  xt_re_repeat *rep;
+  size_t pos;
+  int count;
+} xt_re_repeat_step;
+
+static int xt_re_repeat_try(xt_re_repeat *rep, size_t pos, int count, const xt_re_cap *caps);
+
+static int xt_re_repeat_next(void *v, size_t newpos, const xt_re_cap *caps) {
+  xt_re_repeat_step *s = (xt_re_repeat_step *)v;
+  if (newpos == s->pos) return 0; /* no progress -> stop to avoid loops */
+  return xt_re_repeat_try(s->rep, newpos, s->count + 1, caps);
+}
+
+static int xt_re_repeat_try(xt_re_repeat *rep, size_t pos, int count, const xt_re_cap *caps) {
+  if (rep->max < 0 || count < rep->max) {
+    xt_re_repeat_step step;
+    step.rep = rep;
+    step.pos = pos;
+    step.count = count;
+    if (xt_re_match_atom(rep->atom, rep->in, pos, xt_re_repeat_next, &step, caps)) return 1;
+  }
+  if (count >= rep->min) return rep->cont(rep->ctx, pos, caps);
+  return 0;
+}
+
+static int xt_re_match_piece(xt_re_piece *piece, const xt_re_input *in, size_t pos,
+                             xt_re_cont cont, void *ctx, const xt_re_cap *caps) {
+  xt_re_repeat rep;
+  switch (piece->quant) {
+    case XT_RE_Q_STAR:
+      rep.atom = piece->node;
+      rep.in = in;
+      rep.min = 0;
+      rep.max = -1;
+      rep.cont = cont;
+      rep.ctx = ctx;
+      return xt_re_repeat_try(&rep, pos, 0, caps);
+    case XT_RE_Q_PLUS:
+      rep.atom = piece->node;
+      rep.in = in;
+      rep.min = 1;
+      rep.max = -1;
+      rep.cont = cont;
+      rep.ctx = ctx;
+      return xt_re_repeat_try(&rep, pos, 0, caps);
+    case XT_RE_Q_QUEST:
+      rep.atom = piece->node;
+      rep.in = in;
+      rep.min = 0;
+      rep.max = 1;
+      rep.cont = cont;
+      rep.ctx = ctx;
+      return xt_re_repeat_try(&rep, pos, 0, caps);
+    default:
+      return xt_re_match_atom(piece->node, in, pos, cont, ctx, caps);
+  }
+}
+
+typedef struct {
+  xt_re_concat *concat;
+  const xt_re_input *in;
+  xt_re_cont cont;
+  void *ctx;
+} xt_re_concat_state;
+
+typedef struct {
+  xt_re_concat_state *state;
+  int index;
+} xt_re_concat_step;
+
+static int xt_re_match_concat(xt_re_concat_state *state, int index, size_t pos, const xt_re_cap *caps);
+
+/* The continuation for a concat piece resumes matching at the next piece. */
+static int xt_re_concat_next(void *v, size_t pos, const xt_re_cap *caps) {
+  xt_re_concat_step *s = (xt_re_concat_step *)v;
+  return xt_re_match_concat(s->state, s->index + 1, pos, caps);
+}
+
+static int xt_re_match_concat(xt_re_concat_state *state, int index, size_t pos, const xt_re_cap *caps) {
+  xt_re_concat_step step;
+  if (index >= state->concat->count) return state->cont(state->ctx, pos, caps);
+  step.state = state;
+  step.index = index;
+  return xt_re_match_piece(&state->concat->pieces[index], state->in, pos,
+                           xt_re_concat_next, &step, caps);
+}
+
+static int xt_re_match_alt(xt_re_alt *alt, const xt_re_input *in, size_t pos,
+                           xt_re_cont cont, void *ctx, const xt_re_cap *caps) {
+  int i;
+  for (i = 0; i < alt->count; i++) {
+    xt_re_concat_state state;
+    state.concat = &alt->branches[i];
+    state.in = in;
+    state.cont = cont;
+    state.ctx = ctx;
+    if (xt_re_match_concat(&state, 0, pos, caps)) return 1;
+  }
+  return 0;
+}
+
+typedef struct {
+  size_t end;
+  regmatch_t *pmatch;
+  size_t nmatch;
+} xt_re_match_result;
+
+/* Final continuation: records the whole-match end offset and copies every
+ * capture on the successful path into `pmatch`. Walking from the head means
+ * the most recent frame wins, which is what a quantified group such as
+ * `(a)+` should report (its last iteration). */
+static int xt_re_record_match(void *ctx, size_t pos, const xt_re_cap *caps) {
+  xt_re_match_result *result = (xt_re_match_result *)ctx;
+  const xt_re_cap *cap;
+  result->end = pos;
+  for (cap = caps; cap; cap = cap->parent) {
+    if (cap->index >= 1 && (size_t)cap->index < result->nmatch) {
+      regmatch_t *slot = &result->pmatch[cap->index];
+      if (slot->rm_so < 0) {
+        slot->rm_so = cap->start;
+        slot->rm_eo = cap->end;
+      }
+    }
+  }
+  return 1;
+}