rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Objectify the codemap

Browse Source
This commit is contained in:
Brian Anderson
2012-11-12 18:24:56 -08:00
parent 15a5d2ccbf
commit 2ec09c4eb9
17 changed files with 204 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

301
src/libsyntax/codemap.rs
View File

@@ -58,6 +58,11 @@ impl file_pos : cmp::Eq {
pure fn ne(other: &file_pos) -> bool { !self.eq(other) }
}
pub struct file_lines {
file: @filemap,
lines: ~[uint]
}
pub enum file_substr {
pub fss_none,
pub fss_internal(span),
@@ -90,173 +95,173 @@ pub impl filemap {
return filemap::new_w_substr(filename, fss_none, src,
start_pos_ch, start_pos_byte);
}
fn next_line(@self, chpos: uint, byte_pos: uint) {
self.lines.push(file_pos {ch: chpos, byte: byte_pos + self.start_pos.byte});
}
pub fn get_line(@self, line: int) -> ~str unsafe {
let begin: uint = self.lines[line].byte - self.start_pos.byte;
let end = match str::find_char_from(*self.src, '\n', begin) {
Some(e) => e,
None => str::len(*self.src)
};
str::slice(*self.src, begin, end)
}
}
pub struct CodeMap {
files: DVec<@filemap>
}
pub fn new_codemap() -> CodeMap {
CodeMap {
files: DVec()
pub impl CodeMap {
static pub fn new() -> CodeMap {
CodeMap {
files: DVec()
}
}
}
pub fn mk_substr_filename(cm: @CodeMap, sp: span) -> ~str
{
let pos = lookup_char_pos(cm, sp.lo);
return fmt!("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
}
pub fn next_line(file: @filemap, chpos: uint, byte_pos: uint) {
file.lines.push(file_pos {ch: chpos, byte: byte_pos + file.start_pos.byte});
}
fn lookup_line(map: @CodeMap, pos: uint, lookup: lookup_fn)
-> {fm: @filemap, line: uint}
{
let len = map.files.len();
let mut a = 0u;
let mut b = len;
while b - a > 1u {
let m = (a + b) / 2u;
if lookup(map.files[m].start_pos) > pos { b = m; } else { a = m; }
pub fn mk_substr_filename(@self, sp: span) -> ~str {
let pos = self.lookup_char_pos(sp.lo);
return fmt!("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
}
if (a >= len) {
fail fmt!("position %u does not resolve to a source location", pos)
pub fn lookup_char_pos(@self, pos: uint) -> loc {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
return self.lookup_pos(pos, lookup);
}
let f = map.files[a];
a = 0u;
b = vec::len(f.lines);
while b - a > 1u {
let m = (a + b) / 2u;
if lookup(f.lines[m]) > pos { b = m; } else { a = m; }
pub fn lookup_byte_pos(@self, pos: uint) -> loc {
pure fn lookup(pos: file_pos) -> uint { return pos.byte; }
return self.lookup_pos(pos, lookup);
}
return {fm: f, line: a};
}
fn lookup_pos(map: @CodeMap, pos: uint, lookup: lookup_fn) -> loc {
let {fm: f, line: a} = lookup_line(map, pos, lookup);
return loc {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
}
pub fn lookup_char_pos(map: @CodeMap, pos: uint) -> loc {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
return lookup_pos(map, pos, lookup);
}
fn lookup_byte_pos(map: @CodeMap, pos: uint) -> loc {
pure fn lookup(pos: file_pos) -> uint { return pos.byte; }
return lookup_pos(map, pos, lookup);
}
pub fn lookup_char_pos_adj(map: @CodeMap, pos: uint)
-> {filename: ~str, line: uint, col: uint, file: Option<@filemap>}
{
let loc = lookup_char_pos(map, pos);
match (loc.file.substr) {
fss_none => {
{filename: /* FIXME (#2543) */ copy loc.file.name,
line: loc.line,
col: loc.col,
file: Some(loc.file)}
}
fss_internal(sp) => {
lookup_char_pos_adj(map, sp.lo + (pos - loc.file.start_pos.ch))
}
fss_external(eloc) => {
{filename: /* FIXME (#2543) */ copy eloc.filename,
line: eloc.line + loc.line - 1u,
col: if loc.line == 1u {eloc.col + loc.col} else {loc.col},
file: None}
}
pub fn lookup_char_pos_adj(@self, pos: uint)
-> {filename: ~str, line: uint, col: uint, file: Option<@filemap>}
{
let loc = self.lookup_char_pos(pos);
match (loc.file.substr) {
fss_none => {
{filename: /* FIXME (#2543) */ copy loc.file.name,
line: loc.line,
col: loc.col,
file: Some(loc.file)}
}
fss_internal(sp) => {
self.lookup_char_pos_adj(sp.lo + (pos - loc.file.start_pos.ch))
}
fss_external(eloc) => {
{filename: /* FIXME (#2543) */ copy eloc.filename,
line: eloc.line + loc.line - 1u,
col: if loc.line == 1u {eloc.col + loc.col} else {loc.col},
file: None}
}
}
}
}
pub fn adjust_span(map: @CodeMap, sp: span) -> span {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
let line = lookup_line(map, sp.lo, lookup);
match (line.fm.substr) {
fss_none => sp,
fss_internal(s) => {
adjust_span(map, span {lo: s.lo + (sp.lo - line.fm.start_pos.ch),
hi: s.lo + (sp.hi - line.fm.start_pos.ch),
expn_info: sp.expn_info})}
fss_external(_) => sp
pub fn adjust_span(@self, sp: span) -> span {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
let line = self.lookup_line(sp.lo, lookup);
match (line.fm.substr) {
fss_none => sp,
fss_internal(s) => {
self.adjust_span(span {lo: s.lo + (sp.lo - line.fm.start_pos.ch),
hi: s.lo + (sp.hi - line.fm.start_pos.ch),
expn_info: sp.expn_info})}
fss_external(_) => sp
}
}
pub fn span_to_str(@self, sp: span) -> ~str {
let lo = self.lookup_char_pos_adj(sp.lo);
let hi = self.lookup_char_pos_adj(sp.hi);
return fmt!("%s:%u:%u: %u:%u", lo.filename,
lo.line, lo.col, hi.line, hi.col)
}
pub fn span_to_filename(@self, sp: span) -> filename {
let lo = self.lookup_char_pos(sp.lo);
return /* FIXME (#2543) */ copy lo.file.name;
}
pub fn span_to_lines(@self, sp: span) -> @file_lines {
let lo = self.lookup_char_pos(sp.lo);
let hi = self.lookup_char_pos(sp.hi);
let mut lines = ~[];
for uint::range(lo.line - 1u, hi.line as uint) |i| {
lines.push(i);
};
return @file_lines {file: lo.file, lines: lines};
}
fn lookup_byte_offset(@self, chpos: uint)
-> {fm: @filemap, pos: uint} {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
let {fm, line} = self.lookup_line(chpos, lookup);
let line_offset = fm.lines[line].byte - fm.start_pos.byte;
let col = chpos - fm.lines[line].ch;
let col_offset = str::count_bytes(*fm.src, line_offset, col);
{fm: fm, pos: line_offset + col_offset}
}
pub fn span_to_snippet(@self, sp: span) -> ~str {
let begin = self.lookup_byte_offset(sp.lo);
let end = self.lookup_byte_offset(sp.hi);
assert begin.fm.start_pos == end.fm.start_pos;
return str::slice(*begin.fm.src, begin.pos, end.pos);
}
pub fn get_snippet(@self, fidx: uint, lo: uint, hi: uint) -> ~str
{
let fm = self.files[fidx];
return str::slice(*fm.src, lo, hi)
}
pub fn get_filemap(@self, filename: ~str) -> @filemap {
for self.files.each |fm| { if fm.name == filename { return *fm; } }
//XXjdm the following triggers a mismatched type bug
// (or expected function, found _|_)
fail; // ("asking for " + filename + " which we don't know about");
}
}
fn span_to_str_no_adj(sp: span, cm: @CodeMap) -> ~str {
let lo = lookup_char_pos(cm, sp.lo);
let hi = lookup_char_pos(cm, sp.hi);
return fmt!("%s:%u:%u: %u:%u", lo.file.name,
lo.line, lo.col, hi.line, hi.col)
}
priv impl CodeMap {
fn lookup_line(@self, pos: uint, lookup: lookup_fn)
-> {fm: @filemap, line: uint}
{
let len = self.files.len();
let mut a = 0u;
let mut b = len;
while b - a > 1u {
let m = (a + b) / 2u;
if lookup(self.files[m].start_pos) > pos { b = m; } else { a = m; }
}
if (a >= len) {
fail fmt!("position %u does not resolve to a source location", pos)
}
let f = self.files[a];
a = 0u;
b = vec::len(f.lines);
while b - a > 1u {
let m = (a + b) / 2u;
if lookup(f.lines[m]) > pos { b = m; } else { a = m; }
}
return {fm: f, line: a};
}
pub fn span_to_str(sp: span, cm: @CodeMap) -> ~str {
let lo = lookup_char_pos_adj(cm, sp.lo);
let hi = lookup_char_pos_adj(cm, sp.hi);
return fmt!("%s:%u:%u: %u:%u", lo.filename,
lo.line, lo.col, hi.line, hi.col)
}
fn lookup_pos(@self, pos: uint, lookup: lookup_fn) -> loc {
let {fm: f, line: a} = self.lookup_line(pos, lookup);
return loc {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
}
pub struct file_lines {
file: @filemap,
lines: ~[uint]
}
pub fn span_to_filename(sp: span, cm: @codemap::CodeMap) -> filename {
let lo = lookup_char_pos(cm, sp.lo);
return /* FIXME (#2543) */ copy lo.file.name;
}
pub fn span_to_lines(sp: span, cm: @codemap::CodeMap) -> @file_lines {
let lo = lookup_char_pos(cm, sp.lo);
let hi = lookup_char_pos(cm, sp.hi);
let mut lines = ~[];
for uint::range(lo.line - 1u, hi.line as uint) |i| {
lines.push(i);
};
return @file_lines {file: lo.file, lines: lines};
}
pub fn get_line(fm: @filemap, line: int) -> ~str unsafe {
let begin: uint = fm.lines[line].byte - fm.start_pos.byte;
let end = match str::find_char_from(*fm.src, '\n', begin) {
Some(e) => e,
None => str::len(*fm.src)
};
str::slice(*fm.src, begin, end)
}
fn lookup_byte_offset(cm: @codemap::CodeMap, chpos: uint)
-> {fm: @filemap, pos: uint} {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
let {fm, line} = lookup_line(cm, chpos, lookup);
let line_offset = fm.lines[line].byte - fm.start_pos.byte;
let col = chpos - fm.lines[line].ch;
let col_offset = str::count_bytes(*fm.src, line_offset, col);
{fm: fm, pos: line_offset + col_offset}
}
pub fn span_to_snippet(sp: span, cm: @codemap::CodeMap) -> ~str {
let begin = lookup_byte_offset(cm, sp.lo);
let end = lookup_byte_offset(cm, sp.hi);
assert begin.fm.start_pos == end.fm.start_pos;
return str::slice(*begin.fm.src, begin.pos, end.pos);
}
pub fn get_snippet(cm: @codemap::CodeMap, fidx: uint, lo: uint, hi: uint) -> ~str
{
let fm = cm.files[fidx];
return str::slice(*fm.src, lo, hi)
}
pub fn get_filemap(cm: @CodeMap, filename: ~str) -> @filemap {
for cm.files.each |fm| { if fm.name == filename { return *fm; } }
//XXjdm the following triggers a mismatched type bug
// (or expected function, found _|_)
fail; // ("asking for " + filename + " which we don't know about");
fn span_to_str_no_adj(@self, sp: span) -> ~str {
let lo = self.lookup_char_pos(sp.lo);
let hi = self.lookup_char_pos(sp.hi);
return fmt!("%s:%u:%u: %u:%u", lo.file.name,
lo.line, lo.col, hi.line, hi.col)
}
}
//