bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Centralize ident interner generation.

Browse source
This commit is contained in:
Paul Stansifer 2012-08-02 14:33:26 -07:00
parent 744fea1a4f
commit 9a7890d73a
7 changed files with 35 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/fuzzer/fuzzer.rs
View file

@ -260,8 +260,7 @@ fn check_variants_T<T: copy>(
@as_str(|a|pprust::print_crate(
codemap,
// Assuming we're not generating any token_trees
syntax::util::interner::mk::<@~str>(
|x| str::hash(*x), |x,y| str::eq(*x,*y)),
syntax::parse::token::mk_ident_interner(),
diagnostic::mk_span_handler(handler, codemap),
crate2,
filename,
@ -423,8 +422,7 @@ fn parse_and_print(code: @~str) -> ~str {
pprust::print_crate(
sess.cm,
// Assuming there are no token_trees
syntax::util::interner::mk::<@~str>(
|x| str::hash(*x), |x,y| str::eq(*x,*y)),
syntax::parse::token::mk_ident_interner(),
sess.span_diagnostic,
crate,
filename,
@ -572,8 +570,7 @@ fn check_variants(files: ~[~str], cx: context) {
as_str(|a| pprust::print_crate(
sess.cm,
// Assuming no token_trees
syntax::util::interner::mk::<@~str>(
|x| str::hash(*x), |x,y| str::eq(*x,*y)),
syntax::parse::token::mk_ident_interner(),
sess.span_diagnostic,
crate,
file,

8
src/libsyntax/ext/tt/transcribe.rs
View file

@ -1,9 +1,9 @@
import util::interner::interner;
import diagnostic::span_handler;
import ast::{token_tree, tt_delim, tt_tok, tt_seq, tt_nonterminal,ident};
import earley_parser::{named_match, matched_seq, matched_nonterminal};
import codemap::span;
import parse::token::{EOF, INTERPOLATED, IDENT, token, nt_ident};
import parse::token::{EOF, INTERPOLATED, IDENT, token, nt_ident,
ident_interner};
import std::map::{hashmap, box_str_hash};
export tt_reader, new_tt_reader, dup_tt_reader, tt_next_token;
@ -25,7 +25,7 @@ type tt_frame = @{
type tt_reader = @{
sp_diag: span_handler,
interner: interner<@~str>,
interner: ident_interner,
mut cur: tt_frame,
/* for MBE-style macro transcription */
interpolations: std::map::hashmap<ident, @named_match>,
@ -39,7 +39,7 @@ type tt_reader = @{
/** This can do Macro-By-Example transcription. On the other hand, if
* `src` contains no `tt_seq`s and `tt_nonterminal`s, `interp` can (and
* should) be none. */
fn new_tt_reader(sp_diag: span_handler, itr: interner<@~str>,
fn new_tt_reader(sp_diag: span_handler, itr: ident_interner,
interp: option<std::map::hashmap<ident,@named_match>>,
src: ~[ast::token_tree])
-> tt_reader {

21
src/libsyntax/parse.rs
View file

@ -19,12 +19,13 @@ import ast::node_id;
import util::interner;
import diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
import lexer::{reader, string_reader};
import parse::token::{ident_interner, mk_ident_interner};
type parse_sess = @{
cm: codemap::codemap,
mut next_id: node_id,
span_diagnostic: span_handler,
interner: interner::interner<@~str>,
interner: ident_interner,
// these two must be kept up to date
mut chpos: uint,
mut byte_pos: uint
@ -33,21 +34,19 @@ type parse_sess = @{
fn new_parse_sess(demitter: option<emitter>) -> parse_sess {
let cm = codemap::new_codemap();
return @{cm: cm,
mut next_id: 1,
span_diagnostic: mk_span_handler(mk_handler(demitter), cm),
interner: interner::mk::<@~str>(|x| str::hash(*x),
|x,y| str::eq(*x, *y)),
mut chpos: 0u, mut byte_pos: 0u};
mut next_id: 1,
span_diagnostic: mk_span_handler(mk_handler(demitter), cm),
interner: mk_ident_interner(),
mut chpos: 0u, mut byte_pos: 0u};
}
fn new_parse_sess_special_handler(sh: span_handler, cm: codemap::codemap)
-> parse_sess {
return @{cm: cm,
mut next_id: 1,
span_diagnostic: sh,
interner: interner::mk::<@~str>(|x| str::hash(*x),
|x,y| str::eq(*x, *y)),
mut chpos: 0u, mut byte_pos: 0u};
mut next_id: 1,
span_diagnostic: sh,
interner: mk_ident_interner(),
mut chpos: 0u, mut byte_pos: 0u};
}
fn parse_crate_from_file(input: ~str, cfg: ast::crate_cfg,

5
src/libsyntax/parse/comments.rs
View file

@ -276,10 +276,7 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
srdr: io::Reader) ->
{cmnts: ~[cmnt], lits: ~[lit]} {
let src = @str::from_bytes(srdr.read_whole_stream());
let itr = interner::mk::<@~str>(
|x| str::hash(*x),
|x,y| str::eq(*x, *y)
);
let itr = parse::token::mk_ident_interner();
let rdr = lexer::new_low_level_string_reader
(span_diagnostic, codemap::new_filemap(path, src, 0u, 0u), itr);

13
src/libsyntax/parse/lexer.rs
View file

@ -1,4 +1,3 @@
import util::interner::interner;
import diagnostic::span_handler;
import codemap::span;
import ext::tt::transcribe::{tt_reader, new_tt_reader, dup_tt_reader,
@ -14,7 +13,7 @@ trait reader {
fn next_token() -> {tok: token::token, sp: span};
fn fatal(~str) -> !;
fn span_diag() -> span_handler;
pure fn interner() -> interner<@~str>;
pure fn interner() -> token::ident_interner;
fn peek() -> {tok: token::token, sp: span};
fn dup() -> reader;
}
@ -27,7 +26,7 @@ type string_reader = @{
mut curr: char,
mut chpos: uint,
filemap: codemap::filemap,
interner: interner<@~str>,
interner: token::ident_interner,
/* cached: */
mut peek_tok: token::token,
mut peek_span: span
@ -35,7 +34,7 @@ type string_reader = @{
fn new_string_reader(span_diagnostic: span_handler,
filemap: codemap::filemap,
itr: interner<@~str>) -> string_reader {
itr: token::ident_interner) -> string_reader {
let r = new_low_level_string_reader(span_diagnostic, filemap, itr);
string_advance_token(r); /* fill in peek_* */
return r;
@ -44,7 +43,7 @@ fn new_string_reader(span_diagnostic: span_handler,
/* For comments.rs, which hackily pokes into 'pos' and 'curr' */
fn new_low_level_string_reader(span_diagnostic: span_handler,
filemap: codemap::filemap,
itr: interner<@~str>)
itr: token::ident_interner)
-> string_reader {
let r = @{span_diagnostic: span_diagnostic, src: filemap.src,
mut col: 0u, mut pos: 0u, mut curr: -1 as char,
@ -79,7 +78,7 @@ impl string_reader: reader {
self.span_diagnostic.span_fatal(copy self.peek_span, m)
}
fn span_diag() -> span_handler { self.span_diagnostic }
pure fn interner() -> interner<@~str> { self.interner }
pure fn interner() -> token::ident_interner { self.interner }
fn peek() -> {tok: token::token, sp: span} {
{tok: self.peek_tok, sp: self.peek_span}
}
@ -101,7 +100,7 @@ impl tt_reader: reader {
self.sp_diag.span_fatal(copy self.cur_span, m);
}
fn span_diag() -> span_handler { self.sp_diag }
pure fn interner() -> interner<@~str> { self.interner }
pure fn interner() -> token::ident_interner { self.interner }
fn peek() -> {tok: token::token, sp: span} {
{ tok: self.cur_tok, sp: self.cur_span }
}

8
src/libsyntax/parse/token.rs
View file

@ -277,6 +277,14 @@ pure fn is_bar(t: token) -> bool {
match t { BINOP(OR) | OROR => true, _ => false }
}
type ident_interner = util::interner::interner<@~str>;
fn mk_ident_interner() -> ident_interner {
let rv = @interner::mk::<@~str>(|x| str::hash(*x),
|x,y| str::eq(*x, *y));
rv
}
/**
* All the valid words that have meaning in the Rust language.
*

8
src/libsyntax/print/pprust.rs
View file

@ -1,5 +1,4 @@
import parse::comments;
import parse::lexer;
import parse::{comments, lexer, token};
import codemap::codemap;
import pp::{break_offset, word, printer,
space, zerobreak, hardbreak, breaks, consistent,
@ -30,7 +29,7 @@ fn no_ann() -> pp_ann {
type ps =
@{s: pp::printer,
cm: option<codemap>,
intr: interner::interner<@~str>,
intr: token::ident_interner,
comments: option<~[comments::cmnt]>,
literals: option<~[comments::lit]>,
mut cur_cmnt: uint,
@ -51,8 +50,7 @@ fn end(s: ps) {
fn rust_printer(writer: io::Writer) -> ps {
return @{s: pp::mk_printer(writer, default_columns),
cm: none::<codemap>,
intr: interner::mk::<@~str>(|x| str::hash(*x),
|x,y| str::eq(*x, *y)),
intr: token::mk_ident_interner(),
comments: none::<~[comments::cmnt]>,
literals: none::<~[comments::lit]>,
mut cur_cmnt: 0u,