/// Converts CRLF to LF in the given string, raising an error on bare CR.
fn translate_crlf<'b>(&self, start: BytePos,
s: &'b str, errmsg: &'b str) -> CowString<'b> {
- let mut i = 0us;
+ let mut i = 0;
while i < s.len() {
let str::CharRange { ch, next } = s.char_range_at(i);
if ch == '\r' {
let byte_offset_diff = next.next - current_byte_offset;
self.pos = self.pos + Pos::from_usize(byte_offset_diff);
self.curr = Some(next.ch);
- self.col = self.col + CharPos(1us);
+ self.col = self.col + CharPos(1);
if last_char == '\n' {
self.filemap.next_line(self.last_pos);
- self.col = CharPos(0us);
+ self.col = CharPos(0);
}
if byte_offset_diff > 1 {
cmap.files.borrow_mut().push(self.filemap.clone());
let loc = cmap.lookup_char_pos_adj(self.last_pos);
debug!("Skipping a shebang");
- if loc.line == 1us && loc.col == CharPos(0us) {
+ if loc.line == 1 && loc.col == CharPos(0) {
// FIXME: Add shebang "token", return it
let start = self.last_pos;
while !self.curr_is('\n') && !self.is_eof() { self.bump(); }
/// Scan through any digits (base `radix`) or underscores, and return how
/// many digits there were.
fn scan_digits(&mut self, radix: usize) -> usize {
- let mut len = 0us;
+ let mut len = 0;
loop {
let c = self.curr;
if c == Some('_') { debug!("skipping a _"); self.bump(); continue; }
if self.curr == Some('{') {
self.scan_unicode_escape(delim)
} else {
- let res = self.scan_hex_digits(4us, delim, false);
+ let res = self.scan_hex_digits(4, delim, false);
let sp = codemap::mk_sp(escaped_pos, self.last_pos);
self.old_escape_warning(sp);
res
}
}
'U' if !ascii_only => {
- let res = self.scan_hex_digits(8us, delim, false);
+ let res = self.scan_hex_digits(8, delim, false);
let sp = codemap::mk_sp(escaped_pos, self.last_pos);
self.old_escape_warning(sp);
res
fn scan_unicode_escape(&mut self, delim: char) -> bool {
self.bump(); // past the {
let start_bpos = self.last_pos;
- let mut count = 0us;
+ let mut count = 0;
let mut accum_int = 0;
while !self.curr_is('}') && count <= 6 {
/// error if it isn't.
fn check_float_base(&mut self, start_bpos: BytePos, last_bpos: BytePos, base: usize) {
match base {
- 16us => self.err_span_(start_bpos, last_bpos, "hexadecimal float literal is not \
+ 16 => self.err_span_(start_bpos, last_bpos, "hexadecimal float literal is not \
supported"),
- 8us => self.err_span_(start_bpos, last_bpos, "octal float literal is not supported"),
- 2us => self.err_span_(start_bpos, last_bpos, "binary float literal is not supported"),
+ 8 => self.err_span_(start_bpos, last_bpos, "octal float literal is not supported"),
+ 2 => self.err_span_(start_bpos, last_bpos, "binary float literal is not supported"),
_ => ()
}
}
'r' => {
let start_bpos = self.last_pos;
self.bump();
- let mut hash_count = 0us;
+ let mut hash_count = 0;
while self.curr_is('#') {
self.bump();
hash_count += 1;
fn scan_raw_byte_string(&mut self) -> token::Lit {
let start_bpos = self.last_pos;
self.bump();
- let mut hash_count = 0us;
+ let mut hash_count = 0;
while self.curr_is('#') {
self.bump();
hash_count += 1;
// check that the given reader produces the desired stream
// of tokens (stop checking after exhausting the expected vec)
fn check_tokenization (mut string_reader: StringReader, expected: Vec<token::Token> ) {
- for expected_tok in expected.iter() {
+ for expected_tok in &expected {
assert_eq!(&string_reader.next_token().tok, expected_tok);
}
}