use std::fmt;
use std::iter;
use std::num;
-use std::ops::Index;
/// Static data containing Unicode ranges for general categories and scripts.
use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW};
match self.next_char() {
true => Ok(()),
false => {
- self.err(format!("Expected {:?} but got EOF.",
- expected).index(&FullRange))
+ self.err(&format!("Expected {:?} but got EOF.",
+ expected)[])
}
}
}
fn expect(&mut self, expected: char) -> Result<(), Error> {
match self.next_char() {
true if self.cur() == expected => Ok(()),
- true => self.err(format!("Expected '{:?}' but got '{:?}'.",
- expected, self.cur()).index(&FullRange)),
+ true => self.err(&format!("Expected '{:?}' but got '{:?}'.",
+ expected, self.cur())[]),
false => {
- self.err(format!("Expected '{:?}' but got EOF.",
- expected).index(&FullRange))
+ self.err(&format!("Expected '{:?}' but got EOF.",
+ expected)[])
}
}
}
match try!(self.parse_escape()) {
Literal(c3, _) => c2 = c3, // allow literal escapes below
ast =>
- return self.err(format!("Expected a literal, but got {:?}.",
- ast).index(&FullRange)),
+ return self.err(&format!("Expected a literal, but got {:?}.",
+ ast)[]),
}
}
if c2 < c {
- return self.err(format!("Invalid character class \
- range '{}-{}'",
- c,
- c2).index(&FullRange))
+ return self.err(&format!("Invalid character class \
+ range '{}-{}'",
+ c,
+ c2)[])
}
ranges.push((c, self.cur()))
} else {
FLAG_EMPTY
};
let name = self.slice(name_start, closer - 1);
- match find_class(ASCII_CLASSES, name.index(&FullRange)) {
+ match find_class(ASCII_CLASSES, &name[]) {
None => None,
Some(ranges) => {
self.chari = closer;
match self.pos('}') {
Some(i) => i,
None => {
- return self.err(format!("No closing brace for counted \
- repetition starting at position \
- {:?}.",
- start).index(&FullRange))
+ return self.err(&format!("No closing brace for counted \
+ repetition starting at position \
+ {:?}.",
+ start)[])
}
};
self.chari = closer;
let greed = try!(self.get_next_greedy());
- let inner = self.chars.index(&((start+1)..closer)).iter().cloned()
+ let inner = self.chars[start+1..closer].iter().cloned()
.collect::<String>();
// Parse the min and max values from the regex.
let (mut min, mut max): (uint, Option<uint>);
if !inner.contains(",") {
- min = try!(self.parse_uint(inner.index(&FullRange)));
+ min = try!(self.parse_uint(&inner[]));
max = Some(min);
} else {
let pieces: Vec<&str> = inner.splitn(1, ',').collect();
// Do some bounds checking and make sure max >= min.
if min > MAX_REPEAT {
- return self.err(format!(
+ return self.err(&format!(
"{} exceeds maximum allowed repetitions ({})",
- min, MAX_REPEAT).index(&FullRange));
+ min, MAX_REPEAT)[]);
}
if max.is_some() {
let m = max.unwrap();
if m > MAX_REPEAT {
- return self.err(format!(
+ return self.err(&format!(
"{} exceeds maximum allowed repetitions ({})",
- m, MAX_REPEAT).index(&FullRange));
+ m, MAX_REPEAT)[]);
}
if m < min {
- return self.err(format!(
+ return self.err(&format!(
"Max repetitions ({}) cannot be smaller than min \
- repetitions ({}).", m, min).index(&FullRange));
+ repetitions ({}).", m, min)[]);
}
}
Ok(AstClass(ranges, flags))
}
_ => {
- self.err(format!("Invalid escape sequence '\\\\{}'", c).index(&FullRange))
+ self.err(&format!("Invalid escape sequence '\\\\{}'", c)[])
}
}
}
let closer =
match self.pos('}') {
Some(i) => i,
- None => return self.err(format!(
+ None => return self.err(&format!(
"Missing '}}' for unclosed '{{' at position {}",
- self.chari).index(&FullRange)),
+ self.chari)[]),
};
if closer - self.chari + 1 == 0 {
return self.err("No Unicode class name found.")
name = self.slice(self.chari + 1, self.chari + 2);
self.chari += 1;
}
- match find_class(UNICODE_CLASSES, name.index(&FullRange)) {
+ match find_class(UNICODE_CLASSES, &name[]) {
None => {
- return self.err(format!("Could not find Unicode class '{}'",
- name).index(&FullRange))
+ return self.err(&format!("Could not find Unicode class '{}'",
+ name)[])
}
Some(ranges) => {
Ok(AstClass(ranges, negated | (self.flags & FLAG_NOCASE)))
}
}
let s = self.slice(start, end);
- match num::from_str_radix::<u32>(s.index(&FullRange), 8) {
+ match num::from_str_radix::<u32>(&s[], 8) {
Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
None => {
- self.err(format!("Could not parse '{:?}' as octal number.",
- s).index(&FullRange))
+ self.err(&format!("Could not parse '{:?}' as octal number.",
+ s)[])
}
}
}
let closer =
match self.pos('}') {
None => {
- return self.err(format!("Missing '}}' for unclosed \
+ return self.err(&format!("Missing '}}' for unclosed \
'{{' at position {}",
- start).index(&FullRange))
+ start)[])
}
Some(i) => i,
};
self.chari = closer;
- self.parse_hex_digits(self.slice(start, closer).index(&FullRange))
+ self.parse_hex_digits(&self.slice(start, closer)[])
}
// Parses a two-digit hex number.
match num::from_str_radix::<u32>(s, 16) {
Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
None => {
- self.err(format!("Could not parse '{}' as hex number.", s).index(&FullRange))
+ self.err(&format!("Could not parse '{}' as hex number.", s)[])
}
}
}
"Capture names can only have underscores, letters and digits.")
}
if self.names.contains(&name) {
- return self.err(format!("Duplicate capture group name '{}'.",
- name).index(&FullRange))
+ return self.err(&format!("Duplicate capture group name '{}'.",
+ name)[])
}
self.names.push(name.clone());
self.chari = closer;
'U' => { flags = flags | FLAG_SWAP_GREED; saw_flag = true},
'-' => {
if sign < 0 {
- return self.err(format!(
+ return self.err(&format!(
"Cannot negate flags twice in '{}'.",
- self.slice(start, self.chari + 1)).index(&FullRange))
+ self.slice(start, self.chari + 1))[])
}
sign = -1;
saw_flag = false;
':' | ')' => {
if sign < 0 {
if !saw_flag {
- return self.err(format!(
+ return self.err(&format!(
"A valid flag does not follow negation in '{}'",
- self.slice(start, self.chari + 1)).index(&FullRange))
+ self.slice(start, self.chari + 1))[])
}
flags = flags ^ flags;
}
self.flags = flags;
return Ok(())
}
- _ => return self.err(format!(
- "Unrecognized flag '{}'.", self.cur()).index(&FullRange)),
+ _ => return self.err(&format!(
+ "Unrecognized flag '{}'.", self.cur())[]),
}
}
}
match s.parse::<uint>() {
Some(i) => Ok(i),
None => {
- self.err(format!("Expected an unsigned integer but got '{}'.",
- s).index(&FullRange))
+ self.err(&format!("Expected an unsigned integer but got '{}'.",
+ s)[])
}
}
}
match char::from_u32(n) {
Some(c) => Ok(c),
None => {
- self.err(format!("Could not decode '{}' to unicode \
- character.", n).index(&FullRange))
+ self.err(&format!("Could not decode '{}' to unicode \
+ character.", n)[])
}
}
}
}
fn slice(&self, start: uint, end: uint) -> String {
- self.chars.index(&(start..end)).iter().cloned().collect()
+ self.chars[start..end].iter().cloned().collect()
}
}