diff options
Diffstat (limited to 'Modules')
| -rw-r--r-- | Modules/pcre-int.h | 295 | ||||
| -rw-r--r-- | Modules/pcre.h | 84 | ||||
| -rw-r--r-- | Modules/pcremodule.c | 636 | ||||
| -rw-r--r-- | Modules/pypcre.c | 4756 |
4 files changed, 0 insertions, 5771 deletions
diff --git a/Modules/pcre-int.h b/Modules/pcre-int.h deleted file mode 100644 index d07d536..0000000 --- a/Modules/pcre-int.h +++ /dev/null @@ -1,295 +0,0 @@ -/************************************************* -* Perl-Compatible Regular Expressions * -*************************************************/ - - -#define PCRE_VERSION "1.09 28-Apr-1998" - - -/* This is a library of functions to support regular expressions whose syntax -and semantics are as close as possible to those of the Perl 5 language. See -the file Tech.Notes for some information on the internals. - -Written by: Philip Hazel <ph10@cam.ac.uk> - - Copyright (c) 1998 University of Cambridge - ------------------------------------------------------------------------------ -Permission is granted to anyone to use this software for any purpose on any -computer system, and to redistribute it freely, subject to the following -restrictions: - -1. This software is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - -2. The origin of this software must not be misrepresented, either by - explicit claim or by omission. - -3. Altered versions must be plainly marked as such, and must not be - misrepresented as being the original software. ------------------------------------------------------------------------------ -*/ - -/* This header contains definitions that are shared between the different -modules, but which are not relevant to the outside. */ - - -/* Standard C headers plus the external interface definition */ - -#include <ctype.h> -#include <limits.h> -#include <setjmp.h> -#include <stddef.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include "pcre.h" - -/* In case there is no definition of offsetof() provided - though any proper -Standard C system should have one. */ - -#ifndef offsetof -#define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field)) -#endif - -/* Private options flags start at the most significant end of the two bytes. -The public options defined in pcre.h start at the least significant end. Make -sure they don't overlap! */ - -#define PCRE_FIRSTSET 0x8000 /* first_char is set */ -#define PCRE_STARTLINE 0x4000 /* start after \n for multiline */ -#define PCRE_COMPILED_CASELESS 0x2000 /* like it says */ - -/* Options for the "extra" block produced by pcre_study(). */ - -#define PCRE_STUDY_CASELESS 0x01 /* study was caseless */ -#define PCRE_STUDY_MAPPED 0x02 /* a map of starting chars exists */ - -/* Masks for identifying the public options: all permitted at compile time, -only some permitted at run or study time. */ - -#ifdef FOR_PYTHON -#define PUBLIC_OPTIONS \ - (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \ - PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY| \ - PCRE_LOCALE) -#else -#define PUBLIC_OPTIONS \ - (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \ - PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY) -#endif -#define PUBLIC_EXEC_OPTIONS \ - (PCRE_CASELESS|PCRE_ANCHORED|PCRE_MULTILINE|PCRE_NOTBOL|PCRE_NOTEOL| \ - PCRE_DOTALL|PCRE_DOLLAR_ENDONLY) - -#define PUBLIC_STUDY_OPTIONS (PCRE_CASELESS) - -/* Magic number to provide a small check against being handed junk. */ - -#define MAGIC_NUMBER 0x50435245 /* 'PCRE' */ - -/* Miscellaneous definitions */ - -typedef int BOOL; - -#define FALSE 0 -#define TRUE 1 - -/* These are escaped items that aren't just an encoding of a particular data -value such as \n. They must have non-zero values, as check_escape() returns -their negation. Also, they must appear in the same order as in the opcode -definitions below, up to ESC_Z. The final one must be ESC_REF as subsequent -values are used for \1, \2, \3, etc. There is a test in the code for an escape -greater than ESC_b and less than ESC_X to detect the types that may be -repeated. If any new escapes are put in-between that don't consume a character, -that code will have to change. */ - -enum { ESC_A = 1, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s, ESC_W, ESC_w, - - /* These are not Perl escapes, so can't appear in the */ - ESC_X, /* simple table-lookup because they must be conditional */ - /* on PCRE_EXTRA. */ - ESC_Z, - ESC_REF }; - -/* Opcode table: OP_BRA must be last, as all values >= it are used for brackets -that extract substrings. Starting from 1 (i.e. after OP_END), the values up to -OP_EOD must correspond in order to the list of escapes immediately above. */ - -enum { - OP_END, /* End of pattern */ - - /* Values corresponding to backslashed metacharacters */ - - OP_SOD, /* Start of data: \A */ - OP_NOT_WORD_BOUNDARY, /* \B */ - OP_WORD_BOUNDARY, /* \b */ - OP_NOT_DIGIT, /* \D */ - OP_DIGIT, /* \d */ - OP_NOT_WHITESPACE, /* \S */ - OP_WHITESPACE, /* \s */ - OP_NOT_WORDCHAR, /* \W */ - OP_WORDCHAR, /* \w */ - OP_CUT, /* The analogue of Prolog's "cut" operation (extension) */ - OP_EOD, /* End of data: \Z. */ - - OP_NOT_WORD_BOUNDARY_L, /* localized \B */ - OP_WORD_BOUNDARY_L, /* localized \b */ - OP_NOT_WORDCHAR_L, /* localized \W */ - OP_WORDCHAR_L, /* localized \w */ - - OP_CIRC, /* Start of line - varies with multiline switch */ - OP_DOLL, /* End of line - varies with multiline switch */ - OP_ANY, /* Match any character */ - OP_CHARS, /* Match string of characters */ - OP_NOT, /* Match anything but the following char */ - - OP_STAR, /* The maximizing and minimizing versions of */ - OP_MINSTAR, /* all these opcodes must come in pairs, with */ - OP_PLUS, /* the minimizing one second. */ - OP_MINPLUS, /* This first set applies to single characters */ - OP_QUERY, - OP_MINQUERY, - OP_UPTO, /* From 0 to n matches */ - OP_MINUPTO, - OP_EXACT, /* Exactly n matches */ - - OP_NOTSTAR, /* The maximizing and minimizing versions of */ - OP_NOTMINSTAR, /* all these opcodes must come in pairs, with */ - OP_NOTPLUS, /* the minimizing one second. */ - OP_NOTMINPLUS, /* This first set applies to "not" single characters */ - OP_NOTQUERY, - OP_NOTMINQUERY, - OP_NOTUPTO, /* From 0 to n matches */ - OP_NOTMINUPTO, - OP_NOTEXACT, /* Exactly n matches */ - - OP_TYPESTAR, /* The maximizing and minimizing versions of */ - OP_TYPEMINSTAR, /* all these opcodes must come in pairs, with */ - OP_TYPEPLUS, /* the minimizing one second. These codes must */ - OP_TYPEMINPLUS, /* be in exactly the same order as those above. */ - OP_TYPEQUERY, /* This set applies to character types such as \d */ - OP_TYPEMINQUERY, - OP_TYPEUPTO, /* From 0 to n matches */ - OP_TYPEMINUPTO, - OP_TYPEEXACT, /* Exactly n matches */ - - OP_CRSTAR, /* The maximizing and minimizing versions of */ - OP_CRMINSTAR, /* all these opcodes must come in pairs, with */ - OP_CRPLUS, /* the minimizing one second. These codes must */ - OP_CRMINPLUS, /* be in exactly the same order as those above. */ - OP_CRQUERY, /* These are for character classes and back refs */ - OP_CRMINQUERY, - OP_CRRANGE, /* These are different to the three seta above. */ - OP_CRMINRANGE, - - OP_CLASS, /* Match a character class */ - OP_NEGCLASS, /* Match a character class, specified negatively */ - OP_CLASS_L, /* Match a character class */ - OP_REF, /* Match a back reference */ - - OP_ALT, /* Start of alternation */ - OP_KET, /* End of group that doesn't have an unbounded repeat */ - OP_KETRMAX, /* These two must remain together and in this */ - OP_KETRMIN, /* order. They are for groups the repeat for ever. */ - - OP_ASSERT, - OP_ASSERT_NOT, - OP_ONCE, /* Once matched, don't back up into the subpattern */ - - OP_BRAZERO, /* These two must remain together and in this */ - OP_BRAMINZERO, /* order. */ - - OP_BRA /* This and greater values are used for brackets that - extract substrings. */ -}; - -/* The highest extraction number. This is limited by the number of opcodes -left after OP_BRA, i.e. 255 - OP_BRA. We actually set it somewhat lower. */ - -#define EXTRACT_MAX 99 - -/* The texts of compile-time error messages are defined as macros here so that -they can be accessed by the POSIX wrapper and converted into error codes. Yes, -I could have used error codes in the first place, but didn't feel like changing -just to accommodate the POSIX wrapper. */ - -#define ERR1 "\\ at end of pattern" -#define ERR2 "\\c at end of pattern" -#define ERR3 "unrecognized character follows \\" -#define ERR4 "numbers out of order in {} quantifier" -#define ERR5 "number too big in {} quantifier" -#define ERR6 "missing terminating ] for character class" -#define ERR7 "invalid escape sequence in character class" -#define ERR8 "range out of order in character class" -#define ERR9 "nothing to repeat" -#define ERR10 "operand of unlimited repeat could match the empty string" -#define ERR11 "internal error: unexpected repeat" -#define ERR12 "unrecognized character after (?" -#define ERR13 "too many capturing parenthesized sub-patterns" -#define ERR14 "missing )" -#define ERR15 "back reference to non-existent subpattern" -#define ERR16 "erroffset passed as NULL" -#define ERR17 "unknown option bit(s) set" -#define ERR18 "missing ) after comment" -#define ERR19 "too many sets of parentheses" -#define ERR20 "regular expression too large" -#define ERR21 "failed to get memory" -#define ERR22 "unmatched brackets" -#define ERR23 "internal error: code overflow" - -/* All character handling must be done as unsigned characters. Otherwise there -are problems with top-bit-set characters and functions such as isspace(). -However, we leave the interface to the outside world as char *, because that -should make things easier for callers. We define a short type for unsigned char -to save lots of typing. I tried "uchar", but it causes problems on Digital -Unix, where it is defined in sys/types, so use "uschar" instead. */ - -typedef unsigned char uschar; - -/* The real format of the start of the pcre block; the actual code vector -runs on as long as necessary after the end. */ - -typedef struct real_pcre { - unsigned int magic_number; - unsigned short int options; - unsigned char top_bracket; - unsigned char top_backref; - unsigned char first_char; - unsigned char code[1]; -} real_pcre; - -/* The real format of the extra block returned by pcre_study(). */ - -typedef struct real_pcre_extra { - unsigned char options; - unsigned char start_bits[32]; -} real_pcre_extra; - -/* Global tables from chartables.c */ - -extern uschar pcre_lcc[]; -extern uschar pcre_fcc[]; -extern uschar pcre_cbits[]; -extern uschar pcre_ctypes[]; - -/* Bit definitions for entries in pcre_ctypes[]. */ - -#define ctype_space 0x01 -#define ctype_letter 0x02 -#define ctype_digit 0x04 -#define ctype_xdigit 0x08 -#define ctype_word 0x10 /* alphameric or '_' */ -#define ctype_odigit 0x20 /* octal digit */ -#define ctype_meta 0x80 /* regexp meta char or zero (end pattern) */ - -/* Offsets for the bitmap tables */ - -#define cbit_digit 0 -#define cbit_letter 32 -#define cbit_word 64 -#define cbit_space 96 -#define cbit_length 128 /* Length of the cbits table */ - -/* End of internal.h */ diff --git a/Modules/pcre.h b/Modules/pcre.h deleted file mode 100644 index 3606823..0000000 --- a/Modules/pcre.h +++ /dev/null @@ -1,84 +0,0 @@ -/************************************************* -* Perl-Compatible Regular Expressions * -*************************************************/ - -/* Copyright (c) 1998 University of Cambridge */ - -#ifndef _PCRE_H -#define _PCRE_H - -#ifdef FOR_PYTHON -#include "Python.h" -#endif - -/* Have to include stdlib.h in order to ensure that size_t is defined; -it is needed here for malloc. */ - -#ifndef DONT_HAVE_SYS_TYPES_H -#include <sys/types.h> -#endif -#include <stdlib.h> - -/* Allow for C++ users */ - -#ifdef __cplusplus -extern "C" { -#endif - -/* Options */ - -#define PCRE_CASELESS 0x0001 -#define PCRE_EXTENDED 0x0002 -#define PCRE_ANCHORED 0x0004 -#define PCRE_MULTILINE 0x0008 -#define PCRE_DOTALL 0x0010 -#define PCRE_DOLLAR_ENDONLY 0x0020 -#define PCRE_EXTRA 0x0040 -#define PCRE_NOTBOL 0x0080 -#define PCRE_NOTEOL 0x0100 -#define PCRE_UNGREEDY 0x0400 -#ifdef FOR_PYTHON -#define PCRE_LOCALE 0x0200 -#endif - -/* Exec-time error codes */ - -#define PCRE_ERROR_NOMATCH (-1) -#define PCRE_ERROR_BADREF (-2) -#define PCRE_ERROR_NULL (-3) -#define PCRE_ERROR_BADOPTION (-4) -#define PCRE_ERROR_BADMAGIC (-5) -#define PCRE_ERROR_UNKNOWN_NODE (-6) -#define PCRE_ERROR_NOMEMORY (-7) - -/* Types */ - -typedef void pcre; -typedef void pcre_extra; - -/* Store get and free functions. These can be set to alternative malloc/free -functions if required. */ - -extern void *(*pcre_malloc)(size_t); -extern void (*pcre_free)(void *); - -/* Functions */ - -#ifdef FOR_PYTHON -extern pcre *pcre_compile(const char *, int, const char **, int *, PyObject *); -extern int pcre_exec(const pcre *, const pcre_extra *, const char *, - int, int, int, int *, int); -#else -extern pcre *pcre_compile(const char *, int, const char **, int *); -extern int pcre_exec(const pcre *, const pcre_extra *, const char *, - int, int, int *, int); -#endif -extern int pcre_info(const pcre *, int *, int *); -extern pcre_extra *pcre_study(const pcre *, int, const char **); -extern const char *pcre_version(void); - -#ifdef __cplusplus -} /* extern "C" */ -#endif - -#endif /* End of pcre.h */ diff --git a/Modules/pcremodule.c b/Modules/pcremodule.c deleted file mode 100644 index 656539a..0000000 --- a/Modules/pcremodule.c +++ /dev/null @@ -1,636 +0,0 @@ -/* Pcre objects */ - -#include "Python.h" - -#ifndef Py_eval_input -/* For Python 1.4, graminit.h has to be explicitly included */ -#include "graminit.h" -#define Py_eval_input eval_input -#endif - -#ifndef FOR_PYTHON -#define FOR_PYTHON -#endif - -#include "pcre.h" -#include "pcre-int.h" - -static PyObject *ErrorObject; - -typedef struct { - PyObject_HEAD - pcre *regex; - pcre_extra *regex_extra; - int num_groups; -} PcreObject; - -static PyTypeObject Pcre_Type; - -#define PcreObject_Check(v) ((v)->ob_type == &Pcre_Type) -#define NORMAL 0 -#define CHARCLASS 1 -#define REPLACEMENT 2 - -#define CHAR 0 -#define MEMORY_REFERENCE 1 -#define SYNTAX 2 -#define NOT_SYNTAX 3 -#define SET 4 -#define WORD_BOUNDARY 5 -#define NOT_WORD_BOUNDARY 6 -#define BEGINNING_OF_BUFFER 7 -#define END_OF_BUFFER 8 -#define STRING 9 - -static PcreObject * -newPcreObject(PyObject *args) -{ - PcreObject *self; - self = PyObject_New(PcreObject, &Pcre_Type); - if (self == NULL) - return NULL; - self->regex = NULL; - self->regex_extra = NULL; - return self; -} - -/* Pcre methods */ - -static void -PyPcre_dealloc(PcreObject *self) -{ - if (self->regex) (pcre_free)(self->regex); - if (self->regex_extra) (pcre_free)(self->regex_extra); - PyObject_Del(self); -} - - -static PyObject * -PyPcre_exec(PcreObject *self, PyObject *args) -{ - char *string; - int stringlen, pos = 0, options=0, endpos = -1, i, count; - int offsets[100*2]; - PyObject *list; - - if (!PyArg_ParseTuple(args, "t#|iii:match", &string, &stringlen, - &pos, &endpos, &options)) - return NULL; - if (endpos == -1) {endpos = stringlen;} - count = pcre_exec(self->regex, self->regex_extra, - string, endpos, pos, options, - offsets, sizeof(offsets)/sizeof(int) ); - /* If an error occurred during the match, and an exception was raised, - just return NULL and leave the exception alone. The most likely - problem to cause this would be running out of memory for - the failure stack. */ - if (PyErr_Occurred()) - { - return NULL; - } - if (count==PCRE_ERROR_NOMATCH) {Py_INCREF(Py_None); return Py_None;} - if (count<0) - { - PyObject *errval = Py_BuildValue("si", "Regex execution error", count); - PyErr_SetObject(ErrorObject, errval); - Py_XDECREF(errval); - return NULL; - } - - list=PyList_New(self->num_groups+1); - if (list==NULL) return NULL; - for(i=0; i<=self->num_groups; i++) - { - PyObject *v; - int start=offsets[i*2], end=offsets[i*2+1]; - /* If the group wasn't affected by the match, return -1, -1 */ - if (start<0 || count<=i) - {start=end=-1;} - v=Py_BuildValue("ii", start, end); - if (v==NULL) {Py_DECREF(list); return NULL;} - PyList_SetItem(list, i, v); - } - return list; -} - -static PyMethodDef Pcre_methods[] = { - {"match", (PyCFunction)PyPcre_exec, METH_VARARGS}, - {NULL, NULL} /* sentinel */ -}; - -static PyObject * -PyPcre_getattr(PcreObject *self, char *name) -{ - return Py_FindMethod(Pcre_methods, (PyObject *)self, name); -} - - -static PyTypeObject Pcre_Type = { - PyObject_HEAD_INIT(NULL) - 0, /*ob_size*/ - "pcre.Pcre", /*tp_name*/ - sizeof(PcreObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor)PyPcre_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (getattrfunc)PyPcre_getattr, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ -}; -/* --------------------------------------------------------------------- */ - -static PyObject * -PyPcre_compile(PyObject *self, PyObject *args) -{ - PcreObject *rv; - PyObject *dictionary; - char *pattern; - const char *error; - - int options, erroroffset; - if (!PyArg_ParseTuple(args, "siO!:pcre_compile", &pattern, &options, - &PyDict_Type, &dictionary)) - return NULL; - rv = newPcreObject(args); - if ( rv == NULL ) - return NULL; - - rv->regex = pcre_compile((char*)pattern, options, - &error, &erroroffset, dictionary); - if (rv->regex==NULL) - { - Py_DECREF(rv); - if (!PyErr_Occurred()) - { - PyObject *errval = Py_BuildValue("si", error, erroroffset); - PyErr_SetObject(ErrorObject, errval); - Py_XDECREF(errval); - } - return NULL; - } - rv->regex_extra=pcre_study(rv->regex, 0, &error); - if (rv->regex_extra==NULL && error!=NULL) - { - PyObject *errval = Py_BuildValue("si", error, 0); - Py_DECREF(rv); - PyErr_SetObject(ErrorObject, errval); - Py_XDECREF(errval); - return NULL; - } - rv->num_groups = pcre_info(rv->regex, NULL, NULL); - if (rv->num_groups<0) - { - PyObject *errval = Py_BuildValue("si", error, rv->num_groups); - PyErr_SetObject(ErrorObject, errval); - Py_XDECREF(errval); - Py_DECREF(rv); - return NULL; - } - return (PyObject *)rv; -} - -static PyObject * -PyPcre_expand_escape(unsigned char *pattern, int pattern_len, - int *indexptr, int *typeptr) -{ - unsigned char c; - int index = *indexptr; - - if (pattern_len<=index) - { - PyErr_SetString(ErrorObject, "escape ends too soon"); - return NULL; - } - c=pattern[index]; index++; - *typeptr=CHAR; - - switch (c) - { - case('t'): - *indexptr=index; - return Py_BuildValue("c", (char)9); - case('n'): - *indexptr = index; - return Py_BuildValue("c", (char)10); - case('v'): - *indexptr = index; - return Py_BuildValue("c", (char)11); - case('r'): - *indexptr = index; - return Py_BuildValue("c", (char)13); - case('f'): - *indexptr = index; - return Py_BuildValue("c", (char)12); - case('a'): - *indexptr = index; - return Py_BuildValue("c", (char)7); - case('b'): - *indexptr=index; - return Py_BuildValue("c", (char)8); - case('\\'): - *indexptr=index; - return Py_BuildValue("c", '\\'); - - case('x'): - { - int x, ch, end; - - x = 0; end = index; - while ( (end<pattern_len && pcre_ctypes[ pattern[end] ] & ctype_xdigit) != 0) - { - ch = pattern[end]; - x = x * 16 + pcre_lcc[ch] - - (((pcre_ctypes[ch] & ctype_digit) != 0)? '0' : 'W'); - x &= 255; - end++; - } - if (end==index) - { - PyErr_SetString(ErrorObject, "\\x must be followed by hex digits"); - return NULL; - } - *indexptr = end; - return Py_BuildValue("c", (char)x); - } - - case('E'): case('G'): case('L'): case('Q'): - case('U'): case('l'): case('u'): - { - char message[50]; - PyOS_snprintf(message, sizeof(message), - "\\%c is not allowed", c); - PyErr_SetString(ErrorObject, message); - return NULL; - } - - case('g'): - { - int end, i; - int group_num = 0, is_number=0; - - if (pattern_len<=index) - { - PyErr_SetString(ErrorObject, "unfinished symbolic reference"); - return NULL; - } - if (pattern[index]!='<') - { - PyErr_SetString(ErrorObject, "missing < in symbolic reference"); - return NULL; - } - index++; - end=index; - while (end<pattern_len && pattern[end]!='>') - end++; - if (end==pattern_len) - { - PyErr_SetString(ErrorObject, "unfinished symbolic reference"); - return NULL; - } - - if (index==end) /* Zero-length name */ - { - /* XXX should include the text of the reference */ - PyErr_SetString(ErrorObject, "zero-length symbolic reference"); - return NULL; - } - if ((pcre_ctypes[pattern[index]] & ctype_digit)) /* First char. a digit */ - { - is_number = 1; - group_num = pattern[index] - '0'; - } - - for(i=index+1; i<end; i++) - { - if (is_number && - !(pcre_ctypes[pattern[i]] & ctype_digit) ) - { - /* XXX should include the text of the reference */ - PyErr_SetString(ErrorObject, "illegal non-digit character in \\g<...> starting with digit"); - return NULL; - } - else {group_num = group_num * 10 + pattern[i] - '0';} - if (!(pcre_ctypes[pattern[i]] & ctype_word) ) - { - /* XXX should include the text of the reference */ - PyErr_SetString(ErrorObject, "illegal symbolic reference"); - return NULL; - } - } - - *typeptr = MEMORY_REFERENCE; - *indexptr = end+1; - /* If it's a number, return the integer value of the group */ - if (is_number) return Py_BuildValue("i", group_num); - /* Otherwise, return a string containing the group name */ - return Py_BuildValue("s#", pattern+index, end-index); - } - - case('0'): - { - /* \0 always indicates an octal escape, so we consume up to 3 - characters, as long as they're all octal digits */ - int octval=0, i; - index--; - for(i=index; - i<=index+2 && i<pattern_len - && (pcre_ctypes[ pattern[i] ] & ctype_odigit ); - i++) - { - octval = octval * 8 + pattern[i] - '0'; - } - if (octval>255) - { - PyErr_SetString(ErrorObject, "octal value out of range"); - return NULL; - } - *indexptr = i; - return Py_BuildValue("c", (unsigned char)octval); - } - - case('1'): case('2'): case('3'): case('4'): - case('5'): case('6'): case('7'): case('8'): - case('9'): - { - /* Handle \?, where ? is from 1 through 9 */ - int value=0; - index--; - /* If it's at least a two-digit reference, like \34, it might - either be a 3-digit octal escape (\123) or a 2-digit - decimal memory reference (\34) */ - - if ( (index+1) <pattern_len && - (pcre_ctypes[ pattern[index+1] ] & ctype_digit) ) - { - if ( (index+2) <pattern_len && - (pcre_ctypes[ pattern[index+2] ] & ctype_odigit) && - (pcre_ctypes[ pattern[index+1] ] & ctype_odigit) && - (pcre_ctypes[ pattern[index ] ] & ctype_odigit) - ) - { - /* 3 octal digits */ - value= 8*8*(pattern[index ]-'0') + - 8*(pattern[index+1]-'0') + - (pattern[index+2]-'0'); - if (value>255) - { - PyErr_SetString(ErrorObject, "octal value out of range"); - return NULL; - } - *indexptr = index+3; - return Py_BuildValue("c", (unsigned char)value); - } - else - { - /* 2-digit form, so it's a memory reference */ - value= 10*(pattern[index ]-'0') + - (pattern[index+1]-'0'); - if (value<1 || EXTRACT_MAX<=value) - { - PyErr_SetString(ErrorObject, "memory reference out of range"); - return NULL; - } - *typeptr = MEMORY_REFERENCE; - *indexptr = index+2; - return Py_BuildValue("i", value); - } - } - else - { - /* Single-digit form, like \2, so it's a memory reference */ - *typeptr = MEMORY_REFERENCE; - *indexptr = index+1; - return Py_BuildValue("i", pattern[index]-'0'); - } - } - - default: - /* It's some unknown escape like \s, so return a string containing - \s */ - *typeptr = STRING; - *indexptr = index; - return Py_BuildValue("s#", pattern+index-2, 2); - } -} - -static PyObject * -PyPcre_expand(PyObject *self, PyObject *args) -{ - PyObject *results, *match_obj; - PyObject *repl_obj, *newstring; - unsigned char *repl; - int size, total_len, i, start, pos; - - if (!PyArg_ParseTuple(args, "OS:pcre_expand", &match_obj, &repl_obj)) - return NULL; - - repl=(unsigned char *)PyString_AsString(repl_obj); - size=PyString_Size(repl_obj); - results=PyList_New(0); - if (results==NULL) return NULL; - for(start=total_len=i=0; i<size; i++) - { - if (repl[i]=='\\') - { - PyObject *value; - int escape_type; - - if (start!=i) - { - int status; - PyObject *s = PyString_FromStringAndSize( - (char *)repl+start, i-start); - if (s == NULL) { - Py_DECREF(results); - return NULL; - } - status = PyList_Append(results, s); - Py_DECREF(s); - if (status < 0) { - Py_DECREF(results); - return NULL; - } - total_len += i-start; - } - i++; - value=PyPcre_expand_escape(repl, size, &i, &escape_type); - if (value==NULL) - { - /* PyPcre_expand_escape triggered an exception of some sort, - so just return */ - Py_DECREF(results); - return NULL; - } - switch (escape_type) - { - case (CHAR): - PyList_Append(results, value); - total_len += PyString_Size(value); - break; - case(MEMORY_REFERENCE): - { - PyObject *r, *tuple, *result; - r=PyObject_GetAttrString(match_obj, "group"); - if (r == NULL) { - Py_DECREF(results); - return NULL; - } - tuple=PyTuple_New(1); - Py_INCREF(value); - PyTuple_SetItem(tuple, 0, value); - result=PyEval_CallObject(r, tuple); - Py_DECREF(r); Py_DECREF(tuple); - if (result==NULL) - { - /* The group() method triggered an exception of some sort */ - Py_DECREF(results); - Py_DECREF(value); - return NULL; - } - if (result==Py_None) - { - char message[50]; - PyOS_snprintf(message, sizeof(message), - "group did not contribute to the match"); - PyErr_SetString(ErrorObject, - message); - Py_DECREF(result); - Py_DECREF(value); - Py_DECREF(results); - return NULL; - } - /* typecheck that it's a string! */ - if (!PyString_Check(result)) - { - Py_DECREF(results); - Py_DECREF(result); - PyErr_SetString(ErrorObject, - "group() must return a string value for replacement"); - return NULL; - } - PyList_Append(results, result); - total_len += PyString_Size(result); - Py_DECREF(result); - } - break; - case(STRING): - { - PyList_Append(results, value); - total_len += PyString_Size(value); - break; - } - default: - Py_DECREF(results); - PyErr_SetString(ErrorObject, - "bad escape in replacement"); - return NULL; - } - Py_DECREF(value); - start=i; - i--; /* Decrement now, because the 'for' loop will increment it */ - } - } /* endif repl[i]!='\\' */ - - if (start!=i) - { - int status; - PyObject *s = PyString_FromStringAndSize((char *)repl+start, - i-start); - if (s == NULL) { - Py_DECREF(results); - return NULL; - } - status = PyList_Append(results, s); - Py_DECREF(s); - if (status < 0) { - Py_DECREF(results); - return NULL; - } - total_len += i-start; - } - - /* Whew! Now we've constructed a list containing various pieces of - strings that will make up our final result. So, iterate over - the list concatenating them. A new string measuring total_len - bytes is allocated and filled in. */ - - newstring=PyString_FromStringAndSize(NULL, total_len); - if (newstring==NULL) - { - Py_DECREF(results); - return NULL; - } - - repl=(unsigned char *)PyString_AsString(newstring); - for (pos=i=0; i<PyList_Size(results); i++) - { - PyObject *item=PyList_GetItem(results, i); - memcpy(repl+pos, PyString_AsString(item), PyString_Size(item) ); - pos += PyString_Size(item); - } - Py_DECREF(results); - return newstring; -} - - -/* List of functions defined in the module */ - -static PyMethodDef pcre_methods[] = { - {"pcre_compile", PyPcre_compile, METH_VARARGS}, - {"pcre_expand", PyPcre_expand, METH_VARARGS}, - {NULL, NULL} /* sentinel */ -}; - - -/* - * Convenience routine to export an integer value. - * For simplicity, errors (which are unlikely anyway) are ignored. - */ - -static void -insint(PyObject *d, char *name, int value) -{ - PyObject *v = PyInt_FromLong((long) value); - if (v == NULL) { - /* Don't bother reporting this error */ - PyErr_Clear(); - } - else { - PyDict_SetItemString(d, name, v); - Py_DECREF(v); - } -} - - -/* Initialization function for the module (*must* be called initpcre) */ - -PyMODINIT_FUNC -initpcre(void) -{ - PyObject *m, *d; - - Pcre_Type.ob_type = &PyType_Type; - - /* Create the module and add the functions */ - m = Py_InitModule("pcre", pcre_methods); - - /* Add some symbolic constants to the module */ - d = PyModule_GetDict(m); - ErrorObject = PyErr_NewException("pcre.error", NULL, NULL); - PyDict_SetItemString(d, "error", ErrorObject); - - /* Insert the flags */ - insint(d, "IGNORECASE", PCRE_CASELESS); - insint(d, "ANCHORED", PCRE_ANCHORED); - insint(d, "MULTILINE", PCRE_MULTILINE); - insint(d, "DOTALL", PCRE_DOTALL); - insint(d, "VERBOSE", PCRE_EXTENDED); - insint(d, "LOCALE", PCRE_LOCALE); -} - diff --git a/Modules/pypcre.c b/Modules/pypcre.c deleted file mode 100644 index 6c93326..0000000 --- a/Modules/pypcre.c +++ /dev/null @@ -1,4756 +0,0 @@ - -/************************************************* -* Perl-Compatible Regular Expressions * -*************************************************/ - -/* DO NOT EDIT THIS FILE! */ - -/* This file is automatically written by the merge-files.py script -included with the PCRE distribution for Python; it's produced from -several C files, and code is removed in the process. If you want to -modify the code or track down bugs, it will be much easier to work -with the code in its original, multiple-file form. Don't edit this -file by hand, or submit patches to it. - -The Python-specific PCRE distribution can be retrieved from - http://starship.skyport.net/crew/amk/regex/ - -The unmodified original PCRE distribution is available at -ftp://ftp.cus.cam.ac.uk/pub/software/programs/pcre/, and is originally -written by: Philip Hazel <ph10@cam.ac.uk> - -Extensively modified by the Python String-SIG: <string-sig@python.org> -Send bug reports to: <string-sig@python.org> -(They'll figure out if it's a bug in PCRE or in the Python-specific -changes.) - - Copyright (c) 1997 University of Cambridge - ------------------------------------------------------------------------------ -Permission is granted to anyone to use this software for any purpose on any -computer system, and to redistribute it freely, subject to the following -restrictions: - -1. This software is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - -2. The origin of this software must not be misrepresented, either by - explicit claim or by omission. - -3. Altered versions must be plainly marked as such, and must not be - misrepresented as being the original software. ------------------------------------------------------------------------------ -*/ - - -#define FOR_PYTHON -#include "Python.h" -#include "pcre-int.h" -#include <ctype.h> -#include "graminit.h" - -/************************************************* -* Perl-Compatible Regular Expressions * -*************************************************/ - -/* This file is automatically written by the makechartables auxiliary -program. If you edit it by hand, you might like to edit the Makefile to -prevent its ever being regenerated. */ - -/* This table is a lower casing table. */ - -unsigned char pcre_lcc[] = { - 0, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, - 64, 97, 98, 99,100,101,102,103, - 104,105,106,107,108,109,110,111, - 112,113,114,115,116,117,118,119, - 120,121,122, 91, 92, 93, 94, 95, - 96, 97, 98, 99,100,101,102,103, - 104,105,106,107,108,109,110,111, - 112,113,114,115,116,117,118,119, - 120,121,122,123,124,125,126,127, - 128,129,130,131,132,133,134,135, - 136,137,138,139,140,141,142,143, - 144,145,146,147,148,149,150,151, - 152,153,154,155,156,157,158,159, - 160,161,162,163,164,165,166,167, - 168,169,170,171,172,173,174,175, - 176,177,178,179,180,181,182,183, - 184,185,186,187,188,189,190,191, - 192,193,194,195,196,197,198,199, - 200,201,202,203,204,205,206,207, - 208,209,210,211,212,213,214,215, - 216,217,218,219,220,221,222,223, - 224,225,226,227,228,229,230,231, - 232,233,234,235,236,237,238,239, - 240,241,242,243,244,245,246,247, - 248,249,250,251,252,253,254,255 }; - -/* This table is a case flipping table. */ - -unsigned char pcre_fcc[] = { - 0, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, - 64, 97, 98, 99,100,101,102,103, - 104,105,106,107,108,109,110,111, - 112,113,114,115,116,117,118,119, - 120,121,122, 91, 92, 93, 94, 95, - 96, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90,123,124,125,126,127, - 128,129,130,131,132,133,134,135, - 136,137,138,139,140,141,142,143, - 144,145,146,147,148,149,150,151, - 152,153,154,155,156,157,158,159, - 160,161,162,163,164,165,166,167, - 168,169,170,171,172,173,174,175, - 176,177,178,179,180,181,182,183, - 184,185,186,187,188,189,190,191, - 192,193,194,195,196,197,198,199, - 200,201,202,203,204,205,206,207, - 208,209,210,211,212,213,214,215, - 216,217,218,219,220,221,222,223, - 224,225,226,227,228,229,230,231, - 232,233,234,235,236,237,238,239, - 240,241,242,243,244,245,246,247, - 248,249,250,251,252,253,254,255 }; - -/* This table contains bit maps for digits, letters, 'word' chars, and -white space. Each map is 32 bytes long and the bits run from the least -significant end of each byte. */ - -unsigned char pcre_cbits[] = { - 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0xfe,0xff,0xff,0x07,0xfe,0xff,0xff,0x07, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - - 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, - 0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - - 0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }; - -/* This table identifies various classes of character by individual bits: - 0x01 white space character - 0x02 letter - 0x04 decimal digit - 0x08 hexadecimal digit - 0x10 alphanumeric or '_' - 0x80 regular expression metacharacter or binary zero -*/ - -unsigned char pcre_ctypes[] = { - 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */ - 0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /* 8- 15 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */ - 0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /* - ' */ - 0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /* ( - / */ - 0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c, /* 0 - 7 */ - 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /* 8 - ? */ - 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* @ - G */ - 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* H - O */ - 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* P - W */ - 0x12,0x12,0x12,0x80,0x00,0x00,0x80,0x10, /* X - _ */ - 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* ` - g */ - 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* h - o */ - 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* p - w */ - 0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /* x -127 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */ - -/* End of chartables.c */ -/************************************************* -* Perl-Compatible Regular Expressions * -*************************************************/ - -/* -This is a library of functions to support regular expressions whose syntax -and semantics are as close as possible to those of the Perl 5 language. See -the file Tech.Notes for some information on the internals. - -Written by: Philip Hazel <ph10@cam.ac.uk> - - Copyright (c) 1998 University of Cambridge - ------------------------------------------------------------------------------ -Permission is granted to anyone to use this software for any purpose on any -computer system, and to redistribute it freely, subject to the following -restrictions: - -1. This software is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - -2. The origin of this software must not be misrepresented, either by - explicit claim or by omission. - -3. Altered versions must be plainly marked as such, and must not be - misrepresented as being the original software. ------------------------------------------------------------------------------ -*/ - - -/* Include the internals header, which itself includes Standard C headers plus -the external pcre header. */ - - - - -/************************************************* -* Create bitmap of starting chars * -*************************************************/ - -/* This function scans a compiled unanchored expression and attempts to build a -bitmap of the set of initial characters. If it can't, it returns FALSE. As time -goes by, we may be able to get more clever at doing this. - -Arguments: - code points to an expression - start_bits points to a 32-byte table, initialized to 0 - -Returns: TRUE if table built, FALSE otherwise -*/ - -static BOOL -set_start_bits(const uschar *code, uschar *start_bits) -{ -register int c; -volatile int dummy; - -do - { - const uschar *tcode = code + 3; - BOOL try_next = TRUE; - - while (try_next) - { - try_next = FALSE; - - if ((int)*tcode >= OP_BRA || *tcode == OP_ASSERT) - { - if (!set_start_bits(tcode, start_bits)) return FALSE; - } - - else switch(*tcode) - { - default: - return FALSE; - - /* BRAZERO does the bracket, but carries on. */ - - case OP_BRAZERO: - case OP_BRAMINZERO: - if (!set_start_bits(++tcode, start_bits)) return FALSE; - dummy = 1; - do tcode += (tcode[1] << 8) + tcode[2]; while (*tcode == OP_ALT); - tcode += 3; - try_next = TRUE; - break; - - /* Single-char * or ? sets the bit and tries the next item */ - - case OP_STAR: - case OP_MINSTAR: - case OP_QUERY: - case OP_MINQUERY: - start_bits[tcode[1]/8] |= (1 << (tcode[1]&7)); - tcode += 2; - try_next = TRUE; - break; - - /* Single-char upto sets the bit and tries the next */ - - case OP_UPTO: - case OP_MINUPTO: - start_bits[tcode[3]/8] |= (1 << (tcode[3]&7)); - tcode += 4; - try_next = TRUE; - break; - - /* At least one single char sets the bit and stops */ - - case OP_EXACT: /* Fall through */ - tcode++; - - case OP_CHARS: /* Fall through */ - tcode++; - - case OP_PLUS: - case OP_MINPLUS: - start_bits[tcode[1]/8] |= (1 << (tcode[1]&7)); - break; - - /* Single character type sets the bits and stops */ - - case OP_NOT_DIGIT: - for (c = 0; c < 32; c++) start_bits[c] |= ~pcre_cbits[c+cbit_digit]; - break; - - case OP_DIGIT: - for (c = 0; c < 32; c++) start_bits[c] |= pcre_cbits[c+cbit_digit]; - break; - - case OP_NOT_WHITESPACE: - for (c = 0; c < 32; c++) start_bits[c] |= ~pcre_cbits[c+cbit_space]; - break; - - case OP_WHITESPACE: - for (c = 0; c < 32; c++) start_bits[c] |= pcre_cbits[c+cbit_space]; - break; - - case OP_NOT_WORDCHAR: - for (c = 0; c < 32; c++) - start_bits[c] |= ~(pcre_cbits[c] | pcre_cbits[c+cbit_word]); - break; - - case OP_WORDCHAR: - for (c = 0; c < 32; c++) - start_bits[c] |= (pcre_cbits[c] | pcre_cbits[c+cbit_word]); - break; - - /* One or more character type fudges the pointer and restarts, knowing - it will hit a single character type and stop there. */ - - case OP_TYPEPLUS: - case OP_TYPEMINPLUS: - tcode++; - try_next = TRUE; - break; - - case OP_TYPEEXACT: - tcode += 3; - try_next = TRUE; - break; - - /* Zero or more repeats of character types set the bits and then - try again. */ - - case OP_TYPEUPTO: - case OP_TYPEMINUPTO: - tcode += 2; /* Fall through */ - - case OP_TYPESTAR: - case OP_TYPEMINSTAR: - case OP_TYPEQUERY: - case OP_TYPEMINQUERY: - switch(tcode[1]) - { - case OP_NOT_DIGIT: - for (c = 0; c < 32; c++) start_bits[c] |= ~pcre_cbits[c+cbit_digit]; - break; - - case OP_DIGIT: - for (c = 0; c < 32; c++) start_bits[c] |= pcre_cbits[c+cbit_digit]; - break; - - case OP_NOT_WHITESPACE: - for (c = 0; c < 32; c++) start_bits[c] |= ~pcre_cbits[c+cbit_space]; - break; - - case OP_WHITESPACE: - for (c = 0; c < 32; c++) start_bits[c] |= pcre_cbits[c+cbit_space]; - break; - - case OP_NOT_WORDCHAR: - for (c = 0; c < 32; c++) - start_bits[c] |= ~(pcre_cbits[c] | pcre_cbits[c+cbit_word]); - break; - - case OP_WORDCHAR: - for (c = 0; c < 32; c++) - start_bits[c] |= (pcre_cbits[c] | pcre_cbits[c+cbit_word]); - break; - } - - tcode += 2; - try_next = TRUE; - break; - - /* Character class: set the bits and either carry on or not, - according to the repeat count. */ - - case OP_CLASS: - case OP_NEGCLASS: - { - tcode++; - for (c = 0; c < 32; c++) start_bits[c] |= tcode[c]; - tcode += 32; - switch (*tcode) - { - case OP_CRSTAR: - case OP_CRMINSTAR: - case OP_CRQUERY: - case OP_CRMINQUERY: - tcode++; - try_next = TRUE; - break; - - case OP_CRRANGE: - case OP_CRMINRANGE: - if (((tcode[1] << 8) + tcode[2]) == 0) - { - tcode += 5; - try_next = TRUE; - } - break; - } - } - break; /* End of class handling */ - - } /* End of switch */ - } /* End of try_next loop */ - - code += (code[1] << 8) + code[2]; /* Advance to next branch */ - } -while (*code == OP_ALT); -return TRUE; -} - - - -/************************************************* -* Study a compiled expression * -*************************************************/ - -/* This function is handed a compiled expression that it must study to produce -information that will speed up the matching. It returns a pcre_extra block -which then gets handed back to pcre_exec(). - -Arguments: - re points to the compiled expression - options contains option bits - errorptr points to where to place error messages; - set NULL unless error - -Returns: pointer to a pcre_extra block, - NULL on error or if no optimization possible -*/ - -pcre_extra * -pcre_study(const pcre *external_re, int options, const char **errorptr) -{ -BOOL caseless; -uschar start_bits[32]; -real_pcre_extra *extra; -const real_pcre *re = (const real_pcre *)external_re; - -*errorptr = NULL; - -if (re == NULL || re->magic_number != MAGIC_NUMBER) - { - *errorptr = "argument is not a compiled regular expression"; - return NULL; - } - -if ((options & ~PUBLIC_STUDY_OPTIONS) != 0) - { - *errorptr = "unknown or incorrect option bit(s) set"; - return NULL; - } - -/* Caseless can either be from the compiled regex or from options. */ - -caseless = ((re->options | options) & PCRE_CASELESS) != 0; - -/* For an anchored pattern, or an unanchored pattern that has a first char, or a -multiline pattern that matches only at "line starts", no further processing at -present. */ - -if ((re->options & (PCRE_ANCHORED|PCRE_FIRSTSET|PCRE_STARTLINE)) != 0) - return NULL; - -/* See if we can find a fixed set of initial characters for the pattern. */ - -memset(start_bits, 0, 32 * sizeof(uschar)); -if (!set_start_bits(re->code, start_bits)) return NULL; - -/* If this studying is caseless, scan the created bit map and duplicate the -bits for any letters. */ - -if (caseless) - { - register int c; - for (c = 0; c < 256; c++) - { - if ((start_bits[c/8] & (1 << (c&7))) != 0 && - (pcre_ctypes[c] & ctype_letter) != 0) - { - int d = pcre_fcc[c]; - start_bits[d/8] |= (1 << (d&7)); - } - } - } - -/* Get an "extra" block and put the information therein. */ - -extra = (real_pcre_extra *)(pcre_malloc)(sizeof(real_pcre_extra)); - -if (extra == NULL) - { - *errorptr = "failed to get memory"; - return NULL; - } - -extra->options = PCRE_STUDY_MAPPED | (caseless? PCRE_STUDY_CASELESS : 0); -memcpy(extra->start_bits, start_bits, sizeof(start_bits)); - -return (pcre_extra *)extra; -} - -/* End of study.c */ -/************************************************* -* Perl-Compatible Regular Expressions * -*************************************************/ - -/* -This is a library of functions to support regular expressions whose syntax -and semantics are as close as possible to those of the Perl 5 language. See -the file Tech.Notes for some information on the internals. - -Written by: Philip Hazel <ph10@cam.ac.uk> - - Copyright (c) 1998 University of Cambridge - ------------------------------------------------------------------------------ -Permission is granted to anyone to use this software for any purpose on any -computer system, and to redistribute it freely, subject to the following -restrictions: - -1. This software is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - -2. The origin of this software must not be misrepresented, either by - explicit claim or by omission. - -3. Altered versions must be plainly marked as such, and must not be - misrepresented as being the original software. ------------------------------------------------------------------------------ -*/ - - -/* Define DEBUG to get debugging output on stdout. */ - -/* #define DEBUG */ - -/* Use a macro for debugging printing, 'cause that eliminates the use -of #ifdef inline, and there are *still* stupid compilers about that don't like -indented pre-processor statements. I suppose it's only been 10 years... */ - -#undef DPRINTF -#ifdef DEBUG -#define DPRINTF(p) printf p -#else -#define DPRINTF(p) /*nothing*/ -#endif - -/* Include the internals header, which itself includes Standard C headers plus -the external pcre header. */ - - - - -#ifndef Py_eval_input -/* For Python 1.4, graminit.h has to be explicitly included */ -#define Py_eval_input eval_input - -#endif /* FOR_PYTHON */ - -/* Allow compilation as C++ source code, should anybody want to do that. */ - -#ifdef __cplusplus -#define class pcre_class -#endif - - -/* Min and max values for the common repeats; for the maxima, 0 => infinity */ - -static const char rep_min[] = { 0, 0, 1, 1, 0, 0 }; -static const char rep_max[] = { 0, 0, 0, 0, 1, 1 }; - -/* Text forms of OP_ values and things, for debugging (not all used) */ - -#ifdef DEBUG -static const char *OP_names[] = { - "End", "\\A", "\\B", "\\b", "\\D", "\\d", - "\\S", "\\s", "\\W", "\\w", "Cut", "\\Z", - "localized \\B", "localized \\b", "localized \\W", "localized \\w", - "^", "$", "Any", "chars", - "not", - "*", "*?", "+", "+?", "?", "??", "{", "{", "{", - "*", "*?", "+", "+?", "?", "??", "{", "{", "{", - "*", "*?", "+", "+?", "?", "??", "{", "{", "{", - "*", "*?", "+", "+?", "?", "??", "{", "{", - "class", "negclass", "classL", "Ref", - "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not", "Once", - "Brazero", "Braminzero", "Bra" -}; -#endif - -/* Table for handling escaped characters in the range '0'-'z'. Positive returns -are simple data values; negative values are for special things like \d and so -on. Zero means further processing is needed (for things like \x), or the escape -is invalid. */ - -static const short int escapes[] = { - 0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 7 */ - 0, 0, ':', ';', '<', '=', '>', '?', /* 8 - ? */ - '@', -ESC_A, -ESC_B, 0, -ESC_D, 0, 0, 0, /* @ - G */ - 0, 0, 0, 0, 0, 0, 0, 0, /* H - O */ - 0, 0, 0, -ESC_S, 0, 0, 0, -ESC_W, /* P - W */ - 0, 0, -ESC_Z, '[', '\\', ']', '^', '_', /* X - _ */ - '`', 7, -ESC_b, 0, -ESC_d, 0, '\f', 0, /* ` - g */ - 0, 0, 0, 0, 0, 0, '\n', 0, /* h - o */ - 0, 0, '\r', -ESC_s, '\t', 0, '\v', -ESC_w, /* p - w */ - 0, 0, 0 /* x - z */ -}; - -/* Definition to allow mutual recursion */ - -static BOOL -compile_regex(int, int *, uschar **, const uschar **, const char **, - PyObject *); - -/* Structure for passing "static" information around between the functions -doing the matching, so that they are thread-safe. */ - -typedef struct match_data { - int errorcode; /* As it says */ - int *offset_vector; /* Offset vector */ - int offset_end; /* One past the end */ - BOOL offset_overflow; /* Set if too many extractions */ - BOOL caseless; /* Case-independent flag */ - BOOL runtime_caseless; /* Caseless forced at run time */ - BOOL multiline; /* Multiline flag */ - BOOL notbol; /* NOTBOL flag */ - BOOL noteol; /* NOTEOL flag */ - BOOL dotall; /* Dot matches any char */ - BOOL endonly; /* Dollar not before final \n */ - const uschar *start_subject; /* Start of the subject string */ - const uschar *end_subject; /* End of the subject string */ - jmp_buf fail_env; /* Environment for longjump() break out */ - const uschar *end_match_ptr; /* Subject position at end match */ - int end_offset_top; /* Highwater mark at end of match */ - jmp_buf error_env; /* For longjmp() if an error occurs deep inside a - matching operation */ - int length; /* Length of the allocated stacks */ - int point; /* Point to add next item pushed onto stacks */ - /* Pointers to the 6 stacks */ - int *off_num, *offset_top, *r1, *r2; - const uschar **eptr, **ecode; -} match_data; - - - -/************************************************* -* Global variables * -*************************************************/ - -/* PCRE is thread-clean and doesn't use any global variables in the normal -sense. However, it calls memory allocation and free functions via the two -indirections below, which are can be changed by the caller, but are shared -between all threads. */ - -void *(*pcre_malloc)(size_t) = malloc; -void (*pcre_free)(void *) = free; - - - - -/************************************************* -* Return version string * -*************************************************/ - -const char * -pcre_version(void) -{ -return PCRE_VERSION; -} - - - - -/************************************************* -* Return info about a compiled pattern * -*************************************************/ - -/* This function picks potentially useful data out of the private -structure. - -Arguments: - external_re points to compiled code - optptr where to pass back the options - first_char where to pass back the first character, - or -1 if multiline and all branches start ^, - or -2 otherwise - -Returns: number of identifying extraction brackets - or negative values on error -*/ - -int -pcre_info(const pcre *external_re, int *optptr, int *first_char) -{ -const real_pcre *re = (real_pcre *)external_re; -if (re == NULL) return PCRE_ERROR_NULL; -if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC; -if (optptr != NULL) *optptr = (re->options & PUBLIC_OPTIONS); -if (first_char != NULL) - *first_char = ((re->options & PCRE_FIRSTSET) != 0)? re->first_char : - ((re->options & PCRE_STARTLINE) != 0)? -1 : -2; -return re->top_bracket; -} - - - - -#ifdef DEBUG -/************************************************* -* Debugging function to print chars * -*************************************************/ - -/* Print a sequence of chars in printable format, stopping at the end of the -subject if the requested. - -Arguments: - p points to characters - length number to print - is_subject TRUE if printing from within md->start_subject - md pointer to matching data block, if is_subject is TRUE - -Returns: nothing -*/ - -static void -pchars(const uschar *p, int length, BOOL is_subject, match_data *md) -{ -int c; -if (is_subject && length > md->end_subject - p) length = md->end_subject - p; -while (length-- > 0) - if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c); -} -#endif - - - - -/************************************************* -* Check subpattern for empty operand * -*************************************************/ - -/* This function checks a bracketed subpattern to see if any of the paths -through it could match an empty string. This is used to diagnose an error if -such a subpattern is followed by a quantifier with an unlimited upper bound. - -Argument: - code points to the opening bracket - -Returns: TRUE or FALSE -*/ - -static BOOL -could_be_empty(uschar *code) -{ -do { - uschar *cc = code + 3; - - /* Scan along the opcodes for this branch; as soon as we find something - that matches a non-empty string, break out and advance to test the next - branch. If we get to the end of the branch, return TRUE for the whole - sub-expression. */ - - for (;;) - { - /* Test an embedded subpattern; if it could not be empty, break the - loop. Otherwise carry on in the branch. */ - - if ((int)(*cc) >= OP_BRA || (int)(*cc) == OP_ONCE) - { - if (!could_be_empty(cc)) break; - do cc += (cc[1] << 8) + cc[2]; while (*cc == OP_ALT); - cc += 3; - } - - else switch (*cc) - { - /* Reached end of a branch: the subpattern may match the empty string */ - - case OP_ALT: - case OP_KET: - case OP_KETRMAX: - case OP_KETRMIN: - return TRUE; - - /* Skip over entire bracket groups with zero lower bound */ - - case OP_BRAZERO: - case OP_BRAMINZERO: - cc++; - /* Fall through */ - - /* Skip over assertive subpatterns */ - - case OP_ASSERT: - case OP_ASSERT_NOT: - do cc += (cc[1] << 8) + cc[2]; while (*cc == OP_ALT); - cc += 3; - break; - - /* Skip over things that don't match chars */ - - case OP_SOD: - case OP_EOD: - case OP_CIRC: - case OP_DOLL: - case OP_NOT_WORD_BOUNDARY: - case OP_WORD_BOUNDARY: - case OP_NOT_WORD_BOUNDARY_L: - case OP_WORD_BOUNDARY_L: - cc++; - break; - - /* Skip over simple repeats with zero lower bound */ - - case OP_STAR: - case OP_MINSTAR: - case OP_QUERY: - case OP_MINQUERY: - case OP_NOTSTAR: - case OP_NOTMINSTAR: - case OP_NOTQUERY: - case OP_NOTMINQUERY: - case OP_TYPESTAR: - case OP_TYPEMINSTAR: - case OP_TYPEQUERY: - case OP_TYPEMINQUERY: - cc += 2; - break; - - /* Skip over UPTOs (lower bound is zero) */ - - case OP_UPTO: - case OP_MINUPTO: - case OP_TYPEUPTO: - case OP_TYPEMINUPTO: - cc += 4; - break; - - /* Check a class or a back reference for a zero minimum */ - - case OP_CLASS: - case OP_NEGCLASS: - case OP_REF: - case OP_CLASS_L: - switch(*cc) - { - case (OP_REF): cc += 2; break; - case (OP_CLASS): case (OP_NEGCLASS): cc += 1+32; break; - case (OP_CLASS_L): cc += 1+1+32; break; - } - - switch (*cc) - { - case OP_CRSTAR: - case OP_CRMINSTAR: - case OP_CRQUERY: - case OP_CRMINQUERY: - cc++; - break; - - case OP_CRRANGE: - case OP_CRMINRANGE: - if ((cc[1] << 8) + cc[2] != 0) goto NEXT_BRANCH; - cc += 3; - break; - - default: - goto NEXT_BRANCH; - } - break; - - /* Anything else matches at least one character */ - - default: - goto NEXT_BRANCH; - } - } - - NEXT_BRANCH: - code += (code[1] << 8) + code[2]; - } -while (*code == OP_ALT); - -/* No branches match the empty string */ - -return FALSE; -} - -/* Determine the length of a group ID in an expression like - (?P<foo_123>...) -Arguments: - ptr pattern position pointer (say that 3 times fast) - finalchar the character that will mark the end of the ID - errorptr points to the pointer to the error message -*/ - -static int -get_group_id(const uschar *ptr, char finalchar, const char **errorptr) -{ - const uschar *start = ptr; - - /* If the first character is not in \w, or is in \w but is a digit, - report an error */ - if (!(pcre_ctypes[*ptr] & ctype_word) || - (pcre_ctypes[*ptr++] & ctype_digit)) - { - *errorptr = "(?P identifier must start with a letter or underscore"; - return 0; - } - - /* Increment ptr until we either hit a null byte, the desired - final character, or a non-word character */ - for(; (*ptr != 0) && (*ptr != finalchar) && - (pcre_ctypes[*ptr] & ctype_word); ptr++) - { - /* Empty loop body */ - } - if (*ptr==finalchar) - return ptr-start; - if (*ptr==0) - { - *errorptr = "unterminated (?P identifier"; - return 0; - } - *errorptr = "illegal character in (?P identifier"; - return 0; -} - -/************************************************* -* Handle escapes * -*************************************************/ - -/* This function is called when a \ has been encountered. It either returns a -positive value for a simple escape such as \n, or a negative value which -encodes one of the more complicated things such as \d. On entry, ptr is -pointing at the \. On exit, it is on the final character of the escape -sequence. - -Arguments: - ptrptr points to the pattern position pointer - errorptr points to the pointer to the error message - bracount number of previous extracting brackets - options the options bits - isclass TRUE if inside a character class - -Returns: zero or positive => a data character - negative => a special escape sequence - on error, errorptr is set -*/ - -static int -check_escape(const uschar **ptrptr, const char **errorptr, int bracount, - int options, BOOL isclass) -{ -const uschar *ptr = *ptrptr; -int c = *(++ptr) & 255; /* Ensure > 0 on signed-char systems */ -int i; - -if (c == 0) *errorptr = ERR1; - -/* Digits or letters may have special meaning; all others are literals. */ - -else if (c < '0' || c > 'z') {} - -/* Do an initial lookup in a table. A non-zero result is something that can be -returned immediately. Otherwise further processing may be required. */ - -else if ((i = escapes[c - '0']) != 0) c = i; - -/* Escapes that need further processing, or are illegal. */ - -else - { - - switch (c) - { - /* The handling of escape sequences consisting of a string of digits - starting with one that is not zero is not straightforward. By experiment, - the way Perl works seems to be as follows: - - Outside a character class, the digits are read as a decimal number. If the - number is less than 10, or if there are that many previous extracting - left brackets, then it is a back reference. Otherwise, up to three octal - digits are read to form an escaped byte. Thus \123 is likely to be octal - 123 (cf \0123, which is octal 012 followed by the literal 3). If the octal - value is greater than 377, the least significant 8 bits are taken. Inside a - character class, \ followed by a digit is always an octal number. */ - - case '1': case '2': case '3': case '4': case '5': - case '6': case '7': case '8': case '9': - - { - /* PYTHON: Try to compute an octal value for a character */ - for(c=0, i=0; ptr[i]!=0 && i<3; i++) - { - if (( pcre_ctypes[ ptr[i] ] & ctype_odigit) != 0) - c = (c * 8 + ptr[i]-'0') & 255; - else - break; /* Non-octal character--break out of the loop */ - } - /* It's a character if there were exactly 3 octal digits, or if - we're inside a character class and there was at least one - octal digit. */ - if ( (i == 3) || (isclass && i!=0) ) - { - ptr += i-1; - break; - } - c = ptr[0]; /* Restore the first character after the \ */ - c -= '0'; i = 1; - while (i<2 && (pcre_ctypes[ptr[1]] & ctype_digit) != 0) - { - c = c * 10 + ptr[1] - '0'; - ptr++; i++; - } - if (c > 255 - ESC_REF) *errorptr = "back reference too big"; - c = -(ESC_REF + c); - } - break; - - /* \0 always starts an octal number, but we may drop through to here with a - larger first octal digit */ - - case '0': - c -= '0'; - while(i++ < 2 && (pcre_ctypes[ptr[1]] & ctype_digit) != 0 && - ptr[1] != '8' && ptr[1] != '9') - c = (c * 8 + *(++ptr) - '0') & 255; - break; - - /* Special escapes not starting with a digit are straightforward */ - - case 'x': - c = 0; - while ( (pcre_ctypes[ptr[1]] & ctype_xdigit) != 0) - { - ptr++; - c = c * 16 + pcre_lcc[*ptr] - - (((pcre_ctypes[*ptr] & ctype_digit) != 0)? '0' : 'W'); - c &= 255; - } - break; - - - /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any - other alphameric following \ is an error if PCRE_EXTRA was set; otherwise, - for Perl compatibility, it is a literal. */ - - default: - if ((options & PCRE_EXTRA) != 0) switch(c) - { - case 'X': - c = -ESC_X; /* This could be a lookup if it ever got into Perl */ - break; - - default: - *errorptr = ERR3; - break; - } - break; - } - } - -*ptrptr = ptr; -return c; -} - - - -/************************************************* -* Check for counted repeat * -*************************************************/ - -/* This function is called when a '{' is encountered in a place where it might -start a quantifier. It looks ahead to see if it really is a quantifier or not. -It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd} -where the ddds are digits. - -Arguments: - p pointer to the first char after '{' - -Returns: TRUE or FALSE -*/ - -static BOOL -is_counted_repeat(const uschar *p) -{ -if ((pcre_ctypes[*p++] & ctype_digit) == 0) return FALSE; -while ((pcre_ctypes[*p] & ctype_digit) != 0) p++; -if (*p == '}') return TRUE; - -if (*p++ != ',') return FALSE; -if (*p == '}') return TRUE; - -if ((pcre_ctypes[*p++] & ctype_digit) == 0) return FALSE; -while ((pcre_ctypes[*p] & ctype_digit) != 0) p++; -return (*p == '}'); -} - - - -/************************************************* -* Read repeat counts * -*************************************************/ - -/* Read an item of the form {n,m} and return the values. This is called only -after is_counted_repeat() has confirmed that a repeat-count quantifier exists, -so the syntax is guaranteed to be correct, but we need to check the values. - -Arguments: - p pointer to first char after '{' - minp pointer to int for min - maxp pointer to int for max - returned as -1 if no max - errorptr points to pointer to error message - -Returns: pointer to '}' on success; - current ptr on error, with errorptr set -*/ - -static const uschar * -read_repeat_counts(const uschar *p, int *minp, int *maxp, const char **errorptr) -{ -int min = 0; -int max = -1; - -while ((pcre_ctypes[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0'; - -if (*p == '}') max = min; else - { - if (*(++p) != '}') - { - max = 0; - while((pcre_ctypes[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0'; - if (max < min) - { - *errorptr = ERR4; - return p; - } - } - } - -/* Do paranoid checks, then fill in the required variables, and pass back the -pointer to the terminating '}'. */ - -if (min > 65535 || max > 65535) - *errorptr = ERR5; -else - { - *minp = min; - *maxp = max; - } -return p; -} - - - -/************************************************* -* Compile one branch * -*************************************************/ - -/* Scan the pattern, compiling it into the code vector. - -Arguments: - options the option bits - bracket points to number of brackets used - code points to the pointer to the current code point - ptrptr points to the current pattern pointer - errorptr points to pointer to error message - -Returns: TRUE on success - FALSE, with *errorptr set on error -*/ - -static BOOL -compile_branch(int options, int *brackets, uschar **codeptr, - const uschar **ptrptr, const char **errorptr, PyObject *dictionary) -{ -int repeat_type, op_type; -int repeat_min, repeat_max; -int bravalue, length; -int greedy_default, greedy_non_default; -register int c; -register uschar *code = *codeptr; -const uschar *ptr = *ptrptr; -const uschar *oldptr; -uschar *previous = NULL; -uschar class[32]; -uschar *class_flag; /* Pointer to the single-byte flag for OP_CLASS_L */ - -/* Set up the default and non-default settings for greediness */ - -greedy_default = ((options & PCRE_UNGREEDY) != 0); -greedy_non_default = greedy_default ^ 1; - -/* Switch on next character until the end of the branch */ - -for (;; ptr++) - { - BOOL negate_class; - int class_charcount; - int class_lastchar; - - c = *ptr; - if ((options & PCRE_EXTENDED) != 0) - { - if ((pcre_ctypes[c] & ctype_space) != 0) continue; - if (c == '#') - { - while ((c = *(++ptr)) != 0 && c != '\n'); - continue; - } - } - - switch(c) - { - /* The branch terminates at end of string, |, or ). */ - - case 0: - case '|': - case ')': - *codeptr = code; - *ptrptr = ptr; - return TRUE; - - /* Handle single-character metacharacters */ - - case '^': - previous = NULL; - *code++ = OP_CIRC; - break; - - case '$': - previous = NULL; - *code++ = OP_DOLL; - break; - - case '.': - previous = code; - *code++ = OP_ANY; - break; - - /* Character classes. These always build a 32-byte bitmap of the permitted - characters, except in the special case where there is only one character. - For negated classes, we build the map as usual, then invert it at the end. - */ - - case '[': - previous = code; - if (options & PCRE_LOCALE) - { - *code++ = OP_CLASS_L; - /* Set the flag for localized classes (like \w) to 0 */ - class_flag = code; - *class_flag = 0; - } - else - { - *code++ = OP_CLASS; - class_flag = NULL; - } - - /* If the first character is '^', set the negation flag, and use a - different opcode. This only matters if caseless matching is specified at - runtime. */ - - if ((c = *(++ptr)) == '^') - { - negate_class = TRUE; - if (*(code-1)==OP_CLASS) *(code-1) = OP_NEGCLASS; - c = *(++ptr); - } - else negate_class = FALSE; - - /* Keep a count of chars so that we can optimize the case of just a single - character. */ - - class_charcount = 0; - class_lastchar = -1; - - /* Initialize the 32-char bit map to all zeros. We have to build the - map in a temporary bit of store, in case the class contains only 1 - character, because in that case the compiled code doesn't use the - bit map. */ - - memset(class, 0, 32 * sizeof(uschar)); - - /* Process characters until ] is reached. By writing this as a "do" it - means that an initial ] is taken as a data character. */ - - do - { - if (c == 0) - { - *errorptr = ERR6; - goto FAILED; - } - - /* Backslash may introduce a single character, or it may introduce one - of the specials, which just set a flag. Escaped items are checked for - validity in the pre-compiling pass. The sequence \b is a special case. - Inside a class (and only there) it is treated as backspace. Elsewhere - it marks a word boundary. Other escapes have preset maps ready to - or into the one we are building. We assume they have more than one - character in them, so set class_count bigger than one. */ - - if (c == '\\') - { - c = check_escape(&ptr, errorptr, *brackets, options, TRUE); - if (-c == ESC_b) c = '\b'; - else if (c < 0) - { - class_charcount = 10; - switch (-c) - { - case ESC_d: - { - for (c = 0; c < 32; c++) class[c] |= pcre_cbits[c+cbit_digit]; - } - continue; - - case ESC_D: - { - for (c = 0; c < 32; c++) class[c] |= ~pcre_cbits[c+cbit_digit]; - } - continue; - - case ESC_w: - if (options & PCRE_LOCALE) - { - *class_flag |= 1; - } - else - { - for (c = 0; c < 32; c++) - class[c] |= (pcre_cbits[c] | pcre_cbits[c+cbit_word]); - } - continue; - - case ESC_W: - if (options & PCRE_LOCALE) - { - *class_flag |= 2; - } - else - { - for (c = 0; c < 32; c++) - class[c] |= ~(pcre_cbits[c] | pcre_cbits[c+cbit_word]); - } - continue; - - case ESC_s: - { - for (c = 0; c < 32; c++) class[c] |= pcre_cbits[c+cbit_space]; - } - continue; - - case ESC_S: - { - for (c = 0; c < 32; c++) class[c] |= ~pcre_cbits[c+cbit_space]; - } - continue; - - default: - *errorptr = ERR7; - goto FAILED; - } - } - /* Fall through if single character */ - } - - /* A single character may be followed by '-' to form a range. However, - Perl does not permit ']' to be the end of the range. A '-' character - here is treated as a literal. */ - - if (ptr[1] == '-' && ptr[2] != ']') - { - int d; - ptr += 2; - d = *ptr; - - if (d == 0) - { - *errorptr = ERR6; - goto FAILED; - } - - /* The second part of a range can be a single-character escape, but - not any of the other escapes. */ - - if (d == '\\') - { - d = check_escape(&ptr, errorptr, *brackets, options, TRUE); - if (d < 0) - { - if (d == -ESC_b) d = '\b'; else - { - *errorptr = ERR7; - goto FAILED; - } - } - } - - if (d < c) - { - *errorptr = ERR8; - goto FAILED; - } - - for (; c <= d; c++) - { - class[c/8] |= (1 << (c&7)); - if ((options & PCRE_CASELESS) != 0) - { - int uc = pcre_fcc[c]; /* flip case */ - class[uc/8] |= (1 << (uc&7)); - } - class_charcount++; /* in case a one-char range */ - class_lastchar = c; - } - continue; /* Go get the next char in the class */ - } - - /* Handle a lone single character - we can get here for a normal - non-escape char, or after \ that introduces a single character. */ - - class [c/8] |= (1 << (c&7)); - if ((options & PCRE_CASELESS) != 0) - { - c = pcre_fcc[c]; /* flip case */ - class[c/8] |= (1 << (c&7)); - } - class_charcount++; - class_lastchar = c; - } - - /* Loop until ']' reached; the check for end of string happens inside the - loop. This "while" is the end of the "do" above. */ - - while ((c = *(++ptr)) != ']'); - - /* If class_charcount is 1 and class_lastchar is not negative, we saw - precisely one character. This doesn't need the whole 32-byte bit map. - We turn it into a 1-character OP_CHAR if it's positive, or OP_NOT if - it's negative. */ - - if (class_charcount == 1 && class_lastchar >= 0) - { - if (negate_class) - { - code[-1] = OP_NOT; - } - else - { - code[-1] = OP_CHARS; - *code++ = 1; - } - *code++ = class_lastchar; - } - - /* Otherwise, negate the 32-byte map if necessary, and copy it into - the code vector. */ - - else - { - /* If this is a localized opcode, bump the code pointer up */ - if (class_flag) code++; - if (negate_class) - { - if (class_flag) *class_flag = (*class_flag) ^ 63; - for (c = 0; c < 32; c++) code[c] = ~class[c]; - } - else - memcpy(code, class, 32); - code += 32; - } - break; - - /* Various kinds of repeat */ - - case '{': - if (!is_counted_repeat(ptr+1)) goto NORMAL_CHAR; - ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorptr); - if (*errorptr != NULL) goto FAILED; - goto REPEAT; - - case '*': - repeat_min = 0; - repeat_max = -1; - goto REPEAT; - - case '+': - repeat_min = 1; - repeat_max = -1; - goto REPEAT; - - case '?': - repeat_min = 0; - repeat_max = 1; - - REPEAT: - if (previous == NULL) - { - *errorptr = ERR9; - goto FAILED; - } - - /* If the next character is '?' this is a minimizing repeat, by default, - but if PCRE_UNGREEDY is set, it works the other way round. Advance to the - next character. */ - - if (ptr[1] == '?') - { repeat_type = greedy_non_default; ptr++; } - else repeat_type = greedy_default; - - /* If the maximum is zero then the minimum must also be zero; Perl allows - this case, so we do too - by simply omitting the item altogether. */ - - if (repeat_max == 0) code = previous; - - /* If previous was a string of characters, chop off the last one and use it - as the subject of the repeat. If there was only one character, we can - abolish the previous item altogether. */ - - else if (*previous == OP_CHARS) - { - int len = previous[1]; - if (len == 1) - { - c = previous[2]; - code = previous; - } - else - { - c = previous[len+1]; - previous[1]--; - code--; - } - op_type = 0; /* Use single-char op codes */ - goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */ - } - - /* If previous was a single negated character ([^a] or similar), we use - one of the special opcodes, replacing it. The code is shared with single- - character repeats by adding a suitable offset into repeat_type. */ - - else if ((int)*previous == OP_NOT) - { - op_type = OP_NOTSTAR - OP_STAR; /* Use "not" opcodes */ - c = previous[1]; - code = previous; - goto OUTPUT_SINGLE_REPEAT; - } - - /* If previous was a character type match (\d or similar), abolish it and - create a suitable repeat item. The code is shared with single-character - repeats by adding a suitable offset into repeat_type. */ - - else if ((int)*previous < OP_CIRC || *previous == OP_ANY) - { - op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */ - c = *previous; - code = previous; - - OUTPUT_SINGLE_REPEAT: - repeat_type += op_type; /* Combine both values for many cases */ - - /* A minimum of zero is handled either as the special case * or ?, or as - an UPTO, with the maximum given. */ - - if (repeat_min == 0) - { - if (repeat_max == -1) *code++ = OP_STAR + repeat_type; - else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type; - else - { - *code++ = OP_UPTO + repeat_type; - *code++ = repeat_max >> 8; - *code++ = (repeat_max & 255); - } - } - - /* The case {1,} is handled as the special case + */ - - else if (repeat_min == 1 && repeat_max == -1) - *code++ = OP_PLUS + repeat_type; - - /* The case {n,n} is just an EXACT, while the general case {n,m} is - handled as an EXACT followed by an UPTO. An EXACT of 1 is optimized. */ - - else - { - if (repeat_min != 1) - { - *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */ - *code++ = repeat_min >> 8; - *code++ = (repeat_min & 255); - } - - /* If the minimum is 1 and the previous item was a character string, - we either have to put back the item that got canceled if the string - length was 1, or add the character back onto the end of a longer - string. For a character type nothing need be done; it will just get - put back naturally. Note that the final character is always going to - get added below. */ - - else if (*previous == OP_CHARS) - { - if (code == previous) code += 2; else previous[1]++; - } - - /* For a single negated character we also have to put back the - item that got canceled. */ - - else if (*previous == OP_NOT) code++; - - /* If the maximum is unlimited, insert an OP_STAR. */ - - if (repeat_max < 0) - { - *code++ = c; - *code++ = OP_STAR + repeat_type; - } - - /* Else insert an UPTO if the max is greater than the min. */ - - else if (repeat_max != repeat_min) - { - *code++ = c; - repeat_max -= repeat_min; - *code++ = OP_UPTO + repeat_type; - *code++ = repeat_max >> 8; - *code++ = (repeat_max & 255); - } - } - - /* The character or character type itself comes last in all cases. */ - - *code++ = c; - } - - /* If previous was a character class or a back reference, we put the repeat - stuff after it. */ - - else if (*previous == OP_CLASS || *previous == OP_NEGCLASS || - *previous==OP_CLASS_L || *previous == OP_REF) - { - if (repeat_min == 0 && repeat_max == -1) - *code++ = OP_CRSTAR + repeat_type; - else if (repeat_min == 1 && repeat_max == -1) - *code++ = OP_CRPLUS + repeat_type; - else if (repeat_min == 0 && repeat_max == 1) - *code++ = OP_CRQUERY + repeat_type; - else - { - *code++ = OP_CRRANGE + repeat_type; - *code++ = repeat_min >> 8; - *code++ = repeat_min & 255; - if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */ - *code++ = repeat_max >> 8; - *code++ = repeat_max & 255; - } - } - - /* If previous was a bracket group, we may have to replicate it in certain - cases. If the maximum repeat count is unlimited, check that the bracket - group cannot match the empty string, and diagnose an error if it can. */ - - else if ((int)*previous >= OP_BRA) - { - int i; - int len = code - previous; - - if (repeat_max == -1 && could_be_empty(previous)) - { - *errorptr = ERR10; - goto FAILED; - } - - /* If the minimum is greater than zero, and the maximum is unlimited or - equal to the minimum, the first copy remains where it is, and is - replicated up to the minimum number of times. This case includes the + - repeat, but of course no replication is needed in that case. */ - - if (repeat_min > 0 && (repeat_max == -1 || repeat_max == repeat_min)) - { - for (i = 1; i < repeat_min; i++) - { - memcpy(code, previous, len); - code += len; - } - } - - /* If the minimum is zero, stick BRAZERO in front of the first copy. - Then, if there is a fixed upper limit, replicated up to that many times, - sticking BRAZERO in front of all the optional ones. */ - - else - { - if (repeat_min == 0) - { - memmove(previous+1, previous, len); - code++; - *previous++ = OP_BRAZERO + repeat_type; - } - - for (i = 1; i < repeat_min; i++) - { - memcpy(code, previous, len); - code += len; - } - - for (i = (repeat_min > 0)? repeat_min : 1; i < repeat_max; i++) - { - *code++ = OP_BRAZERO + repeat_type; - memcpy(code, previous, len); - code += len; - } - } - - /* If the maximum is unlimited, set a repeater in the final copy. */ - - if (repeat_max == -1) code[-3] = OP_KETRMAX + repeat_type; - } - - /* Else there's some kind of shambles */ - - else - { - *errorptr = ERR11; - goto FAILED; - } - - /* In all case we no longer have a previous item. */ - - previous = NULL; - break; - - - /* Start of nested bracket sub-expression, or comment or lookahead. - First deal with special things that can come after a bracket; all are - introduced by ?, and the appearance of any of them means that this is not a - referencing group. They were checked for validity in the first pass over - the string, so we don't have to check for syntax errors here. */ - - case '(': - previous = code; /* Only real brackets can be repeated */ - if (*(++ptr) == '?') - { - bravalue = OP_BRA; - - switch (*(++ptr)) - { - case '#': - case 'i': - case 'L': - case 'm': - case 's': - case 'x': - ptr++; - while (*ptr != ')') ptr++; - previous = NULL; - continue; - - case ':': /* Non-extracting bracket */ - ptr++; - break; - - case '=': /* Assertions can't be repeated */ - bravalue = OP_ASSERT; - ptr++; - previous = NULL; - break; - - case '!': - bravalue = OP_ASSERT_NOT; - ptr++; - previous = NULL; - break; - - case ('P'): - ptr++; - if (*ptr=='<') - { - /* (?P<groupname>...) */ - int idlen; - PyObject *string, *intobj; - - ptr++; - idlen = get_group_id(ptr, '>', errorptr); - if (*errorptr) { - goto FAILED; - } - string = PyString_FromStringAndSize((char*)ptr, idlen); - intobj = PyInt_FromLong( brackets[0] + 1 ); - if (intobj == NULL || string == NULL) - { - Py_XDECREF(string); - Py_XDECREF(intobj); - *errorptr = "exception raised"; - goto FAILED; - } - PyDict_SetItem(dictionary, string, intobj); - Py_DECREF(string); Py_DECREF(intobj); /* XXX DECREF commented out! */ - ptr += idlen+1; /* Point to rest of expression */ - goto do_grouping_bracket; - } - if (*ptr=='=') - { - /* (?P=groupname) */ - int idlen, refnum; - PyObject *string, *intobj; - - ptr++; - idlen = get_group_id(ptr, ')', errorptr); - if (*errorptr) { - goto FAILED; - } - string = PyString_FromStringAndSize((char *)ptr, idlen); - if (string==NULL) { - *errorptr = "exception raised"; - goto FAILED; - } - intobj = PyDict_GetItem(dictionary, string); - if (intobj==NULL) { - Py_DECREF(string); - *errorptr = "?P= group identifier isn't defined"; - goto FAILED; - } - - refnum = PyInt_AsLong(intobj); - Py_DECREF(string); - /* The caller doesn't own the reference to the value - returned from PyDict_GetItem, so intobj is not - DECREF'ed. */ - - *code++ = OP_REF; - *code++ = refnum; - /* The continue will cause the top-level for() loop to - be resumed, so ptr will be immediately incremented. - Therefore, the following line adds just idlen, not - idlen+1 */ - ptr += idlen; - continue; - } - /* The character after ?P is neither < nor =, so - report an error. Add more Python-extensions here. */ - *errorptr="unknown after (?P"; - goto FAILED; - - case '>': /* "Match once" brackets */ - if ((options & PCRE_EXTRA) != 0) /* Not yet standard */ - { - bravalue = OP_ONCE; - ptr++; - previous = NULL; - break; - } - /* Else fall through */ - - default: - *errorptr = ERR12; - goto FAILED; - } - } - - /* Else we have a referencing group */ - - else - { - do_grouping_bracket: - if (++(*brackets) > EXTRACT_MAX) - { - *errorptr = ERR13; - goto FAILED; - } - bravalue = OP_BRA + *brackets; - } - - /* Process nested bracketed re; at end pointer is on the bracket. We copy - code into a non-register variable in order to be able to pass its address - because some compilers complain otherwise. */ - - *code = bravalue; - { - uschar *mcode = code; - if (!compile_regex(options, brackets, &mcode, &ptr, errorptr, dictionary)) - goto FAILED; - code = mcode; - } - - if (*ptr != ')') - { - *errorptr = ERR14; - goto FAILED; - } - break; - - /* Check \ for being a real metacharacter; if not, fall through and handle - it as a data character at the start of a string. Escape items are checked - for validity in the pre-compiling pass. */ - - case '\\': - oldptr = ptr; - c = check_escape(&ptr, errorptr, *brackets, options, FALSE); - - /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values - are arranged to be the negation of the corresponding OP_values. For the - back references, the values are ESC_REF plus the reference number. Only - back references and those types that consume a character may be repeated. - We can test for values between ESC_b and ESC_Z for the latter; this may - have to change if any new ones are ever created. */ - - if (c < 0) - { - if (-c >= ESC_REF) - { - int refnum = -c - ESC_REF; - if (*brackets < refnum) - { - *errorptr = ERR15; - goto FAILED; - } - previous = code; - *code++ = OP_REF; - *code++ = refnum; - } - else - { - previous = (-c > ESC_b && -c < ESC_X)? code : NULL; - if ( (options & PCRE_LOCALE) != 0) - { - switch (c) - { - case (-ESC_b): c = -OP_WORD_BOUNDARY_L; break; - case (-ESC_B): c = -OP_NOT_WORD_BOUNDARY_L; break; - case (-ESC_w): c = -OP_WORDCHAR_L; break; - case (-ESC_W): c = -OP_NOT_WORDCHAR_L; break; - } - } - *code++ = -c; - } - continue; - } - - /* Data character: Reset and fall through */ - - ptr = oldptr; - c = '\\'; - - /* Handle a run of data characters until a metacharacter is encountered. - The first character is guaranteed not to be whitespace or # when the - extended flag is set. */ - - NORMAL_CHAR: - default: - previous = code; - *code = OP_CHARS; - code += 2; - length = 0; - - do - { - if ((options & PCRE_EXTENDED) != 0) - { - if ((pcre_ctypes[c] & ctype_space) != 0) continue; - if (c == '#') - { - while ((c = *(++ptr)) != 0 && c != '\n'); - if (c == 0) break; - continue; - } - } - - /* Backslash may introduce a data char or a metacharacter. Escaped items - are checked for validity in the pre-compiling pass. Stop the string - before a metaitem. */ - - if (c == '\\') - { - oldptr = ptr; - c = check_escape(&ptr, errorptr, *brackets, options, FALSE); - if (c < 0) { ptr = oldptr; break; } - } - - /* Ordinary character or single-char escape */ - - *code++ = c; - length++; - } - - /* This "while" is the end of the "do" above. */ - - while (length < 255 && (pcre_ctypes[c = *(++ptr)] & ctype_meta) == 0); - - /* Compute the length and set it in the data vector, and advance to - the next state. */ - - previous[1] = length; - if (length < 255) ptr--; - break; - } - } /* end of big loop */ - -/* Control never reaches here by falling through, only by a goto for all the -error states. Pass back the position in the pattern so that it can be displayed -to the user for diagnosing the error. */ - -FAILED: -*ptrptr = ptr; -return FALSE; -} - - - - -/************************************************* -* Compile sequence of alternatives * -*************************************************/ - -/* On entry, ptr is pointing past the bracket character, but on return -it points to the closing bracket, or vertical bar, or end of string. -The code variable is pointing at the byte into which the BRA operator has been -stored. - -Argument: - options the option bits - brackets -> int containing the number of extracting brackets used - codeptr -> the address of the current code pointer - ptrptr -> the address of the current pattern pointer - errorptr -> pointer to error message - -Returns: TRUE on success -*/ - -static BOOL -compile_regex(int options, int *brackets, uschar **codeptr, - const uschar **ptrptr, const char **errorptr, PyObject *dictionary) -{ -const uschar *ptr = *ptrptr; -uschar *code = *codeptr; -uschar *start_bracket = code; - -for (;;) - { - int length; - uschar *last_branch = code; - - code += 3; - if (!compile_branch(options, brackets, &code, &ptr, errorptr, dictionary)) - { - *ptrptr = ptr; - return FALSE; - } - - /* Fill in the length of the last branch */ - - length = code - last_branch; - last_branch[1] = length >> 8; - last_branch[2] = length & 255; - - /* Reached end of expression, either ')' or end of pattern. Insert a - terminating ket and the length of the whole bracketed item, and return, - leaving the pointer at the terminating char. */ - - if (*ptr != '|') - { - length = code - start_bracket; - *code++ = OP_KET; - *code++ = length >> 8; - *code++ = length & 255; - *codeptr = code; - *ptrptr = ptr; - return TRUE; - } - - /* Another branch follows; insert an "or" node and advance the pointer. */ - - *code = OP_ALT; - ptr++; - } -/* Control never reaches here */ -} - - - -/************************************************* -* Check for anchored expression * -*************************************************/ - -/* Try to find out if this is an anchored regular expression. Consider each -alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket -all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then -it's anchored. However, if this is a multiline pattern, then only OP_SOD -counts, since OP_CIRC can match in the middle. - -A branch is also implicitly anchored if it starts with .* because that will try -the rest of the pattern at all possible matching points, so there is no point -trying them again. - -Argument: points to start of expression (the bracket) -Returns: TRUE or FALSE -*/ - -static BOOL -is_anchored(register const uschar *code, BOOL multiline) -{ -do { - int op = (int)code[3]; - if (op >= OP_BRA || op == OP_ASSERT || op == OP_ONCE) - { if (!is_anchored(code+3, multiline)) return FALSE; } - else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR) - { if (code[4] != OP_ANY) return FALSE; } - else if (op != OP_SOD && (multiline || op != OP_CIRC)) return FALSE; - code += (code[1] << 8) + code[2]; - } -while (*code == OP_ALT); -return TRUE; -} - - - -/************************************************* -* Check for start with \n line expression * -*************************************************/ - -/* This is called for multiline expressions to try to find out if every branch -starts with ^ so that "first char" processing can be done to speed things up. - -Argument: points to start of expression (the bracket) -Returns: TRUE or FALSE -*/ - -static BOOL -is_startline(const uschar *code) -{ -do { - if ((int)code[3] >= OP_BRA || code[3] == OP_ASSERT) - { if (!is_startline(code+3)) return FALSE; } - else if (code[3] != OP_CIRC) return FALSE; - code += (code[1] << 8) + code[2]; - } -while (*code == OP_ALT); -return TRUE; -} - - - -/************************************************* -* Check for fixed first char * -*************************************************/ - -/* Try to find out if there is a fixed first character. This is called for -unanchored expressions, as it speeds up their processing quite considerably. -Consider each alternative branch. If they all start with the same char, or with -a bracket all of whose alternatives start with the same char (recurse ad lib), -then we return that char, otherwise -1. - -Argument: points to start of expression (the bracket) -Returns: -1 or the fixed first char -*/ - -static int -find_firstchar(uschar *code) -{ -register int c = -1; -do - { - register int charoffset = 4; - - if ((int)code[3] >= OP_BRA || code[3] == OP_ASSERT) - { - register int d; - if ((d = find_firstchar(code+3)) < 0) return -1; - if (c < 0) c = d; else if (c != d) return -1; - } - - else switch(code[3]) - { - default: - return -1; - - case OP_EXACT: /* Fall through */ - charoffset++; - - case OP_CHARS: /* Fall through */ - charoffset++; - - case OP_PLUS: - case OP_MINPLUS: - if (c < 0) c = code[charoffset]; else if (c != code[charoffset]) return -1; - break; - } - code += (code[1] << 8) + code[2]; - } -while (*code == OP_ALT); -return c; -} - - - -/************************************************* -* Compile a Regular Expression * -*************************************************/ - -/* This function takes a string and returns a pointer to a block of store -holding a compiled version of the expression. - -Arguments: - pattern the regular expression - options various option bits - errorptr pointer to pointer to error text - erroroffset ptr offset in pattern where error was detected - -Returns: pointer to compiled data block, or NULL on error, - with errorptr and erroroffset set -*/ - -pcre * -pcre_compile(const char *pattern, int options, const char **errorptr, - int *erroroffset, PyObject *dictionary) -{ -real_pcre *re; -int spaces = 0; -int length = 3; /* For initial BRA plus length */ -int runlength; -int c, size; -int bracount = 0; -int brastack[200]; -int top_backref = 0; -unsigned int brastackptr = 0; -uschar *code; -const uschar *ptr; - -#ifdef DEBUG -uschar *code_base, *code_end; -#endif - -/* We can't pass back an error message if errorptr is NULL; I guess the best we -can do is just return NULL. */ - -if (errorptr == NULL) return NULL; -*errorptr = NULL; - -/* However, we can give a message for this error */ - -if (erroroffset == NULL) - { - *errorptr = ERR16; - return NULL; - } -*erroroffset = 0; - -if ((options & ~PUBLIC_OPTIONS) != 0) - { - *errorptr = ERR17; - return NULL; - } - -DPRINTF(("------------------------------------------------------------------\n")); -DPRINTF(("%s\n", pattern)); - -/* The first thing to do is to make a pass over the pattern to compute the -amount of store required to hold the compiled code. This does not have to be -perfect as long as errors are overestimates. At the same time we can detect any -internal flag settings. Make an attempt to correct for any counted white space -if an "extended" flag setting appears late in the pattern. We can't be so -clever for #-comments. */ - -ptr = (const uschar *)(pattern - 1); -while ((c = *(++ptr)) != 0) - { - int min, max; - int class_charcount; - - if ((pcre_ctypes[c] & ctype_space) != 0) - { - if ((options & PCRE_EXTENDED) != 0) continue; - spaces++; - } - - if (c == '#' && (options & PCRE_EXTENDED) != 0) - { - while ((c = *(++ptr)) != 0 && c != '\n'); - continue; - } - - switch(c) - { - /* A backslashed item may be an escaped "normal" character or a - character type. For a "normal" character, put the pointers and - character back so that tests for whitespace etc. in the input - are done correctly. */ - - case '\\': - { - const uschar *save_ptr = ptr; - c = check_escape(&ptr, errorptr, bracount, options, FALSE); - if (*errorptr != NULL) goto PCRE_ERROR_RETURN; - if (c >= 0) - { - ptr = save_ptr; - c = '\\'; - goto NORMAL_CHAR; - } - } - length++; - - /* A back reference needs an additional char, plus either one or 5 - bytes for a repeat. We also need to keep the value of the highest - back reference. */ - - if (c <= -ESC_REF) - { - int refnum = -c - ESC_REF; - if (refnum > top_backref) top_backref = refnum; - length++; /* For single back reference */ - if (ptr[1] == '{' && is_counted_repeat(ptr+2)) - { - ptr = read_repeat_counts(ptr+2, &min, &max, errorptr); - if (*errorptr != NULL) goto PCRE_ERROR_RETURN; - if ((min == 0 && (max == 1 || max == -1)) || - (min == 1 && max == -1)) - length++; - else length += 5; - if (ptr[1] == '?') ptr++; - } - } - continue; - - case '^': - case '.': - case '$': - case '*': /* These repeats won't be after brackets; */ - case '+': /* those are handled separately */ - case '?': - length++; - continue; - - /* This covers the cases of repeats after a single char, metachar, class, - or back reference. */ - - case '{': - if (!is_counted_repeat(ptr+1)) goto NORMAL_CHAR; - ptr = read_repeat_counts(ptr+1, &min, &max, errorptr); - if (*errorptr != NULL) goto PCRE_ERROR_RETURN; - if ((min == 0 && (max == 1 || max == -1)) || - (min == 1 && max == -1)) - length++; - else - { - length--; /* Uncount the original char or metachar */ - if (min == 1) length++; else if (min > 0) length += 4; - if (max > 0) length += 4; else length += 2; - } - if (ptr[1] == '?') ptr++; - continue; - - /* An alternation contains an offset to the next branch or ket. */ - case '|': - length += 3; - continue; - - /* A character class uses 33 characters. Don't worry about character types - that aren't allowed in classes - they'll get picked up during the compile. - A character class that contains only one character uses 2 or 3 bytes, - depending on whether it is negated or not. Notice this where we can. */ - - case '[': - class_charcount = 0; - if (*(++ptr) == '^') ptr++; - do - { - if (*ptr == '\\') - { - int ch = check_escape(&ptr, errorptr, bracount, options, TRUE); - if (*errorptr != NULL) goto PCRE_ERROR_RETURN; - if (-ch == ESC_b) class_charcount++; else class_charcount = 10; - } - else class_charcount++; - ptr++; - } - while (*ptr != 0 && *ptr != ']'); - - /* Repeats for negated single chars are handled by the general code */ - - if (class_charcount == 1) length += 3; else - { - length += 33; - if (options & PCRE_LOCALE) length++; /* Add a byte for the localization flag */ - - /* A repeat needs either 1 or 5 bytes. */ - - if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2)) - { - ptr = read_repeat_counts(ptr+2, &min, &max, errorptr); - if (*errorptr != NULL) goto PCRE_ERROR_RETURN; - if ((min == 0 && (max == 1 || max == -1)) || - (min == 1 && max == -1)) - length++; - else length += 5; - if (ptr[1] == '?') ptr++; - } - } - continue; - - /* Brackets may be genuine groups or special things */ - - case '(': - - /* Handle special forms of bracket, which all start (? */ - - if (ptr[1] == '?') switch (c = ptr[2]) - { - /* Skip over comments entirely */ - case '#': - ptr += 3; - while (*ptr != 0 && *ptr != ')') ptr++; - if (*ptr == 0) - { - *errorptr = ERR18; - goto PCRE_ERROR_RETURN; - } - continue; - - /* Non-referencing groups and lookaheads just move the pointer on, and - then behave like a non-special bracket, except that they don't increment - the count of extracting brackets. */ - - case ':': - case '=': - case '!': - ptr += 2; - break; - - case ('P'): - { - int idlen; - switch (*ptr++) { - case ('<'): - idlen = get_group_id(ptr++, '>', errorptr); - if (*errorptr) goto PCRE_ERROR_RETURN; - ptr += idlen+1; - break; - case ('='): - idlen = get_group_id(ptr++, ')', errorptr); - if (*errorptr) goto PCRE_ERROR_RETURN; - ptr += idlen+1; - length++; - break; - } - } - break; - - /* Ditto for the "once only" bracket, allowed only if the extra bit - is set. */ - - case '>': - if ((options & PCRE_EXTRA) != 0) - { - ptr += 2; - break; - } - /* Else fall through */ - - /* Else loop setting valid options until ) is met. Anything else is an - error. */ - - default: - ptr += 2; - for (;; ptr++) - { - if ((c = *ptr) == 'i') - { - options |= PCRE_CASELESS; - continue; - } - else if ((c = *ptr) == 'L') - { - options |= PCRE_LOCALE; - continue; - } - else if ((c = *ptr) == 'm') - { - options |= PCRE_MULTILINE; - continue; - } - else if (c == 's') - { - options |= PCRE_DOTALL; - continue; - } - else if (c == 'x') - { - options |= PCRE_EXTENDED; - length -= spaces; /* Already counted spaces */ - continue; - } - else if (c == ')') break; - - *errorptr = ERR12; - goto PCRE_ERROR_RETURN; - } - continue; /* End of this bracket handling */ - } - - /* Extracting brackets must be counted so we can process escapes in a - Perlish way. */ - - else bracount++; - - /* Non-special forms of bracket. Save length for computing whole length - at end if there's a repeat that requires duplication of the group. */ - - if (brastackptr >= sizeof(brastack)/sizeof(int)) - { - *errorptr = ERR19; - goto PCRE_ERROR_RETURN; - } - - brastack[brastackptr++] = length; - length += 3; - continue; - - /* Handle ket. Look for subsequent max/min; for certain sets of values we - have to replicate this bracket up to that many times. If brastackptr is - 0 this is an unmatched bracket which will generate an error, but take care - not to try to access brastack[-1]. */ - - case ')': - length += 3; - { - int minval = 1; - int maxval = 1; - int duplength = (brastackptr > 0)? length - brastack[--brastackptr] : 0; - - /* Leave ptr at the final char; for read_repeat_counts this happens - automatically; for the others we need an increment. */ - - if ((c = ptr[1]) == '{' && is_counted_repeat(ptr+2)) - { - ptr = read_repeat_counts(ptr+2, &minval, &maxval, errorptr); - if (*errorptr != NULL) goto PCRE_ERROR_RETURN; - } - else if (c == '*') { minval = 0; maxval = -1; ptr++; } - else if (c == '+') { maxval = -1; ptr++; } - else if (c == '?') { minval = 0; ptr++; } - - /* If there is a minimum > 1 we have to replicate up to minval-1 times; - if there is a limited maximum we have to replicate up to maxval-1 times - and allow for a BRAZERO item before each optional copy, as we also have - to do before the first copy if the minimum is zero. */ - - if (minval == 0) length++; - else if (minval > 1) length += (minval - 1) * duplength; - if (maxval > minval) length += (maxval - minval) * (duplength + 1); - } - continue; - - /* Non-special character. For a run of such characters the length required - is the number of characters + 2, except that the maximum run length is 255. - We won't get a skipped space or a non-data escape or the start of a # - comment as the first character, so the length can't be zero. */ - - NORMAL_CHAR: - default: - length += 2; - runlength = 0; - do - { - if ((pcre_ctypes[c] & ctype_space) != 0) - { - if ((options & PCRE_EXTENDED) != 0) continue; - spaces++; - } - - if (c == '#' && (options & PCRE_EXTENDED) != 0) - { - while ((c = *(++ptr)) != 0 && c != '\n'); - continue; - } - - /* Backslash may introduce a data char or a metacharacter; stop the - string before the latter. */ - - if (c == '\\') - { - const uschar *saveptr = ptr; - c = check_escape(&ptr, errorptr, bracount, options, FALSE); - if (*errorptr != NULL) goto PCRE_ERROR_RETURN; - if (c < 0) { ptr = saveptr; break; } - } - - /* Ordinary character or single-char escape */ - - runlength++; - } - - /* This "while" is the end of the "do" above. */ - - while (runlength < 255 && (pcre_ctypes[c = *(++ptr)] & ctype_meta) == 0); - - ptr--; - length += runlength; - continue; - } - } - -length += 4; /* For final KET and END */ - -if (length > 65539) - { - *errorptr = ERR20; - return NULL; - } - -/* Compute the size of data block needed and get it, either from malloc or -externally provided function. We specify "code[0]" in the offsetof() expression -rather than just "code", because it has been reported that one broken compiler -fails on "code" because it is also an independent variable. It should make no -difference to the value of the offsetof(). */ - -size = length + offsetof(real_pcre, code[0]); -re = (real_pcre *)(pcre_malloc)(size+50); - -if (re == NULL) - { - *errorptr = ERR21; - return NULL; - } - -/* Put in the magic number and the options. */ - -re->magic_number = MAGIC_NUMBER; -re->options = options; - -/* Set up a starting, non-extracting bracket, then compile the expression. On -error, *errorptr will be set non-NULL, so we don't need to look at the result -of the function here. */ - -ptr = (const uschar *)pattern; -code = re->code; -*code = OP_BRA; -bracount = 0; -(void)compile_regex(options, &bracount, &code, &ptr, errorptr, dictionary); -re->top_bracket = bracount; -re->top_backref = top_backref; - -/* If not reached end of pattern on success, there's an excess bracket. */ - -if (*errorptr == NULL && *ptr != 0) *errorptr = ERR22; - -/* Fill in the terminating state and check for disastrous overflow, but -if debugging, leave the test till after things are printed out. */ - -*code++ = OP_END; - - -#ifndef DEBUG -if (code - re->code > length) *errorptr = ERR23; -#endif - -/* Failed to compile */ - -if (*errorptr != NULL) - { - (pcre_free)(re); - PCRE_ERROR_RETURN: - *erroroffset = ptr - (const uschar *)pattern; - return NULL; - } - -/* If the anchored option was not passed, set flag if we can determine that it -is anchored by virtue of ^ characters or \A or anything else. Otherwise, see if -we can determine what the first character has to be, because that speeds up -unanchored matches no end. In the case of multiline matches, an alternative is -to set the PCRE_STARTLINE flag if all branches start with ^. */ - -if ((options & PCRE_ANCHORED) == 0) - { - if (is_anchored(re->code, (options & PCRE_MULTILINE) != 0)) - re->options |= PCRE_ANCHORED; - else - { - int ch = find_firstchar(re->code); - if (ch >= 0) - { - re->first_char = ch; - re->options |= PCRE_FIRSTSET; - } - else if (is_startline(re->code)) - re->options |= PCRE_STARTLINE; - } - } - -/* Print out the compiled data for debugging */ - -#ifdef DEBUG - -printf("Length = %d top_bracket = %d top_backref=%d\n", - length, re->top_bracket, re->top_backref); - -if (re->options != 0) - { - printf("%s%s%s%s%s%s%s%s\n", - ((re->options & PCRE_ANCHORED) != 0)? "anchored " : "", - ((re->options & PCRE_CASELESS) != 0)? "caseless " : "", - ((re->options & PCRE_EXTENDED) != 0)? "extended " : "", - ((re->options & PCRE_MULTILINE) != 0)? "multiline " : "", - ((re->options & PCRE_DOTALL) != 0)? "dotall " : "", - ((re->options & PCRE_DOLLAR_ENDONLY) != 0)? "endonly " : "", - ((re->options & PCRE_EXTRA) != 0)? "extra " : "", - ((re->options & PCRE_UNGREEDY) != 0)? "ungreedy " : ""); - } - -if ((re->options & PCRE_FIRSTSET) != 0) - { - if (isprint(re->first_char)) printf("First char = %c\n", re->first_char); - else printf("First char = \\x%02x\n", re->first_char); - } - -code_end = code; -code_base = code = re->code; - -while (code < code_end) - { - int charlength; - - printf("%3d ", code - code_base); - - if (*code >= OP_BRA) - { - printf("%3d Bra %d", (code[1] << 8) + code[2], *code - OP_BRA); - code += 2; - } - - else switch(*code) - { - case OP_CHARS: - charlength = *(++code); - printf("%3d ", charlength); - while (charlength-- > 0) - if (isprint(c = *(++code))) printf("%c", c); else printf("\\x%02x", c); - break; - - case OP_KETRMAX: - case OP_KETRMIN: - case OP_ALT: - case OP_KET: - case OP_ASSERT: - case OP_ASSERT_NOT: - case OP_ONCE: - printf("%3d %s", (code[1] << 8) + code[2], OP_names[*code]); - code += 2; - break; - - case OP_STAR: - case OP_MINSTAR: - case OP_PLUS: - case OP_MINPLUS: - case OP_QUERY: - case OP_MINQUERY: - case OP_TYPESTAR: - case OP_TYPEMINSTAR: - case OP_TYPEPLUS: - case OP_TYPEMINPLUS: - case OP_TYPEQUERY: - case OP_TYPEMINQUERY: - if (*code >= OP_TYPESTAR) - printf(" %s", OP_names[code[1]]); - else if (isprint(c = code[1])) printf(" %c", c); - else printf(" \\x%02x", c); - printf("%s", OP_names[*code++]); - break; - - case OP_EXACT: - case OP_UPTO: - case OP_MINUPTO: - if (isprint(c = code[3])) printf(" %c{", c); - else printf(" \\x%02x{", c); - if (*code != OP_EXACT) printf("0,"); - printf("%d}", (code[1] << 8) + code[2]); - if (*code == OP_MINUPTO) printf("?"); - code += 3; - break; - - case OP_TYPEEXACT: - case OP_TYPEUPTO: - case OP_TYPEMINUPTO: - printf(" %s{", OP_names[code[3]]); - if (*code != OP_TYPEEXACT) printf(","); - printf("%d}", (code[1] << 8) + code[2]); - if (*code == OP_TYPEMINUPTO) printf("?"); - code += 3; - break; - - case OP_NOT: - if (isprint(c = *(++code))) printf(" [^%c]", c); - else printf(" [^\\x%02x]", c); - break; - - case OP_NOTSTAR: - case OP_NOTMINSTAR: - case OP_NOTPLUS: - case OP_NOTMINPLUS: - case OP_NOTQUERY: - case OP_NOTMINQUERY: - if (isprint(c = code[1])) printf(" [^%c]", c); - else printf(" [^\\x%02x]", c); - printf("%s", OP_names[*code++]); - break; - - case OP_NOTEXACT: - case OP_NOTUPTO: - case OP_NOTMINUPTO: - if (isprint(c = code[3])) printf(" [^%c]{", c); - else printf(" [^\\x%02x]{", c); - if (*code != OP_NOTEXACT) printf(","); - printf("%d}", (code[1] << 8) + code[2]); - if (*code == OP_NOTMINUPTO) printf("?"); - code += 3; - break; - - case OP_REF: - printf(" \\%d", *(++code)); - code ++; - goto CLASS_REF_REPEAT; - - case OP_CLASS: - case OP_NEGCLASS: - case OP_CLASS_L: - { - int i, min, max; - - if (*code==OP_CLASS_L) - { - code++; - printf("Locflag = %i ", *code++); - printf(" ["); - } - else - { - if (*code++ == OP_CLASS) printf(" ["); - else printf(" ^["); - } - - - for (i = 0; i < 256; i++) - { - if ((code[i/8] & (1 << (i&7))) != 0) - { - int j; - for (j = i+1; j < 256; j++) - if ((code[j/8] & (1 << (j&7))) == 0) break; - if (i == '-' || i == ']') printf("\\"); - if (isprint(i)) printf("%c", i); else printf("\\x%02x", i); - if (--j > i) - { - printf("-"); - if (j == '-' || j == ']') printf("\\"); - if (isprint(j)) printf("%c", j); else printf("\\x%02x", j); - } - i = j; - } - } - printf("]"); - code += 32; - /* code ++;*/ - - CLASS_REF_REPEAT: - - switch(*code) - { - case OP_CRSTAR: - case OP_CRMINSTAR: - case OP_CRPLUS: - case OP_CRMINPLUS: - case OP_CRQUERY: - case OP_CRMINQUERY: - printf("%s", OP_names[*code]); - break; - - case OP_CRRANGE: - case OP_CRMINRANGE: - min = (code[1] << 8) + code[2]; - max = (code[3] << 8) + code[4]; - if (max == 0) printf("{%d,}", min); - else printf("{%d,%d}", min, max); - if (*code == OP_CRMINRANGE) printf("?"); - code += 4; - break; - - default: - code--; - } - } - break; - - /* Anything else is just a one-node item */ - - default: - printf(" %s", OP_names[*code]); - break; - } - - code++; - printf("\n"); - } -printf("------------------------------------------------------------------\n"); - -/* This check is done here in the debugging case so that the code that -was compiled can be seen. */ - -if (code - re->code > length) - { - printf("length=%i, code length=%i\n", length, code-re->code); - *errorptr = ERR23; - (pcre_free)(re); - *erroroffset = ptr - (uschar *)pattern; - return NULL; - } -#endif - -return (pcre *)re; -} - - - -/************************************************* -* Match a character type * -*************************************************/ - -/* Not used in all the places it might be as it's sometimes faster -to put the code inline. - -Arguments: - type the character type - c the character - dotall the dotall flag - -Returns: TRUE if character is of the type -*/ - -static BOOL -match_type(int type, int c, BOOL dotall) -{ - -#ifdef DEBUG -if (isprint(c)) printf("matching subject %c against ", c); - else printf("matching subject \\x%02x against ", c); -printf("%s\n", OP_names[type]); -#endif - -switch(type) - { - case OP_ANY: return dotall || c != '\n'; - case OP_NOT_DIGIT: return (pcre_ctypes[c] & ctype_digit) == 0; - case OP_DIGIT: return (pcre_ctypes[c] & ctype_digit) != 0; - case OP_NOT_WHITESPACE: return (pcre_ctypes[c] & ctype_space) == 0; - case OP_WHITESPACE: return (pcre_ctypes[c] & ctype_space) != 0; - case OP_NOT_WORDCHAR: return (pcre_ctypes[c] & ctype_word) == 0; - case OP_WORDCHAR: return (pcre_ctypes[c] & ctype_word) != 0; - case OP_NOT_WORDCHAR_L: return (c!='_' && !isalnum(c)); - case OP_WORDCHAR_L: return (c=='_' || isalnum(c)); - } -return FALSE; -} - - - -/************************************************* -* Match a back-reference * -*************************************************/ - -/* If a back reference hasn't been set, the match fails. - -Arguments: - number reference number - eptr points into the subject - length length to be matched - md points to match data block - -Returns: TRUE if matched -*/ - -static BOOL -match_ref(int number, register const uschar *eptr, int length, match_data *md) -{ -const uschar *p = md->start_subject + md->offset_vector[number]; - -#ifdef DEBUG -if (eptr >= md->end_subject) - printf("matching subject <null>"); -else - { - printf("matching subject "); - pchars(eptr, length, TRUE, md); - } -printf(" against backref "); -pchars(p, length, FALSE, md); -printf("\n"); -#endif - -/* Always fail if not enough characters left */ - -if (length > md->end_subject - p) return FALSE; - -/* Separate the caseless case for speed */ - -if (md->caseless) - { while (length-- > 0) if (pcre_lcc[*p++] != pcre_lcc[*eptr++]) return FALSE; } -else - { while (length-- > 0) if (*p++ != *eptr++) return FALSE; } - -return TRUE; -} - -static int free_stack(match_data *md) -{ -/* Free any stack space that was allocated by the call to match(). */ -if (md->off_num) PyMem_DEL(md->off_num); -if (md->offset_top) PyMem_DEL(md->offset_top); -if (md->r1) PyMem_DEL(md->r1); -if (md->r2) PyMem_DEL(md->r2); -if (md->eptr) PyMem_DEL((char *)md->eptr); -if (md->ecode) PyMem_DEL((char *)md->ecode); -return 0; -} - -static int grow_stack(match_data *md) -{ - if (md->length != 0) - { - md->length = md->length + md->length/2; - } - else - { - int string_len = md->end_subject - md->start_subject + 1; - if (string_len < 80) {md->length = string_len; } - else {md->length = 80;} - } - PyMem_RESIZE(md->offset_top, int, md->length); - /* Can't realloc a pointer-to-const; cast const away. */ - md->eptr = (const uschar **)PyMem_Realloc((void *)md->eptr, - sizeof(uschar *) * md->length); - md->ecode = (const uschar **)PyMem_Realloc((void *)md->ecode, - sizeof(uschar *) * md->length); - PyMem_RESIZE(md->off_num, int, md->length); - PyMem_RESIZE(md->r1, int, md->length); - PyMem_RESIZE(md->r2, int, md->length); - if (md->offset_top == NULL || md->eptr == NULL || md->ecode == NULL || - md->off_num == NULL || md->r1 == NULL || md->r2 == NULL) - { - PyErr_NoMemory(); - longjmp(md->error_env, 1); - } - return 0; -} - - -/************************************************* -* Match from current position * -*************************************************/ - -/* On entry ecode points to the first opcode, and eptr to the first character. - -Arguments: - eptr pointer in subject - ecode position in code - offset_top current top pointer - md pointer to "static" info for the match - -Returns: TRUE if matched -*/ - -static BOOL -match(register const uschar *eptr, register const uschar *ecode, int offset_top, - match_data *md) -{ - int save_stack_position = md->point; -match_loop: - -#define SUCCEED goto succeed -#define FAIL goto fail - -for (;;) - { - int min, max, ctype; - register int i; - register int c; - BOOL minimize = FALSE; - - /* Opening bracket. Check the alternative branches in turn, failing if none - match. We have to set the start offset if required and there is space - in the offset vector so that it is available for subsequent back references - if the bracket matches. However, if the bracket fails, we must put back the - previous value of both offsets in case they were set by a previous copy of - the same bracket. Don't worry about setting the flag for the error case here; - that is handled in the code for KET. */ - - if ((int)*ecode >= OP_BRA) - { - int number = (*ecode - OP_BRA) << 1; - int save_offset1 = 0, save_offset2 = 0; - - DPRINTF(("start bracket %d\n", number/2)); - - if (number > 0 && number < md->offset_end) - { - save_offset1 = md->offset_vector[number]; - save_offset2 = md->offset_vector[number+1]; - md->offset_vector[number] = eptr - md->start_subject; - - DPRINTF(("saving %d %d\n", save_offset1, save_offset2)); - } - - /* Recurse for all the alternatives. */ - - do - { - if (match(eptr, ecode+3, offset_top, md)) SUCCEED; - ecode += (ecode[1] << 8) + ecode[2]; - } - while (*ecode == OP_ALT); - - DPRINTF(("bracket %d failed\n", number/2)); - - if (number > 0 && number < md->offset_end) - { - md->offset_vector[number] = save_offset1; - md->offset_vector[number+1] = save_offset2; - } - - FAIL; - } - - /* Other types of node can be handled by a switch */ - - switch(*ecode) - { - case OP_END: - md->end_match_ptr = eptr; /* Record where we ended */ - md->end_offset_top = offset_top; /* and how many extracts were taken */ - SUCCEED; - - /* The equivalent of Prolog's "cut" - if the rest doesn't match, the - whole thing doesn't match, so we have to get out via a longjmp(). */ - - case OP_CUT: - if (match(eptr, ecode+1, offset_top, md)) SUCCEED; - longjmp(md->fail_env, 1); - - /* Assertion brackets. Check the alternative branches in turn - the - matching won't pass the KET for an assertion. If any one branch matches, - the assertion is true. */ - - case OP_ASSERT: - do - { - if (match(eptr, ecode+3, offset_top, md)) break; - ecode += (ecode[1] << 8) + ecode[2]; - } - while (*ecode == OP_ALT); - if (*ecode == OP_KET) FAIL; - - /* Continue from after the assertion, updating the offsets high water - mark, since extracts may have been taken during the assertion. */ - - do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT); - ecode += 3; - offset_top = md->end_offset_top; - continue; - - /* Negative assertion: all branches must fail to match */ - - case OP_ASSERT_NOT: - do - { - if (match(eptr, ecode+3, offset_top, md)) FAIL; - ecode += (ecode[1] << 8) + ecode[2]; - } - while (*ecode == OP_ALT); - ecode += 3; - continue; - - /* "Once" brackets are like assertion brackets except that after a match, - the point in the subject string is not moved back. Thus there can never be - a move back into the brackets. Check the alternative branches in turn - the - matching won't pass the KET for this kind of subpattern. If any one branch - matches, we carry on, leaving the subject pointer. */ - - case OP_ONCE: - do - { - if (match(eptr, ecode+3, offset_top, md)) break; - ecode += (ecode[1] << 8) + ecode[2]; - } - while (*ecode == OP_ALT); - if (*ecode == OP_KET) FAIL; - - /* Continue as from after the assertion, updating the offsets high water - mark, since extracts may have been taken. */ - - do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT); - ecode += 3; - offset_top = md->end_offset_top; - eptr = md->end_match_ptr; - continue; - - /* An alternation is the end of a branch; scan along to find the end of the - bracketed group and go to there. */ - - case OP_ALT: - do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT); - break; - - /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating - that it may occur zero times. It may repeat infinitely, or not at all - - i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper - repeat limits are compiled as a number of copies, with the optional ones - preceded by BRAZERO or BRAMINZERO. */ - - case OP_BRAZERO: - { - const uschar *next = ecode+1; - if (match(eptr, next, offset_top, md)) SUCCEED; - do next += (next[1] << 8) + next[2]; while (*next == OP_ALT); - ecode = next + 3; - } - break; - - case OP_BRAMINZERO: - { - const uschar *next = ecode+1; - do next += (next[1] << 8) + next[2]; while (*next == OP_ALT); - if (match(eptr, next+3, offset_top, md)) SUCCEED; - ecode++; - } - break;; - - /* End of a group, repeated or non-repeating. If we are at the end of - an assertion "group", stop matching and SUCCEED, but record the - current high water mark for use by positive assertions. */ - - case OP_KET: - case OP_KETRMIN: - case OP_KETRMAX: - { - int number; - const uschar *prev = ecode - (ecode[1] << 8) - ecode[2]; - - if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT || *prev == OP_ONCE) - { - md->end_match_ptr = eptr; /* For ONCE */ - md->end_offset_top = offset_top; - SUCCEED; - } - - /* In all other cases we have to check the group number back at the - start and if necessary complete handling an extraction by setting the - final offset and bumping the high water mark. */ - - number = (*prev - OP_BRA) << 1; - - DPRINTF(("end bracket %d\n", number/2)); - - if (number > 0) - { - if (number >= md->offset_end) md->offset_overflow = TRUE; else - { - md->offset_vector[number+1] = eptr - md->start_subject; - if (offset_top <= number) offset_top = number + 2; - } - } - - /* For a non-repeating ket, just advance to the next node and continue at - this level. */ - - if (*ecode == OP_KET) - { - ecode += 3; - break; - } - - /* The repeating kets try the rest of the pattern or restart from the - preceding bracket, in the appropriate order. */ - - if (*ecode == OP_KETRMIN) - { - const uschar *ptr; - if (match(eptr, ecode+3, offset_top, md)) goto succeed; - /* Handle alternation inside the BRA...KET; push the additional - alternatives onto the stack */ - ptr=prev; - do { - ptr += (ptr[1]<<8)+ ptr[2]; - if (*ptr==OP_ALT) - { - if (md->length == md->point) - { - grow_stack(md); - } - md->offset_top[md->point] = offset_top; - md->eptr[md->point] = eptr; - md->ecode[md->point] = ptr+3; - md->r1[md->point] = 0; - md->r2[md->point] = 0; - md->off_num[md->point] = 0; - md->point++; - } - } while (*ptr==OP_ALT); - ecode=prev+3; goto match_loop; - } - else /* OP_KETRMAX */ - { - const uschar *ptr; - /*int points_pushed=0;*/ - - /* Push one failure point, that will resume matching at the code after - the KETRMAX opcode. */ - if (md->length == md->point) - { - grow_stack(md); - } - md->offset_top[md->point] = offset_top; - md->eptr[md->point] = eptr; - md->ecode[md->point] = ecode+3; - md->r1[md->point] = md->offset_vector[number]; - md->r2[md->point] = md->offset_vector[number+1]; - md->off_num[md->point] = number; - md->point++; - - md->offset_vector[number] = eptr - md->start_subject; - /* Handle alternation inside the BRA...KET; push each of the - additional alternatives onto the stack */ - ptr=prev; - do { - ptr += (ptr[1]<<8)+ ptr[2]; - if (*ptr==OP_ALT) - { - if (md->length == md->point) - if (md->length == md->point) - { - grow_stack(md); - } - md->offset_top[md->point] = offset_top; - md->eptr[md->point] = eptr; - md->ecode[md->point] = ptr+3; - md->r1[md->point] = 0; - md->r2[md->point] = 0; - md->off_num[md->point] = 0; - md->point++; - /*points_pushed++;*/ - } - } while (*ptr==OP_ALT); - /* Jump to the first (or only) alternative and resume trying to match */ - ecode=prev+3; goto match_loop; - } - } - - /* Start of subject unless notbol, or after internal newline if multiline */ - - case OP_CIRC: - if (md->notbol && eptr == md->start_subject) FAIL; - if (md->multiline) - { - if (eptr != md->start_subject && eptr[-1] != '\n') FAIL; - ecode++; - break; - } - /* ... else fall through */ - - /* Start of subject assertion */ - - case OP_SOD: - if (eptr != md->start_subject) FAIL; - ecode++; - break; - - /* Assert before internal newline if multiline, or before - a terminating newline unless endonly is set, else end of subject unless - noteol is set. */ - - case OP_DOLL: - if (md->noteol && eptr >= md->end_subject) FAIL; - if (md->multiline) - { - if (eptr < md->end_subject && *eptr != '\n') FAIL; - ecode++; - break; - } - else if (!md->endonly) - { - if (eptr < md->end_subject - 1 || - (eptr == md->end_subject - 1 && *eptr != '\n')) FAIL; - ecode++; - break; - } - /* ... else fall through */ - - /* End of subject assertion */ - - case OP_EOD: - if (eptr < md->end_subject) FAIL; - ecode++; - break; - - /* Word boundary assertions */ - - case OP_NOT_WORD_BOUNDARY: - case OP_WORD_BOUNDARY: - { - BOOL prev_is_word = (eptr != md->start_subject) && - ((pcre_ctypes[eptr[-1]] & ctype_word) != 0); - BOOL cur_is_word = (eptr < md->end_subject) && - ((pcre_ctypes[*eptr] & ctype_word) != 0); - if ((*ecode++ == OP_WORD_BOUNDARY)? - cur_is_word == prev_is_word : cur_is_word != prev_is_word) - FAIL; - } - break; - - case OP_NOT_WORD_BOUNDARY_L: - case OP_WORD_BOUNDARY_L: - { - BOOL prev_is_word = (eptr != md->start_subject) && - (isalnum(eptr[-1]) || eptr[-1]=='_'); - BOOL cur_is_word = (eptr < md->end_subject) && - (isalnum(*eptr) || *eptr=='_'); - if ((*ecode++ == OP_WORD_BOUNDARY_L)? - cur_is_word == prev_is_word : cur_is_word != prev_is_word) - FAIL; - } - break; - - - /* Match a single character type; inline for speed */ - - case OP_ANY: - if (!md->dotall && eptr < md->end_subject && *eptr == '\n') FAIL; - if (eptr++ >= md->end_subject) FAIL; - ecode++; - break; - - case OP_NOT_DIGIT: - if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_digit) != 0) - FAIL; - ecode++; - break; - - case OP_DIGIT: - if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_digit) == 0) - FAIL; - ecode++; - break; - - case OP_NOT_WHITESPACE: - if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_space) != 0) - FAIL; - ecode++; - break; - - case OP_WHITESPACE: - if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_space) == 0) - FAIL; - ecode++; - break; - - case OP_NOT_WORDCHAR: - if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_word) != 0) - FAIL; - ecode++; - break; - - case OP_WORDCHAR: - if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_word) == 0) - FAIL; - ecode++; - break; - - case OP_NOT_WORDCHAR_L: - if (eptr >= md->end_subject || (*eptr=='_' || isalnum(*eptr) )) - FAIL; - eptr++; - ecode++; - break; - - case OP_WORDCHAR_L: - if (eptr >= md->end_subject || (*eptr!='_' && !isalnum(*eptr) )) - FAIL; - eptr++; - ecode++; - break; - - /* Match a back reference, possibly repeatedly. Look past the end of the - item to see if there is repeat information following. The code is similar - to that for character classes, but repeated for efficiency. Then obey - similar code to character type repeats - written out again for speed. - However, if the referenced string is the empty string, always treat - it as matched, any number of times (otherwise there could be infinite - loops). */ - - case OP_REF: - { - int length; - int number = ecode[1] << 1; /* Doubled reference number */ - ecode += 2; /* Advance past the item */ - - if (number >= offset_top || md->offset_vector[number] < 0) - { - md->errorcode = PCRE_ERROR_BADREF; - FAIL; - } - - length = md->offset_vector[number+1] - md->offset_vector[number]; - - switch (*ecode) - { - case OP_CRSTAR: - case OP_CRMINSTAR: - case OP_CRPLUS: - case OP_CRMINPLUS: - case OP_CRQUERY: - case OP_CRMINQUERY: - c = *ecode++ - OP_CRSTAR; - minimize = (c & 1) != 0; - min = rep_min[c]; /* Pick up values from tables; */ - max = rep_max[c]; /* zero for max => infinity */ - if (max == 0) max = INT_MAX; - break; - - case OP_CRRANGE: - case OP_CRMINRANGE: - minimize = (*ecode == OP_CRMINRANGE); - min = (ecode[1] << 8) + ecode[2]; - max = (ecode[3] << 8) + ecode[4]; - if (max == 0) max = INT_MAX; - ecode += 5; - break; - - default: /* No repeat follows */ - if (!match_ref(number, eptr, length, md)) FAIL; - eptr += length; - continue; /* With the main loop */ - } - - /* If the length of the reference is zero, just continue with the - main loop. */ - - if (length == 0) continue; - - /* First, ensure the minimum number of matches are present. We get back - the length of the reference string explicitly rather than passing the - address of eptr, so that eptr can be a register variable. */ - - for (i = 1; i <= min; i++) - { - if (!match_ref(number, eptr, length, md)) FAIL; - eptr += length; - } - - /* If min = max, continue at the same level without recursion. - They are not both allowed to be zero. */ - - if (min == max) continue; - - /* If minimizing, keep trying and advancing the pointer */ - - if (minimize) - { - for (i = min;; i++) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - if (i >= max || !match_ref(number, eptr, length, md)) - FAIL; - eptr += length; - } - /* Control never gets here */ - } - - /* If maximizing, find the longest string and work backwards */ - - else - { - const uschar *pp = eptr; - for (i = min; i < max; i++) - { - if (!match_ref(number, eptr, length, md)) break; - eptr += length; - } - while (eptr >= pp) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - eptr -= length; - } - FAIL; - } - } - /* Control never gets here */ - - /* Match a character class, possibly repeatedly. Look past the end of the - item to see if there is repeat information following. Then obey similar - code to character type repeats - written out again for speed. If caseless - matching was set at runtime but not at compile time, we have to check both - versions of a character, and we have to behave differently for positive and - negative classes. This is the only time where OP_CLASS and OP_NEGCLASS are - treated differently. */ - - case OP_CLASS: - case OP_NEGCLASS: - { - BOOL nasty_case = *ecode == OP_NEGCLASS && md->runtime_caseless; - const uschar *data = ecode + 1; /* Save for matching */ - ecode += 33; /* Advance past the item */ - - switch (*ecode) - { - case OP_CRSTAR: - case OP_CRMINSTAR: - case OP_CRPLUS: - case OP_CRMINPLUS: - case OP_CRQUERY: - case OP_CRMINQUERY: - c = *ecode++ - OP_CRSTAR; - minimize = (c & 1) != 0; - min = rep_min[c]; /* Pick up values from tables; */ - max = rep_max[c]; /* zero for max => infinity */ - if (max == 0) max = INT_MAX; - break; - - case OP_CRRANGE: - case OP_CRMINRANGE: - minimize = (*ecode == OP_CRMINRANGE); - min = (ecode[1] << 8) + ecode[2]; - max = (ecode[3] << 8) + ecode[4]; - if (max == 0) max = INT_MAX; - ecode += 5; - break; - - default: /* No repeat follows */ - min = max = 1; - break; - } - - /* First, ensure the minimum number of matches are present. */ - - for (i = 1; i <= min; i++) - { - if (eptr >= md->end_subject) FAIL; - c = *eptr++; - - /* Either not runtime caseless, or it was a positive class. For - runtime caseless, continue if either case is in the map. */ - - if (!nasty_case) - { - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if (md->runtime_caseless) - { - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - } - } - - /* Runtime caseless and it was a negative class. Continue only if - both cases are in the map. */ - - else - { - if ((data[c/8] & (1 << (c&7))) == 0) FAIL; - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - } - - FAIL; - } - - /* If max == min we can continue with the main loop without the - need to recurse. */ - - if (min == max) continue; - - /* If minimizing, keep testing the rest of the expression and advancing - the pointer while it matches the class. */ - - if (minimize) - { - for (i = min;; i++) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - if (i >= max || eptr >= md->end_subject) FAIL; - c = *eptr++; - - /* Either not runtime caseless, or it was a positive class. For - runtime caseless, continue if either case is in the map. */ - - if (!nasty_case) - { - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if (md->runtime_caseless) - { - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - } - } - - /* Runtime caseless and it was a negative class. Continue only if - both cases are in the map. */ - - else - { - if ((data[c/8] & (1 << (c&7))) == 0) return FALSE; - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - } - - FAIL; - } - /* Control never gets here */ - } - - /* If maximizing, find the longest possible run, then work backwards. */ - - else - { - const uschar *pp = eptr; - for (i = min; i < max; eptr++, i++) - { - if (eptr >= md->end_subject) break; - c = *eptr; - - /* Either not runtime caseless, or it was a positive class. For - runtime caseless, continue if either case is in the map. */ - - if (!nasty_case) - { - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if (md->runtime_caseless) - { - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - } - } - - /* Runtime caseless and it was a negative class. Continue only if - both cases are in the map. */ - - else - { - if ((data[c/8] & (1 << (c&7))) == 0) break; - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - } - - break; - } - - while (eptr >= pp) - if (match(eptr--, ecode, offset_top, md)) SUCCEED; - FAIL; - } - } - /* Control never gets here */ - - /* OP_CLASS_L opcode: handles localized character classes */ - - case OP_CLASS_L: - { - const uschar *data = ecode + 1; /* Save for matching */ - const uschar locale_flag = *data; - ecode++; data++; /* The localization support adds an extra byte */ - - ecode += 33; /* Advance past the item */ - - switch (*ecode) - { - case OP_CRSTAR: - case OP_CRMINSTAR: - case OP_CRPLUS: - case OP_CRMINPLUS: - case OP_CRQUERY: - case OP_CRMINQUERY: - c = *ecode++ - OP_CRSTAR; - minimize = (c & 1) != 0; - min = rep_min[c]; /* Pick up values from tables; */ - max = rep_max[c]; /* zero for max => infinity */ - if (max == 0) max = INT_MAX; - break; - - case OP_CRRANGE: - case OP_CRMINRANGE: - minimize = (*ecode == OP_CRMINRANGE); - min = (ecode[1] << 8) + ecode[2]; - max = (ecode[3] << 8) + ecode[4]; - if (max == 0) max = INT_MAX; - ecode += 5; - break; - - default: /* No repeat follows */ - if (eptr >= md->end_subject) FAIL; - c = *eptr++; - if ((data[c/8] & (1 << (c&7))) != 0) continue; /* With main loop */ - if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */ - if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */ -#if 0 - if ( (locale_flag & 4) && isdigit(c) ) continue; /* Locale \d */ - if ( (locale_flag & 8) && !isdigit(c) ) continue; /* Locale \D */ - if ( (locale_flag & 16) && isspace(c) ) continue; /* Locale \s */ - if ( (locale_flag & 32) && !isspace(c) ) continue; /* Locale \S */ -#endif - - if (md->runtime_caseless) - { - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; /* With main loop */ - - if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */ - if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */ - } - FAIL; - } - - /* First, ensure the minimum number of matches are present. */ - - for (i = 1; i <= min; i++) - { - if (eptr >= md->end_subject) FAIL; - c = *eptr++; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */ - if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */ - - if (md->runtime_caseless) - { - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */ - if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */ - } - FAIL; - } - - /* If max == min we can continue with the main loop without the - need to recurse. */ - - if (min == max) continue; - - /* If minimizing, keep testing the rest of the expression and advancing - the pointer while it matches the class. */ - - if (minimize) - { - for (i = min;; i++) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - if (i >= max || eptr >= md->end_subject) FAIL; - c = *eptr++; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */ - if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */ - - if (md->runtime_caseless) - { - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */ - if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */ - } - FAIL; - } - /* Control never gets here */ - } - - /* If maximizing, find the longest possible run, then work backwards. */ - - else - { - const uschar *pp = eptr; - for (i = min; i < max; eptr++, i++) - { - if (eptr >= md->end_subject) break; - c = *eptr; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */ - if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */ - if (md->runtime_caseless) - { - c = pcre_fcc[c]; - if ((data[c/8] & (1 << (c&7))) != 0) continue; - if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */ - if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */ - } - break; - } - - while (eptr >= pp) - if (match(eptr--, ecode, offset_top, md)) SUCCEED; - FAIL; - } - } - /* Control never gets here */ - - /* Match a run of characters */ - - case OP_CHARS: - { - register int length = ecode[1]; - ecode += 2; - -#ifdef DEBUG /* Sigh. Some compilers never learn. */ - if (eptr >= md->end_subject) - printf("matching subject <null> against pattern "); - else - { - printf("matching subject "); - pchars(eptr, length, TRUE, md); - printf(" against pattern "); - } - pchars(ecode, length, FALSE, md); - printf("\n"); -#endif - - if (length > md->end_subject - eptr) FAIL; - if (md->caseless) - { - while (length-- > 0) if (pcre_lcc[*ecode++] != pcre_lcc[*eptr++]) FAIL; - } - else - { - while (length-- > 0) if (*ecode++ != *eptr++) FAIL; - } - } - break; - - /* Match a single character repeatedly; different opcodes share code. */ - - case OP_EXACT: - min = max = (ecode[1] << 8) + ecode[2]; - ecode += 3; - goto REPEATCHAR; - - case OP_UPTO: - case OP_MINUPTO: - min = 0; - max = (ecode[1] << 8) + ecode[2]; - minimize = *ecode == OP_MINUPTO; - ecode += 3; - goto REPEATCHAR; - - case OP_STAR: - case OP_MINSTAR: - case OP_PLUS: - case OP_MINPLUS: - case OP_QUERY: - case OP_MINQUERY: - c = *ecode++ - OP_STAR; - minimize = (c & 1) != 0; - min = rep_min[c]; /* Pick up values from tables; */ - max = rep_max[c]; /* zero for max => infinity */ - if (max == 0) max = INT_MAX; - - /* Common code for all repeated single-character matches. We can give - up quickly if there are fewer than the minimum number of characters left in - the subject. */ - - REPEATCHAR: - if (min > md->end_subject - eptr) FAIL; - c = *ecode++; - - /* The code is duplicated for the caseless and caseful cases, for speed, - since matching characters is likely to be quite common. First, ensure the - minimum number of matches are present. If min = max, continue at the same - level without recursing. Otherwise, if minimizing, keep trying the rest of - the expression and advancing one matching character if failing, up to the - maximum. Alternatively, if maximizing, find the maximum number of - characters and work backwards. */ - - DPRINTF(("matching %c{%d,%d} against subject %.*s\n", c, min, max, - max, eptr)); - - if (md->caseless) - { - c = pcre_lcc[c]; - for (i = 1; i <= min; i++) if (c != pcre_lcc[*eptr++]) FAIL; - if (min == max) continue; - if (minimize) - { - for (i = min;; i++) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - if (i >= max || eptr >= md->end_subject || c != pcre_lcc[*eptr++]) - FAIL; - } - /* Control never gets here */ - } - else - { - const uschar *pp = eptr; - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || c != pcre_lcc[*eptr]) break; - eptr++; - } - while (eptr >= pp) - if (match(eptr--, ecode, offset_top, md)) SUCCEED; - FAIL; - } - /* Control never gets here */ - } - - /* Caseful comparisons */ - - else - { - for (i = 1; i <= min; i++) if (c != *eptr++) FAIL; - if (min == max) continue; - if (minimize) - { - for (i = min;; i++) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - if (i >= max || eptr >= md->end_subject || c != *eptr++) FAIL; - } - /* Control never gets here */ - } - else - { - const uschar *pp = eptr; - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || c != *eptr) break; - eptr++; - } - while (eptr >= pp) - if (match(eptr--, ecode, offset_top, md)) SUCCEED; - FAIL; - } - } - /* Control never gets here */ - - /* Match a negated single character */ - - case OP_NOT: - if (eptr >= md->end_subject) FAIL; - ecode++; - if (md->caseless) - { - if (pcre_lcc[*ecode++] == pcre_lcc[*eptr++]) FAIL; - } - else - { - if (*ecode++ == *eptr++) FAIL; - } - break; - - /* Match a negated single character repeatedly. This is almost a repeat of - the code for a repeated single character, but I haven't found a nice way of - commoning these up that doesn't require a test of the positive/negative - option for each character match. Maybe that wouldn't add very much to the - time taken, but character matching *is* what this is all about... */ - - case OP_NOTEXACT: - min = max = (ecode[1] << 8) + ecode[2]; - ecode += 3; - goto REPEATNOTCHAR; - - case OP_NOTUPTO: - case OP_NOTMINUPTO: - min = 0; - max = (ecode[1] << 8) + ecode[2]; - minimize = *ecode == OP_NOTMINUPTO; - ecode += 3; - goto REPEATNOTCHAR; - - case OP_NOTSTAR: - case OP_NOTMINSTAR: - case OP_NOTPLUS: - case OP_NOTMINPLUS: - case OP_NOTQUERY: - case OP_NOTMINQUERY: - c = *ecode++ - OP_NOTSTAR; - minimize = (c & 1) != 0; - min = rep_min[c]; /* Pick up values from tables; */ - max = rep_max[c]; /* zero for max => infinity */ - if (max == 0) max = INT_MAX; - - /* Common code for all repeated single-character matches. We can give - up quickly if there are fewer than the minimum number of characters left in - the subject. */ - - REPEATNOTCHAR: - if (min > md->end_subject - eptr) FAIL; - c = *ecode++; - - /* The code is duplicated for the caseless and caseful cases, for speed, - since matching characters is likely to be quite common. First, ensure the - minimum number of matches are present. If min = max, continue at the same - level without recursing. Otherwise, if minimizing, keep trying the rest of - the expression and advancing one matching character if failing, up to the - maximum. Alternatively, if maximizing, find the maximum number of - characters and work backwards. */ - - DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", c, min, max, - max, eptr)); - - if (md->caseless) - { - c = pcre_lcc[c]; - for (i = 1; i <= min; i++) if (c == pcre_lcc[*eptr++]) FAIL; - if (min == max) continue; - if (minimize) - { - for (i = min;; i++) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - if (i >= max || eptr >= md->end_subject || c == pcre_lcc[*eptr++]) - FAIL; - } - /* Control never gets here */ - } - else - { - const uschar *pp = eptr; - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || c == pcre_lcc[*eptr]) break; - eptr++; - } - while (eptr >= pp) - if (match(eptr--, ecode, offset_top, md)) SUCCEED; - FAIL; - } - /* Control never gets here */ - } - - /* Caseful comparisons */ - - else - { - for (i = 1; i <= min; i++) if (c == *eptr++) FAIL; - if (min == max) continue; - if (minimize) - { - for (i = min;; i++) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - if (i >= max || eptr >= md->end_subject || c == *eptr++) FAIL; - } - /* Control never gets here */ - } - else - { - const uschar *pp = eptr; - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || c == *eptr) break; - eptr++; - } - while (eptr >= pp) - if (match(eptr--, ecode, offset_top, md)) SUCCEED; - FAIL; - } - } - /* Control never gets here */ - - /* Match a single character type repeatedly; several different opcodes - share code. This is very similar to the code for single characters, but we - repeat it in the interests of efficiency. */ - - case OP_TYPEEXACT: - min = max = (ecode[1] << 8) + ecode[2]; - minimize = TRUE; - ecode += 3; - goto REPEATTYPE; - - case OP_TYPEUPTO: - case OP_TYPEMINUPTO: - min = 0; - max = (ecode[1] << 8) + ecode[2]; - minimize = *ecode == OP_TYPEMINUPTO; - ecode += 3; - goto REPEATTYPE; - - case OP_TYPESTAR: - case OP_TYPEMINSTAR: - case OP_TYPEPLUS: - case OP_TYPEMINPLUS: - case OP_TYPEQUERY: - case OP_TYPEMINQUERY: - c = *ecode++ - OP_TYPESTAR; - minimize = (c & 1) != 0; - min = rep_min[c]; /* Pick up values from tables; */ - max = rep_max[c]; /* zero for max => infinity */ - if (max == 0) max = INT_MAX; - - /* Common code for all repeated single character type matches */ - - REPEATTYPE: - ctype = *ecode++; /* Code for the character type */ - - /* First, ensure the minimum number of matches are present. Use inline - code for maximizing the speed, and do the type test once at the start - (i.e. keep it out of the loop). Also test that there are at least the - minimum number of characters before we start. */ - - if (min > md->end_subject - eptr) FAIL; - if (min > 0) switch(ctype) - { - case OP_ANY: - if (!md->dotall) - { for (i = 1; i <= min; i++) if (*eptr++ == '\n') FAIL; } - else eptr += min; - break; - - case OP_NOT_DIGIT: - for (i = 1; i <= min; i++) - if ((pcre_ctypes[*eptr++] & ctype_digit) != 0) FAIL; - break; - - case OP_DIGIT: - for (i = 1; i <= min; i++) - if ((pcre_ctypes[*eptr++] & ctype_digit) == 0) FAIL; - break; - - case OP_NOT_WHITESPACE: - for (i = 1; i <= min; i++) - if ((pcre_ctypes[*eptr++] & ctype_space) != 0) FAIL; - break; - - case OP_WHITESPACE: - for (i = 1; i <= min; i++) - if ((pcre_ctypes[*eptr++] & ctype_space) == 0) FAIL; - break; - - case OP_NOT_WORDCHAR: - for (i = 1; i <= min; i++) if ((pcre_ctypes[*eptr++] & ctype_word) != 0) - FAIL; - break; - - case OP_WORDCHAR: - for (i = 1; i <= min; i++) if ((pcre_ctypes[*eptr++] & ctype_word) == 0) - FAIL; - break; - - case OP_NOT_WORDCHAR_L: - for (i = 1; i <= min; i++, eptr++) if (*eptr=='_' || isalnum(*eptr)) - FAIL; - break; - - case OP_WORDCHAR_L: - for (i = 1; i <= min; i++, eptr++) if (*eptr!='_' && !isalnum(*eptr)) - FAIL; - break; - } - - /* If min = max, continue at the same level without recursing */ - - if (min == max) continue; - - /* If minimizing, we have to test the rest of the pattern before each - subsequent match, so inlining isn't much help; just use the function. */ - - if (minimize) - { - for (i = min;; i++) - { - if (match(eptr, ecode, offset_top, md)) SUCCEED; - if (i >= max || eptr >= md->end_subject || - !match_type(ctype, *eptr++, md->dotall)) - FAIL; - } - /* Control never gets here */ - } - - /* If maximizing it is worth using inline code for speed, doing the type - test once at the start (i.e. keep it out of the loop). */ - - else - { - const uschar *pp = eptr; - switch(ctype) - { - case OP_ANY: - if (!md->dotall) - { - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || *eptr == '\n') break; - eptr++; - } - } - else - { - c = max - min; - if (c > md->end_subject - eptr) c = md->end_subject - eptr; - eptr += c; - } - break; - - case OP_NOT_DIGIT: - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_digit) != 0) - break; - eptr++; - } - break; - - case OP_DIGIT: - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_digit) == 0) - break; - eptr++; - } - break; - - case OP_NOT_WHITESPACE: - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_space) != 0) - break; - eptr++; - } - break; - - case OP_WHITESPACE: - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_space) == 0) - break; - eptr++; - } - break; - - case OP_NOT_WORDCHAR: - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_word) != 0) - break; - eptr++; - } - break; - - case OP_WORDCHAR: - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_word) == 0) - break; - eptr++; - } - break; - case OP_NOT_WORDCHAR_L: - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || (*eptr=='_' || isalnum(*eptr) ) ) - break; - eptr++; - } - break; - - case OP_WORDCHAR_L: - for (i = min; i < max; i++) - { - if (eptr >= md->end_subject || (*eptr!='_' && !isalnum(*eptr) ) ) - break; - eptr++; - } - break; - } - - while (eptr >= pp) - if (match(eptr--, ecode, offset_top, md)) SUCCEED; - FAIL; - } - /* Control never gets here */ - - /* There's been some horrible disaster. */ - - default: - DPRINTF(("Unknown opcode %d\n", *ecode)); - md->errorcode = PCRE_ERROR_UNKNOWN_NODE; - FAIL; - } - - /* Do not stick any code in here without much thought; it is assumed - that "continue" in the code above comes out to here to repeat the main - loop. */ - - } /* End of main loop */ -/* Control never reaches here */ - -fail: - if (md->point > save_stack_position) - { - /* If there are still points remaining on the stack, pop the next one off */ - int off_num; - - md->point--; - offset_top = md->offset_top[md->point]; - eptr = md->eptr[md->point]; - ecode = md->ecode[md->point]; - off_num = md->off_num[md->point]; - md->offset_vector[off_num] = md->r1[md->point]; - md->offset_vector[off_num+1] = md->r2[md->point]; - goto match_loop; - } - /* Failure, and nothing left on the stack, so end this function call */ - - /* Restore the top of the stack to where it was before this function - call. This lets us use one stack for everything; recursive calls - can push and pop information, and may increase the stack. When - the call returns, the parent function can resume pushing and - popping wherever it was. */ - - md->point = save_stack_position; - return FALSE; - -succeed: - return TRUE; -} - - - -/************************************************* -* Segregate setjmp() * -*************************************************/ - -/* The -Wall option of gcc gives warnings for all local variables when setjmp() -is used, even if the coding conforms to the rules of ANSI C. To avoid this, we -hide it in a separate function. This is called only when PCRE_EXTRA is set, -since it's needed only for the extension \X option, and with any luck, a good -compiler will spot the tail recursion and compile it efficiently. - -Arguments: - eptr pointer in subject - ecode position in code - offset_top current top pointer - md pointer to "static" info for the match - -Returns: TRUE if matched -*/ - -static BOOL -match_with_setjmp(const uschar *eptr, const uschar *ecode, int offset_top, - match_data *match_block) -{ -return setjmp(match_block->fail_env) == 0 && - match(eptr, ecode, offset_top, match_block); -} - - - -/************************************************* -* Execute a Regular Expression * -*************************************************/ - -/* This function applies a compiled re to a subject string and picks out -portions of the string if it matches. Two elements in the vector are set for -each substring: the offsets to the start and end of the substring. - -Arguments: - external_re points to the compiled expression - external_extra points to "hints" from pcre_study() or is NULL - subject points to the subject string - length length of subject string (may contain binary zeros) - options option bits - offsets points to a vector of ints to be filled in with offsets - offsetcount the number of elements in the vector - -Returns: > 0 => success; value is the number of elements filled in - = 0 => success, but offsets is not big enough - -1 => failed to match - < -1 => some kind of unexpected problem -*/ - -int -pcre_exec(const pcre *external_re, const pcre_extra *external_extra, - const char *subject, int length, int start_pos, int options, - int *offsets, int offsetcount) -{ - /* The "volatile" directives are to make gcc -Wall stop complaining - that these variables can be clobbered by the longjmp. Hopefully - they won't cost too much performance. */ -volatile int resetcount, ocount; -volatile int first_char = -1; -const uschar * volatile start_bits = NULL; -const uschar * volatile start_match = (const uschar *)subject + start_pos; -match_data match_block; -const uschar *end_subject; -const real_pcre *re = (const real_pcre *)external_re; -const real_pcre_extra *extra = (const real_pcre_extra *)external_extra; -volatile BOOL using_temporary_offsets = FALSE; -volatile BOOL anchored = ((re->options | options) & PCRE_ANCHORED) != 0; -volatile BOOL startline = (re->options & PCRE_STARTLINE) != 0; - -if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION; - -if (re == NULL || subject == NULL || - (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL; -if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC; - -match_block.start_subject = (const uschar *)subject; -match_block.end_subject = match_block.start_subject + length; -end_subject = match_block.end_subject; - -match_block.caseless = ((re->options | options) & PCRE_CASELESS) != 0; -match_block.runtime_caseless = match_block.caseless && - (re->options & PCRE_CASELESS) == 0; - -match_block.multiline = ((re->options | options) & PCRE_MULTILINE) != 0; -match_block.dotall = ((re->options | options) & PCRE_DOTALL) != 0; -match_block.endonly = ((re->options | options) & PCRE_DOLLAR_ENDONLY) != 0; - -match_block.notbol = (options & PCRE_NOTBOL) != 0; -match_block.noteol = (options & PCRE_NOTEOL) != 0; - -match_block.errorcode = PCRE_ERROR_NOMATCH; /* Default error */ - -/* Set the stack state to empty */ - match_block.off_num = match_block.offset_top = NULL; - match_block.r1 = match_block.r2 = NULL; - match_block.eptr = match_block.ecode = NULL; - match_block.point = match_block.length = 0; - -/* If the expression has got more back references than the offsets supplied can -hold, we get a temporary bit of working store to use during the matching. -Otherwise, we can use the vector supplied, rounding down its size to a multiple -of 2. */ - -ocount = offsetcount & (-2); -if (re->top_backref > 0 && re->top_backref >= ocount/2) - { - ocount = re->top_backref * 2 + 2; - match_block.offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int)); - if (match_block.offset_vector == NULL) return PCRE_ERROR_NOMEMORY; - using_temporary_offsets = TRUE; - DPRINTF(("Got memory to hold back references\n")); - } -else match_block.offset_vector = offsets; - -match_block.offset_end = ocount; -match_block.offset_overflow = FALSE; - -/* Compute the minimum number of offsets that we need to reset each time. Doing -this makes a huge difference to execution time when there aren't many brackets -in the pattern. */ - -resetcount = 2 + re->top_bracket * 2; -if (resetcount > offsetcount) resetcount = ocount; - -/* If MULTILINE is set at exec time but was not set at compile time, and the -anchored flag is set, we must re-check because a setting provoked by ^ in the -pattern is not right in multi-line mode. Calling is_anchored() again here does -the right check, because multiline is now set. If it now yields FALSE, the -expression must have had ^ starting some of its branches. Check to see if -that is true for *all* branches, and if so, set the startline flag. */ - -if (match_block.multiline && anchored && (re->options & PCRE_MULTILINE) == 0 && - !is_anchored(re->code, match_block.multiline)) - { - anchored = FALSE; - if (is_startline(re->code)) startline = TRUE; - } - -/* Set up the first character to match, if available. The first_char value is -never set for an anchored regular expression, but the anchoring may be forced -at run time, so we have to test for anchoring. The first char may be unset for -an unanchored pattern, of course. If there's no first char and the pattern was -studied, the may be a bitmap of possible first characters. However, we can -use this only if the caseless state of the studying was correct. */ - -if (!anchored) - { - if ((re->options & PCRE_FIRSTSET) != 0) - { - first_char = re->first_char; - if (match_block.caseless) first_char = pcre_lcc[first_char]; - } - else - if (!startline && extra != NULL && - (extra->options & PCRE_STUDY_MAPPED) != 0 && - ((extra->options & PCRE_STUDY_CASELESS) != 0) == match_block.caseless) - start_bits = extra->start_bits; - } - -/* Loop for unanchored matches; for anchored regexps the loop runs just once. */ - -do - { - int rc; - register int *iptr = match_block.offset_vector; - register int *iend = iptr + resetcount; - - /* Reset the maximum number of extractions we might see. */ - - while (iptr < iend) *iptr++ = -1; - - /* Advance to a unique first char if possible */ - - if (first_char >= 0) - { - if (match_block.caseless) - while (start_match < end_subject && pcre_lcc[*start_match] != first_char) - start_match++; - else - while (start_match < end_subject && *start_match != first_char) - start_match++; - } - - /* Or to just after \n for a multiline match if possible */ - - else if (startline) - { - if (start_match > match_block.start_subject) - { - while (start_match < end_subject && start_match[-1] != '\n') - start_match++; - } - } - - /* Or to a non-unique first char */ - - else if (start_bits != NULL) - { - while (start_match < end_subject) - { - register int c = *start_match; - if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break; - } - } - -#ifdef DEBUG /* Sigh. Some compilers never learn. */ - printf(">>>> Match against: "); - pchars(start_match, end_subject - start_match, TRUE, &match_block); - printf("\n"); -#endif - - /* When a match occurs, substrings will be set for all internal extractions; - we just need to set up the whole thing as substring 0 before returning. If - there were too many extractions, set the return code to zero. In the case - where we had to get some local store to hold offsets for backreferences, copy - those back references that we can. In this case there need not be overflow - if certain parts of the pattern were not used. - - Before starting the match, we have to set up a longjmp() target to enable - the "cut" operation to fail a match completely without backtracking. This - is done in a separate function to avoid compiler warnings. We need not do - it unless PCRE_EXTRA is set, since only in that case is the "cut" operation - enabled. */ - - /* To handle errors such as running out of memory for the failure - stack, we need to save this location via setjmp(), so - error-handling code can call longjmp() to jump out of deeply-nested code. */ - if (setjmp(match_block.error_env)==0) - { - - if ((re->options & PCRE_EXTRA) != 0) - { - if (!match_with_setjmp(start_match, re->code, 2, &match_block)) - continue; - } - else if (!match(start_match, re->code, 2, &match_block)) continue; - - /* Copy the offset information from temporary store if necessary */ - - if (using_temporary_offsets) - { - if (offsetcount >= 4) - { - memcpy(offsets + 2, match_block.offset_vector + 2, - (offsetcount - 2) * sizeof(int)); - DPRINTF(("Copied offsets from temporary memory\n")); - } - if (match_block.end_offset_top > offsetcount) - match_block.offset_overflow = TRUE; - - DPRINTF(("Freeing temporary memory\n")); - (pcre_free)(match_block.offset_vector); - } - - rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2; - - if (match_block.offset_end < 2) rc = 0; else - { - offsets[0] = start_match - match_block.start_subject; - offsets[1] = match_block.end_match_ptr - match_block.start_subject; - } - - DPRINTF((">>>> returning %d\n", rc)); - free_stack(&match_block); - return rc; - } /* End of (if setjmp(match_block.error_env)...) */ - free_stack(&match_block); - - /* Return an error code; pcremodule.c will preserve the exception */ - if (PyErr_Occurred()) return PCRE_ERROR_NOMEMORY; - } -while (!anchored && - match_block.errorcode == PCRE_ERROR_NOMATCH && - start_match++ < end_subject); - -if (using_temporary_offsets) - { - DPRINTF(("Freeing temporary memory\n")); - (pcre_free)(match_block.offset_vector); - } - -#ifdef DEBUG -printf(">>>> returning %d\n", match_block.errorcode); -#endif - - free_stack(&match_block); - return match_block.errorcode; -} - -/* End of pcre.c */ |