summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Lib/test/test_re.py23
-rw-r--r--Misc/NEWS2
-rw-r--r--Modules/_sre.c700
-rw-r--r--Modules/sre.h9
4 files changed, 350 insertions, 384 deletions
diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py
index 9ee077d..8d63fac 100644
--- a/Lib/test/test_re.py
+++ b/Lib/test/test_re.py
@@ -77,6 +77,8 @@ class ReTests(unittest.TestCase):
self.assertTypedEqual(re.sub(b'y', B(b'a'), B(b'xyz')), b'xaz')
self.assertTypedEqual(re.sub(b'y', bytearray(b'a'), bytearray(b'xyz')), b'xaz')
self.assertTypedEqual(re.sub(b'y', memoryview(b'a'), memoryview(b'xyz')), b'xaz')
+ for y in ("\xe0", "\u0430", "\U0001d49c"):
+ self.assertEqual(re.sub(y, 'a', 'x%sz' % y), 'xaz')
self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')
self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),
@@ -250,6 +252,13 @@ class ReTests(unittest.TestCase):
[b'', b'a', b'b', b'c'])
self.assertTypedEqual(re.split(b"(:*)", string),
[b'', b':', b'a', b':', b'b', b'::', b'c'])
+ for a, b, c in ("\xe0\xdf\xe7", "\u0430\u0431\u0432",
+ "\U0001d49c\U0001d49e\U0001d4b5"):
+ string = ":%s:%s::%s" % (a, b, c)
+ self.assertEqual(re.split(":", string), ['', a, b, '', c])
+ self.assertEqual(re.split(":*", string), ['', a, b, c])
+ self.assertEqual(re.split("(:*)", string),
+ ['', ':', a, ':', b, '::', c])
self.assertEqual(re.split("(?::*)", ":a:b::c"), ['', 'a', 'b', 'c'])
self.assertEqual(re.split("(:)*", ":a:b::c"),
@@ -287,6 +296,14 @@ class ReTests(unittest.TestCase):
[b":", b"::", b":::"])
self.assertTypedEqual(re.findall(b"(:)(:*)", string),
[(b":", b""), (b":", b":"), (b":", b"::")])
+ for x in ("\xe0", "\u0430", "\U0001d49c"):
+ xx = x * 2
+ xxx = x * 3
+ string = "a%sb%sc%sd" % (x, xx, xxx)
+ self.assertEqual(re.findall("%s+" % x, string), [x, xx, xxx])
+ self.assertEqual(re.findall("(%s+)" % x, string), [x, xx, xxx])
+ self.assertEqual(re.findall("(%s)(%s*)" % (x, x), string),
+ [(x, ""), (x, x), (x, xx)])
def test_bug_117612(self):
self.assertEqual(re.findall(r"(a|(b))", "aba"),
@@ -305,6 +322,12 @@ class ReTests(unittest.TestCase):
self.assertEqual(re.match(b'(a)', string).group(0), b'a')
self.assertEqual(re.match(b'(a)', string).group(1), b'a')
self.assertEqual(re.match(b'(a)', string).group(1, 1), (b'a', b'a'))
+ for a in ("\xe0", "\u0430", "\U0001d49c"):
+ self.assertEqual(re.match(a, a).groups(), ())
+ self.assertEqual(re.match('(%s)' % a, a).groups(), (a,))
+ self.assertEqual(re.match('(%s)' % a, a).group(0), a)
+ self.assertEqual(re.match('(%s)' % a, a).group(1), a)
+ self.assertEqual(re.match('(%s)' % a, a).group(1, 1), (a, a))
pat = re.compile('((a)|(b))(c)?')
self.assertEqual(pat.match('a').groups(), ('a', 'a', None, None))
diff --git a/Misc/NEWS b/Misc/NEWS
index af55f72..3ba47ef 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -21,6 +21,8 @@ Core and Builtins
Library
-------
+- Issue #18685: Restore re performance to pre-PEP 393 levels.
+
- Issue #19339: telnetlib module is now using time.monotonic() when available
to compute timeout.
diff --git a/Modules/_sre.c b/Modules/_sre.c
index dd9d664..d71cc21 100644
--- a/Modules/_sre.c
+++ b/Modules/_sre.c
@@ -46,6 +46,8 @@ static char copyright[] =
#include "sre.h"
+#define SRE_CODE_BITS (8 * sizeof(SRE_CODE))
+
#include <ctype.h>
/* name of this module, minus the leading underscore */
@@ -58,9 +60,6 @@ static char copyright[] =
/* defining this one enables tracing */
#undef VERBOSE
-/* defining this enables unicode support (default under 1.6a1 and later) */
-#define HAVE_UNICODE
-
/* -------------------------------------------------------------------- */
/* optional features */
@@ -146,9 +145,6 @@ static unsigned int sre_lower(unsigned int ch)
/* locale-specific character predicates */
/* !(c & ~N) == (c < N+1) for any unsigned c, this avoids
* warnings when c's type supports only numbers < N+1 */
-#define SRE_LOC_IS_DIGIT(ch) (!((ch) & ~255) ? isdigit((ch)) : 0)
-#define SRE_LOC_IS_SPACE(ch) (!((ch) & ~255) ? isspace((ch)) : 0)
-#define SRE_LOC_IS_LINEBREAK(ch) ((ch) == '\n')
#define SRE_LOC_IS_ALNUM(ch) (!((ch) & ~255) ? isalnum((ch)) : 0)
#define SRE_LOC_IS_WORD(ch) (SRE_LOC_IS_ALNUM((ch)) || (ch) == '_')
@@ -252,55 +248,39 @@ data_stack_grow(SRE_STATE* state, Py_ssize_t size)
/* generate 8-bit version */
-#define SRE_CHAR unsigned char
-#define SRE_CHARGET(state, buf, index) ((unsigned char*)buf)[index]
-#define SRE_AT sre_at
-#define SRE_COUNT sre_count
-#define SRE_CHARSET sre_charset
-#define SRE_INFO sre_info
-#define SRE_MATCH sre_match
-#define SRE_MATCH_CONTEXT sre_match_context
-#define SRE_SEARCH sre_search
+#define SRE_CHAR Py_UCS1
+#define SIZEOF_SRE_CHAR 1
+#define SRE(F) sre_ucs1_##F
+#define SRE_RECURSIVE
+#include "_sre.c"
+
+/* generate 16-bit unicode version */
+
+#define SRE_CHAR Py_UCS2
+#define SIZEOF_SRE_CHAR 2
+#define SRE(F) sre_ucs2_##F
+#define SRE_RECURSIVE
+#include "_sre.c"
+
+/* generate 32-bit unicode version */
+#define SRE_CHAR Py_UCS4
+#define SIZEOF_SRE_CHAR 4
+#define SRE(F) sre_ucs4_##F
#define SRE_RECURSIVE
#include "_sre.c"
-#undef SRE_RECURSIVE
-
-#undef SRE_SEARCH
-#undef SRE_MATCH
-#undef SRE_MATCH_CONTEXT
-#undef SRE_INFO
-#undef SRE_CHARSET
-#undef SRE_COUNT
-#undef SRE_AT
-#undef SRE_CHAR
-#undef SRE_CHARGET
-
-/* generate 8/16/32-bit unicode version */
-
-#define SRE_CHAR void
-#define SRE_CHARGET(state, buf, index) \
- ((state->charsize==1) ? ((Py_UCS1*)buf)[index] : \
- (state->charsize==2) ? ((Py_UCS2*)buf)[index] : \
- ((Py_UCS4*)buf)[index])
-#define SRE_AT sre_uat
-#define SRE_COUNT sre_ucount
-#define SRE_CHARSET sre_ucharset
-#define SRE_INFO sre_uinfo
-#define SRE_MATCH sre_umatch
-#define SRE_MATCH_CONTEXT sre_umatch_context
-#define SRE_SEARCH sre_usearch
#endif /* SRE_RECURSIVE */
+#ifdef SRE_RECURSIVE
/* -------------------------------------------------------------------- */
/* String matching engine */
-/* the following section is compiled twice, with different character
+/* the following section is compiled three times, with different character
settings */
LOCAL(int)
-SRE_AT(SRE_STATE* state, char* ptr, SRE_CODE at)
+SRE(at)(SRE_STATE* state, SRE_CHAR* ptr, SRE_CODE at)
{
/* check if pointer is at given position */
@@ -314,16 +294,16 @@ SRE_AT(SRE_STATE* state, char* ptr, SRE_CODE at)
case SRE_AT_BEGINNING_LINE:
return ((void*) ptr == state->beginning ||
- SRE_IS_LINEBREAK((int) SRE_CHARGET(state, ptr, -1)));
+ SRE_IS_LINEBREAK((int) ptr[-1]));
case SRE_AT_END:
- return (((void*) (ptr+state->charsize) == state->end &&
- SRE_IS_LINEBREAK((int) SRE_CHARGET(state, ptr, 0))) ||
+ return (((void*) (ptr+1) == state->end &&
+ SRE_IS_LINEBREAK((int) ptr[0])) ||
((void*) ptr == state->end));
case SRE_AT_END_LINE:
return ((void*) ptr == state->end ||
- SRE_IS_LINEBREAK((int) SRE_CHARGET(state, ptr, 0)));
+ SRE_IS_LINEBREAK((int) ptr[0]));
case SRE_AT_END_STRING:
return ((void*) ptr == state->end);
@@ -332,54 +312,54 @@ SRE_AT(SRE_STATE* state, char* ptr, SRE_CODE at)
if (state->beginning == state->end)
return 0;
thatp = ((void*) ptr > state->beginning) ?
- SRE_IS_WORD((int) SRE_CHARGET(state, ptr, -1)) : 0;
+ SRE_IS_WORD((int) ptr[-1]) : 0;
thisp = ((void*) ptr < state->end) ?
- SRE_IS_WORD((int) SRE_CHARGET(state, ptr, 0)) : 0;
+ SRE_IS_WORD((int) ptr[0]) : 0;
return thisp != thatp;
case SRE_AT_NON_BOUNDARY:
if (state->beginning == state->end)
return 0;
thatp = ((void*) ptr > state->beginning) ?
- SRE_IS_WORD((int) SRE_CHARGET(state, ptr, -1)) : 0;
+ SRE_IS_WORD((int) ptr[-1]) : 0;
thisp = ((void*) ptr < state->end) ?
- SRE_IS_WORD((int) SRE_CHARGET(state, ptr, 0)) : 0;
+ SRE_IS_WORD((int) ptr[0]) : 0;
return thisp == thatp;
case SRE_AT_LOC_BOUNDARY:
if (state->beginning == state->end)
return 0;
thatp = ((void*) ptr > state->beginning) ?
- SRE_LOC_IS_WORD((int) SRE_CHARGET(state, ptr, -1)) : 0;
+ SRE_LOC_IS_WORD((int) ptr[-1]) : 0;
thisp = ((void*) ptr < state->end) ?
- SRE_LOC_IS_WORD((int) SRE_CHARGET(state, ptr, 0)) : 0;
+ SRE_LOC_IS_WORD((int) ptr[0]) : 0;
return thisp != thatp;
case SRE_AT_LOC_NON_BOUNDARY:
if (state->beginning == state->end)
return 0;
thatp = ((void*) ptr > state->beginning) ?
- SRE_LOC_IS_WORD((int) SRE_CHARGET(state, ptr, -1)) : 0;
+ SRE_LOC_IS_WORD((int) ptr[-1]) : 0;
thisp = ((void*) ptr < state->end) ?
- SRE_LOC_IS_WORD((int) SRE_CHARGET(state, ptr, 0)) : 0;
+ SRE_LOC_IS_WORD((int) ptr[0]) : 0;
return thisp == thatp;
case SRE_AT_UNI_BOUNDARY:
if (state->beginning == state->end)
return 0;
thatp = ((void*) ptr > state->beginning) ?
- SRE_UNI_IS_WORD((int) SRE_CHARGET(state, ptr, -1)) : 0;
+ SRE_UNI_IS_WORD((int) ptr[-1]) : 0;
thisp = ((void*) ptr < state->end) ?
- SRE_UNI_IS_WORD((int) SRE_CHARGET(state, ptr, 0)) : 0;
+ SRE_UNI_IS_WORD((int) ptr[0]) : 0;
return thisp != thatp;
case SRE_AT_UNI_NON_BOUNDARY:
if (state->beginning == state->end)
return 0;
thatp = ((void*) ptr > state->beginning) ?
- SRE_UNI_IS_WORD((int) SRE_CHARGET(state, ptr, -1)) : 0;
+ SRE_UNI_IS_WORD((int) ptr[-1]) : 0;
thisp = ((void*) ptr < state->end) ?
- SRE_UNI_IS_WORD((int) SRE_CHARGET(state, ptr, 0)) : 0;
+ SRE_UNI_IS_WORD((int) ptr[0]) : 0;
return thisp == thatp;
}
@@ -388,7 +368,7 @@ SRE_AT(SRE_STATE* state, char* ptr, SRE_CODE at)
}
LOCAL(int)
-SRE_CHARSET(SRE_CODE* set, SRE_CODE ch)
+SRE(charset)(SRE_CODE* set, SRE_CODE ch)
{
/* check if character is a member of the given set */
@@ -411,22 +391,15 @@ SRE_CHARSET(SRE_CODE* set, SRE_CODE ch)
/* <CATEGORY> <code> */
if (sre_category(set[0], (int) ch))
return ok;
- set += 1;
+ set++;
break;
case SRE_OP_CHARSET:
- if (sizeof(SRE_CODE) == 2) {
- /* <CHARSET> <bitmap> (16 bits per code word) */
- if (ch < 256 && (set[ch >> 4] & (1 << (ch & 15))))
- return ok;
- set += 16;
- }
- else {
- /* <CHARSET> <bitmap> (32 bits per code word) */
- if (ch < 256 && (set[ch >> 5] & (1u << (ch & 31))))
- return ok;
- set += 8;
- }
+ /* <CHARSET> <bitmap> */
+ if (ch < 256 &&
+ (set[ch/SRE_CODE_BITS] & (1u << (ch & (SRE_CODE_BITS-1)))))
+ return ok;
+ set += 256/SRE_CODE_BITS;
break;
case SRE_OP_RANGE:
@@ -446,26 +419,16 @@ SRE_CHARSET(SRE_CODE* set, SRE_CODE ch)
Py_ssize_t count, block;
count = *(set++);
- if (sizeof(SRE_CODE) == 2) {
+ if (ch < 0x10000u)
block = ((unsigned char*)set)[ch >> 8];
- set += 128;
- if (set[block*16 + ((ch & 255)>>4)] & (1 << (ch & 15)))
- return ok;
- set += count*16;
- }
- else {
- /* !(c & ~N) == (c < N+1) for any unsigned c, this avoids
- * warnings when c's type supports only numbers < N+1 */
- if (!(ch & ~65535))
- block = ((unsigned char*)set)[ch >> 8];
- else
- block = -1;
- set += 64;
- if (block >=0 &&
- (set[block*8 + ((ch & 255)>>5)] & (1u << (ch & 31))))
- return ok;
- set += count*8;
- }
+ else
+ block = -1;
+ set += 256/sizeof(SRE_CODE);
+ if (block >=0 &&
+ (set[(block * 256 + (ch & 255))/SRE_CODE_BITS] &
+ (1u << (ch & (SRE_CODE_BITS-1)))))
+ return ok;
+ set += count * (256/SRE_CODE_BITS);
break;
}
@@ -477,35 +440,35 @@ SRE_CHARSET(SRE_CODE* set, SRE_CODE ch)
}
}
-LOCAL(Py_ssize_t) SRE_MATCH(SRE_STATE* state, SRE_CODE* pattern);
+LOCAL(Py_ssize_t) SRE(match)(SRE_STATE* state, SRE_CODE* pattern);
LOCAL(Py_ssize_t)
-SRE_COUNT(SRE_STATE* state, SRE_CODE* pattern, Py_ssize_t maxcount)
+SRE(count)(SRE_STATE* state, SRE_CODE* pattern, Py_ssize_t maxcount)
{
SRE_CODE chr;
- char* ptr = (char *)state->ptr;
- char* end = (char *)state->end;
+ SRE_CHAR c;
+ SRE_CHAR* ptr = (SRE_CHAR *)state->ptr;
+ SRE_CHAR* end = (SRE_CHAR *)state->end;
Py_ssize_t i;
/* adjust end */
- if (maxcount < (end - ptr) / state->charsize && maxcount != SRE_MAXREPEAT)
- end = ptr + maxcount*state->charsize;
+ if (maxcount < end - ptr && maxcount != SRE_MAXREPEAT)
+ end = ptr + maxcount;
switch (pattern[0]) {
case SRE_OP_IN:
/* repeated set */
TRACE(("|%p|%p|COUNT IN\n", pattern, ptr));
- while (ptr < end &&
- SRE_CHARSET(pattern + 2, SRE_CHARGET(state, ptr, 0)))
- ptr += state->charsize;
+ while (ptr < end && SRE(charset)(pattern + 2, *ptr))
+ ptr++;
break;
case SRE_OP_ANY:
/* repeated dot wildcard. */
TRACE(("|%p|%p|COUNT ANY\n", pattern, ptr));
- while (ptr < end && !SRE_IS_LINEBREAK(SRE_CHARGET(state, ptr, 0)))
- ptr += state->charsize;
+ while (ptr < end && !SRE_IS_LINEBREAK(*ptr))
+ ptr++;
break;
case SRE_OP_ANY_ALL:
@@ -519,75 +482,87 @@ SRE_COUNT(SRE_STATE* state, SRE_CODE* pattern, Py_ssize_t maxcount)
/* repeated literal */
chr = pattern[1];
TRACE(("|%p|%p|COUNT LITERAL %d\n", pattern, ptr, chr));
- while (ptr < end && (SRE_CODE) SRE_CHARGET(state, ptr, 0) == chr)
- ptr += state->charsize;
+ c = (SRE_CHAR) chr;
+#if SIZEOF_SRE_CHAR < 4
+ if ((SRE_CODE) c != chr)
+ ; /* literal can't match: doesn't fit in char width */
+ else
+#endif
+ while (ptr < end && *ptr == c)
+ ptr++;
break;
case SRE_OP_LITERAL_IGNORE:
/* repeated literal */
chr = pattern[1];
TRACE(("|%p|%p|COUNT LITERAL_IGNORE %d\n", pattern, ptr, chr));
- while (ptr < end && (SRE_CODE) state->lower(SRE_CHARGET(state, ptr, 0)) == chr)
- ptr += state->charsize;
+ while (ptr < end && (SRE_CODE) state->lower(*ptr) == chr)
+ ptr++;
break;
case SRE_OP_NOT_LITERAL:
/* repeated non-literal */
chr = pattern[1];
TRACE(("|%p|%p|COUNT NOT_LITERAL %d\n", pattern, ptr, chr));
- while (ptr < end && (SRE_CODE) SRE_CHARGET(state, ptr, 0) != chr)
- ptr += state->charsize;
+ c = (SRE_CHAR) chr;
+#if SIZEOF_SRE_CHAR < 4
+ if ((SRE_CODE) c != chr)
+ ptr = end; /* literal can't match: doesn't fit in char width */
+ else
+#endif
+ while (ptr < end && *ptr != c)
+ ptr++;
break;
case SRE_OP_NOT_LITERAL_IGNORE:
/* repeated non-literal */
chr = pattern[1];
TRACE(("|%p|%p|COUNT NOT_LITERAL_IGNORE %d\n", pattern, ptr, chr));
- while (ptr < end && (SRE_CODE) state->lower(SRE_CHARGET(state, ptr, 0)) != chr)
- ptr += state->charsize;
+ while (ptr < end && (SRE_CODE) state->lower(*ptr) != chr)
+ ptr++;
break;
default:
/* repeated single character pattern */
TRACE(("|%p|%p|COUNT SUBPATTERN\n", pattern, ptr));
- while ((char*) state->ptr < end) {
- i = SRE_MATCH(state, pattern);
+ while ((SRE_CHAR*) state->ptr < end) {
+ i = SRE(match)(state, pattern);
if (i < 0)
return i;
if (!i)
break;
}
TRACE(("|%p|%p|COUNT %" PY_FORMAT_SIZE_T "d\n", pattern, ptr,
- ((char*)state->ptr - ptr)/state->charsize));
- return ((char*)state->ptr - ptr)/state->charsize;
+ (SRE_CHAR*) state->ptr - ptr));
+ return (SRE_CHAR*) state->ptr - ptr;
}
TRACE(("|%p|%p|COUNT %" PY_FORMAT_SIZE_T "d\n", pattern, ptr,
- (ptr - (char*) state->ptr)/state->charsize));
- return (ptr - (char*) state->ptr)/state->charsize;
+ ptr - (SRE_CHAR*) state->ptr));
+ return ptr - (SRE_CHAR*) state->ptr;
}
#if 0 /* not used in this release */
LOCAL(int)
-SRE_INFO(SRE_STATE* state, SRE_CODE* pattern)
+SRE(info)(SRE_STATE* state, SRE_CODE* pattern)
{
/* check if an SRE_OP_INFO block matches at the current position.
returns the number of SRE_CODE objects to skip if successful, 0
if no match */
- char* end = state->end;
- char* ptr = state->ptr;
+ SRE_CHAR* end = (SRE_CHAR*) state->end;
+ SRE_CHAR* ptr = (SRE_CHAR*) state->ptr;
Py_ssize_t i;
/* check minimal length */
- if (pattern[3] && (end - ptr)/state->charsize < pattern[3])
+ if (pattern[3] && end - ptr < pattern[3])
return 0;
/* check known prefix */
if (pattern[2] & SRE_INFO_PREFIX && pattern[5] > 1) {
/* <length> <skip> <prefix data> <overlap data> */
for (i = 0; i < pattern[5]; i++)
- if ((SRE_CODE) SRE_CHARGET(state, ptr, i) != pattern[7 + i])
+ if ((SRE_CODE) ptr[i] != pattern[7 + i])
return 0;
return pattern[0] + 2 * pattern[6];
}
@@ -595,30 +570,30 @@ SRE_INFO(SRE_STATE* state, SRE_CODE* pattern)
}
#endif
-/* The macros below should be used to protect recursive SRE_MATCH()
+/* The macros below should be used to protect recursive SRE(match)()
* calls that *failed* and do *not* return immediately (IOW, those
* that will backtrack). Explaining:
*
- * - Recursive SRE_MATCH() returned true: that's usually a success
+ * - Recursive SRE(match)() returned true: that's usually a success
* (besides atypical cases like ASSERT_NOT), therefore there's no
* reason to restore lastmark;
*
- * - Recursive SRE_MATCH() returned false but the current SRE_MATCH()
- * is returning to the caller: If the current SRE_MATCH() is the
+ * - Recursive SRE(match)() returned false but the current SRE(match)()
+ * is returning to the caller: If the current SRE(match)() is the
* top function of the recursion, returning false will be a matching
* failure, and it doesn't matter where lastmark is pointing to.
- * If it's *not* the top function, it will be a recursive SRE_MATCH()
- * failure by itself, and the calling SRE_MATCH() will have to deal
+ * If it's *not* the top function, it will be a recursive SRE(match)()
+ * failure by itself, and the calling SRE(match)() will have to deal
* with the failure by the same rules explained here (it will restore
* lastmark by itself if necessary);
*
- * - Recursive SRE_MATCH() returned false, and will continue the
+ * - Recursive SRE(match)() returned false, and will continue the
* outside 'for' loop: must be protected when breaking, since the next
* OP could potentially depend on lastmark;
*
- * - Recursive SRE_MATCH() returned false, and will be called again
+ * - Recursive SRE(match)() returned false, and will be called again
* inside a local for/while loop: must be protected between each
- * loop iteration, since the recursive SRE_MATCH() could do anything,
+ * loop iteration, since the recursive SRE(match)() could do anything,
* and could potentially depend on lastmark.
*
* For more information, check the discussion at SF patch #712900.
@@ -657,7 +632,7 @@ do { \
int j = data_stack_grow(state, sizeof(type)); \
if (j < 0) return j; \
if (ctx_pos != -1) \
- DATA_STACK_LOOKUP_AT(state, SRE_MATCH_CONTEXT, ctx, ctx_pos); \
+ DATA_STACK_LOOKUP_AT(state, SRE(match_context), ctx, ctx_pos); \
} \
ptr = (type*)(state->data_stack+alloc_pos); \
state->data_stack_base += sizeof(type); \
@@ -678,7 +653,7 @@ do { \
int j = data_stack_grow(state, size); \
if (j < 0) return j; \
if (ctx_pos != -1) \
- DATA_STACK_LOOKUP_AT(state, SRE_MATCH_CONTEXT, ctx, ctx_pos); \
+ DATA_STACK_LOOKUP_AT(state, SRE(match_context), ctx, ctx_pos); \
} \
memcpy(state->data_stack+state->data_stack_base, data, size); \
state->data_stack_base += size; \
@@ -747,7 +722,7 @@ do { \
#define JUMP_ASSERT_NOT 13
#define DO_JUMP(jumpvalue, jumplabel, nextpattern) \
- DATA_ALLOC(SRE_MATCH_CONTEXT, nextctx); \
+ DATA_ALLOC(SRE(match_context), nextctx); \
nextctx->last_ctx_pos = ctx_pos; \
nextctx->jump = jumpvalue; \
nextctx->pattern = nextpattern; \
@@ -760,7 +735,7 @@ do { \
typedef struct {
Py_ssize_t last_ctx_pos;
Py_ssize_t jump;
- char* ptr;
+ SRE_CHAR* ptr;
SRE_CODE* pattern;
Py_ssize_t count;
Py_ssize_t lastmark;
@@ -769,25 +744,25 @@ typedef struct {
SRE_CODE chr;
SRE_REPEAT* rep;
} u;
-} SRE_MATCH_CONTEXT;
+} SRE(match_context);
/* check if string matches the given pattern. returns <0 for
error, 0 for failure, and 1 for success */
LOCAL(Py_ssize_t)
-SRE_MATCH(SRE_STATE* state, SRE_CODE* pattern)
+SRE(match)(SRE_STATE* state, SRE_CODE* pattern)
{
- char* end = (char*)state->end;
+ SRE_CHAR* end = (SRE_CHAR *)state->end;
Py_ssize_t alloc_pos, ctx_pos = -1;
Py_ssize_t i, ret = 0;
Py_ssize_t jump;
unsigned int sigcount=0;
- SRE_MATCH_CONTEXT* ctx;
- SRE_MATCH_CONTEXT* nextctx;
+ SRE(match_context)* ctx;
+ SRE(match_context)* nextctx;
TRACE(("|%p|%p|ENTER\n", pattern, state->ptr));
- DATA_ALLOC(SRE_MATCH_CONTEXT, ctx);
+ DATA_ALLOC(SRE(match_context), ctx);
ctx->last_ctx_pos = -1;
ctx->jump = JUMP_NONE;
ctx->pattern = pattern;
@@ -795,16 +770,15 @@ SRE_MATCH(SRE_STATE* state, SRE_CODE* pattern)
entrance:
- ctx->ptr = (char *)state->ptr;
+ ctx->ptr = (SRE_CHAR *)state->ptr;
if (ctx->pattern[0] == SRE_OP_INFO) {
/* optimization info block */
/* <INFO> <1=skip> <2=flags> <3=min> ... */
- if (ctx->pattern[3] && (Py_uintptr_t)(end - ctx->ptr)/state->charsize < ctx->pattern[3]) {
+ if (ctx->pattern[3] && (Py_uintptr_t)(end - ctx->ptr) < ctx->pattern[3]) {
TRACE(("reject (got %" PY_FORMAT_SIZE_T "d chars, "
"need %" PY_FORMAT_SIZE_T "d)\n",
- (end - ctx->ptr)/state->charsize,
- (Py_ssize_t) ctx->pattern[3]));
+ end - ctx->ptr, (Py_ssize_t) ctx->pattern[3]));
RETURN_FAILURE;
}
ctx->pattern += ctx->pattern[1] + 1;
@@ -844,10 +818,10 @@ entrance:
/* <LITERAL> <code> */
TRACE(("|%p|%p|LITERAL %d\n", ctx->pattern,
ctx->ptr, *ctx->pattern));
- if (ctx->ptr >= end || (SRE_CODE) SRE_CHARGET(state, ctx->ptr, 0) != ctx->pattern[0])
+ if (ctx->ptr >= end || (SRE_CODE) ctx->ptr[0] != ctx->pattern[0])
RETURN_FAILURE;
ctx->pattern++;
- ctx->ptr += state->charsize;
+ ctx->ptr++;
break;
case SRE_OP_NOT_LITERAL:
@@ -855,10 +829,10 @@ entrance:
/* <NOT_LITERAL> <code> */
TRACE(("|%p|%p|NOT_LITERAL %d\n", ctx->pattern,
ctx->ptr, *ctx->pattern));
- if (ctx->ptr >= end || (SRE_CODE) SRE_CHARGET(state, ctx->ptr, 0) == ctx->pattern[0])
+ if (ctx->ptr >= end || (SRE_CODE) ctx->ptr[0] == ctx->pattern[0])
RETURN_FAILURE;
ctx->pattern++;
- ctx->ptr += state->charsize;
+ ctx->ptr++;
break;
case SRE_OP_SUCCESS:
@@ -871,7 +845,7 @@ entrance:
/* match at given position */
/* <AT> <code> */
TRACE(("|%p|%p|AT %d\n", ctx->pattern, ctx->ptr, *ctx->pattern));
- if (!SRE_AT(state, ctx->ptr, *ctx->pattern))
+ if (!SRE(at)(state, ctx->ptr, *ctx->pattern))
RETURN_FAILURE;
ctx->pattern++;
break;
@@ -881,19 +855,19 @@ entrance:
/* <CATEGORY> <code> */
TRACE(("|%p|%p|CATEGORY %d\n", ctx->pattern,
ctx->ptr, *ctx->pattern));
- if (ctx->ptr >= end || !sre_category(ctx->pattern[0], SRE_CHARGET(state, ctx->ptr, 0)))
+ if (ctx->ptr >= end || !sre_category(ctx->pattern[0], ctx->ptr[0]))
RETURN_FAILURE;
ctx->pattern++;
- ctx->ptr += state->charsize;
+ ctx->ptr++;
break;
case SRE_OP_ANY:
/* match anything (except a newline) */
/* <ANY> */
TRACE(("|%p|%p|ANY\n", ctx->pattern, ctx->ptr));
- if (ctx->ptr >= end || SRE_IS_LINEBREAK(SRE_CHARGET(state, ctx->ptr, 0)))
- RETURN_FAILURE;
- ctx->ptr += state->charsize;
+ if (ctx->ptr >= end || SRE_IS_LINEBREAK(ctx->ptr[0]))
+ RETURN_FAILURE;
+ ctx->ptr++;
break;
case SRE_OP_ANY_ALL:
@@ -902,47 +876,47 @@ entrance:
TRACE(("|%p|%p|ANY_ALL\n", ctx->pattern, ctx->ptr));
if (ctx->ptr >= end)
RETURN_FAILURE;
- ctx->ptr += state->charsize;
+ ctx->ptr++;
break;
case SRE_OP_IN:
/* match set member (or non_member) */
/* <IN> <skip> <set> */
TRACE(("|%p|%p|IN\n", ctx->pattern, ctx->ptr));
- if (ctx->ptr >= end || !SRE_CHARSET(ctx->pattern + 1, SRE_CHARGET(state, ctx->ptr, 0)))
- RETURN_FAILURE;
+ if (ctx->ptr >= end || !SRE(charset)(ctx->pattern + 1, *ctx->ptr))
+ RETURN_FAILURE;
ctx->pattern += ctx->pattern[0];
- ctx->ptr += state->charsize;
+ ctx->ptr++;
break;
case SRE_OP_LITERAL_IGNORE:
TRACE(("|%p|%p|LITERAL_IGNORE %d\n",
ctx->pattern, ctx->ptr, ctx->pattern[0]));
if (ctx->ptr >= end ||
- state->lower(SRE_CHARGET(state, ctx->ptr, 0)) != state->lower(*ctx->pattern))
+ state->lower(*ctx->ptr) != state->lower(*ctx->pattern))
RETURN_FAILURE;
ctx->pattern++;
- ctx->ptr += state->charsize;
+ ctx->ptr++;
break;
case SRE_OP_NOT_LITERAL_IGNORE:
TRACE(("|%p|%p|NOT_LITERAL_IGNORE %d\n",
ctx->pattern, ctx->ptr, *ctx->pattern));
if (ctx->ptr >= end ||
- state->lower(SRE_CHARGET(state, ctx->ptr, 0)) == state->lower(*ctx->pattern))
+ state->lower(*ctx->ptr) == state->lower(*ctx->pattern))
RETURN_FAILURE;
ctx->pattern++;
- ctx->ptr += state->charsize;
+ ctx->ptr++;
break;
case SRE_OP_IN_IGNORE:
TRACE(("|%p|%p|IN_IGNORE\n", ctx->pattern, ctx->ptr));
if (ctx->ptr >= end
- || !SRE_CHARSET(ctx->pattern+1,
- (SRE_CODE)state->lower(SRE_CHARGET(state, ctx->ptr, 0))))
+ || !SRE(charset)(ctx->pattern+1,
+ (SRE_CODE)state->lower(*ctx->ptr)))
RETURN_FAILURE;
ctx->pattern += ctx->pattern[0];
- ctx->ptr += state->charsize;
+ ctx->ptr++;
break;
case SRE_OP_JUMP:
@@ -965,11 +939,11 @@ entrance:
for (; ctx->pattern[0]; ctx->pattern += ctx->pattern[0]) {
if (ctx->pattern[1] == SRE_OP_LITERAL &&
(ctx->ptr >= end ||
- (SRE_CODE) SRE_CHARGET(state, ctx->ptr, 0) != ctx->pattern[2]))
+ (SRE_CODE) *ctx->ptr != ctx->pattern[2]))
continue;
if (ctx->pattern[1] == SRE_OP_IN &&
(ctx->ptr >= end ||
- !SRE_CHARSET(ctx->pattern + 3, (SRE_CODE) SRE_CHARGET(state, ctx->ptr, 0))))
+ !SRE(charset)(ctx->pattern + 3, (SRE_CODE) *ctx->ptr)))
continue;
state->ptr = ctx->ptr;
DO_JUMP(JUMP_BRANCH, jump_branch, ctx->pattern+1);
@@ -1000,16 +974,16 @@ entrance:
TRACE(("|%p|%p|REPEAT_ONE %d %d\n", ctx->pattern, ctx->ptr,
ctx->pattern[1], ctx->pattern[2]));
- if ((Py_ssize_t) ctx->pattern[1] > (end - ctx->ptr) / state->charsize)
+ if ((Py_ssize_t) ctx->pattern[1] > end - ctx->ptr)
RETURN_FAILURE; /* cannot match */
state->ptr = ctx->ptr;
- ret = SRE_COUNT(state, ctx->pattern+3, ctx->pattern[2]);
+ ret = SRE(count)(state, ctx->pattern+3, ctx->pattern[2]);
RETURN_ON_ERROR(ret);
- DATA_LOOKUP_AT(SRE_MATCH_CONTEXT, ctx, ctx_pos);
+ DATA_LOOKUP_AT(SRE(match_context), ctx, ctx_pos);
ctx->count = ret;
- ctx->ptr += state->charsize * ctx->count;
+ ctx->ptr += ctx->count;
/* when we arrive here, count contains the number of
matches, and ctx->ptr points to the tail of the target
@@ -1033,9 +1007,8 @@ entrance:
ctx->u.chr = ctx->pattern[ctx->pattern[0]+1];
for (;;) {
while (ctx->count >= (Py_ssize_t) ctx->pattern[1] &&
- (ctx->ptr >= end ||
- SRE_CHARGET(state, ctx->ptr, 0) != ctx->u.chr)) {
- ctx->ptr -= state->charsize;
+ (ctx->ptr >= end || *ctx->ptr != ctx->u.chr)) {
+ ctx->ptr--;
ctx->count--;
}
if (ctx->count < (Py_ssize_t) ctx->pattern[1])
@@ -1050,7 +1023,7 @@ entrance:
LASTMARK_RESTORE();
- ctx->ptr -= state->charsize;
+ ctx->ptr--;
ctx->count--;
}
@@ -1064,7 +1037,7 @@ entrance:
RETURN_ON_ERROR(ret);
RETURN_SUCCESS;
}
- ctx->ptr -= state->charsize;
+ ctx->ptr--;
ctx->count--;
LASTMARK_RESTORE();
}
@@ -1084,7 +1057,7 @@ entrance:
TRACE(("|%p|%p|MIN_REPEAT_ONE %d %d\n", ctx->pattern, ctx->ptr,
ctx->pattern[1], ctx->pattern[2]));
- if ((Py_ssize_t) ctx->pattern[1] > (end - ctx->ptr) / state->charsize)
+ if ((Py_ssize_t) ctx->pattern[1] > end - ctx->ptr)
RETURN_FAILURE; /* cannot match */
state->ptr = ctx->ptr;
@@ -1093,15 +1066,15 @@ entrance:
ctx->count = 0;
else {
/* count using pattern min as the maximum */
- ret = SRE_COUNT(state, ctx->pattern+3, ctx->pattern[1]);
+ ret = SRE(count)(state, ctx->pattern+3, ctx->pattern[1]);
RETURN_ON_ERROR(ret);
- DATA_LOOKUP_AT(SRE_MATCH_CONTEXT, ctx, ctx_pos);
+ DATA_LOOKUP_AT(SRE(match_context), ctx, ctx_pos);
if (ret < (Py_ssize_t) ctx->pattern[1])
/* didn't match minimum number of times */
RETURN_FAILURE;
/* advance past minimum matches of repeat */
ctx->count = ret;
- ctx->ptr += state->charsize * ctx->count;
+ ctx->ptr += ctx->count;
}
if (ctx->pattern[ctx->pattern[0]] == SRE_OP_SUCCESS) {
@@ -1122,13 +1095,13 @@ entrance:
RETURN_SUCCESS;
}
state->ptr = ctx->ptr;
- ret = SRE_COUNT(state, ctx->pattern+3, 1);
+ ret = SRE(count)(state, ctx->pattern+3, 1);
RETURN_ON_ERROR(ret);
- DATA_LOOKUP_AT(SRE_MATCH_CONTEXT, ctx, ctx_pos);
+ DATA_LOOKUP_AT(SRE(match_context), ctx, ctx_pos);
if (ret == 0)
break;
assert(ret == 1);
- ctx->ptr += state->charsize;
+ ctx->ptr++;
ctx->count++;
LASTMARK_RESTORE();
}
@@ -1305,16 +1278,15 @@ entrance:
if (groupref >= state->lastmark) {
RETURN_FAILURE;
} else {
- char* p = (char*) state->mark[groupref];
- char* e = (char*) state->mark[groupref+1];
+ SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];
+ SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];
if (!p || !e || e < p)
RETURN_FAILURE;
while (p < e) {
- if (ctx->ptr >= end ||
- SRE_CHARGET(state, ctx->ptr, 0) != SRE_CHARGET(state, p, 0))
+ if (ctx->ptr >= end || *ctx->ptr != *p)
RETURN_FAILURE;
- p += state->charsize;
- ctx->ptr += state->charsize;
+ p++;
+ ctx->ptr++;
}
}
}
@@ -1331,17 +1303,16 @@ entrance:
if (groupref >= state->lastmark) {
RETURN_FAILURE;
} else {
- char* p = (char*) state->mark[groupref];
- char* e = (char*) state->mark[groupref+1];
+ SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];
+ SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];
if (!p || !e || e < p)
RETURN_FAILURE;
while (p < e) {
if (ctx->ptr >= end ||
- state->lower(SRE_CHARGET(state, ctx->ptr, 0)) !=
- state->lower(SRE_CHARGET(state, p, 0)))
+ state->lower(*ctx->ptr) != state->lower(*p))
RETURN_FAILURE;
- p += state->charsize;
- ctx->ptr += state->charsize;
+ p++;
+ ctx->ptr++;
}
}
}
@@ -1375,7 +1346,7 @@ entrance:
/* <ASSERT> <skip> <back> <pattern> */
TRACE(("|%p|%p|ASSERT %d\n", ctx->pattern,
ctx->ptr, ctx->pattern[1]));
- state->ptr = ctx->ptr - state->charsize * ctx->pattern[1];
+ state->ptr = ctx->ptr - ctx->pattern[1];
if (state->ptr < state->beginning)
RETURN_FAILURE;
DO_JUMP(JUMP_ASSERT, jump_assert, ctx->pattern+2);
@@ -1388,7 +1359,7 @@ entrance:
/* <ASSERT_NOT> <skip> <back> <pattern> */
TRACE(("|%p|%p|ASSERT_NOT %d\n", ctx->pattern,
ctx->ptr, ctx->pattern[1]));
- state->ptr = ctx->ptr - state->charsize * ctx->pattern[1];
+ state->ptr = ctx->ptr - ctx->pattern[1];
if (state->ptr >= state->beginning) {
DO_JUMP(JUMP_ASSERT_NOT, jump_assert_not, ctx->pattern+2);
if (ret) {
@@ -1417,7 +1388,7 @@ exit:
DATA_POP_DISCARD(ctx);
if (ctx_pos == -1)
return ret;
- DATA_LOOKUP_AT(SRE_MATCH_CONTEXT, ctx, ctx_pos);
+ DATA_LOOKUP_AT(SRE(match_context), ctx, ctx_pos);
switch (jump) {
case JUMP_MAX_UNTIL_2:
@@ -1469,10 +1440,10 @@ exit:
}
LOCAL(Py_ssize_t)
-SRE_SEARCH(SRE_STATE* state, SRE_CODE* pattern)
+SRE(search)(SRE_STATE* state, SRE_CODE* pattern)
{
- char* ptr = (char*)state->start;
- char* end = (char*)state->end;
+ SRE_CHAR* ptr = (SRE_CHAR *)state->start;
+ SRE_CHAR* end = (SRE_CHAR *)state->end;
Py_ssize_t status = 0;
Py_ssize_t prefix_len = 0;
Py_ssize_t prefix_skip = 0;
@@ -1490,9 +1461,9 @@ SRE_SEARCH(SRE_STATE* state, SRE_CODE* pattern)
if (pattern[3] > 1) {
/* adjust end point (but make sure we leave at least one
character in there, so literal search will work) */
- end -= (pattern[3]-1) * state->charsize;
+ end -= pattern[3] - 1;
if (end <= ptr)
- end = ptr + state->charsize;
+ end = ptr;
}
if (flags & SRE_INFO_PREFIX) {
@@ -1519,32 +1490,47 @@ SRE_SEARCH(SRE_STATE* state, SRE_CODE* pattern)
/* pattern starts with a known prefix. use the overlap
table to skip forward as fast as we possibly can */
Py_ssize_t i = 0;
- end = (char *)state->end;
+
+ end = (SRE_CHAR *)state->end;
+ if (prefix_len > end - ptr)
+ return 0;
+#if SIZEOF_SRE_CHAR < 4
+ for (i = 0; i < prefix_len; i++)
+ if ((SRE_CODE)(SRE_CHAR) prefix[i] != prefix[i])
+ return 0; /* literal can't match: doesn't fit in char width */
+#endif
while (ptr < end) {
- for (;;) {
- if ((SRE_CODE) SRE_CHARGET(state, ptr, 0) != prefix[i]) {
- if (!i)
- break;
- else
- i = overlap[i];
- } else {
- if (++i == prefix_len) {
- /* found a potential match */
- TRACE(("|%p|%p|SEARCH SCAN\n", pattern, ptr));
- state->start = ptr - (prefix_len - 1) * state->charsize;
- state->ptr = ptr - (prefix_len - prefix_skip - 1) * state->charsize;
- if (flags & SRE_INFO_LITERAL)
- return 1; /* we got all of it */
- status = SRE_MATCH(state, pattern + 2*prefix_skip);
- if (status != 0)
- return status;
- /* close but no cigar -- try again */
- i = overlap[i];
+ SRE_CHAR c = (SRE_CHAR) prefix[0];
+ while (*ptr++ != c) {
+ if (ptr >= end)
+ return 0;
+ }
+ if (ptr >= end)
+ return 0;
+
+ i = 1;
+ do {
+ if (*ptr == (SRE_CHAR) prefix[i]) {
+ if (++i != prefix_len) {
+ if (++ptr >= end)
+ return 0;
+ continue;
}
- break;
+ /* found a potential match */
+ TRACE(("|%p|%p|SEARCH SCAN\n", pattern, ptr));
+ state->start = ptr - (prefix_len - 1);
+ state->ptr = ptr - (prefix_len - prefix_skip - 1);
+ if (flags & SRE_INFO_LITERAL)
+ return 1; /* we got all of it */
+ status = SRE(match)(state, pattern + 2*prefix_skip);
+ if (status != 0)
+ return status;
+ /* close but no cigar -- try again */
+ if (++ptr >= end)
+ return 0;
}
- }
- ptr += state->charsize;
+ i = overlap[i];
+ } while (i != 0);
}
return 0;
}
@@ -1553,46 +1539,48 @@ SRE_SEARCH(SRE_STATE* state, SRE_CODE* pattern)
if (pattern[0] == SRE_OP_LITERAL) {
/* pattern starts with a literal character. this is used
for short prefixes, and if fast search is disabled */
- SRE_CODE chr = pattern[1];
- end = (char*)state->end;
- for (;;) {
- while (ptr < end && (SRE_CODE) SRE_CHARGET(state, ptr, 0) != chr)
- ptr += state->charsize;
- if (ptr >= end)
- return 0;
+ SRE_CHAR c = (SRE_CHAR) pattern[1];
+#if SIZEOF_SRE_CHAR < 4
+ if ((SRE_CODE) c != pattern[1])
+ return 0; /* literal can't match: doesn't fit in char width */
+#endif
+ end = (SRE_CHAR *)state->end;
+ while (ptr < end) {
+ while (*ptr != c) {
+ if (++ptr >= end)
+ return 0;
+ }
TRACE(("|%p|%p|SEARCH LITERAL\n", pattern, ptr));
state->start = ptr;
- ptr += state->charsize;
- state->ptr = ptr;
+ state->ptr = ++ptr;
if (flags & SRE_INFO_LITERAL)
return 1; /* we got all of it */
- status = SRE_MATCH(state, pattern + 2);
+ status = SRE(match)(state, pattern + 2);
if (status != 0)
break;
}
} else if (charset) {
/* pattern starts with a character from a known set */
- end = (char*)state->end;
+ end = (SRE_CHAR *)state->end;
for (;;) {
- while (ptr < end && !SRE_CHARSET(charset, SRE_CHARGET(state, ptr, 0)))
- ptr += state->charsize;
+ while (ptr < end && !SRE(charset)(charset, *ptr))
+ ptr++;
if (ptr >= end)
return 0;
TRACE(("|%p|%p|SEARCH CHARSET\n", pattern, ptr));
state->start = ptr;
state->ptr = ptr;
- status = SRE_MATCH(state, pattern);
+ status = SRE(match)(state, pattern);
if (status != 0)
break;
- ptr += state->charsize;
+ ptr++;
}
} else
/* general case */
while (ptr <= end) {
TRACE(("|%p|%p|SEARCH\n", pattern, ptr));
- state->start = state->ptr = ptr;
- ptr += state->charsize;
- status = SRE_MATCH(state, pattern);
+ state->start = state->ptr = ptr++;
+ status = SRE(match)(state, pattern);
if (status != 0)
break;
}
@@ -1600,7 +1588,9 @@ SRE_SEARCH(SRE_STATE* state, SRE_CODE* pattern)
return status;
}
-#if !defined(SRE_RECURSIVE)
+#endif /* SRE_RECURSIVE */
+
+#ifndef SRE_RECURSIVE
/* -------------------------------------------------------------------- */
/* factories and destructors */
@@ -1609,23 +1599,6 @@ SRE_SEARCH(SRE_STATE* state, SRE_CODE* pattern)
static PyObject*pattern_new_match(PatternObject*, SRE_STATE*, int);
static PyObject*pattern_scanner(PatternObject*, PyObject*, PyObject* kw);
-static int
-sre_literal_template(int charsize, char* ptr, Py_ssize_t len)
-{
- /* check if given string is a literal template (i.e. no escapes) */
- struct {
- int charsize;
- } state = {
- charsize
- };
- while (len-- > 0) {
- if (SRE_CHARGET((&state), ptr, 0) == '\\')
- return 0;
- ptr += charsize;
- }
- return 1;
-}
-
static PyObject *
sre_codesize(PyObject* self, PyObject *unused)
{
@@ -1661,72 +1634,41 @@ state_reset(SRE_STATE* state)
static void*
getstring(PyObject* string, Py_ssize_t* p_length,
- int* p_logical_charsize, int* p_charsize,
+ int* p_isbytes, int* p_charsize,
Py_buffer *view)
{
/* given a python object, return a data pointer, a length (in
characters), and a character size. return NULL if the object
is not a string (or not compatible) */
- PyBufferProcs *buffer;
- Py_ssize_t size, bytes;
- int charsize;
- void* ptr;
-
/* Unicode objects do not support the buffer API. So, get the data
directly instead. */
if (PyUnicode_Check(string)) {
if (PyUnicode_READY(string) == -1)
return NULL;
- ptr = PyUnicode_DATA(string);
*p_length = PyUnicode_GET_LENGTH(string);
*p_charsize = PyUnicode_KIND(string);
- *p_logical_charsize = 4;
- return ptr;
+ *p_isbytes = 0;
+ return PyUnicode_DATA(string);
}
/* get pointer to byte string buffer */
- view->len = -1;
- buffer = Py_TYPE(string)->tp_as_buffer;
- if (!buffer || !buffer->bf_getbuffer ||
- (*buffer->bf_getbuffer)(string, view, PyBUF_SIMPLE) < 0) {
- PyErr_SetString(PyExc_TypeError, "expected string or buffer");
- return NULL;
- }
-
- /* determine buffer size */
- bytes = view->len;
- ptr = view->buf;
-
- if (bytes < 0) {
- PyErr_SetString(PyExc_TypeError, "buffer has negative size");
- goto err;
- }
-
- /* determine character size */
- size = PyObject_Size(string);
-
- if (PyBytes_Check(string) || bytes == size)
- charsize = 1;
- else {
- PyErr_SetString(PyExc_TypeError, "buffer size mismatch");
- goto err;
+ if (PyObject_GetBuffer(string, view, PyBUF_SIMPLE) != 0) {
+ PyErr_SetString(PyExc_TypeError, "expected string or buffer");
+ return NULL;
}
- *p_length = size;
- *p_charsize = charsize;
- *p_logical_charsize = charsize;
+ *p_length = view->len;
+ *p_charsize = 1;
+ *p_isbytes = 1;
- if (ptr == NULL) {
- PyErr_SetString(PyExc_ValueError,
- "Buffer is NULL");
- goto err;
+ if (view->buf == NULL) {
+ PyErr_SetString(PyExc_ValueError, "Buffer is NULL");
+ PyBuffer_Release(view);
+ view->buf = NULL;
+ return NULL;
}
- return ptr;
- err:
- PyBuffer_Release(view);
- view->buf = NULL;
- return NULL;
+ return view->buf;
}
LOCAL(PyObject*)
@@ -1736,7 +1678,7 @@ state_init(SRE_STATE* state, PatternObject* pattern, PyObject* string,
/* prepare state object */
Py_ssize_t length;
- int logical_charsize, charsize;
+ int isbytes, charsize;
void* ptr;
memset(state, 0, sizeof(SRE_STATE));
@@ -1745,16 +1687,16 @@ state_init(SRE_STATE* state, PatternObject* pattern, PyObject* string,
state->lastindex = -1;
state->buffer.buf = NULL;
- ptr = getstring(string, &length, &logical_charsize, &charsize, &state->buffer);
+ ptr = getstring(string, &length, &isbytes, &charsize, &state->buffer);
if (!ptr)
goto err;
- if (logical_charsize == 1 && pattern->logical_charsize > 1) {
+ if (isbytes && pattern->isbytes == 0) {
PyErr_SetString(PyExc_TypeError,
"can't use a string pattern on a bytes-like object");
goto err;
}
- if (logical_charsize > 1 && pattern->logical_charsize == 1) {
+ if (!isbytes && pattern->isbytes > 0) {
PyErr_SetString(PyExc_TypeError,
"can't use a bytes pattern on a string-like object");
goto err;
@@ -1771,7 +1713,7 @@ state_init(SRE_STATE* state, PatternObject* pattern, PyObject* string,
else if (end > length)
end = length;
- state->logical_charsize = logical_charsize;
+ state->isbytes = isbytes;
state->charsize = charsize;
state->beginning = ptr;
@@ -1812,10 +1754,10 @@ state_fini(SRE_STATE* state)
(((char*)(member) - (char*)(state)->beginning) / (state)->charsize)
LOCAL(PyObject*)
-getslice(int logical_charsize, const void *ptr,
+getslice(int isbytes, const void *ptr,
PyObject* string, Py_ssize_t start, Py_ssize_t end)
{
- if (logical_charsize == 1) {
+ if (isbytes) {
if (PyBytes_CheckExact(string) &&
start == 0 && end == PyBytes_GET_SIZE(string)) {
Py_INCREF(string);
@@ -1849,7 +1791,7 @@ state_getslice(SRE_STATE* state, Py_ssize_t index, PyObject* string, int empty)
j = STATE_OFFSET(state, state->mark[index+1]);
}
- return getslice(state->logical_charsize, state->beginning, string, i, j);
+ return getslice(state->isbytes, state->beginning, string, i, j);
}
static void
@@ -1882,14 +1824,34 @@ pattern_dealloc(PatternObject* self)
{
if (self->weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self);
- if (self->view.buf)
- PyBuffer_Release(&self->view);
Py_XDECREF(self->pattern);
Py_XDECREF(self->groupindex);
Py_XDECREF(self->indexgroup);
PyObject_DEL(self);
}
+LOCAL(Py_ssize_t)
+sre_match(SRE_STATE* state, SRE_CODE* pattern)
+{
+ if (state->charsize == 1)
+ return sre_ucs1_match(state, pattern);
+ if (state->charsize == 2)
+ return sre_ucs2_match(state, pattern);
+ assert(state->charsize == 4);
+ return sre_ucs4_match(state, pattern);
+}
+
+LOCAL(Py_ssize_t)
+sre_search(SRE_STATE* state, SRE_CODE* pattern)
+{
+ if (state->charsize == 1)
+ return sre_ucs1_search(state, pattern);
+ if (state->charsize == 2)
+ return sre_ucs2_search(state, pattern);
+ assert(state->charsize == 4);
+ return sre_ucs4_search(state, pattern);
+}
+
static PyObject*
pattern_match(PatternObject* self, PyObject* args, PyObject* kw)
{
@@ -1912,11 +1874,7 @@ pattern_match(PatternObject* self, PyObject* args, PyObject* kw)
TRACE(("|%p|%p|MATCH\n", PatternObject_GetCode(self), state.ptr));
- if (state.logical_charsize == 1) {
- status = sre_match(&state, PatternObject_GetCode(self));
- } else {
- status = sre_umatch(&state, PatternObject_GetCode(self));
- }
+ status = sre_match(&state, PatternObject_GetCode(self));
TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));
if (PyErr_Occurred())
@@ -1947,11 +1905,7 @@ pattern_search(PatternObject* self, PyObject* args, PyObject* kw)
TRACE(("|%p|%p|SEARCH\n", PatternObject_GetCode(self), state.ptr));
- if (state.logical_charsize == 1) {
- status = sre_search(&state, PatternObject_GetCode(self));
- } else {
- status = sre_usearch(&state, PatternObject_GetCode(self));
- }
+ status = sre_search(&state, PatternObject_GetCode(self));
TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));
@@ -2044,12 +1998,7 @@ pattern_findall(PatternObject* self, PyObject* args, PyObject* kw)
state.ptr = state.start;
- if (state.logical_charsize == 1) {
- status = sre_search(&state, PatternObject_GetCode(self));
- } else {
- status = sre_usearch(&state, PatternObject_GetCode(self));
- }
-
+ status = sre_search(&state, PatternObject_GetCode(self));
if (PyErr_Occurred())
goto error;
@@ -2065,7 +2014,7 @@ pattern_findall(PatternObject* self, PyObject* args, PyObject* kw)
case 0:
b = STATE_OFFSET(&state, state.start);
e = STATE_OFFSET(&state, state.ptr);
- item = getslice(state.logical_charsize, state.beginning,
+ item = getslice(state.isbytes, state.beginning,
string, b, e);
if (!item)
goto error;
@@ -2171,12 +2120,7 @@ pattern_split(PatternObject* self, PyObject* args, PyObject* kw)
state.ptr = state.start;
- if (state.logical_charsize == 1) {
- status = sre_search(&state, PatternObject_GetCode(self));
- } else {
- status = sre_usearch(&state, PatternObject_GetCode(self));
- }
-
+ status = sre_search(&state, PatternObject_GetCode(self));
if (PyErr_Occurred())
goto error;
@@ -2196,7 +2140,7 @@ pattern_split(PatternObject* self, PyObject* args, PyObject* kw)
}
/* get segment before this match */
- item = getslice(state.logical_charsize, state.beginning,
+ item = getslice(state.isbytes, state.beginning,
string, STATE_OFFSET(&state, last),
STATE_OFFSET(&state, state.start)
);
@@ -2225,7 +2169,7 @@ pattern_split(PatternObject* self, PyObject* args, PyObject* kw)
}
/* get segment following last match (even if empty) */
- item = getslice(state.logical_charsize, state.beginning,
+ item = getslice(state.isbytes, state.beginning,
string, STATE_OFFSET(&state, last), state.endpos
);
if (!item)
@@ -2260,7 +2204,7 @@ pattern_subx(PatternObject* self, PyObject* ptemplate, PyObject* string,
Py_ssize_t status;
Py_ssize_t n;
Py_ssize_t i, b, e;
- int logical_charsize, charsize;
+ int isbytes, charsize;
int filter_is_callable;
Py_buffer view;
@@ -2273,10 +2217,13 @@ pattern_subx(PatternObject* self, PyObject* ptemplate, PyObject* string,
/* if not callable, check if it's a literal string */
int literal;
view.buf = NULL;
- ptr = getstring(ptemplate, &n, &logical_charsize, &charsize, &view);
+ ptr = getstring(ptemplate, &n, &isbytes, &charsize, &view);
b = charsize;
if (ptr) {
- literal = sre_literal_template(charsize, ptr, n);
+ if (charsize == 1)
+ literal = memchr(ptr, '\\', n) == NULL;
+ else
+ literal = PyUnicode_FindChar(ptemplate, '\\', 0, n, 1) == -1;
} else {
PyErr_Clear();
literal = 0;
@@ -2320,12 +2267,7 @@ pattern_subx(PatternObject* self, PyObject* ptemplate, PyObject* string,
state.ptr = state.start;
- if (state.logical_charsize == 1) {
- status = sre_search(&state, PatternObject_GetCode(self));
- } else {
- status = sre_usearch(&state, PatternObject_GetCode(self));
- }
-
+ status = sre_search(&state, PatternObject_GetCode(self));
if (PyErr_Occurred())
goto error;
@@ -2341,7 +2283,7 @@ pattern_subx(PatternObject* self, PyObject* ptemplate, PyObject* string,
if (i < b) {
/* get segment before this match */
- item = getslice(state.logical_charsize, state.beginning,
+ item = getslice(state.isbytes, state.beginning,
string, i, b);
if (!item)
goto error;
@@ -2397,7 +2339,7 @@ next:
/* get segment following last match */
if (i < state.endpos) {
- item = getslice(state.logical_charsize, state.beginning,
+ item = getslice(state.isbytes, state.beginning,
string, i, state.endpos);
if (!item)
goto error;
@@ -2412,7 +2354,7 @@ next:
Py_DECREF(filter);
/* convert list to single string (also removes list) */
- joiner = getslice(state.logical_charsize, state.beginning, string, 0, 0);
+ joiner = getslice(state.isbytes, state.beginning, string, 0, 0);
if (!joiner) {
Py_DECREF(list);
return NULL;
@@ -2422,7 +2364,7 @@ next:
item = joiner;
}
else {
- if (state.logical_charsize == 1)
+ if (state.isbytes)
item = _PyBytes_Join(joiner, list);
else
item = PyUnicode_Join(joiner, list);
@@ -2652,7 +2594,6 @@ _compile(PyObject* self_, PyObject* args)
self->pattern = NULL;
self->groupindex = NULL;
self->indexgroup = NULL;
- self->view.buf = NULL;
self->codesize = n;
@@ -2673,16 +2614,20 @@ _compile(PyObject* self_, PyObject* args)
}
if (pattern == Py_None) {
- self->logical_charsize = -1;
- self->charsize = -1;
+ self->isbytes = -1;
}
else {
Py_ssize_t p_length;
- if (!getstring(pattern, &p_length, &self->logical_charsize,
- &self->charsize, &self->view)) {
+ int charsize;
+ Py_buffer view;
+ view.buf = NULL;
+ if (!getstring(pattern, &p_length, &self->isbytes,
+ &charsize, &view)) {
Py_DECREF(self);
return NULL;
}
+ if (view.buf)
+ PyBuffer_Release(&view);
}
Py_INCREF(pattern);
@@ -2801,7 +2746,7 @@ _validate_charset(SRE_CODE *code, SRE_CODE *end)
break;
case SRE_OP_CHARSET:
- offset = 32/sizeof(SRE_CODE); /* 32-byte bitmap */
+ offset = 256/SRE_CODE_BITS; /* 256-bit bitmap */
if (offset > (Py_uintptr_t)(end - code))
FAIL;
code += offset;
@@ -2818,7 +2763,7 @@ _validate_charset(SRE_CODE *code, SRE_CODE *end)
FAIL;
}
code += offset;
- offset = arg * 32/sizeof(SRE_CODE); /* 32-byte bitmap times arg */
+ offset = arg * (256/SRE_CODE_BITS); /* 256-bit bitmap times arg */
if (offset > (Py_uintptr_t)(end - code))
FAIL;
code += offset;
@@ -3188,7 +3133,7 @@ static PyObject*
match_getslice_by_index(MatchObject* self, Py_ssize_t index, PyObject* def)
{
Py_ssize_t length;
- int logical_charsize, charsize;
+ int isbytes, charsize;
Py_buffer view;
PyObject *result;
void* ptr;
@@ -3210,12 +3155,12 @@ match_getslice_by_index(MatchObject* self, Py_ssize_t index, PyObject* def)
return def;
}
- ptr = getstring(self->string, &length, &logical_charsize, &charsize, &view);
+ ptr = getstring(self->string, &length, &isbytes, &charsize, &view);
if (ptr == NULL)
return NULL;
- result = getslice(logical_charsize, ptr,
+ result = getslice(isbytes, ptr,
self->string, self->mark[index], self->mark[index+1]);
- if (logical_charsize == 1 && view.buf != NULL)
+ if (isbytes && view.buf != NULL)
PyBuffer_Release(&view);
return result;
}
@@ -3790,11 +3735,7 @@ scanner_match(ScannerObject* self, PyObject *unused)
state->ptr = state->start;
- if (state->logical_charsize == 1) {
- status = sre_match(state, PatternObject_GetCode(self->pattern));
- } else {
- status = sre_umatch(state, PatternObject_GetCode(self->pattern));
- }
+ status = sre_match(state, PatternObject_GetCode(self->pattern));
if (PyErr_Occurred())
return NULL;
@@ -3821,11 +3762,7 @@ scanner_search(ScannerObject* self, PyObject *unused)
state->ptr = state->start;
- if (state->logical_charsize == 1) {
- status = sre_search(state, PatternObject_GetCode(self->pattern));
- } else {
- status = sre_usearch(state, PatternObject_GetCode(self->pattern));
- }
+ status = sre_search(state, PatternObject_GetCode(self->pattern));
if (PyErr_Occurred())
return NULL;
@@ -3980,5 +3917,12 @@ PyMODINIT_FUNC PyInit__sre(void)
#endif /* !defined(SRE_RECURSIVE) */
+#ifdef SRE_RECURSIVE
+# undef SRE_RECURSIVE
+# undef SRE_CHAR
+# undef SIZEOF_SRE_CHAR
+# undef SRE
+#endif /* SRE_RECURSIVE */
+
/* vim:ts=4:sw=4:et
*/
diff --git a/Modules/sre.h b/Modules/sre.h
index 0a8f0cf..42fe28d 100644
--- a/Modules/sre.h
+++ b/Modules/sre.h
@@ -31,9 +31,7 @@ typedef struct {
PyObject* pattern; /* pattern source (or None) */
int flags; /* flags used when compiling pattern source */
PyObject *weakreflist; /* List of weak references */
- int logical_charsize; /* pattern charsize (or -1) */
- int charsize;
- Py_buffer view;
+ int isbytes; /* pattern type (1 - bytes, 0 - string, -1 - None) */
/* pattern code */
Py_ssize_t codesize;
SRE_CODE code[1];
@@ -73,9 +71,8 @@ typedef struct {
/* attributes for the match object */
PyObject* string;
Py_ssize_t pos, endpos;
- /* character size */
- int logical_charsize; /* kind of thing: 1 - bytes, 2/4 - unicode */
- int charsize;
+ int isbytes;
+ int charsize; /* character size */
/* registers */
Py_ssize_t lastindex;
Py_ssize_t lastmark;
generated by cgit v0.12 at 2024-12-11 13:23:38 (GMT)