bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Camel case all the codemap types except span

Browse source
This commit is contained in:
Brian Anderson 2012-11-12 18:59:37 -08:00
parent 38b9740668
commit 9ecf86343a
13 changed files with 104 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/middle/trans/debuginfo.rs
View file

@ -112,7 +112,7 @@ type compile_unit_md = {name: ~str};
type subprogram_md = {id: ast::node_id}; type subprogram_md = {id: ast::node_id};
type local_var_md = {id: ast::node_id}; type local_var_md = {id: ast::node_id};
type tydesc_md = {hash: uint}; type tydesc_md = {hash: uint};
type block_md = {start: codemap::loc, end: codemap::loc}; type block_md = {start: codemap::Loc, end: codemap::Loc};
type argument_md = {id: ast::node_id}; type argument_md = {id: ast::node_id};
type retval_md = {id: ast::node_id}; type retval_md = {id: ast::node_id};

2
src/librustdoc/attr_parser.rs
View file

@ -30,7 +30,7 @@ mod test {
let parse_sess = syntax::parse::new_parse_sess(None); let parse_sess = syntax::parse::new_parse_sess(None);
let parser = parse::new_parser_from_source_str( let parser = parse::new_parser_from_source_str(
parse_sess, ~[], ~"-", codemap::fss_none, @source); parse_sess, ~[], ~"-", codemap::FssNone, @source);
parser.parse_outer_attributes() parser.parse_outer_attributes()
} }

2
src/libsyntax/ast.rs
View file

@ -4,7 +4,7 @@ use std::serialization::{Serializable,
Deserializable, Deserializable,
Serializer, Serializer,
Deserializer}; Deserializer};
use codemap::{span, filename}; use codemap::{span, FileName};
use parse::token; use parse::token;
#[auto_serialize] #[auto_serialize]

130
src/libsyntax/codemap.rs
View file

