cx.span_err(sp, "malformed inline assembly");
return DummyResult::expr(sp);
}
- let (s, style) = match expr_to_string(cx, p.parse_expr(),
+ let (s, style) = match expr_to_string(cx, panictry!(p.parse_expr_nopanic()),
"inline assembly must be a string literal") {
Some((s, st)) => (s, st),
// let compilation continue
let span = p.last_span;
panictry!(p.expect(&token::OpenDelim(token::Paren)));
- let out = p.parse_expr();
+ let out = panictry!(p.parse_expr_nopanic());
panictry!(p.expect(&token::CloseDelim(token::Paren)));
// Expands a read+write operand into two operands.
}
panictry!(p.expect(&token::OpenDelim(token::Paren)));
- let input = p.parse_expr();
+ let input = panictry!(p.parse_expr_nopanic());
panictry!(p.expect(&token::CloseDelim(token::Paren)));
inputs.push((constraint, input));
cx.span_err(sp, &format!("{} takes 1 argument", name));
return None
}
- let ret = cx.expander().fold_expr(p.parse_expr());
+ let ret = cx.expander().fold_expr(panictry!(p.parse_expr_nopanic()));
if p.token != token::Eof {
cx.span_err(sp, &format!("{} takes 1 argument", name));
}
let mut p = cx.new_parser_from_tts(tts);
let mut es = Vec::new();
while p.token != token::Eof {
- es.push(cx.expander().fold_expr(p.parse_expr()));
+ es.push(cx.expander().fold_expr(panictry!(p.parse_expr_nopanic())));
if panictry!(p.eat(&token::Comma)){
continue;
}
ecx.span_err(sp, "requires at least a format string argument");
return None;
}
- let fmtstr = p.parse_expr();
+ let fmtstr = panictry!(p.parse_expr_nopanic());
let mut named = false;
while p.token != token::Eof {
if !panictry!(p.eat(&token::Comma)) {
let name: &str = &ident.name.as_str();
panictry!(p.expect(&token::Eq));
- let e = p.parse_expr();
+ let e = panictry!(p.parse_expr_nopanic());
match names.get(name) {
None => {}
Some(prev) => {
order.push(name.to_string());
names.insert(name.to_string(), e);
} else {
- args.push(p.parse_expr());
+ args.push(panictry!(p.parse_expr_nopanic()));
}
}
Some((fmtstr, args, order, names))
let mut p = cx.new_parser_from_tts(tts);
p.quote_depth += 1;
- let cx_expr = p.parse_expr();
+ let cx_expr = panictry!(p.parse_expr_nopanic());
if !panictry!(p.eat(&token::Comma)) {
panic!(p.fatal("expected token `,`"));
}
}
impl<'a> base::MacResult for ExpandResult<'a> {
fn make_expr(mut self: Box<ExpandResult<'a>>) -> Option<P<ast::Expr>> {
- Some(self.p.parse_expr())
+ Some(panictry!(self.p.parse_expr_nopanic()))
}
fn make_items(mut self: Box<ExpandResult<'a>>)
-> Option<SmallVector<P<ast::Item>>> {
let mut ret = SmallVector::zero();
while self.p.token != token::Eof {
- match self.p.parse_item() {
+ match panictry!(self.p.parse_item_nopanic()) {
Some(item) => ret.push(item),
None => panic!(self.p.span_fatal(
self.p.span,
// check at the beginning and the parser checks after each bump
panictry!(p.check_unknown_macro_variable());
match name {
- "item" => match p.parse_item() {
+ "item" => match panictry!(p.parse_item_nopanic()) {
Some(i) => token::NtItem(i),
None => panic!(p.fatal("expected an item keyword"))
},
"block" => token::NtBlock(panictry!(p.parse_block())),
- "stmt" => match p.parse_stmt() {
+ "stmt" => match panictry!(p.parse_stmt_nopanic()) {
Some(s) => token::NtStmt(s),
None => panic!(p.fatal("expected a statement"))
},
- "pat" => token::NtPat(p.parse_pat()),
- "expr" => token::NtExpr(p.parse_expr()),
- "ty" => token::NtTy(p.parse_ty()),
+ "pat" => token::NtPat(panictry!(p.parse_pat_nopanic())),
+ "expr" => token::NtExpr(panictry!(p.parse_expr_nopanic())),
+ "ty" => token::NtTy(panictry!(p.parse_ty_nopanic())),
// this could be handled like a token, since it is one
"ident" => match p.token {
token::Ident(sn,b) => { panictry!(p.bump()); token::NtIdent(Box::new(sn),b) }
impl<'a> MacResult for ParserAnyMacro<'a> {
fn make_expr(self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Expr>> {
- let ret = self.parser.borrow_mut().parse_expr();
+ let ret = panictry!(self.parser.borrow_mut().parse_expr_nopanic());
self.ensure_complete_parse(true);
Some(ret)
}
fn make_pat(self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Pat>> {
- let ret = self.parser.borrow_mut().parse_pat();
+ let ret = panictry!(self.parser.borrow_mut().parse_pat_nopanic());
self.ensure_complete_parse(false);
Some(ret)
}
fn make_items(self: Box<ParserAnyMacro<'a>>) -> Option<SmallVector<P<ast::Item>>> {
let mut ret = SmallVector::zero();
- while let Some(item) = self.parser.borrow_mut().parse_item() {
+ while let Some(item) = panictry!(self.parser.borrow_mut().parse_item_nopanic()) {
ret.push(item);
}
self.ensure_complete_parse(false);
}
fn make_ty(self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Ty>> {
- let ret = self.parser.borrow_mut().parse_ty();
+ let ret = panictry!(self.parser.borrow_mut().parse_ty_nopanic());
self.ensure_complete_parse(true);
Some(ret)
}
sess: &ParseSess)
-> P<ast::Expr> {
let mut p = new_parser_from_source_str(sess, cfg, name, source);
- maybe_aborted(p.parse_expr(), p)
+ maybe_aborted(panictry!(p.parse_expr_nopanic()), p)
}
pub fn parse_item_from_source_str(name: String,
sess: &ParseSess)
-> Option<P<ast::Item>> {
let mut p = new_parser_from_source_str(sess, cfg, name, source);
- maybe_aborted(p.parse_item(),p)
+ maybe_aborted(panictry!(p.parse_item_nopanic()), p)
}
pub fn parse_meta_from_source_str(name: String,
sess: &ParseSess)
-> P<ast::MetaItem> {
let mut p = new_parser_from_source_str(sess, cfg, name, source);
- maybe_aborted(p.parse_meta_item(),p)
+ maybe_aborted(p.parse_meta_item(), p)
}
pub fn parse_stmt_from_source_str(name: String,
name,
source
);
- maybe_aborted(p.parse_stmt(), p)
+ maybe_aborted(panictry!(p.parse_stmt_nopanic()), p)
}
// Warning: This parses with quote_depth > 0, which is not the default.
}
// Panicing fns (for now!)
- // This is so that the quote_*!() syntax extensions
+ // These functions are used by the quote_*!() syntax extensions, but shouldn't
+ // be used otherwise.
pub fn parse_expr(&mut self) -> P<Expr> {
panictry!(self.parse_expr_nopanic())
}