bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add nodes for embedding types and blocks in expressions for macros.

Browse source
This commit is contained in:
Paul Stansifer 2011-06-29 18:07:04 -07:00
parent fd24fd5e31
commit 80cf4ecd3b
7 changed files with 58 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/comp/syntax/ast.rs
View file

@ -323,7 +323,6 @@ tag expr_ {
to expr_if_check. */
expr_if_check(@expr, block, option::t[@expr]);
expr_port(option::t[@ty]);
expr_chan(@expr);
expr_anon_obj(anon_obj, ty_param[]);
}

22
src/comp/syntax/fold.rs
View file

@ -445,6 +445,12 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
case (expr_anon_obj(?ao, ?typms)) {
expr_anon_obj(fold_anon_obj(ao), typms)
}
case (expr_embeded_type(?ty)) {
expr_embeded_type(fld.fold_ty(ty))
}
case (expr_embeded_block(?blk)) {
expr_embeded_block(fld.fold_block(blk))
}
}
}
@ -695,22 +701,6 @@ fn make_fold(&ast_fold_precursor afp) -> ast_fold {
fold_path = bind f_path(afp,result,_),
fold_local = bind f_local(afp,result,_));
ret result;
/*
ret rec(fold_crate = noop_fold_crate,
fold_crate_directive = noop_fold_crate_drective,
fold_view_item = noop_fold_view_item,
fold_native_item = noop_fold_native_item,
fold_item = noop_fold_item,
fold_method = noop_fold_method,
fold_block = noop_fold_block,
fold_stmt = noop_fold_stmt,
fold_arm = noop_fold_arm,
fold_pat = noop_fold_pat,
fold_decl = noop_fold_decl,
fold_expr = noop_fold_expr,
fold_ty = noop_fold_ty,
fold_constr = noop_fold_constr,
fold_fn = noop_fold_fn);*/
}

22
src/comp/syntax/parse/lexer.rs
View file

