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
|
|
|
|
2013-01-08 21:37:25 -06:00
|
|
|
use core::prelude::*;
|
|
|
|
|
2012-12-23 16:41:37 -06:00
|
|
|
use core::cmp;
|
|
|
|
use core::dvec::DVec;
|
|
|
|
use core::str;
|
|
|
|
use core::to_bytes;
|
|
|
|
use core::uint;
|
2012-12-17 21:31:04 -06:00
|
|
|
use std::serialize::{Encodable, Decodable, Encoder, Decoder};
|
2012-05-15 15:40:18 -05:00
|
|
|
|
2013-01-25 18:57:39 -06:00
|
|
|
pub trait Pos {
|
2013-01-30 21:42:06 -06:00
|
|
|
static pure fn from_uint(n: uint) -> Self;
|
2012-11-12 21:32:48 -06:00
|
|
|
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
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl Pos for BytePos {
|
2012-11-12 21:32:48 -06:00
|
|
|
static pure fn from_uint(n: uint) -> BytePos { BytePos(n) }
|
|
|
|
pure fn to_uint(&self) -> uint { **self }
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl cmp::Eq for BytePos {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &BytePos) -> bool { **self == **other }
|
|
|
|
pure fn ne(&self, other: &BytePos) -> bool { !(*self).eq(other) }
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl cmp::Ord for BytePos {
|
2012-11-14 20:59:30 -06:00
|
|
|
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 }
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl Add<BytePos, BytePos> for BytePos {
|
2012-12-05 21:22:48 -06:00
|
|
|
pure fn add(&self, rhs: &BytePos) -> BytePos {
|
|
|
|
BytePos(**self + **rhs)
|
2012-11-12 21:32:48 -06:00
|
|
|
}
|
2012-12-05 21:22:48 -06:00
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl Sub<BytePos, BytePos> for BytePos {
|
2012-12-05 21:22:48 -06:00
|
|
|
pure fn sub(&self, rhs: &BytePos) -> BytePos {
|
|
|
|
BytePos(**self - **rhs)
|
2012-11-12 21:32:48 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl to_bytes::IterBytes for BytePos {
|
2013-01-31 19:12:29 -06:00
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) {
|
2012-11-28 13:36:04 -06:00
|
|
|
(**self).iter_bytes(lsb0, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl Pos for CharPos {
|
2012-11-12 21:32:48 -06:00
|
|
|
static pure fn from_uint(n: uint) -> CharPos { CharPos(n) }
|
|
|
|
pure fn to_uint(&self) -> uint { **self }
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl cmp::Eq for CharPos {
|
2012-11-14 20:59:30 -06:00
|
|
|
pure fn eq(&self, other: &CharPos) -> bool { **self == **other }
|
|
|
|
pure fn ne(&self, other: &CharPos) -> bool { !(*self).eq(other) }
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl cmp::Ord for CharPos {
|
2012-11-14 20:59:30 -06:00
|
|
|
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 }
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl to_bytes::IterBytes for CharPos {
|
2013-01-31 19:12:29 -06:00
|
|
|
pure fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) {
|
2012-12-05 21:22:48 -06:00
|
|
|
(**self).iter_bytes(lsb0, f)
|
2012-11-12 21:32:48 -06:00
|
|
|
}
|
2012-12-05 21:22:48 -06:00
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl Add<CharPos,CharPos> for CharPos {
|
2012-12-05 21:22:48 -06:00
|
|
|
pure fn add(&self, rhs: &CharPos) -> CharPos {
|
|
|
|
CharPos(**self + **rhs)
|
2012-11-12 21:32:48 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl Sub<CharPos,CharPos> for CharPos {
|
2012-12-05 21:22:48 -06:00
|
|
|
pure fn sub(&self, rhs: &CharPos) -> CharPos {
|
|
|
|
CharPos(**self - **rhs)
|
2012-11-28 13:36:04 -06:00
|
|
|
}
|
|
|
|
}
|
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
|
|
|
|
2013-01-30 11:56:33 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-02-06 20:35:01 -06:00
|
|
|
#[deriving_eq]
|
2013-01-30 11:56:33 -06:00
|
|
|
pub struct spanned<T> { node: T, span: span }
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl cmp::Eq for span {
|
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
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl<S:Encoder> Encodable<S> for span {
|
2012-12-17 21:31:04 -06:00
|
|
|
/* Note #1972 -- spans are encoded but not decoded */
|
|
|
|
fn encode(&self, _s: &S) { }
|
2012-11-12 19:14:15 -06:00
|
|
|
}
|
|
|
|
|
2013-02-26 19:12:00 -06:00
|
|
|
impl<D:Decoder> Decodable<D> for span {
|
2012-12-17 21:31:04 -06:00
|
|
|
static fn decode(_d: &D) -> span {
|
2013-01-30 11:56:33 -06:00
|
|
|
dummy_sp()
|
2012-11-12 19:14:15 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 11:56:33 -06:00
|
|
|
pub pure fn spanned<T>(+lo: BytePos, +hi: BytePos, +t: T) -> spanned<T> {
|
2013-02-15 03:15:53 -06:00
|
|
|
respan(mk_sp(lo, hi), t)
|
2013-01-30 11:56:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
pub pure fn respan<T>(sp: span, +t: T) -> spanned<T> {
|
|
|
|
spanned {node: t, span: sp}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub pure fn dummy_spanned<T>(+t: T) -> spanned<T> {
|
2013-02-15 03:15:53 -06:00
|
|
|
respan(dummy_sp(), t)
|
2013-01-30 11:56:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* assuming that we're not in macro expansion */
|
|
|
|
pub pure fn mk_sp(+lo: BytePos, +hi: BytePos) -> span {
|
|
|
|
span {lo: lo, hi: hi, expn_info: None}
|
|
|
|
}
|
|
|
|
|
|
|
|
// make this a const, once the compiler supports it
|
|
|
|
pub pure fn dummy_sp() -> span { return mk_sp(BytePos(0), BytePos(0)); }
|
|
|
|
|
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2013-01-30 11:56:33 -06:00
|
|
|
/// A source code location used as the result of lookup_char_pos_adj
|
|
|
|
// Actually, *none* of the clients use the filename *or* file field;
|
|
|
|
// perhaps they should just be removed.
|
|
|
|
pub struct LocWithOpt {
|
|
|
|
filename: ~str,
|
|
|
|
line: uint,
|
|
|
|
col: CharPos,
|
|
|
|
file: Option<@FileMap>,
|
|
|
|
}
|
|
|
|
|
|
|
|
// used to be structural records. Better names, anyone?
|
|
|
|
pub struct FileMapAndLine {fm: @FileMap, line: uint}
|
|
|
|
pub struct FileMapAndBytePos {fm: @FileMap, pos: BytePos}
|
2013-02-21 02:16:31 -06:00
|
|
|
pub struct NameAndSpan {name: ~str, span: Option<span>}
|
|
|
|
|
|
|
|
pub struct CallInfo {
|
|
|
|
call_site: span,
|
|
|
|
callee: NameAndSpan
|
|
|
|
}
|
2013-01-30 11:56:33 -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 {
|
2013-02-21 02:16:31 -06:00
|
|
|
ExpandedFrom(CallInfo)
|
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-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
|
2013-02-21 20:27:24 -06:00
|
|
|
lines: @mut ~[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 {
|
2013-01-30 11:56:33 -06:00
|
|
|
// EFFECT: register a start-of-line offset in the
|
|
|
|
// table of line-beginnings.
|
|
|
|
// UNCHECKED INVARIANT: these offsets must be added in the right
|
|
|
|
// order and must be in the right places; there is shared knowledge
|
|
|
|
// about what ends a line between this file and parse.rs
|
2012-11-16 16:10:17 -06:00
|
|
|
fn next_line(&self, +pos: BytePos) {
|
2013-01-30 11:56:33 -06:00
|
|
|
// the new charpos must be > the last one (or it's the first one).
|
2013-03-06 15:58:02 -06:00
|
|
|
fail_unless!((self.lines.len() == 0)
|
2013-01-30 11:56:33 -06:00
|
|
|
|| (self.lines[self.lines.len() - 1] < pos));
|
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
|
|
|
|
2013-01-30 11:56:33 -06:00
|
|
|
// get a line from the list of pre-computed line-beginnings
|
2013-01-23 13:43:58 -06:00
|
|
|
pub fn get_line(&self, line: int) -> ~str {
|
|
|
|
unsafe {
|
|
|
|
let begin: BytePos = self.lines[line] - self.start_pos;
|
|
|
|
let begin = begin.to_uint();
|
|
|
|
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) {
|
2013-03-06 15:58:02 -06:00
|
|
|
fail_unless!(bytes >=2 && bytes <= 4);
|
2012-11-15 21:37:29 -06:00
|
|
|
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
|
2013-03-02 15:31:21 -06:00
|
|
|
fn new_filemap(&self, +filename: FileName, src: @~str) -> @FileMap {
|
2012-11-16 17:14:11 -06:00
|
|
|
return self.new_filemap_w_substr(filename, FssNone, src);
|
|
|
|
}
|
|
|
|
|
2013-03-02 15:31:21 -06:00
|
|
|
fn new_filemap_w_substr(
|
|
|
|
&self,
|
|
|
|
+filename: FileName,
|
|
|
|
+substr: FileSubstr,
|
|
|
|
src: @~str
|
|
|
|
) -> @FileMap {
|
2012-11-16 16:22:09 -06:00
|
|
|
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),
|
2013-02-21 20:27:24 -06:00
|
|
|
lines: @mut ~[],
|
2012-11-16 16:22:09 -06:00
|
|
|
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
|
|
|
|
2013-01-30 11:56:33 -06:00
|
|
|
pub fn lookup_char_pos_adj(&self, +pos: BytePos) -> LocWithOpt
|
2012-11-12 20:24:56 -06:00
|
|
|
{
|
|
|
|
let loc = self.lookup_char_pos(pos);
|
|
|
|
match (loc.file.substr) {
|
2013-01-30 11:56:33 -06:00
|
|
|
FssNone =>
|
|
|
|
LocWithOpt {
|
|
|
|
filename: /* FIXME (#2543) */ copy loc.file.name,
|
|
|
|
line: loc.line,
|
|
|
|
col: loc.col,
|
|
|
|
file: Some(loc.file)},
|
|
|
|
FssInternal(sp) =>
|
|
|
|
self.lookup_char_pos_adj(
|
|
|
|
sp.lo + (pos - loc.file.start_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 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: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 {
|
2013-01-30 11:56:33 -06:00
|
|
|
if self.files.len() == 0 && sp == dummy_sp() {
|
2012-12-05 17:13:24 -06:00
|
|
|
return ~"no-location";
|
|
|
|
}
|
|
|
|
|
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);
|
2013-03-06 15:58:02 -06:00
|
|
|
fail_unless!(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 _|_)
|
2013-02-11 21:26:38 -06:00
|
|
|
fail!(); // ("asking for " + filename + " which we don't know about");
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
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) {
|
2013-02-11 21:26:38 -06:00
|
|
|
fail!(fmt!("position %u does not resolve to a source location",
|
2013-01-31 19:51:01 -06:00
|
|
|
pos.to_uint()))
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-11-15 21:37:29 -06:00
|
|
|
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
2013-01-30 11:56:33 -06:00
|
|
|
fn lookup_line(&self, pos: BytePos) -> FileMapAndLine
|
2012-11-15 21:37:29 -06:00
|
|
|
{
|
|
|
|
let idx = self.lookup_filemap_idx(pos);
|
|
|
|
let f = self.files[idx];
|
|
|
|
let mut a = 0u;
|
2013-02-21 20:27:24 -06:00
|
|
|
let mut b = f.lines.len();
|
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
|
|
|
}
|
2013-01-30 11:56:33 -06:00
|
|
|
return FileMapAndLine {fm: f, line: a};
|
2012-11-12 20:24:56 -06:00
|
|
|
}
|
2012-01-25 15:22:10 -06:00
|
|
|
|
2012-11-15 21:37:29 -06:00
|
|
|
fn lookup_pos(&self, +pos: BytePos) -> Loc {
|
2013-01-30 11:56:33 -06:00
|
|
|
let FileMapAndLine {fm: f, line: a} = self.lookup_line(pos);
|
2012-11-15 21:37:29 -06:00
|
|
|
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);
|
2013-03-06 15:58:02 -06:00
|
|
|
fail_unless!(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)
|
2013-01-30 11:56:33 -06:00
|
|
|
-> FileMapAndBytePos {
|
2012-11-15 21:37:29 -06:00
|
|
|
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;
|
2013-01-30 11:56:33 -06:00
|
|
|
return FileMapAndBytePos {fm: fm, pos: offset};
|
2012-11-15 21:37:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
2013-03-06 15:58:02 -06:00
|
|
|
fail_unless!(bpos == mbc.pos
|
|
|
|
|| bpos.to_uint() >= mbc.pos.to_uint() + mbc.bytes);
|
2012-11-15 21:37:29 -06:00
|
|
|
} 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
|
|
|
|
2013-01-30 11:56:33 -06:00
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
|
|
|
use super::*;
|
|
|
|
use util::testing::check_equal;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn t1 () {
|
|
|
|
let cm = CodeMap::new();
|
|
|
|
let fm = cm.new_filemap(~"blork.rs",@~"first line.\nsecond line");
|
|
|
|
fm.next_line(BytePos(0));
|
|
|
|
check_equal(&fm.get_line(0),&~"first line.");
|
|
|
|
// TESTING BROKEN BEHAVIOR:
|
|
|
|
fm.next_line(BytePos(10));
|
|
|
|
check_equal(&fm.get_line(1),&~".");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[should_fail]
|
|
|
|
fn t2 () {
|
|
|
|
let cm = CodeMap::new();
|
|
|
|
let fm = cm.new_filemap(~"blork.rs",@~"first line.\nsecond line");
|
|
|
|
// TESTING *REALLY* BROKEN BEHAVIOR:
|
|
|
|
fm.next_line(BytePos(0));
|
|
|
|
fm.next_line(BytePos(10));
|
|
|
|
fm.next_line(BytePos(2));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
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:
|
|
|
|
//
|