remove unnecessary parentheses from range notation

[rust.git] / src / libregex / parse.rs

diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index 07da86afcc9719834b50a60710c3d2104d628133..a54db2654ab7a0224fd62e1d034f2ee7d7534cd8 100644 (file)
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -39,7 +39,7 @@ pub struct Error {
 
 impl fmt::Show for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Regex syntax error near position {}: {}",
+        write!(f, "Regex syntax error near position {}: {:?}",
                self.pos, self.msg)
     }
 }
@@ -121,7 +121,7 @@ fn paren(&self) -> bool {
     fn flags(&self) -> Flags {
         match *self {
             Paren(flags, _, _) => flags,
-            _ => panic!("Cannot get flags from {}", self),
+            _ => panic!("Cannot get flags from {:?}", self),
         }
     }
 
@@ -129,7 +129,7 @@ fn capture(&self) -> Option<uint> {
         match *self {
             Paren(_, 0, _) => None,
             Paren(_, c, _) => Some(c),
-            _ => panic!("Cannot get capture group from {}", self),
+            _ => panic!("Cannot get capture group from {:?}", self),
         }
     }
 
@@ -143,7 +143,7 @@ fn capture_name(&self) -> Option<String> {
                     Some(name.clone())
                 }
             }
-            _ => panic!("Cannot get capture name from {}", self),
+            _ => panic!("Cannot get capture name from {:?}", self),
         }
     }
 
@@ -157,7 +157,7 @@ fn bar(&self) -> bool {
     fn unwrap(self) -> Result<Ast, Error> {
         match self {
             Expr(x) => Ok(x),
-            _ => panic!("Tried to unwrap non-AST item: {}", self),
+            _ => panic!("Tried to unwrap non-AST item: {:?}", self),
         }
     }
 }
@@ -284,8 +284,8 @@ fn noteof(&mut self, expected: &str) -> Result<(), Error> {
         match self.next_char() {
             true => Ok(()),
             false => {
-                self.err(format!("Expected {} but got EOF.",
-                                 expected)[])
+                self.err(&format!("Expected {:?} but got EOF.",
+                                  expected)[])
             }
         }
     }
@@ -293,11 +293,11 @@ fn noteof(&mut self, expected: &str) -> Result<(), Error> {
     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())[]),
+            true => self.err(&format!("Expected '{:?}' but got '{:?}'.",
+                                      expected, self.cur())[]),
             false => {
-                self.err(format!("Expected '{}' but got EOF.",
-                                 expected)[])
+                self.err(&format!("Expected '{:?}' but got EOF.",
+                                  expected)[])
             }
         }
     }
@@ -394,7 +394,7 @@ fn parse_class(&mut self) -> Result<(), Error> {
                             continue
                         }
                         Some(ast) =>
-                            panic!("Expected Class AST but got '{}'", ast),
+                            panic!("Expected Class AST but got '{:?}'", ast),
                         // Just drop down and try to add as a regular character.
                         None => {},
                     },
