8000 bpo-433030: Add support of atomic grouping in regular expressions by serhiy-storchaka · Pull Request #31982 · python/cpython · GitHub
[go: up one dir, main page]
Skip to content

bpo-433030: Add support of atomic grouping in regular expressions #31982

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 9 commits into from
Mar 21, 2022
Merged

bpo-433030: Add support of atomic grouping in regular expressions #31982

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
a4f8ac0
bpo-433030: Add support of atomic grouping in regular expressions
serhiy-storchaka Mar 18, 2022
5066bd1
Polishing.
serhiy-storchaka Mar 19, 2022
8015968
Update documentation.
serhiy-storchaka Mar 19, 2022
599109c
Fix incorrect use of the term role.
serhiy-storchaka Mar 19, 2022
711975d
Polishing.
serhiy-storchaka Mar 20, 2022
1ff76c3
Merge branch 'main' into re-atomic-groups
serhiy-storchaka Mar 20, 2022
9d54059
Simplify the compliler code.
serhiy-storchaka Mar 20, 2022
7e4f64a
Fix possesive repetition of 1-character pattern
serhiy-storchaka Mar 21, 2022
b9e20f0
Add the original author in Misc/ACKS.
serhiy-storchaka Mar 21, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Fix possesive repetition of 1-character pattern
  • Loading branch information
@serhiy-storchaka
serhiy-storchaka committed Mar 21, 2022
commit 7e4f64aa33774fd57d30ae3003eb00736210b1a7
60 changes: 60 additions & 0 deletions Lib/test/test_re.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2077,6 +2077,36 @@ def test_possessive_qualifiers(self):
self.assertIsNone(re.match("^x{}+$", "xxx"))
self.assertTrue(re.match("^x{}+$", "x{}"))

def test_fullmatch_possessive_qualifiers(self):
self.assertTrue(re.fullmatch(r'a++', 'a'))
self.assertTrue(re.fullmatch(r'a*+', 'a'))
self.assertTrue(re.fullmatch(r'a?+', 'a'))
self.assertTrue(re.fullmatch(r'a{1,3}+', 'a'))
self.assertIsNone(re.fullmatch(r'a++', 'ab'))
self.assertIsNone(re.fullmatch(r'a*+', 'ab'))
self.assertIsNone(re.fullmatch(r'a?+', 'ab'))
self.assertIsNone(re.fullmatch(r'a{1,3}+', 'ab'))

self.assertTrue(re.fullmatch(r'(?:ab)++', 'ab'))
self.assertTrue(re.fullmatch(r'(?:ab)*+', 'ab'))
self.assertTrue(re.fullmatch(r'(?:ab)?+', 'ab'))
self.assertTrue(re.fullmatch(r'(?:ab){1,3}+', 'ab'))
self.assertIsNone(re.fullmatch(r'(?:ab)++', 'abc'))
self.assertIsNone(re.fullmatch(r'(?:ab)*+', 'abc'))
self.assertIsNone(re.fullmatch(r'(?:ab)?+', 'abc'))
self.assertIsNone(re.fullmatch(r'(?:ab){1,3}+', 'abc'))

def test_findall_possessive_qualifiers(self):
self.assertEqual(re.findall(r'a++', 'aab'), ['aa'])
self.assertEqual(re.findall(r'a*+', 'aab'), ['aa', '', ''])
self.assertEqual(re.findall(r'a?+', 'aab'), ['a', 'a', '', ''])
self.assertEqual(re.findall(r'a{1,3}+', 'aab'), ['aa'])

self.assertEqual(re.findall(r'(?:ab)++', 'ababc'), ['abab'])
self.assertEqual(re.findall(r'(?:ab)*+', 'ababc'), ['abab', '', ''])
self.assertEqual(re.findall(r'(?:ab)?+', 'ababc'), ['ab', 'ab', '', ''])
self.assertEqual(re.findall(r'(?:ab){1,3}+', 'ababc'), ['abab'])

def test_atomic_grouping(self):
"""Test Atomic Grouping
Test non-capturing groups of the form (?>...), which does
Expand All @@ -2091,6 +2121,36 @@ def test_atomic_grouping(self):
self.assertIsNone(re.match(r'(?>x)++x', 'xxx'))
self.assertIsNone(re.match(r'(?>x++)x', 'xxx'))

def test_fullmatch_atomic_grouping(self):
self.assertTrue(re.fullmatch(r'(?>a+)', 'a'))
self.assertTrue(re.fullmatch(r'(?>a*)', 'a'))
self.assertTrue(re.fullmatch(r'(?>a?)', 'a'))
self.assertTrue(re.fullmatch(r'(?>a{1,3})', 'a'))
self.assertIsNone(re.fullmatch(r'(?>a+)', 'ab'))
self.assertIsNone(re.fullmatch(r'(?>a*)', 'ab'))
self.assertIsNone(re.fullmatch(r'(?>a?)', 'ab'))
self.assertIsNone(re.fullmatch(r'(?>a{1,3})', 'ab'))

self.assertTrue(re.fullmatch(r'(?>(?:ab)+)', 'ab'))
self.assertTrue(re.fullmatch(r'(?>(?:ab)*)', 'ab'))
self.assertTrue(re.fullmatch(r'(?>(?:ab)?)', 'ab'))
self.assertTrue(re.fullmatch(r'(?>(?:ab){1,3})', 'ab'))
self.assertIsNone(re.fullmatch(r'(?>(?:ab)+)', 'abc'))
self.assertIsNone(re.fullmatch(r'(?>(?:ab)*)', 'abc'))
self.assertIsNone(re.fullmatch(r'(?>(?:ab)?)', 'abc'))
self.assertIsNone(re.fullmatch(r'(?>(?:ab){1,3})', 'abc'))

def test_findall_atomic_grouping(self):
self.assertEqual(re.findall(r'(?>a+)', 'aab'), ['aa'])
self.assertEqual(re.findall(r'(?>a*)', 'aab'), ['aa', '', ''])
self.assertEqual(re.findall(r'(?>a?)', 'aab'), ['a', 'a', '', ''])
self.assertEqual(re.findall(r'(?>a{1,3})', 'aab'), ['aa'])

self.assertEqual(re.findall(r'(?>(?:ab)+)', 'ababc'), ['abab'])
self.assertEqual(re.findall(r'(?>(?:ab)*)', 'ababc'), ['abab', '', ''])
self.assertEqual(re.findall(r'(?>(?:ab)?)', 'ababc'), ['ab', 'ab', '', ''])
self.assertEqual(re.findall(r'(?>(?:ab){1,3})', 'ababc'), ['abab'])


def get_debug_out(pat):
with captured_stdout() as out:
Expand Down
5 changes: 4 additions & 1 deletion Modules/sre_lib.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -995,7 +995,10 @@ SRE(match)(SRE_STATE* state, const SRE_CODE* pattern, int toplevel)

/* Let the tail be evaluated separately and consider this
match successful. */
if (*ctx->pattern == SRE_OP_SUCCESS) {
if (*ctx->pattern == SRE_OP_SUCCESS &&
ctx->ptr == state->end &&
!(ctx->toplevel && state->must_advance && ctx->ptr == state->start))
{
/* tail is empty. we're finished */
state->ptr = ctx->ptr;
RETURN_SUCCESS;
Expand Down
0