TXR quasiliterals and output vars treated as Lisp.

* eval.c (format_field): Function moved here from match.c,
along with the introduction of a new behavior: if a meta-expr
occurs among the modifiers, its constituent expression
is evaluated in its place. This allows for @{a @[expr]}
which was previously not allowed in Lisp quasiliterals,
but worked in TXR quasiliterals due to the treatment
of @ by txeval.
(subst_vars): Static function turns external, so code in
match.c can call it instead of the subst_vars in that module.
For that purpose, it needs to take a filter argument and
process filters, like the match.c subst_vars.
(op_quasi_lit): Pass nil as filter argument to subst_vars.

* eval.h (format_field, subst_vars): Declared.

* match.c (format_field): Function removed, moved to
eval.c and slightly changed.
(subst_vars): Renamed to tx_subst_vars. By default, now just a
wrapper for subst_vars. In compatibility mode, invokes the
old logic.
(do_txeval, do_output_line): Call tx_subst_vars rather than
subst_vars.

* match.h (format_field): Declaration removed.

* parser.y (expr): Grammar production removed: no longer
referenced.
(o_var): Braced variable case now parsed as n_expr, and
expanded as expr by default, since this is Lisp now. In
compatibility mode, expanded using expand_meta.
Also SYMTOK case must be subject to expansion; an output
var can now be a symbol macro.
(expand_meta): Expand a quasi-literal as Lisp, except
in compatibility mode.

* txr.1: Bit of a documentation update. Existing doc isn't
totally clear.

1 files changed, 28 insertions, 17 deletions

diff --git a/parser.y b/parser.y
index 7fb42fec..fe3d22aa 100644
--- a/parser.y
+++ b/parser.y
@@ -119,7 +119,7 @@ int yyparse(scanner_t *, parser_t *);
 %type <val> if_clause elif_clauses_opt else_clause_opt
 %type <val> line elems_opt elems clause_parts_h additional_parts_h
 %type <val> text texts elem var var_op modifiers vector hash struct range
-%type <val> list exprs exprs_opt expr n_exprs r_exprs i_expr n_expr n_exprs_opt
+%type <val> list exprs exprs_opt n_exprs r_exprs i_expr n_expr n_exprs_opt
 %type <val> out_clauses out_clauses_opt out_clause
 %type <val> repeat_clause repeat_parts_opt o_line
 %type <val> o_elems_opt o_elems o_elem o_var q_var rep_elem rep_parts_opt
@@ -711,10 +711,20 @@ modifiers : NUMBER              { $$ = cons($1, nil); }
                                                  nil), $1); }
           ;
 
-o_var : SYMTOK                  { $$ = list(var_s, symhlpr($1, nil), nao);
+o_var : SYMTOK                  { val expr = symhlpr($1, nil);
+                                  if (!opt_compat || opt_compat > 128)
+                                    expr = expand(expr, nil);
+                                  $$ = list(var_s, expr, nao);
                                   rl($$, num(parser->lineno)); }
-      | '{' expr exprs_opt '}'
-                                { $$ = list(var_s, $2, $3, nao);
+      | '{' n_expr n_exprs_opt '}'
+                                { if (opt_compat && opt_compat <= 128)
+                                  { $$ = list(var_s,
+                                              expand_meta($2, nil),
+                                              expand_meta($3, nil), nao); }
+                                  else
+                                  { $$ = list(var_s,
+                                              expand($2, nil),
+                                              expand($3, nil), nao); }
                                   rl($$, num(parser->lineno)); }
       | SYMTOK error            { $$ = nil;
                                   yybadtok(yychar, lit("variable spec")); }
@@ -786,9 +796,6 @@ list : '(' n_exprs ')'          { $$ = rl($2, num($1)); }
 exprs : n_exprs                 { $$ = rlcp(expand_meta($1, nil), $1); }
       ;
 
-expr : n_expr                   { $$ = rlcp(expand_meta($1, nil), $1); }
-     ;
-
 exprs_opt : exprs               { $$ = $1; }
           | /* empty */         { $$ = nil; }
           ;
@@ -1318,19 +1325,23 @@ static val expand_meta(val form, val menv)
   menv = default_arg(menv, make_env(nil, nil, nil));
 
   if ((sym = car(form)) == quasi_s) {
-    list_collect_decl (out, ptail);
+    if (opt_compat && opt_compat <= 128) {
+      list_collect_decl (out, ptail);
 
-    for (; consp(form); form = cdr(form)) {
-      val subform = car(form);
-      if (consp(subform) && car(subform) == expr_s)
-        ptail = list_collect(ptail, expand_meta(subform, menv));
-      else
-        ptail = list_collect(ptail, subform);
-    }
+      for (; consp(form); form = cdr(form)) {
+        val subform = car(form);
+        if (consp(subform) && car(subform) == expr_s)
+          ptail = list_collect(ptail, expand_meta(subform, menv));
+        else
+          ptail = list_collect(ptail, subform);
+      }
 
-    ptail = list_collect_nconc(ptail, form);
+      ptail = list_collect_nconc(ptail, form);
+
+      return rlcp(out, form);
+    }
 
-    return rlcp(out, form);
+    return expand(form, nil);
   }
 
   if ((sym = car(form)) == expr_s) {