Support binding in @(repeat)/@(rep) :vars.

* match.c (extract_bindings): Check for (var expr) syntax,
evaluate and bind.

* match.h (vars_k): Declared.

* parser.y (expand_repeat_rep_args): New static function.
(repeat_rep_helper): The :counter and :var arguments of
repeat/rep must be macro-expanded, since there can be Lisp
expressions there. This supports the new feature, but also
fixes the bug of :counter (var form) not expanding
form.

* txr.1: Updated documentation about :vars in @(repeat).

4 files changed, 99 insertions, 9 deletions

diff --git a/match.c b/match.c
index 5c2ce188..4e5ed362 100644
--- a/match.c
+++ b/match.c
@@ -47,6 +47,7 @@
 #include "hash.h"
 #include "debug.h"
 #include "eval.h"
+#include "cadr.h"
 #include "match.h"
 
 int opt_print_bindings = 0;
@@ -1617,7 +1618,21 @@ static val extract_vars(val output_spec)
 static val extract_bindings(val bindings, val output_spec, val vars)
 {
   list_collect_decl (bindings_out, ptail);
-  val var_list = nappend2(extract_vars(output_spec), vars);
+  list_collect_decl (var_list, vtail);
+
+  vtail = list_collect_nconc(vtail, extract_vars(output_spec));
+
+  for (; vars; vars = cdr(vars)) {
+    val var = car(vars);
+    if (consp(var)) {
+      val form = cadr(var);
+      val value = eval_with_bindings(form, output_spec, bindings, form);
+      bindings = cons(cons(car(var), value), bindings);
+      vtail = list_collect(vtail, car(var));
+    } else {
+      vtail = list_collect(vtail, var);
+    }
+  }
 
   for (; bindings; bindings = cdr(bindings)) {
     val binding = car(bindings);
diff --git a/match.h b/match.h
index 2b2547fa..ebae051c 100644
--- a/match.h
+++ b/match.h
@@ -26,7 +26,7 @@
 
 extern val text_s, choose_s, gather_s, do_s, require_s;
 extern val close_s, load_s, include_s, mod_s, modlast_s, line_s;
-extern val counter_k, env_k, var_k;
+extern val counter_k, vars_k, env_k, var_k;
 val match_filter(val name, val arg, val other_args);
 val match_fun(val name, val args, val input, val files);
 val include(val specline);
diff --git a/parser.y b/parser.y
index 0885861b..3849e86b 100644
--- a/parser.y
+++ b/parser.y
@@ -1198,9 +1198,55 @@ static val sym_helper(parser_t *parser, wchar_t *lexeme, val meta_allowed)
   return leading_at ? rl(list(var_s, sym, nao), num(parser->lineno)) : sym;
 }
 
+static val expand_repeat_rep_args(val args)
+{
+  list_collect_decl (out, ptail);
+  val exp_pair = nil, exp_pairs = nil;
+
+  for (; args; args = cdr(args)) {
+    val arg = car(args);
+
+    if (consp(arg)) {
+      if (exp_pairs) {
+        list_collect_decl (iout, iptail);
+        for (; arg; arg = cdr(arg)) {
+          val iarg = car(arg);
+          if (consp(iarg))
+            iptail = list_collect(iptail, list(first(iarg),
+                                               expand(second(iarg), nil),
+                                               nao));
+          else
+            iptail = list_collect(iptail, iarg);
+        }
+        ptail = list_collect(ptail, iout);
+      } else if (exp_pair) {
+        ptail = list_collect(ptail, list(first(arg),
+                                         expand(second(arg), nil),
+                                         nao));
+      } else {
+        ptail = list_collect(ptail, arg);
+      }
+    } else if (arg == counter_k) {
+      exp_pair = t;
+      ptail = list_collect(ptail, arg);
+      continue;
+    } else if (arg == vars_k) {
+      exp_pairs = t;
+      ptail = list_collect(ptail, arg);
+      continue;
+    }
+
+    exp_pair = exp_pairs = nil;
+    ptail = list_collect(ptail, arg);
+  }
+
+  return out;
+}
+
 static val repeat_rep_helper(val sym, val args, val main, val parts)
 {
   uses_or2;
+  val exp_args = expand_repeat_rep_args(args);
   val single_parts = nil, single_parts_p = nil;
   val first_parts = nil, first_parts_p = nil;
   val last_parts = nil, last_parts_p = nil;
@@ -1244,7 +1290,7 @@ static val repeat_rep_helper(val sym, val args, val main, val parts)
   mod_parts = or2(nreverse(mod_parts), mod_parts_p);
   modlast_parts = or2(nreverse(modlast_parts), modlast_parts_p);
 
-  return list(sym, args, main, single_parts, first_parts,
+  return list(sym, exp_args, main, single_parts, first_parts,
               last_parts, empty_parts, nreverse(mod_parts),
               nreverse(modlast_parts), nao);
 }
diff --git a/txr.1 b/txr.1
index 248140b1..a86c4ca1 100644
--- a/txr.1
+++ b/txr.1
@@ -7650,7 +7650,7 @@ Repeat supports arguments.
 .cblk
 .mets @(repeat
 .mets \ \ \  [:counter >> { symbol | >> ( symbol << expr )}]
-.mets \ \ \  [:vars <> ( symbol *)])
+.mets \ \ \  [:vars >> ({ symbol | >> ( symbol << expr )}*)])
 .cble
 
 The
@@ -7661,7 +7661,7 @@ access to the repetition count, starting at zero, incrementing with each
 repetition. If the the argument is given as
 .cblk
 .meti >> ( symbol << expr )
-.cblk
+.cble
 then
 .meta expr
 is a Lisp expression whose value is taken as a displacement value which
@@ -7673,10 +7673,20 @@ which counts from 1.
 
 The
 .code :vars
-argument specifies a list of variables. The repeat directive
-will pick out from this list those variables which have bindings.
-It will assume that all these variables occur in the repeat block and
-are to be iterated. This syntax is needed for situations in which
+argument specifies a list of variable names, or pairs consisting of a variable
+name and Lisp expression. For every variable paired with a Lisp expression,
+the expression is evaluated, and a binding is introduced, associating
+that variable with the expression's value.
+
+The repeat directive then processes the list of variables, selecting from it
+those which have a binding, either a previously existing binding or one just
+introduced from a Lisp expression. For each selected variable, repeat
+will assume that the variable occur in the repeat block and contains
+a list to be iterated.
+
+Thus
+.code :vars
+Firstly, it is needed for situations in which
 .code @(repeat)
 is not able to deduce the existence of a variable in the block.
 It does not dig very deeply to discover variables, and does not "see"
@@ -7715,6 +7725,25 @@ Now the repeat block iterates over list and the output is:
   <c>
 .cble
 
+Secondly, The variable binding syntax supported by
+.code :vars
+additionally provides a solution for situations when it is necessary to iterate
+over some list, but that list is the result of an expression, and not stored in
+any variable. A repeat block iterates only over lists emanating from variables;
+it does not iterate over lists pulled from arbitrary expressions.
+
+Example: output all file names matching the
+.code *.txr
+pattern in the current directory:
+
+.cblk
+  @(output)
+  @(repeat :vars (name (glob "*.txr")))
+  @name
+  @(end)
+  @(end)
+.cble
+
 .coNP Nested @ repeat directives
 
 If a