---

yaml
---
r: 157598
b: refs/heads/snap-stage3
c: 48daba0
h: refs/heads/master
v: v3

Author: pczarn

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 065caf34f5ff29e04605f95d9c5d511af219439a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: e2e47d6eb5425cd860137d632c1b8688e5e74241
+refs/heads/snap-stage3: 48daba088b0f353cc4fdaba144da7a2c1b1de87f
 refs/heads/try: 0ee4d8b0b112c608646fa75463ab4dc59132efd9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libregex/parse.rs

@@ -375,15 +375,15 @@ impl<'a> Parser<'a> {
         let mut alts: Vec<Ast> = vec!();
 
         if self.peek_is(1, ']') {
-            try!(self.expect(']'))
+            try!(self.expect(']'));
             ranges.push((']', ']'))
         }
         while self.peek_is(1, '-') {
-            try!(self.expect('-'))
+            try!(self.expect('-'));
             ranges.push(('-', '-'))
         }
         loop {
-            try!(self.noteof("a closing ']' or a non-empty character class)"))
+            try!(self.noteof("a closing ']' or a non-empty character class)"));
             let mut c = self.cur();
             match c {
                 '[' =>
@@ -428,12 +428,23 @@ impl<'a> Parser<'a> {
                     }
                     return Ok(())
                 }
+                _ => {}
             }
 
             if self.peek_is(1, '-') && !self.peek_is(2, ']') {
-                try!(self.expect('-'))
-                try!(self.noteof("not a ']'"))
-                let c2 = self.cur();
+                try!(self.expect('-'));
+                // The regex can't end here.
+                try!(self.noteof("not a ']'"));
+                // End the range with a single character or character escape.
+                let mut c2 = self.cur();
+                if c2 == '\\' {
+                    match try!(self.parse_escape()) {
+                        Literal(c3, _) => c2 = c3, // allow literal escapes below
+                        ast =>
+                            return self.err(format!("Expected a literal, but got {}.",
+                                                    ast).as_slice()),
+                    }
+                }
                 if c2 < c {
                     return self.err(format!("Invalid character class \
                                              range '{}-{}'",

branches/snap-stage3/src/libregex/test/tests.rs

@@ -53,6 +53,13 @@ fn quoted_bracket_set() {
     assert_eq!(ms, vec![(0, 1), (1, 2)]);
 }
 
+#[test]
+fn range_ends_with_escape() {
+    let re = regex!(r"([\[-\x{5d}])");
+    let ms = re.find_iter("[]").collect::<Vec<(uint, uint)>>();
+    assert_eq!(ms, vec![(0, 1), (1, 2)]);
+}
+
 macro_rules! replace(
     ($name:ident, $which:ident, $re:expr,
      $search:expr, $replace:expr, $result:expr) => (
@@ -124,6 +131,10 @@ noparse!(fail_double_neg, "(?-i-i)")
 noparse!(fail_neg_empty, "(?i-)")
 noparse!(fail_empty_group, "()")
 noparse!(fail_dupe_named, "(?P<a>.)(?P<a>.)")
+noparse!(fail_range_end_no_class, "[a-[:lower:]]")
+noparse!(fail_range_end_no_begin, r"[a-\A]")
+noparse!(fail_range_end_no_end, r"[a-\z]")
+noparse!(fail_range_end_no_boundary, r"[a-\b]")
 
 macro_rules! mat(
     ($name:ident, $re:expr, $text:expr, $($loc:tt)+) => (