/[pcre]/code/trunk/pcreposix.c
ViewVC logotype

Contents of /code/trunk/pcreposix.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 93 - (hide annotations) (download)
Sat Feb 24 21:41:42 2007 UTC (7 years, 9 months ago) by nigel
File MIME type: text/plain
File size: 11801 byte(s)
Load pcre-7.0 into code/trunk.

1 nigel 3 /*************************************************
2     * Perl-Compatible Regular Expressions *
3     *************************************************/
4    
5 nigel 77 /* PCRE is a library of functions to support regular expressions whose syntax
6     and semantics are as close as possible to those of the Perl 5 language.
7 nigel 3
8 nigel 77 Written by Philip Hazel
9 nigel 87 Copyright (c) 1997-2006 University of Cambridge
10 nigel 3
11     -----------------------------------------------------------------------------
12 nigel 75 Redistribution and use in source and binary forms, with or without
13     modification, are permitted provided that the following conditions are met:
14 nigel 3
15 nigel 75 * Redistributions of source code must retain the above copyright notice,
16     this list of conditions and the following disclaimer.
17 nigel 3
18 nigel 75 * Redistributions in binary form must reproduce the above copyright
19     notice, this list of conditions and the following disclaimer in the
20     documentation and/or other materials provided with the distribution.
21 nigel 3
22 nigel 75 * Neither the name of the University of Cambridge nor the names of its
23     contributors may be used to endorse or promote products derived from
24     this software without specific prior written permission.
25 nigel 29
26 nigel 75 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29     ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30     LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36     POSSIBILITY OF SUCH DAMAGE.
37 nigel 3 -----------------------------------------------------------------------------
38     */
39    
40 nigel 77
41     /* This module is a wrapper that provides a POSIX API to the underlying PCRE
42     functions. */
43    
44    
45     #include "pcre_internal.h"
46 nigel 3 #include "pcreposix.h"
47     #include "stdlib.h"
48    
49    
50    
51 nigel 77 /* Table to translate PCRE compile time error codes into POSIX error codes. */
52 nigel 3
53 nigel 73 static const int eint[] = {
54 nigel 77 0, /* no error */
55     REG_EESCAPE, /* \ at end of pattern */
56     REG_EESCAPE, /* \c at end of pattern */
57     REG_EESCAPE, /* unrecognized character follows \ */
58     REG_BADBR, /* numbers out of order in {} quantifier */
59     REG_BADBR, /* number too big in {} quantifier */
60     REG_EBRACK, /* missing terminating ] for character class */
61     REG_ECTYPE, /* invalid escape sequence in character class */
62     REG_ERANGE, /* range out of order in character class */
63     REG_BADRPT, /* nothing to repeat */
64     REG_BADRPT, /* operand of unlimited repeat could match the empty string */
65     REG_ASSERT, /* internal error: unexpected repeat */
66     REG_BADPAT, /* unrecognized character after (? */
67     REG_BADPAT, /* POSIX named classes are supported only within a class */
68     REG_EPAREN, /* missing ) */
69     REG_ESUBREG, /* reference to non-existent subpattern */
70     REG_INVARG, /* erroffset passed as NULL */
71     REG_INVARG, /* unknown option bit(s) set */
72     REG_EPAREN, /* missing ) after comment */
73     REG_ESIZE, /* parentheses nested too deeply */
74     REG_ESIZE, /* regular expression too large */
75     REG_ESPACE, /* failed to get memory */
76     REG_EPAREN, /* unmatched brackets */
77     REG_ASSERT, /* internal error: code overflow */
78     REG_BADPAT, /* unrecognized character after (?< */
79     REG_BADPAT, /* lookbehind assertion is not fixed length */
80 nigel 91 REG_BADPAT, /* malformed number or name after (?( */
81 nigel 93 REG_BADPAT, /* conditional group contains more than two branches */
82 nigel 77 REG_BADPAT, /* assertion expected after (?( */
83     REG_BADPAT, /* (?R or (?digits must be followed by ) */
84     REG_ECTYPE, /* unknown POSIX class name */
85     REG_BADPAT, /* POSIX collating elements are not supported */
86     REG_INVARG, /* this version of PCRE is not compiled with PCRE_UTF8 support */
87     REG_BADPAT, /* spare error */
88     REG_BADPAT, /* character value in \x{...} sequence is too large */
89     REG_BADPAT, /* invalid condition (?(0) */
90     REG_BADPAT, /* \C not allowed in lookbehind assertion */
91     REG_EESCAPE, /* PCRE does not support \L, \l, \N, \U, or \u */
92     REG_BADPAT, /* number after (?C is > 255 */
93     REG_BADPAT, /* closing ) for (?C expected */
94     REG_BADPAT, /* recursive call could loop indefinitely */
95     REG_BADPAT, /* unrecognized character after (?P */
96 nigel 93 REG_BADPAT, /* syntax error in subpattern name (missing terminator) */
97 nigel 91 REG_BADPAT, /* two named subpatterns have the same name */
98 nigel 77 REG_BADPAT, /* invalid UTF-8 string */
99     REG_BADPAT, /* support for \P, \p, and \X has not been compiled */
100     REG_BADPAT, /* malformed \P or \p sequence */
101 nigel 91 REG_BADPAT, /* unknown property name after \P or \p */
102     REG_BADPAT, /* subpattern name is too long (maximum 32 characters) */
103     REG_BADPAT, /* too many named subpatterns (maximum 10,000) */
104     REG_BADPAT, /* repeated subpattern is too long */
105 nigel 93 REG_BADPAT, /* octal value is greater than \377 (not in UTF-8 mode) */
106     REG_BADPAT, /* internal error: overran compiling workspace */
107     REG_BADPAT, /* internal error: previously-checked referenced subpattern not found */
108     REG_BADPAT, /* DEFINE group contains more than one branch */
109     REG_BADPAT, /* repeating a DEFINE group is not allowed */
110     REG_INVARG, /* inconsistent NEWLINE options */
111     REG_BADPAT /* \g is not followed followed by an (optionally braced) non-zero number */
112 nigel 3 };
113    
114     /* Table of texts corresponding to POSIX error codes */
115    
116 nigel 73 static const char *const pstring[] = {
117 nigel 3 "", /* Dummy for value 0 */
118     "internal error", /* REG_ASSERT */
119     "invalid repeat counts in {}", /* BADBR */
120     "pattern error", /* BADPAT */
121     "? * + invalid", /* BADRPT */
122     "unbalanced {}", /* EBRACE */
123     "unbalanced []", /* EBRACK */
124     "collation error - not relevant", /* ECOLLATE */
125     "bad class", /* ECTYPE */
126     "bad escape sequence", /* EESCAPE */
127     "empty expression", /* EMPTY */
128     "unbalanced ()", /* EPAREN */
129     "bad range inside []", /* ERANGE */
130     "expression too big", /* ESIZE */
131     "failed to get memory", /* ESPACE */
132     "bad back reference", /* ESUBREG */
133     "bad argument", /* INVARG */
134     "match failed" /* NOMATCH */
135     };
136    
137    
138    
139    
140     /*************************************************
141     * Translate error code to string *
142     *************************************************/
143    
144 nigel 87 PCRE_DATA_SCOPE size_t
145 nigel 3 regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
146     {
147 nigel 7 const char *message, *addmessage;
148     size_t length, addlength;
149 nigel 3
150 nigel 7 message = (errcode >= (int)(sizeof(pstring)/sizeof(char *)))?
151 nigel 3 "unknown error code" : pstring[errcode];
152 nigel 7 length = strlen(message) + 1;
153 nigel 3
154 nigel 7 addmessage = " at offset ";
155     addlength = (preg != NULL && (int)preg->re_erroffset != -1)?
156     strlen(addmessage) + 6 : 0;
157 nigel 3
158     if (errbuf_size > 0)
159     {
160 nigel 7 if (addlength > 0 && errbuf_size >= length + addlength)
161 nigel 23 sprintf(errbuf, "%s%s%-6d", message, addmessage, (int)preg->re_erroffset);
162 nigel 3 else
163     {
164     strncpy(errbuf, message, errbuf_size - 1);
165     errbuf[errbuf_size-1] = 0;
166     }
167     }
168    
169 nigel 7 return length + addlength;
170 nigel 3 }
171    
172    
173    
174    
175     /*************************************************
176     * Free store held by a regex *
177     *************************************************/
178    
179 nigel 87 PCRE_DATA_SCOPE void
180 nigel 3 regfree(regex_t *preg)
181     {
182     (pcre_free)(preg->re_pcre);
183     }
184    
185    
186    
187    
188     /*************************************************
189     * Compile a regular expression *
190     *************************************************/
191    
192     /*
193     Arguments:
194     preg points to a structure for recording the compiled expression
195     pattern the pattern to compile
196     cflags compilation flags
197    
198     Returns: 0 on success
199     various non-zero codes on failure
200     */
201    
202 nigel 87 PCRE_DATA_SCOPE int
203 nigel 3 regcomp(regex_t *preg, const char *pattern, int cflags)
204     {
205 nigel 7 const char *errorptr;
206 nigel 3 int erroffset;
207 nigel 77 int errorcode;
208 nigel 3 int options = 0;
209    
210 nigel 87 if ((cflags & REG_ICASE) != 0) options |= PCRE_CASELESS;
211 nigel 3 if ((cflags & REG_NEWLINE) != 0) options |= PCRE_MULTILINE;
212 nigel 87 if ((cflags & REG_DOTALL) != 0) options |= PCRE_DOTALL;
213     if ((cflags & REG_NOSUB) != 0) options |= PCRE_NO_AUTO_CAPTURE;
214     if ((cflags & REG_UTF8) != 0) options |= PCRE_UTF8;
215 nigel 3
216 nigel 77 preg->re_pcre = pcre_compile2(pattern, options, &errorcode, &errorptr,
217     &erroffset, NULL);
218 nigel 3 preg->re_erroffset = erroffset;
219    
220 nigel 77 if (preg->re_pcre == NULL) return eint[errorcode];
221 nigel 3
222 nigel 71 preg->re_nsub = pcre_info((const pcre *)preg->re_pcre, NULL, NULL);
223 nigel 3 return 0;
224     }
225    
226    
227    
228    
229     /*************************************************
230     * Match a regular expression *
231     *************************************************/
232    
233 nigel 41 /* Unfortunately, PCRE requires 3 ints of working space for each captured
234     substring, so we have to get and release working store instead of just using
235     the POSIX structures as was done in earlier releases when PCRE needed only 2
236 nigel 63 ints. However, if the number of possible capturing brackets is small, use a
237     block of store on the stack, to reduce the use of malloc/free. The threshold is
238 nigel 87 in a macro that can be changed at configure time.
239 nigel 41
240 nigel 87 If REG_NOSUB was specified at compile time, the PCRE_NO_AUTO_CAPTURE flag will
241     be set. When this is the case, the nmatch and pmatch arguments are ignored, and
242     the only result is yes/no/error. */
243    
244     PCRE_DATA_SCOPE int
245 nigel 69 regexec(const regex_t *preg, const char *string, size_t nmatch,
246 nigel 3 regmatch_t pmatch[], int eflags)
247     {
248     int rc;
249     int options = 0;
250 nigel 41 int *ovector = NULL;
251 nigel 63 int small_ovector[POSIX_MALLOC_THRESHOLD * 3];
252     BOOL allocated_ovector = FALSE;
253 nigel 87 BOOL nosub =
254     (((const pcre *)preg->re_pcre)->options & PCRE_NO_AUTO_CAPTURE) != 0;
255 nigel 3
256     if ((eflags & REG_NOTBOL) != 0) options |= PCRE_NOTBOL;
257     if ((eflags & REG_NOTEOL) != 0) options |= PCRE_NOTEOL;
258    
259 nigel 69 ((regex_t *)preg)->re_erroffset = (size_t)(-1); /* Only has meaning after compile */
260 nigel 3
261 nigel 87 /* When no string data is being returned, ensure that nmatch is zero.
262     Otherwise, ensure the vector for holding the return data is large enough. */
263    
264     if (nosub) nmatch = 0;
265    
266     else if (nmatch > 0)
267 nigel 41 {
268 nigel 63 if (nmatch <= POSIX_MALLOC_THRESHOLD)
269     {
270     ovector = &(small_ovector[0]);
271     }
272     else
273     {
274 nigel 87 if (nmatch > INT_MAX/(sizeof(int) * 3)) return REG_ESPACE;
275 nigel 63 ovector = (int *)malloc(sizeof(int) * nmatch * 3);
276     if (ovector == NULL) return REG_ESPACE;
277     allocated_ovector = TRUE;
278     }
279 nigel 41 }
280    
281 nigel 71 rc = pcre_exec((const pcre *)preg->re_pcre, NULL, string, (int)strlen(string),
282     0, options, ovector, nmatch * 3);
283 nigel 3
284 nigel 41 if (rc == 0) rc = nmatch; /* All captured slots were filled in */
285 nigel 3
286 nigel 41 if (rc >= 0)
287 nigel 3 {
288 nigel 7 size_t i;
289 nigel 87 if (!nosub)
290 nigel 41 {
291 nigel 87 for (i = 0; i < (size_t)rc; i++)
292     {
293     pmatch[i].rm_so = ovector[i*2];
294     pmatch[i].rm_eo = ovector[i*2+1];
295     }
296     if (allocated_ovector) free(ovector);
297     for (; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;
298 nigel 41 }
299 nigel 3 return 0;
300     }
301    
302 nigel 41 else
303 nigel 3 {
304 nigel 63 if (allocated_ovector) free(ovector);
305 nigel 41 switch(rc)
306     {
307     case PCRE_ERROR_NOMATCH: return REG_NOMATCH;
308     case PCRE_ERROR_NULL: return REG_INVARG;
309     case PCRE_ERROR_BADOPTION: return REG_INVARG;
310     case PCRE_ERROR_BADMAGIC: return REG_INVARG;
311     case PCRE_ERROR_UNKNOWN_NODE: return REG_ASSERT;
312     case PCRE_ERROR_NOMEMORY: return REG_ESPACE;
313 nigel 73 case PCRE_ERROR_MATCHLIMIT: return REG_ESPACE;
314     case PCRE_ERROR_BADUTF8: return REG_INVARG;
315     case PCRE_ERROR_BADUTF8_OFFSET: return REG_INVARG;
316 nigel 41 default: return REG_ASSERT;
317     }
318 nigel 3 }
319     }
320    
321     /* End of pcreposix.c */

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12