txr: support @(if)/@(elif)/@(else) in @(output).

This turns out to be way easier than I thought.

* match.c (do_output_if): New static function.
(do_output): Handle if via do_output_if.

* parser.y (out_if_clause, out_elif_clauses_opt,
out_else_clause_opt): New nonterminal symbols and grammar
rules.
(out_clause): Now produces out_if_clause.
(not_a_clause): Remove ELIF and ELSE; these entries here cause
conflicts now. Here, continue to recognize the Lisp if, which
is distinguished by having at least two arguments.
out_if_clause matches only a one-argument if, and a
no-argumeent one that is diagnosed as erroneous.

* txr.1: Documented.

3 files changed, 105 insertions, 5 deletions

diff --git a/match.c b/match.c
index 69bb374f..13c47a54 100644
--- a/match.c
+++ b/match.c
@@ -2234,6 +2234,18 @@ static void do_repeat(val bindings, val repeat_syntax, val filter, val out)
   }
 }
 
+static void do_output_if(val bindings, val if_syntax, val filter, val out)
+{
+  val args = cdr(if_syntax);
+
+  for (; args; args = cdr(args)) {
+    cons_bind (expr, specs, car(args));
+    if (tleval(args, expr, bindings)) {
+      do_output(bindings, specs, filter, out);
+      return;
+    }
+  }
+}
 
 void do_output(val bindings, val specs, val filter, val out)
 {
@@ -2252,6 +2264,8 @@ void do_output(val bindings, val specs, val filter, val out)
         continue;
       }
 
+      if (sym == if_s) {
+        do_output_if(bindings, first_elem, filter, out);
         continue;
       }
     }
diff --git a/parser.y b/parser.y
index 4ae153db..3c6d7353 100644
--- a/parser.y
+++ b/parser.y
@@ -144,6 +144,7 @@ INLINE val expand_form_ver(val form, int ver)
 %type <val> list dwim meta compound
 %type <val> out_clauses out_clauses_opt out_clause
 %type <val> repeat_clause repeat_parts_opt o_line
+%type <val> out_if_clause out_elif_clauses_opt out_else_clause_opt
 %type <val> o_elems_opt o_elems o_elem o_var q_var rep_elem rep_parts_opt
 %type <val> regex lisp_regex regexpr regbranch
 %type <val> regterm regtoken regclass regclassterm regrange
@@ -649,6 +650,7 @@ out_clauses : out_clause                { $$ = cons($1, nil); }
             ;
 
 out_clause : repeat_clause              { $$ = cons($1, nil); }
+           | out_if_clause              { $$ = cons($1, nil); }
            | o_line                     { $$ = $1; }
            ;
 
@@ -701,6 +703,44 @@ repeat_parts_opt : SINGLE newl
                  | /* empty */          { $$ = nil; }
                  ;
 
+out_if_clause : IF n_expr ')' newl
+                out_clauses_opt
+                out_elif_clauses_opt
+                out_else_clause_opt
+                END newl        { val expr = expand($2, nil);
+                                  val ifs = $5;
+                                  val branch = cons(cons(expr, ifs), nil);
+                                  val elifs = $6;
+                                  val els = $7;
+                                  $$ = cons(if_s,
+                                            nappend2(branch, nappend2(elifs, els)));
+                                  rl($$, num($1)); }
+              | IF ')'
+                                { $$ = nil;
+                                  yyerr("if requires expression"); }
+              | IF n_expr ')' newl
+                error           { $$ = nil; yybadtok(yychar, lit("if clause")); }
+              ;
+
+out_elif_clauses_opt : ELIF n_exprs_opt ')' newl
+                       out_clauses_opt
+                       out_elif_clauses_opt
+                                { val expr = expand(car($2), nil);
+                                  val elifs = $5;
+                                  val branch = cons(cons(expr, elifs), nil);
+                                  if (null($2))
+                                    yyerr("elif requires expression");
+                                  else if (cdr($2))
+                                    yyerr("extra expression in elif");
+                                  $$ = nappend2(branch, $6); }
+                     |          { $$ = nil; }
+                     ;
+
+out_else_clause_opt : ELSE newl
+                      out_clauses_opt
+                                { $$ = cons(cons(t, $3), nil); }
+                      |         { $$ = nil; }
+                      ;
 
 out_clauses_opt : out_clauses   { $$ = $1; }
                 | /* empty */   { $$ = nil; }
