Raise re.error on invalid escapes when calling re.sub

Also remove test case which is failed by CPython 3.4.1 in the gate.

Author: jirkamarsik

graalpython/com.oracle.graal.python.test/src/tests/test_re.py

@@ -159,8 +159,13 @@ def test_basic_re_sub(self):
         self.assertEqual(re.sub('a', '\t\n\v\r\f\a\b', 'a'),
                          (chr(9) + chr(10) + chr(11) + chr(13) + chr(12) + chr(7) + chr(8)))
 
-        for c in 'cdehijklmopqsuwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
-            self.assertEqual(re.sub('a', '\\' + c, 'a'), '\\' + c)
+        # The following behavior is correct w.r.t. Python 3.7. However, currently
+        # the gate uses CPython 3.4.1 to validate the test suite,
+        # which does not pass this test case, so we have to skip.
+        # for c in 'cdehijklmopqsuwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
+        #     with self.assertRaises(re.error):
+        #         self.assertEqual(re.sub('a', '\\' + c, 'a'), '\\' + c)
+
 
         self.assertEqual(re.sub(r'^\s*', 'X', 'test'), 'Xtest')
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/bytes/BytesUtils.java

@@ -199,7 +199,9 @@ public static StringBuilder decodeEscapes(ParserErrorCallback errors, String str
                     }
                     throw errors.raise(ValueError, "invalid \\x escape at position %d", i);
                 default:
-                    if (regexMode) {
+                    if (regexMode && (chr == '\\' || chr == 'g' || (chr >= '0' && chr <= '9'))) {
+                        // only allow backslashes, named group references and numbered group
+                        // references in regex mode
                         charList.append('\\');
                         charList.append(chr);
                     } else {

graalpython/lib-graalpython/_sre.py

@@ -336,26 +336,26 @@ def group(match_result, group_nr, string):
         while pos != -1 and start < n:
             if pos+1 < n:
                 if repl[pos + 1].isdigit() and match_result.groupCount > 0:
+                    # TODO: Should handle backreferences longer than 1 digit and fall back to octal escapes.
                     group_nr = int(repl[pos+1].decode('ascii')) if self.__binary else int(repl[pos+1])
                     group_str = group(match_result, group_nr, string)
                     if group_str is None:
-                        raise ValueError("invalid group reference %s at position %s" % (group_nr, pos))
+                        raise error("invalid group reference %s at position %s" % (group_nr, pos))
                     result += repl[start:pos] + group_str
                     start = pos + 2
                 elif repl[pos + 1] == (b'g' if self.__binary else 'g'):
                     group_ref, group_ref_end, digits_only = self.__extract_groupname(repl, pos + 2)
                     if group_ref:
                         group_str = group(match_result, int(group_ref) if digits_only else pattern.groups[group_ref], string)
                         if group_str is None:
-                            raise ValueError("invalid group reference %s at position %s" % (group_ref, pos))
+                            raise error("invalid group reference %s at position %s" % (group_ref, pos))
                         result += repl[start:pos] + group_str
                     start = group_ref_end + 1
                 elif repl[pos + 1] == backslash:
                     result += repl[start:pos] + backslash
                     start = pos + 2
                 else:
-                    result += repl[start:pos + 2]
-                    start = pos + 2
+                    assert False, "unexpected escape in re.sub"
             pos = repl.find(backslash, start)
         result += repl[start:]
         return result
@@ -386,7 +386,10 @@ def sub(self, repl, string, count=0):
         is_string_rep = isinstance(repl, str) or _is_bytes_like(repl)
         if is_string_rep:
             self.__check_input_type(repl)
-            repl = _process_escape_sequences(repl)
+            try:
+                repl = _process_escape_sequences(repl)
+            except ValueError as e:
+                raise error(str(e))
         while (count == 0 or n < count) and pos <= len(string):
             match_result = tregex_call_exec(pattern.exec, string, pos)
             if not match_result.isMatch: