mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

The parser is represented by a class now.

Browse Source
This commit is contained in:
Paul Stansifer 2012-05-23 15:06:11 -07:00
parent a16cb376ac
commit 4c2bf8e4a7
6 changed files with 2371 additions and 2380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/librustsyntax/ext/qquote.rs
View File

@ -49,7 +49,7 @@ impl of qq_helper for @ast::expr {
}
}
fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
mk_path(cx, sp, ["syntax", "parse", "parser", "parse_expr"])
mk_path(cx, sp, ["syntax", "ext", "qquote", "parse_expr"])
}
fn get_fold_fn() -> str {"fold_expr"}
}
@ -90,7 +90,7 @@ impl of qq_helper for @ast::pat {
fn visit(cx: aq_ctxt, v: vt<aq_ctxt>) {visit_pat(self, cx, v);}
fn extract_mac() -> option<ast::mac_> {fail}
fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
mk_path(cx, sp, ["syntax", "parse", "parser", "parse_pat"])
mk_path(cx, sp, ["syntax", "ext", "qquote", "parse_pat"])
}
fn get_fold_fn() -> str {"fold_pat"}
}
@ -154,29 +154,23 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
ret alt what {
"crate" {finish(ecx, body, parse_crate)}
"expr" {finish(ecx, body, parser::parse_expr)}
"expr" {finish(ecx, body, parse_expr)}
"ty" {finish(ecx, body, parse_ty)}
"item" {finish(ecx, body, parse_item)}
"stmt" {finish(ecx, body, parse_stmt)}
"pat" {finish(ecx, body, parser::parse_pat)}
"pat" {finish(ecx, body, parse_pat)}
_ {ecx.span_fatal(_sp, "unsupported ast type")}
};
}
fn parse_crate(p: parser) -> @ast::crate {
parser::parse_crate_mod(p, [])
}
fn parse_ty(p: parser) -> @ast::ty {
parser::parse_ty(p, false)
}
fn parse_stmt(p: parser) -> @ast::stmt {
parser::parse_stmt(p, [])
}
fn parse_crate(p: parser) -> @ast::crate { p.parse_crate_mod([]) }
fn parse_ty(p: parser) -> @ast::ty { p.parse_ty(false) }
fn parse_stmt(p: parser) -> @ast::stmt { p.parse_stmt([]) }
fn parse_expr(p: parser) -> @ast::expr { p.parse_expr() }
fn parse_pat(p: parser) -> @ast::pat { p.parse_pat() }
fn parse_item(p: parser) -> @ast::item {
alt parser::parse_item(p, [], ast::public) {
alt p.parse_item([], ast::public) {
some(item) { item }
none { fail "parse_item: parsing an item failed"; }
}

35
src/librustsyntax/parse.rs
View File

@ -46,13 +46,11 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
let leading_attrs = attr::parse_inner_attrs_and_next(p);
let crate_attrs = leading_attrs.inner;
let first_cdir_attr = leading_attrs.next;
let cdirs = parser::parse_crate_directives(
p, token::EOF, first_cdir_attr);
let cdirs = p.parse_crate_directives(token::EOF, first_cdir_attr);
sess.chpos = p.reader.chpos;
sess.byte_pos = sess.byte_pos + p.reader.pos;
let cx =
@{p: p,
sess: sess,
@{sess: sess,
cfg: p.cfg};
let (companionmod, _) = path::splitext(path::basename(input));
let (m, attrs) = eval::eval_crate_directives_to_mod(
@ -69,7 +67,7 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg,
sess: parse_sess) -> @ast::crate {
let p = new_parser_from_file(sess, cfg, input, parser::SOURCE_FILE);
let r = parser::parse_crate_mod(p, cfg);
let r = p.parse_crate_mod(cfg);
sess.chpos = p.reader.chpos;
sess.byte_pos = sess.byte_pos + p.reader.pos;
ret r;
@ -79,7 +77,7 @@ fn parse_crate_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
sess: parse_sess) -> @ast::crate {
let p = new_parser_from_source_str(
sess, cfg, name, codemap::fss_none, source);
let r = parser::parse_crate_mod(p, cfg);
let r = p.parse_crate_mod(cfg);
sess.chpos = p.reader.chpos;
sess.byte_pos = sess.byte_pos + p.reader.pos;
ret r;
@ -89,7 +87,7 @@ fn parse_expr_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
sess: parse_sess) -> @ast::expr {
let p = new_parser_from_source_str(
sess, cfg, name, codemap::fss_none, source);
let r = parser::parse_expr(p);
let r = p.parse_expr();
sess.chpos = p.reader.chpos;
sess.byte_pos = sess.byte_pos + p.reader.pos;
ret r;
@ -100,7 +98,7 @@ fn parse_item_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
sess: parse_sess) -> option<@ast::item> {
let p = new_parser_from_source_str(
sess, cfg, name, codemap::fss_none, source);
let r = parser::parse_item(p, attrs, vis);
let r = p.parse_item(attrs, vis);
sess.chpos = p.reader.chpos;
sess.byte_pos = sess.byte_pos + p.reader.pos;
ret r;
@ -130,23 +128,6 @@ fn next_node_id(sess: parse_sess) -> node_id {
ret rv;
}
fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
ftype: parser::file_type) -> parser {
let tok0 = lexer::next_token(rdr);
let span0 = ast_util::mk_sp(tok0.chpos, rdr.chpos);
@{sess: sess,
cfg: cfg,
file_type: ftype,
mut token: tok0.tok,
mut span: span0,
mut last_span: span0,
buffer: dvec::dvec(),
mut restriction: parser::UNRESTRICTED,
reader: rdr,
keywords: token::keyword_table(),
restricted_keywords: token::restricted_keyword_table()}
}
fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
name: str, ss: codemap::file_substr,
source: @str) -> parser {
@ -157,7 +138,7 @@ fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
let itr = @interner::mk(str::hash, str::eq);
let rdr = lexer::new_reader(sess.span_diagnostic,
filemap, itr);
ret new_parser(sess, cfg, rdr, ftype);
ret parser(sess, cfg, rdr, ftype);
}
fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
@ -177,5 +158,5 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
sess.cm.files.push(filemap);
let itr = @interner::mk(str::hash, str::eq);
let rdr = lexer::new_reader(sess.span_diagnostic, filemap, itr);
ret new_parser(sess, cfg, rdr, ftype);
ret parser(sess, cfg, rdr, ftype);
}

8
src/librustsyntax/parse/attr.rs
View File

@ -4,8 +4,6 @@ import common::{parse_seq,
seq_sep,
expect,
parse_ident};
import parser::{parse_lit,
parse_syntax_ext_naked};
export attr_or_ext;
export parse_outer_attributes;
@ -31,7 +29,7 @@ fn parse_outer_attrs_or_ext(
|| p.look_ahead(1u) == token::LBRACKET
|| expect_item_next) {
p.bump();
ret some(right(parse_syntax_ext_naked(p, lo)));
ret some(right(p.parse_syntax_ext_naked(lo)));
} else { ret none; }
} else { ret none; }
}
@ -97,7 +95,7 @@ fn parse_meta_item(p: parser) -> @ast::meta_item {
alt p.token {
token::EQ {
p.bump();
let lit = parse_lit(p);
let lit = p.parse_lit();
let mut hi = p.span.hi;
ret @spanned(lo, hi, ast::meta_name_value(ident, lit));
}
@ -115,7 +113,7 @@ fn parse_meta_item(p: parser) -> @ast::meta_item {
fn parse_meta_seq(p: parser) -> [@ast::meta_item] {
ret parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
parse_meta_item, p).node;
p, {|p| parse_meta_item(p)}).node;
}
fn parse_optional_meta(p: parser) -> [@ast::meta_item] {

30
src/librustsyntax/parse/common.rs
View File

@ -126,8 +126,7 @@ fn expect_gt(p: parser) {
}
fn parse_seq_to_before_gt<T: copy>(sep: option<token::token>,
f: fn(parser) -> T,
p: parser) -> [T] {
p: parser, f: fn(parser) -> T) -> [T] {
let mut first = true;
let mut v = [];
while p.token != token::GT && p.token != token::BINOP(token::SHR) {
@ -142,27 +141,26 @@ fn parse_seq_to_before_gt<T: copy>(sep: option<token::token>,
}
fn parse_seq_to_gt<T: copy>(sep: option<token::token>,
f: fn(parser) -> T, p: parser) -> [T] {
let v = parse_seq_to_before_gt(sep, f, p);
p: parser, f: fn(parser) -> T) -> [T] {
let v = parse_seq_to_before_gt(sep, p, f);
expect_gt(p);
ret v;
}
fn parse_seq_lt_gt<T: copy>(sep: option<token::token>,
f: fn(parser) -> T,
p: parser) -> spanned<[T]> {
p: parser, f: fn(parser) -> T) -> spanned<[T]> {
let lo = p.span.lo;
expect(p, token::LT);
let result = parse_seq_to_before_gt::<T>(sep, f, p);
let result = parse_seq_to_before_gt::<T>(sep, p, f);
let hi = p.span.hi;
expect_gt(p);
ret spanned(lo, hi, result);
}
fn parse_seq_to_end<T: copy>(ket: token::token, sep: seq_sep,
f: fn(parser) -> T, p: parser) -> [T] {
let val = parse_seq_to_before_end(ket, sep, f, p);
fn parse_seq_to_end<T: copy>(ket: token::token, sep: seq_sep, p: parser,
f: fn(parser) -> T) -> [T] {
let val = parse_seq_to_before_end(ket, sep, p, f);
p.bump();
ret val;
}
@ -182,9 +180,8 @@ fn seq_sep_none() -> seq_sep {
ret {sep: option::none, trailing_opt: false};
}
fn parse_seq_to_before_end<T: copy>(ket: token::token,
sep: seq_sep,
f: fn(parser) -> T, p: parser) -> [T] {
fn parse_seq_to_before_end<T: copy>(ket: token::token, sep: seq_sep,
p: parser, f: fn(parser) -> T) -> [T] {
let mut first: bool = true;
let mut v: [T] = [];
while p.token != ket {
@ -198,12 +195,11 @@ fn parse_seq_to_before_end<T: copy>(ket: token::token,
ret v;
}
fn parse_seq<T: copy>(bra: token::token, ket: token::token,
sep: seq_sep, f: fn(parser) -> T,
p: parser) -> spanned<[T]> {
fn parse_seq<T: copy>(bra: token::token, ket: token::token, sep: seq_sep,
p: parser, f: fn(parser) -> T) -> spanned<[T]> {
let lo = p.span.lo;
expect(p, bra);
let result = parse_seq_to_before_end::<T>(ket, sep, f, p);
let result = parse_seq_to_before_end::<T>(ket, sep, p, f);
let hi = p.span.hi;
p.bump();
ret spanned(lo, hi, result);

18
src/librustsyntax/parse/eval.rs
View File

@ -1,12 +1,10 @@
import parser::{parser,
parse_mod_items, SOURCE_FILE};
import parser::{parser, SOURCE_FILE};
import attr::parse_inner_attrs_and_next;
export eval_crate_directives_to_mod;
type ctx =
@{p: parser,
sess: parse::parse_sess,
@{sess: parse::parse_sess,
cfg: ast::crate_cfg};
fn eval_crate_directives(cx: ctx, cdirs: [@ast::crate_directive], prefix: str,
@ -66,11 +64,10 @@ fn parse_companion_mod(cx: ctx, prefix: str, suffix: option<str>)
#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 p0 = new_parser_from_file(cx.sess, cx.cfg, modpath, SOURCE_FILE);
let inner_attrs = parse_inner_attrs_and_next(p0);
let first_item_outer_attrs = inner_attrs.next;
let m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs);
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);
@ -103,11 +100,10 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
let inner_attrs = parse_inner_attrs_and_next(p0);
let mod_attrs = attrs + inner_attrs.inner;
let first_item_outer_attrs = inner_attrs.next;
let m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs);
let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
let i =
parser::mk_item(p0, cdir.span.lo, cdir.span.hi, id,
ast::item_mod(m0), ast::public, mod_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;

4634
src/librustsyntax/parse/parser.rs
View File

File diff suppressed because it is too large Load Diff