File:  [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre / pcreposix.c
Revision 1.1.1.4 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Mon Jul 22 08:25:55 2013 UTC (10 years, 11 months ago) by misho
Branches: pcre, MAIN
CVS tags: v8_33, HEAD
8.33

    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-2012 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:   REG_BADPAT,  /* disallowed UTF-8/16/32 code point (>= 0xd800 && <= 0xdfff) */
  161:   REG_BADPAT,  /* invalid UTF-16 string (should not occur) */
  162:   /* 75 */
  163:   REG_BADPAT,  /* overlong MARK name */
  164:   REG_BADPAT,  /* character value in \u.... sequence is too large */
  165:   REG_BADPAT,  /* invalid UTF-32 string (should not occur) */
  166:   REG_BADPAT   /* setting UTF is disabled by the application */
  167: };
  168: 
  169: /* Table of texts corresponding to POSIX error codes */
  170: 
  171: static const char *const pstring[] = {
  172:   "",                                /* Dummy for value 0 */
  173:   "internal error",                  /* REG_ASSERT */
  174:   "invalid repeat counts in {}",     /* BADBR      */
  175:   "pattern error",                   /* BADPAT     */
  176:   "? * + invalid",                   /* BADRPT     */
  177:   "unbalanced {}",                   /* EBRACE     */
  178:   "unbalanced []",                   /* EBRACK     */
  179:   "collation error - not relevant",  /* ECOLLATE   */
  180:   "bad class",                       /* ECTYPE     */
  181:   "bad escape sequence",             /* EESCAPE    */
  182:   "empty expression",                /* EMPTY      */
  183:   "unbalanced ()",                   /* EPAREN     */
  184:   "bad range inside []",             /* ERANGE     */
  185:   "expression too big",              /* ESIZE      */
  186:   "failed to get memory",            /* ESPACE     */
  187:   "bad back reference",              /* ESUBREG    */
  188:   "bad argument",                    /* INVARG     */
  189:   "match failed"                     /* NOMATCH    */
  190: };
  191: 
  192: 
  193: 
  194: 
  195: /*************************************************
  196: *          Translate error code to string        *
  197: *************************************************/
  198: 
  199: PCREPOSIX_EXP_DEFN size_t PCRE_CALL_CONVENTION
  200: regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
  201: {
  202: const char *message, *addmessage;
  203: size_t length, addlength;
  204: 
  205: message = (errcode >= (int)(sizeof(pstring)/sizeof(char *)))?
  206:   "unknown error code" : pstring[errcode];
  207: length = strlen(message) + 1;
  208: 
  209: addmessage = " at offset ";
  210: addlength = (preg != NULL && (int)preg->re_erroffset != -1)?
  211:   strlen(addmessage) + 6 : 0;
  212: 
  213: if (errbuf_size > 0)
  214:   {
  215:   if (addlength > 0 && errbuf_size >= length + addlength)
  216:     sprintf(errbuf, "%s%s%-6d", message, addmessage, (int)preg->re_erroffset);
  217:   else
  218:     {
  219:     strncpy(errbuf, message, errbuf_size - 1);
  220:     errbuf[errbuf_size-1] = 0;
  221:     }
  222:   }
  223: 
  224: return length + addlength;
  225: }
  226: 
  227: 
  228: 
  229: 
  230: /*************************************************
  231: *           Free store held by a regex           *
  232: *************************************************/
  233: 
  234: PCREPOSIX_EXP_DEFN void PCRE_CALL_CONVENTION
  235: regfree(regex_t *preg)
  236: {
  237: (PUBL(free))(preg->re_pcre);
  238: }
  239: 
  240: 
  241: 
  242: 
  243: /*************************************************
  244: *            Compile a regular expression        *
  245: *************************************************/
  246: 
  247: /*
  248: Arguments:
  249:   preg        points to a structure for recording the compiled expression
  250:   pattern     the pattern to compile
  251:   cflags      compilation flags
  252: 
  253: Returns:      0 on success
  254:               various non-zero codes on failure
  255: */
  256: 
  257: PCREPOSIX_EXP_DEFN int PCRE_CALL_CONVENTION
  258: regcomp(regex_t *preg, const char *pattern, int cflags)
  259: {
  260: const char *errorptr;
  261: int erroffset;
  262: int errorcode;
  263: int options = 0;
  264: int re_nsub = 0;
  265: 
  266: if ((cflags & REG_ICASE) != 0)    options |= PCRE_CASELESS;
  267: if ((cflags & REG_NEWLINE) != 0)  options |= PCRE_MULTILINE;
  268: if ((cflags & REG_DOTALL) != 0)   options |= PCRE_DOTALL;
  269: if ((cflags & REG_NOSUB) != 0)    options |= PCRE_NO_AUTO_CAPTURE;
  270: if ((cflags & REG_UTF8) != 0)     options |= PCRE_UTF8;
  271: if ((cflags & REG_UCP) != 0)      options |= PCRE_UCP;
  272: if ((cflags & REG_UNGREEDY) != 0) options |= PCRE_UNGREEDY;
  273: 
  274: preg->re_pcre = pcre_compile2(pattern, options, &errorcode, &errorptr,
  275:   &erroffset, NULL);
  276: preg->re_erroffset = erroffset;
  277: 
  278: /* Safety: if the error code is too big for the translation vector (which
  279: should not happen, but we all make mistakes), return REG_BADPAT. */
  280: 
  281: if (preg->re_pcre == NULL)
  282:   {
  283:   return (errorcode < (int)(sizeof(eint)/sizeof(const int)))?
  284:     eint[errorcode] : REG_BADPAT;
  285:   }
  286: 
  287: (void)pcre_fullinfo((const pcre *)preg->re_pcre, NULL, PCRE_INFO_CAPTURECOUNT,
  288:   &re_nsub);
  289: preg->re_nsub = (size_t)re_nsub;
  290: return 0;
  291: }
  292: 
  293: 
  294: 
  295: 
  296: /*************************************************
  297: *              Match a regular expression        *
  298: *************************************************/
  299: 
  300: /* Unfortunately, PCRE requires 3 ints of working space for each captured
  301: substring, so we have to get and release working store instead of just using
  302: the POSIX structures as was done in earlier releases when PCRE needed only 2
  303: ints. However, if the number of possible capturing brackets is small, use a
  304: block of store on the stack, to reduce the use of malloc/free. The threshold is
  305: in a macro that can be changed at configure time.
  306: 
  307: If REG_NOSUB was specified at compile time, the PCRE_NO_AUTO_CAPTURE flag will
  308: be set. When this is the case, the nmatch and pmatch arguments are ignored, and
  309: the only result is yes/no/error. */
  310: 
  311: PCREPOSIX_EXP_DEFN int PCRE_CALL_CONVENTION
  312: regexec(const regex_t *preg, const char *string, size_t nmatch,
  313:   regmatch_t pmatch[], int eflags)
  314: {
  315: int rc, so, eo;
  316: int options = 0;
  317: int *ovector = NULL;
  318: int small_ovector[POSIX_MALLOC_THRESHOLD * 3];
  319: BOOL allocated_ovector = FALSE;
  320: BOOL nosub =
  321:   (REAL_PCRE_OPTIONS((const pcre *)preg->re_pcre) & PCRE_NO_AUTO_CAPTURE) != 0;
  322: 
  323: if ((eflags & REG_NOTBOL) != 0) options |= PCRE_NOTBOL;
  324: if ((eflags & REG_NOTEOL) != 0) options |= PCRE_NOTEOL;
  325: if ((eflags & REG_NOTEMPTY) != 0) options |= PCRE_NOTEMPTY;
  326: 
  327: ((regex_t *)preg)->re_erroffset = (size_t)(-1);  /* Only has meaning after compile */
  328: 
  329: /* When no string data is being returned, or no vector has been passed in which
  330: to put it, ensure that nmatch is zero. Otherwise, ensure the vector for holding
  331: the return data is large enough. */
  332: 
  333: if (nosub || pmatch == NULL) nmatch = 0;
  334: 
  335: else if (nmatch > 0)
  336:   {
  337:   if (nmatch <= POSIX_MALLOC_THRESHOLD)
  338:     {
  339:     ovector = &(small_ovector[0]);
  340:     }
  341:   else
  342:     {
  343:     if (nmatch > INT_MAX/(sizeof(int) * 3)) return REG_ESPACE;
  344:     ovector = (int *)malloc(sizeof(int) * nmatch * 3);
  345:     if (ovector == NULL) return REG_ESPACE;
  346:     allocated_ovector = TRUE;
  347:     }
  348:   }
  349: 
  350: /* REG_STARTEND is a BSD extension, to allow for non-NUL-terminated strings.
  351: The man page from OS X says "REG_STARTEND affects only the location of the
  352: string, not how it is matched". That is why the "so" value is used to bump the
  353: start location rather than being passed as a PCRE "starting offset". */
  354: 
  355: if ((eflags & REG_STARTEND) != 0)
  356:   {
  357:   so = pmatch[0].rm_so;
  358:   eo = pmatch[0].rm_eo;
  359:   }
  360: else
  361:   {
  362:   so = 0;
  363:   eo = (int)strlen(string);
  364:   }
  365: 
  366: rc = pcre_exec((const pcre *)preg->re_pcre, NULL, string + so, (eo - so),
  367:   0, options, ovector, (int)(nmatch * 3));
  368: 
  369: if (rc == 0) rc = (int)nmatch;    /* All captured slots were filled in */
  370: 
  371: /* Successful match */
  372: 
  373: if (rc >= 0)
  374:   {
  375:   size_t i;
  376:   if (!nosub)
  377:     {
  378:     for (i = 0; i < (size_t)rc; i++)
  379:       {
  380:       pmatch[i].rm_so = ovector[i*2];
  381:       pmatch[i].rm_eo = ovector[i*2+1];
  382:       }
  383:     if (allocated_ovector) free(ovector);
  384:     for (; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;
  385:     }
  386:   return 0;
  387:   }
  388: 
  389: /* Unsuccessful match */
  390: 
  391: if (allocated_ovector) free(ovector);
  392: switch(rc)
  393:   {
  394: /* ========================================================================== */
  395:   /* These cases are never obeyed. This is a fudge that causes a compile-time
  396:   error if the vector eint, which is indexed by compile-time error number, is
  397:   not the correct length. It seems to be the only way to do such a check at
  398:   compile time, as the sizeof() operator does not work in the C preprocessor.
  399:   As all the PCRE_ERROR_xxx values are negative, we can use 0 and 1. */
  400: 
  401:   case 0:
  402:   case (sizeof(eint)/sizeof(int) == ERRCOUNT):
  403:   return REG_ASSERT;
  404: /* ========================================================================== */
  405: 
  406:   case PCRE_ERROR_NOMATCH: return REG_NOMATCH;
  407:   case PCRE_ERROR_NULL: return REG_INVARG;
  408:   case PCRE_ERROR_BADOPTION: return REG_INVARG;
  409:   case PCRE_ERROR_BADMAGIC: return REG_INVARG;
  410:   case PCRE_ERROR_UNKNOWN_NODE: return REG_ASSERT;
  411:   case PCRE_ERROR_NOMEMORY: return REG_ESPACE;
  412:   case PCRE_ERROR_MATCHLIMIT: return REG_ESPACE;
  413:   case PCRE_ERROR_BADUTF8: return REG_INVARG;
  414:   case PCRE_ERROR_BADUTF8_OFFSET: return REG_INVARG;
  415:   case PCRE_ERROR_BADMODE: return REG_INVARG;
  416:   default: return REG_ASSERT;
  417:   }
  418: }
  419: 
  420: /* End of pcreposix.c */

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