@ -361,12 +361,8 @@ fn next_token(&reader rdr) -> token::token {
} else { ret token::BINOP(op); }
}
alt (c) {
case (
// One-byte tokens.
'?') {
rdr.bump();
ret token::QUES;
}
case ('?') { rdr.bump(); ret token::QUES; }
case (';') { rdr.bump(); ret token::SEMI; }
case (',') { rdr.bump(); ret token::COMMA; }
case ('.') { rdr.bump(); ret token::DOT; }
@ -377,7 +373,18 @@ fn next_token(&reader rdr) -> token::token {
case ('[') { rdr.bump(); ret token::LBRACKET; }
case (']') { rdr.bump(); ret token::RBRACKET; }
case ('@') { rdr.bump(); ret token::AT; }
case ('#') { rdr.bump(); ret token::POUND; }
case ('#') {
rdr.bump();
if (rdr.curr() == '<') {
rdr.bump();
ret token::POUND_LT;
}
if (rdr.curr() == '{') {
rdr.bump();
ret token::POUND_LBRACE;
}
ret token::POUND;
}
case ('~') { rdr.bump(); ret token::TILDE; }
case (':') {
rdr.bump();
@ -386,9 +393,8 @@ fn next_token(&reader rdr) -> token::token {
ret token::MOD_SEP;
} else { ret token::COLON; }
}
case (
// Multi-byte tokens.
'=') {
case ('=') {
rdr.bump();
if (rdr.curr() == '=') {
rdr.bump();

18
src/comp/syntax/parse/parser.rs
View file

@ -804,6 +804,13 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA),
parse_expr, p);
ex = ast::expr_vec(es, mut, ast::sk_rc);
} else if (p.peek() == token::POUND_LT) {
p.bump();
ex = ast::expr_embeded_type(parse_ty(p));
expect(p, token::GT);
} else if (p.peek() == token::POUND_LBRACE) {
p.bump();
ex = ast::expr_embeded_block(parse_block_tail(p));
} else if (p.peek() == token::TILDE) {
p.bump();
alt (p.peek()) {
@ -1715,10 +1722,15 @@ fn stmt_ends_with_semi(&ast::stmt stmt) -> bool {
}
fn parse_block(&parser p) -> ast::block {
expect(p, token::LBRACE);
be parse_block_tail(p);
}
// some blocks start with "#{"...
fn parse_block_tail(&parser p) -> ast::block {
auto lo = p.get_lo_pos();
let (@ast::stmt)[] stmts = ~[];
let option::t[@ast::expr] expr = none;
expect(p, token::LBRACE);
while (p.peek() != token::RBRACE) {
alt (p.peek()) {
case (token::SEMI) {
@ -2204,8 +2216,10 @@ fn parse_outer_attrs_or_ext(&parser p) -> attr_or_ext {
if (p.peek() == token::LBRACKET) {
auto first_attr = parse_attribute_naked(p, ast::attr_outer, lo);
ret some(left(~[first_attr] + parse_outer_attributes(p)));
} else {
} else if (! (p.peek() == token::LT || p.peek() == token::LBRACKET)) {
ret some(right(parse_syntax_ext_naked(p, lo)));
} else {
ret none;
}
} else {
ret none;

24
src/comp/syntax/parse/token.rs
View file

@ -60,6 +60,8 @@ tag token {
LBRACE;
RBRACE;
POUND;
POUND_LBRACE;
POUND_LT;
/* Literals */
LIT_INT(int);
@ -110,11 +112,8 @@ fn to_str(lexer::reader r, token t) -> str {
case (ANDAND) { ret "&&"; }
case (BINOP(?op)) { ret binop_to_str(op); }
case (BINOPEQ(?op)) { ret binop_to_str(op) + "="; }
case (
/* Structural symbols */
AT) {
ret "@";
}
case (AT) { ret "@"; }
case (DOT) { ret "."; }
case (COMMA) { ret ","; }
case (SEMI) { ret ";"; }
@ -133,11 +132,10 @@ fn to_str(lexer::reader r, token t) -> str {
case (LBRACE) { ret "{"; }
case (RBRACE) { ret "}"; }
case (POUND) { ret "#"; }
case (
case (POUND_LBRACE) { ret "#{"; }
case (POUND_LT) { ret "#<"; }
/* Literals */
LIT_INT(?i)) {
ret int::to_str(i, 10u);
}
case (LIT_INT(?i)) { ret int::to_str(i, 10u); }
case (LIT_UINT(?u)) { ret uint::to_str(u, 10u); }
case (LIT_MACH_INT(?tm, ?i)) {
ret int::to_str(i, 10u) + "_" + ty_mach_to_str(tm);
@ -147,25 +145,19 @@ fn to_str(lexer::reader r, token t) -> str {
ty_mach_to_str(tm);
}
case (LIT_FLOAT(?s)) { ret interner::get[str](*r.get_interner(), s); }
case (LIT_STR(?s)) {
// FIXME: escape.
case (LIT_STR(?s)) { // FIXME: escape.
ret "\"" + interner::get[str](*r.get_interner(), s) + "\"";
}
case (LIT_CHAR(?c)) {
// FIXME: escape.
auto tmp = "'";
str::push_char(tmp, c);
str::push_byte(tmp, '\'' as u8);
ret tmp;
}
case (LIT_BOOL(?b)) { if (b) { ret "true"; } else { ret "false"; } }
case (
/* Name components */
IDENT(?s, _)) {
ret interner::get[str](*r.get_interner(), s);
}
case (IDENT(?s, _)) { ret interner::get[str](*r.get_interner(), s); }
case (IDX(?i)) { ret "_" + int::to_str(i, 10u); }
case (UNDERSCORE) { ret "_"; }
case (BRACEQUOTE(_)) { ret "<bracequote>"; }

6
src/comp/syntax/visit.rs
View file

@ -397,6 +397,12 @@ fn visit_expr[E](&@expr ex, &E e, &vt[E] v) {
m.node.id, e, v);
}
}
case (expr_embeded_type(?ty)) {
vt(v).visit_ty(ty, e, v);
}
case (expr_embeded_block(?blk)) {
vt(v).visit_block(blk, e, v);
}
}
}

6
src/comp/syntax/walk.rs
View file

@ -410,6 +410,12 @@ fn walk_expr(&ast_visitor v, @ast::expr e) {
v.visit_method_post(m);
}
}
case (ast::expr_embeded_type(?ty)) {
walk_ty(v, ty);
}
case (ast::expr_embeded_block(?blk)) {
walk_block(v, blk);
}
}
v.visit_expr_post(e);
}