use syntax::parse::token::{ident_interner, interner_get};
use syntax::parse::token::special_idents;
use syntax::print::pprust::path_to_str;
-use syntax::codemap::{Span, dummy_sp, BytePos};
+use syntax::codemap::{Span, dummy_sp, Pos};
use syntax::opt_vec::OptVec;
use syntax::visit;
use syntax::visit::Visitor;
if "???" == module_name {
let span = Span {
lo: span.lo,
- hi: span.lo + BytePos(segment_name.len()),
+ hi: span.lo + Pos::from_uint(segment_name.len()),
expn_info: span.expn_info,
};
self.resolve_error(span,
fn to_uint(&self) -> uint;
}
-/// A byte offset
+/// A byte offset. Keep this small (currently 32-bits), as AST contains
+/// a lot of them.
#[deriving(Clone, Eq, IterBytes, Ord)]
-pub struct BytePos(uint);
+pub struct BytePos(u32);
+
/// 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.
// have been unsuccessful
impl Pos for BytePos {
- fn from_uint(n: uint) -> BytePos { BytePos(n) }
- fn to_uint(&self) -> uint { **self }
+ fn from_uint(n: uint) -> BytePos { BytePos(n as u32) }
+ fn to_uint(&self) -> uint { **self as uint }
}
impl Add<BytePos, BytePos> for BytePos {
let filemap = @FileMap {
name: filename, substr: substr, src: src,
- start_pos: BytePos(start_pos),
+ start_pos: Pos::from_uint(start_pos),
lines: @mut ~[],
multibyte_chars: @mut ~[],
};
let last_char = rdr.curr;
let next = rdr.src.char_range_at(current_byte_offset);
let byte_offset_diff = next.next - current_byte_offset;
- rdr.pos = rdr.pos + BytePos(byte_offset_diff);
+ rdr.pos = rdr.pos + Pos::from_uint(byte_offset_diff);
rdr.curr = next.ch;
rdr.col = rdr.col + CharPos(1u);
if last_char == '\n' {
if byte_offset_diff > 1 {
rdr.filemap.record_multibyte_char(
- BytePos(current_byte_offset), byte_offset_diff);
+ Pos::from_uint(current_byte_offset), byte_offset_diff);
}
} else {
rdr.curr = unsafe { transmute(-1u32) }; // FIXME: #8971: unsound
bump(rdr);
// line comments starting with "///" or "//!" are doc-comments
if rdr.curr == '/' || rdr.curr == '!' {
- let start_bpos = rdr.pos - BytePos(3u);
+ let start_bpos = rdr.pos - BytePos(3);
while rdr.curr != '\n' && !is_eof(rdr) {
bump(rdr);
}
-> Option<TokenAndSpan> {
// block comments starting with "/**" or "/*!" are doc-comments
let is_doc_comment = rdr.curr == '*' || rdr.curr == '!';
- let start_bpos = rdr.pos - BytePos(if is_doc_comment {3u} else {2u});
+ let start_bpos = rdr.pos - BytePos(if is_doc_comment {3} else {2});
let mut level: int = 1;
while level > 0 {
// Byte offsetting here is okay because the
// character before position `start` is an
// ascii single quote.
- start - BytePos(1u),
+ start - BytePos(1),
rdr.last_pos,
~"unterminated character constant");
}
token::GT => self.bump(),
token::BINOP(token::SHR) => self.replace_token(
token::GT,
- self.span.lo + BytePos(1u),
+ self.span.lo + BytePos(1),
self.span.hi
),
_ => self.fatal(format!("expected `{}`, found `{}`",
if (*cmnt).style != comments::trailing { return; }
let span_line = cm.lookup_char_pos(span.hi);
let comment_line = cm.lookup_char_pos((*cmnt).pos);
- let mut next = (*cmnt).pos + BytePos(1u);
+ let mut next = (*cmnt).pos + BytePos(1);
match next_pos { None => (), Some(p) => next = p }
if span.hi < (*cmnt).pos && (*cmnt).pos < next &&
span_line.line == comment_line.line {