2012-08-27 16:22:25 -05:00
|
|
|
import dvec::DVec;
|
2012-05-15 15:40:18 -05:00
|
|
|
|
2012-04-15 06:34:51 -05:00
|
|
|
export filename;
|
|
|
|
export filemap;
|
|
|
|
export span;
|
|
|
|
export file_substr;
|
2012-05-22 12:54:12 -05:00
|
|
|
export fss_none;
|
|
|
|
export fss_internal;
|
|
|
|
export fss_external;
|
2012-04-15 06:34:51 -05:00
|
|
|
export codemap;
|
|
|
|
export expn_info;
|
|
|
|
export expn_info_;
|
|
|
|
export expanded_from;
|
|
|
|
export new_filemap;
|
|
|
|
export new_filemap_w_substr;
|
|
|
|
export mk_substr_filename;
|
|
|
|
export lookup_char_pos;
|
2012-05-22 19:27:20 -05:00
|
|
|
export lookup_char_pos_adj;
|
2012-04-15 06:34:51 -05:00
|
|
|
export adjust_span;
|
|
|
|
export span_to_str;
|
2012-05-10 19:18:04 -05:00
|
|
|
export span_to_filename;
|
2012-04-15 06:34:51 -05:00
|
|
|
export span_to_lines;
|
|
|
|
export file_lines;
|
|
|
|
export get_line;
|
|
|
|
export next_line;
|
|
|
|
export span_to_snippet;
|
|
|
|
export loc;
|
|
|
|
export get_filemap;
|
|
|
|
export new_codemap;
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
type filename = ~str;
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
type file_pos = {ch: uint, byte: uint};
|
2011-07-16 01:01:10 -05:00
|
|
|
|
2011-07-05 04:48:19 -05:00
|
|
|
/* A codemap is a thing that maps uints to file/line/column positions
|
|
|
|
* in a crate. This to make it possible to represent the positions
|
|
|
|
* with single-word things, rather than passing records all over the
|
|
|
|
* compiler.
|
|
|
|
*/
|
2012-02-01 04:37:53 -06:00
|
|
|
|
2012-02-10 04:03:21 -06:00
|
|
|
enum file_substr {
|
|
|
|
fss_none,
|
|
|
|
fss_internal(span),
|
2012-07-14 00:57:48 -05:00
|
|
|
fss_external({filename: ~str, line: uint, col: uint})
|
2012-02-10 04:03:21 -06:00
|
|
|
}
|
2012-02-01 04:37:53 -06:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
type filemap =
|
2012-07-14 00:57:48 -05:00
|
|
|
@{name: filename, substr: file_substr, src: @~str,
|
2012-06-29 18:26:56 -05:00
|
|
|
start_pos: file_pos, mut lines: ~[file_pos]};
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-08-14 18:54:13 -05:00
|
|
|
type codemap = @{files: DVec<filemap>};
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-02-01 03:18:59 -06:00
|
|
|
type loc = {file: filemap, line: uint, col: uint};
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-08-27 16:22:25 -05:00
|
|
|
fn new_codemap() -> codemap { @{files: DVec()} }
|
2011-07-16 01:01:10 -05:00
|
|
|
|
2012-06-07 22:12:05 -05:00
|
|
|
fn new_filemap_w_substr(+filename: filename, +substr: file_substr,
|
2012-07-14 00:57:48 -05:00
|
|
|
src: @~str,
|
2012-02-01 04:37:53 -06:00
|
|
|
start_pos_ch: uint, start_pos_byte: uint)
|
2011-07-27 07:19:39 -05:00
|
|
|
-> filemap {
|
2012-08-01 19:30:05 -05:00
|
|
|
return @{name: filename, substr: substr, src: src,
|
2011-07-27 07:19:39 -05:00
|
|
|
start_pos: {ch: start_pos_ch, byte: start_pos_byte},
|
2012-06-29 18:26:56 -05:00
|
|
|
mut lines: ~[{ch: start_pos_ch, byte: start_pos_byte}]};
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn new_filemap(+filename: filename, src: @~str,
|
2012-02-01 04:37:53 -06:00
|
|
|
start_pos_ch: uint, start_pos_byte: uint)
|
|
|
|
-> filemap {
|
2012-08-01 19:30:05 -05:00
|
|
|
return new_filemap_w_substr(filename, fss_none, src,
|
2012-02-01 04:37:53 -06:00
|
|
|
start_pos_ch, start_pos_byte);
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn mk_substr_filename(cm: codemap, sp: span) -> ~str
|
2012-02-01 04:37:53 -06:00
|
|
|
{
|
2012-02-10 04:03:21 -06:00
|
|
|
let pos = lookup_char_pos(cm, sp.lo);
|
2012-08-22 19:24:52 -05:00
|
|
|
return fmt!("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
|
2012-02-01 04:37:53 -06:00
|
|
|
}
|
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
fn next_line(file: filemap, chpos: uint, byte_pos: uint) {
|
2012-06-26 02:39:18 -05:00
|
|
|
vec::push(file.lines, {ch: chpos, byte: byte_pos + file.start_pos.byte});
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
2012-06-02 22:50:21 -05:00
|
|
|
type lookup_fn = pure fn(file_pos) -> uint;
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-01-25 15:22:10 -06:00
|
|
|
fn lookup_line(map: codemap, pos: uint, lookup: lookup_fn)
|
2012-02-03 19:39:39 -06:00
|
|
|
-> {fm: filemap, line: uint}
|
2012-01-25 15:22:10 -06:00
|
|
|
{
|
2012-05-15 15:40:18 -05:00
|
|
|
let len = map.files.len();
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut a = 0u;
|
|
|
|
let mut b = len;
|
2011-07-27 07:19:39 -05:00
|
|
|
while b - a > 1u {
|
|
|
|
let m = (a + b) / 2u;
|
2011-08-19 17:16:48 -05:00
|
|
|
if lookup(map.files[m].start_pos) > pos { b = m; } else { a = m; }
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
2012-01-21 03:00:06 -06:00
|
|
|
if (a >= len) {
|
2012-08-22 19:24:52 -05:00
|
|
|
fail fmt!("position %u does not resolve to a source location", pos)
|
2012-01-21 03:00:06 -06:00
|
|
|
}
|
2011-08-19 17:16:48 -05:00
|
|
|
let f = map.files[a];
|
2011-07-05 04:48:19 -05:00
|
|
|
a = 0u;
|
2011-08-15 18:38:23 -05:00
|
|
|
b = vec::len(f.lines);
|
2011-07-27 07:19:39 -05:00
|
|
|
while b - a > 1u {
|
|
|
|
let m = (a + b) / 2u;
|
2011-08-19 17:16:48 -05:00
|
|
|
if lookup(f.lines[m]) > pos { b = m; } else { a = m; }
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
2012-08-01 19:30:05 -05:00
|
|
|
return {fm: f, line: a};
|
2012-01-25 15:22:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn lookup_pos(map: codemap, pos: uint, lookup: lookup_fn) -> loc {
|
2012-02-03 19:39:39 -06:00
|
|
|
let {fm: f, line: a} = lookup_line(map, pos, lookup);
|
2012-08-01 19:30:05 -05:00
|
|
|
return {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
|
2011-07-16 01:01:10 -05:00
|
|
|
}
|
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
fn lookup_char_pos(map: codemap, pos: uint) -> loc {
|
2012-08-01 19:30:05 -05:00
|
|
|
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
|
|
|
|
return lookup_pos(map, pos, lookup);
|
2011-07-16 01:01:10 -05:00
|
|
|
}
|
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
fn lookup_byte_pos(map: codemap, pos: uint) -> loc {
|
2012-08-01 19:30:05 -05:00
|
|
|
pure fn lookup(pos: file_pos) -> uint { return pos.byte; }
|
|
|
|
return lookup_pos(map, pos, lookup);
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
2012-02-10 12:28:43 -06:00
|
|
|
fn lookup_char_pos_adj(map: codemap, pos: uint)
|
2012-08-20 14:23:37 -05:00
|
|
|
-> {filename: ~str, line: uint, col: uint, file: Option<filemap>}
|
2012-02-10 12:28:43 -06:00
|
|
|
{
|
|
|
|
let loc = lookup_char_pos(map, pos);
|
2012-08-06 14:34:08 -05:00
|
|
|
match (loc.file.substr) {
|
2012-08-03 21:59:04 -05:00
|
|
|
fss_none => {
|
2012-06-21 18:44:10 -05:00
|
|
|
{filename: /* FIXME (#2543) */ copy loc.file.name,
|
2012-06-07 22:12:05 -05:00
|
|
|
line: loc.line,
|
|
|
|
col: loc.col,
|
2012-08-20 14:23:37 -05:00
|
|
|
file: Some(loc.file)}
|
2012-02-10 12:28:43 -06:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
fss_internal(sp) => {
|
2012-02-10 12:28:43 -06:00
|
|
|
lookup_char_pos_adj(map, sp.lo + (pos - loc.file.start_pos.ch))
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
fss_external(eloc) => {
|
2012-06-21 18:44:10 -05:00
|
|
|
{filename: /* FIXME (#2543) */ copy eloc.filename,
|
2012-02-10 12:28:43 -06:00
|
|
|
line: eloc.line + loc.line - 1u,
|
|
|
|
col: if loc.line == 1u {eloc.col + loc.col} else {loc.col},
|
2012-08-20 14:23:37 -05:00
|
|
|
file: None}
|
2012-02-10 12:28:43 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn adjust_span(map: codemap, sp: span) -> span {
|
2012-08-01 19:30:05 -05:00
|
|
|
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
|
2012-02-10 12:28:43 -06:00
|
|
|
let line = lookup_line(map, sp.lo, lookup);
|
2012-08-06 14:34:08 -05:00
|
|
|
match (line.fm.substr) {
|
2012-08-03 21:59:04 -05:00
|
|
|
fss_none => sp,
|
|
|
|
fss_internal(s) => {
|
2012-02-10 12:28:43 -06:00
|
|
|
adjust_span(map, {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})}
|
2012-08-03 21:59:04 -05:00
|
|
|
fss_external(_) => sp
|
2012-02-10 12:28:43 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-04 19:37:24 -06:00
|
|
|
enum expn_info_ {
|
|
|
|
expanded_from({call_site: span,
|
2012-08-20 14:23:37 -05:00
|
|
|
callie: {name: ~str, span: Option<span>}})
|
2011-08-12 10:57:21 -05:00
|
|
|
}
|
2012-08-20 14:23:37 -05:00
|
|
|
type expn_info = Option<@expn_info_>;
|
2012-02-04 19:37:24 -06:00
|
|
|
type span = {lo: uint, hi: uint, expn_info: expn_info};
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn span_to_str_no_adj(sp: span, cm: codemap) -> ~str {
|
2012-02-04 19:37:24 -06:00
|
|
|
let lo = lookup_char_pos(cm, sp.lo);
|
|
|
|
let hi = lookup_char_pos(cm, sp.hi);
|
2012-08-22 19:24:52 -05:00
|
|
|
return fmt!("%s:%u:%u: %u:%u", lo.file.name,
|
|
|
|
lo.line, lo.col, hi.line, hi.col)
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn span_to_str(sp: span, cm: codemap) -> ~str {
|
2012-02-10 12:28:43 -06:00
|
|
|
let lo = lookup_char_pos_adj(cm, sp.lo);
|
|
|
|
let hi = lookup_char_pos_adj(cm, sp.hi);
|
2012-08-22 19:24:52 -05:00
|
|
|
return fmt!("%s:%u:%u: %u:%u", lo.filename,
|
|
|
|
lo.line, lo.col, hi.line, hi.col)
|
2012-02-10 12:28:43 -06:00
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
type file_lines = {file: filemap, lines: ~[uint]};
|
2011-07-11 01:27:03 -05:00
|
|
|
|
2012-05-10 19:18:04 -05:00
|
|
|
fn span_to_filename(sp: span, cm: codemap::codemap) -> filename {
|
|
|
|
let lo = lookup_char_pos(cm, sp.lo);
|
2012-08-01 19:30:05 -05:00
|
|
|
return /* FIXME (#2543) */ copy lo.file.name;
|
2012-05-10 19:18:04 -05:00
|
|
|
}
|
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
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);
|
2012-06-29 18:26:56 -05:00
|
|
|
let mut lines = ~[];
|
2012-06-30 18:19:07 -05:00
|
|
|
for uint::range(lo.line - 1u, hi.line as uint) |i| {
|
2012-06-26 02:39:18 -05:00
|
|
|
vec::push(lines, i);
|
|
|
|
};
|
2012-08-01 19:30:05 -05:00
|
|
|
return @{file: lo.file, lines: lines};
|
2011-07-11 01:27:03 -05:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn get_line(fm: filemap, line: int) -> ~str unsafe {
|
2011-08-19 17:16:48 -05:00
|
|
|
let begin: uint = fm.lines[line].byte - fm.start_pos.byte;
|
2012-08-06 14:34:08 -05:00
|
|
|
let end = match str::find_char_from(*fm.src, '\n', begin) {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(e) => e,
|
|
|
|
None => str::len(*fm.src)
|
2012-02-15 03:19:51 -06:00
|
|
|
};
|
2012-02-23 02:45:25 -06:00
|
|
|
str::slice(*fm.src, begin, end)
|
2011-07-11 01:27:03 -05:00
|
|
|
}
|
|
|
|
|
2012-01-25 15:22:10 -06:00
|
|
|
fn lookup_byte_offset(cm: codemap::codemap, chpos: uint)
|
2012-02-23 09:59:30 -06:00
|
|
|
-> {fm: filemap, pos: uint} {
|
2012-08-01 19:30:05 -05:00
|
|
|
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
|
2012-06-02 22:50:21 -05:00
|
|
|
let {fm, line} = lookup_line(cm, chpos, lookup);
|
2012-02-01 02:35:11 -06:00
|
|
|
let line_offset = fm.lines[line].byte - fm.start_pos.byte;
|
2012-01-25 15:22:10 -06:00
|
|
|
let col = chpos - fm.lines[line].ch;
|
2012-02-23 09:59:30 -06:00
|
|
|
let col_offset = str::count_bytes(*fm.src, line_offset, col);
|
|
|
|
{fm: fm, pos: line_offset + col_offset}
|
2012-01-25 15:22:10 -06:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn span_to_snippet(sp: span, cm: codemap::codemap) -> ~str {
|
2012-02-23 06:41:10 -06:00
|
|
|
let begin = lookup_byte_offset(cm, sp.lo);
|
|
|
|
let end = lookup_byte_offset(cm, sp.hi);
|
2012-01-25 15:22:10 -06:00
|
|
|
assert begin.fm == end.fm;
|
2012-08-01 19:30:05 -05:00
|
|
|
return str::slice(*begin.fm.src, begin.pos, end.pos);
|
2012-01-25 15:22:10 -06:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn get_snippet(cm: codemap::codemap, fidx: uint, lo: uint, hi: uint) -> ~str
|
2012-01-25 15:22:10 -06:00
|
|
|
{
|
|
|
|
let fm = cm.files[fidx];
|
2012-08-01 19:30:05 -05:00
|
|
|
return str::slice(*fm.src, lo, hi)
|
2012-01-25 15:22:10 -06:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn get_filemap(cm: codemap, filename: ~str) -> filemap {
|
2012-08-01 19:30:05 -05:00
|
|
|
for cm.files.each |fm| { if fm.name == filename { return fm; } }
|
2011-07-11 01:27:03 -05:00
|
|
|
//XXjdm the following triggers a mismatched type bug
|
|
|
|
// (or expected function, found _|_)
|
2011-07-27 07:19:39 -05:00
|
|
|
fail; // ("asking for " + filename + " which we don't know about");
|
2011-07-11 01:27:03 -05:00
|
|
|
}
|
2012-01-26 03:52:08 -06:00
|
|
|
|
2011-07-05 04:48:19 -05:00
|
|
|
//
|
|
|
|
// Local Variables:
|
|
|
|
// mode: rust
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|
|
|
|
//
|