diff options
Diffstat (limited to 'Modules/pcremodule.c')
| -rw-r--r-- | Modules/pcremodule.c | 826 |
1 files changed, 388 insertions, 438 deletions
diff --git a/Modules/pcremodule.c b/Modules/pcremodule.c index 73af3ca..8701ba5 100644 --- a/Modules/pcremodule.c +++ b/Modules/pcremodule.c @@ -105,39 +105,47 @@ PyPcre_exec(self, args) PcreObject *self; PyObject *args; { - unsigned char *string; - int stringlen, pos=0, options=0, i, count; - int offsets[100*2]; /* XXX must this be fixed? */ + char *string; + int stringlen, pos = 0, options=0, endpos = -1, i, count; + int offsets[100*2]; PyObject *list; - if (!PyArg_ParseTuple(args, "s#|ii", &string, &stringlen, &pos, &options)) + if (!PyArg_ParseTuple(args, "s#|iiii", &string, &stringlen, &pos, &endpos, &options)) return NULL; + if (endpos == -1) {endpos = stringlen;} count = pcre_exec(self->regex, self->regex_extra, - string+pos, stringlen-pos, options, + (char *)string+pos, 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) - { - PyErr_SetObject(ErrorObject, Py_BuildValue("si", "Regex error", count)); - return NULL; - } + { + PyErr_SetObject(ErrorObject, Py_BuildValue("si", "Regex error", count)); + return NULL; + } list=PyList_New(self->num_groups+1); if (list==NULL) return NULL; - /* XXX count can be >size_offset! */ 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;} - else - {start += pos; end +=pos;} - v=Py_BuildValue("ii", start, end); - if (v==NULL) {Py_DECREF(list); return NULL;} - PyList_SetItem(list, i, v); - } + { + 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;} + else + {start += pos; end +=pos;} + v=Py_BuildValue("ii", start, end); + if (v==NULL) {Py_DECREF(list); return NULL;} + PyList_SetItem(list, i, v); + } return list; } @@ -182,7 +190,7 @@ PyPcre_compile(self, args) { PcreObject *rv; PyObject *dictionary; - unsigned char *pattern, *newpattern; + char *pattern, *newpattern; char *error; int num_zeros, i, j; @@ -192,282 +200,274 @@ PyPcre_compile(self, args) return NULL; rv = newPcreObject(args); if ( rv == NULL ) - return NULL; + return NULL; /* PCRE doesn't like having null bytes in its pattern, so we have to replace any zeros in the string with the characters '\0'. */ num_zeros=1; for(i=0; i<patternlen; i++) { - if (pattern[i]==0) num_zeros++; + if (pattern[i]==0) num_zeros++; } newpattern=malloc(patternlen+num_zeros); if (newpattern==NULL) { - PyErr_SetString(PyExc_MemoryError, "can't allocate memory for new pattern"); - return NULL; + PyErr_SetString(PyExc_MemoryError, "can't allocate memory for new pattern"); + return NULL; } for (i=j=0; i<patternlen; i++, j++) - { - if (pattern[i]!=0) newpattern[j]=pattern[i]; - else { - newpattern[j++]='\\'; - newpattern[j] ='0'; - } - } + { + if (pattern[i]!=0) newpattern[j]=pattern[i]; + else { + newpattern[j++]='\\'; + newpattern[j] ='0'; + } + } newpattern[j]='\0'; - rv->regex = pcre_compile(newpattern, options, + rv->regex = pcre_compile((char*)newpattern, options, &error, &erroroffset, dictionary); free(newpattern); if (rv->regex==NULL) - { - PyMem_DEL(rv); - if (!PyErr_Occurred()) - { - PyErr_SetObject(ErrorObject, Py_BuildValue("si", error, erroroffset)); - } - return NULL; - } + { + PyMem_DEL(rv); + if (!PyErr_Occurred()) + { + PyErr_SetObject(ErrorObject, Py_BuildValue("si", error, erroroffset)); + } + return NULL; + } rv->regex_extra=pcre_study(rv->regex, 0, &error); if (rv->regex_extra==NULL && error!=NULL) - { - PyMem_DEL(rv); - PyErr_SetObject(ErrorObject, Py_BuildValue("si", error, 0)); - return NULL; - } + { + PyMem_DEL(rv); + PyErr_SetObject(ErrorObject, Py_BuildValue("si", error, 0)); + return NULL; + } rv->num_groups = pcre_info(rv->regex, NULL, NULL); if (rv->num_groups<0) - { - PyErr_SetObject(ErrorObject, Py_BuildValue("si", "Regex error", rv->num_groups)); - PyMem_DEL(rv); - return NULL; - } + { + PyErr_SetObject(ErrorObject, Py_BuildValue("si", "Regex error", rv->num_groups)); + PyMem_DEL(rv); + return NULL; + } return (PyObject *)rv; } static PyObject * PyPcre_expand_escape(pattern, pattern_len, indexptr, typeptr) - unsigned char *pattern; - int pattern_len, *indexptr, *typeptr; + unsigned char *pattern; + int pattern_len, *indexptr, *typeptr; { - unsigned char c; - int index = *indexptr; + 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); - break; - case('n'): - *indexptr = index; - return Py_BuildValue("c", (char)10); - break; - case('v'): - *indexptr = index; - return Py_BuildValue("c", (char)11); - break; - case('r'): - *indexptr = index; - return Py_BuildValue("c", (char)13); - break; - case('f'): - *indexptr = index; - return Py_BuildValue("c", (char)12); - break; - case('a'): - *indexptr = index; - return Py_BuildValue("c", (char)7); - break; - case('b'): - *indexptr=index; - return Py_BuildValue("c", (char)8); - break; - - case('x'): - { - int end, length; - unsigned char *string; - PyObject *v; - - end=index; - while (end<pattern_len && - ( pcre_ctypes[ pattern[end] ] & ctype_xdigit ) ) - end++; - if (end==index) - { - PyErr_SetString(ErrorObject, "\\x must be followed by hex digits"); - return NULL; - } - length=end-index; - string=malloc(length+4+1); - if (string==NULL) - { - PyErr_SetString(PyExc_MemoryError, "can't allocate memory for \\x string"); - return NULL; - } - /* Create a string containing "\x<hexdigits>", which will be - passed to eval() */ - string[0]=string[length+3]='"'; - string[1]='\\'; - string[length+4]='\0'; - memcpy(string+2, pattern+index-1, length+1); - v=PyRun_String((char *)string, Py_eval_input, - PyEval_GetGlobals(), PyEval_GetLocals()); - free(string); - /* The evaluation raised an exception */ - if (v==NULL) return NULL; - *indexptr = end; - return v; - } - break; - - case('E'): case('G'): case('L'): case('Q'): - case('U'): case('l'): case('u'): - { - char message[50]; - sprintf(message, "\\%c is not allowed", c); - PyErr_SetString(ErrorObject, message); - return NULL; - } - - case('g'): - { - int end, valid, i; 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; - } - valid=1; - if (index==end /* Zero-length name */ - || !(pcre_ctypes[pattern[index]] & ctype_word) /* First char. not alphanumeric */ - || (pcre_ctypes[pattern[index]] & ctype_digit) ) /* First char. a digit */ - valid=0; - - for(i=index+1; i<end; i++) - { - if (!(pcre_ctypes[pattern[i]] & ctype_word) ) - valid=0; - } - if (!valid) - { - /* XXX should include the text of the reference */ - PyErr_SetString(ErrorObject, "illegal symbolic reference"); - return NULL; - } + { + 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); + break; + case('n'): + *indexptr = index; + return Py_BuildValue("c", (char)10); + break; + case('v'): + *indexptr = index; + return Py_BuildValue("c", (char)11); + break; + case('r'): + *indexptr = index; + return Py_BuildValue("c", (char)13); + break; + case('f'): + *indexptr = index; + return Py_BuildValue("c", (char)12); + break; + case('a'): + *indexptr = index; + return Py_BuildValue("c", (char)7); + break; + case('b'): + *indexptr=index; + return Py_BuildValue("c", (char)8); + break; + + 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); + } + break; + + case('E'): case('G'): case('L'): case('Q'): + case('U'): case('l'): case('u'): + { + char message[50]; + sprintf(message, "\\%c is not allowed", c); + PyErr_SetString(ErrorObject, message); + return NULL; + } + + case('g'): + { + int end, i; + 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_word) /* First char. not alphanumeric */ + || (pcre_ctypes[pattern[index]] & ctype_digit) ) /* First char. a digit */ + { + /* XXX should include the text of the reference */ + PyErr_SetString(ErrorObject, "first character of symbolic reference not a letter or _"); + return NULL; + } + + for(i=index+1; i<end; i++) + { + 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; - return Py_BuildValue("s#", pattern+index, end-index); - } - break; - - 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); - } - break; - 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'); - } - } - break; - - default: - *indexptr = index; - return Py_BuildValue("c", c); + *indexptr = end+1; + return Py_BuildValue("s#", pattern+index, end-index); + } + break; + + 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); + } + break; + 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'); + } + } break; - } + + default: + *indexptr = index; + return Py_BuildValue("c", c); + break; + } } static PyObject * @@ -475,117 +475,127 @@ PyPcre_expand(self, args) 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", &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 *results, *match_obj; + PyObject *repl_obj, *newstring; + unsigned char *repl; + int size, total_len, i, start, pos; + + if (!PyArg_ParseTuple(args, "OS", &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) + { + PyList_Append(results, + PyString_FromStringAndSize((char *)repl+start, i-start)); + 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"); + 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 trigged an exception of some sort */ + Py_DECREF(results); + Py_DECREF(value); + return NULL; + } + if (result==Py_None) + { + char message[50]; + sprintf(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; + 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) { - PyObject *value; - int escape_type; - - if (start!=i) - { - PyList_Append(results, - PyString_FromStringAndSize((char *)repl+start, i-start)); - 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"); - 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 trigged an exception of some sort */ - Py_DECREF(results); - return NULL; - } - if (result==Py_None) - { - char message[50]; - sprintf(message, - "group %li did not contribute to the match", - PyInt_AsLong(value)); - PyErr_SetString(ErrorObject, - message); - Py_DECREF(result); - Py_DECREF(results); - return NULL; - } - /* XXX typecheck that it's a string! */ - PyList_Append(results, result); - total_len += PyString_Size(result); - Py_DECREF(result); - } - break; - default: - Py_DECREF(results); - PyErr_SetString(ErrorObject, - "bad escape in replacement"); - return NULL; - } - start=i; - i--; /* Decrement now, because the 'for' loop will increment it */ + PyList_Append(results, PyString_FromStringAndSize((char *)repl+start, i-start)); + total_len += i-start; } - } /* endif repl[i]!='\\' */ - - if (start!=i) - { - PyList_Append(results, PyString_FromStringAndSize((char *)repl+start, i-start)); - 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. */ + + /* 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; + 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; } @@ -642,67 +652,7 @@ initpcre() insint(d, "MULTILINE", PCRE_MULTILINE); insint(d, "DOTALL", PCRE_DOTALL); insint(d, "VERBOSE", PCRE_EXTENDED); - - /* Insert the opcodes */ - insint(d, "OP_END", OP_END); - insint(d, "OP_SOD", OP_SOD); - insint(d, "OP_NOT_WORD_BOUNDARY", OP_NOT_WORD_BOUNDARY); - insint(d, "OP_WORD_BOUNDARY", OP_WORD_BOUNDARY); - insint(d, "OP_NOT_DIGIT", OP_NOT_DIGIT); - insint(d, "OP_NOT_WHITESPACE", OP_NOT_WHITESPACE); - insint(d, "OP_WHITESPACE", OP_WHITESPACE); - insint(d, "OP_NOT_WORDCHAR", OP_NOT_WORDCHAR); - insint(d, "OP_WORDCHAR", OP_WORDCHAR); - insint(d, "OP_EOD", OP_EOD); - insint(d, "OP_CIRC", OP_CIRC); - insint(d, "OP_DOLL", OP_DOLL); - insint(d, "OP_ANY", OP_ANY); - insint(d, "OP_CHARS", OP_CHARS); - - insint(d, "OP_STAR", OP_STAR); - insint(d, "OP_MINSTAR", OP_MINSTAR); - insint(d, "OP_PLUS", OP_PLUS); - insint(d, "OP_MINPLUS", OP_MINPLUS); - insint(d, "OP_QUERY", OP_QUERY); - insint(d, "OP_MINQUERY", OP_MINQUERY); - insint(d, "OP_UPTO", OP_UPTO); - insint(d, "OP_MINUPTO", OP_MINUPTO); - insint(d, "OP_EXACT", OP_EXACT); - - insint(d, "OP_TYPESTAR", OP_TYPESTAR); - insint(d, "OP_TYPEMINSTAR", OP_TYPEMINSTAR); - insint(d, "OP_TYPEPLUS", OP_TYPEPLUS); - insint(d, "OP_TYPEMINPLUS", OP_TYPEMINPLUS); - insint(d, "OP_TYPEQUERY", OP_TYPEQUERY); - insint(d, "OP_TYPEMINQUERY", OP_TYPEMINQUERY); - insint(d, "OP_TYPEUPTO", OP_TYPEUPTO); - insint(d, "OP_TYPEMINUPTO", OP_TYPEMINUPTO); - insint(d, "OP_TYPEEXACT", OP_TYPEEXACT); - - insint(d, "OP_CRSTAR", OP_CRSTAR); - insint(d, "OP_CRMINSTAR", OP_CRMINSTAR); - insint(d, "OP_CRPLUS", OP_CRPLUS); - insint(d, "OP_CRMINPLUS", OP_CRMINPLUS); - insint(d, "OP_CRQUERY", OP_CRQUERY); - insint(d, "OP_CRMINQUERY", OP_CRMINQUERY); - insint(d, "OP_CRRANGE", OP_CRRANGE); - insint(d, "OP_CRMINRANGE", OP_CRMINRANGE); - - insint(d, "OP_CLASS", OP_CLASS); - insint(d, "OP_NEGCLASS", OP_NEGCLASS); - insint(d, "OP_REF", OP_REF); - - insint(d, "OP_ALT", OP_ALT); - insint(d, "OP_KET", OP_KET); - insint(d, "OP_KETRMAX", OP_KETRMAX); - insint(d, "OP_KETRMIN", OP_KETRMIN); - - insint(d, "OP_ASSERT", OP_ASSERT); - insint(d, "OP_ASSERT_NOT", OP_ASSERT_NOT); - - insint(d, "OP_BRAZERO", OP_BRAZERO); - insint(d, "OP_BRAMINZERO", OP_BRAMINZERO); - insint(d, "OP_BRA", OP_BRA); + insint(d, "LOCALE", PCRE_LOCALE); /* Check for errors */ if (PyErr_Occurred()) |