Modules/reopmodule.c - platform/external/python/cpython3 - Gitiles

 /***********************************************************
 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");
 }
	/***********************************************************
	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");
	}