From 70bf54bcac587c0bc8a3a593bda75115e4c23aa8 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Tue, 1 Feb 2011 16:23:48 -0800 Subject: Implement 'else if' --- src/comp/front/parser.rs | 42 ++++++++++++++++++++++++++++++++---------- 1 file changed, 32 insertions(+), 10 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index bef37a3c..0c90df5c 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -891,18 +891,40 @@ impure fn parse_if_expr(parser p) -> @ast.expr { auto cond = parse_expr(p); expect(p, token.RPAREN); auto thn = parse_block(p); - let option.t[ast.block] els = none[ast.block]; hi = thn.span; - alt (p.peek()) { - case (token.ELSE) { - p.bump(); - auto eblk = parse_block(p); - els = some(eblk); - hi = eblk.span; + + let vec[tup(@ast.expr, ast.block)] elifs = vec(); + let option.t[ast.block] els = none[ast.block]; + let bool parsing_elses = true; + while (parsing_elses) { + alt (p.peek()) { + case (token.ELSE) { + expect(p, token.ELSE); + alt (p.peek()) { + case (token.IF) { + expect(p, token.IF); + expect(p, token.LPAREN); + auto elifcond = parse_expr(p); + expect(p, token.RPAREN); + auto elifthn = parse_block(p); + elifs += tup(elifcond, elifthn); + hi = elifthn.span; + } + case (_) { + auto eblk = parse_block(p); + els = some(eblk); + hi = eblk.span; + parsing_elses = false; + } + } + } + case (_) { + parsing_elses = false; + } } - case (_) { /* fall through */ } } - ret @spanned(lo, hi, ast.expr_if(cond, thn, els, ast.ann_none)); + + ret @spanned(lo, hi, ast.expr_if(cond, thn, elifs, els, ast.ann_none)); } impure fn parse_head_local(parser p) -> @ast.decl { @@ -1331,7 +1353,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { case (ast.expr_unary(_,_,_)) { ret true; } case (ast.expr_lit(_,_)) { ret true; } case (ast.expr_cast(_,_,_)) { ret true; } - case (ast.expr_if(_,_,_,_)) { ret false; } + case (ast.expr_if(_,_,_,_,_)) { ret false; } case (ast.expr_for(_,_,_,_)) { ret false; } case (ast.expr_while(_,_,_)) { ret false; } case (ast.expr_do_while(_,_,_)) { ret false; } -- cgit v1.2.3 From 4b06dc574ba7d3ae50795cbe4f10d4be6e9c64a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Tue, 1 Feb 2011 13:40:04 -0500 Subject: Add very minimal support for native modules. For now they must be empty. --- src/comp/front/parser.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 0c90df5c..16adfedb 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1577,6 +1577,20 @@ impure fn parse_item_mod(parser p) -> @ast.item { ret @spanned(lo, hi, item); } +impure fn parse_item_native_mod(parser p) -> @ast.item { + auto lo = p.get_span(); + expect(p, token.NATIVE); + auto native_name = parse_str_lit(p); + expect(p, token.MOD); + auto id = parse_ident(p); + expect(p, token.LBRACE); + auto m = rec(native_name = native_name); + auto hi = p.get_span(); + expect(p, token.RBRACE); + auto item = ast.item_native_mod(id, m, p.next_def_id()); + ret @spanned(lo, hi, item); +} + impure fn parse_item_type(parser p) -> @ast.item { auto lo = p.get_span(); expect(p, token.TYPE); @@ -1717,6 +1731,11 @@ impure fn parse_item(parser p) -> @ast.item { check (lyr == ast.layer_value); ret parse_item_mod(p); } + case (token.NATIVE) { + check (eff == ast.eff_pure); + check (lyr == ast.layer_value); + ret parse_item_native_mod(p); + } case (token.TYPE) { check (eff == ast.eff_pure); ret parse_item_type(p); -- cgit v1.2.3 From dd3ed6139a6fc6fda15403d0b5679535959945e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Wed, 2 Feb 2011 10:43:57 -0500 Subject: Add most of the plumbing for native items and add support for parsing native type declarations. --- src/comp/front/parser.rs | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 16adfedb..c088e68d 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1577,6 +1577,39 @@ impure fn parse_item_mod(parser p) -> @ast.item { ret @spanned(lo, hi, item); } + +impure fn parse_item_native_type(parser p) -> @ast.native_item { + auto lo = p.get_span(); + expect(p, token.TYPE); + auto id = parse_ident(p); + auto hi = p.get_span(); + expect(p, token.SEMI); + auto item = ast.native_item_ty(id, p.next_def_id()); + ret @spanned(lo, hi, item); +} + +impure fn parse_native_item(parser p) -> @ast.native_item { + alt (p.peek()) { + case (token.TYPE) { + ret parse_item_native_type(p); + } + } +} + +impure fn parse_native_mod_items(parser p, + str native_name) -> ast.native_mod { + auto index = new_str_hash[@ast.native_item](); + let vec[@ast.native_item] items = vec(); + while (p.peek() != token.RBRACE) { + auto item = parse_native_item(p); + items += vec(item); + + // Index the item. + ast.index_native_item(index, item); + } + ret rec(native_name=native_name, items=items, index=index); +} + impure fn parse_item_native_mod(parser p) -> @ast.item { auto lo = p.get_span(); expect(p, token.NATIVE); @@ -1584,7 +1617,7 @@ impure fn parse_item_native_mod(parser p) -> @ast.item { expect(p, token.MOD); auto id = parse_ident(p); expect(p, token.LBRACE); - auto m = rec(native_name = native_name); + auto m = parse_native_mod_items(p, native_name); auto hi = p.get_span(); expect(p, token.RBRACE); auto item = ast.item_native_mod(id, m, p.next_def_id()); -- cgit v1.2.3 From 302cafa81dcc868e840c78f2bfbf41929de8a487 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Fri, 4 Feb 2011 09:46:10 -0500 Subject: Factor the parsing of "type foo" into parse_type_decl. --- src/comp/front/parser.rs | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index c088e68d..1d54a6e1 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1577,15 +1577,12 @@ impure fn parse_item_mod(parser p) -> @ast.item { ret @spanned(lo, hi, item); } - impure fn parse_item_native_type(parser p) -> @ast.native_item { - auto lo = p.get_span(); - expect(p, token.TYPE); - auto id = parse_ident(p); + auto t = parse_type_decl(p); auto hi = p.get_span(); expect(p, token.SEMI); - auto item = ast.native_item_ty(id, p.next_def_id()); - ret @spanned(lo, hi, item); + auto item = ast.native_item_ty(t._1, p.next_def_id()); + ret @spanned(t._0, hi, item); } impure fn parse_native_item(parser p) -> @ast.native_item { @@ -1624,18 +1621,23 @@ impure fn parse_item_native_mod(parser p) -> @ast.item { ret @spanned(lo, hi, item); } -impure fn parse_item_type(parser p) -> @ast.item { +impure fn parse_type_decl(parser p) -> tup(span, ast.ident) { auto lo = p.get_span(); expect(p, token.TYPE); auto id = parse_ident(p); + ret tup(lo, id); +} + +impure fn parse_item_type(parser p) -> @ast.item { + auto t = parse_type_decl(p); auto tps = parse_ty_params(p); expect(p, token.EQ); auto ty = parse_ty(p); auto hi = p.get_span(); expect(p, token.SEMI); - auto item = ast.item_ty(id, ty, tps, p.next_def_id(), ast.ann_none); - ret @spanned(lo, hi, item); + auto item = ast.item_ty(t._1, ty, tps, p.next_def_id(), ast.ann_none); + ret @spanned(t._0, hi, item); } impure fn parse_item_tag(parser p) -> @ast.item { -- cgit v1.2.3 From 57bb9d809bb029caf7b38042a433153bb965e1fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Fri, 4 Feb 2011 11:10:04 -0500 Subject: Parse function declarations. --- src/comp/front/parser.rs | 38 +++++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 9 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 1d54a6e1..e04b8221 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1441,7 +1441,7 @@ impure fn parse_ty_params(parser p) -> vec[ast.ty_param] { ret ty_params; } -impure fn parse_fn(parser p, ast.effect eff, bool is_iter) -> ast._fn { +impure fn parse_fn_decl(parser p, ast.effect eff) -> ast.fn_decl { auto pf = parse_arg; let util.common.spanned[vec[ast.arg]] inputs = // FIXME: passing parse_arg as an lval doesn't work at the @@ -1459,18 +1459,19 @@ impure fn parse_fn(parser p, ast.effect eff, bool is_iter) -> ast._fn { } else { output = @spanned(inputs.span, inputs.span, ast.ty_nil); } + ret rec(effect=eff, inputs=inputs.node, output=output); +} +impure fn parse_fn(parser p, ast.effect eff, bool is_iter) -> ast._fn { + auto decl = parse_fn_decl(p, eff); auto body = parse_block(p); - - ret rec(effect = eff, + ret rec(decl = decl, is_iter = is_iter, - inputs = inputs.node, - output = output, body = body); } -impure fn parse_item_fn_or_iter(parser p, ast.effect eff, - bool is_iter) -> @ast.item { +impure fn parse_fn_header(parser p, bool is_iter) -> tup(span, ast.ident, + vec[ast.ty_param]) { auto lo = p.get_span(); if (is_iter) { expect(p, token.ITER); @@ -1479,10 +1480,16 @@ impure fn parse_item_fn_or_iter(parser p, ast.effect eff, } auto id = parse_ident(p); auto ty_params = parse_ty_params(p); + ret tup(lo, id, ty_params); +} + +impure fn parse_item_fn_or_iter(parser p, ast.effect eff, + bool is_iter) -> @ast.item { + auto t = parse_fn_header(p, is_iter); auto f = parse_fn(p, eff, is_iter); - auto item = ast.item_fn(id, f, ty_params, + auto item = ast.item_fn(t._1, f, t._2, p.next_def_id(), ast.ann_none); - ret @spanned(lo, f.body.span, item); + ret @spanned(t._0, f.body.span, item); } @@ -1585,11 +1592,24 @@ impure fn parse_item_native_type(parser p) -> @ast.native_item { ret @spanned(t._0, hi, item); } +impure fn parse_item_native_fn(parser p, ast.effect eff) -> @ast.native_item { + auto t = parse_fn_header(p, false); + auto decl = parse_fn_decl(p, eff); + auto hi = p.get_span(); + expect(p, token.SEMI); + auto item = ast.native_item_fn(t._1, decl, t._2, p.next_def_id()); + ret @spanned(t._0, hi, item); +} + impure fn parse_native_item(parser p) -> @ast.native_item { + let ast.effect eff = parse_effect(p); alt (p.peek()) { case (token.TYPE) { ret parse_item_native_type(p); } + case (token.FN) { + ret parse_item_native_fn(p, eff); + } } } -- cgit v1.2.3 From 8122e0c54280545c28e8067c0e3a19253fe3aa9b Mon Sep 17 00:00:00 2001 From: Rafael Avila de Espindola Date: Mon, 7 Feb 2011 12:46:28 -0500 Subject: Add support for native mod foo = "bar" ... --- src/comp/front/parser.rs | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index e04b8221..8d130935 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1630,9 +1630,20 @@ impure fn parse_native_mod_items(parser p, impure fn parse_item_native_mod(parser p) -> @ast.item { auto lo = p.get_span(); expect(p, token.NATIVE); - auto native_name = parse_str_lit(p); + auto has_eq; + auto native_name = ""; + if (p.peek() == token.MOD) { + has_eq = true; + } else { + native_name = parse_str_lit(p); + has_eq = false; + } expect(p, token.MOD); auto id = parse_ident(p); + if (has_eq) { + expect(p, token.EQ); + native_name = parse_str_lit(p); + } expect(p, token.LBRACE); auto m = parse_native_mod_items(p, native_name); auto hi = p.get_span(); -- cgit v1.2.3 From 378c0087ca7572cd17726c704fe04d57bf4687af Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Sun, 30 Jan 2011 17:18:19 -0500 Subject: Parse 'be' statement. Pass tailcall tests. No actual tailcalls yet. --- src/comp/front/parser.rs | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 8d130935..a1b519ba 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1200,6 +1200,12 @@ impure fn parse_stmt(parser p) -> @ast.stmt { } } + case (token.BE) { + p.bump(); + auto e = parse_expr(p); + ret @spanned(lo, e.span, ast.stmt_be(e)); + } + case (token.LET) { auto decl = parse_let(p); auto hi = p.get_span(); @@ -1340,6 +1346,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { } } case (ast.stmt_ret(_)) { ret true; } + case (ast.stmt_be(_)) { ret true; } case (ast.stmt_log(_)) { ret true; } case (ast.stmt_check_expr(_)) { ret true; } case (ast.stmt_fail) { ret true; } -- cgit v1.2.3 From f17a3421e01399bcc1a6f8540273d7b4440397a1 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 9 Feb 2011 22:36:37 -0500 Subject: Cleanup for 'be' statement and comments about future typestate --- src/comp/front/parser.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index a1b519ba..ea4cf12c 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1203,7 +1203,13 @@ impure fn parse_stmt(parser p) -> @ast.stmt { case (token.BE) { p.bump(); auto e = parse_expr(p); - ret @spanned(lo, e.span, ast.stmt_be(e)); + // FIXME: Is this the right place for this check? + if /*check*/ (ast.is_call_expr(e)) { + ret @spanned(lo, e.span, ast.stmt_be(e)); + } + else { + p.err("Non-call expression in tail call"); + } } case (token.LET) { -- cgit v1.2.3 From b59d98ccb9de56a49768586961ce745d462e0697 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Thu, 10 Feb 2011 18:58:58 -0800 Subject: Parse effects and layers in a couple contexts; drop on floor as we have nowhere to put them yet. --- src/comp/front/parser.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index ea4cf12c..97e86b7f 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -173,6 +173,10 @@ impure fn parse_ty_obj(parser p, &mutable ast.span hi) -> ast.ty_ { expect(p, token.OBJ); impure fn parse_method_sig(parser p) -> ast.ty_method { auto flo = p.get_span(); + + // FIXME: do something with this, currently it's dropped on the floor. + let ast.effect eff = parse_effect(p); + expect(p, token.FN); auto ident = parse_ident(p); auto f = parse_ty_fn(p, flo); @@ -204,6 +208,12 @@ impure fn parse_ty(parser p) -> @ast.ty { auto lo = p.get_span(); auto hi = lo; let ast.ty_ t; + + // FIXME: do something with these; currently they're + // dropped on the floor. + let ast.effect eff = parse_effect(p); + let ast.layer lyr = parse_layer(p); + alt (p.peek()) { case (token.BOOL) { p.bump(); t = ast.ty_bool; } case (token.INT) { p.bump(); t = ast.ty_int; } -- cgit v1.2.3 From a396652766bc6aa2b4526ddd9807439ecd12033a Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Thu, 10 Feb 2011 18:59:23 -0800 Subject: Add pat_lit to ast, and support parsing it. --- src/comp/front/parser.rs | 43 +++++++++++++++++++++---------------------- 1 file changed, 21 insertions(+), 22 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 97e86b7f..2fa4afeb 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -351,9 +351,9 @@ impure fn parse_seq[T](token.token bra, ret spanned(lo, hi, v); } -impure fn parse_lit(parser p) -> option.t[ast.lit] { +impure fn parse_lit(parser p) -> ast.lit { auto lo = p.get_span(); - let ast.lit_ lit; + let ast.lit_ lit = ast.lit_nil; alt (p.peek()) { case (token.LIT_INT(?i)) { p.bump(); @@ -379,12 +379,11 @@ impure fn parse_lit(parser p) -> option.t[ast.lit] { p.bump(); lit = ast.lit_str(s); } - case (_) { - lit = ast.lit_nil; // FIXME: typestate bug requires this - ret none[ast.lit]; + case (?t) { + unexpected(p, t); } } - ret some(spanned(lo, lo, lit)); + ret spanned(lo, lo, lit); } fn is_ident(token.token t) -> bool { @@ -565,15 +564,9 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { } case (_) { - alt (parse_lit(p)) { - case (some[ast.lit](?lit)) { - hi = lit.span; - ex = ast.expr_lit(@lit, ast.ann_none); - } - case (none[ast.lit]) { - p.err("expecting expression"); - } - } + auto lit = parse_lit(p); + hi = lit.span; + ex = ast.expr_lit(@lit, ast.ann_none); } } @@ -1081,10 +1074,12 @@ impure fn parse_initializer(parser p) -> option.t[@ast.expr] { impure fn parse_pat(parser p) -> @ast.pat { auto lo = p.get_span(); - + auto hi = lo; auto pat = ast.pat_wild(ast.ann_none); // FIXME: typestate bug + alt (p.peek()) { case (token.UNDERSCORE) { + hi = p.get_span(); p.bump(); pat = ast.pat_wild(ast.ann_none); } @@ -1092,6 +1087,7 @@ impure fn parse_pat(parser p) -> @ast.pat { p.bump(); alt (p.peek()) { case (token.IDENT(?id)) { + hi = p.get_span(); p.bump(); pat = ast.pat_bind(id, p.next_def_id(), ast.ann_none); } @@ -1104,13 +1100,16 @@ impure fn parse_pat(parser p) -> @ast.pat { } case (token.IDENT(?id)) { auto tag_path = parse_path(p, GREEDY); + hi = tag_path.span; let vec[@ast.pat] args; alt (p.peek()) { case (token.LPAREN) { auto f = parse_pat; - args = parse_seq[@ast.pat](token.LPAREN, token.RPAREN, - some(token.COMMA), f, p).node; + auto a = parse_seq[@ast.pat](token.LPAREN, token.RPAREN, + some(token.COMMA), f, p); + args = a.node; + hi = a.span; } case (_) { args = vec(); } } @@ -1118,13 +1117,13 @@ impure fn parse_pat(parser p) -> @ast.pat { pat = ast.pat_tag(tag_path, args, none[ast.variant_def], ast.ann_none); } - case (?tok) { - p.err("expected pattern but found " + token.to_str(tok)); - fail; + case (_) { + auto lit = parse_lit(p); + hi = lit.span; + pat = ast.pat_lit(@lit, ast.ann_none); } } - auto hi = p.get_span(); ret @spanned(lo, hi, pat); } -- cgit v1.2.3 From c89460bb659e1af1a3618cfe8d7fa304e531916d Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Thu, 10 Feb 2011 19:04:37 -0800 Subject: Support indexing pat_lit. --- src/comp/front/parser.rs | 1 + 1 file changed, 1 insertion(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 2fa4afeb..87bbe57f 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1331,6 +1331,7 @@ fn index_arm(@ast.pat pat) -> hashmap[ast.ident,ast.def_id] { alt (pat.node) { case (ast.pat_bind(?i, ?def_id, _)) { index.insert(i, def_id); } case (ast.pat_wild(_)) { /* empty */ } + case (ast.pat_lit(_, _)) { /* empty */ } case (ast.pat_tag(_, ?pats, _, _)) { for (@ast.pat p in pats) { do_index_arm(index, p); -- cgit v1.2.3 From 59bce06a967b3806c3d874b8956857f0f01287e1 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 14 Feb 2011 15:52:38 -0800 Subject: Expand expr_rec to take its optional trailing 'with' parameter. --- src/comp/front/parser.rs | 41 ++++++++++++++++++++++++++++++++--------- 1 file changed, 32 insertions(+), 9 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 87bbe57f..2f037dfb 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -529,14 +529,37 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { case (token.REC) { p.bump(); - auto pf = parse_field; - auto fs = - parse_seq[ast.field](token.LPAREN, - token.RPAREN, - some(token.COMMA), - pf, p); - hi = fs.span; - ex = ast.expr_rec(fs.node, ast.ann_none); + expect(p, token.LPAREN); + auto fields = vec(parse_field(p)); + + auto more = true; + auto base = none[@ast.expr]; + while (more) { + alt (p.peek()) { + case (token.RPAREN) { + hi = p.get_span(); + p.bump(); + more = false; + } + case (token.WITH) { + p.bump(); + base = some[@ast.expr](parse_expr(p)); + hi = p.get_span(); + expect(p, token.RPAREN); + more = false; + } + case (token.COMMA) { + p.bump(); + fields += parse_field(p); + } + case (?t) { + unexpected(p, t); + } + } + + } + + ex = ast.expr_rec(fields, base, ast.ann_none); } case (token.BIND) { @@ -1370,7 +1393,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { alt (e.node) { case (ast.expr_vec(_,_)) { ret true; } case (ast.expr_tup(_,_)) { ret true; } - case (ast.expr_rec(_,_)) { ret true; } + case (ast.expr_rec(_,_,_)) { ret true; } case (ast.expr_call(_,_,_)) { ret true; } case (ast.expr_binary(_,_,_,_)) { ret true; } case (ast.expr_unary(_,_,_)) { ret true; } -- cgit v1.2.3 From 890d027b653edd1722b186a5723944e622736313 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 14 Feb 2011 16:33:25 -0800 Subject: Add parse support for expr_ext. --- src/comp/front/parser.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 2f037dfb..e5ea673a 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -586,6 +586,17 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { ex = ast.expr_bind(e, es.node, ast.ann_none); } + case (token.POUND) { + p.bump(); + auto pf = parse_expr; + auto es = parse_seq[@ast.expr](token.LPAREN, + token.RPAREN, + some(token.COMMA), + pf, p); + hi = es.span; + ex = ast.expr_ext(es.node, none[@ast.expr], ast.ann_none); + } + case (_) { auto lit = parse_lit(p); hi = lit.span; -- cgit v1.2.3 From 88cb9663639e915d2b69cef7ec514043ed39e5f4 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 14 Feb 2011 16:35:08 -0800 Subject: Adjust commented-out diagnostic log statement in parser.rs. --- src/comp/front/parser.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index e5ea673a..1296113a 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -41,11 +41,12 @@ impure fn new_parser(session.session sess, lexer.reader rdr) { fn peek() -> token.token { - // log token.to_str(tok); ret tok; } impure fn bump() { + // log rdr.get_filename() + // + ":" + common.istr(lo.line as int); tok = lexer.next_token(rdr); lo = rdr.get_mark_pos(); hi = rdr.get_curr_pos(); -- cgit v1.2.3 From f1f33abdeba156523d6db1752bbff75dc4088724 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 14 Feb 2011 17:46:28 -0800 Subject: Move all non-decl/non-expr stmts to exprs. --- src/comp/front/parser.rs | 116 +++++++++++++++++++++++------------------------ 1 file changed, 58 insertions(+), 58 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 1296113a..5ffaca19 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -598,6 +598,59 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { ex = ast.expr_ext(es.node, none[@ast.expr], ast.ann_none); } + case (token.FAIL) { + p.bump(); + ex = ast.expr_fail; + } + + case (token.LOG) { + p.bump(); + auto e = parse_expr(p); + auto hi = e.span; + ex = ast.expr_log(e); + } + + case (token.CHECK) { + p.bump(); + alt (p.peek()) { + case (token.LPAREN) { + auto e = parse_expr(p); + auto hi = e.span; + ex = ast.expr_check_expr(e); + } + case (_) { + p.get_session().unimpl("constraint-check stmt"); + } + } + } + + case (token.RET) { + p.bump(); + alt (p.peek()) { + case (token.SEMI) { + ex = ast.expr_ret(none[@ast.expr]); + } + case (_) { + auto e = parse_expr(p); + hi = e.span; + ex = ast.expr_ret(some[@ast.expr](e)); + } + } + } + + case (token.BE) { + p.bump(); + auto e = parse_expr(p); + // FIXME: Is this the right place for this check? + if /*check*/ (ast.is_call_expr(e)) { + hi = e.span; + ex = ast.expr_be(e); + } + else { + p.err("Non-call expression in tail call"); + } + } + case (_) { auto lit = parse_lit(p); hi = lit.span; @@ -1203,59 +1256,6 @@ impure fn parse_stmt(parser p) -> @ast.stmt { auto lo = p.get_span(); alt (p.peek()) { - case (token.LOG) { - p.bump(); - auto e = parse_expr(p); - auto hi = p.get_span(); - ret @spanned(lo, hi, ast.stmt_log(e)); - } - - case (token.CHECK) { - p.bump(); - alt (p.peek()) { - case (token.LPAREN) { - auto e = parse_expr(p); - auto hi = p.get_span(); - ret @spanned(lo, hi, ast.stmt_check_expr(e)); - } - case (_) { - p.get_session().unimpl("constraint-check stmt"); - } - } - } - - case (token.FAIL) { - p.bump(); - ret @spanned(lo, p.get_span(), ast.stmt_fail); - } - - case (token.RET) { - p.bump(); - alt (p.peek()) { - case (token.SEMI) { - ret @spanned(lo, p.get_span(), - ast.stmt_ret(none[@ast.expr])); - } - case (_) { - auto e = parse_expr(p); - ret @spanned(lo, e.span, - ast.stmt_ret(some[@ast.expr](e))); - } - } - } - - case (token.BE) { - p.bump(); - auto e = parse_expr(p); - // FIXME: Is this the right place for this check? - if /*check*/ (ast.is_call_expr(e)) { - ret @spanned(lo, e.span, ast.stmt_be(e)); - } - else { - p.err("Non-call expression in tail call"); - } - } - case (token.LET) { auto decl = parse_let(p); auto hi = p.get_span(); @@ -1396,11 +1396,6 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { case (ast.decl_item(_)) { ret false; } } } - case (ast.stmt_ret(_)) { ret true; } - case (ast.stmt_be(_)) { ret true; } - case (ast.stmt_log(_)) { ret true; } - case (ast.stmt_check_expr(_)) { ret true; } - case (ast.stmt_fail) { ret true; } case (ast.stmt_expr(?e)) { alt (e.node) { case (ast.expr_vec(_,_)) { ret true; } @@ -1423,6 +1418,11 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { case (ast.expr_field(_,_,_)) { ret true; } case (ast.expr_index(_,_,_)) { ret true; } case (ast.expr_path(_,_,_)) { ret true; } + case (ast.expr_fail) { ret true; } + case (ast.expr_ret(_)) { ret true; } + case (ast.expr_be(_)) { ret true; } + case (ast.expr_log(_)) { ret true; } + case (ast.expr_check_expr(_)) { ret true; } } } } -- cgit v1.2.3 From 15a01f5c3691a152793d8933a7be9d16a0fc7030 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 14 Feb 2011 17:58:32 -0800 Subject: Add basic front-end support for expr_put. --- src/comp/front/parser.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 5ffaca19..a779d013 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -638,6 +638,20 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { } } + case (token.PUT) { + p.bump(); + alt (p.peek()) { + case (token.SEMI) { + ex = ast.expr_put(none[@ast.expr]); + } + case (_) { + auto e = parse_expr(p); + hi = e.span; + ex = ast.expr_put(some[@ast.expr](e)); + } + } + } + case (token.BE) { p.bump(); auto e = parse_expr(p); @@ -1420,6 +1434,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { case (ast.expr_path(_,_,_)) { ret true; } case (ast.expr_fail) { ret true; } case (ast.expr_ret(_)) { ret true; } + case (ast.expr_put(_)) { ret true; } case (ast.expr_be(_)) { ret true; } case (ast.expr_log(_)) { ret true; } case (ast.expr_check_expr(_)) { ret true; } -- cgit v1.2.3 From 4a72a23171d87fb5a0f9b7ad039944856b93bf0f Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 14 Feb 2011 18:17:31 -0800 Subject: Add basic front-end support for 'for each' loops. --- src/comp/front/parser.rs | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index a779d013..ddadc789 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1049,8 +1049,14 @@ impure fn parse_head_local(parser p) -> @ast.decl { impure fn parse_for_expr(parser p) -> @ast.expr { auto lo = p.get_span(); auto hi = lo; + auto is_each = false; expect(p, token.FOR); + if (p.peek() == token.EACH) { + is_each = true; + p.bump(); + } + expect (p, token.LPAREN); auto decl = parse_head_local(p); @@ -1060,9 +1066,16 @@ impure fn parse_for_expr(parser p) -> @ast.expr { expect(p, token.RPAREN); auto body = parse_block(p); hi = body.span; - ret @spanned(lo, hi, ast.expr_for(decl, seq, body, ast.ann_none)); + if (is_each) { + ret @spanned(lo, hi, ast.expr_for_each(decl, seq, body, + ast.ann_none)); + } else { + ret @spanned(lo, hi, ast.expr_for(decl, seq, body, + ast.ann_none)); + } } + impure fn parse_while_expr(parser p) -> @ast.expr { auto lo = p.get_span(); auto hi = lo; @@ -1422,6 +1435,8 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { case (ast.expr_cast(_,_,_)) { ret true; } case (ast.expr_if(_,_,_,_,_)) { ret false; } case (ast.expr_for(_,_,_,_)) { ret false; } + case (ast.expr_for_each(_,_,_,_)) + { ret false; } case (ast.expr_while(_,_,_)) { ret false; } case (ast.expr_do_while(_,_,_)) { ret false; } case (ast.expr_alt(_,_,_)) { ret false; } -- cgit v1.2.3 From 2bba49a9feed613c2f018d5aa751df3c7a49a3d6 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Tue, 15 Feb 2011 12:20:13 -0800 Subject: Fix missing path in expr_ext. --- src/comp/front/parser.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index ddadc789..085255a4 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -589,13 +589,14 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { case (token.POUND) { p.bump(); + auto pth = parse_path(p, GREEDY); auto pf = parse_expr; auto es = parse_seq[@ast.expr](token.LPAREN, token.RPAREN, some(token.COMMA), pf, p); hi = es.span; - ex = ast.expr_ext(es.node, none[@ast.expr], ast.ann_none); + ex = ast.expr_ext(pth, es.node, none[@ast.expr], ast.ann_none); } case (token.FAIL) { -- cgit v1.2.3 From 9ae89bd404803be6b820189d8e0480b3395d05ee Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Tue, 15 Feb 2011 12:20:30 -0800 Subject: Add _mutable unop. --- src/comp/front/parser.rs | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 085255a4..8acc8897 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -811,6 +811,13 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr { ex = ast.expr_unary(ast.box, e, ast.ann_none); } + case (token.MUTABLE) { + p.bump(); + auto e = parse_prefix_expr(p); + hi = e.span; + ex = ast.expr_unary(ast._mutable, e, ast.ann_none); + } + case (_) { ret parse_dot_or_call_expr(p); } -- cgit v1.2.3 From 012fa69ea500aa31cb3dd2cd3df67ecd3eefd44e Mon Sep 17 00:00:00 2001 From: Rafael Avila de Espindola Date: Wed, 16 Feb 2011 14:02:02 -0500 Subject: More typechecking for native types and the needed plumbing in codegen. --- src/comp/front/parser.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 8acc8897..a108d243 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1693,7 +1693,8 @@ impure fn parse_item_native_fn(parser p, ast.effect eff) -> @ast.native_item { auto decl = parse_fn_decl(p, eff); auto hi = p.get_span(); expect(p, token.SEMI); - auto item = ast.native_item_fn(t._1, decl, t._2, p.next_def_id()); + auto item = ast.native_item_fn(t._1, decl, t._2, p.next_def_id(), + ast.ann_none); ret @spanned(t._0, hi, item); } -- cgit v1.2.3 From 34c60b6edb810d9f142d248b27d8e6e34c95d63c Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Fri, 18 Feb 2011 17:30:57 -0800 Subject: Make a tag for iterness / fnness, teach many places about it. --- src/comp/front/parser.rs | 90 +++++++++++++++++++++++++++--------------------- 1 file changed, 51 insertions(+), 39 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index a108d243..71b06b45 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -133,7 +133,8 @@ impure fn parse_str_lit(parser p) -> ast.ident { } -impure fn parse_ty_fn(parser p, ast.span lo) -> ast.ty_ { +impure fn parse_ty_fn(ast.proto proto, parser p, + ast.span lo) -> ast.ty_ { impure fn parse_fn_input_ty(parser p) -> rec(ast.mode mode, @ast.ty ty) { auto mode; if (p.peek() == token.BINOP(token.AND)) { @@ -167,7 +168,16 @@ impure fn parse_ty_fn(parser p, ast.span lo) -> ast.ty_ { output = @spanned(lo, inputs.span, ast.ty_nil); } - ret ast.ty_fn(inputs.node, output); + ret ast.ty_fn(proto, inputs.node, output); +} + +impure fn parse_proto(parser p) -> ast.proto { + alt (p.peek()) { + case (token.ITER) { p.bump(); ret ast.proto_iter; } + case (token.FN) { p.bump(); ret ast.proto_fn; } + case (?t) { unexpected(p, t); } + } + fail; } impure fn parse_ty_obj(parser p, &mutable ast.span hi) -> ast.ty_ { @@ -177,14 +187,14 @@ impure fn parse_ty_obj(parser p, &mutable ast.span hi) -> ast.ty_ { // FIXME: do something with this, currently it's dropped on the floor. let ast.effect eff = parse_effect(p); - - expect(p, token.FN); + let ast.proto proto = parse_proto(p); auto ident = parse_ident(p); - auto f = parse_ty_fn(p, flo); + auto f = parse_ty_fn(proto, p, flo); expect(p, token.SEMI); alt (f) { - case (ast.ty_fn(?inputs, ?output)) { - ret rec(ident=ident, inputs=inputs, output=output); + case (ast.ty_fn(?proto, ?inputs, ?output)) { + ret rec(proto=proto, ident=ident, + inputs=inputs, output=output); } } fail; @@ -286,9 +296,20 @@ impure fn parse_ty(parser p) -> @ast.ty { case (token.FN) { auto flo = p.get_span(); p.bump(); - t = parse_ty_fn(p, flo); + t = parse_ty_fn(ast.proto_fn, p, flo); alt (t) { - case (ast.ty_fn(_, ?out)) { + case (ast.ty_fn(_, _, ?out)) { + hi = out.span; + } + } + } + + case (token.ITER) { + auto flo = p.get_span(); + p.bump(); + t = parse_ty_fn(ast.proto_iter, p, flo); + alt (t) { + case (ast.ty_fn(_, _, ?out)) { hi = out.span; } } @@ -1537,7 +1558,8 @@ impure fn parse_ty_params(parser p) -> vec[ast.ty_param] { ret ty_params; } -impure fn parse_fn_decl(parser p, ast.effect eff) -> ast.fn_decl { +impure fn parse_fn_decl(parser p, ast.proto proto, + ast.effect eff) -> ast.fn_decl { auto pf = parse_arg; let util.common.spanned[vec[ast.arg]] inputs = // FIXME: passing parse_arg as an lval doesn't work at the @@ -1555,35 +1577,30 @@ impure fn parse_fn_decl(parser p, ast.effect eff) -> ast.fn_decl { } else { output = @spanned(inputs.span, inputs.span, ast.ty_nil); } - ret rec(effect=eff, inputs=inputs.node, output=output); + ret rec(effect=eff, proto=proto, + inputs=inputs.node, output=output); } -impure fn parse_fn(parser p, ast.effect eff, bool is_iter) -> ast._fn { - auto decl = parse_fn_decl(p, eff); +impure fn parse_fn(parser p, ast.effect eff, ast.proto proto) -> ast._fn { + auto decl = parse_fn_decl(p, proto, eff); auto body = parse_block(p); ret rec(decl = decl, - is_iter = is_iter, body = body); } -impure fn parse_fn_header(parser p, bool is_iter) -> tup(span, ast.ident, - vec[ast.ty_param]) { +impure fn parse_fn_header(parser p) + -> tup(span, ast.proto, ast.ident, vec[ast.ty_param]) { auto lo = p.get_span(); - if (is_iter) { - expect(p, token.ITER); - } else { - expect(p, token.FN); - } + auto proto = parse_proto(p); auto id = parse_ident(p); auto ty_params = parse_ty_params(p); - ret tup(lo, id, ty_params); + ret tup(lo, proto, id, ty_params); } -impure fn parse_item_fn_or_iter(parser p, ast.effect eff, - bool is_iter) -> @ast.item { - auto t = parse_fn_header(p, is_iter); - auto f = parse_fn(p, eff, is_iter); - auto item = ast.item_fn(t._1, f, t._2, +impure fn parse_item_fn_or_iter(parser p, ast.effect eff) -> @ast.item { + auto t = parse_fn_header(p); + auto f = parse_fn(p, eff, t._1); + auto item = ast.item_fn(t._2, f, t._3, p.next_def_id(), ast.ann_none); ret @spanned(t._0, f.body.span, item); } @@ -1598,14 +1615,9 @@ impure fn parse_obj_field(parser p) -> ast.obj_field { impure fn parse_method(parser p) -> @ast.method { auto lo = p.get_span(); auto eff = parse_effect(p); - auto is_iter = false; - alt (p.peek()) { - case (token.FN) { p.bump(); } - case (token.ITER) { p.bump(); is_iter = true; } - case (?t) { unexpected(p, t); } - } + auto proto = parse_proto(p); auto ident = parse_ident(p); - auto f = parse_fn(p, eff, is_iter); + auto f = parse_fn(p, eff, proto); auto meth = rec(ident=ident, meth=f, id=p.next_def_id(), ann=ast.ann_none); ret @spanned(lo, f.body.span, meth); @@ -1689,11 +1701,11 @@ impure fn parse_item_native_type(parser p) -> @ast.native_item { } impure fn parse_item_native_fn(parser p, ast.effect eff) -> @ast.native_item { - auto t = parse_fn_header(p, false); - auto decl = parse_fn_decl(p, eff); + auto t = parse_fn_header(p); + auto decl = parse_fn_decl(p, t._1, eff); auto hi = p.get_span(); expect(p, token.SEMI); - auto item = ast.native_item_fn(t._1, decl, t._2, p.next_def_id(), + auto item = ast.native_item_fn(t._2, decl, t._3, p.next_def_id(), ast.ann_none); ret @spanned(t._0, hi, item); } @@ -1883,11 +1895,11 @@ impure fn parse_item(parser p) -> @ast.item { case (token.FN) { check (lyr == ast.layer_value); - ret parse_item_fn_or_iter(p, eff, false); + ret parse_item_fn_or_iter(p, eff); } case (token.ITER) { check (lyr == ast.layer_value); - ret parse_item_fn_or_iter(p, eff, true); + ret parse_item_fn_or_iter(p, eff); } case (token.MOD) { check (eff == ast.eff_pure); -- cgit v1.2.3 From c4df39609c9c09c450dd8fe5905a8e6fbeb5f181 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 22 Feb 2011 18:58:07 -0500 Subject: Rename std._io to std.io since 'io' is no longer a keyword --- src/comp/front/parser.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 71b06b45..bbac78d3 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1,4 +1,4 @@ -import std._io; +import std.io; import std._vec; import std._str; import std.option; @@ -80,7 +80,7 @@ impure fn new_parser(session.session sess, ret tup(crate, def); } } - auto srdr = _io.new_stdio_reader(path); + auto srdr = io.new_stdio_reader(path); auto rdr = lexer.new_reader(srdr, path); auto npos = rdr.get_curr_pos(); ret stdio_parser(sess, lexer.next_token(rdr), -- cgit v1.2.3 From ffcb4613700c968041f891985927b77f70a51c0c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Wed, 23 Feb 2011 14:06:37 -0500 Subject: Parse the abi in native modules. --- src/comp/front/parser.rs | 44 +++++++++++++++++++++++++++++++++----------- 1 file changed, 33 insertions(+), 11 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index bbac78d3..03b24e4e 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1723,7 +1723,8 @@ impure fn parse_native_item(parser p) -> @ast.native_item { } impure fn parse_native_mod_items(parser p, - str native_name) -> ast.native_mod { + str native_name, + ast.native_abi abi) -> ast.native_mod { auto index = new_str_hash[@ast.native_item](); let vec[@ast.native_item] items = vec(); while (p.peek() != token.RBRACE) { @@ -1733,28 +1734,49 @@ impure fn parse_native_mod_items(parser p, // Index the item. ast.index_native_item(index, item); } - ret rec(native_name=native_name, items=items, index=index); + ret rec(native_name=native_name, abi=abi, + items=items, index=index); +} + +fn default_native_name(session.session sess, str id) -> str { + alt (sess.get_targ_cfg().os) { + case (session.os_win32) { + ret id + ".dll"; + } + case (session.os_macos) { + ret "lib" + id + ".dylib"; + } + case (session.os_linux) { + ret "lib" + id + ".so"; + } + } } impure fn parse_item_native_mod(parser p) -> @ast.item { auto lo = p.get_span(); expect(p, token.NATIVE); - auto has_eq; - auto native_name = ""; - if (p.peek() == token.MOD) { - has_eq = true; - } else { - native_name = parse_str_lit(p); - has_eq = false; + auto abi = ast.native_abi_cdecl; + if (p.peek() != token.MOD) { + auto t = parse_str_lit(p); + if (t == "cdecl") { + } else if (t == "rust") { + abi = ast.native_abi_rust; + } else { + p.err("unsupported abi: " + t); + fail; + } } expect(p, token.MOD); auto id = parse_ident(p); - if (has_eq) { + auto native_name; + if (p.peek() == token.EQ) { expect(p, token.EQ); native_name = parse_str_lit(p); + } else { + native_name = default_native_name(p.get_session(), id); } expect(p, token.LBRACE); - auto m = parse_native_mod_items(p, native_name); + auto m = parse_native_mod_items(p, native_name, ast.native_abi_cdecl); auto hi = p.get_span(); expect(p, token.RBRACE); auto item = ast.item_native_mod(id, m, p.next_def_id()); -- cgit v1.2.3 From 5f6110a4db9639dd8c21f976dc2c3f34ede3e038 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Wed, 23 Feb 2011 14:10:02 -0500 Subject: Use the computed abi :-( --- src/comp/front/parser.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 03b24e4e..eb073e00 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1776,7 +1776,7 @@ impure fn parse_item_native_mod(parser p) -> @ast.item { native_name = default_native_name(p.get_session(), id); } expect(p, token.LBRACE); - auto m = parse_native_mod_items(p, native_name, ast.native_abi_cdecl); + auto m = parse_native_mod_items(p, native_name, abi); auto hi = p.get_span(); expect(p, token.RBRACE); auto item = ast.item_native_mod(id, m, p.next_def_id()); -- cgit v1.2.3 From c6bc5cce4bf2ed84740ec6810505014c7d73b779 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Wed, 23 Feb 2011 13:28:46 -0800 Subject: Parse auth clauses, drop them on the floor. Nothing exists to use them yet anyways. --- src/comp/front/parser.rs | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index eb073e00..6d77a204 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -2117,6 +2117,15 @@ impure fn parse_crate_directive(str prefix, parser p, auto lo = p.get_span(); auto hi = lo; alt (p.peek()) { + case (token.AUTH) { + // FIXME: currently dropping auth clauses on the floor, + // as there is no effect-checking pass. + p.bump(); + auto n = parse_path(p, GREEDY); + expect(p, token.EQ); + auto e = parse_effect(p); + expect(p, token.SEMI); + } case (token.CONST) { auto c = parse_item_const(p); ast.index_item(index, c); -- cgit v1.2.3 From 127139aecd5c3a1227ee58c77fc083506125f7cd Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Thu, 24 Feb 2011 12:14:05 -0800 Subject: Parse crate directive tree in one pass, then evaluate it in a second. --- src/comp/front/parser.rs | 126 +++++++++++++++++++++++++++++++++++------------ 1 file changed, 94 insertions(+), 32 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 6d77a204..944e1424 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -8,6 +8,7 @@ import std.map.hashmap; import driver.session; import util.common; +import util.common.filename; import util.common.append; import util.common.span; import util.common.new_str_hash; @@ -2110,9 +2111,81 @@ impure fn parse_crate_from_source_file(parser p) -> @ast.crate { // // Each directive imperatively extends its environment with 0 or more items. -impure fn parse_crate_directive(str prefix, parser p, - &mutable vec[@ast.item] items, - hashmap[ast.ident,ast.mod_index_entry] index) +impure fn eval_crate_directives(parser p, + vec[@ast.crate_directive] cdirs, + str prefix) -> ast._mod { + let vec[@ast.item] items = vec(); + auto index = new_str_hash[ast.mod_index_entry](); + auto view_items = parse_view(p, index); + + for (@ast.crate_directive sub_cdir in cdirs) { + eval_crate_directive(p, sub_cdir, prefix, + view_items, items, index); + } + + ret rec(view_items=view_items, items=items, index=index); +} + +impure fn eval_crate_directive(parser p, + @ast.crate_directive cdir, + str prefix, + &mutable vec[@ast.view_item] view_items, + &mutable vec[@ast.item] items, + hashmap[ast.ident,ast.mod_index_entry] index) { + alt (cdir.node) { + case (ast.cdir_expr(?e)) {} + case (ast.cdir_const(?i)) {} + + case (ast.cdir_src_mod(?id, ?file_opt)) { + + auto file_path = id + ".rs"; + alt (file_opt) { + case (some[filename](?f)) { + file_path = f; + } + case (none[filename]) {} + } + + auto full_path = prefix + std.os.path_sep() + file_path; + + auto p0 = new_parser(p.get_session(), 0, full_path); + auto m0 = parse_mod_items(p0, token.EOF); + auto im = ast.item_mod(id, m0, p.next_def_id()); + auto i = @spanned(cdir.span, cdir.span, im); + ast.index_item(index, i); + append[@ast.item](items, i); + } + + case (ast.cdir_dir_mod(?id, ?dir_opt, ?cdirs)) { + + auto path = id; + alt (dir_opt) { + case (some[filename](?d)) { + path = d; + } + case (none[filename]) {} + } + + auto full_path = prefix + std.os.path_sep() + path; + auto m0 = eval_crate_directives(p, cdirs, path); + auto im = ast.item_mod(id, m0, p.next_def_id()); + auto i = @spanned(cdir.span, cdir.span, im); + ast.index_item(index, i); + append[@ast.item](items, i); + } + + case (ast.cdir_view_item(?vi)) { + append[@ast.view_item](view_items, vi); + ast.index_view_item(index, vi); + } + + case (ast.cdir_meta(?mi)) {} + case (ast.cdir_syntax(?pth)) {} + case (ast.cdir_auth(?pth, ?eff)) {} + } +} + +impure fn parse_crate_directive(parser p) -> ast.crate_directive { auto lo = p.get_span(); auto hi = lo; @@ -2124,28 +2197,27 @@ impure fn parse_crate_directive(str prefix, parser p, auto n = parse_path(p, GREEDY); expect(p, token.EQ); auto e = parse_effect(p); + hi = p.get_span(); expect(p, token.SEMI); + ret spanned(lo, hi, ast.cdir_auth(n, e)); } case (token.CONST) { auto c = parse_item_const(p); - ast.index_item(index, c); - append[@ast.item](items, c); + ret spanned(c.span, c.span, ast.cdir_const(c)); } case (token.MOD) { p.bump(); auto id = parse_ident(p); - auto file_path = id; + auto file_opt = none[filename]; alt (p.peek()) { case (token.EQ) { p.bump(); // FIXME: turn this into parse+eval expr - file_path = parse_str_lit(p); + file_opt = some[filename](parse_str_lit(p)); } case (_) {} } - // dir-qualify file path. - auto full_path = prefix + std.os.path_sep() + file_path; alt (p.peek()) { @@ -2154,29 +2226,18 @@ impure fn parse_crate_directive(str prefix, parser p, case (token.SEMI) { hi = p.get_span(); p.bump(); - if (!_str.ends_with(full_path, ".rs")) { - full_path += ".rs"; - } - auto p0 = new_parser(p.get_session(), 0, full_path); - auto m0 = parse_mod_items(p0, token.EOF); - auto im = ast.item_mod(id, m0, p.next_def_id()); - auto i = @spanned(lo, hi, im); - ast.index_item(index, i); - append[@ast.item](items, i); + ret spanned(lo, hi, ast.cdir_src_mod(id, file_opt)); } // mod x = "foo_dir" { ...directives... } case (token.LBRACE) { p.bump(); - auto m0 = parse_crate_directives(full_path, p, - token.RBRACE); + auto cdirs = parse_crate_directives(p, token.RBRACE); hi = p.get_span(); expect(p, token.RBRACE); - auto im = ast.item_mod(id, m0, p.next_def_id()); - auto i = @spanned(lo, hi, im); - ast.index_item(index, i); - append[@ast.item](items, i); + ret spanned(lo, hi, + ast.cdir_dir_mod(id, file_opt, cdirs)); } case (?t) { @@ -2185,27 +2246,28 @@ impure fn parse_crate_directive(str prefix, parser p, } } } + fail; } -impure fn parse_crate_directives(str prefix, parser p, - token.token term) -> ast._mod { - auto index = new_str_hash[ast.mod_index_entry](); - auto view_items = parse_view(p, index); +impure fn parse_crate_directives(parser p, token.token term) + -> vec[@ast.crate_directive] { - let vec[@ast.item] items = vec(); + let vec[@ast.crate_directive] cdirs = vec(); while (p.peek() != term) { - parse_crate_directive(prefix, p, items, index); + auto cdir = @parse_crate_directive(p); + append[@ast.crate_directive](cdirs, cdir); } - ret rec(view_items=view_items, items=items, index=index); + ret cdirs; } impure fn parse_crate_from_crate_file(parser p) -> @ast.crate { auto lo = p.get_span(); auto hi = lo; auto prefix = std.path.dirname(lo.filename); - auto m = parse_crate_directives(prefix, p, token.EOF); + auto cdirs = parse_crate_directives(p, token.EOF); + auto m = eval_crate_directives(p, cdirs, prefix); hi = p.get_span(); expect(p, token.EOF); ret @spanned(lo, hi, rec(module=m)); -- cgit v1.2.3 From b2a09562a6c0683ca528c866abc1ecc99b4bdcf0 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Thu, 24 Feb 2011 15:54:55 -0800 Subject: Factor crate expr evaluator out of parser, expand to simple scalars and ops, if, alt. --- src/comp/front/parser.rs | 82 ++---------------------------------------------- 1 file changed, 3 insertions(+), 79 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 944e1424..3579a3a0 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -2111,80 +2111,6 @@ impure fn parse_crate_from_source_file(parser p) -> @ast.crate { // // Each directive imperatively extends its environment with 0 or more items. -impure fn eval_crate_directives(parser p, - vec[@ast.crate_directive] cdirs, - str prefix) -> ast._mod { - let vec[@ast.item] items = vec(); - auto index = new_str_hash[ast.mod_index_entry](); - auto view_items = parse_view(p, index); - - for (@ast.crate_directive sub_cdir in cdirs) { - eval_crate_directive(p, sub_cdir, prefix, - view_items, items, index); - } - - ret rec(view_items=view_items, items=items, index=index); -} - -impure fn eval_crate_directive(parser p, - @ast.crate_directive cdir, - str prefix, - &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items, - hashmap[ast.ident,ast.mod_index_entry] index) { - alt (cdir.node) { - case (ast.cdir_expr(?e)) {} - case (ast.cdir_const(?i)) {} - - case (ast.cdir_src_mod(?id, ?file_opt)) { - - auto file_path = id + ".rs"; - alt (file_opt) { - case (some[filename](?f)) { - file_path = f; - } - case (none[filename]) {} - } - - auto full_path = prefix + std.os.path_sep() + file_path; - - auto p0 = new_parser(p.get_session(), 0, full_path); - auto m0 = parse_mod_items(p0, token.EOF); - auto im = ast.item_mod(id, m0, p.next_def_id()); - auto i = @spanned(cdir.span, cdir.span, im); - ast.index_item(index, i); - append[@ast.item](items, i); - } - - case (ast.cdir_dir_mod(?id, ?dir_opt, ?cdirs)) { - - auto path = id; - alt (dir_opt) { - case (some[filename](?d)) { - path = d; - } - case (none[filename]) {} - } - - auto full_path = prefix + std.os.path_sep() + path; - auto m0 = eval_crate_directives(p, cdirs, path); - auto im = ast.item_mod(id, m0, p.next_def_id()); - auto i = @spanned(cdir.span, cdir.span, im); - ast.index_item(index, i); - append[@ast.item](items, i); - } - - case (ast.cdir_view_item(?vi)) { - append[@ast.view_item](view_items, vi); - ast.index_view_item(index, vi); - } - - case (ast.cdir_meta(?mi)) {} - case (ast.cdir_syntax(?pth)) {} - case (ast.cdir_auth(?pth, ?eff)) {} - } -} - impure fn parse_crate_directive(parser p) -> ast.crate_directive { auto lo = p.get_span(); @@ -2201,10 +2127,7 @@ impure fn parse_crate_directive(parser p) -> ast.crate_directive expect(p, token.SEMI); ret spanned(lo, hi, ast.cdir_auth(n, e)); } - case (token.CONST) { - auto c = parse_item_const(p); - ret spanned(c.span, c.span, ast.cdir_const(c)); - } + case (token.MOD) { p.bump(); auto id = parse_ident(p); @@ -2267,7 +2190,8 @@ impure fn parse_crate_from_crate_file(parser p) -> @ast.crate { auto hi = lo; auto prefix = std.path.dirname(lo.filename); auto cdirs = parse_crate_directives(p, token.EOF); - auto m = eval_crate_directives(p, cdirs, prefix); + auto m = eval.eval_crate_directives_to_mod(p, eval.mk_env(), + cdirs, prefix); hi = p.get_span(); expect(p, token.EOF); ret @spanned(lo, hi, rec(module=m)); -- cgit v1.2.3 From 9acf4b912717831f628ad078f28c597e10d7ec93 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Thu, 24 Feb 2011 16:42:04 -0800 Subject: Handle the mutant 'let'-block directive in rustboot, temporarily. --- src/comp/front/parser.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 3579a3a0..4817d960 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -2168,10 +2168,25 @@ impure fn parse_crate_directive(parser p) -> ast.crate_directive } } } + + case (token.LET) { + p.bump(); + expect(p, token.LPAREN); + auto id = parse_ident(p); + expect(p, token.EQ); + auto x = parse_expr(p); + expect(p, token.RPAREN); + expect(p, token.LBRACE); + auto v = parse_crate_directives(p, token.RBRACE); + hi = p.get_span(); + expect(p, token.RBRACE); + ret spanned(lo, hi, ast.cdir_let(id, x, v)); + } } fail; } + impure fn parse_crate_directives(parser p, token.token term) -> vec[@ast.crate_directive] { -- cgit v1.2.3 From dbf53b4c37f9f2a1cda43aa8320ceb4c4460051e Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Thu, 24 Feb 2011 17:00:24 -0800 Subject: Connect the crate and source parsers together. --- src/comp/front/parser.rs | 60 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 4817d960..7ae0050e 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -18,6 +18,11 @@ tag restriction { RESTRICT_NO_CALL_EXPRS; } +tag file_type { + CRATE_FILE; + SOURCE_FILE; +} + state type parser = state obj { fn peek() -> token.token; @@ -25,14 +30,17 @@ state type parser = impure fn err(str s); impure fn restrict(restriction r); fn get_restriction() -> restriction; + fn get_file_type() -> file_type; fn get_session() -> session.session; fn get_span() -> common.span; fn next_def_id() -> ast.def_id; }; impure fn new_parser(session.session sess, - ast.crate_num crate, str path) -> parser { + ast.crate_num crate, + str path) -> parser { state obj stdio_parser(session.session sess, + file_type ftype, mutable token.token tok, mutable common.pos lo, mutable common.pos hi, @@ -80,11 +88,20 @@ impure fn new_parser(session.session sess, def += 1; ret tup(crate, def); } + + fn get_file_type() -> file_type { + ret ftype; + } + } + auto ftype = SOURCE_FILE; + if (_str.ends_with(path, ".rc")) { + ftype = CRATE_FILE; + } auto srdr = io.new_stdio_reader(path); auto rdr = lexer.new_reader(srdr, path); auto npos = rdr.get_curr_pos(); - ret stdio_parser(sess, lexer.next_token(rdr), + ret stdio_parser(sess, ftype, lexer.next_token(rdr), npos, npos, 0, UNRESTRICTED, crate, rdr); } @@ -1310,6 +1327,20 @@ impure fn parse_auto(parser p) -> @ast.decl { } impure fn parse_stmt(parser p) -> @ast.stmt { + if (p.get_file_type() == SOURCE_FILE) { + ret parse_source_stmt(p); + } else { + ret parse_crate_stmt(p); + } +} + +impure fn parse_crate_stmt(parser p) -> @ast.stmt { + auto cdir = parse_crate_directive(p); + ret @spanned(cdir.span, cdir.span, + ast.stmt_crate_directive(@cdir)); +} + +impure fn parse_source_stmt(parser p) -> @ast.stmt { auto lo = p.get_span(); alt (p.peek()) { @@ -1485,6 +1516,16 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { case (ast.expr_check_expr(_)) { ret true; } } } + case (ast.stmt_crate_directive(?cdir)) { + alt (cdir.node) { + case (ast.cdir_src_mod(_, _)) { ret true; } + case (ast.cdir_view_item(_)) { ret true; } + case (ast.cdir_meta(_)) { ret true; } + case (ast.cdir_syntax(_)) { ret true; } + case (ast.cdir_auth(_, _)) { ret true; } + case (_) { ret false; } + } + } } } @@ -2182,6 +2223,21 @@ impure fn parse_crate_directive(parser p) -> ast.crate_directive expect(p, token.RBRACE); ret spanned(lo, hi, ast.cdir_let(id, x, v)); } + + case (token.USE) { + auto vi = parse_use_or_import(p); + ret spanned(lo, vi.span, ast.cdir_view_item(vi)); + } + + case (token.IMPORT) { + auto vi = parse_use_or_import(p); + ret spanned(lo, vi.span, ast.cdir_view_item(vi)); + } + + case (_) { + auto x = parse_expr(p); + ret spanned(lo, x.span, ast.cdir_expr(x)); + } } fail; } -- cgit v1.2.3 From 88f0463c2bd6e7fd2af461afc5e83bd3417e3bc5 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Thu, 24 Feb 2011 17:17:39 -0800 Subject: Support the awful alt-else form in rustboot's cexp grammar, at least transiently. Remove in the future. --- src/comp/front/parser.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 7ae0050e..67b9cc80 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1170,6 +1170,23 @@ impure fn parse_alt_expr(parser p) -> @ast.expr { auto block = parse_block(p); arms += vec(rec(pat=pat, block=block, index=index)); } + + // FIXME: this is a vestigial form left over from + // rustboot, we're keeping it here for source-compat + // for the time being but it should be flushed out + // once we've bootstrapped. When we see 'else {' here, + // we pretend we saw 'case (_) {'. It has the same + // meaning, and only exists due to the cexp/pexp split + // in rustboot, which we're not maintaining. + + case (token.ELSE) { + p.bump(); + auto hi = p.get_span(); + auto pat = @spanned(lo, hi, ast.pat_wild(ast.ann_none)); + auto index = index_arm(pat); + auto block = parse_block(p); + arms += vec(rec(pat=pat, block=block, index=index)); + } case (token.RBRACE) { /* empty */ } case (?tok) { p.err("expected 'case' or '}' when parsing 'alt' statement " + -- cgit v1.2.3 From f8f6f078c505dd0f20526e3ad86c360605fce109 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Fri, 25 Feb 2011 12:08:21 -0500 Subject: There are no native iterators (or at least they are not going to be supported soon.). --- src/comp/front/parser.rs | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 67b9cc80..7bd34fdf 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1617,8 +1617,7 @@ impure fn parse_ty_params(parser p) -> vec[ast.ty_param] { ret ty_params; } -impure fn parse_fn_decl(parser p, ast.proto proto, - ast.effect eff) -> ast.fn_decl { +impure fn parse_fn_decl(parser p, ast.effect eff) -> ast.fn_decl { auto pf = parse_arg; let util.common.spanned[vec[ast.arg]] inputs = // FIXME: passing parse_arg as an lval doesn't work at the @@ -1636,32 +1635,32 @@ impure fn parse_fn_decl(parser p, ast.proto proto, } else { output = @spanned(inputs.span, inputs.span, ast.ty_nil); } - ret rec(effect=eff, proto=proto, - inputs=inputs.node, output=output); + ret rec(effect=eff, inputs=inputs.node, output=output); } impure fn parse_fn(parser p, ast.effect eff, ast.proto proto) -> ast._fn { - auto decl = parse_fn_decl(p, proto, eff); + auto decl = parse_fn_decl(p, eff); auto body = parse_block(p); ret rec(decl = decl, + proto = proto, body = body); } impure fn parse_fn_header(parser p) - -> tup(span, ast.proto, ast.ident, vec[ast.ty_param]) { - auto lo = p.get_span(); - auto proto = parse_proto(p); + -> tup(ast.ident, vec[ast.ty_param]) { auto id = parse_ident(p); auto ty_params = parse_ty_params(p); - ret tup(lo, proto, id, ty_params); + ret tup(id, ty_params); } impure fn parse_item_fn_or_iter(parser p, ast.effect eff) -> @ast.item { + auto lo = p.get_span(); + auto proto = parse_proto(p); auto t = parse_fn_header(p); - auto f = parse_fn(p, eff, t._1); - auto item = ast.item_fn(t._2, f, t._3, + auto f = parse_fn(p, eff, proto); + auto item = ast.item_fn(t._0, f, t._1, p.next_def_id(), ast.ann_none); - ret @spanned(t._0, f.body.span, item); + ret @spanned(lo, f.body.span, item); } @@ -1760,13 +1759,15 @@ impure fn parse_item_native_type(parser p) -> @ast.native_item { } impure fn parse_item_native_fn(parser p, ast.effect eff) -> @ast.native_item { + auto lo = p.get_span(); + expect(p, token.FN); auto t = parse_fn_header(p); - auto decl = parse_fn_decl(p, t._1, eff); + auto decl = parse_fn_decl(p, eff); auto hi = p.get_span(); expect(p, token.SEMI); - auto item = ast.native_item_fn(t._2, decl, t._3, p.next_def_id(), + auto item = ast.native_item_fn(t._0, decl, t._1, p.next_def_id(), ast.ann_none); - ret @spanned(t._0, hi, item); + ret @spanned(lo, hi, item); } impure fn parse_native_item(parser p) -> @ast.native_item { -- cgit v1.2.3 From 081c3aa76dd0805767e0233c0cc6ccf313cf44ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Fri, 25 Feb 2011 15:58:08 -0500 Subject: Pass the abi of native functions all the way to codegen. --- src/comp/front/parser.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 7bd34fdf..32bcf6ef 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1818,8 +1818,8 @@ impure fn parse_item_native_mod(parser p) -> @ast.item { auto abi = ast.native_abi_cdecl; if (p.peek() != token.MOD) { auto t = parse_str_lit(p); - if (t == "cdecl") { - } else if (t == "rust") { + if (_str.eq(t, "cdecl")) { + } else if (_str.eq(t, "rust")) { abi = ast.native_abi_rust; } else { p.err("unsupported abi: " + t); -- cgit v1.2.3 From 348c77c31b7dcd5be85438dfcf4292f7e0951dd6 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Tue, 1 Mar 2011 15:57:55 -0800 Subject: Populate default compilation environment as in rustboot. --- src/comp/front/parser.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 32bcf6ef..4ffa6f92 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -31,15 +31,18 @@ state type parser = impure fn restrict(restriction r); fn get_restriction() -> restriction; fn get_file_type() -> file_type; + fn get_env() -> eval.env; fn get_session() -> session.session; fn get_span() -> common.span; fn next_def_id() -> ast.def_id; }; impure fn new_parser(session.session sess, + eval.env env, ast.crate_num crate, str path) -> parser { state obj stdio_parser(session.session sess, + eval.env env, file_type ftype, mutable token.token tok, mutable common.pos lo, @@ -93,6 +96,10 @@ impure fn new_parser(session.session sess, ret ftype; } + fn get_env() -> eval.env { + ret env; + } + } auto ftype = SOURCE_FILE; if (_str.ends_with(path, ".rc")) { @@ -101,7 +108,7 @@ impure fn new_parser(session.session sess, auto srdr = io.new_stdio_reader(path); auto rdr = lexer.new_reader(srdr, path); auto npos = rdr.get_curr_pos(); - ret stdio_parser(sess, ftype, lexer.next_token(rdr), + ret stdio_parser(sess, env, ftype, lexer.next_token(rdr), npos, npos, 0, UNRESTRICTED, crate, rdr); } @@ -2279,7 +2286,7 @@ impure fn parse_crate_from_crate_file(parser p) -> @ast.crate { auto hi = lo; auto prefix = std.path.dirname(lo.filename); auto cdirs = parse_crate_directives(p, token.EOF); - auto m = eval.eval_crate_directives_to_mod(p, eval.mk_env(), + auto m = eval.eval_crate_directives_to_mod(p, p.get_env(), cdirs, prefix); hi = p.get_span(); expect(p, token.EOF); -- cgit v1.2.3 From 7cae0c8c4d15546cbccacb6a937759903df608d7 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Tue, 1 Mar 2011 16:14:30 -0800 Subject: Implement the gross rustboot hack for contextual parser access to the compilation environment. --- src/comp/front/parser.rs | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 4ffa6f92..696140b1 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -147,9 +147,23 @@ impure fn parse_ident(parser p) -> ast.ident { } -impure fn parse_str_lit(parser p) -> ast.ident { +/* FIXME: gross hack copied from rustboot to make certain configuration-based + * decisions work at build-time. We should probably change it to use a + * lexical sytnax-extension or something similar. For now we just imitate + * rustboot. + */ +impure fn parse_str_lit_or_env_ident(parser p) -> ast.ident { alt (p.peek()) { case (token.LIT_STR(?s)) { p.bump(); ret s; } + case (token.IDENT(?i)) { + auto v = eval.lookup(p.get_session(), p.get_env(), + p.get_span(), i); + if (!eval.val_is_str(v)) { + p.err("expecting string-valued variable"); + } + p.bump(); + ret eval.val_as_str(v); + } case (_) { p.err("expecting string literal"); fail; @@ -1824,7 +1838,7 @@ impure fn parse_item_native_mod(parser p) -> @ast.item { expect(p, token.NATIVE); auto abi = ast.native_abi_cdecl; if (p.peek() != token.MOD) { - auto t = parse_str_lit(p); + auto t = parse_str_lit_or_env_ident(p); if (_str.eq(t, "cdecl")) { } else if (_str.eq(t, "rust")) { abi = ast.native_abi_rust; @@ -1838,7 +1852,7 @@ impure fn parse_item_native_mod(parser p) -> @ast.item { auto native_name; if (p.peek() == token.EQ) { expect(p, token.EQ); - native_name = parse_str_lit(p); + native_name = parse_str_lit_or_env_ident(p); } else { native_name = default_native_name(p.get_session(), id); } @@ -2202,7 +2216,7 @@ impure fn parse_crate_directive(parser p) -> ast.crate_directive case (token.EQ) { p.bump(); // FIXME: turn this into parse+eval expr - file_opt = some[filename](parse_str_lit(p)); + file_opt = some[filename](parse_str_lit_or_env_ident(p)); } case (_) {} } -- cgit v1.2.3 From 64ab5eaaf09de6a75392554c13784c492ed19465 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Tue, 1 Mar 2011 17:32:16 -0800 Subject: Parse (and ignore) dtors on objs. --- src/comp/front/parser.rs | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 696140b1..f747c084 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1715,21 +1715,33 @@ impure fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item { some(token.COMMA), pf, p); - auto pm = parse_method; - let util.common.spanned[vec[@ast.method]] meths = - parse_seq[@ast.method] - (token.LBRACE, - token.RBRACE, - none[token.token], - pm, p); + let vec[@ast.method] meths = vec(); + let option.t[ast.block] dtor = none[ast.block]; + + expect(p, token.LBRACE); + while (p.peek() != token.RBRACE) { + alt (p.peek()) { + case (token.DROP) { + p.bump(); + dtor = some[ast.block](parse_block(p)); + } + case (_) { + append[@ast.method](meths, + parse_method(p)); + } + } + } + auto hi = p.get_span(); + expect(p, token.RBRACE); let ast._obj ob = rec(fields=fields.node, - methods=meths.node); + methods=meths, + dtor=dtor); auto item = ast.item_obj(ident, ob, ty_params, p.next_def_id(), ast.ann_none); - ret @spanned(lo, meths.span, item); + ret @spanned(lo, hi, item); } impure fn parse_mod_items(parser p, token.token term) -> ast._mod { -- cgit v1.2.3 From 9528c34774ff27b112c9e66afff6e10fa7021635 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 23 Feb 2011 23:48:01 -0500 Subject: Begin implementing #fmt in rustc --- src/comp/front/parser.rs | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index f747c084..8f6db17d 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -656,7 +656,10 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { some(token.COMMA), pf, p); hi = es.span; - ex = ast.expr_ext(pth, es.node, none[@ast.expr], ast.ann_none); + ex = ast.expr_ext(pth, es.node, none[@ast.expr], + none[@ast.expr], ast.ann_none); + // FIXME: Here is probably not the right place for this + ex = expand_syntax_ext(p, @spanned(lo, hi, ex)).node; } case (token.FAIL) { @@ -736,6 +739,36 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { ret @spanned(lo, hi, ex); } +/* + * FIXME: This is a crude approximation of the syntax-extension system, + * for purposes of prototyping and/or hard-wiring any extensions we + * wish to use while bootstrapping. The eventual aim is to permit + * loading rust crates to process extensions, but this will likely + * require a rust-based frontend, or an ocaml-FFI-based connection to + * rust crates. At the moment we have neither. + */ + +impure fn expand_syntax_ext(parser p, @ast.expr ext) -> @ast.expr { + check (ast.is_ext_expr(ext)); + alt (ext.node) { + case (ast.expr_ext(?path, ?args, ?body, _, ?ann)) { + check (_vec.len[ast.ident](path.node.idents) > 0u); + auto extname = path.node.idents.(0); + if (_str.eq(extname, "fmt")) { + auto expanded = extfmt.expand_syntax_ext(args, body); + check (ast.is_ext_expr(expanded)); + auto newexpr = ast.expr_ext(path, args, body, + some[@ast.expr](expanded), ann); + + ret @spanned(ext.span, ext.span, newexpr); + } else { + p.err("unknown syntax extension"); + } + } + } + fail; +} + impure fn extend_expr_by_ident(parser p, span lo, span hi, @ast.expr e, ast.ident i) -> @ast.expr { auto e_ = e.node; -- cgit v1.2.3 From 1c60399257cde71fc265eb10cae1f398a0ac2516 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 24 Feb 2011 23:22:36 -0500 Subject: Begin work on #fmt parsing --- src/comp/front/parser.rs | 1 - 1 file changed, 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 8f6db17d..e5f68033 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -756,7 +756,6 @@ impure fn expand_syntax_ext(parser p, @ast.expr ext) -> @ast.expr { auto extname = path.node.idents.(0); if (_str.eq(extname, "fmt")) { auto expanded = extfmt.expand_syntax_ext(args, body); - check (ast.is_ext_expr(expanded)); auto newexpr = ast.expr_ext(path, args, body, some[@ast.expr](expanded), ann); -- cgit v1.2.3 From 5e06ec977f4446a7b19a09dd3a3781bcf26f8442 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Sun, 27 Feb 2011 15:29:31 -0500 Subject: Rewrite expand_syntax_ext to avoid a mysterious memory leak --- src/comp/front/parser.rs | 39 ++++++++++++++++++--------------------- 1 file changed, 18 insertions(+), 21 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index e5f68033..7a7a863c 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -656,10 +656,8 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { some(token.COMMA), pf, p); hi = es.span; - ex = ast.expr_ext(pth, es.node, none[@ast.expr], - none[@ast.expr], ast.ann_none); - // FIXME: Here is probably not the right place for this - ex = expand_syntax_ext(p, @spanned(lo, hi, ex)).node; + ex = expand_syntax_ext(p, es.span, pth, es.node, + none[@ast.expr]); } case (token.FAIL) { @@ -748,24 +746,23 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { * rust crates. At the moment we have neither. */ -impure fn expand_syntax_ext(parser p, @ast.expr ext) -> @ast.expr { - check (ast.is_ext_expr(ext)); - alt (ext.node) { - case (ast.expr_ext(?path, ?args, ?body, _, ?ann)) { - check (_vec.len[ast.ident](path.node.idents) > 0u); - auto extname = path.node.idents.(0); - if (_str.eq(extname, "fmt")) { - auto expanded = extfmt.expand_syntax_ext(args, body); - auto newexpr = ast.expr_ext(path, args, body, - some[@ast.expr](expanded), ann); - - ret @spanned(ext.span, ext.span, newexpr); - } else { - p.err("unknown syntax extension"); - } - } +impure fn expand_syntax_ext(parser p, ast.span sp, + &ast.path path, vec[@ast.expr] args, + option.t[@ast.expr] body) -> ast.expr_ { + + check (_vec.len[ast.ident](path.node.idents) > 0u); + auto extname = path.node.idents.(0); + if (_str.eq(extname, "fmt")) { + auto expanded = extfmt.expand_syntax_ext(args, body); + auto newexpr = ast.expr_ext(path, args, body, + some[@ast.expr](expanded), + ast.ann_none); + + ret newexpr; + } else { + p.err("unknown syntax extension"); + fail; } - fail; } impure fn extend_expr_by_ident(parser p, span lo, span hi, -- cgit v1.2.3 From c1e6f5328c3f46884ed7a7e29c780e307b02100a Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Sun, 27 Feb 2011 22:35:27 -0500 Subject: Make the expanded expression in expr_ext not optional --- src/comp/front/parser.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 7a7a863c..5fe16536 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -755,7 +755,7 @@ impure fn expand_syntax_ext(parser p, ast.span sp, if (_str.eq(extname, "fmt")) { auto expanded = extfmt.expand_syntax_ext(args, body); auto newexpr = ast.expr_ext(path, args, body, - some[@ast.expr](expanded), + expanded, ast.ann_none); ret newexpr; -- cgit v1.2.3 From 77a0dc06a7cead4a1d38cdb68f1465cbeccf48c1 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 1 Mar 2011 19:51:21 -0500 Subject: Whitespace cleanup --- src/comp/front/parser.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 5fe16536..50545a2f 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -737,7 +737,7 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr { ret @spanned(lo, hi, ex); } -/* +/* * FIXME: This is a crude approximation of the syntax-extension system, * for purposes of prototyping and/or hard-wiring any extensions we * wish to use while bootstrapping. The eventual aim is to permit -- cgit v1.2.3 From 9e4943c9229e15fa11069eeb2b20060994f9ac0f Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Wed, 2 Mar 2011 13:50:42 -0800 Subject: Parse, add to AST, and otherwise ignore 'export' view items. Need to add support to resolve. --- src/comp/front/parser.rs | 39 ++++++++++++++++++++++++++++----------- 1 file changed, 28 insertions(+), 11 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 50545a2f..1be4226c 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -2187,7 +2187,16 @@ impure fn parse_import(parser p) -> @ast.view_item { fail; } -impure fn parse_use_or_import(parser p) -> @ast.view_item { +impure fn parse_export(parser p) -> @ast.view_item { + auto lo = p.get_span(); + expect(p, token.EXPORT); + auto id = parse_ident(p); + auto hi = p.get_span(); + expect(p, token.SEMI); + ret @spanned(lo, hi, ast.view_item_export(id)); +} + +impure fn parse_view_item(parser p) -> @ast.view_item { alt (p.peek()) { case (token.USE) { ret parse_use(p); @@ -2195,23 +2204,26 @@ impure fn parse_use_or_import(parser p) -> @ast.view_item { case (token.IMPORT) { ret parse_import(p); } + case (token.EXPORT) { + ret parse_export(p); + } } } -fn is_use_or_import(token.token t) -> bool { - if (t == token.USE) { - ret true; - } - if (t == token.IMPORT) { - ret true; +fn is_view_item(token.token t) -> bool { + alt (t) { + case (token.USE) { ret true; } + case (token.IMPORT) { ret true; } + case (token.EXPORT) { ret true; } + case (_) {} } ret false; } impure fn parse_view(parser p, ast.mod_index index) -> vec[@ast.view_item] { let vec[@ast.view_item] items = vec(); - while (is_use_or_import(p.peek())) { - auto item = parse_use_or_import(p); + while (is_view_item(p.peek())) { + auto item = parse_view_item(p); items += vec(item); ast.index_view_item(index, item); @@ -2305,12 +2317,17 @@ impure fn parse_crate_directive(parser p) -> ast.crate_directive } case (token.USE) { - auto vi = parse_use_or_import(p); + auto vi = parse_view_item(p); ret spanned(lo, vi.span, ast.cdir_view_item(vi)); } case (token.IMPORT) { - auto vi = parse_use_or_import(p); + auto vi = parse_view_item(p); + ret spanned(lo, vi.span, ast.cdir_view_item(vi)); + } + + case (token.EXPORT) { + auto vi = parse_view_item(p); ret spanned(lo, vi.span, ast.cdir_view_item(vi)); } -- cgit v1.2.3 From 02dff96b52cac4900fd35235623c8a2dd98ca08f Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Fri, 4 Mar 2011 11:28:40 -0800 Subject: Parse meta directives in crates. --- src/comp/front/parser.rs | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 1be4226c..f80c3bd5 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1564,14 +1564,14 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { case (ast.expr_if(_,_,_,_,_)) { ret false; } case (ast.expr_for(_,_,_,_)) { ret false; } case (ast.expr_for_each(_,_,_,_)) - { ret false; } + { ret false; } case (ast.expr_while(_,_,_)) { ret false; } case (ast.expr_do_while(_,_,_)) { ret false; } case (ast.expr_alt(_,_,_)) { ret false; } case (ast.expr_block(_,_)) { ret false; } case (ast.expr_assign(_,_,_)) { ret true; } case (ast.expr_assign_op(_,_,_,_)) - { ret true; } + { ret true; } case (ast.expr_field(_,_,_)) { ret true; } case (ast.expr_index(_,_,_)) { ret true; } case (ast.expr_path(_,_,_)) { ret true; } @@ -1583,16 +1583,8 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { case (ast.expr_check_expr(_)) { ret true; } } } - case (ast.stmt_crate_directive(?cdir)) { - alt (cdir.node) { - case (ast.cdir_src_mod(_, _)) { ret true; } - case (ast.cdir_view_item(_)) { ret true; } - case (ast.cdir_meta(_)) { ret true; } - case (ast.cdir_syntax(_)) { ret true; } - case (ast.cdir_auth(_, _)) { ret true; } - case (_) { ret false; } - } - } + // We should not be calling this on a cdir. + case (ast.stmt_crate_directive(?cdir)) { fail; } } } @@ -1636,8 +1628,13 @@ impure fn parse_block(parser p) -> ast.block { case (none[@ast.expr]) { // Not an expression statement. stmts += vec(stmt); - if (stmt_ends_with_semi(stmt)) { - expect(p, token.SEMI); + // FIXME: crazy differentiation between conditions + // used in branches and binary expressions in rustboot + // means we cannot use && here. I know, right? + if (p.get_file_type() == SOURCE_FILE) { + if (stmt_ends_with_semi(stmt)) { + expect(p, token.SEMI); + } } } } @@ -2261,6 +2258,16 @@ impure fn parse_crate_directive(parser p) -> ast.crate_directive ret spanned(lo, hi, ast.cdir_auth(n, e)); } + case (token.META) { + // FIXME: currently dropping meta clauses on the floor, + // as there is no crate metadata system + p.bump(); + auto mis = parse_meta(p); + hi = p.get_span(); + expect(p, token.SEMI); + ret spanned(lo, hi, ast.cdir_meta(mis)); + } + case (token.MOD) { p.bump(); auto id = parse_ident(p); -- cgit v1.2.3 From 596face2745ccc11a959a530807ea3e36e9d1354 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Fri, 4 Mar 2011 14:15:19 -0800 Subject: Parse (and generally ignore) constraints and constrained types. --- src/comp/front/parser.rs | 68 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 67 insertions(+), 1 deletion(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index f80c3bd5..934764e6 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -199,6 +199,10 @@ impure fn parse_ty_fn(ast.proto proto, parser p, auto inputs = parse_seq[rec(ast.mode mode, @ast.ty ty)](token.LPAREN, token.RPAREN, some(token.COMMA), f, p); + // FIXME: dropping constrs on the floor at the moment. + // pick them up when they're used by typestate pass. + parse_constrs(p); + let @ast.ty output; if (p.peek() == token.RARROW) { p.bump(); @@ -254,6 +258,62 @@ impure fn parse_ty_field(parser p) -> ast.ty_field { ret rec(ident=id, ty=ty); } +impure fn parse_constr_arg(parser p) -> @ast.constr_arg { + auto lo = p.get_span(); + auto carg = ast.carg_base; + if (p.peek() == token.BINOP(token.STAR)) { + p.bump(); + } else { + carg = ast.carg_ident(parse_ident(p)); + } + ret @spanned(lo, lo, carg); +} + +impure fn parse_ty_constr(parser p) -> @ast.constr { + auto lo = p.get_span(); + auto path = parse_path(p, GREEDY); + auto pf = parse_constr_arg; + auto args = parse_seq[@ast.constr_arg](token.LPAREN, + token.RPAREN, + some(token.COMMA), pf, p); + auto hi = args.span; + ret @spanned(lo, hi, rec(path=path, args=args.node)); +} + +impure fn parse_constrs(parser p) -> common.spanned[vec[@ast.constr]] { + auto lo = p.get_span(); + auto hi = lo; + let vec[@ast.constr] constrs = vec(); + if (p.peek() == token.COLON) { + p.bump(); + let bool more = true; + while (more) { + alt (p.peek()) { + case (token.IDENT(_)) { + auto constr = parse_ty_constr(p); + hi = constr.span; + append[@ast.constr](constrs, constr); + if (p.peek() == token.COMMA) { + p.bump(); + more = false; + } + } + case (_) { more = false; } + } + } + } + ret spanned(lo, hi, constrs); +} + +impure fn parse_ty_constrs(@ast.ty t, parser p) -> @ast.ty { + if (p.peek() == token.COLON) { + auto constrs = parse_constrs(p); + ret @spanned(t.span, constrs.span, + ast.ty_constr(t, constrs.node)); + } + ret t; +} + impure fn parse_ty(parser p) -> @ast.ty { auto lo = p.get_span(); auto hi = lo; @@ -368,7 +428,8 @@ impure fn parse_ty(parser p) -> @ast.ty { fail; } } - ret @spanned(lo, hi, t); + + ret parse_ty_constrs(@spanned(lo, hi, t), p); } impure fn parse_arg(parser p) -> ast.arg { @@ -1676,6 +1737,11 @@ impure fn parse_fn_decl(parser p, ast.effect eff) -> ast.fn_decl { pf, p); let @ast.ty output; + + // FIXME: dropping constrs on the floor at the moment. + // pick them up when they're used by typestate pass. + parse_constrs(p); + if (p.peek() == token.RARROW) { p.bump(); output = parse_ty(p); -- cgit v1.2.3 From d39da6f97819becd9ea41c194b5f0daa178814fe Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Sun, 6 Mar 2011 13:56:38 -0500 Subject: Remove typestate workarounds --- src/comp/front/parser.rs | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 934764e6..8665a425 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1365,7 +1365,7 @@ impure fn parse_initializer(parser p) -> option.t[@ast.expr] { impure fn parse_pat(parser p) -> @ast.pat { auto lo = p.get_span(); auto hi = lo; - auto pat = ast.pat_wild(ast.ann_none); // FIXME: typestate bug + auto pat; alt (p.peek()) { case (token.UNDERSCORE) { @@ -1541,31 +1541,28 @@ fn index_block(vec[@ast.stmt] stmts, option.t[@ast.expr] expr) -> ast.block_ { auto index = new_str_hash[uint](); auto u = 0u; for (@ast.stmt s in stmts) { - // FIXME: typestate bug requires we do this up top, not - // down below loop. Sigh. - u += 1u; alt (s.node) { case (ast.stmt_decl(?d)) { alt (d.node) { case (ast.decl_local(?loc)) { - index.insert(loc.ident, u-1u); + index.insert(loc.ident, u); } case (ast.decl_item(?it)) { alt (it.node) { case (ast.item_fn(?i, _, _, _, _)) { - index.insert(i, u-1u); + index.insert(i, u); } case (ast.item_mod(?i, _, _)) { - index.insert(i, u-1u); + index.insert(i, u); } case (ast.item_ty(?i, _, _, _, _)) { - index.insert(i, u-1u); + index.insert(i, u); } case (ast.item_tag(?i, _, _, _)) { - index.insert(i, u-1u); + index.insert(i, u); } case (ast.item_obj(?i, _, _, _, _)) { - index.insert(i, u-1u); + index.insert(i, u); } } } @@ -1573,6 +1570,7 @@ fn index_block(vec[@ast.stmt] stmts, option.t[@ast.expr] expr) -> ast.block_ { } case (_) { /* fall through */ } } + u += 1u; } ret rec(stmts=stmts, expr=expr, index=index); } -- cgit v1.2.3 From 1ce6cfbe7c7bf3ffa587d7762825990510f7bfbb Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Mon, 7 Mar 2011 15:29:06 +0100 Subject: use a precedence table for operator parsing --- src/comp/front/parser.rs | 196 ++++++++++++++++------------------------------- 1 file changed, 65 insertions(+), 131 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 8665a425..5b677e9b 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -35,6 +35,7 @@ state type parser = fn get_session() -> session.session; fn get_span() -> common.span; fn next_def_id() -> ast.def_id; + fn get_prec_table() -> vec[op_spec]; }; impure fn new_parser(session.session sess, @@ -50,7 +51,8 @@ impure fn new_parser(session.session sess, mutable ast.def_num def, mutable restriction res, ast.crate_num crate, - lexer.reader rdr) + lexer.reader rdr, + vec[op_spec] precs) { fn peek() -> token.token { ret tok; @@ -100,6 +102,9 @@ impure fn new_parser(session.session sess, ret env; } + fn get_prec_table() -> vec[op_spec] { + ret precs; + } } auto ftype = SOURCE_FILE; if (_str.ends_with(path, ".rc")) { @@ -109,7 +114,8 @@ impure fn new_parser(session.session sess, auto rdr = lexer.new_reader(srdr, path); auto npos = rdr.get_curr_pos(); ret stdio_parser(sess, env, ftype, lexer.next_token(rdr), - npos, npos, 0, UNRESTRICTED, crate, rdr); + npos, npos, 0, UNRESTRICTED, crate, rdr, + prec_table()); } impure fn unexpected(parser p, token.token t) { @@ -975,144 +981,72 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr { ret @spanned(lo, hi, ex); } -impure fn parse_binops(parser p, - (impure fn(parser) -> @ast.expr) sub, - vec[tup(token.binop, ast.binop)] ops) +type op_spec = rec(token.token tok, ast.binop op, int prec); + +fn prec_table() -> vec[op_spec] { + ret vec(rec(tok=token.BINOP(token.STAR), op=ast.mul, prec=11), + rec(tok=token.BINOP(token.SLASH), op=ast.div, prec=11), + rec(tok=token.BINOP(token.PERCENT), op=ast.rem, prec=11), + rec(tok=token.BINOP(token.PLUS), op=ast.add, prec=10), + rec(tok=token.BINOP(token.MINUS), op=ast.sub, prec=10), + rec(tok=token.BINOP(token.LSL), op=ast.lsl, prec=9), + rec(tok=token.BINOP(token.LSR), op=ast.lsr, prec=9), + rec(tok=token.BINOP(token.ASR), op=ast.asr, prec=9), + rec(tok=token.BINOP(token.AND), op=ast.bitand, prec=8), + rec(tok=token.BINOP(token.CARET), op=ast.bitxor, prec=6), + rec(tok=token.BINOP(token.OR), op=ast.bitor, prec=6), + // ast.mul is a bogus placeholder here, AS is special + // cased in parse_more_binops + rec(tok=token.AS, op=ast.mul, prec=5), + rec(tok=token.LT, op=ast.lt, prec=4), + rec(tok=token.LE, op=ast.le, prec=4), + rec(tok=token.GE, op=ast.ge, prec=4), + rec(tok=token.GT, op=ast.gt, prec=4), + rec(tok=token.EQEQ, op=ast.eq, prec=3), + rec(tok=token.NE, op=ast.ne, prec=3), + rec(tok=token.ANDAND, op=ast.and, prec=2), + rec(tok=token.OROR, op=ast.or, prec=1)); +} + +impure fn parse_binops(parser p) -> @ast.expr { + ret parse_more_binops(p, parse_prefix_expr(p), 0); +} + +impure fn parse_more_binops(parser p, @ast.expr lhs, int min_prec) -> @ast.expr { - auto lo = p.get_span(); - auto hi = lo; - auto e = sub(p); - auto more = true; - while (more) { - more = false; - for (tup(token.binop, ast.binop) pair in ops) { - alt (p.peek()) { - case (token.BINOP(?op)) { - if (pair._0 == op) { - p.bump(); - auto rhs = sub(p); - hi = rhs.span; - auto exp = ast.expr_binary(pair._1, e, rhs, - ast.ann_none); - e = @spanned(lo, hi, exp); - more = true; - } + // Magic nonsense to work around rustboot bug + fn op_eq(token.token a, token.token b) -> bool { + if (a == b) {ret true;} + else {ret false;} + } + auto peeked = p.peek(); + for (op_spec cur in p.get_prec_table()) { + if (cur.prec > min_prec && op_eq(cur.tok, peeked)) { + p.bump(); + alt (cur.tok) { + case (token.AS) { + auto rhs = parse_ty(p); + auto _as = ast.expr_cast(lhs, rhs, ast.ann_none); + auto span = @spanned(lhs.span, rhs.span, _as); + ret parse_more_binops(p, span, min_prec); + } + case (_) { + auto rhs = parse_more_binops(p, parse_prefix_expr(p), + cur.prec); + auto bin = ast.expr_binary(cur.op, lhs, rhs, + ast.ann_none); + auto span = @spanned(lhs.span, rhs.span, bin); + ret parse_more_binops(p, span, min_prec); } - case (_) { /* fall through */ } - } - } - } - ret e; -} - -impure fn parse_binary_exprs(parser p, - (impure fn(parser) -> @ast.expr) sub, - vec[tup(token.token, ast.binop)] ops) - -> @ast.expr { - auto lo = p.get_span(); - auto hi = lo; - auto e = sub(p); - auto more = true; - while (more) { - more = false; - for (tup(token.token, ast.binop) pair in ops) { - if (pair._0 == p.peek()) { - p.bump(); - auto rhs = sub(p); - hi = rhs.span; - auto exp = ast.expr_binary(pair._1, e, rhs, ast.ann_none); - e = @spanned(lo, hi, exp); - more = true; - } - } - } - ret e; -} - -impure fn parse_factor_expr(parser p) -> @ast.expr { - auto sub = parse_prefix_expr; - ret parse_binops(p, sub, vec(tup(token.STAR, ast.mul), - tup(token.SLASH, ast.div), - tup(token.PERCENT, ast.rem))); -} - -impure fn parse_term_expr(parser p) -> @ast.expr { - auto sub = parse_factor_expr; - ret parse_binops(p, sub, vec(tup(token.PLUS, ast.add), - tup(token.MINUS, ast.sub))); -} - -impure fn parse_shift_expr(parser p) -> @ast.expr { - auto sub = parse_term_expr; - ret parse_binops(p, sub, vec(tup(token.LSL, ast.lsl), - tup(token.LSR, ast.lsr), - tup(token.ASR, ast.asr))); -} - -impure fn parse_bitand_expr(parser p) -> @ast.expr { - auto sub = parse_shift_expr; - ret parse_binops(p, sub, vec(tup(token.AND, ast.bitand))); -} - -impure fn parse_bitxor_expr(parser p) -> @ast.expr { - auto sub = parse_bitand_expr; - ret parse_binops(p, sub, vec(tup(token.CARET, ast.bitxor))); -} - -impure fn parse_bitor_expr(parser p) -> @ast.expr { - auto sub = parse_bitxor_expr; - ret parse_binops(p, sub, vec(tup(token.OR, ast.bitor))); -} - -impure fn parse_cast_expr(parser p) -> @ast.expr { - auto lo = p.get_span(); - auto e = parse_bitor_expr(p); - auto hi = e.span; - while (true) { - alt (p.peek()) { - case (token.AS) { - p.bump(); - auto t = parse_ty(p); - hi = t.span; - e = @spanned(lo, hi, ast.expr_cast(e, t, ast.ann_none)); - } - - case (_) { - ret e; } } } - ret e; -} - -impure fn parse_relational_expr(parser p) -> @ast.expr { - auto sub = parse_cast_expr; - ret parse_binary_exprs(p, sub, vec(tup(token.LT, ast.lt), - tup(token.LE, ast.le), - tup(token.GE, ast.ge), - tup(token.GT, ast.gt))); -} - - -impure fn parse_equality_expr(parser p) -> @ast.expr { - auto sub = parse_relational_expr; - ret parse_binary_exprs(p, sub, vec(tup(token.EQEQ, ast.eq), - tup(token.NE, ast.ne))); -} - -impure fn parse_and_expr(parser p) -> @ast.expr { - auto sub = parse_equality_expr; - ret parse_binary_exprs(p, sub, vec(tup(token.ANDAND, ast.and))); -} - -impure fn parse_or_expr(parser p) -> @ast.expr { - auto sub = parse_and_expr; - ret parse_binary_exprs(p, sub, vec(tup(token.OROR, ast.or))); + ret lhs; } impure fn parse_assign_expr(parser p) -> @ast.expr { auto lo = p.get_span(); - auto lhs = parse_or_expr(p); + auto lhs = parse_binops(p); alt (p.peek()) { case (token.EQ) { p.bump(); -- cgit v1.2.3 From 44bceb84a71a2dcf71be1545e595e290f35e1fe1 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 7 Mar 2011 10:02:01 -0800 Subject: Complain on unexpected native symbol, rather than failing with none-exhaustive match. --- src/comp/front/parser.rs | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 5b677e9b..67eec424 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1836,6 +1836,9 @@ impure fn parse_native_item(parser p) -> @ast.native_item { case (token.FN) { ret parse_item_native_fn(p, eff); } + case (?t) { + unexpected(p, t); + } } } -- cgit v1.2.3 From dfa85968c346e7d7892a7399cc2b79bfb7e0e5ef Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 7 Mar 2011 10:33:04 -0800 Subject: Stage the last compile fix to put out fire. Thanks git. --- src/comp/front/parser.rs | 1 + 1 file changed, 1 insertion(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 67eec424..8141595b 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1838,6 +1838,7 @@ impure fn parse_native_item(parser p) -> @ast.native_item { } case (?t) { unexpected(p, t); + fail; } } } -- cgit v1.2.3 From 90f299e710c49d689d5bc815e32db375cca00394 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 7 Mar 2011 11:48:43 -0800 Subject: Permit view items in native modules. --- src/comp/front/parser.rs | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 8141595b..6f3111c7 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1846,8 +1846,11 @@ impure fn parse_native_item(parser p) -> @ast.native_item { impure fn parse_native_mod_items(parser p, str native_name, ast.native_abi abi) -> ast.native_mod { - auto index = new_str_hash[@ast.native_item](); + auto index = new_str_hash[ast.native_mod_index_entry](); let vec[@ast.native_item] items = vec(); + + auto view_items = parse_native_view(p, index); + while (p.peek() != token.RBRACE) { auto item = parse_native_item(p); items += vec(item); @@ -1856,7 +1859,9 @@ impure fn parse_native_mod_items(parser p, ast.index_native_item(index, item); } ret rec(native_name=native_name, abi=abi, - items=items, index=index); + view_items=view_items, + items=items, + index=index); } fn default_native_name(session.session sess, str id) -> str { @@ -2230,6 +2235,19 @@ impure fn parse_view(parser p, ast.mod_index index) -> vec[@ast.view_item] { ret items; } +impure fn parse_native_view(parser p, ast.native_mod_index index) + -> vec[@ast.view_item] { + let vec[@ast.view_item] items = vec(); + while (is_view_item(p.peek())) { + auto item = parse_view_item(p); + items += vec(item); + + ast.index_native_view_item(index, item); + } + ret items; +} + + impure fn parse_crate_from_source_file(parser p) -> @ast.crate { auto lo = p.get_span(); auto hi = lo; -- cgit v1.2.3 From 0624f9db4aeaa5681941750c3a1a17ca5fbb7e72 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Fri, 4 Mar 2011 07:22:43 +0100 Subject: Add a pretty-printer Adds a -pp option to the compiler which will cause it to simply pretty-print the given file. --- src/comp/front/parser.rs | 1 + 1 file changed, 1 insertion(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 6f3111c7..f60ff36b 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -983,6 +983,7 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr { type op_spec = rec(token.token tok, ast.binop op, int prec); +// FIXME make this a const, don't store it in parser state fn prec_table() -> vec[op_spec] { ret vec(rec(tok=token.BINOP(token.STAR), op=ast.mul, prec=11), rec(tok=token.BINOP(token.SLASH), op=ast.div, prec=11), -- cgit v1.2.3 From df3038e68bf1189cd9cb0fc81e57da2c23594b63 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 7 Mar 2011 15:38:20 -0800 Subject: Parse opacity (and drop on the floor), so std.rc parses now. --- src/comp/front/parser.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) (limited to 'src/comp/front/parser.rs') diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index f60ff36b..71e592ff 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1830,6 +1830,8 @@ impure fn parse_item_native_fn(parser p, ast.effect eff) -> @ast.native_item { impure fn parse_native_item(parser p) -> @ast.native_item { let ast.effect eff = parse_effect(p); + let ast.opacity opa = parse_opacity(p); + let ast.layer lyr = parse_layer(p); alt (p.peek()) { case (token.TYPE) { ret parse_item_native_type(p); @@ -1978,6 +1980,19 @@ impure fn parse_item_tag(parser p) -> @ast.item { ret @spanned(lo, hi, item); } +impure fn parse_opacity(parser p) -> ast.opacity { + alt (p.peek()) { + case (token.ABS) { + p.bump(); + ret ast.op_abstract; + } + case (_) { + ret ast.op_transparent; + } + } + fail; +} + impure fn parse_layer(parser p) -> ast.layer { alt (p.peek()) { case (token.STATE) { @@ -2033,6 +2048,7 @@ fn peeking_at_item(parser p) -> bool { impure fn parse_item(parser p) -> @ast.item { let ast.effect eff = parse_effect(p); + let ast.opacity opa = parse_opacity(p); let ast.layer lyr = parse_layer(p); alt (p.peek()) { -- cgit v1.2.3