@ -10,13 +10,13 @@ use std::serialization::{Serializable,
Serializer, Serializer,
Deserializer}; Deserializer};
pub type byte_pos = uint; pub type BytePos = uint;
pub type char_pos = uint; pub type CharPos = uint;
pub struct span { pub struct span {
lo: char_pos, lo: CharPos,
hi: char_pos, hi: CharPos,
expn_info: Option<@expn_info> expn_info: Option<@ExpnInfo>
} }
impl span : cmp::Eq { impl span : cmp::Eq {
@ -37,70 +37,70 @@ impl<D: Deserializer> span: Deserializable<D> {
} }
} }
pub struct file_pos { pub struct Loc {
ch: char_pos, byte: byte_pos file: @FileMap, line: uint, col: uint
} }
pub struct loc { pub struct FilePos {
file: @filemap, line: uint, col: uint ch: CharPos, byte: BytePos
} }
impl file_pos : cmp::Eq { impl FilePos : cmp::Eq {
pure fn eq(other: &file_pos) -> bool { pure fn eq(other: &FilePos) -> bool {
self.ch == (*other).ch && self.byte == (*other).byte self.ch == (*other).ch && self.byte == (*other).byte
} }
pure fn ne(other: &file_pos) -> bool { !self.eq(other) } pure fn ne(other: &FilePos) -> bool { !self.eq(other) }
} }
pub enum expn_info { pub enum ExpnInfo {
expanded_from({call_site: span, ExpandedFrom({call_site: span,
callie: {name: ~str, span: Option<span>}}) callie: {name: ~str, span: Option<span>}})
} }
pub type filename = ~str; pub type FileName = ~str;
pub type lookup_fn = pure fn(file_pos) -> uint; pub type LookupFn = pure fn(FilePos) -> uint;
pub struct file_lines { pub struct FileLines {
file: @filemap, file: @FileMap,
lines: ~[uint] lines: ~[uint]
} }
pub enum file_substr { pub enum FileSubstr {
pub fss_none, pub FssNone,
pub fss_internal(span), pub FssInternal(span),
pub fss_external({filename: ~str, line: uint, col: uint}) pub FssExternal({filename: ~str, line: uint, col: uint})
} }
pub struct filemap { pub struct FileMap {
name: filename, name: FileName,
substr: file_substr, substr: FileSubstr,
src: @~str, src: @~str,
start_pos: file_pos, start_pos: FilePos,
mut lines: ~[file_pos] mut lines: ~[FilePos]
} }
pub impl filemap { pub impl FileMap {
static fn new_w_substr(+filename: filename, +substr: file_substr, static fn new_w_substr(+filename: FileName, +substr: FileSubstr,
src: @~str, src: @~str,
start_pos_ch: uint, start_pos_byte: uint) start_pos_ch: uint, start_pos_byte: uint)
-> filemap { -> FileMap {
return filemap { return FileMap {
name: filename, substr: substr, src: src, name: filename, substr: substr, src: src,
start_pos: file_pos {ch: start_pos_ch, byte: start_pos_byte}, start_pos: FilePos {ch: start_pos_ch, byte: start_pos_byte},
mut lines: ~[file_pos {ch: start_pos_ch, byte: start_pos_byte}] mut lines: ~[FilePos {ch: start_pos_ch, byte: start_pos_byte}]
}; };
} }
static fn new(+filename: filename, src: @~str, static fn new(+filename: FileName, src: @~str,
start_pos_ch: char_pos, start_pos_byte: byte_pos) start_pos_ch: CharPos, start_pos_byte: BytePos)
-> filemap { -> FileMap {
return filemap::new_w_substr(filename, fss_none, src, return FileMap::new_w_substr(filename, FssNone, src,
start_pos_ch, start_pos_byte); start_pos_ch, start_pos_byte);
} }
fn next_line(@self, chpos: char_pos, byte_pos: byte_pos) { fn next_line(@self, chpos: CharPos, byte_pos: BytePos) {
self.lines.push(file_pos {ch: chpos, byte: byte_pos + self.start_pos.byte}); self.lines.push(FilePos {ch: chpos, byte: byte_pos + self.start_pos.byte});
} }
pub fn get_line(@self, line: int) -> ~str unsafe { pub fn get_line(@self, line: int) -> ~str unsafe {
@ -115,7 +115,7 @@ pub impl filemap {
} }
pub struct CodeMap { pub struct CodeMap {
files: DVec<@filemap> files: DVec<@FileMap>
} }
pub impl CodeMap { pub impl CodeMap {
@ -130,31 +130,31 @@ pub impl CodeMap {
return fmt!("<%s:%u:%u>", pos.file.name, pos.line, pos.col); return fmt!("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
} }
pub fn lookup_char_pos(@self, pos: char_pos) -> loc { pub fn lookup_char_pos(@self, pos: CharPos) -> Loc {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; } pure fn lookup(pos: FilePos) -> uint { return pos.ch; }
return self.lookup_pos(pos, lookup); return self.lookup_pos(pos, lookup);
} }
pub fn lookup_byte_pos(@self, pos: byte_pos) -> loc { pub fn lookup_byte_pos(@self, pos: BytePos) -> Loc {
pure fn lookup(pos: file_pos) -> uint { return pos.byte; } pure fn lookup(pos: FilePos) -> uint { return pos.byte; }
return self.lookup_pos(pos, lookup); return self.lookup_pos(pos, lookup);
} }
pub fn lookup_char_pos_adj(@self, pos: char_pos) pub fn lookup_char_pos_adj(@self, pos: CharPos)
-> {filename: ~str, line: uint, col: uint, file: Option<@filemap>} -> {filename: ~str, line: uint, col: uint, file: Option<@FileMap>}
{ {
let loc = self.lookup_char_pos(pos); let loc = self.lookup_char_pos(pos);
match (loc.file.substr) { match (loc.file.substr) {
fss_none => { FssNone => {
{filename: /* FIXME (#2543) */ copy loc.file.name, {filename: /* FIXME (#2543) */ copy loc.file.name,
line: loc.line, line: loc.line,
col: loc.col, col: loc.col,
file: Some(loc.file)} file: Some(loc.file)}
} }
fss_internal(sp) => { FssInternal(sp) => {
self.lookup_char_pos_adj(sp.lo + (pos - loc.file.start_pos.ch)) self.lookup_char_pos_adj(sp.lo + (pos - loc.file.start_pos.ch))
} }
fss_external(eloc) => { FssExternal(eloc) => {
{filename: /* FIXME (#2543) */ copy eloc.filename, {filename: /* FIXME (#2543) */ copy eloc.filename,
line: eloc.line + loc.line - 1u, line: eloc.line + loc.line - 1u,
col: if loc.line == 1u {eloc.col + loc.col} else {loc.col}, col: if loc.line == 1u {eloc.col + loc.col} else {loc.col},
@ -164,15 +164,15 @@ pub impl CodeMap {
} }
pub fn adjust_span(@self, sp: span) -> span { pub fn adjust_span(@self, sp: span) -> span {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; } pure fn lookup(pos: FilePos) -> uint { return pos.ch; }
let line = self.lookup_line(sp.lo, lookup); let line = self.lookup_line(sp.lo, lookup);
match (line.fm.substr) { match (line.fm.substr) {
fss_none => sp, FssNone => sp,
fss_internal(s) => { FssInternal(s) => {
self.adjust_span(span {lo: s.lo + (sp.lo - line.fm.start_pos.ch), self.adjust_span(span {lo: s.lo + (sp.lo - line.fm.start_pos.ch),
hi: s.lo + (sp.hi - line.fm.start_pos.ch), hi: s.lo + (sp.hi - line.fm.start_pos.ch),
expn_info: sp.expn_info})} expn_info: sp.expn_info})}
fss_external(_) => sp FssExternal(_) => sp
} }
} }
@ -183,24 +183,24 @@ pub impl CodeMap {
lo.line, lo.col, hi.line, hi.col) lo.line, lo.col, hi.line, hi.col)
} }
pub fn span_to_filename(@self, sp: span) -> filename { pub fn span_to_filename(@self, sp: span) -> FileName {
let lo = self.lookup_char_pos(sp.lo); let lo = self.lookup_char_pos(sp.lo);
return /* FIXME (#2543) */ copy lo.file.name; return /* FIXME (#2543) */ copy lo.file.name;
} }
pub fn span_to_lines(@self, sp: span) -> @file_lines { pub fn span_to_lines(@self, sp: span) -> @FileLines {
let lo = self.lookup_char_pos(sp.lo); let lo = self.lookup_char_pos(sp.lo);
let hi = self.lookup_char_pos(sp.hi); let hi = self.lookup_char_pos(sp.hi);
let mut lines = ~[]; let mut lines = ~[];
for uint::range(lo.line - 1u, hi.line as uint) |i| { for uint::range(lo.line - 1u, hi.line as uint) |i| {
lines.push(i); lines.push(i);
}; };
return @file_lines {file: lo.file, lines: lines}; return @FileLines {file: lo.file, lines: lines};
} }
fn lookup_byte_offset(@self, chpos: char_pos) fn lookup_byte_offset(@self, chpos: CharPos)
-> {fm: @filemap, pos: byte_pos} { -> {fm: @FileMap, pos: BytePos} {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; } pure fn lookup(pos: FilePos) -> uint { return pos.ch; }
let {fm, line} = self.lookup_line(chpos, lookup); let {fm, line} = self.lookup_line(chpos, lookup);
let line_offset = fm.lines[line].byte - fm.start_pos.byte; let line_offset = fm.lines[line].byte - fm.start_pos.byte;
let col = chpos - fm.lines[line].ch; let col = chpos - fm.lines[line].ch;
@ -215,7 +215,7 @@ pub impl CodeMap {
return str::slice(*begin.fm.src, begin.pos, end.pos); return str::slice(*begin.fm.src, begin.pos, end.pos);
} }
pub fn get_filemap(@self, filename: ~str) -> @filemap { pub fn get_filemap(@self, filename: ~str) -> @FileMap {
for self.files.each |fm| { if fm.name == filename { return *fm; } } for self.files.each |fm| { if fm.name == filename { return *fm; } }
//XXjdm the following triggers a mismatched type bug //XXjdm the following triggers a mismatched type bug
// (or expected function, found _|_) // (or expected function, found _|_)
@ -225,8 +225,8 @@ pub impl CodeMap {
} }
priv impl CodeMap { priv impl CodeMap {
fn lookup_line(@self, pos: uint, lookup: lookup_fn) fn lookup_line(@self, pos: uint, lookup: LookupFn)
-> {fm: @filemap, line: uint} -> {fm: @FileMap, line: uint}
{ {
let len = self.files.len(); let len = self.files.len();
let mut a = 0u; let mut a = 0u;
@ -248,9 +248,9 @@ priv impl CodeMap {
return {fm: f, line: a}; return {fm: f, line: a};
} }
fn lookup_pos(@self, pos: uint, lookup: lookup_fn) -> loc { fn lookup_pos(@self, pos: uint, lookup: LookupFn) -> Loc {
let {fm: f, line: a} = self.lookup_line(pos, lookup); let {fm: f, line: a} = self.lookup_line(pos, lookup);
return loc {file: f, line: a + 1u, col: pos - lookup(f.lines[a])}; return Loc {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
} }
fn span_to_str_no_adj(@self, sp: span) -> ~str { fn span_to_str_no_adj(@self, sp: span) -> ~str {

2
src/libsyntax/diagnostic.rs
View file

@ -206,7 +206,7 @@ fn emit(cmsp: Option<(@codemap::CodeMap, span)>, msg: &str, lvl: level) {
} }
fn highlight_lines(cm: @codemap::CodeMap, sp: span, fn highlight_lines(cm: @codemap::CodeMap, sp: span,
lines: @codemap::file_lines) { lines: @codemap::FileLines) {
let fm = lines.file; let fm = lines.file;

18
src/libsyntax/ext/base.rs
View file

@ -1,7 +1,7 @@
use std::map::HashMap; use std::map::HashMap;
use parse::parser; use parse::parser;
use diagnostic::span_handler; use diagnostic::span_handler;
use codemap::{CodeMap, span, expn_info, expanded_from}; use codemap::{CodeMap, span, ExpnInfo, ExpandedFrom};
use ast_util::dummy_sp; use ast_util::dummy_sp;
// obsolete old-style #macro code: // obsolete old-style #macro code:
@ -129,11 +129,11 @@ trait ext_ctxt {
fn parse_sess() -> parse::parse_sess; fn parse_sess() -> parse::parse_sess;
fn cfg() -> ast::crate_cfg; fn cfg() -> ast::crate_cfg;
fn print_backtrace(); fn print_backtrace();
fn backtrace() -> Option<@expn_info>; fn backtrace() -> Option<@ExpnInfo>;
fn mod_push(mod_name: ast::ident); fn mod_push(mod_name: ast::ident);
fn mod_pop(); fn mod_pop();
fn mod_path() -> ~[ast::ident]; fn mod_path() -> ~[ast::ident];
fn bt_push(ei: codemap::expn_info); fn bt_push(ei: codemap::ExpnInfo);
fn bt_pop(); fn bt_pop();
fn span_fatal(sp: span, msg: &str) -> !; fn span_fatal(sp: span, msg: &str) -> !;
fn span_err(sp: span, msg: &str); fn span_err(sp: span, msg: &str);
@ -153,7 +153,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
cfg: ast::crate_cfg) -> ext_ctxt { cfg: ast::crate_cfg) -> ext_ctxt {
type ctxt_repr = {parse_sess: parse::parse_sess, type ctxt_repr = {parse_sess: parse::parse_sess,
cfg: ast::crate_cfg, cfg: ast::crate_cfg,
mut backtrace: Option<@expn_info>, mut backtrace: Option<@ExpnInfo>,
mut mod_path: ~[ast::ident], mut mod_path: ~[ast::ident],
mut trace_mac: bool}; mut trace_mac: bool};
impl ctxt_repr: ext_ctxt { impl ctxt_repr: ext_ctxt {
@ -161,15 +161,15 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
fn parse_sess() -> parse::parse_sess { self.parse_sess } fn parse_sess() -> parse::parse_sess { self.parse_sess }
fn cfg() -> ast::crate_cfg { self.cfg } fn cfg() -> ast::crate_cfg { self.cfg }
fn print_backtrace() { } fn print_backtrace() { }
fn backtrace() -> Option<@expn_info> { self.backtrace } fn backtrace() -> Option<@ExpnInfo> { self.backtrace }
fn mod_push(i: ast::ident) { self.mod_path.push(i); } fn mod_push(i: ast::ident) { self.mod_path.push(i); }
fn mod_pop() { self.mod_path.pop(); } fn mod_pop() { self.mod_path.pop(); }
fn mod_path() -> ~[ast::ident] { return self.mod_path; } fn mod_path() -> ~[ast::ident] { return self.mod_path; }
fn bt_push(ei: codemap::expn_info) { fn bt_push(ei: codemap::ExpnInfo) {
match ei { match ei {
expanded_from({call_site: cs, callie: callie}) => { ExpandedFrom({call_site: cs, callie: callie}) => {
self.backtrace = self.backtrace =
Some(@expanded_from({ Some(@ExpandedFrom({
call_site: span {lo: cs.lo, hi: cs.hi, call_site: span {lo: cs.lo, hi: cs.hi,
expn_info: self.backtrace}, expn_info: self.backtrace},
callie: callie})); callie: callie}));
@ -178,7 +178,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
} }
fn bt_pop() { fn bt_pop() {
match self.backtrace { match self.backtrace {
Some(@expanded_from({call_site: span {expn_info: prev, _}, _})) => { Some(@ExpandedFrom({call_site: span {expn_info: prev, _}, _})) => {
self.backtrace = prev self.backtrace = prev
} }
_ => self.bug(~"tried to pop without a push") _ => self.bug(~"tried to pop without a push")

10
src/libsyntax/ext/expand.rs
View file

@ -8,7 +8,7 @@ use ext::qquote::{qq_helper};
use parse::{parser, parse_expr_from_source_str, new_parser_from_tt}; use parse::{parser, parse_expr_from_source_str, new_parser_from_tt};
use codemap::{span, expanded_from}; use codemap::{span, ExpandedFrom};
fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt, fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
e: expr_, s: span, fld: ast_fold, e: expr_, s: span, fld: ast_fold,
@ -41,7 +41,7 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
Some(normal({expander: exp, span: exp_sp})) => { Some(normal({expander: exp, span: exp_sp})) => {
let expanded = exp(cx, mac.span, args, body); let expanded = exp(cx, mac.span, args, body);
cx.bt_push(expanded_from({call_site: s, cx.bt_push(ExpandedFrom({call_site: s,
callie: {name: *extname, span: exp_sp}})); callie: {name: *extname, span: exp_sp}}));
//keep going, outside-in //keep going, outside-in
let fully_expanded = fld.fold_expr(expanded).node; let fully_expanded = fld.fold_expr(expanded).node;
@ -86,7 +86,7 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
*extname)) *extname))
}; };
cx.bt_push(expanded_from({call_site: s, cx.bt_push(ExpandedFrom({call_site: s,
callie: {name: *extname, span: exp_sp}})); callie: {name: *extname, span: exp_sp}}));
//keep going, outside-in //keep going, outside-in
let fully_expanded = fld.fold_expr(expanded).node; let fully_expanded = fld.fold_expr(expanded).node;
@ -100,7 +100,7 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
tts); tts);
let expanded = exp(cx, mac.span, arg, None); let expanded = exp(cx, mac.span, arg, None);
cx.bt_push(expanded_from({call_site: s, cx.bt_push(ExpandedFrom({call_site: s,
callie: {name: *extname, span: exp_sp}})); callie: {name: *extname, span: exp_sp}}));
//keep going, outside-in //keep going, outside-in
let fully_expanded = fld.fold_expr(expanded).node; let fully_expanded = fld.fold_expr(expanded).node;
@ -206,7 +206,7 @@ fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
} }
Some(item_tt(expand)) => { Some(item_tt(expand)) => {
let expanded = expand.expander(cx, it.span, it.ident, tts); let expanded = expand.expander(cx, it.span, it.ident, tts);
cx.bt_push(expanded_from({call_site: it.span, cx.bt_push(ExpandedFrom({call_site: it.span,
callie: {name: *extname, callie: {name: *extname,
span: expand.span}})); span: expand.span}}));
let maybe_it = match expanded { let maybe_it = match expanded {

6
src/libsyntax/ext/qquote.rs
View file

@ -208,7 +208,7 @@ fn finish<T: qq_helper>
debug!("qquote--str==%?", str); debug!("qquote--str==%?", str);
let fname = cm.mk_substr_filename(body.span); let fname = cm.mk_substr_filename(body.span);
let node = parse_from_source_str let node = parse_from_source_str
(f, fname, codemap::fss_internal(body.span), str, (f, fname, codemap::FssInternal(body.span), str,
ecx.cfg(), ecx.parse_sess()); ecx.cfg(), ecx.parse_sess());
let loc = cm.lookup_char_pos(body.span.lo); let loc = cm.lookup_char_pos(body.span.lo);
@ -345,8 +345,8 @@ fn replace_ty(repls: ~[fragment],
} }
fn mk_file_substr(fname: ~str, line: uint, col: uint) -> fn mk_file_substr(fname: ~str, line: uint, col: uint) ->
codemap::file_substr { codemap::FileSubstr {
codemap::fss_external({filename: fname, line: line, col: col}) codemap::FssExternal({filename: fname, line: line, col: col})
} }
// Local Variables: // Local Variables:

4
src/libsyntax/ext/source_util.rs
View file

@ -1,5 +1,5 @@
use base::*; use base::*;
use codemap::{span, loc, filemap}; use codemap::{span, Loc, FileMap};
use print::pprust; use print::pprust;
use build::{mk_base_vec_e,mk_uint,mk_u8,mk_uniq_str}; use build::{mk_base_vec_e,mk_uint,mk_u8,mk_uniq_str};
@ -34,7 +34,7 @@ fn expand_col(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg, fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
_body: ast::mac_body) -> @ast::expr { _body: ast::mac_body) -> @ast::expr {
get_mac_args(cx, sp, arg, 0u, option::Some(0u), ~"file"); get_mac_args(cx, sp, arg, 0u, option::Some(0u), ~"file");
let loc { file: @filemap { name: filename, _ }, _ } = let Loc { file: @FileMap { name: filename, _ }, _ } =
cx.codemap().lookup_char_pos(sp.lo); cx.codemap().lookup_char_pos(sp.lo);
return mk_uniq_str(cx, sp, filename); return mk_uniq_str(cx, sp, filename);
} }

20
src/libsyntax/parse.rs
View file

@ -20,7 +20,7 @@ use util::interner;
use diagnostic::{span_handler, mk_span_handler, mk_handler, emitter}; use diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
use lexer::{reader, string_reader}; use lexer::{reader, string_reader};
use parse::token::{ident_interner, mk_ident_interner}; use parse::token::{ident_interner, mk_ident_interner};
use codemap::{CodeMap, filemap}; use codemap::{CodeMap, FileMap};
type parse_sess = @{ type parse_sess = @{
cm: @codemap::CodeMap, cm: @codemap::CodeMap,
@ -100,7 +100,7 @@ fn parse_crate_from_source_file(input: &Path, cfg: ast::crate_cfg,
fn parse_crate_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, fn parse_crate_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
sess: parse_sess) -> @ast::crate { sess: parse_sess) -> @ast::crate {
let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name, let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name,
codemap::fss_none, source); codemap::FssNone, source);
let r = p.parse_crate_mod(cfg); let r = p.parse_crate_mod(cfg);
p.abort_if_errors(); p.abort_if_errors();
sess.chpos = rdr.chpos; sess.chpos = rdr.chpos;
@ -111,7 +111,7 @@ fn parse_crate_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
fn parse_expr_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, fn parse_expr_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
sess: parse_sess) -> @ast::expr { sess: parse_sess) -> @ast::expr {
let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name, let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name,
codemap::fss_none, source); codemap::FssNone, source);
let r = p.parse_expr(); let r = p.parse_expr();
p.abort_if_errors(); p.abort_if_errors();
sess.chpos = rdr.chpos; sess.chpos = rdr.chpos;
@ -123,7 +123,7 @@ fn parse_item_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
+attrs: ~[ast::attribute], +attrs: ~[ast::attribute],
sess: parse_sess) -> Option<@ast::item> { sess: parse_sess) -> Option<@ast::item> {
let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name, let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name,
codemap::fss_none, source); codemap::FssNone, source);
let r = p.parse_item(attrs); let r = p.parse_item(attrs);
p.abort_if_errors(); p.abort_if_errors();
sess.chpos = rdr.chpos; sess.chpos = rdr.chpos;
@ -135,7 +135,7 @@ fn parse_stmt_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
+attrs: ~[ast::attribute], +attrs: ~[ast::attribute],
sess: parse_sess) -> @ast::stmt { sess: parse_sess) -> @ast::stmt {
let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name, let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name,
codemap::fss_none, source); codemap::FssNone, source);
let r = p.parse_stmt(attrs); let r = p.parse_stmt(attrs);
p.abort_if_errors(); p.abort_if_errors();
sess.chpos = rdr.chpos; sess.chpos = rdr.chpos;
@ -144,7 +144,7 @@ fn parse_stmt_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
} }
fn parse_from_source_str<T>(f: fn (p: Parser) -> T, fn parse_from_source_str<T>(f: fn (p: Parser) -> T,
name: ~str, ss: codemap::file_substr, name: ~str, ss: codemap::FileSubstr,
source: @~str, cfg: ast::crate_cfg, source: @~str, cfg: ast::crate_cfg,
sess: parse_sess) sess: parse_sess)
-> T -> T
@ -170,10 +170,10 @@ fn next_node_id(sess: parse_sess) -> node_id {
} }
fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
+name: ~str, +ss: codemap::file_substr, +name: ~str, +ss: codemap::FileSubstr,
source: @~str) -> (Parser, string_reader) { source: @~str) -> (Parser, string_reader) {
let ftype = parser::SOURCE_FILE; let ftype = parser::SOURCE_FILE;
let filemap = @filemap::new_w_substr let filemap = @FileMap::new_w_substr
(name, ss, source, sess.chpos, sess.byte_pos); (name, ss, source, sess.chpos, sess.byte_pos);
sess.cm.files.push(filemap); sess.cm.files.push(filemap);
let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap, let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap,
@ -182,7 +182,7 @@ fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
} }
fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
+name: ~str, +ss: codemap::file_substr, +name: ~str, +ss: codemap::FileSubstr,
source: @~str) -> Parser { source: @~str) -> Parser {
let (p, _) = new_parser_etc_from_source_str(sess, cfg, name, ss, source); let (p, _) = new_parser_etc_from_source_str(sess, cfg, name, ss, source);
move p move p
@ -198,7 +198,7 @@ fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg,
result::Err(e) => sess.span_diagnostic.handler().fatal(e) result::Err(e) => sess.span_diagnostic.handler().fatal(e)
} }
let src = @result::unwrap(res); let src = @result::unwrap(res);
let filemap = @filemap::new(path.to_str(), src, let filemap = @FileMap::new(path.to_str(), src,
sess.chpos, sess.byte_pos); sess.chpos, sess.byte_pos);
sess.cm.files.push(filemap); sess.cm.files.push(filemap);
let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap, let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap,

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

@ -3,7 +3,7 @@ use io::ReaderUtil;
use util::interner; use util::interner;
use lexer::{string_reader, bump, is_eof, nextch, use lexer::{string_reader, bump, is_eof, nextch,
is_whitespace, get_str_from, reader}; is_whitespace, get_str_from, reader};
use codemap::filemap; use codemap::FileMap;
export cmnt; export cmnt;
export lit; export lit;
@ -289,7 +289,7 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
let src = @str::from_bytes(srdr.read_whole_stream()); let src = @str::from_bytes(srdr.read_whole_stream());
let itr = parse::token::mk_fake_ident_interner(); let itr = parse::token::mk_fake_ident_interner();
let rdr = lexer::new_low_level_string_reader let rdr = lexer::new_low_level_string_reader
(span_diagnostic, @filemap::new(path, src, 0u, 0u), itr); (span_diagnostic, @FileMap::new(path, src, 0u, 0u), itr);
let mut comments: ~[cmnt] = ~[]; let mut comments: ~[cmnt] = ~[];
let mut literals: ~[lit] = ~[]; let mut literals: ~[lit] = ~[];

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

@ -25,7 +25,7 @@ type string_reader = @{
mut pos: uint, mut pos: uint,
mut curr: char, mut curr: char,
mut chpos: uint, mut chpos: uint,
filemap: @codemap::filemap, filemap: @codemap::FileMap,
interner: @token::ident_interner, interner: @token::ident_interner,
/* cached: */ /* cached: */
mut peek_tok: token::Token, mut peek_tok: token::Token,
@ -33,7 +33,7 @@ type string_reader = @{
}; };
fn new_string_reader(span_diagnostic: span_handler, fn new_string_reader(span_diagnostic: span_handler,
filemap: @codemap::filemap, filemap: @codemap::FileMap,
itr: @token::ident_interner) -> string_reader { itr: @token::ident_interner) -> string_reader {
let r = new_low_level_string_reader(span_diagnostic, filemap, itr); let r = new_low_level_string_reader(span_diagnostic, filemap, itr);
string_advance_token(r); /* fill in peek_* */ string_advance_token(r); /* fill in peek_* */
@ -42,7 +42,7 @@ fn new_string_reader(span_diagnostic: span_handler,
/* For comments.rs, which hackily pokes into 'pos' and 'curr' */ /* For comments.rs, which hackily pokes into 'pos' and 'curr' */
fn new_low_level_string_reader(span_diagnostic: span_handler, fn new_low_level_string_reader(span_diagnostic: span_handler,
filemap: @codemap::filemap, filemap: @codemap::FileMap,
itr: @token::ident_interner) itr: @token::ident_interner)
-> string_reader { -> string_reader {
let r = @{span_diagnostic: span_diagnostic, src: filemap.src, let r = @{span_diagnostic: span_diagnostic, src: filemap.src,

2
src/libsyntax/parse/parser.rs
View file

@ -5,7 +5,7 @@ use either::{Either, Left, Right};
use std::map::HashMap; use std::map::HashMap;
use token::{can_begin_expr, is_ident, is_ident_or_path, is_plain_ident, use token::{can_begin_expr, is_ident, is_ident_or_path, is_plain_ident,
INTERPOLATED, special_idents}; INTERPOLATED, special_idents};
use codemap::{span,fss_none}; use codemap::{span,FssNone};
use util::interner::Interner; use util::interner::Interner;
use ast_util::{spanned, respan, mk_sp, ident_to_path, operator_prec}; use ast_util::{spanned, respan, mk_sp, ident_to_path, operator_prec};
use lexer::reader; use lexer::reader;