New versions straight from Jeffrey Ollie's web site
diff --git a/Modules/regexpr.c b/Modules/regexpr.c
index 87f747f..0b6ec8b 100644
--- a/Modules/regexpr.c
+++ b/Modules/regexpr.c
@@ -1,3 +1,7 @@
+/*
+ * -*- mode: c-mode; c-file-style: python -*-
+ */
+
/* regexpr.c
*
* Author: Tatu Ylonen <ylo@ngs.fi>
@@ -57,6 +61,12 @@
#endif /* __STDC__ */
#endif /* THINK_C */
+/* The original code blithely assumed that sizeof(short) == 2. Not
+ * always true. Original instances of "(short)x" were replaced by
+ * SHORT(x), where SHORT is #defined below. */
+
+#define SHORT(x) ((x) & 0x8000 ? (x) - 0x10000 : (x))
+
/* The stack implementation is taken from an idea by Andrew Kuchling.
* It's a doubly linked list of arrays. The advantages of this over a
* simple linked list are that the number of mallocs required are
@@ -75,27 +85,27 @@
typedef union item_t
{
- struct
- {
- int num;
- int level;
- char *start;
- char *end;
- } reg;
- struct
- {
- int count;
- int level;
- int phantom;
- char *code;
- char *text;
- } fail;
- struct
- {
- int num;
- int level;
- int count;
- } cntr;
+ struct
+ {
+ int num;
+ int level;
+ char *start;
+ char *end;
+ } reg;
+ struct
+ {
+ int count;
+ int level;
+ int phantom;
+ char *code;
+ char *text;
+ } fail;
+ struct
+ {
+ int num;
+ int level;
+ int count;
+ } cntr;
} item_t;
#define STACK_PAGE_SIZE 256
@@ -105,43 +115,98 @@
typedef struct item_page_t
{
- item_t items[STACK_PAGE_SIZE];
- struct item_page_t *prev;
- struct item_page_t *next;
+ item_t items[STACK_PAGE_SIZE];
+ struct item_page_t *prev;
+ struct item_page_t *next;
} item_page_t;
typedef struct match_state
{
- /* Structure to encapsulate the stack. */
- struct
- {
- /* index into the curent page. If index == 0 and you need
- * to pop and item, move to the previous page and set
- * index = STACK_PAGE_SIZE - 1. Otherwise decrement index
- * to push a page. If index == STACK_PAGE_SIZE and you
- * need to push a page move to the next page and set index
- * = 0. If there is no new next page, allocate a new page
- * and link it in. Otherwise, increment index to push a
- * page. */
- int index;
- item_page_t *current; /* Pointer to the current page. */
- item_page_t first; /* First page is statically allocated. */
- } stack;
- char *start[NUM_REGISTERS];
- char *end[NUM_REGISTERS];
+ /* The number of registers that have been pushed onto the stack
+ * since the last failure point. */
- int changed[NUM_REGISTERS];
- /* The number of registers that have been pushed onto the stack
- * since the last failure point. */
- int count;
- /* Used to control when registers need to be pushed onto the
- * stack. */
- int level;
- /* The number of failure points on the stack. */
- int point;
+ int count;
+
+ /* Used to control when registers need to be pushed onto the
+ * stack. */
+
+ int level;
+
+ /* The number of failure points on the stack. */
+
+ int point;
+
+ /* Storage for the registers. Each register consists of two
+ * pointers to characters. So register N is represented as
+ * start[N] and end[N]. The pointers must be converted to
+ * offsets from the beginning of the string before returning the
+ * registers to the calling program. */
+
+ char *start[NUM_REGISTERS];
+ char *end[NUM_REGISTERS];
+
+ /* Keeps track of whether a register has changed recently. */
+
+ int changed[NUM_REGISTERS];
+
+ /* Structure to encapsulate the stack. */
+ struct
+ {
+ /* index into the curent page. If index == 0 and you need
+ * to pop an item, move to the previous page and set index
+ * = STACK_PAGE_SIZE - 1. Otherwise decrement index to
+ * push a page. If index == STACK_PAGE_SIZE and you need
+ * to push a page move to the next page and set index =
+ * 0. If there is no new next page, allocate a new page
+ * and link it in. Otherwise, increment index to push a
+ * page. */
+
+ int index;
+ item_page_t *current; /* Pointer to the current page. */
+ item_page_t first; /* First page is statically allocated. */
+ } stack;
} match_state;
+/* Initialize a state object */
+
+/* #define NEW_STATE(state) \ */
+/* memset(&state, 0, (void *)(&state.stack) - (void *)(&state)); \ */
+/* state.stack.current = &state.stack.first; \ */
+/* state.stack.first.prev = NULL; \ */
+/* state.stack.first.next = NULL; \ */
+/* state.stack.index = 0; \ */
+/* state.level = 1 */
+
+#define NEW_STATE(state, nregs) \
+{ \
+ int i; \
+ for (i = 0; i < nregs; i++) \
+ { \
+ state.start[i] = NULL; \
+ state.end[i] = NULL; \
+ state.changed[i] = 0; \
+ } \
+ state.stack.current = &state.stack.first; \
+ state.stack.first.prev = NULL; \
+ state.stack.first.next = NULL; \
+ state.stack.index = 0; \
+ state.level = 1; \
+ state.count = 0; \
+ state.level = 0; \
+ state.point = 0; \
+}
+
+/* Free any memory that might have been malloc'd */
+
+#define FREE_STATE(state) \
+while(state.stack.first.next != NULL) \
+{ \
+ state.stack.current = state.stack.first.next; \
+ state.stack.first.next = state.stack.current->next; \
+ free(state.stack.current); \
+}
+
/* Discard the top 'count' stack items. */
#define STACK_DISCARD(stack, count, on_error) \
@@ -226,24 +291,6 @@
#define STACK_EMPTY(stack) ((stack.index == 0) && \
(stack.current->prev == NULL))
-
-/* Initialize a state object */
-
-#define NEW_STATE(state) \
-memset(&state, 0, sizeof(match_state)); \
-state.stack.current = &state.stack.first; \
-state.level = 1
-
-/* Free any memory that might have been malloc'd */
-
-#define FREE_STATE(state) \
-while(state.stack.first.next != NULL) \
-{ \
- state.stack.current = state.stack.first.next; \
- state.stack.first.next = state.stack.current->next; \
- free(state.stack.current); \
-}
-
/* Return the start of register 'reg' */
#define GET_REG_START(state, reg) (state.start[reg])
@@ -302,22 +349,6 @@
/* Update the last failure point with a new position in the text. */
-/* #define UPDATE_FAILURE(state, xtext, on_error) \ */
-/* { \ */
-/* item_t *item; \ */
-/* STACK_DISCARD(state.stack, state.count, on_error); \ */
-/* STACK_TOP(state.stack, item, on_error); \ */
-/* item->fail.text = xtext; \ */
-/* state.count = 0; \ */
-/* } */
-
-/* #define UPDATE_FAILURE(state, xtext, on_error) \ */
-/* { \ */
-/* item_t *item; \ */
-/* STACK_BACK(state.stack, item, state.count + 1, on_error); \ */
-/* item->fail.text = xtext; \ */
-/* } */
-
#define UPDATE_FAILURE(state, xtext, on_error) \
{ \
item_t *item; \
@@ -391,7 +422,8 @@
Cwordbound, /* match if at word boundary */
Cnotwordbound, /* match if not at word boundary */
Csyntaxspec, /* matches syntax code (1 byte follows) */
- Cnotsyntaxspec /* matches if syntax code does not match (1 byte foll)*/
+ Cnotsyntaxspec, /* matches if syntax code does not match (1 byte foll)*/
+ Crepeat1
};
enum regexp_syntax_op /* syntax codes for plain and quoted characters */
@@ -581,6 +613,8 @@
case Cwordbound:
case Cnotwordbound:
{
+ for (a = 0; a < 256; a++)
+ fastmap[a] = 1;
break;
}
case Csyntaxspec:
@@ -648,7 +682,7 @@
{
a = (unsigned char)code[pos++];
a |= (unsigned char)code[pos++] << 8;
- pos += (int)(short)a;
+ pos += (int)SHORT(a);
if (visited[pos])
{
/* argh... the regexp contains empty loops. This is not
@@ -664,10 +698,15 @@
{
a = (unsigned char)code[pos++];
a |= (unsigned char)code[pos++] << 8;
- a = pos + (int)(short)a;
+ a = pos + (int)SHORT(a);
re_compile_fastmap_aux(code, a, visited, can_be_null, fastmap);
break;
}
+ case Crepeat1:
+ {
+ pos += 2;
+ break;
+ }
default:
{
abort(); /* probably some opcode is missing from this switch */
@@ -754,10 +793,11 @@
char ch;
int a;
int b;
+ int num_instructions = 0;
a = (unsigned char)*code++;
a |= (unsigned char)*code++ << 8;
- a = (int)(short)a;
+ a = (int)SHORT(a);
p1 = code + a + 3; /* skip the failure_jump */
assert(p1[-3] == Cfailure_jump);
@@ -775,6 +815,7 @@
/* loop until we find something that consumes a character */
loop_p1:
+ num_instructions++;
switch (*p1++)
{
case Cbol:
@@ -824,6 +865,7 @@
/* now we know that we can't backtrack. */
while (p1 != p2 - 3)
{
+ num_instructions++;
switch (*p1++)
{
case Cend:
@@ -873,11 +915,22 @@
}
}
+ make_update_jump:
code -= 3;
a += 3; /* jump to after the Cfailure_jump */
code[0] = Cupdate_failure_jump;
code[1] = a & 0xff;
code[2] = a >> 8;
+ if (num_instructions > 1)
+ return 1;
+ assert(num_instructions == 1);
+ /* if the only instruction matches a single character, we can do
+ * better
+ */
+ p1 = code + 3 + a; /* start of sole instruction */
+ if (*p1 == Cset || *p1 == Cexact || *p1 == Canychar ||
+ *p1 == Csyntaxspec || *p1 == Cnotsyntaxspec)
+ code[0] = Crepeat1;
return 1;
make_normal_jump:
@@ -939,6 +992,7 @@
case Cjump:
case Cdummy_failure_jump:
case Cfailure_jump:
+ case Crepeat1:
{
code += 2;
break;
@@ -1111,7 +1165,8 @@
re_compile_initialize();
bufp->used = 0;
bufp->fastmap_accurate = 0;
- bufp->uses_registers = 0;
+ bufp->uses_registers = 1;
+ bufp->num_registers = 1;
translate = bufp->translate;
pattern = bufp->buffer;
alloc = bufp->allocated;
@@ -1289,6 +1344,7 @@
STORE(Cstart_memory);
STORE(next_register);
open_registers[num_open_registers++] = next_register;
+ bufp->num_registers++;
next_register++;
}
paren_depth++;
@@ -1545,27 +1601,8 @@
code = bufp->buffer;
translate = bufp->translate;
-/* translated = NULL; */
-/* if (bufp->translate) */
-/* { */
-/* char *t1; */
-/* char *t2; */
-
-/* translated = malloc(size); */
-/* if (translated == NULL) */
-/* goto error; */
-
-/* t1 = string; */
-/* t2 = translated; */
-/* while(t1 < textend) */
-/* *t2++ = bufp->translate[*t1++]; */
-
-/* text = translated + pos; */
-/* textstart = translated; */
-/* textend = translated + size; */
-/* } */
- NEW_STATE(state);
+ NEW_STATE(state, bufp->num_registers);
continue_matching:
switch (*code++)
@@ -1587,7 +1624,7 @@
}
else
{
- for (a = 1; a < RE_NREGS; a++)
+ for (a = 1; a < bufp->num_registers; a++)
{
if ((GET_REG_START(state, a) == NULL) ||
(GET_REG_END(state, a) == NULL))
@@ -1599,10 +1636,13 @@
old_regs->start[a] = GET_REG_START(state, a) - textstart;
old_regs->end[a] = GET_REG_END(state, a) - textstart;
}
+ for (; a < RE_NREGS; a++)
+ {
+ old_regs->start[a] = -1;
+ old_regs->end[a] = -1;
+ }
}
}
-/* if(translated) */
-/* free(translated); */
FREE_STATE(state);
return match_end - pos;
}
@@ -1703,18 +1743,18 @@
{
a = (unsigned char)*code++;
a |= (unsigned char)*code++ << 8;
- code += (int)(short)a;
+ code += (int)SHORT(a);
goto continue_matching;
}
case Cdummy_failure_jump:
{
a = (unsigned char)*code++;
a |= (unsigned char)*code++ << 8;
- a = (int)(short)a;
+ a = (int)SHORT(a);
assert(*code == Cfailure_jump);
b = (unsigned char)code[1];
b |= (unsigned char)code[2] << 8;
- PUSH_FAILURE(state, code + (int)(short)b + 3, NULL, goto error);
+ PUSH_FAILURE(state, code + (int)SHORT(b) + 3, NULL, goto error);
code += a;
goto continue_matching;
}
@@ -1722,10 +1762,120 @@
{
a = (unsigned char)*code++;
a |= (unsigned char)*code++ << 8;
- a = (int)(short)a;
+ a = (int)SHORT(a);
PUSH_FAILURE(state, code + a, text, goto error);
goto continue_matching;
}
+ case Crepeat1:
+ {
+ char *pinst;
+ a = (unsigned char)*code++;
+ a |= (unsigned char)*code++ << 8;
+ a = (int)SHORT(a);
+ pinst = code + a;
+ /* pinst is sole instruction in loop, and it matches a
+ * single character. Since Crepeat1 was originally a
+ * Cupdate_failure_jump, we also know that backtracking is
+ * useless: so long as the single-character expression matches,
+ * it must be used. Also, in the case of +, we've already
+ * matched one character, so + can't fail: nothing here can
+ * cause a failure.
+ */
+ switch (*pinst++)
+ {
+ case Cset:
+ {
+ if (translate)
+ {
+ while (text < textend)
+ {
+ ch = translate[(unsigned char)*text];
+ if (pinst[ch/8] & (1<<(ch & 7)))
+ text++;
+ else
+ break;
+ }
+ }
+ else
+ {
+ while (text < textend)
+ {
+ ch = (unsigned char)*text;
+ if (pinst[ch/8] & (1<<(ch & 7)))
+ text++;
+ else
+ break;
+ }
+ }
+ break;
+ }
+ case Cexact:
+ {
+ ch = (unsigned char)*pinst;
+ if (translate)
+ {
+ while (text < textend &&
+ translate[(unsigned char)*text] == ch)
+ text++;
+ }
+ else
+ {
+ while (text < textend && (unsigned char)*text == ch)
+ text++;
+ }
+ break;
+ }
+ case Canychar:
+ {
+ while (text < textend && (unsigned char)*text != '\n')
+ text++;
+ break;
+ }
+ case Csyntaxspec:
+ {
+ a = (unsigned char)*pinst;
+ if (translate)
+ {
+ while (text < textend &&
+ translate[SYNTAX(*text)] == a)
+ text++;
+ }
+ else
+ {
+ while (text < textend && SYNTAX(*text) == a)
+ text++;
+ }
+ break;
+ }
+ case Cnotsyntaxspec:
+ {
+ a = (unsigned char)*pinst;
+ if (translate)
+ {
+ while (text < textend &&
+ translate[SYNTAX(*text)] != a)
+ text++;
+ }
+ else
+ {
+ while (text < textend && SYNTAX(*text) != a)
+ text++;
+ }
+ break;
+ }
+ default:
+ {
+ abort();
+ /*NOTREACHED*/
+ }
+ }
+ /* due to the funky way + and * are compiled, the top failure-
+ * stack entry at this point is actually a success entry --
+ * update it & pop it
+ */
+ UPDATE_FAILURE(state, text, goto error);
+ goto fail; /* i.e., succeed <wink/sigh> */
+ }
case Cbegbuf:
{
if (text == textstart)
diff --git a/Modules/regexpr.h b/Modules/regexpr.h
index e623362..1221802 100644
--- a/Modules/regexpr.h
+++ b/Modules/regexpr.h
@@ -1,3 +1,7 @@
+/*
+ * -*- mode: c-mode; c-file-style: python -*-
+ */
+
#ifndef Py_REGEXPR_H
#define Py_REGEXPR_H
#ifdef __cplusplus
@@ -5,22 +9,22 @@
#endif
/*
+ * regexpr.h
+ *
+ * Author: Tatu Ylonen <ylo@ngs.fi>
+ *
+ * Copyright (c) 1991 Tatu Ylonen, Espoo, Finland
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies. This
+ * software is provided "as is" without express or implied warranty.
+ *
+ * Created: Thu Sep 26 17:15:36 1991 ylo
+ * Last modified: Mon Nov 4 15:49:46 1991 ylo
+ */
-regexpr.h
-
-Author: Tatu Ylonen <ylo@ngs.fi>
-
-Copyright (c) 1991 Tatu Ylonen, Espoo, Finland
-
-Permission to use, copy, modify, distribute, and sell this software
-and its documentation for any purpose is hereby granted without fee,
-provided that the above copyright notice appear in all copies. This
-software is provided "as is" without express or implied warranty.
-
-Created: Thu Sep 26 17:15:36 1991 ylo
-Last modified: Mon Nov 4 15:49:46 1991 ylo
-
-*/
+/* $Id$ */
#ifndef REGEXPR_H
#define REGEXPR_H
@@ -29,21 +33,22 @@
typedef struct re_pattern_buffer
{
- char *buffer; /* compiled pattern */
- int allocated; /* allocated size of compiled pattern */
- int used; /* actual length of compiled pattern */
- char *fastmap; /* fastmap[ch] is true if ch can start pattern */
- char *translate; /* translation to apply during compilation/matching */
- char fastmap_accurate; /* true if fastmap is valid */
- char can_be_null; /* true if can match empty string */
- char uses_registers; /* registers are used and need to be initialized */
- char anchor; /* anchor: 0=none 1=begline 2=begbuf */
+ char *buffer; /* compiled pattern */
+ int allocated; /* allocated size of compiled pattern */
+ int used; /* actual length of compiled pattern */
+ char *fastmap; /* fastmap[ch] is true if ch can start pattern */
+ char *translate; /* translation to apply during compilation/matching */
+ char fastmap_accurate; /* true if fastmap is valid */
+ char can_be_null; /* true if can match empty string */
+ char uses_registers; /* registers are used and need to be initialized */
+ int num_registers; /* number of registers used */
+ char anchor; /* anchor: 0=none 1=begline 2=begbuf */
} *regexp_t;
typedef struct re_registers
{
- int start[RE_NREGS]; /* start offset of region */
- int end[RE_NREGS]; /* end offset of region */
+ int start[RE_NREGS]; /* start offset of region */
+ int end[RE_NREGS]; /* end offset of region */
} *regexp_registers_t;
/* bit definitions for syntax */
@@ -77,52 +82,53 @@
#ifdef HAVE_PROTOTYPES
extern int re_syntax;
-/* This is the actual syntax mask. It was added so that Python
- could do syntax-dependent munging of patterns before compilation. */
+/* This is the actual syntax mask. It was added so that Python could do
+ * syntax-dependent munging of patterns before compilation. */
int re_set_syntax(int syntax);
/* This sets the syntax to use and returns the previous syntax. The
- syntax is specified by a bit mask of the above defined bits. */
+ * syntax is specified by a bit mask of the above defined bits. */
char *re_compile_pattern(char *regex, int regex_size, regexp_t compiled);
/* This compiles the regexp (given in regex and length in regex_size).
- This returns NULL if the regexp compiled successfully, and an error
- message if an error was encountered. The buffer field must be
- initialized to a memory area allocated by malloc (or to NULL) before
- use, and the allocated field must be set to its length (or 0 if buffer is
- NULL). Also, the translate field must be set to point to a valid
- translation table, or NULL if it is not used. */
+ * This returns NULL if the regexp compiled successfully, and an error
+ * message if an error was encountered. The buffer field must be
+ * initialized to a memory area allocated by malloc (or to NULL) before
+ * use, and the allocated field must be set to its length (or 0 if
+ * buffer is NULL). Also, the translate field must be set to point to a
+ * valid translation table, or NULL if it is not used. */
int re_match(regexp_t compiled, char *string, int size, int pos,
regexp_registers_t old_regs);
/* This tries to match the regexp against the string. This returns the
- length of the matched portion, or -1 if the pattern could not be
- matched and -2 if an error (such as failure stack overflow) is
- encountered. */
+ * length of the matched portion, or -1 if the pattern could not be
+ * matched and -2 if an error (such as failure stack overflow) is
+ * encountered. */
int re_search(regexp_t compiled, char *string, int size, int startpos,
int range, regexp_registers_t regs);
-/* This rearches for a substring matching the regexp. This returns the first
- index at which a match is found. range specifies at how many positions to
- try matching; positive values indicate searching forwards, and negative
- values indicate searching backwards. mstop specifies the offset beyond
- which a match must not go. This returns -1 if no match is found, and
- -2 if an error (such as failure stack overflow) is encountered. */
+/* This rearches for a substring matching the regexp. This returns the
+ * first index at which a match is found. range specifies at how many
+ * positions to try matching; positive values indicate searching
+ * forwards, and negative values indicate searching backwards. mstop
+ * specifies the offset beyond which a match must not go. This returns
+ * -1 if no match is found, and -2 if an error (such as failure stack
+ * overflow) is encountered. */
void re_compile_fastmap(regexp_t compiled);
/* This computes the fastmap for the regexp. For this to have any effect,
- the calling program must have initialized the fastmap field to point
- to an array of 256 characters. */
+ * the calling program must have initialized the fastmap field to point
+ * to an array of 256 characters. */
char *re_comp(char *s);
/* BSD 4.2 regex library routine re_comp. This compiles the regexp into
- an internal buffer. This returns NULL if the regexp was compiled
- successfully, and an error message if there was an error. */
+ * an internal buffer. This returns NULL if the regexp was compiled
+ * successfully, and an error message if there was an error. */
int re_exec(char *s);
-/* BSD 4.2 regexp library routine re_exec. This returns true if the string
- matches the regular expression (that is, a matching part is found
- anywhere in the string). */
+/* BSD 4.2 regexp library routine re_exec. This returns true if the
+ * string matches the regular expression (that is, a matching part is
+ * found anywhere in the string). */
#else /* HAVE_PROTOTYPES */
diff --git a/Modules/reopmodule.c b/Modules/reopmodule.c
new file mode 100644
index 0000000..0d12210
--- /dev/null
+++ b/Modules/reopmodule.c
@@ -0,0 +1,375 @@
+/***********************************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI or Corporation for National Research Initiatives or
+CNRI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+While CWI is the initial source for this software, a modified version
+is made available by the Corporation for National Research Initiatives
+(CNRI) at the Internet address ftp://ftp.python.org.
+
+STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
+CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* $Id$ */
+
+/* Regular expression objects */
+/* This uses Tatu Ylonen's copyleft-free reimplementation of
+ GNU regular expressions */
+
+#include "Python.h"
+
+#include <ctype.h>
+
+#include "regexpr.h"
+
+static PyObject *ReopError; /* Exception */
+
+static PyObject *
+makeresult(regs, num_regs)
+ struct re_registers *regs;
+ int num_regs;
+{
+ PyObject *v;
+ int i;
+ static PyObject *filler = NULL;
+
+ if (filler == NULL) {
+ filler = Py_BuildValue("(ii)", -1, -1);
+ if (filler == NULL)
+ return NULL;
+ }
+ v = PyTuple_New(num_regs);
+ if (v == NULL)
+ return NULL;
+
+ for (i = 0; i < num_regs; i++) {
+ int lo = regs->start[i];
+ int hi = regs->end[i];
+ PyObject *w;
+ if (lo == -1 && hi == -1) {
+ w = filler;
+ Py_INCREF(w);
+ }
+ else
+ w = Py_BuildValue("(ii)", lo, hi);
+ if (w == NULL || PyTuple_SetItem(v, i, w) < 0) {
+ Py_DECREF(v);
+ return NULL;
+ }
+ }
+ return v;
+}
+
+static PyObject *
+reop_match(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *string;
+ int fastmaplen, stringlen;
+ int can_be_null, anchor, i;
+ int num_regs, flags, pos, result;
+ struct re_pattern_buffer bufp;
+ struct re_registers re_regs;
+
+ if (!PyArg_Parse(args, "(s#iiis#is#i)",
+ &(bufp.buffer), &(bufp.allocated),
+ &num_regs, &flags, &can_be_null,
+ &(bufp.fastmap), &fastmaplen,
+ &anchor,
+ &string, &stringlen,
+ &pos))
+ return NULL;
+
+ /* XXX sanity-check the input data */
+ bufp.used=bufp.allocated;
+ bufp.translate=NULL;
+ bufp.fastmap_accurate=1;
+ bufp.can_be_null=can_be_null;
+ bufp.uses_registers=1;
+ bufp.num_registers=num_regs;
+ bufp.anchor=anchor;
+
+ for(i=0; i<num_regs; i++) {re_regs.start[i]=-1; re_regs.end[i]=-1;}
+
+ result = re_match(&bufp,
+ string, stringlen, pos,
+ &re_regs);
+ if (result < -1) {
+ /* Failure like stack overflow */
+ PyErr_SetString(ReopError, "match failure");
+ return NULL;
+ }
+ return makeresult(&re_regs, num_regs);
+}
+
+static PyObject *
+reop_search(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *string;
+ int fastmaplen, stringlen;
+ int can_be_null, anchor, i;
+ int num_regs, flags, pos, result;
+ struct re_pattern_buffer bufp;
+ struct re_registers re_regs;
+
+ if (!PyArg_Parse(args, "(s#iiis#is#i)",
+ &(bufp.buffer), &(bufp.allocated),
+ &num_regs, &flags, &can_be_null,
+ &(bufp.fastmap), &fastmaplen,
+ &anchor,
+ &string, &stringlen,
+ &pos))
+ return NULL;
+
+ /* XXX sanity-check the input data */
+ bufp.used=bufp.allocated;
+ bufp.translate=NULL;
+ bufp.fastmap_accurate=1;
+ bufp.can_be_null=can_be_null;
+ bufp.uses_registers=1;
+ bufp.num_registers=1;
+ bufp.anchor=anchor;
+
+ for(i=0; i<num_regs; i++) {re_regs.start[i]=-1; re_regs.end[i]=-1;}
+
+ result = re_search(&bufp,
+ string, stringlen, pos, stringlen-pos,
+ &re_regs);
+ if (result < -1) {
+ /* Failure like stack overflow */
+ PyErr_SetString(ReopError, "match failure");
+ return NULL;
+ }
+ return makeresult(&re_regs, num_regs);
+}
+
+#if 0
+/* Functions originally in the regsub module.
+ Added June 1, 1997.
+ */
+
+/* A cache of previously used patterns is maintained. Notice that if
+ you change the reop syntax flag, entries in the cache are
+ invalidated.
+ XXX Solution: use (syntax flag, pattern) as keys? Clear the cache
+ every so often, or once it gets past a certain size?
+*/
+
+static PyObject *cache_dict=NULL;
+
+/* Accept an object; if it's a reop pattern, Py_INCREF it and return
+ it. If it's a string, a reop object is compiled and cached.
+*/
+
+static reopobject *
+cached_compile(pattern)
+ PyObject *pattern;
+{
+ reopobject *p2;
+
+ if (!PyString_Check(pattern))
+ {
+ /* It's not a string, so assume it's a compiled reop object */
+ /* XXX check that! */
+ Py_INCREF(pattern);
+ return (reopobject*)pattern;
+ }
+ if (cache_dict==NULL)
+ {
+ cache_dict=PyDict_New();
+ if (cache_dict==NULL)
+ {
+ return (reopobject*)NULL;
+ }
+ }
+
+ /* See if the pattern has already been cached; if so, return that
+ reop object */
+ p2=(reopobject*)PyDict_GetItem(cache_dict, pattern);
+ if (p2)
+ {
+ Py_INCREF(p2);
+ return (reopobject*)p2;
+ }
+
+ /* Compile the pattern and cache it */
+ p2=(reopobject*)newreopobject(pattern, NULL, pattern, NULL);
+ if (!p2) return p2;
+ PyDict_SetItem(cache_dict, pattern, (PyObject*)p2);
+ return p2;
+}
+
+
+static PyObject *
+internal_split(args, retain)
+ PyObject *args;
+ int retain;
+{
+ PyObject *newlist, *s;
+ reopobject *pattern;
+ int maxsplit=0, count=0, length, next=0, result;
+ int match_end=0; /* match_start is defined below */
+ char *start;
+
+ if (!PyArg_ParseTuple(args, "s#Oi", &start, &length, &pattern,
+ &maxsplit))
+ {
+ PyErr_Clear();
+ if (!PyArg_ParseTuple(args, "s#O", &start, &length, &pattern))
+ return NULL;
+ }
+ pattern=cached_compile((PyObject *)pattern);
+ if (!pattern) return NULL;
+
+ newlist=PyList_New(0);
+ if (!newlist) return NULL;
+
+ do
+ {
+ result = re_search(&pattern->re_patbuf,
+ start, length, next, length-next,
+ &pattern->re_regs);
+ if (result < -1)
+ { /* Erk... an error happened during the reop search */
+ Py_DECREF(newlist);
+ PyErr_SetString(ReopError, "match failure");
+ return NULL;
+ }
+ if (next<=result)
+ {
+ int match_start=pattern->re_regs.start[0];
+ int oldmatch_end=match_end;
+ match_end=pattern->re_regs.end[0];
+
+ if (match_start==match_end)
+ { /* A zero-length match; increment to the next position */
+ next=result+1;
+ match_end=oldmatch_end;
+ continue;
+ }
+
+ /* Append the string up to the start of the match */
+ s=PyString_FromStringAndSize(start+oldmatch_end, match_start-oldmatch_end);
+ if (!s)
+ {
+ Py_DECREF(newlist);
+ return NULL;
+ }
+ PyList_Append(newlist, s);
+ Py_DECREF(s);
+
+ if (retain)
+ {
+ /* Append a string containing whatever matched */
+ s=PyString_FromStringAndSize(start+match_start, match_end-match_start);
+ if (!s)
+ {
+ Py_DECREF(newlist);
+ return NULL;
+ }
+ PyList_Append(newlist, s);
+ Py_DECREF(s);
+ }
+ /* Update the pointer, and increment the count of splits */
+ next=match_end; count++;
+ }
+ } while (result!=-1 && !(maxsplit && maxsplit==count) &&
+ next<length);
+ s=PyString_FromStringAndSize(start+match_end, length-match_end);
+ if (!s)
+ {
+ Py_DECREF(newlist);
+ return NULL;
+ }
+ PyList_Append(newlist, s);
+ Py_DECREF(s);
+ Py_DECREF(pattern);
+ return newlist;
+}
+
+static PyObject *
+reop_split(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return internal_split(args, 0);
+}
+
+static PyObject *
+reop_splitx(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return internal_split(args, 1);
+}
+#endif
+
+static struct PyMethodDef reop_global_methods[] = {
+ {"match", reop_match, 0},
+ {"search", reop_search, 0},
+#if 0
+ {"split", reop_split, 0},
+ {"splitx", reop_splitx, 0},
+#endif
+ {NULL, NULL} /* sentinel */
+};
+
+void
+initreop()
+{
+ PyObject *m, *d, *v;
+ int i;
+ char *s;
+
+ m = Py_InitModule("reop", reop_global_methods);
+ d = PyModule_GetDict(m);
+
+ /* Initialize reop.error exception */
+ v = ReopError = PyString_FromString("reop.error");
+ if (v == NULL || PyDict_SetItemString(d, "error", v) != 0)
+ goto finally;
+
+ /* Initialize reop.casefold constant */
+ if (!(v = PyString_FromStringAndSize((char *)NULL, 256)))
+ goto finally;
+
+ if (!(s = PyString_AsString(v)))
+ goto finally;
+
+ for (i = 0; i < 256; i++) {
+ if (isupper(i))
+ s[i] = tolower(i);
+ else
+ s[i] = i;
+ }
+ if (PyDict_SetItemString(d, "casefold", v) < 0)
+ goto finally;
+ Py_DECREF(v);
+
+ if (!PyErr_Occurred())
+ return;
+ finally:
+ Py_FatalError("can't initialize reop module");
+}