• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
327 if (preg->re_match_data == NULL)
328   {
329   pcre2_code_free(preg->re_pcre2_code);
330   return REG_ESPACE;
331   }
332 
333 return 0;
334 }
335 
336 
337 
338 /*************************************************
339 *              Match a regular expression        *
340 *************************************************/
341 
342 /* A suitable match_data block, large enough to hold all possible captures, was
343 obtained when the pattern was compiled, to save having to allocate and free it
344 for each match. If REG_NOSUB was specified at compile time, the nmatch and
345 pmatch arguments are ignored, and the only result is yes/no/error. */
346 
347 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_regexec(const regex_t * preg,const char * string,size_t nmatch,regmatch_t pmatch[],int eflags)348 pcre2_regexec(const regex_t *preg, const char *string, size_t nmatch,
349   regmatch_t pmatch[], int eflags)
350 {
351 int rc, so, eo;
352 int options = 0;
353 pcre2_match_data *md = (pcre2_match_data *)preg->re_match_data;
354 
355 if ((eflags & REG_NOTBOL) != 0) options |= PCRE2_NOTBOL;
356 if ((eflags & REG_NOTEOL) != 0) options |= PCRE2_NOTEOL;
357 if ((eflags & REG_NOTEMPTY) != 0) options |= PCRE2_NOTEMPTY;
358 
359 ((regex_t *)preg)->re_erroffset = (size_t)(-1);  /* Only has meaning after compile */
360 
361 /* When REG_NOSUB was specified, or if no vector has been passed in which to
362 put captured strings, ensure that nmatch is zero. This will stop any attempt to
363 write to pmatch. */
364 
365 if ((preg->re_cflags & REG_NOSUB) != 0 || pmatch == NULL) nmatch = 0;
366 
367 /* REG_STARTEND is a BSD extension, to allow for non-NUL-terminated strings.
368 The man page from OS X says "REG_STARTEND affects only the location of the
369 string, not how it is matched". That is why the "so" value is used to bump the
370 start location rather than being passed as a PCRE2 "starting offset". */
371 
372 if ((eflags & REG_STARTEND) != 0)
373   {
374   if (pmatch == NULL) return REG_INVARG;
375   so = pmatch[0].rm_so;
376   eo = pmatch[0].rm_eo;
377   }
378 else
379   {
380   so = 0;
381   eo = (int)strlen(string);
382   }
383 
384 rc = pcre2_match((const pcre2_code *)preg->re_pcre2_code,
385   (PCRE2_SPTR)string + so, (eo - so), 0, options, md, NULL);
386 
387 /* Successful match */
388 
389 if (rc >= 0)
390   {
391   size_t i;
392   PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(md);
393   if ((size_t)rc > nmatch) rc = (int)nmatch;
394   for (i = 0; i < (size_t)rc; i++)
395     {
396     pmatch[i].rm_so = (ovector[i*2] == PCRE2_UNSET)? -1 :
397       (int)(ovector[i*2] + so);
398     pmatch[i].rm_eo = (ovector[i*2+1] == PCRE2_UNSET)? -1 :
399       (int)(ovector[i*2+1] + so);
400     }
401   for (; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;
402   return 0;
403   }
404 
405 /* Unsuccessful match */
406 
407 if (rc <= PCRE2_ERROR_UTF8_ERR1 && rc >= PCRE2_ERROR_UTF8_ERR21)
408   return REG_INVARG;
409 
410 switch(rc)
411   {
412   default: return REG_ASSERT;
413   case PCRE2_ERROR_BADMODE: return REG_INVARG;
414   case PCRE2_ERROR_BADMAGIC: return REG_INVARG;
415   case PCRE2_ERROR_BADOPTION: return REG_INVARG;
416   case PCRE2_ERROR_BADUTFOFFSET: return REG_INVARG;
417   case PCRE2_ERROR_MATCHLIMIT: return REG_ESPACE;
418   case PCRE2_ERROR_NOMATCH: return REG_NOMATCH;
419   case PCRE2_ERROR_NOMEMORY: return REG_ESPACE;
420   case PCRE2_ERROR_NULL: return REG_INVARG;
421   }
422 }
423 
424 /* End of pcre2posix.c */
425