Bind variable during directive delimited match.

The existing behavior is: when a situation like @a@(foo)
performs a search for the match for @(foo) in order to
determine the extent of the text matched by variable a, the
variable a is not bound. That is to say, @(foo) is tried in an
environment in which a doesn't exist.  The variable is only
bound when the search succeeds, and then @(foo) is processed
again, with the variable now available.

The new behavior is that @(foo) is tested in an environment
in which a is bound. The variable's value is bound to the
range of text between the original position and the tested
position where @(foo) is tried.

This is subject to the copatibility option.

* match.c (ml_bindings_specline_pos): New static function.
(search_match_binding_var): New static function, variant of
search_match.
(h_var): In the var-delimited-by-directive case, perform
the search using search_match_binding_var, unless <= 172
compatibility is requested.

* txr.1: Compatibility note added.

1 files changed, 37 insertions, 1 deletions

diff --git a/match.c b/match.c
index 98c2ee6c..b25502fe 100644
--- a/match.c
+++ b/match.c
@@ -460,6 +460,16 @@ static match_line_ctx ml_bindings_specline(match_line_ctx c, val bindings,
   return nc;
 }
 
+static match_line_ctx ml_bindings_specline_pos(match_line_ctx c, val bindings,
+                                               val specline, val pos)
+{
+  match_line_ctx nc = c;
+  nc.bindings = bindings;
+  nc.specline = specline;
+  nc.pos = pos;
+  return nc;
+}
+
 static val do_match_line(match_line_ctx *c);
 static val match_line(match_line_ctx c);
 
@@ -534,6 +544,30 @@ static val search_match(match_line_ctx *c, val from_end, val spec)
   return nil;
 }
 
+static val search_match_binding_var(match_line_ctx *c, val sym,
+                                    val from_end, val spec)
+{
+  val pos = from_end ? length_str(c->dataline) : c->pos;
+  val step = from_end ? negone : one;
+
+  for (; (from_end && ge(pos, c->pos)) ||
+         (!from_end && length_str_ge(c->dataline, pos));
+       pos = plus(pos, step))
+  {
+    val nbind = acons(sym, sub_str(c->dataline, c->pos, pos), c->bindings);
+    val new_pos = cdr(match_line(ml_bindings_specline_pos(*c, nbind,
+                                                          spec, pos)));
+    if (new_pos == t) {
+      return cons(pos, t);
+    } else if (new_pos) {
+      new_pos = minus(new_pos, c->base);
+      return cons(pos, minus(new_pos, pos));
+    }
+  }
+
+  return nil;
+}
+
 static val h_var(match_line_ctx *c)
 {
   val elem = pop(&c->specline);
@@ -722,7 +756,9 @@ static val h_var(match_line_ctx *c)
         c->bindings = acons(sym, sub_str(c->dataline, c->pos, find), c->bindings);
       c->pos = plus(find, len);
     } else {
-      val find = search_match(c, modifier, c->specline);
+      val find = if3(opt_compat && opt_compat <= 172,
+                     search_match(c, modifier, c->specline),
+                     search_match_binding_var(c, sym, modifier, c->specline));
       val fpos = car(find);
       if (!find) {
         LOG_MISMATCH("var delimiting spec");