2012-12-03 18:48:01 -06:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
/*!
|
|
|
|
|
|
|
|
The CodeMap tracks all the source code used within a single crate, mapping
|
|
|
|
from integer byte positions to the original source code location. Each bit of
|
|
|
|
source parsed during crate parsing (typically files, in-memory strings, or
|
|
|
|
various bits of macro expansion) cover a continuous range of bytes in the
|
|
|
|
CodeMap and are represented by FileMaps. Byte positions are stored in `spans`
|
|
|
|
and used pervasively in the compiler. They are absolute positions within the
|
|
|
|
CodeMap, which upon request can be converted to line and column information,
|
|
|
|
source code snippets, etc.
|
|
|
|
|
|
|
|
*/
|
2012-11-12 18:45:24 -06:00
|
|
|
|
2012-09-04 13:37:29 -05:00
|
|
|
use dvec::DVec;
|
2012-10-18 15:29:34 -05:00
|
|
|
use std::serialization::{Serializable,
|
|
|
|
Deserializable,
|
|
|
|
Serializer,
|
|
|
|
Deserializer};
|
2012-05-15 15:40:18 -05:00
|
|
|
|
2012-11-12 21:32:48 -06:00
|
|
|
trait Pos {
|
|
|
|
static pure fn from_uint(n: uint) -> self;
|
|
|
|
pure fn to_uint(&self) -> uint;
|
|
|
|
}
|
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
/// A byte offset
|
2012-11-12 21:32:48 -06:00
|
|
|
pub enum BytePos = uint;
|
2012-11-16 17:14:11 -06:00
|
|
|
/// A character offset. Because of multibyte utf8 characters, a byte offset
|
|
|
|
/// is not equivalent to a character offset. The CodeMap will convert BytePos
|
|
|
|
/// values to CharPos values as necessary.
|
2012-11-12 21:32:48 -06:00
|
|
|
pub enum CharPos = uint;
|
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
// XXX: Lots of boilerplate in these impls, but so far my attempts to fix
|
|
|
|
// have been unsuccessful
|
|
|
|
|
2012-11-12 21:32:48 -06:00
|
|
|
impl BytePos: Pos {
|
|
|
|
static pure fn from_uint(n: uint) -> BytePos { BytePos(n) }
|
|
|
|
pure fn to_uint(&self) -> uint { **self }
|
|
|
|
}
|
|
|
|
|
2012-11-14 20:59:30 -06:00
|
|
|
impl BytePos: cmp::Eq {
|
|
|
|
pure fn eq(&self, other: &BytePos) -> bool { **self == **other }
|
|
|
|
pure fn ne(&self, other: &BytePos) -> bool { !(*self).eq(other) }
|
|
|
|
}
|
|
|
|
|
|
|
|
impl BytePos: cmp::Ord {
|
|
|
|
pure fn lt(&self, other: &BytePos) -> bool { **self < **other }
|
|
|
|
pure fn le(&self, other: &BytePos) -> bool { **self <= **other }
|
|
|
|
pure fn ge(&self, other: &BytePos) -> bool { **self >= **other }
|
|
|
|
pure fn gt(&self, other: &BytePos) -> bool { **self > **other }
|
|
|
|
}
|
|
|
|
|
2012-11-12 21:32:48 -06:00
|
|
|
impl BytePos: Num {
|
|
|
|
pure fn add(other: &BytePos) -> BytePos {
|
|
|
|
BytePos(*self + **other)
|
|
|
|
}
|
|
|
|
pure fn sub(other: &BytePos) -> BytePos {
|
|
|
|
BytePos(*self - **other)
|
|
|
|
}
|
|
|
|
pure fn mul(other: &BytePos) -> BytePos {
|
|
|
|
BytePos(*self * (**other))
|
|
|
|
}
|
|
|
|
pure fn div(other: &BytePos) -> BytePos {
|
|
|
|
BytePos(*self / **other)
|
|
|
|
}
|
|
|
|
pure fn modulo(other: &BytePos) -> BytePos {
|
|
|
|
BytePos(*self % **other)
|
|
|
|
}
|
|
|
|
pure fn neg() -> BytePos {
|
|
|
|
BytePos(-*self)
|
|
|
|
}
|
|
|
|
pure fn to_int() -> int { *self as int }
|
|
|
|
static pure fn from_int(+n: int) -> BytePos { BytePos(n as uint) }
|
|
|
|
}
|
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl BytePos: to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(**self).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-12 21:32:48 -06:00
|
|
|
impl CharPos: Pos {
|
|
|
|
static pure fn from_uint(n: uint) -> CharPos { CharPos(n) }
|
|
|
|
pure fn to_uint(&self) -> uint { **self }
|
|
|
|
}
|
|
|
|
|
2012-11-14 20:59:30 -06:00
|
|
|
impl CharPos: cmp::Eq {
|
|
|
|
pure fn eq(&self, other: &CharPos) -> bool { **self == **other }
|
|
|
|
pure fn ne(&self, other: &CharPos) -> bool { !(*self).eq(other) }
|
|
|
|
}
|
|
|
|
|
|
|
|
impl CharPos: cmp::Ord {
|
|
|
|
pure fn lt(&self, other: &CharPos) -> bool { **self < **other }
|
|
|
|
pure fn le(&self, other: &CharPos) -> bool { **self <= **other }
|
|
|
|
pure fn ge(&self, other: &CharPos) -> bool { **self >= **other }
|
|
|
|
pure fn gt(&self, other: &CharPos) -> bool { **self > **other }
|
|
|
|
}
|
|
|
|
|
2012-11-12 21:32:48 -06:00
|
|
|
impl CharPos: Num {
|
|
|
|
pure fn add(other: &CharPos) -> CharPos {
|
|
|
|
CharPos(*self + **other)
|
|
|
|
}
|
|
|
|
pure fn sub(other: &CharPos) -> CharPos {
|
|
|
|
CharPos(*self - **other)
|
|
|
|
}
|
|
|
|
pure fn mul(other: &CharPos) -> CharPos {
|
|
|
|
CharPos(*self * (**other))
|
|
|
|
}
|
|
|
|
pure fn div(other: &CharPos) -> CharPos {
|
|
|
|
CharPos(*self / **other)
|
|
|
|
}
|
|
|
|
pure fn modulo(other: &CharPos) -> CharPos {
|
|
|
|
CharPos(*self % **other)
|
|
|
|
}
|
|
|
|
pure fn neg() -> CharPos {
|
|
|
|
CharPos(-*self)
|
|
|
|
}
|
|
|
|
pure fn to_int() -> int { *self as int }
|
|
|
|
static pure fn from_int(+n: int) -> CharPos { CharPos(n as uint) }
|
|
|
|
}
|
|
|
|
|
2012-11-28 13:36:04 -06:00
|
|
|
impl CharPos: to_bytes::IterBytes {
|
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
|
|
|
|
(**self).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
2012-11-12 20:35:17 -06:00
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
/**
|
|
|
|
Spans represent a region of code, used for error reporting. Positions in spans
|
|
|
|
are *absolute* positions from the beginning of the codemap, not positions
|
|
|
|
relative to FileMaps. Methods on the CodeMap can be used to relate spans back
|
|
|
|
to the original source.
|
|
|
|
*/
|
2012-11-12 19:26:02 -06:00
|
|
|
pub struct span {
|
2012-11-15 21:37:29 -06:00
|
|
|
lo: BytePos,
|
|
|
|
hi: BytePos,
|
2012-11-12 20:59:37 -06:00
|
|
|
expn_info: Option<@ExpnInfo>
|
2012-11-12 19:19:56 -06:00
|
|
|
}
|
2012-11-12 19:14:15 -06:00
|
|
|
|
|
|
|
impl span : cmp::Eq {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &span) -> bool {
|
|
|
|
return (*self).lo == (*other).lo && (*self).hi == (*other).hi;
|
|
|
|
}
|
|
|
|
pure fn ne(&self, other: &span) -> bool { !(*self).eq(other) }
|
2012-11-12 19:14:15 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<S: Serializer> span: Serializable<S> {
|
|
|
|
/* Note #1972 -- spans are serialized but not deserialized */
|
|
|
|
fn serialize(&self, _s: &S) { }
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<D: Deserializer> span: Deserializable<D> {
|
|
|
|
static fn deserialize(_d: &D) -> span {
|
|
|
|
ast_util::dummy_sp()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
/// A source code location used for error reporting
|
2012-11-15 21:37:29 -06:00
|
|
|
pub struct Loc {
|
2012-11-16 17:14:11 -06:00
|
|
|
/// Information about the original source
|
|
|
|
file: @FileMap,
|
|
|
|
/// The (1-based) line number
|
|
|
|
line: uint,
|
|
|
|
/// The (0-based) column offset
|
|
|
|
col: CharPos
|
2012-11-12 19:14:15 -06:00
|
|
|
}
|
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
/// Extra information for tracking macro expansion of spans
|
2012-11-12 20:59:37 -06:00
|
|
|
pub enum ExpnInfo {
|
|
|
|
ExpandedFrom({call_site: span,
|
|
|
|
callie: {name: ~str, span: Option<span>}})
|
2012-11-12 20:35:17 -06:00
|
|
|
}
|
|
|
|
|
2012-11-12 20:59:37 -06:00
|
|
|
pub type FileName = ~str;
|
2012-11-12 20:35:17 -06:00
|
|
|
|
2012-11-12 20:59:37 -06:00
|
|
|
pub struct FileLines {
|
|
|
|
file: @FileMap,
|
2012-11-12 20:24:56 -06:00
|
|
|
lines: ~[uint]
|
|
|
|
}
|
|
|
|
|
2012-11-12 20:59:37 -06:00
|
|
|
pub enum FileSubstr {
|
|
|
|
pub FssNone,
|
|
|
|
pub FssInternal(span),
|
2012-11-12 21:32:48 -06:00
|
|
|
pub FssExternal({filename: ~str, line: uint, col: CharPos})
|
2012-02-10 04:03:21 -06:00
|
|
|
}
|
2012-02-01 04:37:53 -06:00
|
|
|
|
2012-11-15 21:37:29 -06:00
|
|
|
/// Identifies an offset of a multi-byte character in a FileMap
|
|
|
|
pub struct MultiByteChar {
|
|
|
|
/// The absolute offset of the character in the CodeMap
|
|
|
|
pos: BytePos,
|
|
|
|
/// The number of bytes, >=2
|
|
|
|
bytes: uint,
|
|
|
|
}
|
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
/// A single source in the CodeMap
|
2012-11-12 20:59:37 -06:00
|
|
|
pub struct FileMap {
|
2012-11-16 17:14:11 -06:00
|
|
|
/// The name of the file that the source came from, source that doesn't
|
|
|
|
/// originate from files has names between angle brackets by convention,
|
|
|
|
/// e.g. `<anon>`
|
2012-11-12 20:59:37 -06:00
|
|
|
name: FileName,
|
2012-11-16 17:14:11 -06:00
|
|
|
/// Extra information used by qquote
|
2012-11-12 20:59:37 -06:00
|
|
|
substr: FileSubstr,
|
2012-11-16 17:14:11 -06:00
|
|
|
/// The complete source code
|
2012-11-12 18:47:17 -06:00
|
|
|
src: @~str,
|
2012-11-16 17:14:11 -06:00
|
|
|
/// The start position of this source in the CodeMap
|
2012-11-16 16:10:17 -06:00
|
|
|
start_pos: BytePos,
|
2012-11-16 17:14:11 -06:00
|
|
|
/// Locations of lines beginnings in the source code
|
2012-11-16 16:10:17 -06:00
|
|
|
mut lines: ~[BytePos],
|
2012-11-16 17:14:11 -06:00
|
|
|
/// Locations of multi-byte characters in the source code
|
2012-11-15 21:37:29 -06:00
|
|
|
multibyte_chars: DVec<MultiByteChar>
|
2012-11-12 17:12:20 -06:00
|
|
|
}
|
|
|
|
|
2012-11-12 20:59:37 -06:00
|
|
|
pub impl FileMap {
|
2012-11-16 16:10:17 -06:00
|
|
|
fn next_line(&self, +pos: BytePos) {
|
2012-11-15 00:27:53 -06:00
|
|
|
self.lines.push(pos);
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
pub fn get_line(&self, line: int) -> ~str unsafe {
|
2012-11-16 16:10:17 -06:00
|
|
|
let begin: BytePos = self.lines[line] - self.start_pos;
|
2012-11-12 21:32:48 -06:00
|
|
|
let begin = begin.to_uint();
|
2012-11-12 20:24:56 -06:00
|
|
|
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)
|
2012-11-12 18:56:39 -06:00
|
|
|
}
|
2011-07-16 01:01:10 -05:00
|
|
|
|
2012-11-15 21:37:29 -06:00
|
|
|
pub fn record_multibyte_char(&self, pos: BytePos, bytes: uint) {
|
|
|
|
assert bytes >=2 && bytes <= 4;
|
|
|
|
let mbc = MultiByteChar {
|
|
|
|
pos: pos,
|
|
|
|
bytes: bytes,
|
|
|
|
};
|
|
|
|
self.multibyte_chars.push(mbc);
|
|
|
|
}
|
2012-02-01 04:37:53 -06:00
|
|
|
}
|
|
|
|
|
2012-11-12 20:24:56 -06:00
|
|
|
pub struct CodeMap {
|
2012-11-12 20:59:37 -06:00
|
|
|
files: DVec<@FileMap>
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
2012-11-12 20:24:56 -06:00
|
|
|
pub impl CodeMap {
|
|
|
|
static pub fn new() -> CodeMap {
|
|
|
|
CodeMap {
|
|
|
|
files: DVec()
|
|
|
|
}
|
2012-01-21 03:00:06 -06:00
|
|
|
}
|
2012-11-12 20:24:56 -06:00
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
/// Add a new FileMap to the CodeMap and return it
|
|
|
|
fn new_filemap(+filename: FileName, src: @~str) -> @FileMap {
|
|
|
|
return self.new_filemap_w_substr(filename, FssNone, src);
|
|
|
|
}
|
|
|
|
|
2012-11-16 16:22:09 -06:00
|
|
|
fn new_filemap_w_substr(+filename: FileName, +substr: FileSubstr,
|
|
|
|
src: @~str) -> @FileMap {
|
|
|
|
let start_pos = if self.files.len() == 0 {
|
2012-11-15 00:27:53 -06:00
|
|
|
0
|
|
|
|
} else {
|
2012-11-16 16:10:17 -06:00
|
|
|
let last_start = self.files.last().start_pos.to_uint();
|
2012-11-15 00:27:53 -06:00
|
|
|
let last_len = self.files.last().src.len();
|
|
|
|
last_start + last_len
|
|
|
|
};
|
2012-11-16 16:22:09 -06:00
|
|
|
|
|
|
|
let filemap = @FileMap {
|
|
|
|
name: filename, substr: substr, src: src,
|
|
|
|
start_pos: BytePos(start_pos),
|
|
|
|
mut lines: ~[],
|
|
|
|
multibyte_chars: DVec()
|
|
|
|
};
|
|
|
|
|
2012-11-14 19:43:41 -06:00
|
|
|
self.files.push(filemap);
|
2012-11-16 16:22:09 -06:00
|
|
|
|
|
|
|
return filemap;
|
|
|
|
}
|
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
pub fn mk_substr_filename(&self, sp: span) -> ~str {
|
2012-11-12 20:24:56 -06:00
|
|
|
let pos = self.lookup_char_pos(sp.lo);
|
2012-11-12 21:32:48 -06:00
|
|
|
return fmt!("<%s:%u:%u>", pos.file.name,
|
|
|
|
pos.line, pos.col.to_uint());
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
2012-01-25 15:22:10 -06:00
|
|
|
|
2012-11-16 17:14:11 -06:00
|
|
|
/// Lookup source information about a BytePos
|
2012-11-15 21:37:29 -06:00
|
|
|
pub fn lookup_char_pos(&self, +pos: BytePos) -> Loc {
|
|
|
|
return self.lookup_pos(pos);
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2011-07-16 01:01:10 -05:00
|
|
|
|
2012-11-15 21:37:29 -06:00
|
|
|
pub fn lookup_char_pos_adj(&self, +pos: BytePos)
|
2012-11-12 21:32:48 -06:00
|
|
|
-> {filename: ~str, line: uint, col: CharPos, file: Option<@FileMap>}
|
2012-11-12 20:24:56 -06:00
|
|
|
{
|
|
|
|
let loc = self.lookup_char_pos(pos);
|
|
|
|
match (loc.file.substr) {
|
2012-11-12 20:59:37 -06:00
|
|
|
FssNone => {
|
2012-11-12 20:24:56 -06:00
|
|
|
{filename: /* FIXME (#2543) */ copy loc.file.name,
|
|
|
|
line: loc.line,
|
|
|
|
col: loc.col,
|
|
|
|
file: Some(loc.file)}
|
|
|
|
}
|
2012-11-12 20:59:37 -06:00
|
|
|
FssInternal(sp) => {
|
2012-11-12 21:32:48 -06:00
|
|
|
self.lookup_char_pos_adj(
|
2012-11-16 16:10:17 -06:00
|
|
|
sp.lo + (pos - loc.file.start_pos))
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
FssExternal(ref 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},
|
2012-11-12 20:24:56 -06:00
|
|
|
file: None}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
pub fn adjust_span(&self, sp: span) -> span {
|
2012-11-15 21:37:29 -06:00
|
|
|
let line = self.lookup_line(sp.lo);
|
2012-11-12 20:24:56 -06:00
|
|
|
match (line.fm.substr) {
|
2012-11-12 20:59:37 -06:00
|
|
|
FssNone => sp,
|
|
|
|
FssInternal(s) => {
|
2012-11-12 21:32:48 -06:00
|
|
|
self.adjust_span(span {
|
2012-11-16 16:10:17 -06:00
|
|
|
lo: s.lo + (sp.lo - line.fm.start_pos),
|
|
|
|
hi: s.lo + (sp.hi - line.fm.start_pos),
|
2012-11-12 21:32:48 -06:00
|
|
|
expn_info: sp.expn_info
|
|
|
|
})
|
|
|
|
}
|
2012-11-12 20:59:37 -06:00
|
|
|
FssExternal(_) => sp
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-02-10 12:28:43 -06:00
|
|
|
}
|
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
pub fn span_to_str(&self, sp: span) -> ~str {
|
2012-11-12 20:24:56 -06:00
|
|
|
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,
|
2012-11-12 21:32:48 -06:00
|
|
|
lo.line, lo.col.to_uint(), hi.line, hi.col.to_uint())
|
2012-02-10 12:28:43 -06:00
|
|
|
}
|
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
pub fn span_to_filename(&self, sp: span) -> FileName {
|
2012-11-12 20:24:56 -06:00
|
|
|
let lo = self.lookup_char_pos(sp.lo);
|
|
|
|
return /* FIXME (#2543) */ copy lo.file.name;
|
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
pub fn span_to_lines(&self, sp: span) -> @FileLines {
|
2012-11-12 20:24:56 -06:00
|
|
|
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);
|
|
|
|
};
|
2012-11-12 20:59:37 -06:00
|
|
|
return @FileLines {file: lo.file, lines: lines};
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-02-10 12:28:43 -06:00
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
pub fn span_to_snippet(&self, sp: span) -> ~str {
|
2012-11-12 20:24:56 -06:00
|
|
|
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;
|
2012-11-12 21:32:48 -06:00
|
|
|
return str::slice(*begin.fm.src,
|
|
|
|
begin.pos.to_uint(), end.pos.to_uint());
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-05-10 19:18:04 -05:00
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
pub fn get_filemap(&self, filename: ~str) -> @FileMap {
|
2012-11-12 20:24:56 -06:00
|
|
|
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");
|
|
|
|
}
|
2011-07-11 01:27:03 -05:00
|
|
|
|
2012-01-25 15:22:10 -06:00
|
|
|
}
|
|
|
|
|
2012-11-12 20:24:56 -06:00
|
|
|
priv impl CodeMap {
|
2012-11-15 21:37:29 -06:00
|
|
|
|
|
|
|
fn lookup_filemap_idx(&self, +pos: BytePos) -> uint {
|
2012-11-12 20:24:56 -06:00
|
|
|
let len = self.files.len();
|
|
|
|
let mut a = 0u;
|
|
|
|
let mut b = len;
|
|
|
|
while b - a > 1u {
|
|
|
|
let m = (a + b) / 2u;
|
2012-11-16 16:10:17 -06:00
|
|
|
if self.files[m].start_pos > pos {
|
2012-11-12 21:32:48 -06:00
|
|
|
b = m;
|
|
|
|
} else {
|
|
|
|
a = m;
|
|
|
|
}
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
|
|
|
if (a >= len) {
|
2012-11-12 21:32:48 -06:00
|
|
|
fail fmt!("position %u does not resolve to a source location",
|
|
|
|
pos.to_uint())
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-11-15 21:37:29 -06:00
|
|
|
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn lookup_line(&self, +pos: BytePos)
|
|
|
|
-> {fm: @FileMap, line: uint}
|
|
|
|
{
|
|
|
|
let idx = self.lookup_filemap_idx(pos);
|
|
|
|
let f = self.files[idx];
|
|
|
|
let mut a = 0u;
|
|
|
|
let mut b = vec::len(f.lines);
|
2012-11-12 20:24:56 -06:00
|
|
|
while b - a > 1u {
|
|
|
|
let m = (a + b) / 2u;
|
2012-11-16 16:10:17 -06:00
|
|
|
if f.lines[m] > pos { b = m; } else { a = m; }
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
|
|
|
return {fm: f, line: a};
|
|
|
|
}
|
2012-01-25 15:22:10 -06:00
|
|
|
|
2012-11-15 21:37:29 -06:00
|
|
|
fn lookup_pos(&self, +pos: BytePos) -> Loc {
|
|
|
|
let {fm: f, line: a} = self.lookup_line(pos);
|
|
|
|
let line = a + 1u; // Line numbers start at 1
|
|
|
|
let chpos = self.bytepos_to_local_charpos(pos);
|
2012-11-16 16:10:17 -06:00
|
|
|
let linebpos = f.lines[a];
|
2012-11-15 21:37:29 -06:00
|
|
|
let linechpos = self.bytepos_to_local_charpos(linebpos);
|
|
|
|
debug!("codemap: byte pos %? is on the line at byte pos %?",
|
|
|
|
pos, linebpos);
|
|
|
|
debug!("codemap: char pos %? is on the line at char pos %?",
|
|
|
|
chpos, linechpos);
|
|
|
|
debug!("codemap: byte is on line: %?", line);
|
|
|
|
assert chpos >= linechpos;
|
2012-11-12 21:32:48 -06:00
|
|
|
return Loc {
|
|
|
|
file: f,
|
2012-11-15 21:37:29 -06:00
|
|
|
line: line,
|
|
|
|
col: chpos - linechpos
|
2012-11-12 21:32:48 -06:00
|
|
|
};
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-01-25 15:22:10 -06:00
|
|
|
|
2012-11-15 17:00:49 -06:00
|
|
|
fn span_to_str_no_adj(&self, sp: span) -> ~str {
|
2012-11-12 20:24:56 -06:00
|
|
|
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,
|
2012-11-12 21:32:48 -06:00
|
|
|
lo.line, lo.col.to_uint(), hi.line, hi.col.to_uint())
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-11-15 21:37:29 -06:00
|
|
|
|
|
|
|
fn lookup_byte_offset(&self, +bpos: BytePos)
|
|
|
|
-> {fm: @FileMap, pos: BytePos} {
|
|
|
|
let idx = self.lookup_filemap_idx(bpos);
|
|
|
|
let fm = self.files[idx];
|
2012-11-16 16:10:17 -06:00
|
|
|
let offset = bpos - fm.start_pos;
|
2012-11-15 21:37:29 -06:00
|
|
|
return {fm: fm, pos: offset};
|
|
|
|
}
|
|
|
|
|
|
|
|
// Converts an absolute BytePos to a CharPos relative to the file it is
|
|
|
|
// located in
|
|
|
|
fn bytepos_to_local_charpos(&self, +bpos: BytePos) -> CharPos {
|
|
|
|
debug!("codemap: converting %? to char pos", bpos);
|
|
|
|
let idx = self.lookup_filemap_idx(bpos);
|
|
|
|
let map = self.files[idx];
|
|
|
|
|
|
|
|
// The number of extra bytes due to multibyte chars in the FileMap
|
|
|
|
let mut total_extra_bytes = 0;
|
|
|
|
|
|
|
|
for map.multibyte_chars.each |mbc| {
|
|
|
|
debug!("codemap: %?-byte char at %?", mbc.bytes, mbc.pos);
|
|
|
|
if mbc.pos < bpos {
|
|
|
|
total_extra_bytes += mbc.bytes;
|
|
|
|
// We should never see a byte position in the middle of a
|
|
|
|
// character
|
|
|
|
assert bpos == mbc.pos
|
|
|
|
|| bpos.to_uint() >= mbc.pos.to_uint() + mbc.bytes;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CharPos(bpos.to_uint() - total_extra_bytes)
|
|
|
|
}
|
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:
|
|
|
|
//
|