OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Change macro syntax to accept a single expr, not a sequence of exprs.

Browse Source
This commit is contained in:
Paul Stansifer 2011-07-27 17:36:37 -07:00
parent 3d7016ae95
commit 86f337484e
11 changed files with 80 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/comp/syntax/ast.rs
View File

@ -333,7 +333,7 @@ tag expr_ {
type mac = spanned[mac_];
tag mac_ {
mac_invoc(path, (@expr)[], option::t[str]);
mac_invoc(path, @expr, option::t[str]);
mac_embed_type(@ty);
mac_embed_block(blk);
mac_ellipsis;

4
src/comp/syntax/ext/base.rs
View File

@ -7,10 +7,10 @@ import std::map::new_str_hash;
import codemap;
type syntax_expander =
fn(&ext_ctxt, span, &(@ast::expr)[], option::t[str]) -> @ast::expr ;
fn(&ext_ctxt, span, @ast::expr, option::t[str]) -> @ast::expr ;
type macro_def = {ident: str, ext: syntax_extension};
type macro_definer =
fn(&ext_ctxt, span, &(@ast::expr)[], option::t[str]) -> macro_def ;
fn(&ext_ctxt, span, @ast::expr, option::t[str]) -> macro_def ;
tag syntax_extension {
normal(syntax_expander);

6
src/comp/syntax/ext/env.rs
View File

@ -12,8 +12,12 @@ import std::generic_os;
import base::*;
export expand_syntax_ext;
fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, args: &(@ast::expr)[],
fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
body: option::t[str]) -> @ast::expr {
let args: (@ast::expr)[] = alt arg.node {
ast::expr_vec(elts, _, _) { elts }
_ { cx.span_fatal(sp, "#env requires arguments of the form `[...]`.") }
};
if ivec::len[@ast::expr](args) != 1u {
cx.span_fatal(sp, "malformed #env call");
}

6
src/comp/syntax/ext/fmt.rs
View File

@ -16,8 +16,12 @@ import base::*;
import codemap::span;
export expand_syntax_ext;
fn expand_syntax_ext(cx: &ext_ctxt, sp: span, args: &(@ast::expr)[],
fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,
body: option::t[str]) -> @ast::expr {
let args: (@ast::expr)[] = alt arg.node {
ast::expr_vec(elts, _, _) { elts }
_ { cx.span_fatal(sp, "#fmt requires arguments of the form `[...]`.") }
};
if ivec::len[@ast::expr](args) == 0u {
cx.span_fatal(sp, "#fmt requires a format string");
}

73
src/comp/syntax/ext/simplext.rs
View File

@ -42,7 +42,7 @@ fn path_to_ident(pth: &path) -> option::t[ident] {
}
//an ivec of binders might be a little big.
type clause = {params: binders[], body: @expr};
type clause = {params: binders, body: @expr};
/* logically, an arb_depth should contain only one kind of matchable */
tag arb_depth[T] { leaf(T); seq(vec[arb_depth[T]], span); }
@ -107,6 +107,7 @@ fn elts_to_ell(cx: &ext_ctxt, elts: &(@expr)[]) -> option::t[@expr] {
}
ret some(elts.(0));
}
_ { }
}
}
_ { }
@ -179,6 +180,10 @@ selectors. */
fn use_selectors_to_bind(b: &binders, e: @expr) -> option::t[bindings] {
let res = new_str_hash[arb_depth[matchable]]();
//need to do this first, to check vec lengths.
for sel: selector in b.literal_ast_matchers {
alt sel(match_expr(e)) { none. { ret none; } _ { } }
}
let never_mind: bool = false;
for each pair: @{key: ident, val: selector} in b.real_binders.items() {
alt pair.val(match_expr(e)) {
@ -186,12 +191,8 @@ fn use_selectors_to_bind(b: &binders, e: @expr) -> option::t[bindings] {
some(mtc) { res.insert(pair.key, mtc); }
}
}
if never_mind {
ret none; //HACK: `ret` doesn't work in `for each`
}
for sel: selector in b.literal_ast_matchers {
alt sel(match_expr(e)) { none. { ret none; } _ { } }
}
//HACK: `ret` doesn't work in `for each`
if never_mind { ret none; }
ret some(res);
}
@ -537,8 +538,8 @@ fn p_t_s_r_mac(cx: &ext_ctxt, mac: &ast::mac, s: &selector, b: &binders) {
_ { none }
}
}
b.real_binders.insert(id,
bind select_pt_1(cx, _, select_pt_2));
let final_step = bind select_pt_1(cx, _, select_pt_2);
b.real_binders.insert(id, compose_sels(s, final_step));
}
none. { no_des(cx, pth.span, "under `#<>`"); }
}
@ -557,7 +558,8 @@ fn p_t_s_r_mac(cx: &ext_ctxt, mac: &ast::mac, s: &selector, b: &binders) {
_ { none }
}
}
b.real_binders.insert(id, bind select_pt_1(cx, _, select_pt_2));
let final_step = bind select_pt_1(cx, _, select_pt_2);
b.real_binders.insert(id, compose_sels(s, final_step));
}
none. { no_des(cx, blk.span, "under `#{}`"); }
}
@ -576,7 +578,7 @@ fn ivec_to_vec[T](v: &T[]) -> vec[T] {
fn p_t_s_r_ellipses(cx: &ext_ctxt, repeat_me: @expr, s: &selector,
b: &binders) {
fn select(cx: &ext_ctxt, repeat_me: @expr, m: &matchable) ->
match_result {
match_result {
ret alt m {
match_expr(e) {
alt e.node {
@ -640,8 +642,15 @@ fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: (@expr)[], s: &selector,
}
}
fn add_new_extension(cx: &ext_ctxt, sp: span, args: &(@expr)[],
fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
body: option::t[str]) -> base::macro_def {
let args: (@ast::expr)[] = alt arg.node {
ast::expr_vec(elts, _, _) { elts }
_ {
cx.span_fatal(sp, "#macro requires arguments of the form `[...]`.")
}
};
let macro_name: option::t[str] = none;
let clauses: clause[] = ~[];
for arg: @expr in args {
@ -657,19 +666,16 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, args: &(@expr)[],
alt elts.(0u).node {
expr_mac(mac) {
alt mac.node {
mac_invoc(pth, invoc_args, body) {
mac_invoc(pth, invoc_arg, body) {
alt path_to_ident(pth) {
some(id) { macro_name = some(id); }
none. {
cx.span_fatal(pth.span,
"macro name " + "must not be a path");
"macro name must not be a path");
}
}
let bdrses = ~[];
for arg: @expr in invoc_args {
bdrses += ~[pattern_to_selectors(cx, arg)];
}
clauses += ~[{params: bdrses, body: elts.(1u)}];
clauses += ~[{params: pattern_to_selectors(cx, invoc_arg),
body: elts.(1u)}];
// FIXME: check duplicates (or just simplify
// the macro arg situation)
}
@ -702,32 +708,15 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, args: &(@expr)[],
},
ext: normal(ext)};
fn generic_extension(cx: &ext_ctxt, sp: span, args: &(@expr)[],
fn generic_extension(cx: &ext_ctxt, sp: span, arg: @expr,
body: option::t[str], clauses: clause[]) -> @expr {
for c: clause in clauses {
if ivec::len(args) != ivec::len(c.params) { cont; }
let i: uint = 0u;
let bdgs: bindings = new_str_hash[arb_depth[matchable]]();
let abort: bool = false;
while i < ivec::len(args) {
alt use_selectors_to_bind(c.params.(i), args.(i)) {
some(new_bindings) {
/* ick; I wish macros just took one expr */
for each it: @{key: ident, val: arb_depth[matchable]} in
new_bindings.items() {
bdgs.insert(it.key, it.val);
}
}
none. { abort = true; }
}
i += 1u;
alt use_selectors_to_bind(c.params, arg) {
some(bindings) {
ret transcribe(cx, bindings, c.body)
}
none. { cont; }
}
if abort { cont; }
ret transcribe(cx, bdgs, c.body);
}
cx.span_fatal(sp, "no clauses match macro invocation");
}

17
src/comp/syntax/fold.rs
View File

@ -130,15 +130,14 @@ fn fold_arg_(a: &arg, fld: ast_fold) -> arg {
//used in noop_fold_expr, and possibly elsewhere in the future
fn fold_mac_(m: &mac, fld: ast_fold) -> mac {
ret {node:
alt m.node {
mac_invoc(pth, args, body) {
mac_invoc(fld.fold_path(pth),
fld.map_exprs(fld.fold_expr, args), body)
}
mac_embed_type(ty) { mac_embed_type(fld.fold_ty(ty)) }
mac_embed_block(blk) { mac_embed_block(fld.fold_block(blk)) }
mac_ellipsis. { mac_ellipsis }
},
alt m.node {
mac_invoc(pth, arg, body) {
mac_invoc(fld.fold_path(pth), fld.fold_expr(arg), body)
}
mac_embed_type(ty) { mac_embed_type(fld.fold_ty(ty)) }
mac_embed_block(blk) { mac_embed_block(fld.fold_block(blk)) }
mac_ellipsis. { mac_ellipsis }
},
span: m.span};
}

13
src/comp/syntax/parse/parser.rs
View File

@ -1021,11 +1021,18 @@ fn parse_syntax_ext_naked(p: &parser, lo: uint) -> @ast::expr {
if ivec::len(pth.node.idents) == 0u {
p.fatal("expected a syntax expander name");
}
let es =
//temporary for a backwards-compatible cycle:
let es = if p.peek() == token::LPAREN {
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_expr, p);
parse_expr, p)
} else {
parse_seq(token::LBRACKET, token::RBRACKET, some(token::COMMA),
parse_expr, p)
};
let hi = es.span.hi;
ret mk_mac_expr(p, lo, hi, ast::mac_invoc(pth, es.node, none));
let e = mk_expr(p, es.span.lo, hi,
ast::expr_vec(es.node, ast::imm, ast::sk_rc));
ret mk_mac_expr(p, lo, hi, ast::mac_invoc(pth, e, none));
}
fn parse_self_method(p: &parser) -> @ast::expr {

11
src/comp/syntax/print/pprust.rs
View File

@ -642,16 +642,15 @@ fn print_if(s: &ps, test: &@ast::expr, blk: &ast::blk,
fn print_mac(s: &ps, m: &ast::mac) {
alt m.node {
ast::mac_invoc(path, args, body) {
ast::mac_invoc(path, arg, body) {
word(s.s, "#");
print_path(s, path);
if ivec::len(args) > 0u {
popen(s);
commasep_exprs(s, inconsistent, args);
pclose(s);
alt (arg.node) {
ast::expr_vec(_,_,_) {}
_ { word(s.s, " "); }
}
print_expr(s, arg);
// FIXME: extension 'body'
}
ast::mac_embed_type(ty) {
word(s.s, "#<");

2
src/comp/syntax/visit.rs
View File

@ -239,7 +239,7 @@ fn visit_exprs[E](exprs: &(@expr)[], e: &E, v: &vt[E]) {
fn visit_mac[E](m: mac, e: &E, v: &vt[E]) {
alt m.node {
ast::mac_invoc(pth, args, body) { visit_exprs(args, e, v); }
ast::mac_invoc(pth, arg, body) { visit_expr(arg, e, v); }
ast::mac_embed_type(ty) { v.visit_ty(ty, e, v); }
ast::mac_embed_block(blk) { v.visit_block(blk, e, v); }
ast::mac_ellipsis. { }

2
src/comp/syntax/walk.rs
View File

@ -262,7 +262,7 @@ fn walk_exprs(v: &ast_visitor, exprs: &(@ast::expr)[]) {
fn walk_mac(v: &ast_visitor, mac: ast::mac) {
alt mac.node {
ast::mac_invoc(pth, args, body) { walk_exprs(v, args); }
ast::mac_invoc(pth, arg, body) { walk_expr(v, arg); }
ast::mac_embed_type(ty) { walk_ty(v, ty); }
ast::mac_embed_block(blk) { walk_block(v, blk); }
ast::mac_ellipsis. { }

22
src/test/run-pass/macro-by-example-2.rs
View File

@ -1,34 +1,34 @@
fn main() {
#macro([#zip_or_unzip([[x, ...], [y, ...]]), [[x, y], ...]],
[#zip_or_unzip([[xx, yy], ...]), [[xx, ...], [yy, ...]]]);
#macro([#zip_or_unzip[[x, ...], [y, ...]], [[x, y], ...]],
[#zip_or_unzip[[xx, yy], ...], [[xx, ...], [yy, ...]]]);
assert (#zip_or_unzip([[1, 2, 3, 4], [5, 6, 7, 8]]) ==
assert (#zip_or_unzip[[1, 2, 3, 4], [5, 6, 7, 8]] ==
[[1, 5], [2, 6], [3, 7], [4, 8]]);
assert (#zip_or_unzip([[1, 5], [2, 6], [3, 7], [4, 8]]) ==
assert (#zip_or_unzip[[1, 5], [2, 6], [3, 7], [4, 8]] ==
[[1, 2, 3, 4], [5, 6, 7, 8]]);
#macro([#nested([[[x, ...], ...], [[y, ...], ...]]),
#macro([#nested[[[x, ...], ...], [[y, ...], ...]],
[[[x, y], ...], ...]]);
assert (#nested([[[1, 2, 3, 4, 5], [7, 8, 9, 10, 11, 12]],
[[-1, -2, -3, -4, -5], [-7, -8, -9, -10, -11, -12]]]) ==
assert (#nested[[[1, 2, 3, 4, 5], [7, 8, 9, 10, 11, 12]],
[[-1, -2, -3, -4, -5], [-7, -8, -9, -10, -11, -12]]] ==
[[[1, -1], [2, -2], [3, -3], [4, -4], [5, -5]],
[[7, -7], [8, -8], [9, -9], [10, -10], [11, -11],
[12, -12]]]);
#macro([#dup([y, [x, ...]]), [[y, x], ...]]);
#macro([#dup[y, [x, ...]], [[y, x], ...]]);
assert (#dup([1, [1, 2, 3, 4]]) == [[1, 1], [1, 2], [1, 3], [1, 4]]);
assert (#dup[1, [1, 2, 3, 4]] == [[1, 1], [1, 2], [1, 3], [1, 4]]);
#macro([#lambda(x, #<t>, body, #<s>),
#macro([#lambda[x, #<t>, body, #<s>],
{
fn result(x: t) -> s { ret body }
result
}]);
assert (#lambda(i, #<uint>, i + 4u, #<uint>)(12u) == 16u)
assert ((#lambda[i, #<uint>, i + 4u, #<uint>])(12u) == 16u)
}