diff options
| -rw-r--r-- | match.c | 17 | ||||
| -rw-r--r-- | match.h | 2 | ||||
| -rw-r--r-- | parser.y | 48 | ||||
| -rw-r--r-- | txr.1 | 41 |
4 files changed, 99 insertions, 9 deletions
@@ -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); @@ -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); @@ -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); } @@ -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 |