@@ -1296,8 +1336,6 @@ not_a_clause : ALL              { $$ = mkexp(all_s, nil, num(parser->lineno)); }
              | OR               { $$ = mkexp(or_s, nil, num(parser->lineno)); }
              | TRY              { $$ = mkexp(try_s, nil, num(parser->lineno)); }
              | FINALLY          { $$ = mkexp(finally_s, nil, num(parser->lineno)); }
-             | ELSE             { $$ = mkexp(else_s, nil, num(parser->lineno)); }
-             | ELIF             { $$ = mkexp(elif_s, nil, num(parser->lineno)); }
              | BLOCK
                exprs_opt ')'    { $$ = mkexp(block_s, $2, nil); }
              | CHOOSE
@@ -1313,7 +1351,10 @@ not_a_clause : ALL              { $$ = mkexp(all_s, nil, num(parser->lineno)); }
              | CATCH
                exprs_opt ')'    { $$ = mkexp(catch_s, $2, nil); }
              | IF
-               exprs_opt ')'    { $$ = mkexp(if_s, $2, nil); }
+               n_expr n_expr exprs_opt ')'  { $$ = mkexp(if_s,
+                                                         cons($2,
+                                                              cons($3, $4)),
+                                                         nil); }
              | OUTPUT
                 exprs_opt ')'   { yyerr("@(output) doesn't nest"); }
 
diff --git a/txr.1 b/txr.1
index 55bfdea4..119bc1d4 100644
--- a/txr.1
+++ b/txr.1
@@ -3484,7 +3484,10 @@ directive with optional
 and
 .code else
 clauses allows one of multiple bodies of pattern matching directives to be
-conditionally selected by testing the values of Lisp expressions.
+conditionally selected by testing the values of Lisp expressions. It is
+also available inside
+.code @(output)
+for conditionally selecting output clauses.
 
 .coIP @(choose)
 Multiple clauses are applied to the same input. The one whose effect persists
@@ -5067,7 +5070,14 @@ Example:
 The
 .code if
 directive allows for conditional selection of pattern matching clauses,
-based on the Boolean results Lisp expressions.
+based on the Boolean results of Lisp expressions.
+
+A variant of the
+.code if
+directive is also available for use inside an
+.code output
+clauses, where it similarly allows for the conditional selection of output
+clauses.
 
 The syntax of the
 .code if
@@ -5153,6 +5163,41 @@ clause, then the
 directive is deemed to have trivially succeeded, allowing matching to continue
 with whatever directive follows it.
 
+.coNP The Lisp @ if versus TXR @ if
+
+The
+.code @(output)
+directive supports the embedding of Lisp expressions, whose values are
+interpolated into the output. In particular, Lisp
+.code if
+expressions are useful. For instance
+.code "@(if expr \(dqA\(dq \(dqB\(dq)"
+reproduces
+.code A
+if
+.code expr
+yields a true value, otherwise
+.codn B .
+Yet the
+.code @(if)
+directive is also supported in
+.codn @(output) .
+How the apparent conflict between the two is resolved is that the two take
+different numbers of arguments. An
+.code @(if)
+which has no arguments at all is a syntax error. One that has one argument
+is the head of the
+.code if
+directive syntax which must be terminated by
+.code @(end)
+and which takes the optional
+.code @(elif)
+and
+.code @(else)
+clauses. An
+.code @(if)
+which has two or more arguments is parsed as a self-contained Lisp expression.
+
 .dir gather
 
 Sometimes text is structured as items that can appear in an arbitrary order.