--- Lib\test\re_tests.py.orig	2003-04-20 00:35:44.000000000 -0700
+++ Lib\test\re_tests.py	2003-04-22 09:57:41.000000000 -0700
@@ -659,6 +659,13 @@
     ('^([ab]*?)(?=(b)?)c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
     ('^([ab]*?)(?!(b))c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
     ('^([ab]*?)(?<!(a))c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
+    # test that capturing groups inside negative assertions work correctly
+    # for backreferences inside the assertion, but are None outside
+    ('^(?!(a)\\1)', 'aa', FAIL),
+    ('^(a)(?:(?!(b)*))*', 'abb', SUCCEED, 'g1+"-"+g2', 'a-None'),
+    ('^((?!(a)c)[ab])*', 'abc', SUCCEED, 'g1+"-"+g2', 'b-None'),
+    # test that saved marks are popped after successful postive assertion
+    ('^(a)(?:(?=(b)*)c)*', 'abb', SUCCEED, 'g1+"-"+g2', 'a-None'),
 ]
 
 try:
--- Modules\_sre.c.orig	2003-04-20 00:35:44.000000000 -0700
+++ Modules\_sre.c	2003-04-22 11:21:02.000000000 -0700
@@ -344,6 +344,7 @@
 #define SRE_COUNT sre_count
 #define SRE_CHARSET sre_charset
 #define SRE_INFO sre_info
+#define SRE_ASSERT sre_assert
 #define SRE_MATCH sre_match
 #define SRE_SEARCH sre_search
 #define SRE_LITERAL_TEMPLATE sre_literal_template
@@ -358,6 +359,7 @@
 #undef SRE_SEARCH
 #undef SRE_MATCH
 #undef SRE_INFO
+#undef SRE_ASSERT
 #undef SRE_CHARSET
 #undef SRE_COUNT
 #undef SRE_AT
@@ -370,6 +372,7 @@
 #define SRE_COUNT sre_ucount
 #define SRE_CHARSET sre_ucharset
 #define SRE_INFO sre_uinfo
+#define SRE_ASSERT sre_uassert
 #define SRE_MATCH sre_umatch
 #define SRE_SEARCH sre_usearch
 #define SRE_LITERAL_TEMPLATE sre_uliteral_template
@@ -694,6 +697,69 @@
     } while (0)
 
 LOCAL(int)
+SRE_ASSERT(SRE_STATE *state, SRE_CODE *pattern, int level, int positive)
+{
+    int lastmark, lastindex, mark_stack_base, i, result;
+
+    if (!positive) {
+        /* For negative assertions, if the subpattern fails, the assertion
+           succeeds and we want to continue matching.  However, in failing, 
+           the subpattern may have left any capturing groups it contains
+           in an inconsistent (partially matched) state.  For consistency,
+           "unmark" all groups in the subpattern after it completes by 
+           restoring marks to the state they had before executing the 
+           subpattern.  When not in a repeat, it is sufficient simply to
+           restore lastmark to its previous value (since a repeat is the 
+           only way to move from right to left in a pattern, without a repeat
+           marks in the assertion will be greater than any so far 
+           encountered. */
+        LASTMARK_SAVE();
+        if (state->repeat) {
+            i = mark_save(state, 0, lastmark);
+            if (i < 0)
+                return i;
+        }
+    }
+    /* If the subpattern in the assertion succeeds, it may leave marks
+       at the top of the mark stack.  These marks reflect potential 
+       backtrack points which were not needed because the subpattern
+       succeeded.  Once the assertion completes, the overall pattern
+       will never backtrack into the assertion, so we need to be ready to
+       pop any marks pushed by the assertion to resynch the mark stack 
+       with active backtrack points. */
+    mark_stack_base = state->mark_stack_base;  
+
+    result = SRE_MATCH(state, pattern, level);
+    if (result < 0)
+        return result;
+
+    if (result)
+        /* pop off any marks that may have been left by successful repeats 
+           or branches */
+        state->mark_stack_base = mark_stack_base;  
+    else
+        /* subpattern should only fail after trying all backtrack points,
+           so, in case of failure, the top of the mark stack should be
+           the same as before executing the subpattern */
+        assert(state->mark_stack_base == mark_stack_base);
+
+    if (!positive) {
+        if (state->repeat) {
+            i = mark_restore(state, 0, lastmark);
+            if (i < 0)
+                return i;
+        }
+        LASTMARK_RESTORE();
+    }
+
+    if (positive)
+        return result;
+    else
+        return !result;
+}
+
+
+LOCAL(int)
 SRE_MATCH(SRE_STATE* state, SRE_CODE* pattern, int level)
 {
     /* check if string matches the given pattern.  returns <0 for
@@ -905,7 +971,7 @@
             state->ptr = ptr - pattern[1];
             if (state->ptr < state->beginning)
                 return 0;
-            i = SRE_MATCH(state, pattern + 2, level + 1);
+            i = SRE_ASSERT(state, pattern + 2, level + 1, 1);
             if (i <= 0)
                 return i;
             pattern += pattern[0];
@@ -917,11 +983,9 @@
             TRACE(("|%p|%p|ASSERT_NOT %d\n", pattern, ptr, pattern[1]));
             state->ptr = ptr - pattern[1];
             if (state->ptr >= state->beginning) {
-                i = SRE_MATCH(state, pattern + 2, level + 1);
-                if (i < 0)
+                i = SRE_ASSERT(state, pattern + 2, level + 1, 0);
+                if (i <= 0)
                     return i;
-                if (i)
-                    return 0;
             }
             pattern += pattern[0];
             break;