@@ -409,7 +409,7 @@ fn parse_class(&mut self) -> Result<(), Error> {
                             return self.err(
                                 "\\A, \\z, \\b and \\B are not valid escape \
                                  sequences inside a character class."),
-                        ast => panic!("Unexpected AST item '{}'", ast),
+                        ast => panic!("Unexpected AST item '{:?}'", ast),
                     }
                 }
                 ']' if ranges.len() > 0 || alts.len() > 0 => {
@@ -442,15 +442,15 @@ fn parse_class(&mut self) -> Result<(), Error> {
                     match try!(self.parse_escape()) {
                         Literal(c3, _) => c2 = c3, // allow literal escapes below
                         ast =>
-                            return self.err(format!("Expected a literal, but got {}.",
-                                                    ast)[]),
+                            return self.err(&format!("Expected a literal, but got {:?}.",
+                                                     ast)[]),
                     }
                 }
                 if c2 < c {
-                    return self.err(format!("Invalid character class \
-                                             range '{}-{}'",
-                                            c,
-                                            c2)[])
+                    return self.err(&format!("Invalid character class \
+                                              range '{}-{}'",
+                                             c,
+                                             c2)[])
                 }
                 ranges.push((c, self.cur()))
             } else {
@@ -488,7 +488,7 @@ fn try_parse_ascii(&mut self) -> Option<Ast> {
                 FLAG_EMPTY
             };
         let name = self.slice(name_start, closer - 1);
-        match find_class(ASCII_CLASSES, name[]) {
+        match find_class(ASCII_CLASSES, &name[]) {
             None => None,
             Some(ranges) => {
                 self.chari = closer;
@@ -510,10 +510,10 @@ fn parse_counted(&mut self) -> Result<(), Error> {
             match self.pos('}') {
                 Some(i) => i,
                 None => {
-                    return self.err(format!("No closing brace for counted \
-                                             repetition starting at position \
-                                             {}.",
-                                            start)[])
+                    return self.err(&format!("No closing brace for counted \
+                                              repetition starting at position \
+                                              {:?}.",
+                                             start)[])
                 }
             };
         self.chari = closer;
@@ -524,7 +524,7 @@ fn parse_counted(&mut self) -> Result<(), Error> {
         // 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[]));
+            min = try!(self.parse_uint(&inner[]));
             max = Some(min);
         } else {
             let pieces: Vec<&str> = inner.splitn(1, ',').collect();
@@ -544,19 +544,19 @@ fn parse_counted(&mut self) -> Result<(), Error> {
 
         // 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)[]);
         }
         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)[]);
             }
             if m < min {
-                return self.err(format!(
+                return self.err(&format!(
                     "Max repetitions ({}) cannot be smaller than min \
                      repetitions ({}).", m, min)[]);
             }
@@ -622,7 +622,7 @@ fn parse_escape(&mut self) -> Result<Ast, Error> {
                 Ok(AstClass(ranges, flags))
             }
             _ => {
-                self.err(format!("Invalid escape sequence '\\\\{}'", c)[])
+                self.err(&format!("Invalid escape sequence '\\\\{}'", c)[])
             }
         }
     }
@@ -640,7 +640,7 @@ fn parse_unicode_name(&mut self) -> Result<Ast, Error> {
             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)[]),
                 };
@@ -656,9 +656,9 @@ fn parse_unicode_name(&mut self) -> Result<Ast, Error> {
             name = self.slice(self.chari + 1, self.chari + 2);
             self.chari += 1;
         }
-        match find_class(UNICODE_CLASSES, name[]) {
+        match find_class(UNICODE_CLASSES, &name[]) {
             None => {
-                return self.err(format!("Could not find Unicode class '{}'",
+                return self.err(&format!("Could not find Unicode class '{}'",
                                         name)[])
             }
             Some(ranges) => {
@@ -682,10 +682,10 @@ fn parse_octal(&mut self) -> Result<Ast, Error> {
             }
         }
         let s = self.slice(start, end);
-        match num::from_str_radix::<u32>(s[], 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.",
+                self.err(&format!("Could not parse '{:?}' as octal number.",
                                  s)[])
             }
         }
@@ -702,14 +702,14 @@ fn parse_hex(&mut self) -> Result<Ast, Error> {
         let closer =
             match self.pos('}') {
                 None => {
-                    return self.err(format!("Missing '}}' for unclosed \
+                    return self.err(&format!("Missing '}}' for unclosed \
                                              '{{' at position {}",
                                             start)[])
                 }
                 Some(i) => i,
             };
         self.chari = closer;
-        self.parse_hex_digits(self.slice(start, closer)[])
+        self.parse_hex_digits(&self.slice(start, closer)[])
     }
 
     // Parses a two-digit hex number.
@@ -729,7 +729,7 @@ fn parse_hex_digits(&self, s: &str) -> Result<Ast, Error> {
         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)[])
+                self.err(&format!("Could not parse '{}' as hex number.", s)[])
             }
         }
     }
@@ -754,7 +754,7 @@ fn parse_named_capture(&mut self) -> Result<(), Error> {
                 "Capture names can only have underscores, letters and digits.")
         }
         if self.names.contains(&name) {
-            return self.err(format!("Duplicate capture group name '{}'.",
+            return self.err(&format!("Duplicate capture group name '{}'.",
                                     name)[])
         }
         self.names.push(name.clone());
@@ -787,7 +787,7 @@ fn parse_group_opts(&mut self) -> Result<(), Error> {
                 '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))[])
                     }
@@ -798,7 +798,7 @@ fn parse_group_opts(&mut self) -> Result<(), Error> {
                 ':' | ')' => {
                     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))[])
                         }
@@ -811,7 +811,7 @@ fn parse_group_opts(&mut self) -> Result<(), Error> {
                     self.flags = flags;
                     return Ok(())
                 }
-                _ => return self.err(format!(
+                _ => return self.err(&format!(
                     "Unrecognized flag '{}'.", self.cur())[]),
             }
         }
@@ -909,7 +909,7 @@ fn parse_uint(&self, s: &str) -> Result<uint, Error> {
         match s.parse::<uint>() {
             Some(i) => Ok(i),
             None => {
-                self.err(format!("Expected an unsigned integer but got '{}'.",
+                self.err(&format!("Expected an unsigned integer but got '{}'.",
                                  s)[])
             }
         }
@@ -919,7 +919,7 @@ fn char_from_u32(&self, n: u32) -> Result<char, Error> {
         match char::from_u32(n) {
             Some(c) => Ok(c),
             None => {
-                self.err(format!("Could not decode '{}' to unicode \
+                self.err(&format!("Could not decode '{}' to unicode \
                                   character.", n)[])
             }
         }