backout 9fcf4008b626 (#9179) for further consideration

diff --git a/Lib/re.py b/Lib/re.py
index 82244db3cd24e770e1b8907686e293806b6986f1..199afee4b90418df7885a52246f173821bb6785f 100644 (file)
--- a/Lib/re.py
+++ b/Lib/re.py
@@ -352,11 +352,10 @@ class Scanner:
         s = sre_parse.Pattern()
         s.flags = flags
         for phrase, action in lexicon:
-            gid = s.opengroup()
             p.append(sre_parse.SubPattern(s, [
-                (SUBPATTERN, (gid, sre_parse.parse(phrase, flags))),
+                (SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
                 ]))
-            s.closegroup(gid, p[-1])
+        s.groups = len(p)+1
         p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
         self.scanner = sre_compile.compile(p)
     def scan(self, string):

diff --git a/Lib/sre_parse.py b/Lib/sre_parse.py
index fad80148aa27fefe7c6ee5ffc5c58594dc020902..b56d437c3479d04fc1f0351071bad85c9d8d7be1 100644 (file)
--- a/Lib/sre_parse.py
+++ b/Lib/sre_parse.py
@@ -66,25 +66,24 @@ class Pattern:
     # master pattern object.  keeps track of global attributes
     def __init__(self):
         self.flags = 0
+        self.open = []
+        self.groups = 1
         self.groupdict = {}
-        self.subpatterns = [None]  # group 0
-    @property
-    def groups(self):
-        return len(self.subpatterns)
     def opengroup(self, name=None):
         gid = self.groups
-        self.subpatterns.append(None)
+        self.groups = gid + 1
         if name is not None:
             ogid = self.groupdict.get(name, None)
             if ogid is not None:
                 raise error("redefinition of group name %s as group %d; "
                             "was group %d" % (repr(name), gid,  ogid))
             self.groupdict[name] = gid
+        self.open.append(gid)
         return gid
-    def closegroup(self, gid, p):
-        self.subpatterns[gid] = p
+    def closegroup(self, gid):
+        self.open.remove(gid)
     def checkgroup(self, gid):
-        return gid < self.groups and self.subpatterns[gid] is not None
+        return gid < self.groups and gid not in self.open
 
 class SubPattern:
     # a subpattern, in intermediate form
@@ -182,21 +181,7 @@ class SubPattern:
             elif op in UNITCODES:
                 lo = lo + 1
                 hi = hi + 1
-            elif op is GROUPREF:
-                i, j = self.pattern.subpatterns[av].getwidth()
-                lo = lo + i
-                hi = hi + j
-            elif op is GROUPREF_EXISTS:
-                i, j = av[1].getwidth()
-                if av[2] is not None:
-                    l, h = av[2].getwidth()
-                    i = min(i, l)
-                    j = max(j, h)
-                else:
-                    i = 0
-                lo = lo + i
-                hi = hi + j
-            elif op is SUCCESS:
+            elif op == SUCCESS:
                 break
         self.width = min(lo, MAXREPEAT - 1), min(hi, MAXREPEAT)
         return self.width
@@ -724,7 +709,7 @@ def _parse(source, state):
                 if not sourcematch(")"):
                     raise error("unbalanced parenthesis")
                 if group is not None:
-                    state.closegroup(group, p)
+                    state.closegroup(group)
                 subpatternappend((SUBPATTERN, (group, p)))
             else:
                 while 1:

diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py
index 42672f578ea3a89da7024dd7fe4ceebb52a5879a..8251c26993c456bec0f50998a723e9694f9babe1 100644 (file)
--- a/Lib/test/test_re.py
+++ b/Lib/test/test_re.py
@@ -557,7 +557,7 @@ class ReTests(unittest.TestCase):
         self.assertEqual(re.match("a.*b", "a\n\nb", re.DOTALL).group(0),
                          "a\n\nb")
 
-    def test_lookahead(self):
+    def test_non_consuming(self):
         self.assertEqual(re.match("(a(?=\s[^a]))", "a b").group(1), "a")
         self.assertEqual(re.match("(a(?=\s[^a]*))", "a b").group(1), "a")
         self.assertEqual(re.match("(a(?=\s[abc]))", "a b").group(1), "a")
@@ -571,42 +571,6 @@ class ReTests(unittest.TestCase):
         self.assertEqual(re.match(r"(a)(?!\s\1)", "a b").group(1), "a")
         self.assertEqual(re.match(r"(a)(?!\s(abc|a))", "a b").group(1), "a")
 
-        # Group reference.
-        self.assertTrue(re.match(r'(a)b(?=\1)a', 'aba'))
-        self.assertIsNone(re.match(r'(a)b(?=\1)c', 'abac'))
-        # Conditional group reference.
-        self.assertTrue(re.match('(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
-        self.assertIsNone(re.match('(?:(a)|(x))b(?=(?(2)c|x))c', 'abc'))
-        self.assertTrue(re.match('(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
-        self.assertIsNone(re.match('(?:(a)|(x))b(?=(?(1)b|x))c', 'abc'))
-        self.assertTrue(re.match('(?:(a)|(x))b(?=(?(1)c|x))c', 'abc'))
-        # Group used before defined.
-        self.assertTrue(re.match('(a)b(?=(?(2)x|c))(c)', 'abc'))
-        self.assertIsNone(re.match('(a)b(?=(?(2)b|x))(c)', 'abc'))
-        self.assertTrue(re.match('(a)b(?=(?(1)c|x))(c)', 'abc'))
-
-    def test_lookbehind(self):
-        self.assertTrue(re.match('ab(?<=b)c', 'abc'))
-        self.assertIsNone(re.match('ab(?<=c)c', 'abc'))
-        self.assertIsNone(re.match('ab(?<!b)c', 'abc'))
-        self.assertTrue(re.match('ab(?<!c)c', 'abc'))
-        # Group reference.
-        self.assertTrue(re.match(r'(a)a(?<=\1)c', 'aac'))
-        self.assertIsNone(re.match(r'(a)b(?<=\1)a', 'abaa'))
-        self.assertIsNone(re.match(r'(a)a(?<!\1)c', 'aac'))
-        self.assertTrue(re.match(r'(a)b(?<!\1)a', 'abaa'))
-        # Conditional group reference.
-        self.assertIsNone(re.match('(?:(a)|(x))b(?<=(?(2)x|c))c', 'abc'))
-        self.assertIsNone(re.match('(?:(a)|(x))b(?<=(?(2)b|x))c', 'abc'))
-        self.assertTrue(re.match('(?:(a)|(x))b(?<=(?(2)x|b))c', 'abc'))
-        self.assertIsNone(re.match('(?:(a)|(x))b(?<=(?(1)c|x))c', 'abc'))
-        self.assertTrue(re.match('(?:(a)|(x))b(?<=(?(1)b|x))c', 'abc'))
-        # Group used before defined.
-        self.assertIsNone(re.match('(a)b(?<=(?(2)x|c))(c)', 'abc'))
-        self.assertIsNone(re.match('(a)b(?<=(?(2)b|x))(c)', 'abc'))
-        self.assertIsNone(re.match('(a)b(?<=(?(1)c|x))(c)', 'abc'))
-        self.assertTrue(re.match('(a)b(?<=(?(1)b|x))(c)', 'abc'))
-
     def test_ignore_case(self):
         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
         self.assertEqual(re.match(b"abc", b"ABC", re.I).group(0), b"ABC")

diff --git a/Misc/NEWS b/Misc/NEWS
index 924a8a205353d5a789cf839670b92a7047253c8b..6916ca3f539b2a2284e6de39ce6e1b0c85ef6be5 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -68,9 +68,6 @@ Library
 - Issue #22821: Fixed fcntl() with integer argument on 64-bit big-endian
   platforms.
 
-- Issues #814253, #9179: Group references and conditional group references now
-  work in lookbehind assertions in regular expressions.
-
 - Issue #22406: Fixed the uu_codec codec incorrectly ported to 3.x.
   Based on patch by Martin Panter.