10. limit max group to 1,073,741,823

1,073,741,823 groups should enough for most users.

This change reduces sizeof(match_context) again:
- On 32 bit platform: 32 bytes, no change.
- On 64 bit platform: 64 bytes -> 56 bytes.

sre uses stack and match_context struct to simulate recursive call, smaller struct brings:
- deeper recursive call
- less memory consume
- less memory realloc

Here is a test, if limit the stack size (state->data_stack_base) to 1 GiB, the max available value of n is:

re.match(r'(ab)*', n * 'ab')   # need to save MARKs
72 bytes: n = 11,184,809
64 bytes: n = 12,201,610
56 bytes: n = 13,421,771

re.match(r'(?:ab)*', n * 'ab') # no need to save MARKs
72 bytes: n = 13,421,770
64 bytes: n = 14,913,079
56 bytes: n = 16,777,214

Author: wjssz

Modules/sre.h

@@ -16,12 +16,14 @@
 /* size of a code word (must be unsigned short or larger, and
    large enough to hold a UCS4 character) */
 #define SRE_CODE Py_UCS4
+
+/* SRE_MAXGROUPS is 1,073,741,823 */
+#define SRE_MAXGROUPS INT_MAX / 2
+
 #if SIZEOF_SIZE_T > 4
 # define SRE_MAXREPEAT (~(SRE_CODE)0)
-# define SRE_MAXGROUPS ((~(SRE_CODE)0) / 2)
 #else
 # define SRE_MAXREPEAT ((SRE_CODE)PY_SSIZE_T_MAX)
-# define SRE_MAXGROUPS ((SRE_CODE)PY_SSIZE_T_MAX / SIZEOF_SIZE_T / 2)
 #endif
 
 typedef struct {
@@ -71,18 +73,18 @@ typedef struct {
     Py_ssize_t pos, endpos;
     int isbytes;
     int charsize; /* character size */
+    /* current repeat context */
+    SRE_REPEAT *repeat;
     /* registers */
-    Py_ssize_t lastindex;
-    Py_ssize_t lastmark;
+    int32_t lastmark;
+    int32_t lastindex;
     void** mark;
     int match_all;
     int must_advance;
     /* dynamically allocated stuff */
     char* data_stack;
     size_t data_stack_size;
     size_t data_stack_base;
-    /* current repeat context */
-    SRE_REPEAT *repeat;
 } SRE_STATE;
 
 typedef struct {

Modules/sre_lib.h

@@ -532,8 +532,8 @@ typedef struct {
     SRE_CHAR* ptr;
     SRE_CODE* pattern;
     Py_ssize_t count;
-    Py_ssize_t lastmark;
-    Py_ssize_t lastindex;
+    int32_t lastmark;
+    int32_t lastindex;
     union {
         SRE_CODE chr;
         SRE_REPEAT* rep;
@@ -550,7 +550,8 @@ SRE(match)(SRE_STATE* state, SRE_CODE* pattern, int toplevel)
 {
     SRE_CHAR* end = (SRE_CHAR *)state->end;
     Py_ssize_t alloc_pos, ctx_pos = -1;
-    Py_ssize_t i, ret = 0;
+    Py_ssize_t ret = 0;
+    int32_t i;
     unsigned int sigcount=0;
     int8_t jump;