1 /*************************************************
2 * Perl-Compatible Regular Expressions *
3 *************************************************/
4
5 /* 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
8 Written by Philip Hazel
9 Original API code Copyright (c) 1997-2012 University of Cambridge
10 New API code Copyright (c) 2016-2019 University of Cambridge
11
12 -----------------------------------------------------------------------------
13 Redistribution and use in source and binary forms, with or without
14 modification, are permitted provided that the following conditions are met:
15
16 * Redistributions of source code must retain the above copyright notice,
17 this list of conditions and the following disclaimer.
18
19 * Redistributions in binary form must reproduce the above copyright
20 notice, this list of conditions and the following disclaimer in the
21 documentation and/or other materials provided with the distribution.
22
23 * Neither the name of the University of Cambridge nor the names of its
24 contributors may be used to endorse or promote products derived from
25 this software without specific prior written permission.
26
27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 POSSIBILITY OF SUCH DAMAGE.
38 -----------------------------------------------------------------------------
39 */
40
41
42 /* This module is a wrapper that provides a POSIX API to the underlying PCRE2
43 functions. The operative functions are called pcre2_regcomp(), etc., with
44 wrappers that use the plain POSIX names. In addition, pcre2posix.h defines the
45 POSIX names as macros for the pcre2_xxx functions, so any program that includes
46 it and uses the POSIX names will call the base functions directly. This makes
47 it easier for an application to be sure it gets the PCRE2 versions in the
48 presence of other POSIX regex libraries. */
49
50
51 #ifdef HAVE_CONFIG_H
52 #include "config.h"
53 #endif
54
55
56 /* Ensure that the PCRE2POSIX_EXP_xxx macros are set appropriately for
57 compiling these functions. This must come before including pcre2posix.h, where
58 they are set for an application (using these functions) if they have not
59 previously been set. */
60
61 #if defined(_WIN32) && !defined(PCRE2_STATIC)
62 # define PCRE2POSIX_EXP_DECL extern __declspec(dllexport)
63 # define PCRE2POSIX_EXP_DEFN __declspec(dllexport)
64 #endif
65
66 /* Older versions of MSVC lack snprintf(). This define allows for
67 warning/error-free compilation and testing with MSVC compilers back to at least
68 MSVC 10/2010. Except for VC6 (which is missing some fundamentals and fails). */
69
70 #if defined(_MSC_VER) && (_MSC_VER < 1900)
71 #define snprintf _snprintf
72 #endif
73
74
75 /* Compile-time error numbers start at this value. It should probably never be
76 changed. This #define is a copy of the one in pcre2_internal.h. */
77
78 #define COMPILE_ERROR_BASE 100
79
80
81 /* Standard C headers */
82
83 #include <ctype.h>
84 #include <limits.h>
85 #include <stddef.h>
86 #include <stdio.h>
87 #include <stdlib.h>
88 #include <string.h>
89
90 /* PCRE2 headers */
91
92 #include "pcre2.h"
93 #include "pcre2posix.h"
94
95 /* When compiling with the MSVC compiler, it is sometimes necessary to include
96 a "calling convention" before exported function names. (This is secondhand
97 information; I know nothing about MSVC myself). For example, something like
98
99 void __cdecl function(....)
100
101 might be needed. In order to make this easy, all the exported functions have
102 PCRE2_CALL_CONVENTION just before their names. It is rarely needed; if not
103 set, we ensure here that it has no effect. */
104
105 #ifndef PCRE2_CALL_CONVENTION
106 #define PCRE2_CALL_CONVENTION
107 #endif
108
109 /* Table to translate PCRE2 compile time error codes into POSIX error codes.
110 Only a few PCRE2 errors with a value greater than 23 turn into special POSIX
111 codes: most go to REG_BADPAT. The second table lists, in pairs, those that
112 don't. */
113
114 static const int eint1[] = {
115 0, /* No error */
116 REG_EESCAPE, /* \ at end of pattern */
117 REG_EESCAPE, /* \c at end of pattern */
118 REG_EESCAPE, /* unrecognized character follows \ */
119 REG_BADBR, /* numbers out of order in {} quantifier */
120 /* 5 */
121 REG_BADBR, /* number too big in {} quantifier */
122 REG_EBRACK, /* missing terminating ] for character class */
123 REG_ECTYPE, /* invalid escape sequence in character class */
124 REG_ERANGE, /* range out of order in character class */
125 REG_BADRPT, /* nothing to repeat */
126 /* 10 */
127 REG_ASSERT, /* internal error: unexpected repeat */
128 REG_BADPAT, /* unrecognized character after (? or (?- */
129 REG_BADPAT, /* POSIX named classes are supported only within a class */
130 REG_BADPAT, /* POSIX collating elements are not supported */
131 REG_EPAREN, /* missing ) */
132 /* 15 */
133 REG_ESUBREG, /* reference to non-existent subpattern */
134 REG_INVARG, /* pattern passed as NULL */
135 REG_INVARG, /* unknown compile-time option bit(s) */
136 REG_EPAREN, /* missing ) after (?# comment */
137 REG_ESIZE, /* parentheses nested too deeply */
138 /* 20 */
139 REG_ESIZE, /* regular expression too large */
140 REG_ESPACE, /* failed to get memory */
141 REG_EPAREN, /* unmatched closing parenthesis */
142 REG_ASSERT /* internal error: code overflow */
143 };
144
145 static const int eint2[] = {
146 30, REG_ECTYPE, /* unknown POSIX class name */
147 32, REG_INVARG, /* this version of PCRE2 does not have Unicode support */
148 37, REG_EESCAPE, /* PCRE2 does not support \L, \l, \N{name}, \U, or \u */
149 56, REG_INVARG, /* internal error: unknown newline setting */
150 92, REG_INVARG, /* invalid option bits with PCRE2_LITERAL */
151 };
152
153 /* Table of texts corresponding to POSIX error codes */
154
155 static const char *const pstring[] = {
156 "", /* Dummy for value 0 */
157 "internal error", /* REG_ASSERT */
158 "invalid repeat counts in {}", /* BADBR */
159 "pattern error", /* BADPAT */
160 "? * + invalid", /* BADRPT */
161 "unbalanced {}", /* EBRACE */
162 "unbalanced []", /* EBRACK */
163 "collation error - not relevant", /* ECOLLATE */
164 "bad class", /* ECTYPE */
165 "bad escape sequence", /* EESCAPE */
166 "empty expression", /* EMPTY */
167 "unbalanced ()", /* EPAREN */
168 "bad range inside []", /* ERANGE */
169 "expression too big", /* ESIZE */
170 "failed to get memory", /* ESPACE */
171 "bad back reference", /* ESUBREG */
172 "bad argument", /* INVARG */
173 "match failed" /* NOMATCH */
174 };
175
176
177
178 /*************************************************
179 * Wrappers with traditional POSIX names *
180 *************************************************/
181
182 /* Keep defining them to preseve the ABI for applications linked to the pcre2
183 POSIX library before these names were changed into macros in pcre2posix.h.
184 This also ensures that the POSIX names are callable from languages that do not
185 include pcre2posix.h. It is vital to #undef the macro definitions from
186 pcre2posix.h! */
187
188 #undef regerror
189 PCRE2POSIX_EXP_DECL size_t regerror(int, const regex_t *, char *, size_t);
190 PCRE2POSIX_EXP_DEFN size_t PCRE2_CALL_CONVENTION
regerror(int errcode,const regex_t * preg,char * errbuf,size_t errbuf_size)191 regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
192 {
193 return pcre2_regerror(errcode, preg, errbuf, errbuf_size);
194 }
195
196 #undef regfree
197 PCRE2POSIX_EXP_DECL void regfree(regex_t *);
198 PCRE2POSIX_EXP_DEFN void PCRE2_CALL_CONVENTION
regfree(regex_t * preg)199 regfree(regex_t *preg)
200 {
201 pcre2_regfree(preg);
202 }
203
204 #undef regcomp
205 PCRE2POSIX_EXP_DECL int regcomp(regex_t *, const char *, int);
206 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
regcomp(regex_t * preg,const char * pattern,int cflags)207 regcomp(regex_t *preg, const char *pattern, int cflags)
208 {
209 return pcre2_regcomp(preg, pattern, cflags);
210 }
211
212 #undef regexec
213 PCRE2POSIX_EXP_DECL int regexec(const regex_t *, const char *, size_t,
214 regmatch_t *, int);
215 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
regexec(const regex_t * preg,const char * string,size_t nmatch,regmatch_t pmatch[],int eflags)216 regexec(const regex_t *preg, const char *string, size_t nmatch,
217 regmatch_t pmatch[], int eflags)
218 {
219 return pcre2_regexec(preg, string, nmatch, pmatch, eflags);
220 }
221
222
223
224 /*************************************************
225 * Translate error code to string *
226 *************************************************/
227
228 PCRE2POSIX_EXP_DEFN size_t PCRE2_CALL_CONVENTION
pcre2_regerror(int errcode,const regex_t * preg,char * errbuf,size_t errbuf_size)229 pcre2_regerror(int errcode, const regex_t *preg, char *errbuf,
230 size_t errbuf_size)
231 {
232 int used;
233 const char *message;
234
235 message = (errcode <= 0 || errcode >= (int)(sizeof(pstring)/sizeof(char *)))?
236 "unknown error code" : pstring[errcode];
237
238 if (preg != NULL && (int)preg->re_erroffset != -1)
239 {
240 used = snprintf(errbuf, errbuf_size, "%s at offset %-6d", message,
241 (int)preg->re_erroffset);
242 }
243 else
244 {
245 used = snprintf(errbuf, errbuf_size, "%s", message);
246 }
247
248 return used + 1;
249 }
250
251
252
253 /*************************************************
254 * Free store held by a regex *
255 *************************************************/
256
257 PCRE2POSIX_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_regfree(regex_t * preg)258 pcre2_regfree(regex_t *preg)
259 {
260 pcre2_match_data_free(preg->re_match_data);
261 pcre2_code_free(preg->re_pcre2_code);
262 }
263
264
265
266 /*************************************************
267 * Compile a regular expression *
268 *************************************************/
269
270 /*
271 Arguments:
272 preg points to a structure for recording the compiled expression
273 pattern the pattern to compile
274 cflags compilation flags
275
276 Returns: 0 on success
277 various non-zero codes on failure
278 */
279
280 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_regcomp(regex_t * preg,const char * pattern,int cflags)281 pcre2_regcomp(regex_t *preg, const char *pattern, int cflags)
282 {
283 PCRE2_SIZE erroffset;
284 PCRE2_SIZE patlen;
285 int errorcode;
286 int options = 0;
287 int re_nsub = 0;
288
289 patlen = ((cflags & REG_PEND) != 0)? (PCRE2_SIZE)(preg->re_endp - pattern) :
290 PCRE2_ZERO_TERMINATED;
291
292 if ((cflags & REG_ICASE) != 0) options |= PCRE2_CASELESS;
293 if ((cflags & REG_NEWLINE) != 0) options |= PCRE2_MULTILINE;
294 if ((cflags & REG_DOTALL) != 0) options |= PCRE2_DOTALL;
295 if ((cflags & REG_NOSPEC) != 0) options |= PCRE2_LITERAL;
296 if ((cflags & REG_UTF) != 0) options |= PCRE2_UTF;
297 if ((cflags & REG_UCP) != 0) options |= PCRE2_UCP;
298 if ((cflags & REG_UNGREEDY) != 0) options |= PCRE2_UNGREEDY;
299
300 preg->re_cflags = cflags;
301 preg->re_pcre2_code = pcre2_compile((PCRE2_SPTR)pattern, patlen, options,
302 &errorcode, &erroffset, NULL);
303 preg->re_erroffset = erroffset;
304
305 if (preg->re_pcre2_code == NULL)
306 {
307 unsigned int i;
308
309 /* A negative value is a UTF error; otherwise all error codes are greater
310 than COMPILE_ERROR_BASE, but check, just in case. */
311
312 if (errorcode < COMPILE_ERROR_BASE) return REG_BADPAT;
313 errorcode -= COMPILE_ERROR_BASE;
314
315 if (errorcode < (int)(sizeof(eint1)/sizeof(const int)))
316 return eint1[errorcode];
317 for (i = 0; i < sizeof(eint2)/sizeof(const int); i += 2)
318 if (errorcode == eint2[i]) return eint2[i+1];
319 return REG_BADPAT;
320 }
321
322 (void)pcre2_pattern_info((const pcre2_code *)preg->re_pcre2_code,
323 PCRE2_INFO_CAPTURECOUNT, &re_nsub);
324 preg->re_nsub = (size_t)re_nsub;
325 preg->re_match_data = pcre2_match_data_create(re_nsub + 1, NULL);
326 preg->re_erroffset = (size_t)(-1); /* No meaning after successful compile */
327
328 if (preg->re_match_data == NULL)
329 {
330 pcre2_code_free(preg->re_pcre2_code);
331 return REG_ESPACE;
332 }
333
334 return 0;
335 }
336
337
338
339 /*************************************************
340 * Match a regular expression *
341 *************************************************/
342
343 /* A suitable match_data block, large enough to hold all possible captures, was
344 obtained when the pattern was compiled, to save having to allocate and free it
345 for each match. If REG_NOSUB was specified at compile time, the nmatch and
346 pmatch arguments are ignored, and the only result is yes/no/error. */
347
348 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_regexec(const regex_t * preg,const char * string,size_t nmatch,regmatch_t pmatch[],int eflags)349 pcre2_regexec(const regex_t *preg, const char *string, size_t nmatch,
350 regmatch_t pmatch[], int eflags)
351 {
352 int rc, so, eo;
353 int options = 0;
354 pcre2_match_data *md = (pcre2_match_data *)preg->re_match_data;
355
356 if ((eflags & REG_NOTBOL) != 0) options |= PCRE2_NOTBOL;
357 if ((eflags & REG_NOTEOL) != 0) options |= PCRE2_NOTEOL;
358 if ((eflags & REG_NOTEMPTY) != 0) options |= PCRE2_NOTEMPTY;
359
360 /* When REG_NOSUB was specified, or if no vector has been passed in which to
361 put captured strings, ensure that nmatch is zero. This will stop any attempt to
362 write to pmatch. */
363
364 if ((preg->re_cflags & REG_NOSUB) != 0 || pmatch == NULL) nmatch = 0;
365
366 /* REG_STARTEND is a BSD extension, to allow for non-NUL-terminated strings.
367 The man page from OS X says "REG_STARTEND affects only the location of the
368 string, not how it is matched". That is why the "so" value is used to bump the
369 start location rather than being passed as a PCRE2 "starting offset". */
370
371 if ((eflags & REG_STARTEND) != 0)
372 {
373 if (pmatch == NULL) return REG_INVARG;
374 so = pmatch[0].rm_so;
375 eo = pmatch[0].rm_eo;
376 }
377 else
378 {
379 so = 0;
380 eo = (int)strlen(string);
381 }
382
383 rc = pcre2_match((const pcre2_code *)preg->re_pcre2_code,
384 (PCRE2_SPTR)string + so, (eo - so), 0, options, md, NULL);
385
386 /* Successful match */
387
388 if (rc >= 0)
389 {
390 size_t i;
391 PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(md);
392 if ((size_t)rc > nmatch) rc = (int)nmatch;
393 for (i = 0; i < (size_t)rc; i++)
394 {
395 pmatch[i].rm_so = (ovector[i*2] == PCRE2_UNSET)? -1 :
396 (int)(ovector[i*2] + so);
397 pmatch[i].rm_eo = (ovector[i*2+1] == PCRE2_UNSET)? -1 :
398 (int)(ovector[i*2+1] + so);
399 }
400 for (; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;
401 return 0;
402 }
403
404 /* Unsuccessful match */
405
406 if (rc <= PCRE2_ERROR_UTF8_ERR1 && rc >= PCRE2_ERROR_UTF8_ERR21)
407 return REG_INVARG;
408
409 switch(rc)
410 {
411 default: return REG_ASSERT;
412 case PCRE2_ERROR_BADMODE: return REG_INVARG;
413 case PCRE2_ERROR_BADMAGIC: return REG_INVARG;
414 case PCRE2_ERROR_BADOPTION: return REG_INVARG;
415 case PCRE2_ERROR_BADUTFOFFSET: return REG_INVARG;
416 case PCRE2_ERROR_MATCHLIMIT: return REG_ESPACE;
417 case PCRE2_ERROR_NOMATCH: return REG_NOMATCH;
418 case PCRE2_ERROR_NOMEMORY: return REG_ESPACE;
419 case PCRE2_ERROR_NULL: return REG_INVARG;
420 }
421 }
422
423 /* End of pcre2posix.c */
424