Annotation of embedaddon/pcre/pcreposix.c, revision 1.1.1.1

1.1       misho       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:            Copyright (c) 1997-2010 University of Cambridge
                     10: 
                     11: -----------------------------------------------------------------------------
                     12: Redistribution and use in source and binary forms, with or without
                     13: modification, are permitted provided that the following conditions are met:
                     14: 
                     15:     * Redistributions of source code must retain the above copyright notice,
                     16:       this list of conditions and the following disclaimer.
                     17: 
                     18:     * 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: 
                     22:     * 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: 
                     26: 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: -----------------------------------------------------------------------------
                     38: */
                     39: 
                     40: 
                     41: /* This module is a wrapper that provides a POSIX API to the underlying PCRE
                     42: functions. */
                     43: 
                     44: 
                     45: #ifdef HAVE_CONFIG_H
                     46: #include "config.h"
                     47: #endif
                     48: 
                     49: 
                     50: /* Ensure that the PCREPOSIX_EXP_xxx macros are set appropriately for
                     51: compiling these functions. This must come before including pcreposix.h, where
                     52: they are set for an application (using these functions) if they have not
                     53: previously been set. */
                     54: 
                     55: #if defined(_WIN32) && !defined(PCRE_STATIC)
                     56: #  define PCREPOSIX_EXP_DECL extern __declspec(dllexport)
                     57: #  define PCREPOSIX_EXP_DEFN __declspec(dllexport)
                     58: #endif
                     59: 
                     60: /* We include pcre.h before pcre_internal.h so that the PCRE library functions
                     61: are declared as "import" for Windows by defining PCRE_EXP_DECL as "import".
                     62: This is needed even though pcre_internal.h itself includes pcre.h, because it
                     63: does so after it has set PCRE_EXP_DECL to "export" if it is not already set. */
                     64: 
                     65: #include "pcre.h"
                     66: #include "pcre_internal.h"
                     67: #include "pcreposix.h"
                     68: 
                     69: 
                     70: /* Table to translate PCRE compile time error codes into POSIX error codes. */
                     71: 
                     72: static const int eint[] = {
                     73:   0,           /* no error */
                     74:   REG_EESCAPE, /* \ at end of pattern */
                     75:   REG_EESCAPE, /* \c at end of pattern */
                     76:   REG_EESCAPE, /* unrecognized character follows \ */
                     77:   REG_BADBR,   /* numbers out of order in {} quantifier */
                     78:   /* 5 */
                     79:   REG_BADBR,   /* number too big in {} quantifier */
                     80:   REG_EBRACK,  /* missing terminating ] for character class */
                     81:   REG_ECTYPE,  /* invalid escape sequence in character class */
                     82:   REG_ERANGE,  /* range out of order in character class */
                     83:   REG_BADRPT,  /* nothing to repeat */
                     84:   /* 10 */
                     85:   REG_BADRPT,  /* operand of unlimited repeat could match the empty string */
                     86:   REG_ASSERT,  /* internal error: unexpected repeat */
                     87:   REG_BADPAT,  /* unrecognized character after (? */
                     88:   REG_BADPAT,  /* POSIX named classes are supported only within a class */
                     89:   REG_EPAREN,  /* missing ) */
                     90:   /* 15 */
                     91:   REG_ESUBREG, /* reference to non-existent subpattern */
                     92:   REG_INVARG,  /* erroffset passed as NULL */
                     93:   REG_INVARG,  /* unknown option bit(s) set */
                     94:   REG_EPAREN,  /* missing ) after comment */
                     95:   REG_ESIZE,   /* parentheses nested too deeply */
                     96:   /* 20 */
                     97:   REG_ESIZE,   /* regular expression too large */
                     98:   REG_ESPACE,  /* failed to get memory */
                     99:   REG_EPAREN,  /* unmatched parentheses */
                    100:   REG_ASSERT,  /* internal error: code overflow */
                    101:   REG_BADPAT,  /* unrecognized character after (?< */
                    102:   /* 25 */
                    103:   REG_BADPAT,  /* lookbehind assertion is not fixed length */
                    104:   REG_BADPAT,  /* malformed number or name after (?( */
                    105:   REG_BADPAT,  /* conditional group contains more than two branches */
                    106:   REG_BADPAT,  /* assertion expected after (?( */
                    107:   REG_BADPAT,  /* (?R or (?[+-]digits must be followed by ) */
                    108:   /* 30 */
                    109:   REG_ECTYPE,  /* unknown POSIX class name */
                    110:   REG_BADPAT,  /* POSIX collating elements are not supported */
                    111:   REG_INVARG,  /* this version of PCRE is not compiled with PCRE_UTF8 support */
                    112:   REG_BADPAT,  /* spare error */
                    113:   REG_BADPAT,  /* character value in \x{...} sequence is too large */
                    114:   /* 35 */
                    115:   REG_BADPAT,  /* invalid condition (?(0) */
                    116:   REG_BADPAT,  /* \C not allowed in lookbehind assertion */
                    117:   REG_EESCAPE, /* PCRE does not support \L, \l, \N, \U, or \u */
                    118:   REG_BADPAT,  /* number after (?C is > 255 */
                    119:   REG_BADPAT,  /* closing ) for (?C expected */
                    120:   /* 40 */
                    121:   REG_BADPAT,  /* recursive call could loop indefinitely */
                    122:   REG_BADPAT,  /* unrecognized character after (?P */
                    123:   REG_BADPAT,  /* syntax error in subpattern name (missing terminator) */
                    124:   REG_BADPAT,  /* two named subpatterns have the same name */
                    125:   REG_BADPAT,  /* invalid UTF-8 string */
                    126:   /* 45 */
                    127:   REG_BADPAT,  /* support for \P, \p, and \X has not been compiled */
                    128:   REG_BADPAT,  /* malformed \P or \p sequence */
                    129:   REG_BADPAT,  /* unknown property name after \P or \p */
                    130:   REG_BADPAT,  /* subpattern name is too long (maximum 32 characters) */
                    131:   REG_BADPAT,  /* too many named subpatterns (maximum 10,000) */
                    132:   /* 50 */
                    133:   REG_BADPAT,  /* repeated subpattern is too long */
                    134:   REG_BADPAT,  /* octal value is greater than \377 (not in UTF-8 mode) */
                    135:   REG_BADPAT,  /* internal error: overran compiling workspace */
                    136:   REG_BADPAT,  /* internal error: previously-checked referenced subpattern not found */
                    137:   REG_BADPAT,  /* DEFINE group contains more than one branch */
                    138:   /* 55 */
                    139:   REG_BADPAT,  /* repeating a DEFINE group is not allowed */
                    140:   REG_INVARG,  /* inconsistent NEWLINE options */
                    141:   REG_BADPAT,  /* \g is not followed followed by an (optionally braced) non-zero number */
                    142:   REG_BADPAT,  /* a numbered reference must not be zero */
                    143:   REG_BADPAT,  /* an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT) */
                    144:   /* 60 */
                    145:   REG_BADPAT,  /* (*VERB) not recognized */
                    146:   REG_BADPAT,  /* number is too big */
                    147:   REG_BADPAT,  /* subpattern name expected */
                    148:   REG_BADPAT,  /* digit expected after (?+ */
                    149:   REG_BADPAT,  /* ] is an invalid data character in JavaScript compatibility mode */
                    150:   /* 65 */
                    151:   REG_BADPAT,  /* different names for subpatterns of the same number are not allowed */
                    152:   REG_BADPAT,  /* (*MARK) must have an argument */
                    153:   REG_INVARG,  /* this version of PCRE is not compiled with PCRE_UCP support */
                    154:   REG_BADPAT,  /* \c must be followed by an ASCII character */
                    155:   REG_BADPAT,  /* \k is not followed by a braced, angle-bracketed, or quoted name */
                    156:   /* 70 */
                    157:   REG_BADPAT,  /* internal error: unknown opcode in find_fixedlength() */
                    158:   REG_BADPAT,  /* \N is not supported in a class */
                    159:   REG_BADPAT,  /* too many forward references */
                    160: };
                    161: 
                    162: /* Table of texts corresponding to POSIX error codes */
                    163: 
                    164: static const char *const pstring[] = {
                    165:   "",                                /* Dummy for value 0 */
                    166:   "internal error",                  /* REG_ASSERT */
                    167:   "invalid repeat counts in {}",     /* BADBR      */
                    168:   "pattern error",                   /* BADPAT     */
                    169:   "? * + invalid",                   /* BADRPT     */
                    170:   "unbalanced {}",                   /* EBRACE     */
                    171:   "unbalanced []",                   /* EBRACK     */
                    172:   "collation error - not relevant",  /* ECOLLATE   */
                    173:   "bad class",                       /* ECTYPE     */
                    174:   "bad escape sequence",             /* EESCAPE    */
                    175:   "empty expression",                /* EMPTY      */
                    176:   "unbalanced ()",                   /* EPAREN     */
                    177:   "bad range inside []",             /* ERANGE     */
                    178:   "expression too big",              /* ESIZE      */
                    179:   "failed to get memory",            /* ESPACE     */
                    180:   "bad back reference",              /* ESUBREG    */
                    181:   "bad argument",                    /* INVARG     */
                    182:   "match failed"                     /* NOMATCH    */
                    183: };
                    184: 
                    185: 
                    186: 
                    187: 
                    188: /*************************************************
                    189: *          Translate error code to string        *
                    190: *************************************************/
                    191: 
                    192: PCREPOSIX_EXP_DEFN size_t PCRE_CALL_CONVENTION
                    193: regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
                    194: {
                    195: const char *message, *addmessage;
                    196: size_t length, addlength;
                    197: 
                    198: message = (errcode >= (int)(sizeof(pstring)/sizeof(char *)))?
                    199:   "unknown error code" : pstring[errcode];
                    200: length = strlen(message) + 1;
                    201: 
                    202: addmessage = " at offset ";
                    203: addlength = (preg != NULL && (int)preg->re_erroffset != -1)?
                    204:   strlen(addmessage) + 6 : 0;
                    205: 
                    206: if (errbuf_size > 0)
                    207:   {
                    208:   if (addlength > 0 && errbuf_size >= length + addlength)
                    209:     sprintf(errbuf, "%s%s%-6d", message, addmessage, (int)preg->re_erroffset);
                    210:   else
                    211:     {
                    212:     strncpy(errbuf, message, errbuf_size - 1);
                    213:     errbuf[errbuf_size-1] = 0;
                    214:     }
                    215:   }
                    216: 
                    217: return length + addlength;
                    218: }
                    219: 
                    220: 
                    221: 
                    222: 
                    223: /*************************************************
                    224: *           Free store held by a regex           *
                    225: *************************************************/
                    226: 
                    227: PCREPOSIX_EXP_DEFN void PCRE_CALL_CONVENTION
                    228: regfree(regex_t *preg)
                    229: {
                    230: (pcre_free)(preg->re_pcre);
                    231: }
                    232: 
                    233: 
                    234: 
                    235: 
                    236: /*************************************************
                    237: *            Compile a regular expression        *
                    238: *************************************************/
                    239: 
                    240: /*
                    241: Arguments:
                    242:   preg        points to a structure for recording the compiled expression
                    243:   pattern     the pattern to compile
                    244:   cflags      compilation flags
                    245: 
                    246: Returns:      0 on success
                    247:               various non-zero codes on failure
                    248: */
                    249: 
                    250: PCREPOSIX_EXP_DEFN int PCRE_CALL_CONVENTION
                    251: regcomp(regex_t *preg, const char *pattern, int cflags)
                    252: {
                    253: const char *errorptr;
                    254: int erroffset;
                    255: int errorcode;
                    256: int options = 0;
                    257: 
                    258: if ((cflags & REG_ICASE) != 0)    options |= PCRE_CASELESS;
                    259: if ((cflags & REG_NEWLINE) != 0)  options |= PCRE_MULTILINE;
                    260: if ((cflags & REG_DOTALL) != 0)   options |= PCRE_DOTALL;
                    261: if ((cflags & REG_NOSUB) != 0)    options |= PCRE_NO_AUTO_CAPTURE;
                    262: if ((cflags & REG_UTF8) != 0)     options |= PCRE_UTF8;
                    263: if ((cflags & REG_UCP) != 0)      options |= PCRE_UCP;
                    264: if ((cflags & REG_UNGREEDY) != 0) options |= PCRE_UNGREEDY;
                    265: 
                    266: preg->re_pcre = pcre_compile2(pattern, options, &errorcode, &errorptr,
                    267:   &erroffset, NULL);
                    268: preg->re_erroffset = erroffset;
                    269: 
                    270: /* Safety: if the error code is too big for the translation vector (which
                    271: should not happen, but we all make mistakes), return REG_BADPAT. */
                    272: 
                    273: if (preg->re_pcre == NULL)
                    274:   {
                    275:   return (errorcode < sizeof(eint)/sizeof(const int))?
                    276:     eint[errorcode] : REG_BADPAT;
                    277:   }
                    278: 
                    279: preg->re_nsub = pcre_info((const pcre *)preg->re_pcre, NULL, NULL);
                    280: return 0;
                    281: }
                    282: 
                    283: 
                    284: 
                    285: 
                    286: /*************************************************
                    287: *              Match a regular expression        *
                    288: *************************************************/
                    289: 
                    290: /* Unfortunately, PCRE requires 3 ints of working space for each captured
                    291: substring, so we have to get and release working store instead of just using
                    292: the POSIX structures as was done in earlier releases when PCRE needed only 2
                    293: ints. However, if the number of possible capturing brackets is small, use a
                    294: block of store on the stack, to reduce the use of malloc/free. The threshold is
                    295: in a macro that can be changed at configure time.
                    296: 
                    297: If REG_NOSUB was specified at compile time, the PCRE_NO_AUTO_CAPTURE flag will
                    298: be set. When this is the case, the nmatch and pmatch arguments are ignored, and
                    299: the only result is yes/no/error. */
                    300: 
                    301: PCREPOSIX_EXP_DEFN int PCRE_CALL_CONVENTION
                    302: regexec(const regex_t *preg, const char *string, size_t nmatch,
                    303:   regmatch_t pmatch[], int eflags)
                    304: {
                    305: int rc, so, eo;
                    306: int options = 0;
                    307: int *ovector = NULL;
                    308: int small_ovector[POSIX_MALLOC_THRESHOLD * 3];
                    309: BOOL allocated_ovector = FALSE;
                    310: BOOL nosub =
                    311:   (((const pcre *)preg->re_pcre)->options & PCRE_NO_AUTO_CAPTURE) != 0;
                    312: 
                    313: if ((eflags & REG_NOTBOL) != 0) options |= PCRE_NOTBOL;
                    314: if ((eflags & REG_NOTEOL) != 0) options |= PCRE_NOTEOL;
                    315: if ((eflags & REG_NOTEMPTY) != 0) options |= PCRE_NOTEMPTY;
                    316: 
                    317: ((regex_t *)preg)->re_erroffset = (size_t)(-1);  /* Only has meaning after compile */
                    318: 
                    319: /* When no string data is being returned, or no vector has been passed in which
                    320: to put it, ensure that nmatch is zero. Otherwise, ensure the vector for holding
                    321: the return data is large enough. */
                    322: 
                    323: if (nosub || pmatch == NULL) nmatch = 0;
                    324: 
                    325: else if (nmatch > 0)
                    326:   {
                    327:   if (nmatch <= POSIX_MALLOC_THRESHOLD)
                    328:     {
                    329:     ovector = &(small_ovector[0]);
                    330:     }
                    331:   else
                    332:     {
                    333:     if (nmatch > INT_MAX/(sizeof(int) * 3)) return REG_ESPACE;
                    334:     ovector = (int *)malloc(sizeof(int) * nmatch * 3);
                    335:     if (ovector == NULL) return REG_ESPACE;
                    336:     allocated_ovector = TRUE;
                    337:     }
                    338:   }
                    339: 
                    340: /* REG_STARTEND is a BSD extension, to allow for non-NUL-terminated strings.
                    341: The man page from OS X says "REG_STARTEND affects only the location of the
                    342: string, not how it is matched". That is why the "so" value is used to bump the
                    343: start location rather than being passed as a PCRE "starting offset". */
                    344: 
                    345: if ((eflags & REG_STARTEND) != 0)
                    346:   {
                    347:   so = pmatch[0].rm_so;
                    348:   eo = pmatch[0].rm_eo;
                    349:   }
                    350: else
                    351:   {
                    352:   so = 0;
                    353:   eo = (int)strlen(string);
                    354:   }
                    355: 
                    356: rc = pcre_exec((const pcre *)preg->re_pcre, NULL, string + so, (eo - so),
                    357:   0, options, ovector, (int)(nmatch * 3));
                    358: 
                    359: if (rc == 0) rc = (int)nmatch;    /* All captured slots were filled in */
                    360: 
                    361: /* Successful match */
                    362: 
                    363: if (rc >= 0)
                    364:   {
                    365:   size_t i;
                    366:   if (!nosub)
                    367:     {
                    368:     for (i = 0; i < (size_t)rc; i++)
                    369:       {
                    370:       pmatch[i].rm_so = ovector[i*2];
                    371:       pmatch[i].rm_eo = ovector[i*2+1];
                    372:       }
                    373:     if (allocated_ovector) free(ovector);
                    374:     for (; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;
                    375:     }
                    376:   return 0;
                    377:   }
                    378: 
                    379: /* Unsuccessful match */
                    380: 
                    381: if (allocated_ovector) free(ovector);
                    382: switch(rc)
                    383:   {
                    384: /* ========================================================================== */
                    385:   /* These cases are never obeyed. This is a fudge that causes a compile-time
                    386:   error if the vector eint, which is indexed by compile-time error number, is
                    387:   not the correct length. It seems to be the only way to do such a check at
                    388:   compile time, as the sizeof() operator does not work in the C preprocessor.
                    389:   As all the PCRE_ERROR_xxx values are negative, we can use 0 and 1. */
                    390: 
                    391:   case 0:
                    392:   case (sizeof(eint)/sizeof(int) == ERRCOUNT):
                    393:   return REG_ASSERT;
                    394: /* ========================================================================== */
                    395: 
                    396:   case PCRE_ERROR_NOMATCH: return REG_NOMATCH;
                    397:   case PCRE_ERROR_NULL: return REG_INVARG;
                    398:   case PCRE_ERROR_BADOPTION: return REG_INVARG;
                    399:   case PCRE_ERROR_BADMAGIC: return REG_INVARG;
                    400:   case PCRE_ERROR_UNKNOWN_NODE: return REG_ASSERT;
                    401:   case PCRE_ERROR_NOMEMORY: return REG_ESPACE;
                    402:   case PCRE_ERROR_MATCHLIMIT: return REG_ESPACE;
                    403:   case PCRE_ERROR_BADUTF8: return REG_INVARG;
                    404:   case PCRE_ERROR_BADUTF8_OFFSET: return REG_INVARG;
                    405:   default: return REG_ASSERT;
                    406:   }
                    407: }
                    408: 
                    409: /* End of pcreposix.c */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>