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

auto merge of #11226 : pcwalton/rust/mutable-parser, r=pcwalton 

r? @alexcrichton
This commit is contained in:
bors 2014-01-02 15:56:49 -08:00
parent 2e98a93ba9 f3eee0ebad
commit 27ce4d3f79
14 changed files with 881 additions and 847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/libsyntax/ext/asm.rs
View File

@ -39,9 +39,9 @@ fn next_state(s: State) -> Option<State> {
pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
-> base::MacResult {
let p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
tts.to_owned());
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
tts.to_owned());
let mut asm = @"";
let mut asm_str_style = None;
@ -66,9 +66,9 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
asm_str_style = Some(style);
}
Outputs => {
while *p.token != token::EOF &&
*p.token != token::COLON &&
*p.token != token::MOD_SEP {
while p.token != token::EOF &&
p.token != token::COLON &&
p.token != token::MOD_SEP {
if outputs.len() != 0 {
p.eat(&token::COMMA);
@ -77,10 +77,10 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
let (constraint, _str_style) = p.parse_str();
if constraint.starts_with("+") {
cx.span_unimpl(*p.last_span,
cx.span_unimpl(p.last_span,
"'+' (read+write) output operand constraint modifier");
} else if !constraint.starts_with("=") {
cx.span_err(*p.last_span, "output operand constraint lacks '='");
cx.span_err(p.last_span, "output operand constraint lacks '='");
}
p.expect(&token::LPAREN);
@ -91,9 +91,9 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
}
}
Inputs => {
while *p.token != token::EOF &&
*p.token != token::COLON &&
*p.token != token::MOD_SEP {
while p.token != token::EOF &&
p.token != token::COLON &&
p.token != token::MOD_SEP {
if inputs.len() != 0 {
p.eat(&token::COMMA);
@ -102,9 +102,9 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
let (constraint, _str_style) = p.parse_str();
if constraint.starts_with("=") {
cx.span_err(*p.last_span, "input operand constraint contains '='");
cx.span_err(p.last_span, "input operand constraint contains '='");
} else if constraint.starts_with("+") {
cx.span_err(*p.last_span, "input operand constraint contains '+'");
cx.span_err(p.last_span, "input operand constraint contains '+'");
}
p.expect(&token::LPAREN);
@ -116,9 +116,9 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
}
Clobbers => {
let mut clobs = ~[];
while *p.token != token::EOF &&
*p.token != token::COLON &&
*p.token != token::MOD_SEP {
while p.token != token::EOF &&
p.token != token::COLON &&
p.token != token::MOD_SEP {
if clobs.len() != 0 {
p.eat(&token::COMMA);
@ -142,16 +142,16 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
dialect = ast::asm_intel;
}
if *p.token == token::COMMA {
if p.token == token::COMMA {
p.eat(&token::COMMA);
}
}
}
while *p.token == token::COLON ||
*p.token == token::MOD_SEP ||
*p.token == token::EOF {
state = if *p.token == token::COLON {
while p.token == token::COLON ||
p.token == token::MOD_SEP ||
p.token == token::EOF {
state = if p.token == token::COLON {
p.bump();
match next_state(state) {
Some(x) => x,
@ -160,7 +160,7 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
break
}
}
} else if *p.token == token::MOD_SEP {
} else if p.token == token::MOD_SEP {
p.bump();
let s = match next_state(state) {
Some(x) => x,
@ -176,7 +176,7 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
break
}
}
} else if *p.token == token::EOF {
} else if p.token == token::EOF {
continue_ = false;
break;
} else {

8
src/libsyntax/ext/base.rs
View File

@ -442,11 +442,11 @@ pub fn get_single_str_from_tts(cx: &ExtCtxt,
pub fn get_exprs_from_tts(cx: &ExtCtxt,
sp: Span,
tts: &[ast::token_tree]) -> ~[@ast::Expr] {
let p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
tts.to_owned());
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
tts.to_owned());
let mut es = ~[];
while *p.token != token::EOF {
while p.token != token::EOF {
if es.len() != 0 && !p.eat(&token::COMMA) {
cx.span_fatal(sp, "expected token: `,`");
}

6
src/libsyntax/ext/cfg.rs
View File

@ -26,11 +26,13 @@ use parse::token;
use parse::attr::parser_attr;
pub fn expand_cfg(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree]) -> base::MacResult {
let p = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), tts.to_owned());
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
tts.to_owned());
let mut cfgs = ~[];
// parse `cfg!(meta_item, meta_item(x,y), meta_item="foo", ...)`
while *p.token != token::EOF {
while p.token != token::EOF {
cfgs.push(p.parse_meta_item());
if p.eat(&token::EOF) { break } // trailing comma is optional,.
p.expect(&token::COMMA);

24
src/libsyntax/ext/format.rs
View File

@ -53,11 +53,11 @@ struct Context<'a> {
impl<'a> Context<'a> {
/// Parses the arguments from the given list of tokens, returning None if
/// there's a parse error so we can continue parsing other format! expressions.
fn parse_args(&mut self, sp: Span,
tts: &[ast::token_tree]) -> (@ast::Expr, Option<@ast::Expr>) {
let p = rsparse::new_parser_from_tts(self.ecx.parse_sess(),
self.ecx.cfg(),
tts.to_owned());
fn parse_args(&mut self, sp: Span, tts: &[ast::token_tree])
-> (@ast::Expr, Option<@ast::Expr>) {
let mut p = rsparse::new_parser_from_tts(self.ecx.parse_sess(),
self.ecx.cfg(),
tts.to_owned());
// Parse the leading function expression (maybe a block, maybe a path)
let extra = p.parse_expr();
if !p.eat(&token::COMMA) {
@ -65,34 +65,34 @@ impl<'a> Context<'a> {
return (extra, None);
}
if *p.token == token::EOF {
if p.token == token::EOF {
self.ecx.span_err(sp, "requires at least a format string argument");
return (extra, None);
}
let fmtstr = p.parse_expr();
let mut named = false;
while *p.token != token::EOF {
while p.token != token::EOF {
if !p.eat(&token::COMMA) {
self.ecx.span_err(sp, "expected token: `,`");
return (extra, None);
}
if *p.token == token::EOF { break } // accept trailing commas
if named || (token::is_ident(p.token) &&
if p.token == token::EOF { break } // accept trailing commas
if named || (token::is_ident(&p.token) &&
p.look_ahead(1, |t| *t == token::EQ)) {
named = true;
let ident = match *p.token {
let ident = match p.token {
token::IDENT(i, _) => {
p.bump();
i
}
_ if named => {
self.ecx.span_err(*p.span,
self.ecx.span_err(p.span,
"expected ident, positional arguments \
cannot follow named arguments");
return (extra, None);
}
_ => {
self.ecx.span_err(*p.span,
self.ecx.span_err(p.span,
format!("expected ident for named \
argument, but found `{}`",
p.this_token_to_str()));

16
src/libsyntax/ext/quote.rs
View File

@ -579,22 +579,18 @@ fn mk_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::token_tree])
ss
}
fn expand_tts(cx: &ExtCtxt,
sp: Span,
tts: &[ast::token_tree]) -> (@ast::Expr, @ast::Expr) {
fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::token_tree])
-> (@ast::Expr, @ast::Expr) {
// NB: It appears that the main parser loses its mind if we consider
// $foo as a tt_nonterminal during the main parse, so we have to re-parse
// under quote_depth > 0. This is silly and should go away; the _guess_ is
// it has to do with transition away from supporting old-style macros, so
// try removing it when enough of them are gone.
let p = parse::new_parser_from_tts(
cx.parse_sess(),
cx.cfg(),
tts.to_owned()
);
*p.quote_depth += 1u;
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
tts.to_owned());
p.quote_depth += 1u;
let cx_expr = p.parse_expr();
if !p.eat(&token::COMMA) {

10
src/libsyntax/ext/source_util.rs
View File

@ -81,9 +81,13 @@ pub fn expand_include(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
-> base::MacResult {
let file = get_single_str_from_tts(cx, sp, tts, "include!");
// The file will be added to the code map by the parser
let p = parse::new_sub_parser_from_file(
cx.parse_sess(), cx.cfg(),
&res_rel_file(cx, sp, &Path::new(file)), sp);
let mut p =
parse::new_sub_parser_from_file(cx.parse_sess(),
cx.cfg(),
&res_rel_file(cx,
sp,
&Path::new(file)),
sp);
base::MRExpr(p.parse_expr())
}

4
src/libsyntax/ext/trace_macros.rs
View File

@ -26,7 +26,7 @@ pub fn expand_trace_macros(cx: &mut ExtCtxt,
None,
tt.to_owned());
let rdr = tt_rdr as @mut reader;
let rust_parser = Parser(sess, cfg.clone(), rdr.dup());
let mut rust_parser = Parser(sess, cfg.clone(), rdr.dup());
if rust_parser.is_keyword(keywords::True) {
cx.set_trace_macros(true);
@ -38,7 +38,7 @@ pub fn expand_trace_macros(cx: &mut ExtCtxt,
rust_parser.bump();
let rust_parser = Parser(sess, cfg, rdr.dup());
let mut rust_parser = Parser(sess, cfg, rdr.dup());
let result = rust_parser.parse_expr();
base::MRExpr(result)
}

18
src/libsyntax/ext/tt/macro_parser.rs
View File

@ -403,13 +403,13 @@ pub fn parse(
}
rdr.next_token();
} else /* bb_eis.len() == 1 */ {
let rust_parser = Parser(sess, cfg.clone(), rdr.dup());
let mut rust_parser = Parser(sess, cfg.clone(), rdr.dup());
let mut ei = bb_eis.pop();
match ei.elts[ei.idx].node {
match_nonterminal(_, ref name, idx) => {
ei.matches[idx].push(@matched_nonterminal(
parse_nt(&rust_parser, ident_to_str(name))));
parse_nt(&mut rust_parser, ident_to_str(name))));
ei.idx += 1u;
}
_ => fail!()
@ -426,7 +426,7 @@ pub fn parse(
}
}
pub fn parse_nt(p: &Parser, name: &str) -> nonterminal {
pub fn parse_nt(p: &mut Parser, name: &str) -> nonterminal {
match name {
"item" => match p.parse_item(~[]) {
Some(i) => token::nt_item(i),
@ -438,19 +438,21 @@ pub fn parse_nt(p: &Parser, name: &str) -> nonterminal {
"expr" => token::nt_expr(p.parse_expr()),
"ty" => token::nt_ty(p.parse_ty(false /* no need to disambiguate*/)),
// this could be handled like a token, since it is one
"ident" => match *p.token {
"ident" => match p.token {
token::IDENT(sn,b) => { p.bump(); token::nt_ident(~sn,b) }
_ => p.fatal(~"expected ident, found "
+ token::to_str(get_ident_interner(), p.token))
_ => {
let token_str = token::to_str(get_ident_interner(), &p.token);
p.fatal(~"expected ident, found " + token_str)
}
},
"path" => {
token::nt_path(~p.parse_path(LifetimeAndTypesWithoutColons).path)
}
"attr" => token::nt_attr(@p.parse_attribute(false)),
"tt" => {
*p.quote_depth += 1u; //but in theory, non-quoted tts might be useful
p.quote_depth += 1u; //but in theory, non-quoted tts might be useful
let res = token::nt_tt(@p.parse_token_tree());
*p.quote_depth -= 1u;
p.quote_depth -= 1u;
res
}
"matchers" => token::nt_matchers(p.parse_matchers()),

44
src/libsyntax/ext/tt/macro_rules.rs
View File

@ -24,10 +24,11 @@ use parse::attr::parser_attr;
use parse::token::{get_ident_interner, special_idents, gensym_ident, ident_to_str};
use parse::token::{FAT_ARROW, SEMI, nt_matchers, nt_tt, EOF};
use print;
use std::cell::RefCell;
use util::small_vector::SmallVector;
struct ParserAnyMacro {
parser: @Parser,
parser: RefCell<Parser>,
}
impl ParserAnyMacro {
@ -38,28 +39,36 @@ impl ParserAnyMacro {
/// fail!(); } )` doesn't get picked up by .parse_expr(), but it's
/// allowed to be there.
fn ensure_complete_parse(&self, allow_semi: bool) {
if allow_semi && *self.parser.token == SEMI {
self.parser.bump()
let mut parser = self.parser.borrow_mut();
if allow_semi && parser.get().token == SEMI {
parser.get().bump()
}
if *self.parser.token != EOF {
let msg = format!("macro expansion ignores token `{}` and any following",
self.parser.this_token_to_str());
self.parser.span_err(*self.parser.span, msg);
if parser.get().token != EOF {
let token_str = parser.get().this_token_to_str();
let msg = format!("macro expansion ignores token `{}` and any \
following",
token_str);
let span = parser.get().span;
parser.get().span_err(span, msg);
}
}
}
impl AnyMacro for ParserAnyMacro {
fn make_expr(&self) -> @ast::Expr {
let ret = self.parser.parse_expr();
let ret = {
let mut parser = self.parser.borrow_mut();
parser.get().parse_expr()
};
self.ensure_complete_parse(true);
ret
}
fn make_items(&self) -> SmallVector<@ast::item> {
let mut ret = SmallVector::zero();
loop {
let attrs = self.parser.parse_outer_attributes();
match self.parser.parse_item(attrs) {
let mut parser = self.parser.borrow_mut();
let attrs = parser.get().parse_outer_attributes();
match parser.get().parse_item(attrs) {
Some(item) => ret.push(item),
None => break
}
@ -68,8 +77,11 @@ impl AnyMacro for ParserAnyMacro {
ret
}
fn make_stmt(&self) -> @ast::Stmt {
let attrs = self.parser.parse_outer_attributes();
let ret = self.parser.parse_stmt(attrs);
let ret = {
let mut parser = self.parser.borrow_mut();
let attrs = parser.get().parse_outer_attributes();
parser.get().parse_stmt(attrs)
};
self.ensure_complete_parse(true);
ret
}
@ -142,14 +154,14 @@ fn generic_extension(cx: &ExtCtxt,
// rhs has holes ( `$id` and `$(...)` that need filled)
let trncbr = new_tt_reader(s_d, Some(named_matches),
rhs);
let p = @Parser(cx.parse_sess(),
cx.cfg(),
trncbr as @mut reader);
let p = Parser(cx.parse_sess(),
cx.cfg(),
trncbr as @mut reader);
// Let the context choose how to interpret the result.
// Weird, but useful for X-macros.
return MRAny(@ParserAnyMacro {
parser: p,
parser: RefCell::new(p),
} as @AnyMacro)
}
failure(sp, ref msg) => if sp.lo >= best_fail_spot.lo {

45
src/libsyntax/parse/attr.rs
View File

@ -17,24 +17,23 @@ use parse::token::INTERPOLATED;
// a parser that can parse attributes.
pub trait parser_attr {
fn parse_outer_attributes(&self) -> ~[ast::Attribute];
fn parse_attribute(&self, permit_inner: bool) -> ast::Attribute;
fn parse_inner_attrs_and_next(&self) ->
(~[ast::Attribute], ~[ast::Attribute]);
fn parse_meta_item(&self) -> @ast::MetaItem;
fn parse_meta_seq(&self) -> ~[@ast::MetaItem];
fn parse_optional_meta(&self) -> ~[@ast::MetaItem];
fn parse_outer_attributes(&mut self) -> ~[ast::Attribute];
fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute;
fn parse_inner_attrs_and_next(&mut self)
-> (~[ast::Attribute], ~[ast::Attribute]);
fn parse_meta_item(&mut self) -> @ast::MetaItem;
fn parse_meta_seq(&mut self) -> ~[@ast::MetaItem];
fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem];
}
impl parser_attr for Parser {
// Parse attributes that appear before an item
fn parse_outer_attributes(&self) -> ~[ast::Attribute] {
fn parse_outer_attributes(&mut self) -> ~[ast::Attribute] {
let mut attrs: ~[ast::Attribute] = ~[];
loop {
debug!("parse_outer_attributes: self.token={:?}",
self.token);
match *self.token {
match self.token {
token::INTERPOLATED(token::nt_attr(..)) => {
attrs.push(self.parse_attribute(false));
}
@ -66,10 +65,10 @@ impl parser_attr for Parser {
//
// if permit_inner is true, then a trailing `;` indicates an inner
// attribute
fn parse_attribute(&self, permit_inner: bool) -> ast::Attribute {
fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute {
debug!("parse_attributes: permit_inner={:?} self.token={:?}",
permit_inner, self.token);
let (span, value) = match *self.token {
let (span, value) = match self.token {
INTERPOLATED(token::nt_attr(attr)) => {
assert!(attr.node.style == ast::AttrOuter);
self.bump();
@ -85,11 +84,12 @@ impl parser_attr for Parser {
(mk_sp(lo, hi), meta_item)
}
_ => {
let token_str = self.this_token_to_str();
self.fatal(format!("expected `\\#` but found `{}`",
self.this_token_to_str()));
token_str));
}
};
let style = if permit_inner && *self.token == token::SEMI {
let style = if permit_inner && self.token == token::SEMI {
self.bump();
ast::AttrInner
} else {
@ -115,12 +115,12 @@ impl parser_attr for Parser {
// matches inner_attrs* outer_attr?
// you can make the 'next' field an Option, but the result is going to be
// more useful as a vector.
fn parse_inner_attrs_and_next(&self)
fn parse_inner_attrs_and_next(&mut self)
-> (~[ast::Attribute], ~[ast::Attribute]) {
let mut inner_attrs: ~[ast::Attribute] = ~[];
let mut next_outer_attrs: ~[ast::Attribute] = ~[];
loop {
let attr = match *self.token {
let attr = match self.token {
token::INTERPOLATED(token::nt_attr(..)) => {
self.parse_attribute(true)
}
@ -154,10 +154,11 @@ impl parser_attr for Parser {
// matches meta_item = IDENT
// | IDENT = lit
// | IDENT meta_seq
fn parse_meta_item(&self) -> @ast::MetaItem {
fn parse_meta_item(&mut self) -> @ast::MetaItem {
let lo = self.span.lo;
let name = self.id_to_str(self.parse_ident());
match *self.token {
let ident = self.parse_ident();
let name = self.id_to_str(ident);
match self.token {
token::EQ => {
self.bump();
let lit = self.parse_lit();
@ -187,15 +188,15 @@ impl parser_attr for Parser {
}
// matches meta_seq = ( COMMASEP(meta_item) )
fn parse_meta_seq(&self) -> ~[@ast::MetaItem] {
fn parse_meta_seq(&mut self) -> ~[@ast::MetaItem] {
self.parse_seq(&token::LPAREN,
&token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA),
|p| p.parse_meta_item()).node
}
fn parse_optional_meta(&self) -> ~[@ast::MetaItem] {
match *self.token {
fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem] {
match self.token {
token::LPAREN => self.parse_meta_seq(),
_ => ~[]
}

59
src/libsyntax/parse/mod.rs
View File

@ -84,7 +84,7 @@ pub fn parse_crate_attrs_from_file(
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> ~[ast::Attribute] {
let parser = new_parser_from_file(sess, cfg, input);
let mut parser = new_parser_from_file(sess, cfg, input);
let (inner, _) = parser.parse_inner_attrs_and_next();
return inner;
}
@ -95,10 +95,10 @@ pub fn parse_crate_from_source_str(
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> ast::Crate {
let p = new_parser_from_source_str(sess,
/*bad*/ cfg.clone(),
name,
source);
let mut p = new_parser_from_source_str(sess,
/*bad*/ cfg.clone(),
name,
source);
maybe_aborted(p.parse_crate_mod(),p)
}
@ -108,10 +108,10 @@ pub fn parse_crate_attrs_from_source_str(
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> ~[ast::Attribute] {
let p = new_parser_from_source_str(sess,
/*bad*/ cfg.clone(),
name,
source);
let mut p = new_parser_from_source_str(sess,
/*bad*/ cfg.clone(),
name,
source);
let (inner, _) = maybe_aborted(p.parse_inner_attrs_and_next(),p);
return inner;
}
@ -122,12 +122,7 @@ pub fn parse_expr_from_source_str(
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> @ast::Expr {
let p = new_parser_from_source_str(
sess,
cfg,
name,
source
);
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_expr(), p)
}
@ -138,12 +133,7 @@ pub fn parse_item_from_source_str(
attrs: ~[ast::Attribute],
sess: @mut ParseSess
) -> Option<@ast::item> {
let p = new_parser_from_source_str(
sess,
cfg,
name,
source
);
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_item(attrs),p)
}
@ -153,12 +143,7 @@ pub fn parse_meta_from_source_str(
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> @ast::MetaItem {
let p = new_parser_from_source_str(
sess,
cfg,
name,
source
);
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_meta_item(),p)
}
@ -169,7 +154,7 @@ pub fn parse_stmt_from_source_str(
attrs: ~[ast::Attribute],
sess: @mut ParseSess
) -> @ast::Stmt {
let p = new_parser_from_source_str(
let mut p = new_parser_from_source_str(
sess,
cfg,
name,
@ -184,13 +169,13 @@ pub fn parse_tts_from_source_str(
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> ~[ast::token_tree] {
let p = new_parser_from_source_str(
let mut p = new_parser_from_source_str(
sess,
cfg,
name,
source
);
*p.quote_depth += 1u;
p.quote_depth += 1u;
// right now this is re-creating the token trees from ... token trees.
maybe_aborted(p.parse_all_token_trees(),p)
}
@ -201,15 +186,15 @@ pub fn parse_tts_from_source_str(
// consumed all of the input before returning the function's
// result.
pub fn parse_from_source_str<T>(
f: |&Parser| -> T,
f: |&mut Parser| -> T,
name: @str,
ss: codemap::FileSubstr,
source: @str,
cfg: ast::CrateConfig,
sess: @mut ParseSess)
-> T {
let p = new_parser_from_source_substr(sess, cfg, name, ss, source);
let r = f(&p);
let mut p = new_parser_from_source_substr(sess, cfg, name, ss, source);
let r = f(&mut p);
if !p.reader.is_eof() {
p.reader.fatal(~"expected end-of-string");
}
@ -326,7 +311,7 @@ pub fn filemap_to_tts(sess: @mut ParseSess, filemap: @FileMap)
// parsing tt's probably shouldn't require a parser at all.
let cfg = ~[];
let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap);
let p1 = Parser(sess, cfg, srdr as @mut reader);
let mut p1 = Parser(sess, cfg, srdr as @mut reader);
p1.parse_all_token_trees()
}
@ -339,7 +324,7 @@ pub fn tts_to_parser(sess: @mut ParseSess,
}
// abort if necessary
pub fn maybe_aborted<T>(result : T, p: Parser) -> T {
pub fn maybe_aborted<T>(result: T, mut p: Parser) -> T {
p.abort_if_errors();
result
}
@ -646,11 +631,11 @@ mod test {
}
fn parser_done(p: Parser){
assert_eq!((*p.token).clone(), token::EOF);
assert_eq!(p.token.clone(), token::EOF);
}
#[test] fn parse_ident_pat () {
let parser = string_to_parser(@"b");
let mut parser = string_to_parser(@"b");
assert_eq!(parser.parse_pat(),
@ast::Pat{id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(

29
src/libsyntax/parse/obsolete.rs
View File

@ -20,7 +20,6 @@ removed.
use ast::{Expr, ExprLit, lit_nil};
use codemap::{Span, respan};
use parse::parser::Parser;
use parse::token::Token;
use parse::token;
use std::str;
@ -57,23 +56,22 @@ impl to_bytes::IterBytes for ObsoleteSyntax {
pub trait ParserObsoleteMethods {
/// Reports an obsolete syntax non-fatal error.
fn obsolete(&self, sp: Span, kind: ObsoleteSyntax);
fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax);
// Reports an obsolete syntax non-fatal error, and returns
// a placeholder expression
fn obsolete_expr(&self, sp: Span, kind: ObsoleteSyntax) -> @Expr;
fn report(&self,
fn obsolete_expr(&mut self, sp: Span, kind: ObsoleteSyntax) -> @Expr;
fn report(&mut self,
sp: Span,
kind: ObsoleteSyntax,
kind_str: &str,
desc: &str);
fn token_is_obsolete_ident(&self, ident: &str, token: &Token) -> bool;
fn is_obsolete_ident(&self, ident: &str) -> bool;
fn eat_obsolete_ident(&self, ident: &str) -> bool;
fn is_obsolete_ident(&mut self, ident: &str) -> bool;
fn eat_obsolete_ident(&mut self, ident: &str) -> bool;
}
impl ParserObsoleteMethods for Parser {
/// Reports an obsolete syntax non-fatal error.
fn obsolete(&self, sp: Span, kind: ObsoleteSyntax) {
fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax) {
let (kind_str, desc) = match kind {
ObsoleteSwap => (
"swap",
@ -158,12 +156,12 @@ impl ParserObsoleteMethods for Parser {
// Reports an obsolete syntax non-fatal error, and returns
// a placeholder expression
fn obsolete_expr(&self, sp: Span, kind: ObsoleteSyntax) -> @Expr {
fn obsolete_expr(&mut self, sp: Span, kind: ObsoleteSyntax) -> @Expr {
self.obsolete(sp, kind);
self.mk_expr(sp.lo, sp.hi, ExprLit(@respan(sp, lit_nil)))
}
fn report(&self,
fn report(&mut self,
sp: Span,
kind: ObsoleteSyntax,
kind_str: &str,
@ -176,9 +174,8 @@ impl ParserObsoleteMethods for Parser {
}
}
fn token_is_obsolete_ident(&self, ident: &str, token: &Token)
-> bool {
match *token {
fn is_obsolete_ident(&mut self, ident: &str) -> bool {
match self.token {
token::IDENT(sid, _) => {
str::eq_slice(self.id_to_str(sid), ident)
}
@ -186,11 +183,7 @@ impl ParserObsoleteMethods for Parser {
}
}
fn is_obsolete_ident(&self, ident: &str) -> bool {
self.token_is_obsolete_ident(ident, self.token)
}
fn eat_obsolete_ident(&self, ident: &str) -> bool {
fn eat_obsolete_ident(&mut self, ident: &str) -> bool {
if self.is_obsolete_ident(ident) {
self.bump();
true

1417
src/libsyntax/parse/parser.rs
View File

File diff suppressed because it is too large Load Diff

2
src/libsyntax/util/parser_testing.rs
View File

@ -55,7 +55,7 @@ pub fn string_to_crate (source_str : @str) -> ast::Crate {
// parse a string, return a crate and the ParseSess
pub fn string_to_crate_and_sess (source_str : @str) -> (ast::Crate,@mut ParseSess) {
let (p,ps) = string_to_parser_and_sess(source_str);
let (mut p,ps) = string_to_parser_and_sess(source_str);
(p.parse_crate_mod(),ps)
}