Annotation of embedaddon/pcre/pcreposix.c, revision 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>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcreposix.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre