diff options
Diffstat (limited to 'src/libsyntax/parse')
| -rw-r--r-- | src/libsyntax/parse/attr.rs | 132 | ||||
| -rw-r--r-- | src/libsyntax/parse/classify.rs | 69 | ||||
| -rw-r--r-- | src/libsyntax/parse/comments.rs | 203 | ||||
| -rw-r--r-- | src/libsyntax/parse/common.rs | 217 | ||||
| -rw-r--r-- | src/libsyntax/parse/eval.rs | 142 | ||||
| -rw-r--r-- | src/libsyntax/parse/lexer.rs | 536 | ||||
| -rw-r--r-- | src/libsyntax/parse/parser.rs | 2557 | ||||
| -rw-r--r-- | src/libsyntax/parse/prec.rs | 43 | ||||
| -rw-r--r-- | src/libsyntax/parse/token.rs | 286 |
9 files changed, 4185 insertions, 0 deletions
diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs new file mode 100644 index 00000000000..6615938b9ad --- /dev/null +++ b/src/libsyntax/parse/attr.rs @@ -0,0 +1,132 @@ +import either::{either, left, right}; +import ast_util::spanned; +import common::{parser_common, seq_sep}; + +export attr_or_ext; +export parser_attr; + +// A type to distingush between the parsing of item attributes or syntax +// extensions, which both begin with token.POUND +type attr_or_ext = option<either<[ast::attribute], @ast::expr>>; + +impl parser_attr for parser { + + fn parse_outer_attrs_or_ext(first_item_attrs: [ast::attribute]) + -> attr_or_ext + { + let expect_item_next = vec::is_not_empty(first_item_attrs); + if self.token == token::POUND { + let lo = self.span.lo; + if self.look_ahead(1u) == token::LBRACKET { + self.bump(); + let first_attr = + self.parse_attribute_naked(ast::attr_outer, lo); + ret some(left([first_attr] + self.parse_outer_attributes())); + } else if !(self.look_ahead(1u) == token::LT + || self.look_ahead(1u) == token::LBRACKET + || expect_item_next) { + self.bump(); + ret some(right(self.parse_syntax_ext_naked(lo))); + } else { ret none; } + } else { ret none; } + } + + // Parse attributes that appear before an item + fn parse_outer_attributes() -> [ast::attribute] { + let mut attrs: [ast::attribute] = []; + while self.token == token::POUND + && self.look_ahead(1u) == token::LBRACKET { + attrs += [self.parse_attribute(ast::attr_outer)]; + } + ret attrs; + } + + fn parse_attribute(style: ast::attr_style) -> ast::attribute { + let lo = self.span.lo; + self.expect(token::POUND); + ret self.parse_attribute_naked(style, lo); + } + + fn parse_attribute_naked(style: ast::attr_style, lo: uint) -> + ast::attribute { + self.expect(token::LBRACKET); + let meta_item = self.parse_meta_item(); + self.expect(token::RBRACKET); + let mut hi = self.span.hi; + ret spanned(lo, hi, {style: style, value: *meta_item}); + } + + // Parse attributes that appear after the opening of an item, each + // terminated by a semicolon. In addition to a vector of inner attributes, + // this function also returns a vector that may contain the first outer + // attribute of the next item (since we can't know whether the attribute + // is an inner attribute of the containing item or an outer attribute of + // the first contained item until we see the semi). + fn parse_inner_attrs_and_next() -> + {inner: [ast::attribute], next: [ast::attribute]} { + let mut inner_attrs: [ast::attribute] = []; + let mut next_outer_attrs: [ast::attribute] = []; + while self.token == token::POUND { + if self.look_ahead(1u) != token::LBRACKET { + // This is an extension + break; + } + let attr = self.parse_attribute(ast::attr_inner); + if self.token == token::SEMI { + self.bump(); + inner_attrs += [attr]; + } else { + // It's not really an inner attribute + let outer_attr = + spanned(attr.span.lo, attr.span.hi, + {style: ast::attr_outer, value: attr.node.value}); + next_outer_attrs += [outer_attr]; + break; + } + } + ret {inner: inner_attrs, next: next_outer_attrs}; + } + + fn parse_meta_item() -> @ast::meta_item { + let lo = self.span.lo; + let ident = self.parse_ident(); + alt self.token { + token::EQ { + self.bump(); + let lit = self.parse_lit(); + let mut hi = self.span.hi; + ret @spanned(lo, hi, ast::meta_name_value(ident, lit)); + } + token::LPAREN { + let inner_items = self.parse_meta_seq(); + let mut hi = self.span.hi; + ret @spanned(lo, hi, ast::meta_list(ident, inner_items)); + } + _ { + let mut hi = self.span.hi; + ret @spanned(lo, hi, ast::meta_word(ident)); + } + } + } + + fn parse_meta_seq() -> [@ast::meta_item] { + ret self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_meta_item()}).node; + } + + fn parse_optional_meta() -> [@ast::meta_item] { + alt self.token { token::LPAREN { ret self.parse_meta_seq(); } + _ { ret []; } } + } +} + +// +// Local Variables: +// mode: rust +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// End: +// diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs new file mode 100644 index 00000000000..471fe15788d --- /dev/null +++ b/src/libsyntax/parse/classify.rs @@ -0,0 +1,69 @@ +/* + Predicates on exprs and stmts that the pretty-printer and parser use + */ +import ast_util::*; + +fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool { + alt e.node { + ast::expr_if(_, _, _) | ast::expr_if_check(_, _, _) + | ast::expr_alt(_, _, _) | ast::expr_block(_) + | ast::expr_while(_, _) | ast::expr_loop(_) + | ast::expr_call(_, _, true) { + false + } + _ { true } + } +} + +fn stmt_ends_with_semi(stmt: ast::stmt) -> bool { + alt stmt.node { + ast::stmt_decl(d, _) { + ret alt d.node { + ast::decl_local(_) { true } + ast::decl_item(_) { false } + } + } + ast::stmt_expr(e, _) { + ret expr_requires_semi_to_be_stmt(e); + } + ast::stmt_semi(e, _) { + ret false; + } + } +} + +fn need_parens(expr: @ast::expr, outer_prec: uint) -> bool { + alt expr.node { + ast::expr_binary(op, _, _) { operator_prec(op) < outer_prec } + ast::expr_cast(_, _) { parse::prec::as_prec < outer_prec } + // This may be too conservative in some cases + ast::expr_assign(_, _) { true } + ast::expr_move(_, _) { true } + ast::expr_swap(_, _) { true } + ast::expr_assign_op(_, _, _) { true } + ast::expr_ret(_) { true } + ast::expr_assert(_) { true } + ast::expr_check(_, _) { true } + ast::expr_log(_, _, _) { true } + _ { !parse::classify::expr_requires_semi_to_be_stmt(expr) } + } +} + +fn ends_in_lit_int(ex: @ast::expr) -> bool { + alt ex.node { + ast::expr_lit(@{node: ast::lit_int(_, ast::ty_i), _}) { true } + ast::expr_binary(_, _, sub) | ast::expr_unary(_, sub) | + ast::expr_move(_, sub) | ast::expr_copy(sub) | + ast::expr_assign(_, sub) | + ast::expr_assign_op(_, _, sub) | ast::expr_swap(_, sub) | + ast::expr_log(_, _, sub) | ast::expr_assert(sub) | + ast::expr_check(_, sub) { ends_in_lit_int(sub) } + ast::expr_fail(osub) | ast::expr_ret(osub) { + alt osub { + some(ex) { ends_in_lit_int(ex) } + _ { false } + } + } + _ { false } + } +} diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs new file mode 100644 index 00000000000..9fa4a4c3e8c --- /dev/null +++ b/src/libsyntax/parse/comments.rs @@ -0,0 +1,203 @@ +import io::reader_util; +import io::println;//XXXXXXXXxxx +import util::interner; +import lexer::{ reader, new_reader, next_token, is_whitespace }; + +export cmnt; +export lit; +export cmnt_style; +export gather_comments_and_literals; + +enum cmnt_style { + isolated, // No code on either side of each line of the comment + trailing, // Code exists to the left of the comment + mixed, // Code before /* foo */ and after the comment + blank_line, // Just a manual blank line "\n\n", for layout +} + +type cmnt = {style: cmnt_style, lines: [str], pos: uint}; + +fn read_to_eol(rdr: reader) -> str { + let mut val = ""; + while rdr.curr != '\n' && !rdr.is_eof() { + str::push_char(val, rdr.curr); + rdr.bump(); + } + if rdr.curr == '\n' { rdr.bump(); } + ret val; +} + +fn read_one_line_comment(rdr: reader) -> str { + let val = read_to_eol(rdr); + assert ((val[0] == '/' as u8 && val[1] == '/' as u8) || + (val[0] == '#' as u8 && val[1] == '!' as u8)); + ret val; +} + +fn consume_non_eol_whitespace(rdr: reader) { + while is_whitespace(rdr.curr) && rdr.curr != '\n' && !rdr.is_eof() { + rdr.bump(); + } +} + +fn push_blank_line_comment(rdr: reader, &comments: [cmnt]) { + #debug(">>> blank-line comment"); + let v: [str] = []; + comments += [{style: blank_line, lines: v, pos: rdr.chpos}]; +} + +fn consume_whitespace_counting_blank_lines(rdr: reader, &comments: [cmnt]) { + while is_whitespace(rdr.curr) && !rdr.is_eof() { + if rdr.col == 0u && rdr.curr == '\n' { + push_blank_line_comment(rdr, comments); + } + rdr.bump(); + } +} + +fn read_shebang_comment(rdr: reader, code_to_the_left: bool) -> cmnt { + #debug(">>> shebang comment"); + let p = rdr.chpos; + #debug("<<< shebang comment"); + ret {style: if code_to_the_left { trailing } else { isolated }, + lines: [read_one_line_comment(rdr)], + pos: p}; +} + +fn read_line_comments(rdr: reader, code_to_the_left: bool) -> cmnt { + #debug(">>> line comments"); + let p = rdr.chpos; + let mut lines: [str] = []; + while rdr.curr == '/' && rdr.next() == '/' { + let line = read_one_line_comment(rdr); + log(debug, line); + lines += [line]; + consume_non_eol_whitespace(rdr); + } + #debug("<<< line comments"); + ret {style: if code_to_the_left { trailing } else { isolated }, + lines: lines, + pos: p}; +} + +fn all_whitespace(s: str, begin: uint, end: uint) -> bool { + let mut i: uint = begin; + while i != end { if !is_whitespace(s[i] as char) { ret false; } i += 1u; } + ret true; +} + +fn trim_whitespace_prefix_and_push_line(&lines: [str], + s: str, col: uint) unsafe { + let mut s1; + let len = str::len(s); + if all_whitespace(s, 0u, uint::min(len, col)) { + if col < len { + s1 = str::slice(s, col, len); + } else { s1 = ""; } + } else { s1 = s; } + log(debug, "pushing line: " + s1); + lines += [s1]; +} + +fn read_block_comment(rdr: reader, code_to_the_left: bool) -> cmnt { + #debug(">>> block comment"); + let p = rdr.chpos; + let mut lines: [str] = []; + let mut col: uint = rdr.col; + rdr.bump(); + rdr.bump(); + let mut curr_line = "/*"; + let mut level: int = 1; + while level > 0 { + #debug("=== block comment level %d", level); + if rdr.is_eof() { rdr.fatal("unterminated block comment"); } + if rdr.curr == '\n' { + trim_whitespace_prefix_and_push_line(lines, curr_line, col); + curr_line = ""; + rdr.bump(); + } else { + str::push_char(curr_line, rdr.curr); + if rdr.curr == '/' && rdr.next() == '*' { + rdr.bump(); + rdr.bump(); + curr_line += "*"; + level += 1; + } else { + if rdr.curr == '*' && rdr.next() == '/' { + rdr.bump(); + rdr.bump(); + curr_line += "/"; + level -= 1; + } else { rdr.bump(); } + } + } + } + if str::len(curr_line) != 0u { + trim_whitespace_prefix_and_push_line(lines, curr_line, col); + } + let mut style = if code_to_the_left { trailing } else { isolated }; + consume_non_eol_whitespace(rdr); + if !rdr.is_eof() && rdr.curr != '\n' && vec::len(lines) == 1u { + style = mixed; + } + #debug("<<< block comment"); + ret {style: style, lines: lines, pos: p}; +} + +fn peeking_at_comment(rdr: reader) -> bool { + ret ((rdr.curr == '/' && rdr.next() == '/') || + (rdr.curr == '/' && rdr.next() == '*')) || + (rdr.curr == '#' && rdr.next() == '!'); +} + +fn consume_comment(rdr: reader, code_to_the_left: bool, &comments: [cmnt]) { + #debug(">>> consume comment"); + if rdr.curr == '/' && rdr.next() == '/' { + comments += [read_line_comments(rdr, code_to_the_left)]; + } else if rdr.curr == '/' && rdr.next() == '*' { + comments += [read_block_comment(rdr, code_to_the_left)]; + } else if rdr.curr == '#' && rdr.next() == '!' { + comments += [read_shebang_comment(rdr, code_to_the_left)]; + } else { fail; } + #debug("<<< consume comment"); +} + +type lit = {lit: str, pos: uint}; + +fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler, + path: str, + srdr: io::reader) -> + {cmnts: [cmnt], lits: [lit]} { + let src = @str::from_bytes(srdr.read_whole_stream()); + let itr = @interner::mk::<str>(str::hash, str::eq); + let rdr = new_reader(span_diagnostic, + codemap::new_filemap(path, src, 0u, 0u), itr); + let mut comments: [cmnt] = []; + let mut literals: [lit] = []; + let mut first_read: bool = true; + while !rdr.is_eof() { + loop { + let mut code_to_the_left = !first_read; + consume_non_eol_whitespace(rdr); + if rdr.curr == '\n' { + code_to_the_left = false; + consume_whitespace_counting_blank_lines(rdr, comments); + } + while peeking_at_comment(rdr) { + consume_comment(rdr, code_to_the_left, comments); + consume_whitespace_counting_blank_lines(rdr, comments); + } + break; + } + let tok = next_token(rdr); + if token::is_lit(tok.tok) { + let s = rdr.get_str_from(tok.bpos); + literals += [{lit: s, pos: tok.chpos}]; + log(debug, "tok lit: " + s); + } else { + log(debug, "tok: " + token::to_str(*rdr.interner, tok.tok)); + } + first_read = false; + } + ret {cmnts: comments, lits: literals}; +} diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs new file mode 100644 index 00000000000..4bfba482c4f --- /dev/null +++ b/src/libsyntax/parse/common.rs @@ -0,0 +1,217 @@ +import std::map::{hashmap}; +import ast_util::spanned; +import parser::parser; + +type seq_sep = { + sep: option<token::token>, + trailing_opt: bool // is trailing separator optional? +}; + +fn seq_sep(t: token::token) -> seq_sep { + ret {sep: option::some(t), trailing_opt: false}; +} +fn seq_sep_opt(t: token::token) -> seq_sep { + ret {sep: option::some(t), trailing_opt: true}; +} +fn seq_sep_none() -> seq_sep { + ret {sep: option::none, trailing_opt: false}; +} + + +fn token_to_str(reader: reader, token: token::token) -> str { + token::to_str(*reader.interner, token) +} + + +// This should be done with traits, once traits work +impl parser_common for parser { + + fn unexpected_last(t: token::token) -> ! { + self.span_fatal(self.last_span, "unexpected token: '" + + token_to_str(self.reader, t) + "'"); + } + + fn unexpected() -> ! { + self.fatal("unexpected token: '" + + token_to_str(self.reader, self.token) + "'"); + } + + fn expect(t: token::token) { + if self.token == t { + self.bump(); + } else { + let mut s: str = "expecting '"; + s += token_to_str(self.reader, t); + s += "' but found '"; + s += token_to_str(self.reader, self.token); + self.fatal(s + "'"); + } + } + + fn parse_ident() -> ast::ident { + alt self.token { + token::IDENT(i, _) { self.bump(); ret self.get_str(i); } + _ { self.fatal("expecting ident, found " + + token_to_str(self.reader, self.token)); } + } + } + + fn parse_path_list_ident() -> ast::path_list_ident { + let lo = self.span.lo; + let ident = self.parse_ident(); + let hi = self.span.hi; + ret spanned(lo, hi, {name: ident, id: self.get_id()}); + } + + fn parse_value_ident() -> ast::ident { + self.check_restricted_keywords(); + ret self.parse_ident(); + } + + fn eat(tok: token::token) -> bool { + ret if self.token == tok { self.bump(); true } else { false }; + } + + // A sanity check that the word we are asking for is a known keyword + fn require_keyword(word: str) { + if !self.keywords.contains_key(word) { + self.bug(#fmt("unknown keyword: %s", word)); + } + } + + fn token_is_keyword(word: str, tok: token::token) -> bool { + self.require_keyword(word); + alt tok { + token::IDENT(sid, false) { str::eq(word, self.get_str(sid)) } + _ { false } + } + } + + fn is_keyword(word: str) -> bool { + self.token_is_keyword(word, self.token) + } + + fn eat_keyword(word: str) -> bool { + self.require_keyword(word); + alt self.token { + token::IDENT(sid, false) { + if str::eq(word, self.get_str(sid)) { + self.bump(); + ret true; + } else { ret false; } + } + _ { ret false; } + } + } + + fn expect_keyword(word: str) { + self.require_keyword(word); + if !self.eat_keyword(word) { + self.fatal("expecting " + word + ", found " + + token_to_str(self.reader, self.token)); + } +} + + fn is_restricted_keyword(word: str) -> bool { + self.restricted_keywords.contains_key(word) + } + + fn check_restricted_keywords() { + alt self.token { + token::IDENT(_, false) { + let w = token_to_str(self.reader, self.token); + self.check_restricted_keywords_(w); + } + _ { } + } + } + + fn check_restricted_keywords_(w: ast::ident) { + if self.is_restricted_keyword(w) { + self.fatal("found `" + w + "` in restricted position"); + } + } + + fn expect_gt() { + if self.token == token::GT { + self.bump(); + } else if self.token == token::BINOP(token::SHR) { + self.swap(token::GT, self.span.lo + 1u, self.span.hi); + } else { + let mut s: str = "expecting "; + s += token_to_str(self.reader, token::GT); + s += ", found "; + s += token_to_str(self.reader, self.token); + self.fatal(s); + } + } + + fn parse_seq_to_before_gt<T: copy>(sep: option<token::token>, + f: fn(parser) -> T) -> [T] { + let mut first = true; + let mut v = []; + while self.token != token::GT + && self.token != token::BINOP(token::SHR) { + alt sep { + some(t) { if first { first = false; } + else { self.expect(t); } } + _ { } + } + v += [f(self)]; + } + + ret v; + } + + fn parse_seq_to_gt<T: copy>(sep: option<token::token>, + f: fn(parser) -> T) -> [T] { + let v = self.parse_seq_to_before_gt(sep, f); + self.expect_gt(); + + ret v; + } + + fn parse_seq_lt_gt<T: copy>(sep: option<token::token>, + f: fn(parser) -> T) -> spanned<[T]> { + let lo = self.span.lo; + self.expect(token::LT); + let result = self.parse_seq_to_before_gt::<T>(sep, f); + let hi = self.span.hi; + self.expect_gt(); + ret spanned(lo, hi, result); + } + + fn parse_seq_to_end<T: copy>(ket: token::token, sep: seq_sep, + f: fn(parser) -> T) -> [T] { + let val = self.parse_seq_to_before_end(ket, sep, f); + self.bump(); + ret val; + } + + + fn parse_seq_to_before_end<T: copy>(ket: token::token, sep: seq_sep, + f: fn(parser) -> T) -> [T] { + let mut first: bool = true; + let mut v: [T] = []; + while self.token != ket { + alt sep.sep { + some(t) { if first { first = false; } + else { self.expect(t); } } + _ { } + } + if sep.trailing_opt && self.token == ket { break; } + v += [f(self)]; + } + ret v; + } + + fn parse_seq<T: copy>(bra: token::token, ket: token::token, sep: seq_sep, + f: fn(parser) -> T) -> spanned<[T]> { + let lo = self.span.lo; + self.expect(bra); + let result = self.parse_seq_to_before_end::<T>(ket, sep, f); + let hi = self.span.hi; + self.bump(); + ret spanned(lo, hi, result); + } +} \ No newline at end of file diff --git a/src/libsyntax/parse/eval.rs b/src/libsyntax/parse/eval.rs new file mode 100644 index 00000000000..98d75499878 --- /dev/null +++ b/src/libsyntax/parse/eval.rs @@ -0,0 +1,142 @@ +import parser::{parser, SOURCE_FILE}; +import attr::parser_attr; + +export eval_crate_directives_to_mod; + +type ctx = + @{sess: parse::parse_sess, + cfg: ast::crate_cfg}; + +fn eval_crate_directives(cx: ctx, cdirs: [@ast::crate_directive], prefix: str, + &view_items: [@ast::view_item], + &items: [@ast::item]) { + for cdirs.each {|sub_cdir| + eval_crate_directive(cx, sub_cdir, prefix, view_items, items); + } +} + +fn eval_crate_directives_to_mod(cx: ctx, cdirs: [@ast::crate_directive], + prefix: str, suffix: option<str>) + -> (ast::_mod, [ast::attribute]) { + #debug("eval crate prefix: %s", prefix); + #debug("eval crate suffix: %s", + option::get_default(suffix, "none")); + let (cview_items, citems, cattrs) + = parse_companion_mod(cx, prefix, suffix); + let mut view_items: [@ast::view_item] = []; + let mut items: [@ast::item] = []; + eval_crate_directives(cx, cdirs, prefix, view_items, items); + ret ({view_items: view_items + cview_items, + items: items + citems}, + cattrs); +} + +/* +The 'companion mod'. So .rc crates and directory mod crate directives define +modules but not a .rs file to fill those mods with stuff. The companion mod is +a convention for location a .rs file to go with them. For .rc files the +companion mod is a .rs file with the same name; for directory mods the +companion mod is a .rs file with the same name as the directory. + +We build the path to the companion mod by combining the prefix and the +optional suffix then adding the .rs extension. +*/ +fn parse_companion_mod(cx: ctx, prefix: str, suffix: option<str>) + -> ([@ast::view_item], [@ast::item], [ast::attribute]) { + + fn companion_file(prefix: str, suffix: option<str>) -> str { + ret alt suffix { + option::some(s) { path::connect(prefix, s) } + option::none { prefix } + } + ".rs"; + } + + fn file_exists(path: str) -> bool { + // Crude, but there's no lib function for this and I'm not + // up to writing it just now + alt io::file_reader(path) { + result::ok(_) { true } + result::err(_) { false } + } + } + + let modpath = companion_file(prefix, suffix); + #debug("looking for companion mod %s", modpath); + if file_exists(modpath) { + #debug("found companion mod"); + let p0 = new_parser_from_file(cx.sess, cx.cfg, modpath, SOURCE_FILE); + let inner_attrs = p0.parse_inner_attrs_and_next(); + let first_item_outer_attrs = inner_attrs.next; + let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs); + cx.sess.chpos = p0.reader.chpos; + cx.sess.byte_pos = cx.sess.byte_pos + p0.reader.pos; + ret (m0.view_items, m0.items, inner_attrs.inner); + } else { + ret ([], [], []); + } +} + +fn cdir_path_opt(id: str, attrs: [ast::attribute]) -> str { + alt ::attr::first_attr_value_str_by_name(attrs, "path") { + some(d) { + ret d; + } + none { ret id; } + } +} + +fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str, + &view_items: [@ast::view_item], + &items: [@ast::item]) { + alt cdir.node { + ast::cdir_src_mod(id, attrs) { + let file_path = cdir_path_opt(id + ".rs", attrs); + let full_path = + if path::path_is_absolute(file_path) { + file_path + } else { prefix + path::path_sep() + file_path }; + let p0 = + new_parser_from_file(cx.sess, cx.cfg, full_path, SOURCE_FILE); + let inner_attrs = p0.parse_inner_attrs_and_next(); + let mod_attrs = attrs + inner_attrs.inner; + let first_item_outer_attrs = inner_attrs.next; + let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs); + + let i = p0.mk_item(cdir.span.lo, cdir.span.hi, id, + ast::item_mod(m0), ast::public, mod_attrs); + // Thread defids, chpos and byte_pos through the parsers + cx.sess.chpos = p0.reader.chpos; + cx.sess.byte_pos = cx.sess.byte_pos + p0.reader.pos; + items += [i]; + } + ast::cdir_dir_mod(id, cdirs, attrs) { + let path = cdir_path_opt(id, attrs); + let full_path = + if path::path_is_absolute(path) { + path + } else { prefix + path::path_sep() + path }; + let (m0, a0) = eval_crate_directives_to_mod( + cx, cdirs, full_path, none); + let i = + @{ident: id, + attrs: attrs + a0, + id: cx.sess.next_id, + node: ast::item_mod(m0), + vis: ast::public, + span: cdir.span}; + cx.sess.next_id += 1; + items += [i]; + } + ast::cdir_view_item(vi) { view_items += [vi]; } + ast::cdir_syntax(pth) { } + } +} +// +// Local Variables: +// mode: rust +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// End: +// diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs new file mode 100644 index 00000000000..63dc85e865d --- /dev/null +++ b/src/libsyntax/parse/lexer.rs @@ -0,0 +1,536 @@ +import util::interner; +import util::interner::intern; +import diagnostic; + +export reader, new_reader, next_token, is_whitespace; + +type reader = @{ + span_diagnostic: diagnostic::span_handler, + src: @str, + mut col: uint, + mut pos: uint, + mut curr: char, + mut chpos: uint, + filemap: codemap::filemap, + interner: @interner::interner<str> +}; + +impl reader for reader { + fn is_eof() -> bool { self.curr == -1 as char } + fn get_str_from(start: uint) -> str unsafe { + // I'm pretty skeptical about this subtraction. What if there's a + // multi-byte character before the mark? + ret str::slice(*self.src, start - 1u, self.pos - 1u); + } + fn next() -> char { + if self.pos < (*self.src).len() { + ret str::char_at(*self.src, self.pos); + } else { ret -1 as char; } + } + fn bump() { + if self.pos < (*self.src).len() { + self.col += 1u; + self.chpos += 1u; + if self.curr == '\n' { + codemap::next_line(self.filemap, self.chpos, self.pos); + self.col = 0u; + } + let next = str::char_range_at(*self.src, self.pos); + self.pos = next.next; + self.curr = next.ch; + } else { + if (self.curr != -1 as char) { + self.col += 1u; + self.chpos += 1u; + self.curr = -1 as char; + } + } + } + fn fatal(m: str) -> ! { + self.span_diagnostic.span_fatal( + ast_util::mk_sp(self.chpos, self.chpos), + m) + } +} + +fn new_reader(span_diagnostic: diagnostic::span_handler, + filemap: codemap::filemap, + itr: @interner::interner<str>) -> reader { + let r = @{span_diagnostic: span_diagnostic, src: filemap.src, + mut col: 0u, mut pos: 0u, mut curr: -1 as char, + mut chpos: filemap.start_pos.ch, + filemap: filemap, interner: itr}; + if r.pos < (*filemap.src).len() { + let next = str::char_range_at(*r.src, r.pos); + r.pos = next.next; + r.curr = next.ch; + } + ret r; +} + +fn dec_digit_val(c: char) -> int { ret (c as int) - ('0' as int); } + +fn hex_digit_val(c: char) -> int { + if in_range(c, '0', '9') { ret (c as int) - ('0' as int); } + if in_range(c, 'a', 'f') { ret (c as int) - ('a' as int) + 10; } + if in_range(c, 'A', 'F') { ret (c as int) - ('A' as int) + 10; } + fail; +} + +fn bin_digit_value(c: char) -> int { if c == '0' { ret 0; } ret 1; } + +fn is_whitespace(c: char) -> bool { + ret c == ' ' || c == '\t' || c == '\r' || c == '\n'; +} + +fn may_begin_ident(c: char) -> bool { ret is_alpha(c) || c == '_'; } + +fn in_range(c: char, lo: char, hi: char) -> bool { ret lo <= c && c <= hi; } + +fn is_alpha(c: char) -> bool { + ret in_range(c, 'a', 'z') || in_range(c, 'A', 'Z'); +} + +fn is_dec_digit(c: char) -> bool { ret in_range(c, '0', '9'); } + +fn is_alnum(c: char) -> bool { ret is_alpha(c) || is_dec_digit(c); } + +fn is_hex_digit(c: char) -> bool { + ret in_range(c, '0', '9') || in_range(c, 'a', 'f') || + in_range(c, 'A', 'F'); +} + +fn is_bin_digit(c: char) -> bool { ret c == '0' || c == '1'; } + +fn consume_whitespace_and_comments(rdr: reader) { + while is_whitespace(rdr.curr) { rdr.bump(); } + ret consume_any_line_comment(rdr); +} + +fn consume_any_line_comment(rdr: reader) { + if rdr.curr == '/' { + alt rdr.next() { + '/' { + while rdr.curr != '\n' && !rdr.is_eof() { rdr.bump(); } + // Restart whitespace munch. + + ret consume_whitespace_and_comments(rdr); + } + '*' { rdr.bump(); rdr.bump(); ret consume_block_comment(rdr); } + _ { ret; } + } + } else if rdr.curr == '#' { + if rdr.next() == '!' { + let cmap = codemap::new_codemap(); + (*cmap).files.push(rdr.filemap); + let loc = codemap::lookup_char_pos_adj(cmap, rdr.chpos); + if loc.line == 1u && loc.col == 0u { + while rdr.curr != '\n' && !rdr.is_eof() { rdr.bump(); } + ret consume_whitespace_and_comments(rdr); + } + } + } +} + +fn consume_block_comment(rdr: reader) { + let mut level: int = 1; + while level > 0 { + if rdr.is_eof() { rdr.fatal("unterminated block comment"); } + if rdr.curr == '/' && rdr.next() == '*' { + rdr.bump(); + rdr.bump(); + level += 1; + } else { + if rdr.curr == '*' && rdr.next() == '/' { + rdr.bump(); + rdr.bump(); + level -= 1; + } else { rdr.bump(); } + } + } + // restart whitespace munch. + + ret consume_whitespace_and_comments(rdr); +} + +fn scan_exponent(rdr: reader) -> option<str> { + let mut c = rdr.curr; + let mut rslt = ""; + if c == 'e' || c == 'E' { + str::push_char(rslt, c); + rdr.bump(); + c = rdr.curr; + if c == '-' || c == '+' { + str::push_char(rslt, c); + rdr.bump(); + } + let exponent = scan_digits(rdr, 10u); + if str::len(exponent) > 0u { + ret some(rslt + exponent); + } else { rdr.fatal("scan_exponent: bad fp literal"); } + } else { ret none::<str>; } +} + +fn scan_digits(rdr: reader, radix: uint) -> str { + let mut rslt = ""; + loop { + let c = rdr.curr; + if c == '_' { rdr.bump(); cont; } + alt char::to_digit(c, radix) { + some(d) { + str::push_char(rslt, c); + rdr.bump(); + } + _ { ret rslt; } + } + }; +} + +fn scan_number(c: char, rdr: reader) -> token::token { + let mut num_str, base = 10u, c = c, n = rdr.next(); + if c == '0' && n == 'x' { + rdr.bump(); + rdr.bump(); + base = 16u; + } else if c == '0' && n == 'b' { + rdr.bump(); + rdr.bump(); + base = 2u; + } + num_str = scan_digits(rdr, base); + c = rdr.curr; + rdr.next(); + if c == 'u' || c == 'i' { + let signed = c == 'i'; + let mut tp = { + if signed { either::left(ast::ty_i) } + else { either::right(ast::ty_u) } + }; + rdr.bump(); + c = rdr.curr; + if c == '8' { + rdr.bump(); + tp = if signed { either::left(ast::ty_i8) } + else { either::right(ast::ty_u8) }; + } + n = rdr.next(); + if c == '1' && n == '6' { + rdr.bump(); + rdr.bump(); + tp = if signed { either::left(ast::ty_i16) } + else { either::right(ast::ty_u16) }; + } else if c == '3' && n == '2' { + rdr.bump(); + rdr.bump(); + tp = if signed { either::left(ast::ty_i32) } + else { either::right(ast::ty_u32) }; + } else if c == '6' && n == '4' { + rdr.bump(); + rdr.bump(); + tp = if signed { either::left(ast::ty_i64) } + else { either::right(ast::ty_u64) }; + } + if str::len(num_str) == 0u { + rdr.fatal("no valid digits found for number"); + } + let parsed = option::get(u64::from_str_radix(num_str, base as u64)); + alt tp { + either::left(t) { ret token::LIT_INT(parsed as i64, t); } + either::right(t) { ret token::LIT_UINT(parsed, t); } + } + } + let mut is_float = false; + if rdr.curr == '.' && !(is_alpha(rdr.next()) || rdr.next() == '_') { + is_float = true; + rdr.bump(); + let dec_part = scan_digits(rdr, 10u); + num_str += "." + dec_part; + } + alt scan_exponent(rdr) { + some(s) { + is_float = true; + num_str += s; + } + none {} + } + if rdr.curr == 'f' { + rdr.bump(); + c = rdr.curr; + n = rdr.next(); + if c == '3' && n == '2' { + rdr.bump(); + rdr.bump(); + ret token::LIT_FLOAT(intern(*rdr.interner, num_str), + ast::ty_f32); + } else if c == '6' && n == '4' { + rdr.bump(); + rdr.bump(); + ret token::LIT_FLOAT(intern(*rdr.interner, num_str), + ast::ty_f64); + /* FIXME: if this is out of range for either a 32-bit or + 64-bit float, it won't be noticed till the back-end (Issue #2252) + */ + } else { + is_float = true; + } + } + if is_float { + ret token::LIT_FLOAT(interner::intern(*rdr.interner, num_str), + ast::ty_f); + } else { + if str::len(num_str) == 0u { + rdr.fatal("no valid digits found for number"); + } + let parsed = option::get(u64::from_str_radix(num_str, base as u64)); + ret token::LIT_INT(parsed as i64, ast::ty_i); + } +} + +fn scan_numeric_escape(rdr: reader, n_hex_digits: uint) -> char { + let mut accum_int = 0, i = n_hex_digits; + while i != 0u { + let n = rdr.curr; + rdr.bump(); + if !is_hex_digit(n) { + rdr.fatal(#fmt["illegal numeric character escape: %d", n as int]); + } + accum_int *= 16; + accum_int += hex_digit_val(n); + i -= 1u; + } + ret accum_int as char; +} + +fn next_token(rdr: reader) -> {tok: token::token, chpos: uint, bpos: uint} { + consume_whitespace_and_comments(rdr); + let start_chpos = rdr.chpos; + let start_bpos = rdr.pos; + let tok = if rdr.is_eof() { token::EOF } else { next_token_inner(rdr) }; + ret {tok: tok, chpos: start_chpos, bpos: start_bpos}; +} + +fn next_token_inner(rdr: reader) -> token::token { + let mut accum_str = ""; + let mut c = rdr.curr; + if (c >= 'a' && c <= 'z') + || (c >= 'A' && c <= 'Z') + || c == '_' + || (c > 'z' && char::is_XID_start(c)) { + while (c >= 'a' && c <= 'z') + || (c >= 'A' && c <= 'Z') + || (c >= '0' && c <= '9') + || c == '_' + || (c > 'z' && char::is_XID_continue(c)) { + str::push_char(accum_str, c); + rdr.bump(); + c = rdr.curr; + } + if str::eq(accum_str, "_") { ret token::UNDERSCORE; } + let is_mod_name = c == ':' && rdr.next() == ':'; + + // FIXME: perform NFKC normalization here. (Issue #2253) + ret token::IDENT(interner::intern::<str>(*rdr.interner, + accum_str), is_mod_name); + } + if is_dec_digit(c) { + ret scan_number(c, rdr); + } + fn binop(rdr: reader, op: token::binop) -> token::token { + rdr.bump(); + if rdr.curr == '=' { + rdr.bump(); + ret token::BINOPEQ(op); + } else { ret token::BINOP(op); } + } + alt c { + + + + + + // One-byte tokens. + ';' { rdr.bump(); ret token::SEMI; } + ',' { rdr.bump(); ret token::COMMA; } + '.' { + rdr.bump(); + if rdr.curr == '.' && rdr.next() == '.' { + rdr.bump(); + rdr.bump(); + ret token::ELLIPSIS; + } + ret token::DOT; + } + '(' { rdr.bump(); ret token::LPAREN; } + ')' { rdr.bump(); ret token::RPAREN; } + '{' { rdr.bump(); ret token::LBRACE; } + '}' { rdr.bump(); ret token::RBRACE; } + '[' { rdr.bump(); ret token::LBRACKET; } + ']' { rdr.bump(); ret token::RBRACKET; } + '@' { rdr.bump(); ret token::AT; } + '#' { rdr.bump(); ret token::POUND; } + '~' { rdr.bump(); ret token::TILDE; } + ':' { + rdr.bump(); + if rdr.curr == ':' { + rdr.bump(); + ret token::MOD_SEP; + } else { ret token::COLON; } + } + + '$' { rdr.bump(); ret token::DOLLAR; } + + + + + + // Multi-byte tokens. + '=' { + rdr.bump(); + if rdr.curr == '=' { + rdr.bump(); + ret token::EQEQ; + } else { ret token::EQ; } + } + '!' { + rdr.bump(); + if rdr.curr == '=' { + rdr.bump(); + ret token::NE; + } else { ret token::NOT; } + } + '<' { + rdr.bump(); + alt rdr.curr { + '=' { rdr.bump(); ret token::LE; } + '<' { ret binop(rdr, token::SHL); } + '-' { + rdr.bump(); + alt rdr.curr { + '>' { rdr.bump(); ret token::DARROW; } + _ { ret token::LARROW; } + } + } + _ { ret token::LT; } + } + } + '>' { + rdr.bump(); + alt rdr.curr { + '=' { rdr.bump(); ret token::GE; } + '>' { ret binop(rdr, token::SHR); } + _ { ret token::GT; } + } + } + '\'' { + rdr.bump(); + let mut c2 = rdr.curr; + rdr.bump(); + if c2 == '\\' { + let escaped = rdr.curr; + rdr.bump(); + alt escaped { + 'n' { c2 = '\n'; } + 'r' { c2 = '\r'; } + 't' { c2 = '\t'; } + '\\' { c2 = '\\'; } + '\'' { c2 = '\''; } + 'x' { c2 = scan_numeric_escape(rdr, 2u); } + 'u' { c2 = scan_numeric_escape(rdr, 4u); } + 'U' { c2 = scan_numeric_escape(rdr, 8u); } + c2 { + rdr.fatal(#fmt["unknown character escape: %d", c2 as int]); + } + } + } + if rdr.curr != '\'' { + rdr.fatal("unterminated character constant"); + } + rdr.bump(); // advance curr past token + ret token::LIT_INT(c2 as i64, ast::ty_char); + } + '"' { + let n = rdr.chpos; + rdr.bump(); + while rdr.curr != '"' { + if rdr.is_eof() { + rdr.fatal(#fmt["unterminated double quote string: %s", + rdr.get_str_from(n)]); + } + + let ch = rdr.curr; + rdr.bump(); + alt ch { + '\\' { + let escaped = rdr.curr; + rdr.bump(); + alt escaped { + 'n' { str::push_char(accum_str, '\n'); } + 'r' { str::push_char(accum_str, '\r'); } + 't' { str::push_char(accum_str, '\t'); } + '\\' { str::push_char(accum_str, '\\'); } + '"' { str::push_char(accum_str, '"'); } + '\n' { consume_whitespace(rdr); } + 'x' { + str::push_char(accum_str, scan_numeric_escape(rdr, 2u)); + } + 'u' { + str::push_char(accum_str, scan_numeric_escape(rdr, 4u)); + } + 'U' { + str::push_char(accum_str, scan_numeric_escape(rdr, 8u)); + } + c2 { + rdr.fatal(#fmt["unknown string escape: %d", c2 as int]); + } + } + } + _ { str::push_char(accum_str, ch); } + } + } + rdr.bump(); + ret token::LIT_STR(interner::intern::<str>(*rdr.interner, + accum_str)); + } + '-' { + if rdr.next() == '>' { + rdr.bump(); + rdr.bump(); + ret token::RARROW; + } else { ret binop(rdr, token::MINUS); } + } + '&' { + if rdr.next() == '&' { + rdr.bump(); + rdr.bump(); + ret token::ANDAND; + } else { ret binop(rdr, token::AND); } + } + '|' { + alt rdr.next() { + '|' { rdr.bump(); rdr.bump(); ret token::OROR; } + _ { ret binop(rdr, token::OR); } + } + } + '+' { ret binop(rdr, token::PLUS); } + '*' { ret binop(rdr, token::STAR); } + '/' { ret binop(rdr, token::SLASH); } + '^' { ret binop(rdr, token::CARET); } + '%' { ret binop(rdr, token::PERCENT); } + c { rdr.fatal(#fmt["unknown start of token: %d", c as int]); } + } +} + +fn consume_whitespace(rdr: reader) { + while is_whitespace(rdr.curr) && !rdr.is_eof() { rdr.bump(); } +} + + +// +// Local Variables: +// mode: rust +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// End: +// diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs new file mode 100644 index 00000000000..8594aed9776 --- /dev/null +++ b/src/libsyntax/parse/parser.rs @@ -0,0 +1,2557 @@ +import result::result; +import either::{either, left, right}; +import std::map::{hashmap, str_hash}; +import token::{can_begin_expr, is_ident, is_plain_ident}; +import codemap::{span,fss_none}; +import util::interner; +import ast_util::{spanned, mk_sp, ident_to_path, operator_prec}; +import ast::*; +import lexer::reader; +import prec::{as_prec, token_to_binop}; +import attr::parser_attr; +import common::*; +import dvec::{dvec, extensions}; + +export file_type; +export parser; +export parse_expr; +export parse_pat; + +// FIXME: #ast expects to find this here but it's actually defined in `parse` +// Fixing this will be easier when we have export decls on individual items -- +// then parse can export this publicly, and everything else crate-visibly. +// (See #1893) +import parse_from_source_str; +export parse_from_source_str; + +// TODO: remove these once we go around a snapshot cycle. +// These are here for the old way that #ast (qquote.rs) worked +fn parse_expr(p: parser) -> @ast::expr { p.parse_expr() } +fn parse_pat(p: parser) -> @ast::pat { p.parse_pat() } + + +enum restriction { + UNRESTRICTED, + RESTRICT_STMT_EXPR, + RESTRICT_NO_CALL_EXPRS, + RESTRICT_NO_BAR_OP, +} + +enum file_type { CRATE_FILE, SOURCE_FILE, } + + +// We don't allow single-entry tuples in the true AST; that indicates a +// parenthesized expression. However, we preserve them temporarily while +// parsing because `(while{...})+3` parses differently from `while{...}+3`. +// +// To reflect the fact that the @expr is not a true expr that should be +// part of the AST, we wrap such expressions in the pexpr enum. They +// can then be converted to true expressions by a call to `to_expr()`. +enum pexpr { + pexpr(@expr), +} + +/* + So that we can distinguish a class ctor or dtor + from other class members + */ +enum class_contents { ctor_decl(fn_decl, blk, codemap::span), + dtor_decl(blk, codemap::span), + members([@class_member]) } + +type arg_or_capture_item = either<arg, capture_item>; +type item_info = (ident, item_, option<[attribute]>); + +class parser { + let sess: parse_sess; + let cfg: crate_cfg; + let file_type: file_type; + let mut token: token::token; + let mut span: span; + let mut last_span: span; + let buffer: dvec<{tok: token::token, span: span}>; + let mut restriction: restriction; + let reader: reader; + let keywords: hashmap<str, ()>; + let restricted_keywords: hashmap<str, ()>; + + new(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, + ftype: file_type) { + let tok0 = lexer::next_token(rdr); + let span0 = ast_util::mk_sp(tok0.chpos, rdr.chpos); + self.sess = sess; + self.cfg = cfg; + self.file_type = ftype; + self.token = tok0.tok; + self.span = span0; + self.last_span = span0; + self.buffer = dvec::dvec(); + self.restriction = UNRESTRICTED; + self.reader = rdr; + self.keywords = token::keyword_table(); + self.restricted_keywords = token::restricted_keyword_table(); + } + + //TODO: uncomment when destructors workd + //drop {} /* do not copy the parser; its state is tied to outside state */ + + fn bump() { + self.last_span = self.span; + if self.buffer.len() == 0u { + let next = lexer::next_token(self.reader); + self.token = next.tok; + self.span = mk_sp(next.chpos, self.reader.chpos); + } else { + let next = self.buffer.shift(); + self.token = next.tok; + self.span = next.span; + } + } + fn swap(next: token::token, lo: uint, hi: uint) { + self.token = next; + self.span = mk_sp(lo, hi); + } + fn look_ahead(distance: uint) -> token::token { + while self.buffer.len() < distance { + let next = lexer::next_token(self.reader); + let sp = mk_sp(next.chpos, self.reader.chpos); + self.buffer.push({tok: next.tok, span: sp}); + } + ret self.buffer[distance - 1u].tok; + } + fn fatal(m: str) -> ! { + self.sess.span_diagnostic.span_fatal(self.span, m) + } + fn span_fatal(sp: span, m: str) -> ! { + self.sess.span_diagnostic.span_fatal(sp, m) + } + fn bug(m: str) -> ! { + self.sess.span_diagnostic.span_bug(self.span, m) + } + fn warn(m: str) { + self.sess.span_diagnostic.span_warn(self.span, m) + } + fn get_str(i: token::str_num) -> str { + interner::get(*self.reader.interner, i) + } + fn get_id() -> node_id { next_node_id(self.sess) } + + fn parse_ty_fn(purity: ast::purity) -> ty_ { + let proto = if self.eat_keyword("native") { + self.expect_keyword("fn"); + ast::proto_bare + } else { + self.expect_keyword("fn"); + self.parse_fn_ty_proto() + }; + ty_fn(proto, self.parse_ty_fn_decl(purity)) + } + + fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl { + let inputs = + self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA)) { |p| + let mode = p.parse_arg_mode(); + let name = if is_plain_ident(p.token) + && p.look_ahead(1u) == token::COLON { + + let name = self.parse_value_ident(); + p.bump(); + name + } else { "" }; + + {mode: mode, ty: p.parse_ty(false), ident: name, + id: p.get_id()} + }; + // FIXME: constrs is empty because right now, higher-order functions + // can't have constrained types. + // Not sure whether that would be desirable anyway. See #34 for the + // story on constrained types. + let constrs: [@constr] = []; + let (ret_style, ret_ty) = self.parse_ret_ty(); + ret {inputs: inputs.node, output: ret_ty, + purity: purity, cf: ret_style, + constraints: constrs}; + } + + fn parse_ty_methods() -> [ty_method] { + (self.parse_seq(token::LBRACE, token::RBRACE, seq_sep_none()) { |p| + let attrs = p.parse_outer_attributes(); + let flo = p.span.lo; + let pur = p.parse_fn_purity(); + let ident = p.parse_method_name(); + let tps = p.parse_ty_params(); + let d = p.parse_ty_fn_decl(pur), fhi = p.last_span.hi; + self.expect(token::SEMI); + {ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps, + span: mk_sp(flo, fhi)} + }).node + } + + fn parse_mt() -> mt { + let mutbl = self.parse_mutability(); + let t = self.parse_ty(false); + ret {ty: t, mutbl: mutbl}; + } + + fn parse_ty_field() -> ty_field { + let lo = self.span.lo; + let mutbl = self.parse_mutability(); + let id = self.parse_ident(); + self.expect(token::COLON); + let ty = self.parse_ty(false); + ret spanned(lo, ty.span.hi, {ident: id, mt: {ty: ty, mutbl: mutbl}}); + } + + // if i is the jth ident in args, return j + // otherwise, fail + fn ident_index(args: [arg], i: ident) -> uint { + let mut j = 0u; + for args.each {|a| if a.ident == i { ret j; } j += 1u; } + self.fatal("unbound variable `" + i + "` in constraint arg"); + } + + fn parse_type_constr_arg() -> @ty_constr_arg { + let sp = self.span; + let mut carg = carg_base; + self.expect(token::BINOP(token::STAR)); + if self.token == token::DOT { + // "*..." notation for record fields + self.bump(); + let pth = self.parse_path_without_tps(); + carg = carg_ident(pth); + } + // No literals yet, I guess? + ret @{node: carg, span: sp}; + } + + fn parse_constr_arg(args: [arg]) -> @constr_arg { + let sp = self.span; + let mut carg = carg_base; + if self.token == token::BINOP(token::STAR) { + self.bump(); + } else { + let i: ident = self.parse_value_ident(); + carg = carg_ident(self.ident_index(args, i)); + } + ret @{node: carg, span: sp}; + } + + fn parse_ty_constr(fn_args: [arg]) -> @constr { + let lo = self.span.lo; + let path = self.parse_path_without_tps(); + let args: {node: [@constr_arg], span: span} = + self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_constr_arg(fn_args)}); + ret @spanned(lo, args.span.hi, + {path: path, args: args.node, id: self.get_id()}); + } + + fn parse_constr_in_type() -> @ty_constr { + let lo = self.span.lo; + let path = self.parse_path_without_tps(); + let args: [@ty_constr_arg] = + self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_type_constr_arg()}).node; + let hi = self.span.lo; + let tc: ty_constr_ = {path: path, args: args, id: self.get_id()}; + ret @spanned(lo, hi, tc); + } + + + fn parse_constrs<T: copy>(pser: fn(parser) -> @constr_general<T>) -> + [@constr_general<T>] { + let mut constrs: [@constr_general<T>] = []; + loop { + let constr = pser(self); + constrs += [constr]; + if self.token == token::COMMA { self.bump(); } + else { ret constrs; } + }; + } + + fn parse_type_constraints() -> [@ty_constr] { + ret self.parse_constrs({|p| p.parse_constr_in_type()}); + } + + fn parse_ret_ty() -> (ret_style, @ty) { + ret if self.eat(token::RARROW) { + let lo = self.span.lo; + if self.eat(token::NOT) { + (noreturn, @{id: self.get_id(), + node: ty_bot, + span: mk_sp(lo, self.last_span.hi)}) + } else { + (return_val, self.parse_ty(false)) + } + } else { + let pos = self.span.lo; + (return_val, @{id: self.get_id(), + node: ty_nil, + span: mk_sp(pos, pos)}) + } + } + + fn region_from_name(s: option<str>) -> @region { + let r = alt s { + some (string) { re_named(string) } + none { re_anon } + }; + + @{id: self.get_id(), node: r} + } + + // Parses something like "&x" + fn parse_region() -> @region { + self.expect(token::BINOP(token::AND)); + alt self.token { + token::IDENT(sid, _) { + self.bump(); + let n = self.get_str(sid); + self.region_from_name(some(n)) + } + _ { + self.region_from_name(none) + } + } + } + + // Parses something like "&x." (note the trailing dot) + fn parse_region_dot() -> @region { + let name = + alt self.token { + token::IDENT(sid, _) if self.look_ahead(1u) == token::DOT { + self.bump(); self.bump(); + some(self.get_str(sid)) + } + _ { none } + }; + self.region_from_name(name) + } + + fn parse_ty(colons_before_params: bool) -> @ty { + let lo = self.span.lo; + + alt self.maybe_parse_dollar_mac() { + some(e) { + ret @{id: self.get_id(), + node: ty_mac(spanned(lo, self.span.hi, e)), + span: mk_sp(lo, self.span.hi)}; + } + none {} + } + + let t = if self.token == token::LPAREN { + self.bump(); + if self.token == token::RPAREN { + self.bump(); + ty_nil + } else { + let mut ts = [self.parse_ty(false)]; + while self.token == token::COMMA { + self.bump(); + ts += [self.parse_ty(false)]; + } + let t = if vec::len(ts) == 1u { ts[0].node } + else { ty_tup(ts) }; + self.expect(token::RPAREN); + t + } + } else if self.token == token::AT { + self.bump(); + ty_box(self.parse_mt()) + } else if self.token == token::TILDE { + self.bump(); + ty_uniq(self.parse_mt()) + } else if self.token == token::BINOP(token::STAR) { + self.bump(); + ty_ptr(self.parse_mt()) + } else if self.token == token::LBRACE { + let elems = self.parse_seq(token::LBRACE, token::RBRACE, + seq_sep_opt(token::COMMA), + {|p| p.parse_ty_field()}); + if vec::len(elems.node) == 0u { + self.unexpected_last(token::RBRACE); + } + let hi = elems.span.hi; + + let t = ty_rec(elems.node); + if self.token == token::COLON { + self.bump(); + ty_constr(@{id: self.get_id(), + node: t, + span: mk_sp(lo, hi)}, + self.parse_type_constraints()) + } else { t } + } else if self.token == token::LBRACKET { + self.expect(token::LBRACKET); + let t = ty_vec(self.parse_mt()); + self.expect(token::RBRACKET); + t + } else if self.token == token::BINOP(token::AND) { + self.bump(); + let region = self.parse_region_dot(); + let mt = self.parse_mt(); + ty_rptr(region, mt) + } else if self.eat_keyword("pure") { + self.parse_ty_fn(ast::pure_fn) + } else if self.eat_keyword("unsafe") { + self.parse_ty_fn(ast::unsafe_fn) + } else if self.is_keyword("fn") { + self.parse_ty_fn(ast::impure_fn) + } else if self.eat_keyword("native") { + self.expect_keyword("fn"); + ty_fn(proto_bare, self.parse_ty_fn_decl(ast::impure_fn)) + } else if self.token == token::MOD_SEP || is_ident(self.token) { + let path = self.parse_path_with_tps(colons_before_params); + ty_path(path, self.get_id()) + } else { self.fatal("expecting type"); }; + + let sp = mk_sp(lo, self.last_span.hi); + ret @{id: self.get_id(), + node: alt self.maybe_parse_vstore() { + // Consider a vstore suffix like /@ or /~ + none { t } + some(v) { + ty_vstore(@{id: self.get_id(), node:t, span: sp}, v) + } }, + span: sp} + } + + fn parse_arg_mode() -> mode { + if self.eat(token::BINOP(token::AND)) { + expl(by_mutbl_ref) + } else if self.eat(token::BINOP(token::MINUS)) { + expl(by_move) + } else if self.eat(token::ANDAND) { + expl(by_ref) + } else if self.eat(token::BINOP(token::PLUS)) { + if self.eat(token::BINOP(token::PLUS)) { + expl(by_val) + } else { + expl(by_copy) + } + } else { infer(self.get_id()) } + } + + fn parse_capture_item_or(parse_arg_fn: fn(parser) -> arg_or_capture_item) + -> arg_or_capture_item { + + fn parse_capture_item(p:parser, is_move: bool) -> capture_item { + let sp = mk_sp(p.span.lo, p.span.hi); + let ident = p.parse_ident(); + @{id: p.get_id(), is_move: is_move, name: ident, span: sp} + } + + if self.eat_keyword("move") { + either::right(parse_capture_item(self, true)) + } else if self.eat_keyword("copy") { + either::right(parse_capture_item(self, false)) + } else { + parse_arg_fn(self) + } + } + + fn parse_arg() -> arg_or_capture_item { + let m = self.parse_arg_mode(); + let i = self.parse_value_ident(); + self.expect(token::COLON); + let t = self.parse_ty(false); + either::left({mode: m, ty: t, ident: i, id: self.get_id()}) + } + + fn parse_arg_or_capture_item() -> arg_or_capture_item { + self.parse_capture_item_or() {|p| p.parse_arg() } + } + + fn parse_fn_block_arg() -> arg_or_capture_item { + self.parse_capture_item_or() {|p| + let m = p.parse_arg_mode(); + let i = p.parse_value_ident(); + let t = if p.eat(token::COLON) { + p.parse_ty(false) + } else { + @{id: p.get_id(), + node: ty_infer, + span: mk_sp(p.span.lo, p.span.hi)} + }; + either::left({mode: m, ty: t, ident: i, id: p.get_id()}) + } + } + + fn maybe_parse_dollar_mac() -> option<mac_> { + alt self.token { + token::DOLLAR { + let lo = self.span.lo; + self.bump(); + alt self.token { + token::LIT_INT(num, ty_i) { + self.bump(); + some(mac_var(num as uint)) + } + token::LPAREN { + self.bump(); + let e = self.parse_expr(); + self.expect(token::RPAREN); + let hi = self.last_span.hi; + some(mac_aq(mk_sp(lo,hi), e)) + } + _ { + self.fatal("expected `(` or integer literal"); + } + } + } + _ {none} + } + } + + fn maybe_parse_vstore() -> option<vstore> { + if self.token == token::BINOP(token::SLASH) { + self.bump(); + alt self.token { + token::AT { + self.bump(); some(vstore_box) + } + token::TILDE { + self.bump(); some(vstore_uniq) + } + token::UNDERSCORE { + self.bump(); some(vstore_fixed(none)) + } + token::LIT_INT(i, ty_i) if i >= 0i64 { + self.bump(); some(vstore_fixed(some(i as uint))) + } + token::BINOP(token::AND) { + some(vstore_slice(self.parse_region())) + } + _ { + none + } + } + } else { + none + } + } + + fn lit_from_token(tok: token::token) -> lit_ { + alt tok { + token::LIT_INT(i, it) { lit_int(i, it) } + token::LIT_UINT(u, ut) { lit_uint(u, ut) } + token::LIT_FLOAT(s, ft) { lit_float(self.get_str(s), ft) } + token::LIT_STR(s) { lit_str(self.get_str(s)) } + token::LPAREN { self.expect(token::RPAREN); lit_nil } + _ { self.unexpected_last(tok); } + } + } + + fn parse_lit() -> lit { + let lo = self.span.lo; + let lit = if self.eat_keyword("true") { + lit_bool(true) + } else if self.eat_keyword("false") { + lit_bool(false) + } else { + let tok = self.token; + self.bump(); + self.lit_from_token(tok) + }; + ret {node: lit, span: mk_sp(lo, self.last_span.hi)}; + } + + fn parse_path_without_tps() -> @path { + self.parse_path_without_tps_({|p| p.parse_ident()}, + {|p| p.parse_ident()}) + } + + fn parse_path_without_tps_( + parse_ident: fn(parser) -> ident, + parse_last_ident: fn(parser) -> ident) -> @path { + + let lo = self.span.lo; + let global = self.eat(token::MOD_SEP); + let mut ids = []; + loop { + let is_not_last = + self.look_ahead(2u) != token::LT + && self.look_ahead(1u) == token::MOD_SEP; + + if is_not_last { + ids += [parse_ident(self)]; + self.expect(token::MOD_SEP); + } else { + ids += [parse_last_ident(self)]; + break; + } + } + @{span: mk_sp(lo, self.last_span.hi), global: global, + idents: ids, rp: none, types: []} + } + + fn parse_value_path() -> @path { + self.parse_path_without_tps_({|p| p.parse_ident()}, + {|p| p.parse_value_ident()}) + } + + fn parse_path_with_tps(colons: bool) -> @path { + #debug["parse_path_with_tps(colons=%b)", colons]; + + let lo = self.span.lo; + let path = self.parse_path_without_tps(); + if colons && !self.eat(token::MOD_SEP) { + ret path; + } + + // Parse the region parameter, if any, which will + // be written "foo/&x" + let rp = { + // Hack: avoid parsing vstores like /@ and /~. This is painful + // because the notation for region bounds and the notation for + // vstores is... um... the same. I guess that's my fault. This + // is still not ideal as for str/& we end up parsing more than we + // ought to and have to sort it out later. + if self.token == token::BINOP(token::SLASH) + && self.look_ahead(1u) == token::BINOP(token::AND) { + + self.expect(token::BINOP(token::SLASH)); + some(self.parse_region()) + } else { + none + } + }; + + // Parse any type parameters which may appear: + let tps = { + if self.token == token::LT { + self.parse_seq_lt_gt(some(token::COMMA), + {|p| p.parse_ty(false)}) + } else { + {node: [], span: path.span} + } + }; + + ret @{span: mk_sp(lo, tps.span.hi), + rp: rp, + types: tps.node with *path}; + } + + fn parse_mutability() -> mutability { + if self.eat_keyword("mut") { + m_mutbl + } else if self.eat_keyword("mut") { + m_mutbl + } else if self.eat_keyword("const") { + m_const + } else { + m_imm + } + } + + fn parse_field(sep: token::token) -> field { + let lo = self.span.lo; + let m = self.parse_mutability(); + let i = self.parse_ident(); + self.expect(sep); + let e = self.parse_expr(); + ret spanned(lo, e.span.hi, {mutbl: m, ident: i, expr: e}); + } + + fn mk_expr(lo: uint, hi: uint, +node: expr_) -> @expr { + ret @{id: self.get_id(), node: node, span: mk_sp(lo, hi)}; + } + + fn mk_mac_expr(lo: uint, hi: uint, m: mac_) -> @expr { + ret @{id: self.get_id(), + node: expr_mac({node: m, span: mk_sp(lo, hi)}), + span: mk_sp(lo, hi)}; + } + + fn mk_lit_u32(i: u32) -> @expr { + let span = self.span; + let lv_lit = @{node: lit_uint(i as u64, ty_u32), + span: span}; + + ret @{id: self.get_id(), node: expr_lit(lv_lit), span: span}; + } + + fn mk_pexpr(lo: uint, hi: uint, node: expr_) -> pexpr { + ret pexpr(self.mk_expr(lo, hi, node)); + } + + fn to_expr(e: pexpr) -> @expr { + alt e.node { + expr_tup(es) if vec::len(es) == 1u { es[0u] } + _ { *e } + } + } + + fn parse_bottom_expr() -> pexpr { + let lo = self.span.lo; + let mut hi = self.span.hi; + + let mut ex: expr_; + + alt self.maybe_parse_dollar_mac() { + some(x) {ret pexpr(self.mk_mac_expr(lo, self.span.hi, x));} + _ {} + } + + if self.token == token::LPAREN { + self.bump(); + if self.token == token::RPAREN { + hi = self.span.hi; + self.bump(); + let lit = @spanned(lo, hi, lit_nil); + ret self.mk_pexpr(lo, hi, expr_lit(lit)); + } + let mut es = [self.parse_expr()]; + while self.token == token::COMMA { + self.bump(); es += [self.parse_expr()]; + } + hi = self.span.hi; + self.expect(token::RPAREN); + + // Note: we retain the expr_tup() even for simple + // parenthesized expressions, but only for a "little while". + // This is so that wrappers around parse_bottom_expr() + // can tell whether the expression was parenthesized or not, + // which affects expr_is_complete(). + ret self.mk_pexpr(lo, hi, expr_tup(es)); + } else if self.token == token::LBRACE { + self.bump(); + if self.is_keyword("mut") || + is_plain_ident(self.token) + && self.look_ahead(1u) == token::COLON { + let mut fields = [self.parse_field(token::COLON)]; + let mut base = none; + while self.token != token::RBRACE { + if self.eat_keyword("with") { + base = some(self.parse_expr()); break; + } + self.expect(token::COMMA); + if self.token == token::RBRACE { + // record ends by an optional trailing comma + break; + } + fields += [self.parse_field(token::COLON)]; + } + hi = self.span.hi; + self.expect(token::RBRACE); + ex = expr_rec(fields, base); + } else if token::is_bar(self.token) { + ret pexpr(self.parse_fn_block_expr()); + } else { + let blk = self.parse_block_tail(lo, default_blk); + ret self.mk_pexpr(blk.span.lo, blk.span.hi, expr_block(blk)); + } + } else if self.eat_keyword("new") { + self.expect(token::LPAREN); + let r = self.parse_expr(); + self.expect(token::RPAREN); + let v = self.parse_expr(); + ret self.mk_pexpr(lo, self.span.hi, + expr_new(r, self.get_id(), v)); + } else if self.eat_keyword("if") { + ret pexpr(self.parse_if_expr()); + } else if self.eat_keyword("for") { + ret pexpr(self.parse_for_expr()); + } else if self.eat_keyword("while") { + ret pexpr(self.parse_while_expr()); + } else if self.eat_keyword("loop") { + ret pexpr(self.parse_loop_expr()); + } else if self.eat_keyword("alt") { + ret pexpr(self.parse_alt_expr()); + } else if self.eat_keyword("fn") { + let proto = self.parse_fn_ty_proto(); + alt proto { + proto_bare { self.fatal("fn expr are deprecated, use fn@"); } + proto_any { self.fatal("fn* cannot be used in an expression"); } + _ { /* fallthrough */ } + } + ret pexpr(self.parse_fn_expr(proto)); + } else if self.eat_keyword("unchecked") { + ret pexpr(self.parse_block_expr(lo, unchecked_blk)); + } else if self.eat_keyword("unsafe") { + ret pexpr(self.parse_block_expr(lo, unsafe_blk)); + } else if self.token == token::LBRACKET { + self.bump(); + let mutbl = self.parse_mutability(); + let es = + self.parse_seq_to_end(token::RBRACKET, seq_sep(token::COMMA), + {|p| p.parse_expr()}); + hi = self.span.hi; + ex = expr_vec(es, mutbl); + } else if self.token == token::POUND + && self.look_ahead(1u) == token::LT { + self.bump(); + self.bump(); + let ty = self.parse_ty(false); + self.expect(token::GT); + + /* hack: early return to take advantage of specialized function */ + ret pexpr(self.mk_mac_expr(lo, self.span.hi, + mac_embed_type(ty))); + } else if self.token == token::POUND + && self.look_ahead(1u) == token::LBRACE { + self.bump(); + self.bump(); + let blk = mac_embed_block( + self.parse_block_tail(lo, default_blk)); + ret pexpr(self.mk_mac_expr(lo, self.span.hi, blk)); + } else if self.token == token::ELLIPSIS { + self.bump(); + ret pexpr(self.mk_mac_expr(lo, self.span.hi, mac_ellipsis)); + } else if self.token == token::POUND { + let ex_ext = self.parse_syntax_ext(); + hi = ex_ext.span.hi; + ex = ex_ext.node; + } else if self.eat_keyword("bind") { + let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS); + let es = self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_expr_or_hole()}); + hi = es.span.hi; + ex = expr_bind(e, es.node); + } else if self.eat_keyword("fail") { + if can_begin_expr(self.token) { + let e = self.parse_expr(); + hi = e.span.hi; + ex = expr_fail(some(e)); + } else { ex = expr_fail(none); } + } else if self.eat_keyword("log") { + self.expect(token::LPAREN); + let lvl = self.parse_expr(); + self.expect(token::COMMA); + let e = self.parse_expr(); + ex = expr_log(2, lvl, e); + hi = self.span.hi; + self.expect(token::RPAREN); + } else if self.eat_keyword("assert") { + let e = self.parse_expr(); + ex = expr_assert(e); + hi = e.span.hi; + } else if self.eat_keyword("check") { + /* Should be a predicate (pure boolean function) applied to + arguments that are all either slot variables or literals. + but the typechecker enforces that. */ + let e = self.parse_expr(); + hi = e.span.hi; + ex = expr_check(checked_expr, e); + } else if self.eat_keyword("claim") { + /* Same rules as check, except that if check-claims + is enabled (a command-line flag), then the parser turns + claims into check */ + + let e = self.parse_expr(); + hi = e.span.hi; + ex = expr_check(claimed_expr, e); + } else if self.eat_keyword("ret") { + if can_begin_expr(self.token) { + let e = self.parse_expr(); + hi = e.span.hi; + ex = expr_ret(some(e)); + } else { ex = expr_ret(none); } + } else if self.eat_keyword("break") { + ex = expr_break; + hi = self.span.hi; + } else if self.eat_keyword("cont") { + ex = expr_cont; + hi = self.span.hi; + } else if self.eat_keyword("copy") { + let e = self.parse_expr(); + ex = expr_copy(e); + hi = e.span.hi; + } else if self.token == token::MOD_SEP || + is_ident(self.token) && !self.is_keyword("true") && + !self.is_keyword("false") { + let pth = self.parse_path_with_tps(true); + hi = pth.span.hi; + ex = expr_path(pth); + } else { + let lit = self.parse_lit(); + hi = lit.span.hi; + ex = expr_lit(@lit); + } + + // Vstore is legal following expr_lit(lit_str(...)) and expr_vec(...) + // only. + alt ex { + expr_lit(@{node: lit_str(_), span: _}) | + expr_vec(_, _) { + alt self.maybe_parse_vstore() { + none { } + some(v) { + hi = self.span.hi; + ex = expr_vstore(self.mk_expr(lo, hi, ex), v); + } + } + } + _ { } + } + + ret self.mk_pexpr(lo, hi, ex); + } + + fn parse_block_expr(lo: uint, blk_mode: blk_check_mode) -> @expr { + self.expect(token::LBRACE); + let blk = self.parse_block_tail(lo, blk_mode); + ret self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); + } + + fn parse_syntax_ext() -> @expr { + let lo = self.span.lo; + self.expect(token::POUND); + ret self.parse_syntax_ext_naked(lo); + } + + fn parse_syntax_ext_naked(lo: uint) -> @expr { + alt self.token { + token::IDENT(_, _) {} + _ { self.fatal("expected a syntax expander name"); } + } + let pth = self.parse_path_without_tps(); + //temporary for a backwards-compatible cycle: + let sep = seq_sep(token::COMMA); + let mut e = none; + if (self.token == token::LPAREN || self.token == token::LBRACKET) { + let es = + if self.token == token::LPAREN { + self.parse_seq(token::LPAREN, token::RPAREN, + sep, {|p| p.parse_expr()}) + } else { + self.parse_seq(token::LBRACKET, token::RBRACKET, + sep, {|p| p.parse_expr()}) + }; + let hi = es.span.hi; + e = some(self.mk_expr(es.span.lo, hi, + expr_vec(es.node, m_imm))); + } + let mut b = none; + if self.token == token::LBRACE { + self.bump(); + let lo = self.span.lo; + let mut depth = 1u; + while (depth > 0u) { + alt (self.token) { + token::LBRACE {depth += 1u;} + token::RBRACE {depth -= 1u;} + token::EOF {self.fatal("unexpected EOF in macro body");} + _ {} + } + self.bump(); + } + let hi = self.last_span.lo; + b = some({span: mk_sp(lo,hi)}); + } + ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b)); +} + + fn parse_dot_or_call_expr() -> pexpr { + let b = self.parse_bottom_expr(); + self.parse_dot_or_call_expr_with(b) + } + + fn permits_call() -> bool { + ret self.restriction != RESTRICT_NO_CALL_EXPRS; + } + + fn parse_dot_or_call_expr_with(e0: pexpr) -> pexpr { + let mut e = e0; + let lo = e.span.lo; + let mut hi; + loop { + // expr.f + if self.eat(token::DOT) { + alt self.token { + token::IDENT(i, _) { + hi = self.span.hi; + self.bump(); + let tys = if self.eat(token::MOD_SEP) { + self.expect(token::LT); + self.parse_seq_to_gt(some(token::COMMA), + {|p| p.parse_ty(false)}) + } else { [] }; + e = self.mk_pexpr(lo, hi, expr_field(self.to_expr(e), + self.get_str(i), + tys)); + } + _ { self.unexpected(); } + } + cont; + } + if self.expr_is_complete(e) { break; } + alt self.token { + // expr(...) + token::LPAREN if self.permits_call() { + let es_opt = self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_expr_or_hole()}); + hi = es_opt.span.hi; + + let nd = + if vec::any(es_opt.node, {|e| option::is_none(e) }) { + expr_bind(self.to_expr(e), es_opt.node) + } else { + let es = vec::map(es_opt.node) {|e| option::get(e) }; + expr_call(self.to_expr(e), es, false) + }; + e = self.mk_pexpr(lo, hi, nd); + } + + // expr {|| ... } + token::LBRACE if (token::is_bar(self.look_ahead(1u)) + && self.permits_call()) { + self.bump(); + let blk = self.parse_fn_block_expr(); + alt e.node { + expr_call(f, args, false) { + e = pexpr(@{node: expr_call(f, args + [blk], true) + with *self.to_expr(e)}); + } + _ { + e = self.mk_pexpr(lo, self.last_span.hi, + expr_call(self.to_expr(e), [blk], true)); + } + } + } + + // expr[...] + token::LBRACKET { + self.bump(); + let ix = self.parse_expr(); + hi = ix.span.hi; + self.expect(token::RBRACKET); + self.get_id(); // see ast_util::op_expr_callee_id + e = self.mk_pexpr(lo, hi, expr_index(self.to_expr(e), ix)); + } + + _ { ret e; } + } + } + ret e; +} + + fn parse_prefix_expr() -> pexpr { + let lo = self.span.lo; + let mut hi; + + let mut ex; + alt self.token { + token::NOT { + self.bump(); + let e = self.to_expr(self.parse_prefix_expr()); + hi = e.span.hi; + self.get_id(); // see ast_util::op_expr_callee_id + ex = expr_unary(not, e); + } + token::BINOP(b) { + alt b { + token::MINUS { + self.bump(); + let e = self.to_expr(self.parse_prefix_expr()); + hi = e.span.hi; + self.get_id(); // see ast_util::op_expr_callee_id + ex = expr_unary(neg, e); + } + token::STAR { + self.bump(); + let e = self.to_expr(self.parse_prefix_expr()); + hi = e.span.hi; + ex = expr_unary(deref, e); + } + token::AND { + self.bump(); + let m = self.parse_mutability(); + let e = self.to_expr(self.parse_prefix_expr()); + hi = e.span.hi; + ex = expr_addr_of(m, e); + } + _ { ret self.parse_dot_or_call_expr(); } + } + } + token::AT { + self.bump(); + let m = self.parse_mutability(); + let e = self.to_expr(self.parse_prefix_expr()); + hi = e.span.hi; + ex = expr_unary(box(m), e); + } + token::TILDE { + self.bump(); + let m = self.parse_mutability(); + let e = self.to_expr(self.parse_prefix_expr()); + hi = e.span.hi; + ex = expr_unary(uniq(m), e); + } + _ { ret self.parse_dot_or_call_expr(); } + } + ret self.mk_pexpr(lo, hi, ex); + } + + + fn parse_binops() -> @expr { + ret self.parse_more_binops(self.parse_prefix_expr(), 0u); + } + + fn parse_more_binops(plhs: pexpr, min_prec: uint) -> + @expr { + let lhs = self.to_expr(plhs); + if self.expr_is_complete(plhs) { ret lhs; } + let peeked = self.token; + if peeked == token::BINOP(token::OR) && + self.restriction == RESTRICT_NO_BAR_OP { ret lhs; } + let cur_opt = token_to_binop(peeked); + alt cur_opt { + some(cur_op) { + let cur_prec = operator_prec(cur_op); + if cur_prec > min_prec { + self.bump(); + let expr = self.parse_prefix_expr(); + let rhs = self.parse_more_binops(expr, cur_prec); + self.get_id(); // see ast_util::op_expr_callee_id + let bin = self.mk_pexpr(lhs.span.lo, rhs.span.hi, + expr_binary(cur_op, lhs, rhs)); + ret self.parse_more_binops(bin, min_prec); + } + } + _ {} + } + if as_prec > min_prec && self.eat_keyword("as") { + let rhs = self.parse_ty(true); + let _as = + self.mk_pexpr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs)); + ret self.parse_more_binops(_as, min_prec); + } + ret lhs; + } + + fn parse_assign_expr() -> @expr { + let lo = self.span.lo; + let lhs = self.parse_binops(); + alt self.token { + token::EQ { + self.bump(); + let rhs = self.parse_expr(); + ret self.mk_expr(lo, rhs.span.hi, expr_assign(lhs, rhs)); + } + token::BINOPEQ(op) { + self.bump(); + let rhs = self.parse_expr(); + let mut aop; + alt op { + token::PLUS { aop = add; } + token::MINUS { aop = subtract; } + token::STAR { aop = mul; } + token::SLASH { aop = div; } + token::PERCENT { aop = rem; } + token::CARET { aop = bitxor; } + token::AND { aop = bitand; } + token::OR { aop = bitor; } + token::SHL { aop = shl; } + token::SHR { aop = shr; } + } + self.get_id(); // see ast_util::op_expr_callee_id + ret self.mk_expr(lo, rhs.span.hi, expr_assign_op(aop, lhs, rhs)); + } + token::LARROW { + self.bump(); + let rhs = self.parse_expr(); + ret self.mk_expr(lo, rhs.span.hi, expr_move(lhs, rhs)); + } + token::DARROW { + self.bump(); + let rhs = self.parse_expr(); + ret self.mk_expr(lo, rhs.span.hi, expr_swap(lhs, rhs)); + } + _ {/* fall through */ } + } + ret lhs; + } + + fn parse_if_expr_1() -> + {cond: @expr, + then: blk, + els: option<@expr>, + lo: uint, + hi: uint} { + let lo = self.last_span.lo; + let cond = self.parse_expr(); + let thn = self.parse_block(); + let mut els: option<@expr> = none; + let mut hi = thn.span.hi; + if self.eat_keyword("else") { + let elexpr = self.parse_else_expr(); + els = some(elexpr); + hi = elexpr.span.hi; + } + ret {cond: cond, then: thn, els: els, lo: lo, hi: hi}; + } + + fn parse_if_expr() -> @expr { + if self.eat_keyword("check") { + let q = self.parse_if_expr_1(); + ret self.mk_expr(q.lo, q.hi, + expr_if_check(q.cond, q.then, q.els)); + } else { + let q = self.parse_if_expr_1(); + ret self.mk_expr(q.lo, q.hi, expr_if(q.cond, q.then, q.els)); + } + } + + fn parse_fn_expr(proto: proto) -> @expr { + let lo = self.last_span.lo; + + let cc_old = self.parse_old_skool_capture_clause(); + + // if we want to allow fn expression argument types to be inferred in + // the future, just have to change parse_arg to parse_fn_block_arg. + let (decl, capture_clause) = + self.parse_fn_decl(impure_fn, + {|p| p.parse_arg_or_capture_item()}); + + let body = self.parse_block(); + ret self.mk_expr(lo, body.span.hi, + expr_fn(proto, decl, body, + @(*capture_clause + cc_old))); + } + + fn parse_fn_block_expr() -> @expr { + let lo = self.last_span.lo; + let (decl, captures) = self.parse_fn_block_decl(); + let body = self.parse_block_tail(lo, default_blk); + ret self.mk_expr(lo, body.span.hi, + expr_fn_block(decl, body, captures)); + } + + fn parse_else_expr() -> @expr { + if self.eat_keyword("if") { + ret self.parse_if_expr(); + } else { + let blk = self.parse_block(); + ret self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); + } + } + + fn parse_for_expr() -> @expr { + let lo = self.last_span; + let call = self.parse_expr_res(RESTRICT_STMT_EXPR); + alt call.node { + expr_call(f, args, true) { + let b_arg = vec::last(args); + let last = self.mk_expr(b_arg.span.lo, b_arg.span.hi, + expr_loop_body(b_arg)); + @{node: expr_call(f, vec::init(args) + [last], true) + with *call} + } + _ { + self.span_fatal(lo, "`for` must be followed by a block call"); + } + } + } + + fn parse_while_expr() -> @expr { + let lo = self.last_span.lo; + let cond = self.parse_expr(); + let body = self.parse_block_no_value(); + let mut hi = body.span.hi; + ret self.mk_expr(lo, hi, expr_while(cond, body)); + } + + fn parse_loop_expr() -> @expr { + let lo = self.last_span.lo; + let body = self.parse_block_no_value(); + let mut hi = body.span.hi; + ret self.mk_expr(lo, hi, expr_loop(body)); + } + + fn parse_alt_expr() -> @expr { + let lo = self.last_span.lo; + let mode = if self.eat_keyword("check") { alt_check } + else { alt_exhaustive }; + let discriminant = self.parse_expr(); + self.expect(token::LBRACE); + let mut arms: [arm] = []; + while self.token != token::RBRACE { + let pats = self.parse_pats(); + let mut guard = none; + if self.eat_keyword("if") { guard = some(self.parse_expr()); } + let blk = self.parse_block(); + arms += [{pats: pats, guard: guard, body: blk}]; + } + let mut hi = self.span.hi; + self.bump(); + ret self.mk_expr(lo, hi, expr_alt(discriminant, arms, mode)); + } + + fn parse_expr() -> @expr { + ret self.parse_expr_res(UNRESTRICTED); + } + + fn parse_expr_or_hole() -> option<@expr> { + alt self.token { + token::UNDERSCORE { self.bump(); ret none; } + _ { ret some(self.parse_expr()); } + } + } + + fn parse_expr_res(r: restriction) -> @expr { + let old = self.restriction; + self.restriction = r; + let e = self.parse_assign_expr(); + self.restriction = old; + ret e; + } + + fn parse_initializer() -> option<initializer> { + alt self.token { + token::EQ { + self.bump(); + ret some({op: init_assign, expr: self.parse_expr()}); + } + token::LARROW { + self.bump(); + ret some({op: init_move, expr: self.parse_expr()}); + } + // Now that the the channel is the first argument to receive, + // combining it with an initializer doesn't really make sense. + // case (token::RECV) { + // self.bump(); + // ret some(rec(op = init_recv, + // expr = self.parse_expr())); + // } + _ { + ret none; + } + } + } + + fn parse_pats() -> [@pat] { + let mut pats = []; + loop { + pats += [self.parse_pat()]; + if self.token == token::BINOP(token::OR) { self.bump(); } + else { ret pats; } + }; + } + + fn parse_pat() -> @pat { + let lo = self.span.lo; + let mut hi = self.span.hi; + let mut pat; + alt self.token { + token::UNDERSCORE { self.bump(); pat = pat_wild; } + token::AT { + self.bump(); + let sub = self.parse_pat(); + pat = pat_box(sub); + hi = sub.span.hi; + } + token::TILDE { + self.bump(); + let sub = self.parse_pat(); + pat = pat_uniq(sub); + hi = sub.span.hi; + } + token::LBRACE { + self.bump(); + let mut fields = []; + let mut etc = false; + let mut first = true; + while self.token != token::RBRACE { + if first { first = false; } + else { self.expect(token::COMMA); } + + if self.token == token::UNDERSCORE { + self.bump(); + if self.token != token::RBRACE { + self.fatal("expecting }, found " + + token_to_str(self.reader, self.token)); + } + etc = true; + break; + } + + let lo1 = self.last_span.lo; + let fieldname = if self.look_ahead(1u) == token::COLON { + self.parse_ident() + } else { + self.parse_value_ident() + }; + let hi1 = self.last_span.lo; + let fieldpath = ast_util::ident_to_path(mk_sp(lo1, hi1), + fieldname); + let mut subpat; + if self.token == token::COLON { + self.bump(); + subpat = self.parse_pat(); + } else { + subpat = @{id: self.get_id(), + node: pat_ident(fieldpath, none), + span: mk_sp(lo, hi)}; + } + fields += [{ident: fieldname, pat: subpat}]; + } + hi = self.span.hi; + self.bump(); + pat = pat_rec(fields, etc); + } + token::LPAREN { + self.bump(); + if self.token == token::RPAREN { + hi = self.span.hi; + self.bump(); + let lit = @{node: lit_nil, span: mk_sp(lo, hi)}; + let expr = self.mk_expr(lo, hi, expr_lit(lit)); + pat = pat_lit(expr); + } else { + let mut fields = [self.parse_pat()]; + while self.token == token::COMMA { + self.bump(); + fields += [self.parse_pat()]; + } + if vec::len(fields) == 1u { self.expect(token::COMMA); } + hi = self.span.hi; + self.expect(token::RPAREN); + pat = pat_tup(fields); + } + } + tok { + if !is_ident(tok) || self.is_keyword("true") + || self.is_keyword("false") { + let val = self.parse_expr_res(RESTRICT_NO_BAR_OP); + if self.eat_keyword("to") { + let end = self.parse_expr_res(RESTRICT_NO_BAR_OP); + hi = end.span.hi; + pat = pat_range(val, end); + } else { + hi = val.span.hi; + pat = pat_lit(val); + } + } else if is_plain_ident(self.token) && + alt self.look_ahead(1u) { + token::LPAREN | token::LBRACKET | token::LT { false } + _ { true } + } { + let name = self.parse_value_path(); + let sub = if self.eat(token::AT) { some(self.parse_pat()) } + else { none }; + pat = pat_ident(name, sub); + } else { + let enum_path = self.parse_path_with_tps(true); + hi = enum_path.span.hi; + let mut args: [@pat] = []; + let mut star_pat = false; + alt self.token { + token::LPAREN { + alt self.look_ahead(1u) { + token::BINOP(token::STAR) { + // This is a "top constructor only" pat + self.bump(); self.bump(); + star_pat = true; + self.expect(token::RPAREN); + } + _ { + let a = self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_pat()}); + args = a.node; + hi = a.span.hi; + } + } + } + _ { } + } + // at this point, we're not sure whether it's a enum or a bind + if star_pat { + pat = pat_enum(enum_path, none); + } + else if vec::is_empty(args) && + vec::len(enum_path.idents) == 1u { + pat = pat_ident(enum_path, none); + } + else { + pat = pat_enum(enum_path, some(args)); + } + } + } + } + ret @{id: self.get_id(), node: pat, span: mk_sp(lo, hi)}; + } + + fn parse_local(is_mutbl: bool, + allow_init: bool) -> @local { + let lo = self.span.lo; + let pat = self.parse_pat(); + let mut ty = @{id: self.get_id(), + node: ty_infer, + span: mk_sp(lo, lo)}; + if self.eat(token::COLON) { ty = self.parse_ty(false); } + let init = if allow_init { self.parse_initializer() } else { none }; + ret @spanned(lo, self.last_span.hi, + {is_mutbl: is_mutbl, ty: ty, pat: pat, + init: init, id: self.get_id()}); + } + + fn parse_let() -> @decl { + let is_mutbl = self.eat_keyword("mut"); + let lo = self.span.lo; + let mut locals = [self.parse_local(is_mutbl, true)]; + while self.eat(token::COMMA) { + locals += [self.parse_local(is_mutbl, true)]; + } + ret @spanned(lo, self.last_span.hi, decl_local(locals)); + } + + /* assumes "let" token has already been consumed */ + fn parse_instance_var(pr: visibility) -> @class_member { + let mut is_mutbl = class_immutable; + let lo = self.span.lo; + if self.eat_keyword("mut") { + is_mutbl = class_mutable; + } + if !is_plain_ident(self.token) { + self.fatal("expecting ident"); + } + let name = self.parse_ident(); + self.expect(token::COLON); + let ty = self.parse_ty(false); + ret @{node: instance_var(name, ty, is_mutbl, self.get_id(), pr), + span: mk_sp(lo, self.last_span.hi)}; + } + + fn parse_stmt(+first_item_attrs: [attribute]) -> @stmt { + fn check_expected_item(p: parser, current_attrs: [attribute]) { + // If we have attributes then we should have an item + if vec::is_not_empty(current_attrs) { + p.fatal("expected item"); + } + } + + let lo = self.span.lo; + if self.is_keyword("let") { + check_expected_item(self, first_item_attrs); + self.expect_keyword("let"); + let decl = self.parse_let(); + ret @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id())); + } else { + let mut item_attrs; + alt self.parse_outer_attrs_or_ext(first_item_attrs) { + none { item_attrs = []; } + some(left(attrs)) { item_attrs = attrs; } + some(right(ext)) { + ret @spanned(lo, ext.span.hi, stmt_expr(ext, self.get_id())); + } + } + + let item_attrs = first_item_attrs + item_attrs; + + alt self.parse_item(item_attrs, public) { + some(i) { + let mut hi = i.span.hi; + let decl = @spanned(lo, hi, decl_item(i)); + ret @spanned(lo, hi, stmt_decl(decl, self.get_id())); + } + none() { /* fallthrough */ } + } + + check_expected_item(self, item_attrs); + + // Remainder are line-expr stmts. + let e = self.parse_expr_res(RESTRICT_STMT_EXPR); + ret @spanned(lo, e.span.hi, stmt_expr(e, self.get_id())); + } + } + + fn expr_is_complete(e: pexpr) -> bool { + log(debug, ("expr_is_complete", self.restriction, + print::pprust::expr_to_str(*e), + classify::expr_requires_semi_to_be_stmt(*e))); + ret self.restriction == RESTRICT_STMT_EXPR && + !classify::expr_requires_semi_to_be_stmt(*e); + } + + fn parse_block() -> blk { + let (attrs, blk) = self.parse_inner_attrs_and_block(false); + assert vec::is_empty(attrs); + ret blk; + } + + fn parse_inner_attrs_and_block(parse_attrs: bool) -> ([attribute], blk) { + + fn maybe_parse_inner_attrs_and_next(p: parser, parse_attrs: bool) -> + {inner: [attribute], next: [attribute]} { + if parse_attrs { + p.parse_inner_attrs_and_next() + } else { + {inner: [], next: []} + } + } + + let lo = self.span.lo; + if self.eat_keyword("unchecked") { + self.expect(token::LBRACE); + let {inner, next} = maybe_parse_inner_attrs_and_next(self, + parse_attrs); + ret (inner, self.parse_block_tail_(lo, unchecked_blk, next)); + } else if self.eat_keyword("unsafe") { + self.expect(token::LBRACE); + let {inner, next} = maybe_parse_inner_attrs_and_next(self, + parse_attrs); + ret (inner, self.parse_block_tail_(lo, unsafe_blk, next)); + } else { + self.expect(token::LBRACE); + let {inner, next} = maybe_parse_inner_attrs_and_next(self, + parse_attrs); + ret (inner, self.parse_block_tail_(lo, default_blk, next)); + } + } + + fn parse_block_no_value() -> blk { + // We parse blocks that cannot have a value the same as any other + // block; the type checker will make sure that the tail expression (if + // any) has unit type. + ret self.parse_block(); + } + + // Precondition: already parsed the '{' or '#{' + // I guess that also means "already parsed the 'impure'" if + // necessary, and this should take a qualifier. + // some blocks start with "#{"... + fn parse_block_tail(lo: uint, s: blk_check_mode) -> blk { + self.parse_block_tail_(lo, s, []) + } + + fn parse_block_tail_(lo: uint, s: blk_check_mode, + +first_item_attrs: [attribute]) -> blk { + let mut stmts = []; + let mut expr = none; + let {attrs_remaining, view_items} = + self.parse_view(first_item_attrs, true); + let mut initial_attrs = attrs_remaining; + + if self.token == token::RBRACE && !vec::is_empty(initial_attrs) { + self.fatal("expected item"); + } + + while self.token != token::RBRACE { + alt self.token { + token::SEMI { + self.bump(); // empty + } + _ { + let stmt = self.parse_stmt(initial_attrs); + initial_attrs = []; + alt stmt.node { + stmt_expr(e, stmt_id) { // Expression without semicolon: + alt self.token { + token::SEMI { + self.bump(); + stmts += [@{node: stmt_semi(e, stmt_id) with *stmt}]; + } + token::RBRACE { + expr = some(e); + } + t { + if classify::stmt_ends_with_semi(*stmt) { + self.fatal("expected ';' or '}' after expression \ + but found '" + + token_to_str(self.reader, t) + "'"); + } + stmts += [stmt]; + } + } + } + + _ { // All other kinds of statements: + stmts += [stmt]; + + if classify::stmt_ends_with_semi(*stmt) { + self.expect(token::SEMI); + } + } + } + } + } + } + let mut hi = self.span.hi; + self.bump(); + let bloc = {view_items: view_items, stmts: stmts, expr: expr, + id: self.get_id(), rules: s}; + ret spanned(lo, hi, bloc); + } + + fn parse_ty_param() -> ty_param { + let mut bounds = []; + let ident = self.parse_ident(); + if self.eat(token::COLON) { + while self.token != token::COMMA && self.token != token::GT { + if self.eat_keyword("send") { bounds += [bound_send]; } + else if self.eat_keyword("copy") { bounds += [bound_copy]; } + else if self.eat_keyword("const") { bounds += [bound_const]; } + else { bounds += [bound_iface(self.parse_ty(false))]; } + } + } + ret {ident: ident, id: self.get_id(), bounds: @bounds}; + } + + fn parse_ty_params() -> [ty_param] { + if self.eat(token::LT) { + self.parse_seq_to_gt(some(token::COMMA), {|p| p.parse_ty_param()}) + } else { [] } + } + + // FIXME Remove after snapshot + fn parse_old_skool_capture_clause() -> [capture_item] { + fn expect_opt_trailing_semi(p: parser) { + if !p.eat(token::SEMI) { + if p.token != token::RBRACKET { + p.fatal("expecting ; or ]"); + } + } + } + + fn eat_ident_list(p: parser, is_move: bool) -> [capture_item] { + let mut res = []; + loop { + alt p.token { + token::IDENT(_, _) { + let id = p.get_id(); + let sp = mk_sp(p.span.lo, p.span.hi); + let ident = p.parse_ident(); + res += [@{id:id, is_move: is_move, name:ident, span:sp}]; + if !p.eat(token::COMMA) { + ret res; + } + } + + _ { ret res; } + } + }; + } + + let mut cap_items = []; + + if self.eat(token::LBRACKET) { + while !self.eat(token::RBRACKET) { + if self.eat_keyword("copy") { + cap_items += eat_ident_list(self, false); + expect_opt_trailing_semi(self); + } else if self.eat_keyword("move") { + cap_items += eat_ident_list(self, true); + expect_opt_trailing_semi(self); + } else { + let s: str = "expecting send, copy, or move clause"; + self.fatal(s); + } + } + } + + ret cap_items; + } + + fn parse_fn_decl(purity: purity, + parse_arg_fn: fn(parser) -> arg_or_capture_item) + -> (fn_decl, capture_clause) { + + let args_or_capture_items: [arg_or_capture_item] = + self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), parse_arg_fn).node; + + let inputs = either::lefts(args_or_capture_items); + let capture_clause = @either::rights(args_or_capture_items); + + // Use the args list to translate each bound variable + // mentioned in a constraint to an arg index. + // Seems weird to do this in the parser, but I'm not sure how else to. + let mut constrs = []; + if self.token == token::COLON { + self.bump(); + constrs = self.parse_constrs({|p| p.parse_ty_constr(inputs) }); + } + let (ret_style, ret_ty) = self.parse_ret_ty(); + ret ({inputs: inputs, + output: ret_ty, + purity: purity, + cf: ret_style, + constraints: constrs}, capture_clause); + } + + fn parse_fn_block_decl() -> (fn_decl, capture_clause) { + let inputs_captures = { + if self.eat(token::OROR) { + [] + } else { + self.parse_seq(token::BINOP(token::OR), + token::BINOP(token::OR), seq_sep(token::COMMA), + {|p| p.parse_fn_block_arg()}).node + } + }; + let output = if self.eat(token::RARROW) { + self.parse_ty(false) + } else { + @{id: self.get_id(), node: ty_infer, span: self.span} + }; + ret ({inputs: either::lefts(inputs_captures), + output: output, + purity: impure_fn, + cf: return_val, + constraints: []}, + @either::rights(inputs_captures)); + } + + fn parse_fn_header() -> {ident: ident, tps: [ty_param]} { + let id = self.parse_value_ident(); + let ty_params = self.parse_ty_params(); + ret {ident: id, tps: ty_params}; + } + + fn mk_item(lo: uint, hi: uint, +ident: ident, + +node: item_, vis: visibility, + +attrs: [attribute]) -> @item { + ret @{ident: ident, + attrs: attrs, + id: self.get_id(), + node: node, + vis: vis, + span: mk_sp(lo, hi)}; + } + + fn parse_item_fn(purity: purity) -> item_info { + let t = self.parse_fn_header(); + let (decl, _) = self.parse_fn_decl(purity, {|p| p.parse_arg()}); + let (inner_attrs, body) = self.parse_inner_attrs_and_block(true); + (t.ident, item_fn(decl, t.tps, body), some(inner_attrs)) + } + + fn parse_method_name() -> ident { + alt self.token { + token::BINOP(op) { self.bump(); token::binop_to_str(op) } + token::NOT { self.bump(); "!" } + token::LBRACKET { self.bump(); self.expect(token::RBRACKET); "[]" } + _ { + let id = self.parse_value_ident(); + if id == "unary" && self.eat(token::BINOP(token::MINUS)) { + "unary-" + } + else { id } + } + } + } + + fn parse_method(pr: visibility) -> @method { + let attrs = self.parse_outer_attributes(); + let lo = self.span.lo, pur = self.parse_fn_purity(); + let ident = self.parse_method_name(); + let tps = self.parse_ty_params(); + let (decl, _) = self.parse_fn_decl(pur, {|p| p.parse_arg()}); + let (inner_attrs, body) = self.parse_inner_attrs_and_block(true); + let attrs = attrs + inner_attrs; + @{ident: ident, attrs: attrs, tps: tps, decl: decl, body: body, + id: self.get_id(), span: mk_sp(lo, body.span.hi), + self_id: self.get_id(), vis: pr} + } + + fn parse_item_iface() -> item_info { + let ident = self.parse_ident(); + let rp = self.parse_region_param(); + let tps = self.parse_ty_params(); + let meths = self.parse_ty_methods(); + (ident, item_iface(tps, rp, meths), none) + } + + // Parses three variants (with the region/type params always optional): + // impl /&<T: copy> of to_str for [T] { ... } + // impl name/&<T> of to_str for [T] { ... } + // impl name/&<T> for [T] { ... } + fn parse_item_impl() -> item_info { + fn wrap_path(p: parser, pt: @path) -> @ty { + @{id: p.get_id(), node: ty_path(pt, p.get_id()), span: pt.span} + } + let mut (ident, rp, tps) = { + if self.token == token::LT { + (none, rp_none, self.parse_ty_params()) + } else if self.token == token::BINOP(token::SLASH) { + (none, self.parse_region_param(), self.parse_ty_params()) + } + else if self.is_keyword("of") { + (none, rp_none, []) + } else { + let id = self.parse_ident(); + let rp = self.parse_region_param(); + (some(id), rp, self.parse_ty_params()) + } + }; + let ifce = if self.eat_keyword("of") { + let path = self.parse_path_with_tps(false); + if option::is_none(ident) { + ident = some(vec::last(path.idents)); + } + some(@{path: path, id: self.get_id()}) + } else { none }; + let ident = alt ident { + some(name) { name } + none { self.expect_keyword("of"); fail; } + }; + self.expect_keyword("for"); + let ty = self.parse_ty(false); + let mut meths = []; + self.expect(token::LBRACE); + while !self.eat(token::RBRACE) { + meths += [self.parse_method(public)]; + } + (ident, item_impl(tps, rp, ifce, ty, meths), none) + } + + fn parse_item_res() -> item_info { + let ident = self.parse_value_ident(); + let rp = self.parse_region_param(); + let ty_params = self.parse_ty_params(); + self.expect(token::LPAREN); + let arg_ident = self.parse_value_ident(); + self.expect(token::COLON); + let t = self.parse_ty(false); + self.expect(token::RPAREN); + let dtor = self.parse_block_no_value(); + let decl = { + inputs: [{mode: expl(by_ref), ty: t, + ident: arg_ident, id: self.get_id()}], + output: @{id: self.get_id(), node: ty_nil, + span: ast_util::dummy_sp()}, + purity: impure_fn, + cf: return_val, + constraints: [] + }; + (ident, item_res(decl, ty_params, dtor, + self.get_id(), self.get_id(), rp), none) + } + + // Instantiates ident <i> with references to <typarams> as arguments. + // Used to create a path that refers to a class which will be defined as + // the return type of the ctor function. + fn ident_to_path_tys(i: ident, + rp: region_param, + typarams: [ty_param]) -> @path { + let s = self.last_span; + + // Hack. But then, this whole function is in service of a hack. + let a_r = alt rp { + rp_none { none } + rp_self { some(self.region_from_name(some("self"))) } + }; + + @{span: s, global: false, idents: [i], + rp: a_r, + types: vec::map(typarams, {|tp| + @{id: self.get_id(), + node: ty_path(ident_to_path(s, tp.ident), self.get_id()), + span: s}}) + } + } + + fn parse_iface_ref() -> @iface_ref { + @{path: self.parse_path_with_tps(false), + id: self.get_id()} + } + + fn parse_iface_ref_list() -> [@iface_ref] { + self.parse_seq_to_before_end(token::LBRACE, seq_sep(token::COMMA), + {|p| p.parse_iface_ref()}) + } + + fn parse_item_class() -> item_info { + let class_name = self.parse_value_ident(); + let rp = self.parse_region_param(); + let ty_params = self.parse_ty_params(); + let class_path = self.ident_to_path_tys(class_name, rp, ty_params); + let ifaces : [@iface_ref] = if self.eat_keyword("implements") + { self.parse_iface_ref_list() } + else { [] }; + self.expect(token::LBRACE); + let mut ms: [@class_member] = []; + let ctor_id = self.get_id(); + let mut the_ctor : option<(fn_decl, blk, codemap::span)> = none; + let mut the_dtor : option<(blk, codemap::span)> = none; + while self.token != token::RBRACE { + alt self.parse_class_item(class_path) { + ctor_decl(a_fn_decl, blk, s) { + the_ctor = some((a_fn_decl, blk, s)); + } + dtor_decl(blk, s) { + the_dtor = some((blk, s)); + } + members(mms) { ms += mms; } + } + } + let actual_dtor = option::map(the_dtor) {|dtor| + let (d_body, d_s) = dtor; + {node: {id: self.get_id(), + self_id: self.get_id(), + body: d_body}, + span: d_s}}; + self.bump(); + alt the_ctor { + some((ct_d, ct_b, ct_s)) { + (class_name, + item_class(ty_params, ifaces, ms, { + node: {id: ctor_id, + self_id: self.get_id(), + dec: ct_d, + body: ct_b}, + span: ct_s}, actual_dtor, rp), + none) + } + /* + Is it strange for the parser to check this? + */ + none { + self.fatal("class with no ctor"); + } + } + } + + fn parse_single_class_item(vis: visibility) + -> @class_member { + if self.eat_keyword("let") { + let a_var = self.parse_instance_var(vis); + self.expect(token::SEMI); + ret a_var; + } + else { + let m = self.parse_method(vis); + ret @{node: class_method(m), span: m.span}; + } + } + + fn parse_ctor(result_ty: ast::ty_) -> class_contents { + // Can ctors/dtors have attrs? FIXME + let lo = self.last_span.lo; + let (decl_, _) = self.parse_fn_decl(impure_fn, {|p| p.parse_arg()}); + let decl = {output: @{id: self.get_id(), + node: result_ty, span: decl_.output.span} + with decl_}; + let body = self.parse_block(); + ctor_decl(decl, body, mk_sp(lo, self.last_span.hi)) + } + + fn parse_dtor() -> class_contents { + // Can ctors/dtors have attrs? FIXME + let lo = self.last_span.lo; + let body = self.parse_block(); + dtor_decl(body, mk_sp(lo, self.last_span.hi)) + } + + fn parse_class_item(class_name_with_tps: @path) + -> class_contents { + if self.eat_keyword("new") { + // result type is always the type of the class + ret self.parse_ctor(ty_path(class_name_with_tps, + self.get_id())); + } + else if self.eat_keyword("drop") { + ret self.parse_dtor(); + } + else if self.eat_keyword("priv") { + self.expect(token::LBRACE); + let mut results = []; + while self.token != token::RBRACE { + results += [self.parse_single_class_item(private)]; + } + self.bump(); + ret members(results); + } + else { + // Probably need to parse attrs + ret members([self.parse_single_class_item(public)]); + } +} + + fn parse_visibility(def: visibility) -> visibility { + if self.eat_keyword("pub") { public } + else if self.eat_keyword("priv") { private } + else { def } + } + + fn parse_mod_items(term: token::token, + +first_item_attrs: [attribute]) -> _mod { + // Shouldn't be any view items since we've already parsed an item attr + let {attrs_remaining, view_items} = + self.parse_view(first_item_attrs, false); + let mut items: [@item] = []; + let mut first = true; + while self.token != term { + let mut attrs = self.parse_outer_attributes(); + if first { attrs = attrs_remaining + attrs; first = false; } + #debug["parse_mod_items: parse_item(attrs=%?)", attrs]; + let vis = self.parse_visibility(private); + alt self.parse_item(attrs, vis) { + some(i) { items += [i]; } + _ { + self.fatal("expected item but found '" + + token_to_str(self.reader, self.token) + "'"); + } + } + #debug["parse_mod_items: attrs=%?", attrs]; + } + + if first && attrs_remaining.len() > 0u { + // We parsed attributes for the first item but didn't find it + self.fatal("expected item"); + } + + ret {view_items: view_items, items: items}; + } + + fn parse_item_const() -> item_info { + let id = self.parse_value_ident(); + self.expect(token::COLON); + let ty = self.parse_ty(false); + self.expect(token::EQ); + let e = self.parse_expr(); + self.expect(token::SEMI); + (id, item_const(ty, e), none) + } + + fn parse_item_mod() -> item_info { + let id = self.parse_ident(); + self.expect(token::LBRACE); + let inner_attrs = self.parse_inner_attrs_and_next(); + let m = self.parse_mod_items(token::RBRACE, inner_attrs.next); + self.expect(token::RBRACE); + (id, item_mod(m), some(inner_attrs.inner)) + } + + fn parse_item_native_fn(+attrs: [attribute], + purity: purity) -> @native_item { + let lo = self.last_span.lo; + let t = self.parse_fn_header(); + let (decl, _) = self.parse_fn_decl(purity, {|p| p.parse_arg()}); + let mut hi = self.span.hi; + self.expect(token::SEMI); + ret @{ident: t.ident, + attrs: attrs, + node: native_item_fn(decl, t.tps), + id: self.get_id(), + span: mk_sp(lo, hi)}; + } + + fn parse_fn_purity() -> purity { + if self.eat_keyword("fn") { impure_fn } + else if self.eat_keyword("pure") { + self.expect_keyword("fn"); + pure_fn + } else if self.eat_keyword("unsafe") { + self.expect_keyword("fn"); + unsafe_fn + } + else { self.unexpected(); } + } + + fn parse_native_item(+attrs: [attribute]) -> + @native_item { + self.parse_item_native_fn(attrs, self.parse_fn_purity()) + } + + fn parse_native_mod_items(+first_item_attrs: [attribute]) -> + native_mod { + // Shouldn't be any view items since we've already parsed an item attr + let {attrs_remaining, view_items} = + self.parse_view(first_item_attrs, false); + let mut items: [@native_item] = []; + let mut initial_attrs = attrs_remaining; + while self.token != token::RBRACE { + let attrs = initial_attrs + self.parse_outer_attributes(); + initial_attrs = []; + items += [self.parse_native_item(attrs)]; + } + ret {view_items: view_items, + items: items}; + } + + fn parse_item_native_mod() -> item_info { + self.expect_keyword("mod"); + let id = self.parse_ident(); + self.expect(token::LBRACE); + let more_attrs = self.parse_inner_attrs_and_next(); + let m = self.parse_native_mod_items(more_attrs.next); + self.expect(token::RBRACE); + (id, item_native_mod(m), some(more_attrs.inner)) + } + + fn parse_type_decl() -> {lo: uint, ident: ident} { + let lo = self.last_span.lo; + let id = self.parse_ident(); + ret {lo: lo, ident: id}; + } + + fn parse_item_type() -> item_info { + let t = self.parse_type_decl(); + let rp = self.parse_region_param(); + let tps = self.parse_ty_params(); + self.expect(token::EQ); + let ty = self.parse_ty(false); + self.expect(token::SEMI); + (t.ident, item_ty(ty, tps, rp), none) + } + + fn parse_region_param() -> region_param { + if self.eat(token::BINOP(token::SLASH)) { + self.expect(token::BINOP(token::AND)); + rp_self + } else { + rp_none + } + } + + fn parse_item_enum(default_vis: visibility) -> item_info { + let id = self.parse_ident(); + let rp = self.parse_region_param(); + let ty_params = self.parse_ty_params(); + let mut variants: [variant] = []; + // Newtype syntax + if self.token == token::EQ { + self.check_restricted_keywords_(id); + self.bump(); + let ty = self.parse_ty(false); + self.expect(token::SEMI); + let variant = + spanned(ty.span.lo, ty.span.hi, + {name: id, + attrs: [], + args: [{ty: ty, id: self.get_id()}], + id: self.get_id(), + disr_expr: none, + vis: public}); + ret (id, item_enum([variant], ty_params, rp), none); + } + self.expect(token::LBRACE); + + let mut all_nullary = true, have_disr = false; + + while self.token != token::RBRACE { + let variant_attrs = self.parse_outer_attributes(); + let vlo = self.span.lo; + let vis = self.parse_visibility(default_vis); + let ident = self.parse_value_ident(); + let mut args = [], disr_expr = none; + if self.token == token::LPAREN { + all_nullary = false; + let arg_tys = self.parse_seq(token::LPAREN, token::RPAREN, + seq_sep(token::COMMA), + {|p| p.parse_ty(false)}); + for arg_tys.node.each {|ty| + args += [{ty: ty, id: self.get_id()}]; + } + } else if self.eat(token::EQ) { + have_disr = true; + disr_expr = some(self.parse_expr()); + } + + let vr = {name: ident, attrs: variant_attrs, + args: args, id: self.get_id(), + disr_expr: disr_expr, vis: vis}; + variants += [spanned(vlo, self.last_span.hi, vr)]; + + if !self.eat(token::COMMA) { break; } + } + self.expect(token::RBRACE); + if (have_disr && !all_nullary) { + self.fatal("discriminator values can only be used with a c-like \ + enum"); + } + (id, item_enum(variants, ty_params, rp), none) + } + + fn parse_fn_ty_proto() -> proto { + alt self.token { + token::AT { + self.bump(); + proto_box + } + token::TILDE { + self.bump(); + proto_uniq + } + token::BINOP(token::AND) { + self.bump(); + proto_block + } + _ { + proto_any + } + } + } + + fn fn_expr_lookahead(tok: token::token) -> bool { + alt tok { + token::LPAREN | token::AT | token::TILDE | token::BINOP(_) { + true + } + _ { + false + } + } + } + + fn parse_item(+attrs: [attribute], vis: visibility) + -> option<@item> { + let lo = self.span.lo; + let (ident, item_, extra_attrs) = if self.eat_keyword("const") { + self.parse_item_const() + } else if self.is_keyword("fn") && + !self.fn_expr_lookahead(self.look_ahead(1u)) { + self.bump(); + self.parse_item_fn(impure_fn) + } else if self.eat_keyword("pure") { + self.expect_keyword("fn"); + self.parse_item_fn(pure_fn) + } else if self.is_keyword("unsafe") + && self.look_ahead(1u) != token::LBRACE { + self.bump(); + self.expect_keyword("fn"); + self.parse_item_fn(unsafe_fn) + } else if self.eat_keyword("crust") { + self.expect_keyword("fn"); + self.parse_item_fn(crust_fn) + } else if self.eat_keyword("mod") { + self.parse_item_mod() + } else if self.eat_keyword("native") { + self.parse_item_native_mod() + } else if self.eat_keyword("type") { + self.parse_item_type() + } else if self.eat_keyword("enum") { + self.parse_item_enum(vis) + } else if self.eat_keyword("iface") { + self.parse_item_iface() + } else if self.eat_keyword("impl") { + self.parse_item_impl() + } else if self.eat_keyword("resource") { + self.parse_item_res() + } else if self.eat_keyword("class") { + self.parse_item_class() + } else { ret none; }; + some(self.mk_item(lo, self.last_span.hi, ident, item_, vis, + alt extra_attrs { + some(as) { attrs + as } + none { attrs } + })) + } + + fn parse_use() -> view_item_ { + let ident = self.parse_ident(); + let metadata = self.parse_optional_meta(); + ret view_item_use(ident, metadata, self.get_id()); + } + + fn parse_view_path() -> @view_path { + let lo = self.span.lo; + let first_ident = self.parse_ident(); + let mut path = [first_ident]; + #debug("parsed view_path: %s", first_ident); + alt self.token { + token::EQ { + // x = foo::bar + self.bump(); + path = [self.parse_ident()]; + while self.token == token::MOD_SEP { + self.bump(); + let id = self.parse_ident(); + path += [id]; + } + let path = @{span: mk_sp(lo, self.span.hi), global: false, + idents: path, rp: none, types: []}; + ret @spanned(lo, self.span.hi, + view_path_simple(first_ident, path, self.get_id())); + } + + token::MOD_SEP { + // foo::bar or foo::{a,b,c} or foo::* + while self.token == token::MOD_SEP { + self.bump(); + + alt self.token { + + token::IDENT(i, _) { + self.bump(); + path += [self.get_str(i)]; + } + + // foo::bar::{a,b,c} + token::LBRACE { + let idents = + self.parse_seq(token::LBRACE, token::RBRACE, + seq_sep(token::COMMA), + {|p| p.parse_path_list_ident()}).node; + let path = @{span: mk_sp(lo, self.span.hi), + global: false, idents: path, + rp: none, types: []}; + ret @spanned(lo, self.span.hi, + view_path_list(path, idents, self.get_id())); + } + + // foo::bar::* + token::BINOP(token::STAR) { + self.bump(); + let path = @{span: mk_sp(lo, self.span.hi), + global: false, idents: path, + rp: none, types: []}; + ret @spanned(lo, self.span.hi, + view_path_glob(path, self.get_id())); + } + + _ { break; } + } + } + } + _ { } + } + let last = path[vec::len(path) - 1u]; + let path = @{span: mk_sp(lo, self.span.hi), global: false, + idents: path, rp: none, types: []}; + ret @spanned(lo, self.span.hi, + view_path_simple(last, path, self.get_id())); + } + + fn parse_view_paths() -> [@view_path] { + let mut vp = [self.parse_view_path()]; + while self.token == token::COMMA { + self.bump(); + vp += [self.parse_view_path()]; + } + ret vp; + } + + fn is_view_item() -> bool { + let tok = if !self.is_keyword("pub") && !self.is_keyword("priv") { + self.token + } else { self.look_ahead(1u) }; + self.token_is_keyword("use", tok) + || self.token_is_keyword("import", tok) + || self.token_is_keyword("export", tok) + } + + fn parse_view_item(+attrs: [attribute]) -> @view_item { + let lo = self.span.lo, vis = self.parse_visibility(private); + let node = if self.eat_keyword("use") { + self.parse_use() + } else if self.eat_keyword("import") { + view_item_import(self.parse_view_paths()) + } else if self.eat_keyword("export") { + view_item_export(self.parse_view_paths()) + } else { fail; }; + self.expect(token::SEMI); + @{node: node, attrs: attrs, + vis: vis, span: mk_sp(lo, self.last_span.hi)} + } + + fn parse_view(+first_item_attrs: [attribute], + only_imports: bool) -> {attrs_remaining: [attribute], + view_items: [@view_item]} { + let mut attrs = first_item_attrs + self.parse_outer_attributes(); + let mut items = []; + while if only_imports { self.is_keyword("import") } + else { self.is_view_item() } { + items += [self.parse_view_item(attrs)]; + attrs = self.parse_outer_attributes(); + } + {attrs_remaining: attrs, view_items: items} + } + + // Parses a source module as a crate + fn parse_crate_mod(_cfg: crate_cfg) -> @crate { + let lo = self.span.lo; + let crate_attrs = self.parse_inner_attrs_and_next(); + let first_item_outer_attrs = crate_attrs.next; + let m = self.parse_mod_items(token::EOF, first_item_outer_attrs); + ret @spanned(lo, self.span.lo, + {directives: [], + module: m, + attrs: crate_attrs.inner, + config: self.cfg}); + } + + fn parse_str() -> str { + alt self.token { + token::LIT_STR(s) { self.bump(); self.get_str(s) } + _ { + self.fatal("expected string literal") + } + } + } + + // Logic for parsing crate files (.rc) + // + // Each crate file is a sequence of directives. + // + // Each directive imperatively extends its environment with 0 or more + // items. + fn parse_crate_directive(first_outer_attr: [attribute]) -> + crate_directive { + + // Collect the next attributes + let outer_attrs = first_outer_attr + self.parse_outer_attributes(); + // In a crate file outer attributes are only going to apply to mods + let expect_mod = vec::len(outer_attrs) > 0u; + + let lo = self.span.lo; + if expect_mod || self.is_keyword("mod") { + self.expect_keyword("mod"); + let id = self.parse_ident(); + alt self.token { + // mod x = "foo.rs"; + token::SEMI { + let mut hi = self.span.hi; + self.bump(); + ret spanned(lo, hi, cdir_src_mod(id, outer_attrs)); + } + // mod x = "foo_dir" { ...directives... } + token::LBRACE { + self.bump(); + let inner_attrs = self.parse_inner_attrs_and_next(); + let mod_attrs = outer_attrs + inner_attrs.inner; + let next_outer_attr = inner_attrs.next; + let cdirs = self.parse_crate_directives(token::RBRACE, + next_outer_attr); + let mut hi = self.span.hi; + self.expect(token::RBRACE); + ret spanned(lo, hi, + cdir_dir_mod(id, cdirs, mod_attrs)); + } + _ { self.unexpected(); } + } + } else if self.is_view_item() { + let vi = self.parse_view_item(outer_attrs); + ret spanned(lo, vi.span.hi, cdir_view_item(vi)); + } else { ret self.fatal("expected crate directive"); } + } + + fn parse_crate_directives(term: token::token, + first_outer_attr: [attribute]) -> + [@crate_directive] { + + // This is pretty ugly. If we have an outer attribute then we can't + // accept seeing the terminator next, so if we do see it then fail the + // same way parse_crate_directive would + if vec::len(first_outer_attr) > 0u && self.token == term { + self.expect_keyword("mod"); + } + + let mut cdirs: [@crate_directive] = []; + let mut first_outer_attr = first_outer_attr; + while self.token != term { + let cdir = @self.parse_crate_directive(first_outer_attr); + cdirs += [cdir]; + first_outer_attr = []; + } + ret cdirs; + } +} +// +// Local Variables: +// mode: rust +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// End: +// diff --git a/src/libsyntax/parse/prec.rs b/src/libsyntax/parse/prec.rs new file mode 100644 index 00000000000..e2e35447af3 --- /dev/null +++ b/src/libsyntax/parse/prec.rs @@ -0,0 +1,43 @@ +export as_prec; +export unop_prec; +export token_to_binop; + +import token::*; +import token::token; +import ast::*; + +#[doc = "Unary operators have higher precedence than binary"] +const unop_prec: uint = 100u; + +#[doc = " +Precedence of the `as` operator, which is a binary operator +but is not represented in the precedence table. +"] +const as_prec: uint = 11u; + +#[doc = "Maps a token to a record specifying the corresponding binary + operator and its precedence"] +fn token_to_binop(tok: token) -> option<ast::binop> { + alt tok { + BINOP(STAR) { some(mul) } + BINOP(SLASH) { some(div) } + BINOP(PERCENT) { some(rem) } + // 'as' sits between here with 11 + BINOP(PLUS) { some(add) } + BINOP(MINUS) { some(subtract) } + BINOP(SHL) { some(shl) } + BINOP(SHR) { some(shr) } + BINOP(AND) { some(bitand) } + BINOP(CARET) { some(bitxor) } + BINOP(OR) { some(bitor) } + LT { some(lt) } + LE { some(le) } + GE { some(ge) } + GT { some(gt) } + EQEQ { some(eq) } + NE { some(ne) } + ANDAND { some(and) } + OROR { some(or) } + _ { none } + } +} diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs new file mode 100644 index 00000000000..1c6f240cf82 --- /dev/null +++ b/src/libsyntax/parse/token.rs @@ -0,0 +1,286 @@ + +import util::interner; +import util::interner::interner; +import std::map::{hashmap, str_hash}; + +type str_num = uint; + +enum binop { + PLUS, + MINUS, + STAR, + SLASH, + PERCENT, + CARET, + AND, + OR, + SHL, + SHR, +} + +enum token { + /* Expression-operator symbols. */ + EQ, + LT, + LE, + EQEQ, + NE, + GE, + GT, + ANDAND, + OROR, + NOT, + TILDE, + BINOP(binop), + BINOPEQ(binop), + + /* Structural symbols */ + AT, + DOT, + ELLIPSIS, + COMMA, + SEMI, + COLON, + MOD_SEP, + RARROW, + LARROW, + DARROW, + LPAREN, + RPAREN, + LBRACKET, + RBRACKET, + LBRACE, + RBRACE, + POUND, + DOLLAR, + + /* Literals */ + LIT_INT(i64, ast::int_ty), + LIT_UINT(u64, ast::uint_ty), + LIT_FLOAT(str_num, ast::float_ty), + LIT_STR(str_num), + + /* Name components */ + IDENT(str_num, bool), + UNDERSCORE, + EOF, + +} + +fn binop_to_str(o: binop) -> str { + alt o { + PLUS { ret "+"; } + MINUS { ret "-"; } + STAR { ret "*"; } + SLASH { ret "/"; } + PERCENT { ret "%"; } + CARET { ret "^"; } + AND { ret "&"; } + OR { ret "|"; } + SHL { ret "<<"; } + SHR { ret ">>"; } + } +} + +fn to_str(in: interner<str>, t: token) -> str { + alt t { + EQ { ret "="; } + LT { ret "<"; } + LE { ret "<="; } + EQEQ { ret "=="; } + NE { ret "!="; } + GE { ret ">="; } + GT { ret ">"; } + NOT { ret "!"; } + TILDE { ret "~"; } + OROR { ret "||"; } + ANDAND { ret "&&"; } + BINOP(op) { ret binop_to_str(op); } + BINOPEQ(op) { ret binop_to_str(op) + "="; } + + /* Structural symbols */ + AT { + ret "@"; + } + DOT { ret "."; } + ELLIPSIS { ret "..."; } + COMMA { ret ","; } + SEMI { ret ";"; } + COLON { ret ":"; } + MOD_SEP { ret "::"; } + RARROW { ret "->"; } + LARROW { ret "<-"; } + DARROW { ret "<->"; } + LPAREN { ret "("; } + RPAREN { ret ")"; } + LBRACKET { ret "["; } + RBRACKET { ret "]"; } + LBRACE { ret "{"; } + RBRACE { ret "}"; } + POUND { ret "#"; } + DOLLAR { ret "$"; } + + /* Literals */ + LIT_INT(c, ast::ty_char) { + // FIXME: escape. + let mut tmp = "'"; + str::push_char(tmp, c as char); + str::push_char(tmp, '\''); + ret tmp; + } + LIT_INT(i, t) { + ret int::to_str(i as int, 10u) + ast_util::int_ty_to_str(t); + } + LIT_UINT(u, t) { + ret uint::to_str(u as uint, 10u) + ast_util::uint_ty_to_str(t); + } + LIT_FLOAT(s, t) { + ret interner::get::<str>(in, s) + + ast_util::float_ty_to_str(t); + } + LIT_STR(s) { // FIXME: escape. + ret "\"" + interner::get::<str>(in, s) + "\""; + } + + /* Name components */ + IDENT(s, _) { + ret interner::get::<str>(in, s); + } + UNDERSCORE { ret "_"; } + EOF { ret "<eof>"; } + } +} + + +pure fn can_begin_expr(t: token) -> bool { + alt t { + LPAREN { true } + LBRACE { true } + LBRACKET { true } + IDENT(_, _) { true } + UNDERSCORE { true } + TILDE { true } + LIT_INT(_, _) { true } + LIT_UINT(_, _) { true } + LIT_FLOAT(_, _) { true } + LIT_STR(_) { true } + POUND { true } + AT { true } + NOT { true } + BINOP(MINUS) { true } + BINOP(STAR) { true } + BINOP(AND) { true } + MOD_SEP { true } + _ { false } + } +} + +fn is_lit(t: token::token) -> bool { + ret alt t { + token::LIT_INT(_, _) { true } + token::LIT_UINT(_, _) { true } + token::LIT_FLOAT(_, _) { true } + token::LIT_STR(_) { true } + _ { false } + } +} + +fn is_ident(t: token::token) -> bool { + alt t { token::IDENT(_, _) { ret true; } _ { } } + ret false; +} + +fn is_plain_ident(t: token::token) -> bool { + ret alt t { token::IDENT(_, false) { true } _ { false } }; +} + +fn is_bar(t: token::token) -> bool { + alt t { token::BINOP(token::OR) | token::OROR { true } _ { false } } +} + +#[doc = " +All the valid words that have meaning in the Rust language. + +Rust keywords are either 'contextual' or 'restricted'. Contextual +keywords may be used as identifiers because their appearance in +the grammar is unambiguous. Restricted keywords may not appear +in positions that might otherwise contain _value identifiers_. +"] +fn keyword_table() -> hashmap<str, ()> { + let keywords = str_hash(); + for contextual_keyword_table().each_key {|word| + keywords.insert(word, ()); + } + for restricted_keyword_table().each_key {|word| + keywords.insert(word, ()); + } + ret keywords; +} + +#[doc = "Keywords that may be used as identifiers"] +fn contextual_keyword_table() -> hashmap<str, ()> { + let words = str_hash(); + let keys = [ + "as", + "bind", + "else", + "implements", + "move", + "of", + "priv", "pub", + "self", "send", "static", + "to", + "use", + "with" + ]; + for keys.each {|word| + words.insert(word, ()); + } + words +} + +#[doc = " +Keywords that may not appear in any position that might otherwise contain a +_value identifier_. Restricted keywords may still be used as other types of +identifiers. + +Reasons: + +* For some (most?), if used at the start of a line, they will cause the line + to be interpreted as a specific kind of statement, which would be confusing. + +* `true` or `false` as identifiers would always be shadowed by + the boolean constants +"] +fn restricted_keyword_table() -> hashmap<str, ()> { + let words = str_hash(); + let keys = [ + "alt", + "assert", + "be", "break", + "check", "claim", "class", "const", "cont", "copy", "crust", + "drop", + "else", "enum", "export", + "fail", "false", "fn", "for", + "if", "iface", "impl", "import", + "let", "log", "loop", + "mod", "mut", + "native", "new", + "pure", + "resource", "ret", + "true", "trait", "type", + "unchecked", "unsafe", + "while" + ]; + for keys.each {|word| + words.insert(word, ()); + } + words +} + +// Local Variables: +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// End: |