pub mod ptr;
pub mod show_span;
pub mod std_inject;
-pub mod str;
pub use syntax_pos::edition;
pub use syntax_pos::symbol;
pub mod test;
use parse::lexer::{is_block_doc_comment, is_pattern_whitespace};
use parse::lexer::{self, ParseSess, StringReader, TokenAndSpan};
use print::pprust;
-use str::char_at;
use std::io::Read;
use std::usize;
/// Otherwise returns Some(k) where k is first char offset after that leading
/// whitespace. Note k may be outside bounds of s.
fn all_whitespace(s: &str, col: CharPos) -> Option<usize> {
- let len = s.len();
- let mut col = col.to_usize();
- let mut cursor: usize = 0;
-
- while col > 0 && cursor < len {
- let ch = char_at(s, cursor);
+ let mut idx = 0;
+ for (i, ch) in s.char_indices().take(col.to_usize()) {
if !ch.is_whitespace() {
return None;
}
- cursor += ch.len_utf8();
- col -= 1;
+ idx = i;
}
-
- Some(cursor)
+ Some(idx)
}
fn trim_whitespace_prefix_and_push_line(lines: &mut Vec<String>, s: String, col: CharPos) {
let s1 = match all_whitespace(&s[..], col) {
Some(col) => {
if col < len {
- (&s[col..len]).to_string()
+ s[col..len].to_string()
} else {
String::new()
}
let mut lines: Vec<String> = Vec::new();
// Count the number of chars since the start of the line by rescanning.
- let mut src_index = rdr.src_index(rdr.source_file.line_begin_pos(rdr.pos));
+ let src_index = rdr.src_index(rdr.source_file.line_begin_pos(rdr.pos));
let end_src_index = rdr.src_index(rdr.pos);
assert!(src_index <= end_src_index,
"src_index={}, end_src_index={}, line_begin_pos={}",
src_index, end_src_index, rdr.source_file.line_begin_pos(rdr.pos).to_u32());
- let mut n = 0;
-
- while src_index < end_src_index {
- let c = char_at(&rdr.src, src_index);
- src_index += c.len_utf8();
- n += 1;
- }
- let col = CharPos(n);
+ let col = CharPos(rdr.src[src_index..end_src_index].chars().count());
rdr.bump();
rdr.bump();
use source_map::{SourceMap, FilePathMapping};
use errors::{Applicability, FatalError, Diagnostic, DiagnosticBuilder};
use parse::{token, ParseSess};
-use str::char_at;
use symbol::{Symbol, keywords};
use core::unicode::property::Pattern_White_Space;
use std::borrow::Cow;
use std::char;
+use std::iter;
use std::mem::replace;
use rustc_data_structures::sync::Lrc;
/// 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) -> Cow<'b, str> {
- let mut i = 0;
- while i < s.len() {
- let ch = char_at(s, i);
- let next = i + ch.len_utf8();
+ let mut chars = s.char_indices().peekable();
+ while let Some((i, ch)) = chars.next() {
if ch == '\r' {
- if next < s.len() && char_at(s, next) == '\n' {
- return translate_crlf_(self, start, s, errmsg, i).into();
+ if let Some((lf_idx, '\n')) = chars.peek() {
+ return translate_crlf_(self, start, s, *lf_idx, chars, errmsg).into();
}
let pos = start + BytePos(i as u32);
- let end_pos = start + BytePos(next as u32);
+ let end_pos = start + BytePos((i + ch.len_utf8()) as u32);
self.err_span_(pos, end_pos, errmsg);
}
- i = next;
}
return s.into();
fn translate_crlf_(rdr: &StringReader,
start: BytePos,
s: &str,
- errmsg: &str,
- mut i: usize)
+ mut j: usize,
+ mut chars: iter::Peekable<impl Iterator<Item = (usize, char)>>,
+ errmsg: &str)
-> String {
let mut buf = String::with_capacity(s.len());
- let mut j = 0;
- while i < s.len() {
- let ch = char_at(s, i);
- let next = i + ch.len_utf8();
+ // Skip first CR
+ buf.push_str(&s[.. j - 1]);
+ while let Some((i, ch)) = chars.next() {
if ch == '\r' {
if j < i {
buf.push_str(&s[j..i]);
}
+ let next = i + ch.len_utf8();
j = next;
- if next >= s.len() || char_at(s, next) != '\n' {
+ if chars.peek().map(|(_, ch)| *ch) != Some('\n') {
let pos = start + BytePos(i as u32);
let end_pos = start + BytePos(next as u32);
rdr.err_span_(pos, end_pos, errmsg);
}
}
- i = next;
}
if j < s.len() {
buf.push_str(&s[j..]);
(c > '\x7f' && c.is_xid_continue())
}
+#[inline]
+fn char_at(s: &str, byte: usize) -> char {
+ s[byte..].chars().next().unwrap()
+}
+
#[cfg(test)]
mod tests {
use super::*;
use feature_gate::UnstableFeatures;
use parse::parser::Parser;
use ptr::P;
-use str::char_at;
use symbol::Symbol;
use tokenstream::{TokenStream, TokenTree};
use diagnostics::plugin::ErrorMap;
// check if `s` looks like i32 or u1234 etc.
fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool {
- s.len() > 1 &&
- first_chars.contains(&char_at(s, 0)) &&
- s[1..].chars().all(|c| '0' <= c && c <= '9')
+ s.starts_with(first_chars) && s[1..].chars().all(|c| c.is_ascii_digit())
}
macro_rules! err {
let orig = s;
let mut ty = ast::LitIntType::Unsuffixed;
- if char_at(s, 0) == '0' && s.len() > 1 {
- match char_at(s, 1) {
- 'x' => base = 16,
- 'o' => base = 8,
- 'b' => base = 2,
+ if s.starts_with('0') && s.len() > 1 {
+ match s.as_bytes()[1] {
+ b'x' => base = 16,
+ b'o' => base = 8,
+ b'b' => base = 2,
_ => { }
}
}
+++ /dev/null
-// Copyright 2012-2014 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.
-
-#[inline]
-pub fn char_at(s: &str, byte: usize) -> char {
- s[byte..].chars().next().unwrap()
-}
projects / rust.git / commitdiff