From d51973a6a66756c2f2cb7ab0649483ef41ba3050 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 17 Apr 2012 21:14:40 -0700 Subject: [PATCH] syntax: Move some functions from parser to token --- src/librustsyntax/parse/parser.rs | 61 ++++++++----------------------- src/librustsyntax/parse/token.rs | 44 ++++++++++++++++++++++ 2 files changed, 59 insertions(+), 46 deletions(-) diff --git a/src/librustsyntax/parse/parser.rs b/src/librustsyntax/parse/parser.rs index 858289faaea..a5eb2d6b8be 100644 --- a/src/librustsyntax/parse/parser.rs +++ b/src/librustsyntax/parse/parser.rs @@ -1,7 +1,7 @@ import result::result; import either::{either, left, right}; import std::map::{hashmap, str_hash}; -import token::can_begin_expr; +import token::{can_begin_expr, is_ident, is_plain_ident}; import codemap::{span,fss_none}; import util::interner; import ast::{node_id, spanned}; @@ -160,24 +160,7 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, mut restriction: UNRESTRICTED, reader: rdr, binop_precs: binop_prec_table(), - bad_expr_words: bad_expr_word_table()} -} - -// These are the words that shouldn't be allowed as value identifiers, -// because, 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. -fn bad_expr_word_table() -> hashmap { - let words = str_hash(); - let keys = ["alt", "assert", "be", "break", "check", "claim", - "class", "const", "cont", "copy", "crust", "do", "else", - "enum", "export", "fail", "fn", "for", "if", "iface", - "impl", "import", "let", "log", "loop", "mod", - "mut", "native", "pure", "resource", "ret", "trait", - "type", "unchecked", "unsafe", "while", "new"]; - for keys.each {|word| - words.insert(word, ()); - } - words + bad_expr_words: token::bad_expr_word_table()} } fn token_to_str(reader: reader, token: token::token) -> str { @@ -276,21 +259,19 @@ fn expect_word(p: parser, word: str) { } fn check_bad_word(p: parser) { - alt p.token { - token::IDENT(sid, false) { - let w = p.get_str(sid); - if p.bad_expr_words.contains_key(w) { - p.fatal("found " + w + " in expression position"); - } - } - _ { } + if token::is_bad_expr_word(p.token, p.bad_expr_words, + *p.reader.interner) { + let w = token_to_str(p.reader, p.token); + p.fatal("found " + w + " in expression position"); } } fn parse_ty_fn(p: parser) -> ast::fn_decl { fn parse_fn_input_ty(p: parser) -> ast::arg { let mode = parse_arg_mode(p); - let name = if is_plain_ident(p) && p.look_ahead(1u) == token::COLON { + let name = if is_plain_ident(p.token) + && p.look_ahead(1u) == token::COLON { + let name = parse_value_ident(p); p.bump(); name @@ -783,15 +764,6 @@ fn parse_lit(p: parser) -> ast::lit { ret {node: lit, span: ast_util::mk_sp(lo, p.last_span.hi)}; } -fn is_ident(t: token::token) -> bool { - alt t { token::IDENT(_, _) { ret true; } _ { } } - ret false; -} - -fn is_plain_ident(p: parser) -> bool { - ret alt p.token { token::IDENT(_, false) { true } _ { false } }; -} - fn parse_path(p: parser) -> @ast::path { let lo = p.span.lo; let global = eat(p, token::MOD_SEP); @@ -858,10 +830,6 @@ fn mk_mac_expr(p: parser, lo: uint, hi: uint, m: ast::mac_) -> @ast::expr { span: ast_util::mk_sp(lo, hi)}; } -fn is_bar(t: token::token) -> bool { - alt t { token::BINOP(token::OR) | token::OROR { true } _ { false } } -} - fn mk_lit_u32(p: parser, i: u32) -> @ast::expr { let span = p.span; let lv_lit = @{node: ast::lit_uint(i as u64, ast::ty_u32), @@ -925,7 +893,7 @@ fn parse_bottom_expr(p: parser) -> pexpr { } else if p.token == token::LBRACE { p.bump(); if is_word(p, "mut") || - is_plain_ident(p) && p.look_ahead(1u) == token::COLON { + is_plain_ident(p.token) && p.look_ahead(1u) == token::COLON { let mut fields = [parse_field(p, token::COLON)]; let mut base = none; while p.token != token::RBRACE { @@ -940,7 +908,7 @@ fn parse_bottom_expr(p: parser) -> pexpr { hi = p.span.hi; expect(p, token::RBRACE); ex = ast::expr_rec(fields, base); - } else if is_bar(p.token) { + } else if token::is_bar(p.token) { ret pexpr(parse_fn_block_expr(p)); } else { let blk = parse_block_tail(p, lo, ast::default_blk); @@ -1211,7 +1179,8 @@ fn parse_dot_or_call_expr_with(p: parser, e0: pexpr) -> pexpr { } // expr {|| ... } - token::LBRACE if is_bar(p.look_ahead(1u)) && permits_call(p) { + token::LBRACE if (token::is_bar(p.look_ahead(1u)) + && permits_call(p)) { p.bump(); let blk = parse_fn_block_expr(p); alt e.node { @@ -1683,7 +1652,7 @@ fn parse_pat(p: parser) -> @ast::pat { hi = val.span.hi; pat = ast::pat_lit(val); } - } else if is_plain_ident(p) && + } else if is_plain_ident(p.token) && alt p.look_ahead(1u) { token::LPAREN | token::LBRACKET | token::LT { false } _ { true } @@ -1751,7 +1720,7 @@ fn parse_instance_var(p:parser, pr: ast::privacy) -> @ast::class_member { if eat_word(p, "mut") || eat_word(p, "mutable") { is_mutbl = ast::class_mutable; } - if !is_plain_ident(p) { + if !is_plain_ident(p.token) { p.fatal("expecting ident"); } let name = parse_ident(p); diff --git a/src/librustsyntax/parse/token.rs b/src/librustsyntax/parse/token.rs index 1c0b4721e18..1b4e871270a 100644 --- a/src/librustsyntax/parse/token.rs +++ b/src/librustsyntax/parse/token.rs @@ -1,6 +1,7 @@ import util::interner; import util::interner::interner; +import std::map::{hashmap, str_hash}; type str_num = uint; @@ -192,6 +193,49 @@ pure fn can_begin_expr(t: token) -> bool { } } +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 } } +} + +fn is_bad_expr_word(t: token, + bad_expr_words: hashmap, + in: interner) -> bool { + alt t { + token::IDENT(_, false) { + bad_expr_words.contains_key(to_str(in, t)) + } + _ { false } + } +} + +#[doc = " +These are the words that shouldn't be allowed as value identifiers, +because, 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. +"] +fn bad_expr_word_table() -> hashmap { + let words = str_hash(); + let keys = ["alt", "assert", "be", "break", "check", "claim", + "class", "const", "cont", "copy", "crust", "do", "else", + "enum", "export", "fail", "fn", "for", "if", "iface", + "impl", "import", "let", "log", "loop", "mod", + "mut", "native", "pure", "resource", "ret", "trait", + "type", "unchecked", "unsafe", "while", "new"]; + for keys.each {|word| + words.insert(word, ()); + } + words +} + // Local Variables: // fill-column: 78; // indent-tabs-mode: nil