Annotation of parser3/src/lib/pcre/pcre.c, revision 1.1
1.1 ! paf 1: /*************************************************
! 2: * Perl-Compatible Regular Expressions *
! 3: *************************************************/
! 4:
! 5: /*
! 6: This is a library of functions to support regular expressions whose syntax
! 7: and semantics are as close as possible to those of the Perl 5 language. See
! 8: the file Tech.Notes for some information on the internals.
! 9:
! 10: Written by: Philip Hazel <ph10@cam.ac.uk>
! 11:
! 12: Copyright (c) 1997-1999 University of Cambridge
! 13:
! 14: -----------------------------------------------------------------------------
! 15: Permission is granted to anyone to use this software for any purpose on any
! 16: computer system, and to redistribute it freely, subject to the following
! 17: restrictions:
! 18:
! 19: 1. This software is distributed in the hope that it will be useful,
! 20: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 21: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
! 22:
! 23: 2. The origin of this software must not be misrepresented, either by
! 24: explicit claim or by omission.
! 25:
! 26: 3. Altered versions must be plainly marked as such, and must not be
! 27: misrepresented as being the original software.
! 28:
! 29: 4. If PCRE is embedded in any software that is released under the GNU
! 30: General Purpose Licence (GPL), then the terms of that licence shall
! 31: supersede any condition above with which it is incompatible.
! 32: -----------------------------------------------------------------------------
! 33: */
! 34:
! 35:
! 36: /* Define DEBUG to get debugging output on stdout. */
! 37:
! 38: /* #define DEBUG */
! 39:
! 40: /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
! 41: inline, and there are *still* stupid compilers about that don't like indented
! 42: pre-processor statements. I suppose it's only been 10 years... */
! 43:
! 44: #ifdef DEBUG
! 45: #define DPRINTF(p) printf p
! 46: #else
! 47: #define DPRINTF(p) /*nothing*/
! 48: #endif
! 49:
! 50: /* Include the internals header, which itself includes Standard C headers plus
! 51: the external pcre header. */
! 52:
! 53: #include "internal.h"
! 54:
! 55:
! 56: /* Allow compilation as C++ source code, should anybody want to do that. */
! 57:
! 58: #ifdef __cplusplus
! 59: #define class pcre_class
! 60: #endif
! 61:
! 62:
! 63: /* Number of items on the nested bracket stacks at compile time. This should
! 64: not be set greater than 200. */
! 65:
! 66: #define BRASTACK_SIZE 200
! 67:
! 68:
! 69: /* Min and max values for the common repeats; for the maxima, 0 => infinity */
! 70:
! 71: static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
! 72: static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
! 73:
! 74: /* Text forms of OP_ values and things, for debugging (not all used) */
! 75:
! 76: #ifdef DEBUG
! 77: static const char *OP_names[] = {
! 78: "End", "\\A", "\\B", "\\b", "\\D", "\\d",
! 79: "\\S", "\\s", "\\W", "\\w", "\\Z", "\\z",
! 80: "Opt", "^", "$", "Any", "chars", "not",
! 81: "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
! 82: "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
! 83: "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
! 84: "*", "*?", "+", "+?", "?", "??", "{", "{",
! 85: "class", "Ref",
! 86: "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",
! 87: "AssertB", "AssertB not", "Reverse", "Once", "Cond", "Cref",
! 88: "Brazero", "Braminzero", "Bra"
! 89: };
! 90: #endif
! 91:
! 92: /* Table for handling escaped characters in the range '0'-'z'. Positive returns
! 93: are simple data values; negative values are for special things like \d and so
! 94: on. Zero means further processing is needed (for things like \x), or the escape
! 95: is invalid. */
! 96:
! 97: static const short int escapes[] = {
! 98: 0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 7 */
! 99: 0, 0, ':', ';', '<', '=', '>', '?', /* 8 - ? */
! 100: '@', -ESC_A, -ESC_B, 0, -ESC_D, 0, 0, 0, /* @ - G */
! 101: 0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
! 102: 0, 0, 0, -ESC_S, 0, 0, 0, -ESC_W, /* P - W */
! 103: 0, 0, -ESC_Z, '[', '\\', ']', '^', '_', /* X - _ */
! 104: '`', 7, -ESC_b, 0, -ESC_d, 27, '\f', 0, /* ` - g */
! 105: 0, 0, 0, 0, 0, 0, '\n', 0, /* h - o */
! 106: 0, 0, '\r', -ESC_s, '\t', 0, 0, -ESC_w, /* p - w */
! 107: 0, 0, -ESC_z /* x - z */
! 108: };
! 109:
! 110: /* Definition to allow mutual recursion */
! 111:
! 112: static BOOL
! 113: compile_regex(int, int, int *, uschar **, const uschar **, const char **,
! 114: BOOL, int, int *, int *, compile_data *);
! 115:
! 116:
! 117:
! 118: /*************************************************
! 119: * Global variables *
! 120: *************************************************/
! 121:
! 122: /* PCRE is thread-clean and doesn't use any global variables in the normal
! 123: sense. However, it calls memory allocation and free functions via the two
! 124: indirections below, which are can be changed by the caller, but are shared
! 125: between all threads. */
! 126:
! 127: void *(*pcre_malloc)(size_t) = malloc;
! 128: void (*pcre_free)(void *) = free;
! 129:
! 130:
! 131:
! 132:
! 133: /*************************************************
! 134: * Default character tables *
! 135: *************************************************/
! 136:
! 137: /* A default set of character tables is included in the PCRE binary. Its source
! 138: is built by the maketables auxiliary program, which uses the default C ctypes
! 139: functions, and put in the file chartables.c. These tables are used by PCRE
! 140: whenever the caller of pcre_compile() does not provide an alternate set of
! 141: tables. */
! 142:
! 143: #include "chartables.c"
! 144:
! 145:
! 146:
! 147: /*************************************************
! 148: * Return version string *
! 149: *************************************************/
! 150:
! 151: #define STRING(a) # a
! 152: #define XSTRING(s) STRING(s)
! 153:
! 154: const char *
! 155: pcre_version(void)
! 156: {
! 157: return XSTRING(PCRE_MAJOR) "." XSTRING(PCRE_MINOR) " " XSTRING(PCRE_DATE);
! 158: }
! 159:
! 160:
! 161:
! 162:
! 163: /*************************************************
! 164: * Return info about a compiled pattern *
! 165: *************************************************/
! 166:
! 167: /* This function picks potentially useful data out of the private
! 168: structure. The public options are passed back in an int - though the
! 169: re->options field has been expanded to a long int, all the public options
! 170: at the low end of it, and so even on 16-bit systems this will still be OK.
! 171: Therefore, I haven't changed the API for pcre_info().
! 172:
! 173: Arguments:
! 174: external_re points to compiled code
! 175: optptr where to pass back the options
! 176: first_char where to pass back the first character,
! 177: or -1 if multiline and all branches start ^,
! 178: or -2 otherwise
! 179:
! 180: Returns: number of identifying extraction brackets
! 181: or negative values on error
! 182: */
! 183:
! 184: int
! 185: pcre_info(const pcre *external_re, int *optptr, int *first_char)
! 186: {
! 187: const real_pcre *re = (const real_pcre *)external_re;
! 188: if (re == NULL) return PCRE_ERROR_NULL;
! 189: if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
! 190: if (optptr != NULL) *optptr = (int)(re->options & PUBLIC_OPTIONS);
! 191: if (first_char != NULL)
! 192: *first_char = ((re->options & PCRE_FIRSTSET) != 0)? re->first_char :
! 193: ((re->options & PCRE_STARTLINE) != 0)? -1 : -2;
! 194: return re->top_bracket;
! 195: }
! 196:
! 197:
! 198:
! 199:
! 200: #ifdef DEBUG
! 201: /*************************************************
! 202: * Debugging function to print chars *
! 203: *************************************************/
! 204:
! 205: /* Print a sequence of chars in printable format, stopping at the end of the
! 206: subject if the requested.
! 207:
! 208: Arguments:
! 209: p points to characters
! 210: length number to print
! 211: is_subject TRUE if printing from within md->start_subject
! 212: md pointer to matching data block, if is_subject is TRUE
! 213:
! 214: Returns: nothing
! 215: */
! 216:
! 217: static void
! 218: pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
! 219: {
! 220: int c;
! 221: if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
! 222: while (length-- > 0)
! 223: if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);
! 224: }
! 225: #endif
! 226:
! 227:
! 228:
! 229:
! 230: /*************************************************
! 231: * Handle escapes *
! 232: *************************************************/
! 233:
! 234: /* This function is called when a \ has been encountered. It either returns a
! 235: positive value for a simple escape such as \n, or a negative value which
! 236: encodes one of the more complicated things such as \d. On entry, ptr is
! 237: pointing at the \. On exit, it is on the final character of the escape
! 238: sequence.
! 239:
! 240: Arguments:
! 241: ptrptr points to the pattern position pointer
! 242: errorptr points to the pointer to the error message
! 243: bracount number of previous extracting brackets
! 244: options the options bits
! 245: isclass TRUE if inside a character class
! 246: cd pointer to char tables block
! 247:
! 248: Returns: zero or positive => a data character
! 249: negative => a special escape sequence
! 250: on error, errorptr is set
! 251: */
! 252:
! 253: static int
! 254: check_escape(const uschar **ptrptr, const char **errorptr, int bracount,
! 255: int options, BOOL isclass, compile_data *cd)
! 256: {
! 257: const uschar *ptr = *ptrptr;
! 258: int c = *(++ptr) & 255; /* Ensure > 0 on signed-char systems */
! 259: int i;
! 260:
! 261: if (c == 0) *errorptr = ERR1;
! 262:
! 263: /* Digits or letters may have special meaning; all others are literals. */
! 264:
! 265: else if (c < '0' || c > 'z') {}
! 266:
! 267: /* Do an initial lookup in a table. A non-zero result is something that can be
! 268: returned immediately. Otherwise further processing may be required. */
! 269:
! 270: else if ((i = escapes[c - '0']) != 0) c = i;
! 271:
! 272: /* Escapes that need further processing, or are illegal. */
! 273:
! 274: else
! 275: {
! 276: const uschar *oldptr;
! 277: switch (c)
! 278: {
! 279: /* The handling of escape sequences consisting of a string of digits
! 280: starting with one that is not zero is not straightforward. By experiment,
! 281: the way Perl works seems to be as follows:
! 282:
! 283: Outside a character class, the digits are read as a decimal number. If the
! 284: number is less than 10, or if there are that many previous extracting
! 285: left brackets, then it is a back reference. Otherwise, up to three octal
! 286: digits are read to form an escaped byte. Thus \123 is likely to be octal
! 287: 123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
! 288: value is greater than 377, the least significant 8 bits are taken. Inside a
! 289: character class, \ followed by a digit is always an octal number. */
! 290:
! 291: case '1': case '2': case '3': case '4': case '5':
! 292: case '6': case '7': case '8': case '9':
! 293:
! 294: if (!isclass)
! 295: {
! 296: oldptr = ptr;
! 297: c -= '0';
! 298: while ((cd->ctypes[ptr[1]] & ctype_digit) != 0)
! 299: c = c * 10 + *(++ptr) - '0';
! 300: if (c < 10 || c <= bracount)
! 301: {
! 302: c = -(ESC_REF + c);
! 303: break;
! 304: }
! 305: ptr = oldptr; /* Put the pointer back and fall through */
! 306: }
! 307:
! 308: /* Handle an octal number following \. If the first digit is 8 or 9, Perl
! 309: generates a binary zero byte and treats the digit as a following literal.
! 310: Thus we have to pull back the pointer by one. */
! 311:
! 312: if ((c = *ptr) >= '8')
! 313: {
! 314: ptr--;
! 315: c = 0;
! 316: break;
! 317: }
! 318:
! 319: /* \0 always starts an octal number, but we may drop through to here with a
! 320: larger first octal digit */
! 321:
! 322: case '0':
! 323: c -= '0';
! 324: while(i++ < 2 && (cd->ctypes[ptr[1]] & ctype_digit) != 0 &&
! 325: ptr[1] != '8' && ptr[1] != '9')
! 326: c = c * 8 + *(++ptr) - '0';
! 327: break;
! 328:
! 329: /* Special escapes not starting with a digit are straightforward */
! 330:
! 331: case 'x':
! 332: c = 0;
! 333: while (i++ < 2 && (cd->ctypes[ptr[1]] & ctype_xdigit) != 0)
! 334: {
! 335: ptr++;
! 336: c = c * 16 + cd->lcc[*ptr] -
! 337: (((cd->ctypes[*ptr] & ctype_digit) != 0)? '0' : 'W');
! 338: }
! 339: break;
! 340:
! 341: case 'c':
! 342: c = *(++ptr);
! 343: if (c == 0)
! 344: {
! 345: *errorptr = ERR2;
! 346: return 0;
! 347: }
! 348:
! 349: /* A letter is upper-cased; then the 0x40 bit is flipped */
! 350:
! 351: if (c >= 'a' && c <= 'z') c = cd->fcc[c];
! 352: c ^= 0x40;
! 353: break;
! 354:
! 355: /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
! 356: other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
! 357: for Perl compatibility, it is a literal. This code looks a bit odd, but
! 358: there used to be some cases other than the default, and there may be again
! 359: in future, so I haven't "optimized" it. */
! 360:
! 361: default:
! 362: if ((options & PCRE_EXTRA) != 0) switch(c)
! 363: {
! 364: default:
! 365: *errorptr = ERR3;
! 366: break;
! 367: }
! 368: break;
! 369: }
! 370: }
! 371:
! 372: *ptrptr = ptr;
! 373: return c;
! 374: }
! 375:
! 376:
! 377:
! 378: /*************************************************
! 379: * Check for counted repeat *
! 380: *************************************************/
! 381:
! 382: /* This function is called when a '{' is encountered in a place where it might
! 383: start a quantifier. It looks ahead to see if it really is a quantifier or not.
! 384: It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
! 385: where the ddds are digits.
! 386:
! 387: Arguments:
! 388: p pointer to the first char after '{'
! 389: cd pointer to char tables block
! 390:
! 391: Returns: TRUE or FALSE
! 392: */
! 393:
! 394: static BOOL
! 395: is_counted_repeat(const uschar *p, compile_data *cd)
! 396: {
! 397: if ((cd->ctypes[*p++] & ctype_digit) == 0) return FALSE;
! 398: while ((cd->ctypes[*p] & ctype_digit) != 0) p++;
! 399: if (*p == '}') return TRUE;
! 400:
! 401: if (*p++ != ',') return FALSE;
! 402: if (*p == '}') return TRUE;
! 403:
! 404: if ((cd->ctypes[*p++] & ctype_digit) == 0) return FALSE;
! 405: while ((cd->ctypes[*p] & ctype_digit) != 0) p++;
! 406: return (*p == '}');
! 407: }
! 408:
! 409:
! 410:
! 411: /*************************************************
! 412: * Read repeat counts *
! 413: *************************************************/
! 414:
! 415: /* Read an item of the form {n,m} and return the values. This is called only
! 416: after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
! 417: so the syntax is guaranteed to be correct, but we need to check the values.
! 418:
! 419: Arguments:
! 420: p pointer to first char after '{'
! 421: minp pointer to int for min
! 422: maxp pointer to int for max
! 423: returned as -1 if no max
! 424: errorptr points to pointer to error message
! 425: cd pointer to character tables clock
! 426:
! 427: Returns: pointer to '}' on success;
! 428: current ptr on error, with errorptr set
! 429: */
! 430:
! 431: static const uschar *
! 432: read_repeat_counts(const uschar *p, int *minp, int *maxp,
! 433: const char **errorptr, compile_data *cd)
! 434: {
! 435: int min = 0;
! 436: int max = -1;
! 437:
! 438: while ((cd->ctypes[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
! 439:
! 440: if (*p == '}') max = min; else
! 441: {
! 442: if (*(++p) != '}')
! 443: {
! 444: max = 0;
! 445: while((cd->ctypes[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
! 446: if (max < min)
! 447: {
! 448: *errorptr = ERR4;
! 449: return p;
! 450: }
! 451: }
! 452: }
! 453:
! 454: /* Do paranoid checks, then fill in the required variables, and pass back the
! 455: pointer to the terminating '}'. */
! 456:
! 457: if (min > 65535 || max > 65535)
! 458: *errorptr = ERR5;
! 459: else
! 460: {
! 461: *minp = min;
! 462: *maxp = max;
! 463: }
! 464: return p;
! 465: }
! 466:
! 467:
! 468:
! 469: /*************************************************
! 470: * Find the fixed length of a pattern *
! 471: *************************************************/
! 472:
! 473: /* Scan a pattern and compute the fixed length of subject that will match it,
! 474: if the length is fixed. This is needed for dealing with backward assertions.
! 475:
! 476: Arguments:
! 477: code points to the start of the pattern (the bracket)
! 478:
! 479: Returns: the fixed length, or -1 if there is no fixed length
! 480: */
! 481:
! 482: static int
! 483: find_fixedlength(uschar *code)
! 484: {
! 485: int length = -1;
! 486:
! 487: register int branchlength = 0;
! 488: register uschar *cc = code + 3;
! 489:
! 490: /* Scan along the opcodes for this branch. If we get to the end of the
! 491: branch, check the length against that of the other branches. */
! 492:
! 493: for (;;)
! 494: {
! 495: int d;
! 496: register int op = *cc;
! 497: if (op >= OP_BRA) op = OP_BRA;
! 498:
! 499: switch (op)
! 500: {
! 501: case OP_BRA:
! 502: case OP_ONCE:
! 503: case OP_COND:
! 504: d = find_fixedlength(cc);
! 505: if (d < 0) return -1;
! 506: branchlength += d;
! 507: do cc += (cc[1] << 8) + cc[2]; while (*cc == OP_ALT);
! 508: cc += 3;
! 509: break;
! 510:
! 511: /* Reached end of a branch; if it's a ket it is the end of a nested
! 512: call. If it's ALT it is an alternation in a nested call. If it is
! 513: END it's the end of the outer call. All can be handled by the same code. */
! 514:
! 515: case OP_ALT:
! 516: case OP_KET:
! 517: case OP_KETRMAX:
! 518: case OP_KETRMIN:
! 519: case OP_END:
! 520: if (length < 0) length = branchlength;
! 521: else if (length != branchlength) return -1;
! 522: if (*cc != OP_ALT) return length;
! 523: cc += 3;
! 524: branchlength = 0;
! 525: break;
! 526:
! 527: /* Skip over assertive subpatterns */
! 528:
! 529: case OP_ASSERT:
! 530: case OP_ASSERT_NOT:
! 531: case OP_ASSERTBACK:
! 532: case OP_ASSERTBACK_NOT:
! 533: do cc += (cc[1] << 8) + cc[2]; while (*cc == OP_ALT);
! 534: cc += 3;
! 535: break;
! 536:
! 537: /* Skip over things that don't match chars */
! 538:
! 539: case OP_REVERSE:
! 540: cc++;
! 541: /* Fall through */
! 542:
! 543: case OP_CREF:
! 544: case OP_OPT:
! 545: cc++;
! 546: /* Fall through */
! 547:
! 548: case OP_SOD:
! 549: case OP_EOD:
! 550: case OP_EODN:
! 551: case OP_CIRC:
! 552: case OP_DOLL:
! 553: case OP_NOT_WORD_BOUNDARY:
! 554: case OP_WORD_BOUNDARY:
! 555: cc++;
! 556: break;
! 557:
! 558: /* Handle char strings */
! 559:
! 560: case OP_CHARS:
! 561: branchlength += *(++cc);
! 562: cc += *cc + 1;
! 563: break;
! 564:
! 565: /* Handle exact repetitions */
! 566:
! 567: case OP_EXACT:
! 568: case OP_TYPEEXACT:
! 569: branchlength += (cc[1] << 8) + cc[2];
! 570: cc += 4;
! 571: break;
! 572:
! 573: /* Handle single-char matchers */
! 574:
! 575: case OP_NOT_DIGIT:
! 576: case OP_DIGIT:
! 577: case OP_NOT_WHITESPACE:
! 578: case OP_WHITESPACE:
! 579: case OP_NOT_WORDCHAR:
! 580: case OP_WORDCHAR:
! 581: case OP_ANY:
! 582: branchlength++;
! 583: cc++;
! 584: break;
! 585:
! 586:
! 587: /* Check a class for variable quantification */
! 588:
! 589: case OP_CLASS:
! 590: cc += (*cc == OP_REF)? 2 : 33;
! 591:
! 592: switch (*cc)
! 593: {
! 594: case OP_CRSTAR:
! 595: case OP_CRMINSTAR:
! 596: case OP_CRQUERY:
! 597: case OP_CRMINQUERY:
! 598: return -1;
! 599:
! 600: case OP_CRRANGE:
! 601: case OP_CRMINRANGE:
! 602: if ((cc[1] << 8) + cc[2] != (cc[3] << 8) + cc[4]) return -1;
! 603: branchlength += (cc[1] << 8) + cc[2];
! 604: cc += 5;
! 605: break;
! 606:
! 607: default:
! 608: branchlength++;
! 609: }
! 610: break;
! 611:
! 612: /* Anything else is variable length */
! 613:
! 614: default:
! 615: return -1;
! 616: }
! 617: }
! 618: /* Control never gets here */
! 619: }
! 620:
! 621:
! 622:
! 623:
! 624: /*************************************************
! 625: * Compile one branch *
! 626: *************************************************/
! 627:
! 628: /* Scan the pattern, compiling it into the code vector.
! 629:
! 630: Arguments:
! 631: options the option bits
! 632: brackets points to number of brackets used
! 633: code points to the pointer to the current code point
! 634: ptrptr points to the current pattern pointer
! 635: errorptr points to pointer to error message
! 636: optchanged set to the value of the last OP_OPT item compiled
! 637: reqchar set to the last literal character required, else -1
! 638: countlits set to count of mandatory literal characters
! 639: cd contains pointers to tables
! 640:
! 641: Returns: TRUE on success
! 642: FALSE, with *errorptr set on error
! 643: */
! 644:
! 645: static BOOL
! 646: compile_branch(int options, int *brackets, uschar **codeptr,
! 647: const uschar **ptrptr, const char **errorptr, int *optchanged,
! 648: int *reqchar, int *countlits, compile_data *cd)
! 649: {
! 650: int repeat_type, op_type;
! 651: int repeat_min, repeat_max;
! 652: int bravalue, length;
! 653: int greedy_default, greedy_non_default;
! 654: int prevreqchar;
! 655: int condcount = 0;
! 656: int subcountlits = 0;
! 657: register int c;
! 658: register uschar *code = *codeptr;
! 659: uschar *tempcode;
! 660: const uschar *ptr = *ptrptr;
! 661: const uschar *tempptr;
! 662: uschar *previous = NULL;
! 663: uschar class[32];
! 664:
! 665: /* Set up the default and non-default settings for greediness */
! 666:
! 667: greedy_default = ((options & PCRE_UNGREEDY) != 0);
! 668: greedy_non_default = greedy_default ^ 1;
! 669:
! 670: /* Initialize no required char, and count of literals */
! 671:
! 672: *reqchar = prevreqchar = -1;
! 673: *countlits = 0;
! 674:
! 675: /* Switch on next character until the end of the branch */
! 676:
! 677: for (;; ptr++)
! 678: {
! 679: BOOL negate_class;
! 680: int class_charcount;
! 681: int class_lastchar;
! 682: int newoptions;
! 683: int condref;
! 684: int subreqchar;
! 685:
! 686: c = *ptr;
! 687: if ((options & PCRE_EXTENDED) != 0)
! 688: {
! 689: if ((cd->ctypes[c] & ctype_space) != 0) continue;
! 690: if (c == '#')
! 691: {
! 692: while ((c = *(++ptr)) != 0 && c != '\n');
! 693: continue;
! 694: }
! 695: }
! 696:
! 697: switch(c)
! 698: {
! 699: /* The branch terminates at end of string, |, or ). */
! 700:
! 701: case 0:
! 702: case '|':
! 703: case ')':
! 704: *codeptr = code;
! 705: *ptrptr = ptr;
! 706: return TRUE;
! 707:
! 708: /* Handle single-character metacharacters */
! 709:
! 710: case '^':
! 711: previous = NULL;
! 712: *code++ = OP_CIRC;
! 713: break;
! 714:
! 715: case '$':
! 716: previous = NULL;
! 717: *code++ = OP_DOLL;
! 718: break;
! 719:
! 720: case '.':
! 721: previous = code;
! 722: *code++ = OP_ANY;
! 723: break;
! 724:
! 725: /* Character classes. These always build a 32-byte bitmap of the permitted
! 726: characters, except in the special case where there is only one character.
! 727: For negated classes, we build the map as usual, then invert it at the end.
! 728: */
! 729:
! 730: case '[':
! 731: previous = code;
! 732: *code++ = OP_CLASS;
! 733:
! 734: /* If the first character is '^', set the negation flag and skip it. */
! 735:
! 736: if ((c = *(++ptr)) == '^')
! 737: {
! 738: negate_class = TRUE;
! 739: c = *(++ptr);
! 740: }
! 741: else negate_class = FALSE;
! 742:
! 743: /* Keep a count of chars so that we can optimize the case of just a single
! 744: character. */
! 745:
! 746: class_charcount = 0;
! 747: class_lastchar = -1;
! 748:
! 749: /* Initialize the 32-char bit map to all zeros. We have to build the
! 750: map in a temporary bit of store, in case the class contains only 1
! 751: character, because in that case the compiled code doesn't use the
! 752: bit map. */
! 753:
! 754: memset(class, 0, 32 * sizeof(uschar));
! 755:
! 756: /* Process characters until ] is reached. By writing this as a "do" it
! 757: means that an initial ] is taken as a data character. */
! 758:
! 759: do
! 760: {
! 761: if (c == 0)
! 762: {
! 763: *errorptr = ERR6;
! 764: goto FAILED;
! 765: }
! 766:
! 767: /* Backslash may introduce a single character, or it may introduce one
! 768: of the specials, which just set a flag. Escaped items are checked for
! 769: validity in the pre-compiling pass. The sequence \b is a special case.
! 770: Inside a class (and only there) it is treated as backspace. Elsewhere
! 771: it marks a word boundary. Other escapes have preset maps ready to
! 772: or into the one we are building. We assume they have more than one
! 773: character in them, so set class_count bigger than one. */
! 774:
! 775: if (c == '\\')
! 776: {
! 777: c = check_escape(&ptr, errorptr, *brackets, options, TRUE, cd);
! 778: if (-c == ESC_b) c = '\b';
! 779: else if (c < 0)
! 780: {
! 781: register const uschar *cbits = cd->cbits;
! 782: class_charcount = 10;
! 783: switch (-c)
! 784: {
! 785: case ESC_d:
! 786: for (c = 0; c < 32; c++) class[c] |= cbits[c+cbit_digit];
! 787: continue;
! 788:
! 789: case ESC_D:
! 790: for (c = 0; c < 32; c++) class[c] |= ~cbits[c+cbit_digit];
! 791: continue;
! 792:
! 793: case ESC_w:
! 794: for (c = 0; c < 32; c++)
! 795: class[c] |= (cbits[c+cbit_digit] | cbits[c+cbit_word]);
! 796: continue;
! 797:
! 798: case ESC_W:
! 799: for (c = 0; c < 32; c++)
! 800: class[c] |= ~(cbits[c+cbit_digit] | cbits[c+cbit_word]);
! 801: continue;
! 802:
! 803: case ESC_s:
! 804: for (c = 0; c < 32; c++) class[c] |= cbits[c+cbit_space];
! 805: continue;
! 806:
! 807: case ESC_S:
! 808: for (c = 0; c < 32; c++) class[c] |= ~cbits[c+cbit_space];
! 809: continue;
! 810:
! 811: default:
! 812: *errorptr = ERR7;
! 813: goto FAILED;
! 814: }
! 815: }
! 816: /* Fall through if single character */
! 817: }
! 818:
! 819: /* A single character may be followed by '-' to form a range. However,
! 820: Perl does not permit ']' to be the end of the range. A '-' character
! 821: here is treated as a literal. */
! 822:
! 823: if (ptr[1] == '-' && ptr[2] != ']')
! 824: {
! 825: int d;
! 826: ptr += 2;
! 827: d = *ptr;
! 828:
! 829: if (d == 0)
! 830: {
! 831: *errorptr = ERR6;
! 832: goto FAILED;
! 833: }
! 834:
! 835: /* The second part of a range can be a single-character escape, but
! 836: not any of the other escapes. */
! 837:
! 838: if (d == '\\')
! 839: {
! 840: d = check_escape(&ptr, errorptr, *brackets, options, TRUE, cd);
! 841: if (d < 0)
! 842: {
! 843: if (d == -ESC_b) d = '\b'; else
! 844: {
! 845: *errorptr = ERR7;
! 846: goto FAILED;
! 847: }
! 848: }
! 849: }
! 850:
! 851: if (d < c)
! 852: {
! 853: *errorptr = ERR8;
! 854: goto FAILED;
! 855: }
! 856:
! 857: for (; c <= d; c++)
! 858: {
! 859: class[c/8] |= (1 << (c&7));
! 860: if ((options & PCRE_CASELESS) != 0)
! 861: {
! 862: int uc = cd->fcc[c]; /* flip case */
! 863: class[uc/8] |= (1 << (uc&7));
! 864: }
! 865: class_charcount++; /* in case a one-char range */
! 866: class_lastchar = c;
! 867: }
! 868: continue; /* Go get the next char in the class */
! 869: }
! 870:
! 871: /* Handle a lone single character - we can get here for a normal
! 872: non-escape char, or after \ that introduces a single character. */
! 873:
! 874: class [c/8] |= (1 << (c&7));
! 875: if ((options & PCRE_CASELESS) != 0)
! 876: {
! 877: c = cd->fcc[c]; /* flip case */
! 878: class[c/8] |= (1 << (c&7));
! 879: }
! 880: class_charcount++;
! 881: class_lastchar = c;
! 882: }
! 883:
! 884: /* Loop until ']' reached; the check for end of string happens inside the
! 885: loop. This "while" is the end of the "do" above. */
! 886:
! 887: while ((c = *(++ptr)) != ']');
! 888:
! 889: /* If class_charcount is 1 and class_lastchar is not negative, we saw
! 890: precisely one character. This doesn't need the whole 32-byte bit map.
! 891: We turn it into a 1-character OP_CHAR if it's positive, or OP_NOT if
! 892: it's negative. */
! 893:
! 894: if (class_charcount == 1 && class_lastchar >= 0)
! 895: {
! 896: if (negate_class)
! 897: {
! 898: code[-1] = OP_NOT;
! 899: }
! 900: else
! 901: {
! 902: code[-1] = OP_CHARS;
! 903: *code++ = 1;
! 904: }
! 905: *code++ = class_lastchar;
! 906: }
! 907:
! 908: /* Otherwise, negate the 32-byte map if necessary, and copy it into
! 909: the code vector. */
! 910:
! 911: else
! 912: {
! 913: if (negate_class)
! 914: for (c = 0; c < 32; c++) code[c] = ~class[c];
! 915: else
! 916: memcpy(code, class, 32);
! 917: code += 32;
! 918: }
! 919: break;
! 920:
! 921: /* Various kinds of repeat */
! 922:
! 923: case '{':
! 924: if (!is_counted_repeat(ptr+1, cd)) goto NORMAL_CHAR;
! 925: ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorptr, cd);
! 926: if (*errorptr != NULL) goto FAILED;
! 927: goto REPEAT;
! 928:
! 929: case '*':
! 930: repeat_min = 0;
! 931: repeat_max = -1;
! 932: goto REPEAT;
! 933:
! 934: case '+':
! 935: repeat_min = 1;
! 936: repeat_max = -1;
! 937: goto REPEAT;
! 938:
! 939: case '?':
! 940: repeat_min = 0;
! 941: repeat_max = 1;
! 942:
! 943: REPEAT:
! 944: if (previous == NULL)
! 945: {
! 946: *errorptr = ERR9;
! 947: goto FAILED;
! 948: }
! 949:
! 950: /* If the next character is '?' this is a minimizing repeat, by default,
! 951: but if PCRE_UNGREEDY is set, it works the other way round. Advance to the
! 952: next character. */
! 953:
! 954: if (ptr[1] == '?')
! 955: { repeat_type = greedy_non_default; ptr++; }
! 956: else repeat_type = greedy_default;
! 957:
! 958: /* If previous was a string of characters, chop off the last one and use it
! 959: as the subject of the repeat. If there was only one character, we can
! 960: abolish the previous item altogether. A repeat with a zero minimum wipes
! 961: out any reqchar setting, backing up to the previous value. We must also
! 962: adjust the countlits value. */
! 963:
! 964: if (*previous == OP_CHARS)
! 965: {
! 966: int len = previous[1];
! 967:
! 968: if (repeat_min == 0) *reqchar = prevreqchar;
! 969: *countlits += repeat_min - 1;
! 970:
! 971: if (len == 1)
! 972: {
! 973: c = previous[2];
! 974: code = previous;
! 975: }
! 976: else
! 977: {
! 978: c = previous[len+1];
! 979: previous[1]--;
! 980: code--;
! 981: }
! 982: op_type = 0; /* Use single-char op codes */
! 983: goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */
! 984: }
! 985:
! 986: /* If previous was a single negated character ([^a] or similar), we use
! 987: one of the special opcodes, replacing it. The code is shared with single-
! 988: character repeats by adding a suitable offset into repeat_type. */
! 989:
! 990: else if ((int)*previous == OP_NOT)
! 991: {
! 992: op_type = OP_NOTSTAR - OP_STAR; /* Use "not" opcodes */
! 993: c = previous[1];
! 994: code = previous;
! 995: goto OUTPUT_SINGLE_REPEAT;
! 996: }
! 997:
! 998: /* If previous was a character type match (\d or similar), abolish it and
! 999: create a suitable repeat item. The code is shared with single-character
! 1000: repeats by adding a suitable offset into repeat_type. */
! 1001:
! 1002: else if ((int)*previous < OP_EODN || *previous == OP_ANY)
! 1003: {
! 1004: op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */
! 1005: c = *previous;
! 1006: code = previous;
! 1007:
! 1008: OUTPUT_SINGLE_REPEAT:
! 1009:
! 1010: /* If the maximum is zero then the minimum must also be zero; Perl allows
! 1011: this case, so we do too - by simply omitting the item altogether. */
! 1012:
! 1013: if (repeat_max == 0) goto END_REPEAT;
! 1014:
! 1015: /* Combine the op_type with the repeat_type */
! 1016:
! 1017: repeat_type += op_type;
! 1018:
! 1019: /* A minimum of zero is handled either as the special case * or ?, or as
! 1020: an UPTO, with the maximum given. */
! 1021:
! 1022: if (repeat_min == 0)
! 1023: {
! 1024: if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
! 1025: else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
! 1026: else
! 1027: {
! 1028: *code++ = OP_UPTO + repeat_type;
! 1029: *code++ = repeat_max >> 8;
! 1030: *code++ = (repeat_max & 255);
! 1031: }
! 1032: }
! 1033:
! 1034: /* The case {1,} is handled as the special case + */
! 1035:
! 1036: else if (repeat_min == 1 && repeat_max == -1)
! 1037: *code++ = OP_PLUS + repeat_type;
! 1038:
! 1039: /* The case {n,n} is just an EXACT, while the general case {n,m} is
! 1040: handled as an EXACT followed by an UPTO. An EXACT of 1 is optimized. */
! 1041:
! 1042: else
! 1043: {
! 1044: if (repeat_min != 1)
! 1045: {
! 1046: *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */
! 1047: *code++ = repeat_min >> 8;
! 1048: *code++ = (repeat_min & 255);
! 1049: }
! 1050:
! 1051: /* If the mininum is 1 and the previous item was a character string,
! 1052: we either have to put back the item that got cancelled if the string
! 1053: length was 1, or add the character back onto the end of a longer
! 1054: string. For a character type nothing need be done; it will just get
! 1055: put back naturally. Note that the final character is always going to
! 1056: get added below. */
! 1057:
! 1058: else if (*previous == OP_CHARS)
! 1059: {
! 1060: if (code == previous) code += 2; else previous[1]++;
! 1061: }
! 1062:
! 1063: /* For a single negated character we also have to put back the
! 1064: item that got cancelled. */
! 1065:
! 1066: else if (*previous == OP_NOT) code++;
! 1067:
! 1068: /* If the maximum is unlimited, insert an OP_STAR. */
! 1069:
! 1070: if (repeat_max < 0)
! 1071: {
! 1072: *code++ = c;
! 1073: *code++ = OP_STAR + repeat_type;
! 1074: }
! 1075:
! 1076: /* Else insert an UPTO if the max is greater than the min. */
! 1077:
! 1078: else if (repeat_max != repeat_min)
! 1079: {
! 1080: *code++ = c;
! 1081: repeat_max -= repeat_min;
! 1082: *code++ = OP_UPTO + repeat_type;
! 1083: *code++ = repeat_max >> 8;
! 1084: *code++ = (repeat_max & 255);
! 1085: }
! 1086: }
! 1087:
! 1088: /* The character or character type itself comes last in all cases. */
! 1089:
! 1090: *code++ = c;
! 1091: }
! 1092:
! 1093: /* If previous was a character class or a back reference, we put the repeat
! 1094: stuff after it, but just skip the item if the repeat was {0,0}. */
! 1095:
! 1096: else if (*previous == OP_CLASS || *previous == OP_REF)
! 1097: {
! 1098: if (repeat_max == 0)
! 1099: {
! 1100: code = previous;
! 1101: goto END_REPEAT;
! 1102: }
! 1103: if (repeat_min == 0 && repeat_max == -1)
! 1104: *code++ = OP_CRSTAR + repeat_type;
! 1105: else if (repeat_min == 1 && repeat_max == -1)
! 1106: *code++ = OP_CRPLUS + repeat_type;
! 1107: else if (repeat_min == 0 && repeat_max == 1)
! 1108: *code++ = OP_CRQUERY + repeat_type;
! 1109: else
! 1110: {
! 1111: *code++ = OP_CRRANGE + repeat_type;
! 1112: *code++ = repeat_min >> 8;
! 1113: *code++ = repeat_min & 255;
! 1114: if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */
! 1115: *code++ = repeat_max >> 8;
! 1116: *code++ = repeat_max & 255;
! 1117: }
! 1118: }
! 1119:
! 1120: /* If previous was a bracket group, we may have to replicate it in certain
! 1121: cases. */
! 1122:
! 1123: else if ((int)*previous >= OP_BRA || (int)*previous == OP_ONCE ||
! 1124: (int)*previous == OP_COND)
! 1125: {
! 1126: register int i;
! 1127: int ketoffset = 0;
! 1128: int len = code - previous;
! 1129: uschar *bralink = NULL;
! 1130:
! 1131: /* If the maximum repeat count is unlimited, find the end of the bracket
! 1132: by scanning through from the start, and compute the offset back to it
! 1133: from the current code pointer. There may be an OP_OPT setting following
! 1134: the final KET, so we can't find the end just by going back from the code
! 1135: pointer. */
! 1136:
! 1137: if (repeat_max == -1)
! 1138: {
! 1139: register uschar *ket = previous;
! 1140: do ket += (ket[1] << 8) + ket[2]; while (*ket != OP_KET);
! 1141: ketoffset = code - ket;
! 1142: }
! 1143:
! 1144: /* The case of a zero minimum is special because of the need to stick
! 1145: OP_BRAZERO in front of it, and because the group appears once in the
! 1146: data, whereas in other cases it appears the minimum number of times. For
! 1147: this reason, it is simplest to treat this case separately, as otherwise
! 1148: the code gets far too mess. There are several special subcases when the
! 1149: minimum is zero. */
! 1150:
! 1151: if (repeat_min == 0)
! 1152: {
! 1153: /* If we set up a required char from the bracket, we must back off
! 1154: to the previous value and reset the countlits value too. */
! 1155:
! 1156: if (subcountlits > 0)
! 1157: {
! 1158: *reqchar = prevreqchar;
! 1159: *countlits -= subcountlits;
! 1160: }
! 1161:
! 1162: /* If the maximum is also zero, we just omit the group from the output
! 1163: altogether. */
! 1164:
! 1165: if (repeat_max == 0)
! 1166: {
! 1167: code = previous;
! 1168: goto END_REPEAT;
! 1169: }
! 1170:
! 1171: /* If the maximum is 1 or unlimited, we just have to stick in the
! 1172: BRAZERO and do no more at this point. */
! 1173:
! 1174: if (repeat_max <= 1)
! 1175: {
! 1176: memmove(previous+1, previous, len);
! 1177: code++;
! 1178: *previous++ = OP_BRAZERO + repeat_type;
! 1179: }
! 1180:
! 1181: /* If the maximum is greater than 1 and limited, we have to replicate
! 1182: in a nested fashion, sticking OP_BRAZERO before each set of brackets.
! 1183: The first one has to be handled carefully because it's the original
! 1184: copy, which has to be moved up. The remainder can be handled by code
! 1185: that is common with the non-zero minimum case below. We just have to
! 1186: adjust the value or repeat_max, since one less copy is required. */
! 1187:
! 1188: else
! 1189: {
! 1190: int offset;
! 1191: memmove(previous+4, previous, len);
! 1192: code += 4;
! 1193: *previous++ = OP_BRAZERO + repeat_type;
! 1194: *previous++ = OP_BRA;
! 1195:
! 1196: /* We chain together the bracket offset fields that have to be
! 1197: filled in later when the ends of the brackets are reached. */
! 1198:
! 1199: offset = (bralink == NULL)? 0 : previous - bralink;
! 1200: bralink = previous;
! 1201: *previous++ = offset >> 8;
! 1202: *previous++ = offset & 255;
! 1203: }
! 1204:
! 1205: repeat_max--;
! 1206: }
! 1207:
! 1208: /* If the minimum is greater than zero, replicate the group as many
! 1209: times as necessary, and adjust the maximum to the number of subsequent
! 1210: copies that we need. */
! 1211:
! 1212: else
! 1213: {
! 1214: for (i = 1; i < repeat_min; i++)
! 1215: {
! 1216: memcpy(code, previous, len);
! 1217: code += len;
! 1218: }
! 1219: if (repeat_max > 0) repeat_max -= repeat_min;
! 1220: }
! 1221:
! 1222: /* This code is common to both the zero and non-zero minimum cases. If
! 1223: the maximum is limited, it replicates the group in a nested fashion,
! 1224: remembering the bracket starts on a stack. In the case of a zero minimum,
! 1225: the first one was set up above. In all cases the repeat_max now specifies
! 1226: the number of additional copies needed. */
! 1227:
! 1228: if (repeat_max >= 0)
! 1229: {
! 1230: for (i = repeat_max - 1; i >= 0; i--)
! 1231: {
! 1232: *code++ = OP_BRAZERO + repeat_type;
! 1233:
! 1234: /* All but the final copy start a new nesting, maintaining the
! 1235: chain of brackets outstanding. */
! 1236:
! 1237: if (i != 0)
! 1238: {
! 1239: int offset;
! 1240: *code++ = OP_BRA;
! 1241: offset = (bralink == NULL)? 0 : code - bralink;
! 1242: bralink = code;
! 1243: *code++ = offset >> 8;
! 1244: *code++ = offset & 255;
! 1245: }
! 1246:
! 1247: memcpy(code, previous, len);
! 1248: code += len;
! 1249: }
! 1250:
! 1251: /* Now chain through the pending brackets, and fill in their length
! 1252: fields (which are holding the chain links pro tem). */
! 1253:
! 1254: while (bralink != NULL)
! 1255: {
! 1256: int oldlinkoffset;
! 1257: int offset = code - bralink + 1;
! 1258: uschar *bra = code - offset;
! 1259: oldlinkoffset = (bra[1] << 8) + bra[2];
! 1260: bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
! 1261: *code++ = OP_KET;
! 1262: *code++ = bra[1] = offset >> 8;
! 1263: *code++ = bra[2] = (offset & 255);
! 1264: }
! 1265: }
! 1266:
! 1267: /* If the maximum is unlimited, set a repeater in the final copy. We
! 1268: can't just offset backwards from the current code point, because we
! 1269: don't know if there's been an options resetting after the ket. The
! 1270: correct offset was computed above. */
! 1271:
! 1272: else code[-ketoffset] = OP_KETRMAX + repeat_type;
! 1273: }
! 1274:
! 1275: /* Else there's some kind of shambles */
! 1276:
! 1277: else
! 1278: {
! 1279: *errorptr = ERR11;
! 1280: goto FAILED;
! 1281: }
! 1282:
! 1283: /* In all case we no longer have a previous item. */
! 1284:
! 1285: END_REPEAT:
! 1286: previous = NULL;
! 1287: break;
! 1288:
! 1289:
! 1290: /* Start of nested bracket sub-expression, or comment or lookahead or
! 1291: lookbehind or option setting or condition. First deal with special things
! 1292: that can come after a bracket; all are introduced by ?, and the appearance
! 1293: of any of them means that this is not a referencing group. They were
! 1294: checked for validity in the first pass over the string, so we don't have to
! 1295: check for syntax errors here. */
! 1296:
! 1297: case '(':
! 1298: newoptions = options;
! 1299: condref = -1;
! 1300:
! 1301: if (*(++ptr) == '?')
! 1302: {
! 1303: int set, unset;
! 1304: int *optset;
! 1305:
! 1306: switch (*(++ptr))
! 1307: {
! 1308: case '#': /* Comment; skip to ket */
! 1309: ptr++;
! 1310: while (*ptr != ')') ptr++;
! 1311: continue;
! 1312:
! 1313: case ':': /* Non-extracting bracket */
! 1314: bravalue = OP_BRA;
! 1315: ptr++;
! 1316: break;
! 1317:
! 1318: case '(':
! 1319: bravalue = OP_COND; /* Conditional group */
! 1320: if ((cd->ctypes[*(++ptr)] & ctype_digit) != 0)
! 1321: {
! 1322: condref = *ptr - '0';
! 1323: while (*(++ptr) != ')') condref = condref*10 + *ptr - '0';
! 1324: ptr++;
! 1325: }
! 1326: else ptr--;
! 1327: break;
! 1328:
! 1329: case '=': /* Positive lookahead */
! 1330: bravalue = OP_ASSERT;
! 1331: ptr++;
! 1332: break;
! 1333:
! 1334: case '!': /* Negative lookahead */
! 1335: bravalue = OP_ASSERT_NOT;
! 1336: ptr++;
! 1337: break;
! 1338:
! 1339: case '<': /* Lookbehinds */
! 1340: switch (*(++ptr))
! 1341: {
! 1342: case '=': /* Positive lookbehind */
! 1343: bravalue = OP_ASSERTBACK;
! 1344: ptr++;
! 1345: break;
! 1346:
! 1347: case '!': /* Negative lookbehind */
! 1348: bravalue = OP_ASSERTBACK_NOT;
! 1349: ptr++;
! 1350: break;
! 1351:
! 1352: default: /* Syntax error */
! 1353: *errorptr = ERR24;
! 1354: goto FAILED;
! 1355: }
! 1356: break;
! 1357:
! 1358: case '>': /* One-time brackets */
! 1359: bravalue = OP_ONCE;
! 1360: ptr++;
! 1361: break;
! 1362:
! 1363: default: /* Option setting */
! 1364: set = unset = 0;
! 1365: optset = &set;
! 1366:
! 1367: while (*ptr != ')' && *ptr != ':')
! 1368: {
! 1369: switch (*ptr++)
! 1370: {
! 1371: case '-': optset = &unset; break;
! 1372:
! 1373: case 'i': *optset |= PCRE_CASELESS; break;
! 1374: case 'm': *optset |= PCRE_MULTILINE; break;
! 1375: case 's': *optset |= PCRE_DOTALL; break;
! 1376: case 'x': *optset |= PCRE_EXTENDED; break;
! 1377: case 'U': *optset |= PCRE_UNGREEDY; break;
! 1378: case 'X': *optset |= PCRE_EXTRA; break;
! 1379:
! 1380: default:
! 1381: *errorptr = ERR12;
! 1382: goto FAILED;
! 1383: }
! 1384: }
! 1385:
! 1386: /* Set up the changed option bits, but don't change anything yet. */
! 1387:
! 1388: newoptions = (options | set) & (~unset);
! 1389:
! 1390: /* If the options ended with ')' this is not the start of a nested
! 1391: group with option changes, so the options change at this level. At top
! 1392: level there is nothing else to be done (the options will in fact have
! 1393: been set from the start of compiling as a result of the first pass) but
! 1394: at an inner level we must compile code to change the ims options if
! 1395: necessary, and pass the new setting back so that it can be put at the
! 1396: start of any following branches, and when this group ends, a resetting
! 1397: item can be compiled. */
! 1398:
! 1399: if (*ptr == ')')
! 1400: {
! 1401: if ((options & PCRE_INGROUP) != 0 &&
! 1402: (options & PCRE_IMS) != (newoptions & PCRE_IMS))
! 1403: {
! 1404: *code++ = OP_OPT;
! 1405: *code++ = *optchanged = newoptions & PCRE_IMS;
! 1406: }
! 1407: options = newoptions; /* Change options at this level */
! 1408: previous = NULL; /* This item can't be repeated */
! 1409: continue; /* It is complete */
! 1410: }
! 1411:
! 1412: /* If the options ended with ':' we are heading into a nested group
! 1413: with possible change of options. Such groups are non-capturing and are
! 1414: not assertions of any kind. All we need to do is skip over the ':';
! 1415: the newoptions value is handled below. */
! 1416:
! 1417: bravalue = OP_BRA;
! 1418: ptr++;
! 1419: }
! 1420: }
! 1421:
! 1422: /* Else we have a referencing group; adjust the opcode. */
! 1423:
! 1424: else
! 1425: {
! 1426: if (++(*brackets) > EXTRACT_MAX)
! 1427: {
! 1428: *errorptr = ERR13;
! 1429: goto FAILED;
! 1430: }
! 1431: bravalue = OP_BRA + *brackets;
! 1432: }
! 1433:
! 1434: /* Process nested bracketed re. Assertions may not be repeated, but other
! 1435: kinds can be. We copy code into a non-register variable in order to be able
! 1436: to pass its address because some compilers complain otherwise. Pass in a
! 1437: new setting for the ims options if they have changed. */
! 1438:
! 1439: previous = (bravalue >= OP_ONCE)? code : NULL;
! 1440: *code = bravalue;
! 1441: tempcode = code;
! 1442:
! 1443: if (!compile_regex(
! 1444: options | PCRE_INGROUP, /* Set for all nested groups */
! 1445: ((options & PCRE_IMS) != (newoptions & PCRE_IMS))?
! 1446: newoptions & PCRE_IMS : -1, /* Pass ims options if changed */
! 1447: brackets, /* Bracket level */
! 1448: &tempcode, /* Where to put code (updated) */
! 1449: &ptr, /* Input pointer (updated) */
! 1450: errorptr, /* Where to put an error message */
! 1451: (bravalue == OP_ASSERTBACK ||
! 1452: bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
! 1453: condref, /* Condition reference number */
! 1454: &subreqchar, /* For possible last char */
! 1455: &subcountlits, /* For literal count */
! 1456: cd)) /* Tables block */
! 1457: goto FAILED;
! 1458:
! 1459: /* At the end of compiling, code is still pointing to the start of the
! 1460: group, while tempcode has been updated to point past the end of the group
! 1461: and any option resetting that may follow it. The pattern pointer (ptr)
! 1462: is on the bracket. */
! 1463:
! 1464: /* If this is a conditional bracket, check that there are no more than
! 1465: two branches in the group. */
! 1466:
! 1467: if (bravalue == OP_COND)
! 1468: {
! 1469: uschar *tc = code;
! 1470: condcount = 0;
! 1471:
! 1472: do {
! 1473: condcount++;
! 1474: tc += (tc[1] << 8) | tc[2];
! 1475: }
! 1476: while (*tc != OP_KET);
! 1477:
! 1478: if (condcount > 2)
! 1479: {
! 1480: *errorptr = ERR27;
! 1481: goto FAILED;
! 1482: }
! 1483: }
! 1484:
! 1485: /* Handle updating of the required character. If the subpattern didn't
! 1486: set one, leave it as it was. Otherwise, update it for normal brackets of
! 1487: all kinds, forward assertions, and conditions with two branches. Don't
! 1488: update the literal count for forward assertions, however. If the bracket
! 1489: is followed by a quantifier with zero repeat, we have to back off. Hence
! 1490: the definition of prevreqchar and subcountlits outside the main loop so
! 1491: that they can be accessed for the back off. */
! 1492:
! 1493: if (subreqchar > 0 &&
! 1494: (bravalue >= OP_BRA || bravalue == OP_ONCE || bravalue == OP_ASSERT ||
! 1495: (bravalue == OP_COND && condcount == 2)))
! 1496: {
! 1497: prevreqchar = *reqchar;
! 1498: *reqchar = subreqchar;
! 1499: if (bravalue != OP_ASSERT) *countlits += subcountlits;
! 1500: }
! 1501:
! 1502: /* Now update the main code pointer to the end of the group. */
! 1503:
! 1504: code = tempcode;
! 1505:
! 1506: /* Error if hit end of pattern */
! 1507:
! 1508: if (*ptr != ')')
! 1509: {
! 1510: *errorptr = ERR14;
! 1511: goto FAILED;
! 1512: }
! 1513: break;
! 1514:
! 1515: /* Check \ for being a real metacharacter; if not, fall through and handle
! 1516: it as a data character at the start of a string. Escape items are checked
! 1517: for validity in the pre-compiling pass. */
! 1518:
! 1519: case '\\':
! 1520: tempptr = ptr;
! 1521: c = check_escape(&ptr, errorptr, *brackets, options, FALSE, cd);
! 1522:
! 1523: /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
! 1524: are arranged to be the negation of the corresponding OP_values. For the
! 1525: back references, the values are ESC_REF plus the reference number. Only
! 1526: back references and those types that consume a character may be repeated.
! 1527: We can test for values between ESC_b and ESC_Z for the latter; this may
! 1528: have to change if any new ones are ever created. */
! 1529:
! 1530: if (c < 0)
! 1531: {
! 1532: if (-c >= ESC_REF)
! 1533: {
! 1534: previous = code;
! 1535: *code++ = OP_REF;
! 1536: *code++ = -c - ESC_REF;
! 1537: }
! 1538: else
! 1539: {
! 1540: previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
! 1541: *code++ = -c;
! 1542: }
! 1543: continue;
! 1544: }
! 1545:
! 1546: /* Data character: reset and fall through */
! 1547:
! 1548: ptr = tempptr;
! 1549: c = '\\';
! 1550:
! 1551: /* Handle a run of data characters until a metacharacter is encountered.
! 1552: The first character is guaranteed not to be whitespace or # when the
! 1553: extended flag is set. */
! 1554:
! 1555: NORMAL_CHAR:
! 1556: default:
! 1557: previous = code;
! 1558: *code = OP_CHARS;
! 1559: code += 2;
! 1560: length = 0;
! 1561:
! 1562: do
! 1563: {
! 1564: if ((options & PCRE_EXTENDED) != 0)
! 1565: {
! 1566: if ((cd->ctypes[c] & ctype_space) != 0) continue;
! 1567: if (c == '#')
! 1568: {
! 1569: while ((c = *(++ptr)) != 0 && c != '\n');
! 1570: if (c == 0) break;
! 1571: continue;
! 1572: }
! 1573: }
! 1574:
! 1575: /* Backslash may introduce a data char or a metacharacter. Escaped items
! 1576: are checked for validity in the pre-compiling pass. Stop the string
! 1577: before a metaitem. */
! 1578:
! 1579: if (c == '\\')
! 1580: {
! 1581: tempptr = ptr;
! 1582: c = check_escape(&ptr, errorptr, *brackets, options, FALSE, cd);
! 1583: if (c < 0) { ptr = tempptr; break; }
! 1584: }
! 1585:
! 1586: /* Ordinary character or single-char escape */
! 1587:
! 1588: *code++ = c;
! 1589: length++;
! 1590: }
! 1591:
! 1592: /* This "while" is the end of the "do" above. */
! 1593:
! 1594: while (length < 255 && (cd->ctypes[c = *(++ptr)] & ctype_meta) == 0);
! 1595:
! 1596: /* Update the last character and the count of literals */
! 1597:
! 1598: prevreqchar = (length > 1)? code[-2] : *reqchar;
! 1599: *reqchar = code[-1];
! 1600: *countlits += length;
! 1601:
! 1602: /* Compute the length and set it in the data vector, and advance to
! 1603: the next state. */
! 1604:
! 1605: previous[1] = length;
! 1606: if (length < 255) ptr--;
! 1607: break;
! 1608: }
! 1609: } /* end of big loop */
! 1610:
! 1611: /* Control never reaches here by falling through, only by a goto for all the
! 1612: error states. Pass back the position in the pattern so that it can be displayed
! 1613: to the user for diagnosing the error. */
! 1614:
! 1615: FAILED:
! 1616: *ptrptr = ptr;
! 1617: return FALSE;
! 1618: }
! 1619:
! 1620:
! 1621:
! 1622:
! 1623: /*************************************************
! 1624: * Compile sequence of alternatives *
! 1625: *************************************************/
! 1626:
! 1627: /* On entry, ptr is pointing past the bracket character, but on return
! 1628: it points to the closing bracket, or vertical bar, or end of string.
! 1629: The code variable is pointing at the byte into which the BRA operator has been
! 1630: stored. If the ims options are changed at the start (for a (?ims: group) or
! 1631: during any branch, we need to insert an OP_OPT item at the start of every
! 1632: following branch to ensure they get set correctly at run time, and also pass
! 1633: the new options into every subsequent branch compile.
! 1634:
! 1635: Argument:
! 1636: options the option bits
! 1637: optchanged new ims options to set as if (?ims) were at the start, or -1
! 1638: for no change
! 1639: brackets -> int containing the number of extracting brackets used
! 1640: codeptr -> the address of the current code pointer
! 1641: ptrptr -> the address of the current pattern pointer
! 1642: errorptr -> pointer to error message
! 1643: lookbehind TRUE if this is a lookbehind assertion
! 1644: condref > 0 for OPT_CREF setting at start of conditional group
! 1645: reqchar -> place to put the last required character, or a negative number
! 1646: countlits -> place to put the shortest literal count of any branch
! 1647: cd points to the data block with tables pointers
! 1648:
! 1649: Returns: TRUE on success
! 1650: */
! 1651:
! 1652: static BOOL
! 1653: compile_regex(int options, int optchanged, int *brackets, uschar **codeptr,
! 1654: const uschar **ptrptr, const char **errorptr, BOOL lookbehind, int condref,
! 1655: int *reqchar, int *countlits, compile_data *cd)
! 1656: {
! 1657: const uschar *ptr = *ptrptr;
! 1658: uschar *code = *codeptr;
! 1659: uschar *last_branch = code;
! 1660: uschar *start_bracket = code;
! 1661: uschar *reverse_count = NULL;
! 1662: int oldoptions = options & PCRE_IMS;
! 1663: int branchreqchar, branchcountlits;
! 1664:
! 1665: *reqchar = -1;
! 1666: *countlits = PCRE_MAX_POS;
! 1667: code += 3;
! 1668:
! 1669: /* At the start of a reference-based conditional group, insert the reference
! 1670: number as an OP_CREF item. */
! 1671:
! 1672: if (condref > 0)
! 1673: {
! 1674: *code++ = OP_CREF;
! 1675: *code++ = condref;
! 1676: }
! 1677:
! 1678: /* Loop for each alternative branch */
! 1679:
! 1680: for (;;)
! 1681: {
! 1682: int length;
! 1683:
! 1684: /* Handle change of options */
! 1685:
! 1686: if (optchanged >= 0)
! 1687: {
! 1688: *code++ = OP_OPT;
! 1689: *code++ = optchanged;
! 1690: options = (options & ~PCRE_IMS) | optchanged;
! 1691: }
! 1692:
! 1693: /* Set up dummy OP_REVERSE if lookbehind assertion */
! 1694:
! 1695: if (lookbehind)
! 1696: {
! 1697: *code++ = OP_REVERSE;
! 1698: reverse_count = code;
! 1699: *code++ = 0;
! 1700: *code++ = 0;
! 1701: }
! 1702:
! 1703: /* Now compile the branch */
! 1704:
! 1705: if (!compile_branch(options, brackets, &code, &ptr, errorptr, &optchanged,
! 1706: &branchreqchar, &branchcountlits, cd))
! 1707: {
! 1708: *ptrptr = ptr;
! 1709: return FALSE;
! 1710: }
! 1711:
! 1712: /* Fill in the length of the last branch */
! 1713:
! 1714: length = code - last_branch;
! 1715: last_branch[1] = length >> 8;
! 1716: last_branch[2] = length & 255;
! 1717:
! 1718: /* Save the last required character if all branches have the same; a current
! 1719: value of -1 means unset, while -2 means "previous branch had no last required
! 1720: char". */
! 1721:
! 1722: if (*reqchar != -2)
! 1723: {
! 1724: if (branchreqchar >= 0)
! 1725: {
! 1726: if (*reqchar == -1) *reqchar = branchreqchar;
! 1727: else if (*reqchar != branchreqchar) *reqchar = -2;
! 1728: }
! 1729: else *reqchar = -2;
! 1730: }
! 1731:
! 1732: /* Keep the shortest literal count */
! 1733:
! 1734: if (branchcountlits < *countlits) *countlits = branchcountlits;
! 1735: DPRINTF(("literal count = %d min=%d\n", branchcountlits, *countlits));
! 1736:
! 1737: /* If lookbehind, check that this branch matches a fixed-length string,
! 1738: and put the length into the OP_REVERSE item. Temporarily mark the end of
! 1739: the branch with OP_END. */
! 1740:
! 1741: if (lookbehind)
! 1742: {
! 1743: *code = OP_END;
! 1744: length = find_fixedlength(last_branch);
! 1745: DPRINTF(("fixed length = %d\n", length));
! 1746: if (length < 0)
! 1747: {
! 1748: *errorptr = ERR25;
! 1749: *ptrptr = ptr;
! 1750: return FALSE;
! 1751: }
! 1752: reverse_count[0] = (length >> 8);
! 1753: reverse_count[1] = length & 255;
! 1754: }
! 1755:
! 1756: /* Reached end of expression, either ')' or end of pattern. Insert a
! 1757: terminating ket and the length of the whole bracketed item, and return,
! 1758: leaving the pointer at the terminating char. If any of the ims options
! 1759: were changed inside the group, compile a resetting op-code following. */
! 1760:
! 1761: if (*ptr != '|')
! 1762: {
! 1763: length = code - start_bracket;
! 1764: *code++ = OP_KET;
! 1765: *code++ = length >> 8;
! 1766: *code++ = length & 255;
! 1767: if (optchanged >= 0)
! 1768: {
! 1769: *code++ = OP_OPT;
! 1770: *code++ = oldoptions;
! 1771: }
! 1772: *codeptr = code;
! 1773: *ptrptr = ptr;
! 1774: return TRUE;
! 1775: }
! 1776:
! 1777: /* Another branch follows; insert an "or" node and advance the pointer. */
! 1778:
! 1779: *code = OP_ALT;
! 1780: last_branch = code;
! 1781: code += 3;
! 1782: ptr++;
! 1783: }
! 1784: /* Control never reaches here */
! 1785: }
! 1786:
! 1787:
! 1788:
! 1789:
! 1790: /*************************************************
! 1791: * Find first significant op code *
! 1792: *************************************************/
! 1793:
! 1794: /* This is called by several functions that scan a compiled expression looking
! 1795: for a fixed first character, or an anchoring op code etc. It skips over things
! 1796: that do not influence this. For one application, a change of caseless option is
! 1797: important.
! 1798:
! 1799: Arguments:
! 1800: code pointer to the start of the group
! 1801: options pointer to external options
! 1802: optbit the option bit whose changing is significant, or
! 1803: zero if none are
! 1804: optstop TRUE to return on option change, otherwise change the options
! 1805: value and continue
! 1806:
! 1807: Returns: pointer to the first significant opcode
! 1808: */
! 1809:
! 1810: static const uschar*
! 1811: first_significant_code(const uschar *code, int *options, int optbit,
! 1812: BOOL optstop)
! 1813: {
! 1814: for (;;)
! 1815: {
! 1816: switch ((int)*code)
! 1817: {
! 1818: case OP_OPT:
! 1819: if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))
! 1820: {
! 1821: if (optstop) return code;
! 1822: *options = (int)code[1];
! 1823: }
! 1824: code += 2;
! 1825: break;
! 1826:
! 1827: case OP_CREF:
! 1828: code += 2;
! 1829: break;
! 1830:
! 1831: case OP_WORD_BOUNDARY:
! 1832: case OP_NOT_WORD_BOUNDARY:
! 1833: code++;
! 1834: break;
! 1835:
! 1836: case OP_ASSERT_NOT:
! 1837: case OP_ASSERTBACK:
! 1838: case OP_ASSERTBACK_NOT:
! 1839: do code += (code[1] << 8) + code[2]; while (*code == OP_ALT);
! 1840: code += 3;
! 1841: break;
! 1842:
! 1843: default:
! 1844: return code;
! 1845: }
! 1846: }
! 1847: /* Control never reaches here */
! 1848: }
! 1849:
! 1850:
! 1851:
! 1852:
! 1853: /*************************************************
! 1854: * Check for anchored expression *
! 1855: *************************************************/
! 1856:
! 1857: /* Try to find out if this is an anchored regular expression. Consider each
! 1858: alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
! 1859: all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
! 1860: it's anchored. However, if this is a multiline pattern, then only OP_SOD
! 1861: counts, since OP_CIRC can match in the middle.
! 1862:
! 1863: A branch is also implicitly anchored if it starts with .* and DOTALL is set,
! 1864: because that will try the rest of the pattern at all possible matching points,
! 1865: so there is no point trying them again.
! 1866:
! 1867: Arguments:
! 1868: code points to start of expression (the bracket)
! 1869: options points to the options setting
! 1870:
! 1871: Returns: TRUE or FALSE
! 1872: */
! 1873:
! 1874: static BOOL
! 1875: is_anchored(register const uschar *code, int *options)
! 1876: {
! 1877: do {
! 1878: const uschar *scode = first_significant_code(code + 3, options,
! 1879: PCRE_MULTILINE, FALSE);
! 1880: register int op = *scode;
! 1881: if (op >= OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
! 1882: { if (!is_anchored(scode, options)) return FALSE; }
! 1883: else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR) &&
! 1884: (*options & PCRE_DOTALL) != 0)
! 1885: { if (scode[1] != OP_ANY) return FALSE; }
! 1886: else if (op != OP_SOD &&
! 1887: ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
! 1888: return FALSE;
! 1889: code += (code[1] << 8) + code[2];
! 1890: }
! 1891: while (*code == OP_ALT);
! 1892: return TRUE;
! 1893: }
! 1894:
! 1895:
! 1896:
! 1897: /*************************************************
! 1898: * Check for starting with ^ or .* *
! 1899: *************************************************/
! 1900:
! 1901: /* This is called to find out if every branch starts with ^ or .* so that
! 1902: "first char" processing can be done to speed things up in multiline
! 1903: matching and for non-DOTALL patterns that start with .* (which must start at
! 1904: the beginning or after \n).
! 1905:
! 1906: Argument: points to start of expression (the bracket)
! 1907: Returns: TRUE or FALSE
! 1908: */
! 1909:
! 1910: static BOOL
! 1911: is_startline(const uschar *code)
! 1912: {
! 1913: do {
! 1914: const uschar *scode = first_significant_code(code + 3, NULL, 0, FALSE);
! 1915: register int op = *scode;
! 1916: if (op >= OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
! 1917: { if (!is_startline(scode)) return FALSE; }
! 1918: else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
! 1919: { if (scode[1] != OP_ANY) return FALSE; }
! 1920: else if (op != OP_CIRC) return FALSE;
! 1921: code += (code[1] << 8) + code[2];
! 1922: }
! 1923: while (*code == OP_ALT);
! 1924: return TRUE;
! 1925: }
! 1926:
! 1927:
! 1928:
! 1929: /*************************************************
! 1930: * Check for fixed first char *
! 1931: *************************************************/
! 1932:
! 1933: /* Try to find out if there is a fixed first character. This is called for
! 1934: unanchored expressions, as it speeds up their processing quite considerably.
! 1935: Consider each alternative branch. If they all start with the same char, or with
! 1936: a bracket all of whose alternatives start with the same char (recurse ad lib),
! 1937: then we return that char, otherwise -1.
! 1938:
! 1939: Arguments:
! 1940: code points to start of expression (the bracket)
! 1941: options pointer to the options (used to check casing changes)
! 1942:
! 1943: Returns: -1 or the fixed first char
! 1944: */
! 1945:
! 1946: static int
! 1947: find_firstchar(const uschar *code, int *options)
! 1948: {
! 1949: register int c = -1;
! 1950: do {
! 1951: int d;
! 1952: const uschar *scode = first_significant_code(code + 3, options,
! 1953: PCRE_CASELESS, TRUE);
! 1954: register int op = *scode;
! 1955:
! 1956: if (op >= OP_BRA) op = OP_BRA;
! 1957:
! 1958: switch(op)
! 1959: {
! 1960: default:
! 1961: return -1;
! 1962:
! 1963: case OP_BRA:
! 1964: case OP_ASSERT:
! 1965: case OP_ONCE:
! 1966: case OP_COND:
! 1967: if ((d = find_firstchar(scode, options)) < 0) return -1;
! 1968: if (c < 0) c = d; else if (c != d) return -1;
! 1969: break;
! 1970:
! 1971: case OP_EXACT: /* Fall through */
! 1972: scode++;
! 1973:
! 1974: case OP_CHARS: /* Fall through */
! 1975: scode++;
! 1976:
! 1977: case OP_PLUS:
! 1978: case OP_MINPLUS:
! 1979: if (c < 0) c = scode[1]; else if (c != scode[1]) return -1;
! 1980: break;
! 1981: }
! 1982:
! 1983: code += (code[1] << 8) + code[2];
! 1984: }
! 1985: while (*code == OP_ALT);
! 1986: return c;
! 1987: }
! 1988:
! 1989:
! 1990:
! 1991:
! 1992:
! 1993: /*************************************************
! 1994: * Compile a Regular Expression *
! 1995: *************************************************/
! 1996:
! 1997: /* This function takes a string and returns a pointer to a block of store
! 1998: holding a compiled version of the expression.
! 1999:
! 2000: Arguments:
! 2001: pattern the regular expression
! 2002: options various option bits
! 2003: errorptr pointer to pointer to error text
! 2004: erroroffset ptr offset in pattern where error was detected
! 2005: tables pointer to character tables or NULL
! 2006:
! 2007: Returns: pointer to compiled data block, or NULL on error,
! 2008: with errorptr and erroroffset set
! 2009: */
! 2010:
! 2011: pcre *
! 2012: pcre_compile(const char *pattern, int options, const char **errorptr,
! 2013: int *erroroffset, const unsigned char *tables)
! 2014: {
! 2015: real_pcre *re;
! 2016: int length = 3; /* For initial BRA plus length */
! 2017: int runlength;
! 2018: int c, size, reqchar, countlits;
! 2019: int bracount = 0;
! 2020: int top_backref = 0;
! 2021: int branch_extra = 0;
! 2022: int branch_newextra;
! 2023: unsigned int brastackptr = 0;
! 2024: uschar *code;
! 2025: const uschar *ptr;
! 2026: compile_data compile_block;
! 2027: int brastack[BRASTACK_SIZE];
! 2028: uschar bralenstack[BRASTACK_SIZE];
! 2029:
! 2030: #ifdef DEBUG
! 2031: uschar *code_base, *code_end;
! 2032: #endif
! 2033:
! 2034: /* We can't pass back an error message if errorptr is NULL; I guess the best we
! 2035: can do is just return NULL. */
! 2036:
! 2037: if (errorptr == NULL) return NULL;
! 2038: *errorptr = NULL;
! 2039:
! 2040: /* However, we can give a message for this error */
! 2041:
! 2042: if (erroroffset == NULL)
! 2043: {
! 2044: *errorptr = ERR16;
! 2045: return NULL;
! 2046: }
! 2047: *erroroffset = 0;
! 2048:
! 2049: if ((options & ~PUBLIC_OPTIONS) != 0)
! 2050: {
! 2051: *errorptr = ERR17;
! 2052: return NULL;
! 2053: }
! 2054:
! 2055: /* Set up pointers to the individual character tables */
! 2056:
! 2057: if (tables == NULL) tables = pcre_default_tables;
! 2058: compile_block.lcc = tables + lcc_offset;
! 2059: compile_block.fcc = tables + fcc_offset;
! 2060: compile_block.cbits = tables + cbits_offset;
! 2061: compile_block.ctypes = tables + ctypes_offset;
! 2062:
! 2063: /* Reflect pattern for debugging output */
! 2064:
! 2065: DPRINTF(("------------------------------------------------------------------\n"));
! 2066: DPRINTF(("%s\n", pattern));
! 2067:
! 2068: /* The first thing to do is to make a pass over the pattern to compute the
! 2069: amount of store required to hold the compiled code. This does not have to be
! 2070: perfect as long as errors are overestimates. At the same time we can detect any
! 2071: internal flag settings. Make an attempt to correct for any counted white space
! 2072: if an "extended" flag setting appears late in the pattern. We can't be so
! 2073: clever for #-comments. */
! 2074:
! 2075: ptr = (const uschar *)(pattern - 1);
! 2076: while ((c = *(++ptr)) != 0)
! 2077: {
! 2078: int min, max;
! 2079: int class_charcount;
! 2080:
! 2081: if ((options & PCRE_EXTENDED) != 0)
! 2082: {
! 2083: if ((compile_block.ctypes[c] & ctype_space) != 0) continue;
! 2084: if (c == '#')
! 2085: {
! 2086: while ((c = *(++ptr)) != 0 && c != '\n');
! 2087: continue;
! 2088: }
! 2089: }
! 2090:
! 2091: switch(c)
! 2092: {
! 2093: /* A backslashed item may be an escaped "normal" character or a
! 2094: character type. For a "normal" character, put the pointers and
! 2095: character back so that tests for whitespace etc. in the input
! 2096: are done correctly. */
! 2097:
! 2098: case '\\':
! 2099: {
! 2100: const uschar *save_ptr = ptr;
! 2101: c = check_escape(&ptr, errorptr, bracount, options, FALSE, &compile_block);
! 2102: if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
! 2103: if (c >= 0)
! 2104: {
! 2105: ptr = save_ptr;
! 2106: c = '\\';
! 2107: goto NORMAL_CHAR;
! 2108: }
! 2109: }
! 2110: length++;
! 2111:
! 2112: /* A back reference needs an additional char, plus either one or 5
! 2113: bytes for a repeat. We also need to keep the value of the highest
! 2114: back reference. */
! 2115:
! 2116: if (c <= -ESC_REF)
! 2117: {
! 2118: int refnum = -c - ESC_REF;
! 2119: if (refnum > top_backref) top_backref = refnum;
! 2120: length++; /* For single back reference */
! 2121: if (ptr[1] == '{' && is_counted_repeat(ptr+2, &compile_block))
! 2122: {
! 2123: ptr = read_repeat_counts(ptr+2, &min, &max, errorptr, &compile_block);
! 2124: if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
! 2125: if ((min == 0 && (max == 1 || max == -1)) ||
! 2126: (min == 1 && max == -1))
! 2127: length++;
! 2128: else length += 5;
! 2129: if (ptr[1] == '?') ptr++;
! 2130: }
! 2131: }
! 2132: continue;
! 2133:
! 2134: case '^':
! 2135: case '.':
! 2136: case '$':
! 2137: case '*': /* These repeats won't be after brackets; */
! 2138: case '+': /* those are handled separately */
! 2139: case '?':
! 2140: length++;
! 2141: continue;
! 2142:
! 2143: /* This covers the cases of repeats after a single char, metachar, class,
! 2144: or back reference. */
! 2145:
! 2146: case '{':
! 2147: if (!is_counted_repeat(ptr+1, &compile_block)) goto NORMAL_CHAR;
! 2148: ptr = read_repeat_counts(ptr+1, &min, &max, errorptr, &compile_block);
! 2149: if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
! 2150: if ((min == 0 && (max == 1 || max == -1)) ||
! 2151: (min == 1 && max == -1))
! 2152: length++;
! 2153: else
! 2154: {
! 2155: length--; /* Uncount the original char or metachar */
! 2156: if (min == 1) length++; else if (min > 0) length += 4;
! 2157: if (max > 0) length += 4; else length += 2;
! 2158: }
! 2159: if (ptr[1] == '?') ptr++;
! 2160: continue;
! 2161:
! 2162: /* An alternation contains an offset to the next branch or ket. If any ims
! 2163: options changed in the previous branch(es), and/or if we are in a
! 2164: lookbehind assertion, extra space will be needed at the start of the
! 2165: branch. This is handled by branch_extra. */
! 2166:
! 2167: case '|':
! 2168: length += 3 + branch_extra;
! 2169: continue;
! 2170:
! 2171: /* A character class uses 33 characters. Don't worry about character types
! 2172: that aren't allowed in classes - they'll get picked up during the compile.
! 2173: A character class that contains only one character uses 2 or 3 bytes,
! 2174: depending on whether it is negated or not. Notice this where we can. */
! 2175:
! 2176: case '[':
! 2177: class_charcount = 0;
! 2178: if (*(++ptr) == '^') ptr++;
! 2179: do
! 2180: {
! 2181: if (*ptr == '\\')
! 2182: {
! 2183: int ch = check_escape(&ptr, errorptr, bracount, options, TRUE,
! 2184: &compile_block);
! 2185: if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
! 2186: if (-ch == ESC_b) class_charcount++; else class_charcount = 10;
! 2187: }
! 2188: else class_charcount++;
! 2189: ptr++;
! 2190: }
! 2191: while (*ptr != 0 && *ptr != ']');
! 2192:
! 2193: /* Repeats for negated single chars are handled by the general code */
! 2194:
! 2195: if (class_charcount == 1) length += 3; else
! 2196: {
! 2197: length += 33;
! 2198:
! 2199: /* A repeat needs either 1 or 5 bytes. */
! 2200:
! 2201: if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2, &compile_block))
! 2202: {
! 2203: ptr = read_repeat_counts(ptr+2, &min, &max, errorptr, &compile_block);
! 2204: if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
! 2205: if ((min == 0 && (max == 1 || max == -1)) ||
! 2206: (min == 1 && max == -1))
! 2207: length++;
! 2208: else length += 5;
! 2209: if (ptr[1] == '?') ptr++;
! 2210: }
! 2211: }
! 2212: continue;
! 2213:
! 2214: /* Brackets may be genuine groups or special things */
! 2215:
! 2216: case '(':
! 2217: branch_newextra = 0;
! 2218:
! 2219: /* Handle special forms of bracket, which all start (? */
! 2220:
! 2221: if (ptr[1] == '?')
! 2222: {
! 2223: int set, unset;
! 2224: int *optset;
! 2225:
! 2226: switch (c = ptr[2])
! 2227: {
! 2228: /* Skip over comments entirely */
! 2229: case '#':
! 2230: ptr += 3;
! 2231: while (*ptr != 0 && *ptr != ')') ptr++;
! 2232: if (*ptr == 0)
! 2233: {
! 2234: *errorptr = ERR18;
! 2235: goto PCRE_ERROR_RETURN;
! 2236: }
! 2237: continue;
! 2238:
! 2239: /* Non-referencing groups and lookaheads just move the pointer on, and
! 2240: then behave like a non-special bracket, except that they don't increment
! 2241: the count of extracting brackets. Ditto for the "once only" bracket,
! 2242: which is in Perl from version 5.005. */
! 2243:
! 2244: case ':':
! 2245: case '=':
! 2246: case '!':
! 2247: case '>':
! 2248: ptr += 2;
! 2249: break;
! 2250:
! 2251: /* Lookbehinds are in Perl from version 5.005 */
! 2252:
! 2253: case '<':
! 2254: if (ptr[3] == '=' || ptr[3] == '!')
! 2255: {
! 2256: ptr += 3;
! 2257: branch_newextra = 3;
! 2258: length += 3; /* For the first branch */
! 2259: break;
! 2260: }
! 2261: *errorptr = ERR24;
! 2262: goto PCRE_ERROR_RETURN;
! 2263:
! 2264: /* Conditionals are in Perl from version 5.005. The bracket must either
! 2265: be followed by a number (for bracket reference) or by an assertion
! 2266: group. */
! 2267:
! 2268: case '(':
! 2269: if ((compile_block.ctypes[ptr[3]] & ctype_digit) != 0)
! 2270: {
! 2271: ptr += 4;
! 2272: length += 2;
! 2273: while ((compile_block.ctypes[*ptr] & ctype_digit) != 0) ptr++;
! 2274: if (*ptr != ')')
! 2275: {
! 2276: *errorptr = ERR26;
! 2277: goto PCRE_ERROR_RETURN;
! 2278: }
! 2279: }
! 2280: else /* An assertion must follow */
! 2281: {
! 2282: ptr++; /* Can treat like ':' as far as spacing is concerned */
! 2283:
! 2284: if (ptr[2] != '?' || strchr("=!<", ptr[3]) == NULL)
! 2285: {
! 2286: ptr += 2; /* To get right offset in message */
! 2287: *errorptr = ERR28;
! 2288: goto PCRE_ERROR_RETURN;
! 2289: }
! 2290: }
! 2291: break;
! 2292:
! 2293: /* Else loop checking valid options until ) is met. Anything else is an
! 2294: error. If we are without any brackets, i.e. at top level, the settings
! 2295: act as if specified in the options, so massage the options immediately.
! 2296: This is for backward compatibility with Perl 5.004. */
! 2297:
! 2298: default:
! 2299: set = unset = 0;
! 2300: optset = &set;
! 2301: ptr += 2;
! 2302:
! 2303: for (;; ptr++)
! 2304: {
! 2305: c = *ptr;
! 2306: switch (c)
! 2307: {
! 2308: case 'i':
! 2309: *optset |= PCRE_CASELESS;
! 2310: continue;
! 2311:
! 2312: case 'm':
! 2313: *optset |= PCRE_MULTILINE;
! 2314: continue;
! 2315:
! 2316: case 's':
! 2317: *optset |= PCRE_DOTALL;
! 2318: continue;
! 2319:
! 2320: case 'x':
! 2321: *optset |= PCRE_EXTENDED;
! 2322: continue;
! 2323:
! 2324: case 'X':
! 2325: *optset |= PCRE_EXTRA;
! 2326: continue;
! 2327:
! 2328: case 'U':
! 2329: *optset |= PCRE_UNGREEDY;
! 2330: continue;
! 2331:
! 2332: case '-':
! 2333: optset = &unset;
! 2334: continue;
! 2335:
! 2336: /* A termination by ')' indicates an options-setting-only item;
! 2337: this is global at top level; otherwise nothing is done here and
! 2338: it is handled during the compiling process on a per-bracket-group
! 2339: basis. */
! 2340:
! 2341: case ')':
! 2342: if (brastackptr == 0)
! 2343: {
! 2344: options = (options | set) & (~unset);
! 2345: set = unset = 0; /* To save length */
! 2346: }
! 2347: /* Fall through */
! 2348:
! 2349: /* A termination by ':' indicates the start of a nested group with
! 2350: the given options set. This is again handled at compile time, but
! 2351: we must allow for compiled space if any of the ims options are
! 2352: set. We also have to allow for resetting space at the end of
! 2353: the group, which is why 4 is added to the length and not just 2.
! 2354: If there are several changes of options within the same group, this
! 2355: will lead to an over-estimate on the length, but this shouldn't
! 2356: matter very much. We also have to allow for resetting options at
! 2357: the start of any alternations, which we do by setting
! 2358: branch_newextra to 2. Finally, we record whether the case-dependent
! 2359: flag ever changes within the regex. This is used by the "required
! 2360: character" code. */
! 2361:
! 2362: case ':':
! 2363: if (((set|unset) & PCRE_IMS) != 0)
! 2364: {
! 2365: length += 4;
! 2366: branch_newextra = 2;
! 2367: if (((set|unset) & PCRE_CASELESS) != 0) options |= PCRE_ICHANGED;
! 2368: }
! 2369: goto END_OPTIONS;
! 2370:
! 2371: /* Unrecognized option character */
! 2372:
! 2373: default:
! 2374: *errorptr = ERR12;
! 2375: goto PCRE_ERROR_RETURN;
! 2376: }
! 2377: }
! 2378:
! 2379: /* If we hit a closing bracket, that's it - this is a freestanding
! 2380: option-setting. We need to ensure that branch_extra is updated if
! 2381: necessary. The only values branch_newextra can have here are 0 or 2.
! 2382: If the value is 2, then branch_extra must either be 2 or 5, depending
! 2383: on whether this is a lookbehind group or not. */
! 2384:
! 2385: END_OPTIONS:
! 2386: if (c == ')')
! 2387: {
! 2388: if (branch_newextra == 2 && (branch_extra == 0 || branch_extra == 3))
! 2389: branch_extra += branch_newextra;
! 2390: continue;
! 2391: }
! 2392:
! 2393: /* If options were terminated by ':' control comes here. Fall through
! 2394: to handle the group below. */
! 2395: }
! 2396: }
! 2397:
! 2398: /* Extracting brackets must be counted so we can process escapes in a
! 2399: Perlish way. */
! 2400:
! 2401: else bracount++;
! 2402:
! 2403: /* Non-special forms of bracket. Save length for computing whole length
! 2404: at end if there's a repeat that requires duplication of the group. Also
! 2405: save the current value of branch_extra, and start the new group with
! 2406: the new value. If non-zero, this will either be 2 for a (?imsx: group, or 3
! 2407: for a lookbehind assertion. */
! 2408:
! 2409: if (brastackptr >= sizeof(brastack)/sizeof(int))
! 2410: {
! 2411: *errorptr = ERR19;
! 2412: goto PCRE_ERROR_RETURN;
! 2413: }
! 2414:
! 2415: bralenstack[brastackptr] = branch_extra;
! 2416: branch_extra = branch_newextra;
! 2417:
! 2418: brastack[brastackptr++] = length;
! 2419: length += 3;
! 2420: continue;
! 2421:
! 2422: /* Handle ket. Look for subsequent max/min; for certain sets of values we
! 2423: have to replicate this bracket up to that many times. If brastackptr is
! 2424: 0 this is an unmatched bracket which will generate an error, but take care
! 2425: not to try to access brastack[-1] when computing the length and restoring
! 2426: the branch_extra value. */
! 2427:
! 2428: case ')':
! 2429: length += 3;
! 2430: {
! 2431: int minval = 1;
! 2432: int maxval = 1;
! 2433: int duplength;
! 2434:
! 2435: if (brastackptr > 0)
! 2436: {
! 2437: duplength = length - brastack[--brastackptr];
! 2438: branch_extra = bralenstack[brastackptr];
! 2439: }
! 2440: else duplength = 0;
! 2441:
! 2442: /* Leave ptr at the final char; for read_repeat_counts this happens
! 2443: automatically; for the others we need an increment. */
! 2444:
! 2445: if ((c = ptr[1]) == '{' && is_counted_repeat(ptr+2, &compile_block))
! 2446: {
! 2447: ptr = read_repeat_counts(ptr+2, &minval, &maxval, errorptr,
! 2448: &compile_block);
! 2449: if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
! 2450: }
! 2451: else if (c == '*') { minval = 0; maxval = -1; ptr++; }
! 2452: else if (c == '+') { maxval = -1; ptr++; }
! 2453: else if (c == '?') { minval = 0; ptr++; }
! 2454:
! 2455: /* If the minimum is zero, we have to allow for an OP_BRAZERO before the
! 2456: group, and if the maximum is greater than zero, we have to replicate
! 2457: maxval-1 times; each replication acquires an OP_BRAZERO plus a nesting
! 2458: bracket set - hence the 7. */
! 2459:
! 2460: if (minval == 0)
! 2461: {
! 2462: length++;
! 2463: if (maxval > 0) length += (maxval - 1) * (duplength + 7);
! 2464: }
! 2465:
! 2466: /* When the minimum is greater than zero, 1 we have to replicate up to
! 2467: minval-1 times, with no additions required in the copies. Then, if
! 2468: there is a limited maximum we have to replicate up to maxval-1 times
! 2469: allowing for a BRAZERO item before each optional copy and nesting
! 2470: brackets for all but one of the optional copies. */
! 2471:
! 2472: else
! 2473: {
! 2474: length += (minval - 1) * duplength;
! 2475: if (maxval > minval) /* Need this test as maxval=-1 means no limit */
! 2476: length += (maxval - minval) * (duplength + 7) - 6;
! 2477: }
! 2478: }
! 2479: continue;
! 2480:
! 2481: /* Non-special character. For a run of such characters the length required
! 2482: is the number of characters + 2, except that the maximum run length is 255.
! 2483: We won't get a skipped space or a non-data escape or the start of a #
! 2484: comment as the first character, so the length can't be zero. */
! 2485:
! 2486: NORMAL_CHAR:
! 2487: default:
! 2488: length += 2;
! 2489: runlength = 0;
! 2490: do
! 2491: {
! 2492: if ((options & PCRE_EXTENDED) != 0)
! 2493: {
! 2494: if ((compile_block.ctypes[c] & ctype_space) != 0) continue;
! 2495: if (c == '#')
! 2496: {
! 2497: while ((c = *(++ptr)) != 0 && c != '\n');
! 2498: continue;
! 2499: }
! 2500: }
! 2501:
! 2502: /* Backslash may introduce a data char or a metacharacter; stop the
! 2503: string before the latter. */
! 2504:
! 2505: if (c == '\\')
! 2506: {
! 2507: const uschar *saveptr = ptr;
! 2508: c = check_escape(&ptr, errorptr, bracount, options, FALSE,
! 2509: &compile_block);
! 2510: if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
! 2511: if (c < 0) { ptr = saveptr; break; }
! 2512: }
! 2513:
! 2514: /* Ordinary character or single-char escape */
! 2515:
! 2516: runlength++;
! 2517: }
! 2518:
! 2519: /* This "while" is the end of the "do" above. */
! 2520:
! 2521: while (runlength < 255 &&
! 2522: (compile_block.ctypes[c = *(++ptr)] & ctype_meta) == 0);
! 2523:
! 2524: ptr--;
! 2525: length += runlength;
! 2526: continue;
! 2527: }
! 2528: }
! 2529:
! 2530: length += 4; /* For final KET and END */
! 2531:
! 2532: if (length > 65539)
! 2533: {
! 2534: *errorptr = ERR20;
! 2535: return NULL;
! 2536: }
! 2537:
! 2538: /* Compute the size of data block needed and get it, either from malloc or
! 2539: externally provided function. We specify "code[0]" in the offsetof() expression
! 2540: rather than just "code", because it has been reported that one broken compiler
! 2541: fails on "code" because it is also an independent variable. It should make no
! 2542: difference to the value of the offsetof(). */
! 2543:
! 2544: size = length + offsetof(real_pcre, code[0]);
! 2545: re = (real_pcre *)(pcre_malloc)(size);
! 2546:
! 2547: if (re == NULL)
! 2548: {
! 2549: *errorptr = ERR21;
! 2550: return NULL;
! 2551: }
! 2552:
! 2553: /* Put in the magic number and the options. */
! 2554:
! 2555: re->magic_number = MAGIC_NUMBER;
! 2556: re->options = options;
! 2557: re->tables = tables;
! 2558:
! 2559: /* Set up a starting, non-extracting bracket, then compile the expression. On
! 2560: error, *errorptr will be set non-NULL, so we don't need to look at the result
! 2561: of the function here. */
! 2562:
! 2563: ptr = (const uschar *)pattern;
! 2564: code = re->code;
! 2565: *code = OP_BRA;
! 2566: bracount = 0;
! 2567: (void)compile_regex(options, -1, &bracount, &code, &ptr, errorptr, FALSE, -1,
! 2568: &reqchar, &countlits, &compile_block);
! 2569: re->top_bracket = bracount;
! 2570: re->top_backref = top_backref;
! 2571:
! 2572: /* If not reached end of pattern on success, there's an excess bracket. */
! 2573:
! 2574: if (*errorptr == NULL && *ptr != 0) *errorptr = ERR22;
! 2575:
! 2576: /* Fill in the terminating state and check for disastrous overflow, but
! 2577: if debugging, leave the test till after things are printed out. */
! 2578:
! 2579: *code++ = OP_END;
! 2580:
! 2581: #ifndef DEBUG
! 2582: if (code - re->code > length) *errorptr = ERR23;
! 2583: #endif
! 2584:
! 2585: /* Give an error if there's back reference to a non-existent capturing
! 2586: subpattern. */
! 2587:
! 2588: if (top_backref > re->top_bracket) *errorptr = ERR15;
! 2589:
! 2590: /* Failed to compile */
! 2591:
! 2592: if (*errorptr != NULL)
! 2593: {
! 2594: (pcre_free)(re);
! 2595: PCRE_ERROR_RETURN:
! 2596: *erroroffset = ptr - (const uschar *)pattern;
! 2597: return NULL;
! 2598: }
! 2599:
! 2600: /* If the anchored option was not passed, set flag if we can determine that the
! 2601: pattern is anchored by virtue of ^ characters or \A or anything else (such as
! 2602: starting with .* when DOTALL is set).
! 2603:
! 2604: Otherwise, see if we can determine what the first character has to be, because
! 2605: that speeds up unanchored matches no end. If not, see if we can set the
! 2606: PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
! 2607: start with ^. and also when all branches start with .* for non-DOTALL matches.
! 2608: */
! 2609:
! 2610: if ((options & PCRE_ANCHORED) == 0)
! 2611: {
! 2612: int temp_options = options;
! 2613: if (is_anchored(re->code, &temp_options))
! 2614: re->options |= PCRE_ANCHORED;
! 2615: else
! 2616: {
! 2617: int ch = find_firstchar(re->code, &temp_options);
! 2618: if (ch >= 0)
! 2619: {
! 2620: re->first_char = ch;
! 2621: re->options |= PCRE_FIRSTSET;
! 2622: }
! 2623: else if (is_startline(re->code))
! 2624: re->options |= PCRE_STARTLINE;
! 2625: }
! 2626: }
! 2627:
! 2628: /* Save the last required character if there are at least two literal
! 2629: characters on all paths, or if there is no first character setting. */
! 2630:
! 2631: if (reqchar >= 0 && (countlits > 1 || (re->options & PCRE_FIRSTSET) == 0))
! 2632: {
! 2633: re->req_char = reqchar;
! 2634: re->options |= PCRE_REQCHSET;
! 2635: }
! 2636:
! 2637: /* Print out the compiled data for debugging */
! 2638:
! 2639: #ifdef DEBUG
! 2640:
! 2641: printf("Length = %d top_bracket = %d top_backref = %d\n",
! 2642: length, re->top_bracket, re->top_backref);
! 2643:
! 2644: if (re->options != 0)
! 2645: {
! 2646: printf("%s%s%s%s%s%s%s%s%s\n",
! 2647: ((re->options & PCRE_ANCHORED) != 0)? "anchored " : "",
! 2648: ((re->options & PCRE_CASELESS) != 0)? "caseless " : "",
! 2649: ((re->options & PCRE_ICHANGED) != 0)? "case state changed " : "",
! 2650: ((re->options & PCRE_EXTENDED) != 0)? "extended " : "",
! 2651: ((re->options & PCRE_MULTILINE) != 0)? "multiline " : "",
! 2652: ((re->options & PCRE_DOTALL) != 0)? "dotall " : "",
! 2653: ((re->options & PCRE_DOLLAR_ENDONLY) != 0)? "endonly " : "",
! 2654: ((re->options & PCRE_EXTRA) != 0)? "extra " : "",
! 2655: ((re->options & PCRE_UNGREEDY) != 0)? "ungreedy " : "");
! 2656: }
! 2657:
! 2658: if ((re->options & PCRE_FIRSTSET) != 0)
! 2659: {
! 2660: if (isprint(re->first_char)) printf("First char = %c\n", re->first_char);
! 2661: else printf("First char = \\x%02x\n", re->first_char);
! 2662: }
! 2663:
! 2664: if ((re->options & PCRE_REQCHSET) != 0)
! 2665: {
! 2666: if (isprint(re->req_char)) printf("Req char = %c\n", re->req_char);
! 2667: else printf("Req char = \\x%02x\n", re->req_char);
! 2668: }
! 2669:
! 2670: code_end = code;
! 2671: code_base = code = re->code;
! 2672:
! 2673: while (code < code_end)
! 2674: {
! 2675: int charlength;
! 2676:
! 2677: printf("%3d ", code - code_base);
! 2678:
! 2679: if (*code >= OP_BRA)
! 2680: {
! 2681: printf("%3d Bra %d", (code[1] << 8) + code[2], *code - OP_BRA);
! 2682: code += 2;
! 2683: }
! 2684:
! 2685: else switch(*code)
! 2686: {
! 2687: case OP_OPT:
! 2688: printf(" %.2x %s", code[1], OP_names[*code]);
! 2689: code++;
! 2690: break;
! 2691:
! 2692: case OP_COND:
! 2693: printf("%3d Cond", (code[1] << 8) + code[2]);
! 2694: code += 2;
! 2695: break;
! 2696:
! 2697: case OP_CREF:
! 2698: printf(" %.2d %s", code[1], OP_names[*code]);
! 2699: code++;
! 2700: break;
! 2701:
! 2702: case OP_CHARS:
! 2703: charlength = *(++code);
! 2704: printf("%3d ", charlength);
! 2705: while (charlength-- > 0)
! 2706: if (isprint(c = *(++code))) printf("%c", c); else printf("\\x%02x", c);
! 2707: break;
! 2708:
! 2709: case OP_KETRMAX:
! 2710: case OP_KETRMIN:
! 2711: case OP_ALT:
! 2712: case OP_KET:
! 2713: case OP_ASSERT:
! 2714: case OP_ASSERT_NOT:
! 2715: case OP_ASSERTBACK:
! 2716: case OP_ASSERTBACK_NOT:
! 2717: case OP_ONCE:
! 2718: printf("%3d %s", (code[1] << 8) + code[2], OP_names[*code]);
! 2719: code += 2;
! 2720: break;
! 2721:
! 2722: case OP_REVERSE:
! 2723: printf("%3d %s", (code[1] << 8) + code[2], OP_names[*code]);
! 2724: code += 2;
! 2725: break;
! 2726:
! 2727: case OP_STAR:
! 2728: case OP_MINSTAR:
! 2729: case OP_PLUS:
! 2730: case OP_MINPLUS:
! 2731: case OP_QUERY:
! 2732: case OP_MINQUERY:
! 2733: case OP_TYPESTAR:
! 2734: case OP_TYPEMINSTAR:
! 2735: case OP_TYPEPLUS:
! 2736: case OP_TYPEMINPLUS:
! 2737: case OP_TYPEQUERY:
! 2738: case OP_TYPEMINQUERY:
! 2739: if (*code >= OP_TYPESTAR)
! 2740: printf(" %s", OP_names[code[1]]);
! 2741: else if (isprint(c = code[1])) printf(" %c", c);
! 2742: else printf(" \\x%02x", c);
! 2743: printf("%s", OP_names[*code++]);
! 2744: break;
! 2745:
! 2746: case OP_EXACT:
! 2747: case OP_UPTO:
! 2748: case OP_MINUPTO:
! 2749: if (isprint(c = code[3])) printf(" %c{", c);
! 2750: else printf(" \\x%02x{", c);
! 2751: if (*code != OP_EXACT) printf("0,");
! 2752: printf("%d}", (code[1] << 8) + code[2]);
! 2753: if (*code == OP_MINUPTO) printf("?");
! 2754: code += 3;
! 2755: break;
! 2756:
! 2757: case OP_TYPEEXACT:
! 2758: case OP_TYPEUPTO:
! 2759: case OP_TYPEMINUPTO:
! 2760: printf(" %s{", OP_names[code[3]]);
! 2761: if (*code != OP_TYPEEXACT) printf(",");
! 2762: printf("%d}", (code[1] << 8) + code[2]);
! 2763: if (*code == OP_TYPEMINUPTO) printf("?");
! 2764: code += 3;
! 2765: break;
! 2766:
! 2767: case OP_NOT:
! 2768: if (isprint(c = *(++code))) printf(" [^%c]", c);
! 2769: else printf(" [^\\x%02x]", c);
! 2770: break;
! 2771:
! 2772: case OP_NOTSTAR:
! 2773: case OP_NOTMINSTAR:
! 2774: case OP_NOTPLUS:
! 2775: case OP_NOTMINPLUS:
! 2776: case OP_NOTQUERY:
! 2777: case OP_NOTMINQUERY:
! 2778: if (isprint(c = code[1])) printf(" [^%c]", c);
! 2779: else printf(" [^\\x%02x]", c);
! 2780: printf("%s", OP_names[*code++]);
! 2781: break;
! 2782:
! 2783: case OP_NOTEXACT:
! 2784: case OP_NOTUPTO:
! 2785: case OP_NOTMINUPTO:
! 2786: if (isprint(c = code[3])) printf(" [^%c]{", c);
! 2787: else printf(" [^\\x%02x]{", c);
! 2788: if (*code != OP_NOTEXACT) printf(",");
! 2789: printf("%d}", (code[1] << 8) + code[2]);
! 2790: if (*code == OP_NOTMINUPTO) printf("?");
! 2791: code += 3;
! 2792: break;
! 2793:
! 2794: case OP_REF:
! 2795: printf(" \\%d", *(++code));
! 2796: code ++;
! 2797: goto CLASS_REF_REPEAT;
! 2798:
! 2799: case OP_CLASS:
! 2800: {
! 2801: int i, min, max;
! 2802: code++;
! 2803: printf(" [");
! 2804:
! 2805: for (i = 0; i < 256; i++)
! 2806: {
! 2807: if ((code[i/8] & (1 << (i&7))) != 0)
! 2808: {
! 2809: int j;
! 2810: for (j = i+1; j < 256; j++)
! 2811: if ((code[j/8] & (1 << (j&7))) == 0) break;
! 2812: if (i == '-' || i == ']') printf("\\");
! 2813: if (isprint(i)) printf("%c", i); else printf("\\x%02x", i);
! 2814: if (--j > i)
! 2815: {
! 2816: printf("-");
! 2817: if (j == '-' || j == ']') printf("\\");
! 2818: if (isprint(j)) printf("%c", j); else printf("\\x%02x", j);
! 2819: }
! 2820: i = j;
! 2821: }
! 2822: }
! 2823: printf("]");
! 2824: code += 32;
! 2825:
! 2826: CLASS_REF_REPEAT:
! 2827:
! 2828: switch(*code)
! 2829: {
! 2830: case OP_CRSTAR:
! 2831: case OP_CRMINSTAR:
! 2832: case OP_CRPLUS:
! 2833: case OP_CRMINPLUS:
! 2834: case OP_CRQUERY:
! 2835: case OP_CRMINQUERY:
! 2836: printf("%s", OP_names[*code]);
! 2837: break;
! 2838:
! 2839: case OP_CRRANGE:
! 2840: case OP_CRMINRANGE:
! 2841: min = (code[1] << 8) + code[2];
! 2842: max = (code[3] << 8) + code[4];
! 2843: if (max == 0) printf("{%d,}", min);
! 2844: else printf("{%d,%d}", min, max);
! 2845: if (*code == OP_CRMINRANGE) printf("?");
! 2846: code += 4;
! 2847: break;
! 2848:
! 2849: default:
! 2850: code--;
! 2851: }
! 2852: }
! 2853: break;
! 2854:
! 2855: /* Anything else is just a one-node item */
! 2856:
! 2857: default:
! 2858: printf(" %s", OP_names[*code]);
! 2859: break;
! 2860: }
! 2861:
! 2862: code++;
! 2863: printf("\n");
! 2864: }
! 2865: printf("------------------------------------------------------------------\n");
! 2866:
! 2867: /* This check is done here in the debugging case so that the code that
! 2868: was compiled can be seen. */
! 2869:
! 2870: if (code - re->code > length)
! 2871: {
! 2872: *errorptr = ERR23;
! 2873: (pcre_free)(re);
! 2874: *erroroffset = ptr - (uschar *)pattern;
! 2875: return NULL;
! 2876: }
! 2877: #endif
! 2878:
! 2879: return (pcre *)re;
! 2880: }
! 2881:
! 2882:
! 2883:
! 2884: /*************************************************
! 2885: * Match a back-reference *
! 2886: *************************************************/
! 2887:
! 2888: /* If a back reference hasn't been set, the length that is passed is greater
! 2889: than the number of characters left in the string, so the match fails.
! 2890:
! 2891: Arguments:
! 2892: offset index into the offset vector
! 2893: eptr points into the subject
! 2894: length length to be matched
! 2895: md points to match data block
! 2896: ims the ims flags
! 2897:
! 2898: Returns: TRUE if matched
! 2899: */
! 2900:
! 2901: static BOOL
! 2902: match_ref(int offset, register const uschar *eptr, int length, match_data *md,
! 2903: unsigned long int ims)
! 2904: {
! 2905: const uschar *p = md->start_subject + md->offset_vector[offset];
! 2906:
! 2907: #ifdef DEBUG
! 2908: if (eptr >= md->end_subject)
! 2909: printf("matching subject <null>");
! 2910: else
! 2911: {
! 2912: printf("matching subject ");
! 2913: pchars(eptr, length, TRUE, md);
! 2914: }
! 2915: printf(" against backref ");
! 2916: pchars(p, length, FALSE, md);
! 2917: printf("\n");
! 2918: #endif
! 2919:
! 2920: /* Always fail if not enough characters left */
! 2921:
! 2922: if (length > md->end_subject - eptr) return FALSE;
! 2923:
! 2924: /* Separate the caselesss case for speed */
! 2925:
! 2926: if ((ims & PCRE_CASELESS) != 0)
! 2927: {
! 2928: while (length-- > 0)
! 2929: if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;
! 2930: }
! 2931: else
! 2932: { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
! 2933:
! 2934: return TRUE;
! 2935: }
! 2936:
! 2937:
! 2938:
! 2939: /*************************************************
! 2940: * Match from current position *
! 2941: *************************************************/
! 2942:
! 2943: /* On entry ecode points to the first opcode, and eptr to the first character
! 2944: in the subject string, while eptrb holds the value of eptr at the start of the
! 2945: last bracketed group - used for breaking infinite loops matching zero-length
! 2946: strings.
! 2947:
! 2948: Arguments:
! 2949: eptr pointer in subject
! 2950: ecode position in code
! 2951: offset_top current top pointer
! 2952: md pointer to "static" info for the match
! 2953: ims current /i, /m, and /s options
! 2954: condassert TRUE if called to check a condition assertion
! 2955: eptrb eptr at start of last bracket
! 2956:
! 2957: Returns: TRUE if matched
! 2958: */
! 2959:
! 2960: static BOOL
! 2961: match(register const uschar *eptr, register const uschar *ecode,
! 2962: int offset_top, match_data *md, unsigned long int ims, BOOL condassert,
! 2963: const uschar *eptrb)
! 2964: {
! 2965: unsigned long int original_ims = ims; /* Save for resetting on ')' */
! 2966:
! 2967: for (;;)
! 2968: {
! 2969: int op = (int)*ecode;
! 2970: int min, max, ctype;
! 2971: register int i;
! 2972: register int c;
! 2973: BOOL minimize = FALSE;
! 2974:
! 2975: /* Opening capturing bracket. If there is space in the offset vector, save
! 2976: the current subject position in the working slot at the top of the vector. We
! 2977: mustn't change the current values of the data slot, because they may be set
! 2978: from a previous iteration of this group, and be referred to by a reference
! 2979: inside the group.
! 2980:
! 2981: If the bracket fails to match, we need to restore this value and also the
! 2982: values of the final offsets, in case they were set by a previous iteration of
! 2983: the same bracket.
! 2984:
! 2985: If there isn't enough space in the offset vector, treat this as if it were a
! 2986: non-capturing bracket. Don't worry about setting the flag for the error case
! 2987: here; that is handled in the code for KET. */
! 2988:
! 2989: if (op > OP_BRA)
! 2990: {
! 2991: int number = op - OP_BRA;
! 2992: int offset = number << 1;
! 2993:
! 2994: #ifdef DEBUG
! 2995: printf("start bracket %d subject=", number);
! 2996: pchars(eptr, 16, TRUE, md);
! 2997: printf("\n");
! 2998: #endif
! 2999:
! 3000: if (offset < md->offset_max)
! 3001: {
! 3002: int save_offset1 = md->offset_vector[offset];
! 3003: int save_offset2 = md->offset_vector[offset+1];
! 3004: int save_offset3 = md->offset_vector[md->offset_end - number];
! 3005:
! 3006: DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
! 3007: md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
! 3008:
! 3009: do
! 3010: {
! 3011: if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
! 3012: ecode += (ecode[1] << 8) + ecode[2];
! 3013: }
! 3014: while (*ecode == OP_ALT);
! 3015:
! 3016: DPRINTF(("bracket %d failed\n", number));
! 3017:
! 3018: md->offset_vector[offset] = save_offset1;
! 3019: md->offset_vector[offset+1] = save_offset2;
! 3020: md->offset_vector[md->offset_end - number] = save_offset3;
! 3021: return FALSE;
! 3022: }
! 3023:
! 3024: /* Insufficient room for saving captured contents */
! 3025:
! 3026: else op = OP_BRA;
! 3027: }
! 3028:
! 3029: /* Other types of node can be handled by a switch */
! 3030:
! 3031: switch(op)
! 3032: {
! 3033: case OP_BRA: /* Non-capturing bracket: optimized */
! 3034: DPRINTF(("start bracket 0\n"));
! 3035: do
! 3036: {
! 3037: if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
! 3038: ecode += (ecode[1] << 8) + ecode[2];
! 3039: }
! 3040: while (*ecode == OP_ALT);
! 3041: DPRINTF(("bracket 0 failed\n"));
! 3042: return FALSE;
! 3043:
! 3044: /* Conditional group: compilation checked that there are no more than
! 3045: two branches. If the condition is false, skipping the first branch takes us
! 3046: past the end if there is only one branch, but that's OK because that is
! 3047: exactly what going to the ket would do. */
! 3048:
! 3049: case OP_COND:
! 3050: if (ecode[3] == OP_CREF) /* Condition is extraction test */
! 3051: {
! 3052: int offset = ecode[4] << 1; /* Doubled reference number */
! 3053: return match(eptr,
! 3054: ecode + ((offset < offset_top && md->offset_vector[offset] >= 0)?
! 3055: 5 : 3 + (ecode[1] << 8) + ecode[2]),
! 3056: offset_top, md, ims, FALSE, eptr);
! 3057: }
! 3058:
! 3059: /* The condition is an assertion. Call match() to evaluate it - setting
! 3060: the final argument TRUE causes it to stop at the end of an assertion. */
! 3061:
! 3062: else
! 3063: {
! 3064: if (match(eptr, ecode+3, offset_top, md, ims, TRUE, NULL))
! 3065: {
! 3066: ecode += 3 + (ecode[4] << 8) + ecode[5];
! 3067: while (*ecode == OP_ALT) ecode += (ecode[1] << 8) + ecode[2];
! 3068: }
! 3069: else ecode += (ecode[1] << 8) + ecode[2];
! 3070: return match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr);
! 3071: }
! 3072: /* Control never reaches here */
! 3073:
! 3074: /* Skip over conditional reference data if encountered (should not be) */
! 3075:
! 3076: case OP_CREF:
! 3077: ecode += 2;
! 3078: break;
! 3079:
! 3080: /* End of the pattern. If PCRE_NOTEMPTY is set, fail if we have matched
! 3081: an empty string - recursion will then try other alternatives, if any. */
! 3082:
! 3083: case OP_END:
! 3084: if (md->notempty && eptr == md->start_match) return FALSE;
! 3085: md->end_match_ptr = eptr; /* Record where we ended */
! 3086: md->end_offset_top = offset_top; /* and how many extracts were taken */
! 3087: return TRUE;
! 3088:
! 3089: /* Change option settings */
! 3090:
! 3091: case OP_OPT:
! 3092: ims = ecode[1];
! 3093: ecode += 2;
! 3094: DPRINTF(("ims set to %02lx\n", ims));
! 3095: break;
! 3096:
! 3097: /* Assertion brackets. Check the alternative branches in turn - the
! 3098: matching won't pass the KET for an assertion. If any one branch matches,
! 3099: the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
! 3100: start of each branch to move the current point backwards, so the code at
! 3101: this level is identical to the lookahead case. */
! 3102:
! 3103: case OP_ASSERT:
! 3104: case OP_ASSERTBACK:
! 3105: do
! 3106: {
! 3107: if (match(eptr, ecode+3, offset_top, md, ims, FALSE, NULL)) break;
! 3108: ecode += (ecode[1] << 8) + ecode[2];
! 3109: }
! 3110: while (*ecode == OP_ALT);
! 3111: if (*ecode == OP_KET) return FALSE;
! 3112:
! 3113: /* If checking an assertion for a condition, return TRUE. */
! 3114:
! 3115: if (condassert) return TRUE;
! 3116:
! 3117: /* Continue from after the assertion, updating the offsets high water
! 3118: mark, since extracts may have been taken during the assertion. */
! 3119:
! 3120: do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT);
! 3121: ecode += 3;
! 3122: offset_top = md->end_offset_top;
! 3123: continue;
! 3124:
! 3125: /* Negative assertion: all branches must fail to match */
! 3126:
! 3127: case OP_ASSERT_NOT:
! 3128: case OP_ASSERTBACK_NOT:
! 3129: do
! 3130: {
! 3131: if (match(eptr, ecode+3, offset_top, md, ims, FALSE, NULL)) return FALSE;
! 3132: ecode += (ecode[1] << 8) + ecode[2];
! 3133: }
! 3134: while (*ecode == OP_ALT);
! 3135:
! 3136: if (condassert) return TRUE;
! 3137: ecode += 3;
! 3138: continue;
! 3139:
! 3140: /* Move the subject pointer back. This occurs only at the start of
! 3141: each branch of a lookbehind assertion. If we are too close to the start to
! 3142: move back, this match function fails. */
! 3143:
! 3144: case OP_REVERSE:
! 3145: eptr -= (ecode[1] << 8) + ecode[2];
! 3146: if (eptr < md->start_subject) return FALSE;
! 3147: ecode += 3;
! 3148: break;
! 3149:
! 3150:
! 3151: /* "Once" brackets are like assertion brackets except that after a match,
! 3152: the point in the subject string is not moved back. Thus there can never be
! 3153: a move back into the brackets. Check the alternative branches in turn - the
! 3154: matching won't pass the KET for this kind of subpattern. If any one branch
! 3155: matches, we carry on as at the end of a normal bracket, leaving the subject
! 3156: pointer. */
! 3157:
! 3158: case OP_ONCE:
! 3159: {
! 3160: const uschar *prev = ecode;
! 3161:
! 3162: do
! 3163: {
! 3164: if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) break;
! 3165: ecode += (ecode[1] << 8) + ecode[2];
! 3166: }
! 3167: while (*ecode == OP_ALT);
! 3168:
! 3169: /* If hit the end of the group (which could be repeated), fail */
! 3170:
! 3171: if (*ecode != OP_ONCE && *ecode != OP_ALT) return FALSE;
! 3172:
! 3173: /* Continue as from after the assertion, updating the offsets high water
! 3174: mark, since extracts may have been taken. */
! 3175:
! 3176: do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT);
! 3177:
! 3178: offset_top = md->end_offset_top;
! 3179: eptr = md->end_match_ptr;
! 3180:
! 3181: /* For a non-repeating ket, just continue at this level. This also
! 3182: happens for a repeating ket if no characters were matched in the group.
! 3183: This is the forcible breaking of infinite loops as implemented in Perl
! 3184: 5.005. If there is an options reset, it will get obeyed in the normal
! 3185: course of events. */
! 3186:
! 3187: if (*ecode == OP_KET || eptr == eptrb)
! 3188: {
! 3189: ecode += 3;
! 3190: break;
! 3191: }
! 3192:
! 3193: /* The repeating kets try the rest of the pattern or restart from the
! 3194: preceding bracket, in the appropriate order. We need to reset any options
! 3195: that changed within the bracket before re-running it, so check the next
! 3196: opcode. */
! 3197:
! 3198: if (ecode[3] == OP_OPT)
! 3199: {
! 3200: ims = (ims & ~PCRE_IMS) | ecode[4];
! 3201: DPRINTF(("ims set to %02lx at group repeat\n", ims));
! 3202: }
! 3203:
! 3204: if (*ecode == OP_KETRMIN)
! 3205: {
! 3206: if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr) ||
! 3207: match(eptr, prev, offset_top, md, ims, FALSE, eptr)) return TRUE;
! 3208: }
! 3209: else /* OP_KETRMAX */
! 3210: {
! 3211: if (match(eptr, prev, offset_top, md, ims, FALSE, eptr) ||
! 3212: match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
! 3213: }
! 3214: }
! 3215: return FALSE;
! 3216:
! 3217: /* An alternation is the end of a branch; scan along to find the end of the
! 3218: bracketed group and go to there. */
! 3219:
! 3220: case OP_ALT:
! 3221: do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT);
! 3222: break;
! 3223:
! 3224: /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
! 3225: that it may occur zero times. It may repeat infinitely, or not at all -
! 3226: i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
! 3227: repeat limits are compiled as a number of copies, with the optional ones
! 3228: preceded by BRAZERO or BRAMINZERO. */
! 3229:
! 3230: case OP_BRAZERO:
! 3231: {
! 3232: const uschar *next = ecode+1;
! 3233: if (match(eptr, next, offset_top, md, ims, FALSE, eptr)) return TRUE;
! 3234: do next += (next[1] << 8) + next[2]; while (*next == OP_ALT);
! 3235: ecode = next + 3;
! 3236: }
! 3237: break;
! 3238:
! 3239: case OP_BRAMINZERO:
! 3240: {
! 3241: const uschar *next = ecode+1;
! 3242: do next += (next[1] << 8) + next[2]; while (*next == OP_ALT);
! 3243: if (match(eptr, next+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
! 3244: ecode++;
! 3245: }
! 3246: break;
! 3247:
! 3248: /* End of a group, repeated or non-repeating. If we are at the end of
! 3249: an assertion "group", stop matching and return TRUE, but record the
! 3250: current high water mark for use by positive assertions. Do this also
! 3251: for the "once" (not-backup up) groups. */
! 3252:
! 3253: case OP_KET:
! 3254: case OP_KETRMIN:
! 3255: case OP_KETRMAX:
! 3256: {
! 3257: const uschar *prev = ecode - (ecode[1] << 8) - ecode[2];
! 3258:
! 3259: if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
! 3260: *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
! 3261: *prev == OP_ONCE)
! 3262: {
! 3263: md->end_match_ptr = eptr; /* For ONCE */
! 3264: md->end_offset_top = offset_top;
! 3265: return TRUE;
! 3266: }
! 3267:
! 3268: /* In all other cases except a conditional group we have to check the
! 3269: group number back at the start and if necessary complete handling an
! 3270: extraction by setting the offsets and bumping the high water mark. */
! 3271:
! 3272: if (*prev != OP_COND)
! 3273: {
! 3274: int number = *prev - OP_BRA;
! 3275: int offset = number << 1;
! 3276:
! 3277: DPRINTF(("end bracket %d\n", number));
! 3278:
! 3279: if (number > 0)
! 3280: {
! 3281: if (offset >= md->offset_max) md->offset_overflow = TRUE; else
! 3282: {
! 3283: md->offset_vector[offset] =
! 3284: md->offset_vector[md->offset_end - number];
! 3285: md->offset_vector[offset+1] = eptr - md->start_subject;
! 3286: if (offset_top <= offset) offset_top = offset + 2;
! 3287: }
! 3288: }
! 3289: }
! 3290:
! 3291: /* Reset the value of the ims flags, in case they got changed during
! 3292: the group. */
! 3293:
! 3294: ims = original_ims;
! 3295: DPRINTF(("ims reset to %02lx\n", ims));
! 3296:
! 3297: /* For a non-repeating ket, just continue at this level. This also
! 3298: happens for a repeating ket if no characters were matched in the group.
! 3299: This is the forcible breaking of infinite loops as implemented in Perl
! 3300: 5.005. If there is an options reset, it will get obeyed in the normal
! 3301: course of events. */
! 3302:
! 3303: if (*ecode == OP_KET || eptr == eptrb)
! 3304: {
! 3305: ecode += 3;
! 3306: break;
! 3307: }
! 3308:
! 3309: /* The repeating kets try the rest of the pattern or restart from the
! 3310: preceding bracket, in the appropriate order. */
! 3311:
! 3312: if (*ecode == OP_KETRMIN)
! 3313: {
! 3314: if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr) ||
! 3315: match(eptr, prev, offset_top, md, ims, FALSE, eptr)) return TRUE;
! 3316: }
! 3317: else /* OP_KETRMAX */
! 3318: {
! 3319: if (match(eptr, prev, offset_top, md, ims, FALSE, eptr) ||
! 3320: match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
! 3321: }
! 3322: }
! 3323: return FALSE;
! 3324:
! 3325: /* Start of subject unless notbol, or after internal newline if multiline */
! 3326:
! 3327: case OP_CIRC:
! 3328: if (md->notbol && eptr == md->start_subject) return FALSE;
! 3329: if ((ims & PCRE_MULTILINE) != 0)
! 3330: {
! 3331: if (eptr != md->start_subject && eptr[-1] != '\n') return FALSE;
! 3332: ecode++;
! 3333: break;
! 3334: }
! 3335: /* ... else fall through */
! 3336:
! 3337: /* Start of subject assertion */
! 3338:
! 3339: case OP_SOD:
! 3340: if (eptr != md->start_subject) return FALSE;
! 3341: ecode++;
! 3342: break;
! 3343:
! 3344: /* Assert before internal newline if multiline, or before a terminating
! 3345: newline unless endonly is set, else end of subject unless noteol is set. */
! 3346:
! 3347: case OP_DOLL:
! 3348: if ((ims & PCRE_MULTILINE) != 0)
! 3349: {
! 3350: if (eptr < md->end_subject) { if (*eptr != '\n') return FALSE; }
! 3351: else { if (md->noteol) return FALSE; }
! 3352: ecode++;
! 3353: break;
! 3354: }
! 3355: else
! 3356: {
! 3357: if (md->noteol) return FALSE;
! 3358: if (!md->endonly)
! 3359: {
! 3360: if (eptr < md->end_subject - 1 ||
! 3361: (eptr == md->end_subject - 1 && *eptr != '\n')) return FALSE;
! 3362:
! 3363: ecode++;
! 3364: break;
! 3365: }
! 3366: }
! 3367: /* ... else fall through */
! 3368:
! 3369: /* End of subject assertion (\z) */
! 3370:
! 3371: case OP_EOD:
! 3372: if (eptr < md->end_subject) return FALSE;
! 3373: ecode++;
! 3374: break;
! 3375:
! 3376: /* End of subject or ending \n assertion (\Z) */
! 3377:
! 3378: case OP_EODN:
! 3379: if (eptr < md->end_subject - 1 ||
! 3380: (eptr == md->end_subject - 1 && *eptr != '\n')) return FALSE;
! 3381: ecode++;
! 3382: break;
! 3383:
! 3384: /* Word boundary assertions */
! 3385:
! 3386: case OP_NOT_WORD_BOUNDARY:
! 3387: case OP_WORD_BOUNDARY:
! 3388: {
! 3389: BOOL prev_is_word = (eptr != md->start_subject) &&
! 3390: ((md->ctypes[eptr[-1]] & ctype_word) != 0);
! 3391: BOOL cur_is_word = (eptr < md->end_subject) &&
! 3392: ((md->ctypes[*eptr] & ctype_word) != 0);
! 3393: if ((*ecode++ == OP_WORD_BOUNDARY)?
! 3394: cur_is_word == prev_is_word : cur_is_word != prev_is_word)
! 3395: return FALSE;
! 3396: }
! 3397: break;
! 3398:
! 3399: /* Match a single character type; inline for speed */
! 3400:
! 3401: case OP_ANY:
! 3402: if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject && *eptr == '\n')
! 3403: return FALSE;
! 3404: if (eptr++ >= md->end_subject) return FALSE;
! 3405: ecode++;
! 3406: break;
! 3407:
! 3408: case OP_NOT_DIGIT:
! 3409: if (eptr >= md->end_subject ||
! 3410: (md->ctypes[*eptr++] & ctype_digit) != 0)
! 3411: return FALSE;
! 3412: ecode++;
! 3413: break;
! 3414:
! 3415: case OP_DIGIT:
! 3416: if (eptr >= md->end_subject ||
! 3417: (md->ctypes[*eptr++] & ctype_digit) == 0)
! 3418: return FALSE;
! 3419: ecode++;
! 3420: break;
! 3421:
! 3422: case OP_NOT_WHITESPACE:
! 3423: if (eptr >= md->end_subject ||
! 3424: (md->ctypes[*eptr++] & ctype_space) != 0)
! 3425: return FALSE;
! 3426: ecode++;
! 3427: break;
! 3428:
! 3429: case OP_WHITESPACE:
! 3430: if (eptr >= md->end_subject ||
! 3431: (md->ctypes[*eptr++] & ctype_space) == 0)
! 3432: return FALSE;
! 3433: ecode++;
! 3434: break;
! 3435:
! 3436: case OP_NOT_WORDCHAR:
! 3437: if (eptr >= md->end_subject ||
! 3438: (md->ctypes[*eptr++] & ctype_word) != 0)
! 3439: return FALSE;
! 3440: ecode++;
! 3441: break;
! 3442:
! 3443: case OP_WORDCHAR:
! 3444: if (eptr >= md->end_subject ||
! 3445: (md->ctypes[*eptr++] & ctype_word) == 0)
! 3446: return FALSE;
! 3447: ecode++;
! 3448: break;
! 3449:
! 3450: /* Match a back reference, possibly repeatedly. Look past the end of the
! 3451: item to see if there is repeat information following. The code is similar
! 3452: to that for character classes, but repeated for efficiency. Then obey
! 3453: similar code to character type repeats - written out again for speed.
! 3454: However, if the referenced string is the empty string, always treat
! 3455: it as matched, any number of times (otherwise there could be infinite
! 3456: loops). */
! 3457:
! 3458: case OP_REF:
! 3459: {
! 3460: int length;
! 3461: int offset = ecode[1] << 1; /* Doubled reference number */
! 3462: ecode += 2; /* Advance past the item */
! 3463:
! 3464: /* If the reference is unset, set the length to be longer than the amount
! 3465: of subject left; this ensures that every attempt at a match fails. We
! 3466: can't just fail here, because of the possibility of quantifiers with zero
! 3467: minima. */
! 3468:
! 3469: length = (offset >= offset_top || md->offset_vector[offset] < 0)?
! 3470: md->end_subject - eptr + 1 :
! 3471: md->offset_vector[offset+1] - md->offset_vector[offset];
! 3472:
! 3473: /* Set up for repetition, or handle the non-repeated case */
! 3474:
! 3475: switch (*ecode)
! 3476: {
! 3477: case OP_CRSTAR:
! 3478: case OP_CRMINSTAR:
! 3479: case OP_CRPLUS:
! 3480: case OP_CRMINPLUS:
! 3481: case OP_CRQUERY:
! 3482: case OP_CRMINQUERY:
! 3483: c = *ecode++ - OP_CRSTAR;
! 3484: minimize = (c & 1) != 0;
! 3485: min = rep_min[c]; /* Pick up values from tables; */
! 3486: max = rep_max[c]; /* zero for max => infinity */
! 3487: if (max == 0) max = PCRE_MAX_POS;
! 3488: break;
! 3489:
! 3490: case OP_CRRANGE:
! 3491: case OP_CRMINRANGE:
! 3492: minimize = (*ecode == OP_CRMINRANGE);
! 3493: min = (ecode[1] << 8) + ecode[2];
! 3494: max = (ecode[3] << 8) + ecode[4];
! 3495: if (max == 0) max = PCRE_MAX_POS;
! 3496: ecode += 5;
! 3497: break;
! 3498:
! 3499: default: /* No repeat follows */
! 3500: if (!match_ref(offset, eptr, length, md, ims)) return FALSE;
! 3501: eptr += length;
! 3502: continue; /* With the main loop */
! 3503: }
! 3504:
! 3505: /* If the length of the reference is zero, just continue with the
! 3506: main loop. */
! 3507:
! 3508: if (length == 0) continue;
! 3509:
! 3510: /* First, ensure the minimum number of matches are present. We get back
! 3511: the length of the reference string explicitly rather than passing the
! 3512: address of eptr, so that eptr can be a register variable. */
! 3513:
! 3514: for (i = 1; i <= min; i++)
! 3515: {
! 3516: if (!match_ref(offset, eptr, length, md, ims)) return FALSE;
! 3517: eptr += length;
! 3518: }
! 3519:
! 3520: /* If min = max, continue at the same level without recursion.
! 3521: They are not both allowed to be zero. */
! 3522:
! 3523: if (min == max) continue;
! 3524:
! 3525: /* If minimizing, keep trying and advancing the pointer */
! 3526:
! 3527: if (minimize)
! 3528: {
! 3529: for (i = min;; i++)
! 3530: {
! 3531: if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
! 3532: return TRUE;
! 3533: if (i >= max || !match_ref(offset, eptr, length, md, ims))
! 3534: return FALSE;
! 3535: eptr += length;
! 3536: }
! 3537: /* Control never gets here */
! 3538: }
! 3539:
! 3540: /* If maximizing, find the longest string and work backwards */
! 3541:
! 3542: else
! 3543: {
! 3544: const uschar *pp = eptr;
! 3545: for (i = min; i < max; i++)
! 3546: {
! 3547: if (!match_ref(offset, eptr, length, md, ims)) break;
! 3548: eptr += length;
! 3549: }
! 3550: while (eptr >= pp)
! 3551: {
! 3552: if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
! 3553: return TRUE;
! 3554: eptr -= length;
! 3555: }
! 3556: return FALSE;
! 3557: }
! 3558: }
! 3559: /* Control never gets here */
! 3560:
! 3561:
! 3562:
! 3563: /* Match a character class, possibly repeatedly. Look past the end of the
! 3564: item to see if there is repeat information following. Then obey similar
! 3565: code to character type repeats - written out again for speed. */
! 3566:
! 3567: case OP_CLASS:
! 3568: {
! 3569: const uschar *data = ecode + 1; /* Save for matching */
! 3570: ecode += 33; /* Advance past the item */
! 3571:
! 3572: switch (*ecode)
! 3573: {
! 3574: case OP_CRSTAR:
! 3575: case OP_CRMINSTAR:
! 3576: case OP_CRPLUS:
! 3577: case OP_CRMINPLUS:
! 3578: case OP_CRQUERY:
! 3579: case OP_CRMINQUERY:
! 3580: c = *ecode++ - OP_CRSTAR;
! 3581: minimize = (c & 1) != 0;
! 3582: min = rep_min[c]; /* Pick up values from tables; */
! 3583: max = rep_max[c]; /* zero for max => infinity */
! 3584: if (max == 0) max = PCRE_MAX_POS;
! 3585: break;
! 3586:
! 3587: case OP_CRRANGE:
! 3588: case OP_CRMINRANGE:
! 3589: minimize = (*ecode == OP_CRMINRANGE);
! 3590: min = (ecode[1] << 8) + ecode[2];
! 3591: max = (ecode[3] << 8) + ecode[4];
! 3592: if (max == 0) max = PCRE_MAX_POS;
! 3593: ecode += 5;
! 3594: break;
! 3595:
! 3596: default: /* No repeat follows */
! 3597: min = max = 1;
! 3598: break;
! 3599: }
! 3600:
! 3601: /* First, ensure the minimum number of matches are present. */
! 3602:
! 3603: for (i = 1; i <= min; i++)
! 3604: {
! 3605: if (eptr >= md->end_subject) return FALSE;
! 3606: c = *eptr++;
! 3607: if ((data[c/8] & (1 << (c&7))) != 0) continue;
! 3608: return FALSE;
! 3609: }
! 3610:
! 3611: /* If max == min we can continue with the main loop without the
! 3612: need to recurse. */
! 3613:
! 3614: if (min == max) continue;
! 3615:
! 3616: /* If minimizing, keep testing the rest of the expression and advancing
! 3617: the pointer while it matches the class. */
! 3618:
! 3619: if (minimize)
! 3620: {
! 3621: for (i = min;; i++)
! 3622: {
! 3623: if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
! 3624: return TRUE;
! 3625: if (i >= max || eptr >= md->end_subject) return FALSE;
! 3626: c = *eptr++;
! 3627: if ((data[c/8] & (1 << (c&7))) != 0) continue;
! 3628: return FALSE;
! 3629: }
! 3630: /* Control never gets here */
! 3631: }
! 3632:
! 3633: /* If maximizing, find the longest possible run, then work backwards. */
! 3634:
! 3635: else
! 3636: {
! 3637: const uschar *pp = eptr;
! 3638: for (i = min; i < max; eptr++, i++)
! 3639: {
! 3640: if (eptr >= md->end_subject) break;
! 3641: c = *eptr;
! 3642: if ((data[c/8] & (1 << (c&7))) != 0) continue;
! 3643: break;
! 3644: }
! 3645:
! 3646: while (eptr >= pp)
! 3647: if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
! 3648: return TRUE;
! 3649: return FALSE;
! 3650: }
! 3651: }
! 3652: /* Control never gets here */
! 3653:
! 3654: /* Match a run of characters */
! 3655:
! 3656: case OP_CHARS:
! 3657: {
! 3658: register int length = ecode[1];
! 3659: ecode += 2;
! 3660:
! 3661: #ifdef DEBUG /* Sigh. Some compilers never learn. */
! 3662: if (eptr >= md->end_subject)
! 3663: printf("matching subject <null> against pattern ");
! 3664: else
! 3665: {
! 3666: printf("matching subject ");
! 3667: pchars(eptr, length, TRUE, md);
! 3668: printf(" against pattern ");
! 3669: }
! 3670: pchars(ecode, length, FALSE, md);
! 3671: printf("\n");
! 3672: #endif
! 3673:
! 3674: if (length > md->end_subject - eptr) return FALSE;
! 3675: if ((ims & PCRE_CASELESS) != 0)
! 3676: {
! 3677: while (length-- > 0)
! 3678: if (md->lcc[*ecode++] != md->lcc[*eptr++])
! 3679: return FALSE;
! 3680: }
! 3681: else
! 3682: {
! 3683: while (length-- > 0) if (*ecode++ != *eptr++) return FALSE;
! 3684: }
! 3685: }
! 3686: break;
! 3687:
! 3688: /* Match a single character repeatedly; different opcodes share code. */
! 3689:
! 3690: case OP_EXACT:
! 3691: min = max = (ecode[1] << 8) + ecode[2];
! 3692: ecode += 3;
! 3693: goto REPEATCHAR;
! 3694:
! 3695: case OP_UPTO:
! 3696: case OP_MINUPTO:
! 3697: min = 0;
! 3698: max = (ecode[1] << 8) + ecode[2];
! 3699: minimize = *ecode == OP_MINUPTO;
! 3700: ecode += 3;
! 3701: goto REPEATCHAR;
! 3702:
! 3703: case OP_STAR:
! 3704: case OP_MINSTAR:
! 3705: case OP_PLUS:
! 3706: case OP_MINPLUS:
! 3707: case OP_QUERY:
! 3708: case OP_MINQUERY:
! 3709: c = *ecode++ - OP_STAR;
! 3710: minimize = (c & 1) != 0;
! 3711: min = rep_min[c]; /* Pick up values from tables; */
! 3712: max = rep_max[c]; /* zero for max => infinity */
! 3713: if (max == 0) max = PCRE_MAX_POS;
! 3714:
! 3715: /* Common code for all repeated single-character matches. We can give
! 3716: up quickly if there are fewer than the minimum number of characters left in
! 3717: the subject. */
! 3718:
! 3719: REPEATCHAR:
! 3720: if (min > md->end_subject - eptr) return FALSE;
! 3721: c = *ecode++;
! 3722:
! 3723: /* The code is duplicated for the caseless and caseful cases, for speed,
! 3724: since matching characters is likely to be quite common. First, ensure the
! 3725: minimum number of matches are present. If min = max, continue at the same
! 3726: level without recursing. Otherwise, if minimizing, keep trying the rest of
! 3727: the expression and advancing one matching character if failing, up to the
! 3728: maximum. Alternatively, if maximizing, find the maximum number of
! 3729: characters and work backwards. */
! 3730:
! 3731: DPRINTF(("matching %c{%d,%d} against subject %.*s\n", c, min, max,
! 3732: max, eptr));
! 3733:
! 3734: if ((ims & PCRE_CASELESS) != 0)
! 3735: {
! 3736: c = md->lcc[c];
! 3737: for (i = 1; i <= min; i++)
! 3738: if (c != md->lcc[*eptr++]) return FALSE;
! 3739: if (min == max) continue;
! 3740: if (minimize)
! 3741: {
! 3742: for (i = min;; i++)
! 3743: {
! 3744: if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
! 3745: return TRUE;
! 3746: if (i >= max || eptr >= md->end_subject ||
! 3747: c != md->lcc[*eptr++])
! 3748: return FALSE;
! 3749: }
! 3750: /* Control never gets here */
! 3751: }
! 3752: else
! 3753: {
! 3754: const uschar *pp = eptr;
! 3755: for (i = min; i < max; i++)
! 3756: {
! 3757: if (eptr >= md->end_subject || c != md->lcc[*eptr]) break;
! 3758: eptr++;
! 3759: }
! 3760: while (eptr >= pp)
! 3761: if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
! 3762: return TRUE;
! 3763: return FALSE;
! 3764: }
! 3765: /* Control never gets here */
! 3766: }
! 3767:
! 3768: /* Caseful comparisons */
! 3769:
! 3770: else
! 3771: {
! 3772: for (i = 1; i <= min; i++) if (c != *eptr++) return FALSE;
! 3773: if (min == max) continue;
! 3774: if (minimize)
! 3775: {
! 3776: for (i = min;; i++)
! 3777: {
! 3778: if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
! 3779: return TRUE;
! 3780: if (i >= max || eptr >= md->end_subject || c != *eptr++) return FALSE;
! 3781: }
! 3782: /* Control never gets here */
! 3783: }
! 3784: else
! 3785: {
! 3786: const uschar *pp = eptr;
! 3787: for (i = min; i < max; i++)
! 3788: {
! 3789: if (eptr >= md->end_subject || c != *eptr) break;
! 3790: eptr++;
! 3791: }
! 3792: while (eptr >= pp)
! 3793: if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
! 3794: return TRUE;
! 3795: return FALSE;
! 3796: }
! 3797: }
! 3798: /* Control never gets here */
! 3799:
! 3800: /* Match a negated single character */
! 3801:
! 3802: case OP_NOT:
! 3803: if (eptr >= md->end_subject) return FALSE;
! 3804: ecode++;
! 3805: if ((ims & PCRE_CASELESS) != 0)
! 3806: {
! 3807: if (md->lcc[*ecode++] == md->lcc[*eptr++]) return FALSE;
! 3808: }
! 3809: else
! 3810: {
! 3811: if (*ecode++ == *eptr++) return FALSE;
! 3812: }
! 3813: break;
! 3814:
! 3815: /* Match a negated single character repeatedly. This is almost a repeat of
! 3816: the code for a repeated single character, but I haven't found a nice way of
! 3817: commoning these up that doesn't require a test of the positive/negative
! 3818: option for each character match. Maybe that wouldn't add very much to the
! 3819: time taken, but character matching *is* what this is all about... */
! 3820:
! 3821: case OP_NOTEXACT:
! 3822: min = max = (ecode[1] << 8) + ecode[2];
! 3823: ecode += 3;
! 3824: goto REPEATNOTCHAR;
! 3825:
! 3826: case OP_NOTUPTO:
! 3827: case OP_NOTMINUPTO:
! 3828: min = 0;
! 3829: max = (ecode[1] << 8) + ecode[2];
! 3830: minimize = *ecode == OP_NOTMINUPTO;
! 3831: ecode += 3;
! 3832: goto REPEATNOTCHAR;
! 3833:
! 3834: case OP_NOTSTAR:
! 3835: case OP_NOTMINSTAR:
! 3836: case OP_NOTPLUS:
! 3837: case OP_NOTMINPLUS:
! 3838: case OP_NOTQUERY:
! 3839: case OP_NOTMINQUERY:
! 3840: c = *ecode++ - OP_NOTSTAR;
! 3841: minimize = (c & 1) != 0;
! 3842: min = rep_min[c]; /* Pick up values from tables; */
! 3843: max = rep_max[c]; /* zero for max => infinity */
! 3844: if (max == 0) max = PCRE_MAX_POS;
! 3845:
! 3846: /* Common code for all repeated single-character matches. We can give
! 3847: up quickly if there are fewer than the minimum number of characters left in
! 3848: the subject. */
! 3849:
! 3850: REPEATNOTCHAR:
! 3851: if (min > md->end_subject - eptr) return FALSE;
! 3852: c = *ecode++;
! 3853:
! 3854: /* The code is duplicated for the caseless and caseful cases, for speed,
! 3855: since matching characters is likely to be quite common. First, ensure the
! 3856: minimum number of matches are present. If min = max, continue at the same
! 3857: level without recursing. Otherwise, if minimizing, keep trying the rest of
! 3858: the expression and advancing one matching character if failing, up to the
! 3859: maximum. Alternatively, if maximizing, find the maximum number of
! 3860: characters and work backwards. */
! 3861:
! 3862: DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", c, min, max,
! 3863: max, eptr));
! 3864:
! 3865: if ((ims & PCRE_CASELESS) != 0)
! 3866: {
! 3867: c = md->lcc[c];
! 3868: for (i = 1; i <= min; i++)
! 3869: if (c == md->lcc[*eptr++]) return FALSE;
! 3870: if (min == max) continue;
! 3871: if (minimize)
! 3872: {
! 3873: for (i = min;; i++)
! 3874: {
! 3875: if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
! 3876: return TRUE;
! 3877: if (i >= max || eptr >= md->end_subject ||
! 3878: c == md->lcc[*eptr++])
! 3879: return FALSE;
! 3880: }
! 3881: /* Control never gets here */
! 3882: }
! 3883: else
! 3884: {
! 3885: const uschar *pp = eptr;
! 3886: for (i = min; i < max; i++)
! 3887: {
! 3888: if (eptr >= md->end_subject || c == md->lcc[*eptr]) break;
! 3889: eptr++;
! 3890: }
! 3891: while (eptr >= pp)
! 3892: if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
! 3893: return TRUE;
! 3894: return FALSE;
! 3895: }
! 3896: /* Control never gets here */
! 3897: }
! 3898:
! 3899: /* Caseful comparisons */
! 3900:
! 3901: else
! 3902: {
! 3903: for (i = 1; i <= min; i++) if (c == *eptr++) return FALSE;
! 3904: if (min == max) continue;
! 3905: if (minimize)
! 3906: {
! 3907: for (i = min;; i++)
! 3908: {
! 3909: if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
! 3910: return TRUE;
! 3911: if (i >= max || eptr >= md->end_subject || c == *eptr++) return FALSE;
! 3912: }
! 3913: /* Control never gets here */
! 3914: }
! 3915: else
! 3916: {
! 3917: const uschar *pp = eptr;
! 3918: for (i = min; i < max; i++)
! 3919: {
! 3920: if (eptr >= md->end_subject || c == *eptr) break;
! 3921: eptr++;
! 3922: }
! 3923: while (eptr >= pp)
! 3924: if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
! 3925: return TRUE;
! 3926: return FALSE;
! 3927: }
! 3928: }
! 3929: /* Control never gets here */
! 3930:
! 3931: /* Match a single character type repeatedly; several different opcodes
! 3932: share code. This is very similar to the code for single characters, but we
! 3933: repeat it in the interests of efficiency. */
! 3934:
! 3935: case OP_TYPEEXACT:
! 3936: min = max = (ecode[1] << 8) + ecode[2];
! 3937: minimize = TRUE;
! 3938: ecode += 3;
! 3939: goto REPEATTYPE;
! 3940:
! 3941: case OP_TYPEUPTO:
! 3942: case OP_TYPEMINUPTO:
! 3943: min = 0;
! 3944: max = (ecode[1] << 8) + ecode[2];
! 3945: minimize = *ecode == OP_TYPEMINUPTO;
! 3946: ecode += 3;
! 3947: goto REPEATTYPE;
! 3948:
! 3949: case OP_TYPESTAR:
! 3950: case OP_TYPEMINSTAR:
! 3951: case OP_TYPEPLUS:
! 3952: case OP_TYPEMINPLUS:
! 3953: case OP_TYPEQUERY:
! 3954: case OP_TYPEMINQUERY:
! 3955: c = *ecode++ - OP_TYPESTAR;
! 3956: minimize = (c & 1) != 0;
! 3957: min = rep_min[c]; /* Pick up values from tables; */
! 3958: max = rep_max[c]; /* zero for max => infinity */
! 3959: if (max == 0) max = PCRE_MAX_POS;
! 3960:
! 3961: /* Common code for all repeated single character type matches */
! 3962:
! 3963: REPEATTYPE:
! 3964: ctype = *ecode++; /* Code for the character type */
! 3965:
! 3966: /* First, ensure the minimum number of matches are present. Use inline
! 3967: code for maximizing the speed, and do the type test once at the start
! 3968: (i.e. keep it out of the loop). Also test that there are at least the
! 3969: minimum number of characters before we start. */
! 3970:
! 3971: if (min > md->end_subject - eptr) return FALSE;
! 3972: if (min > 0) switch(ctype)
! 3973: {
! 3974: case OP_ANY:
! 3975: if ((ims & PCRE_DOTALL) == 0)
! 3976: { for (i = 1; i <= min; i++) if (*eptr++ == '\n') return FALSE; }
! 3977: else eptr += min;
! 3978: break;
! 3979:
! 3980: case OP_NOT_DIGIT:
! 3981: for (i = 1; i <= min; i++)
! 3982: if ((md->ctypes[*eptr++] & ctype_digit) != 0) return FALSE;
! 3983: break;
! 3984:
! 3985: case OP_DIGIT:
! 3986: for (i = 1; i <= min; i++)
! 3987: if ((md->ctypes[*eptr++] & ctype_digit) == 0) return FALSE;
! 3988: break;
! 3989:
! 3990: case OP_NOT_WHITESPACE:
! 3991: for (i = 1; i <= min; i++)
! 3992: if ((md->ctypes[*eptr++] & ctype_space) != 0) return FALSE;
! 3993: break;
! 3994:
! 3995: case OP_WHITESPACE:
! 3996: for (i = 1; i <= min; i++)
! 3997: if ((md->ctypes[*eptr++] & ctype_space) == 0) return FALSE;
! 3998: break;
! 3999:
! 4000: case OP_NOT_WORDCHAR:
! 4001: for (i = 1; i <= min; i++)
! 4002: if ((md->ctypes[*eptr++] & ctype_word) != 0)
! 4003: return FALSE;
! 4004: break;
! 4005:
! 4006: case OP_WORDCHAR:
! 4007: for (i = 1; i <= min; i++)
! 4008: if ((md->ctypes[*eptr++] & ctype_word) == 0)
! 4009: return FALSE;
! 4010: break;
! 4011: }
! 4012:
! 4013: /* If min = max, continue at the same level without recursing */
! 4014:
! 4015: if (min == max) continue;
! 4016:
! 4017: /* If minimizing, we have to test the rest of the pattern before each
! 4018: subsequent match. */
! 4019:
! 4020: if (minimize)
! 4021: {
! 4022: for (i = min;; i++)
! 4023: {
! 4024: if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb)) return TRUE;
! 4025: if (i >= max || eptr >= md->end_subject) return FALSE;
! 4026:
! 4027: c = *eptr++;
! 4028: switch(ctype)
! 4029: {
! 4030: case OP_ANY:
! 4031: if ((ims & PCRE_DOTALL) == 0 && c == '\n') return FALSE;
! 4032: break;
! 4033:
! 4034: case OP_NOT_DIGIT:
! 4035: if ((md->ctypes[c] & ctype_digit) != 0) return FALSE;
! 4036: break;
! 4037:
! 4038: case OP_DIGIT:
! 4039: if ((md->ctypes[c] & ctype_digit) == 0) return FALSE;
! 4040: break;
! 4041:
! 4042: case OP_NOT_WHITESPACE:
! 4043: if ((md->ctypes[c] & ctype_space) != 0) return FALSE;
! 4044: break;
! 4045:
! 4046: case OP_WHITESPACE:
! 4047: if ((md->ctypes[c] & ctype_space) == 0) return FALSE;
! 4048: break;
! 4049:
! 4050: case OP_NOT_WORDCHAR:
! 4051: if ((md->ctypes[c] & ctype_word) != 0) return FALSE;
! 4052: break;
! 4053:
! 4054: case OP_WORDCHAR:
! 4055: if ((md->ctypes[c] & ctype_word) == 0) return FALSE;
! 4056: break;
! 4057: }
! 4058: }
! 4059: /* Control never gets here */
! 4060: }
! 4061:
! 4062: /* If maximizing it is worth using inline code for speed, doing the type
! 4063: test once at the start (i.e. keep it out of the loop). */
! 4064:
! 4065: else
! 4066: {
! 4067: const uschar *pp = eptr;
! 4068: switch(ctype)
! 4069: {
! 4070: case OP_ANY:
! 4071: if ((ims & PCRE_DOTALL) == 0)
! 4072: {
! 4073: for (i = min; i < max; i++)
! 4074: {
! 4075: if (eptr >= md->end_subject || *eptr == '\n') break;
! 4076: eptr++;
! 4077: }
! 4078: }
! 4079: else
! 4080: {
! 4081: c = max - min;
! 4082: if (c > md->end_subject - eptr) c = md->end_subject - eptr;
! 4083: eptr += c;
! 4084: }
! 4085: break;
! 4086:
! 4087: case OP_NOT_DIGIT:
! 4088: for (i = min; i < max; i++)
! 4089: {
! 4090: if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)
! 4091: break;
! 4092: eptr++;
! 4093: }
! 4094: break;
! 4095:
! 4096: case OP_DIGIT:
! 4097: for (i = min; i < max; i++)
! 4098: {
! 4099: if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)
! 4100: break;
! 4101: eptr++;
! 4102: }
! 4103: break;
! 4104:
! 4105: case OP_NOT_WHITESPACE:
! 4106: for (i = min; i < max; i++)
! 4107: {
! 4108: if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)
! 4109: break;
! 4110: eptr++;
! 4111: }
! 4112: break;
! 4113:
! 4114: case OP_WHITESPACE:
! 4115: for (i = min; i < max; i++)
! 4116: {
! 4117: if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)
! 4118: break;
! 4119: eptr++;
! 4120: }
! 4121: break;
! 4122:
! 4123: case OP_NOT_WORDCHAR:
! 4124: for (i = min; i < max; i++)
! 4125: {
! 4126: if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)
! 4127: break;
! 4128: eptr++;
! 4129: }
! 4130: break;
! 4131:
! 4132: case OP_WORDCHAR:
! 4133: for (i = min; i < max; i++)
! 4134: {
! 4135: if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)
! 4136: break;
! 4137: eptr++;
! 4138: }
! 4139: break;
! 4140: }
! 4141:
! 4142: while (eptr >= pp)
! 4143: if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
! 4144: return TRUE;
! 4145: return FALSE;
! 4146: }
! 4147: /* Control never gets here */
! 4148:
! 4149: /* There's been some horrible disaster. */
! 4150:
! 4151: default:
! 4152: DPRINTF(("Unknown opcode %d\n", *ecode));
! 4153: md->errorcode = PCRE_ERROR_UNKNOWN_NODE;
! 4154: return FALSE;
! 4155: }
! 4156:
! 4157: /* Do not stick any code in here without much thought; it is assumed
! 4158: that "continue" in the code above comes out to here to repeat the main
! 4159: loop. */
! 4160:
! 4161: } /* End of main loop */
! 4162: /* Control never reaches here */
! 4163: }
! 4164:
! 4165:
! 4166:
! 4167:
! 4168: /*************************************************
! 4169: * Execute a Regular Expression *
! 4170: *************************************************/
! 4171:
! 4172: /* This function applies a compiled re to a subject string and picks out
! 4173: portions of the string if it matches. Two elements in the vector are set for
! 4174: each substring: the offsets to the start and end of the substring.
! 4175:
! 4176: Arguments:
! 4177: external_re points to the compiled expression
! 4178: external_extra points to "hints" from pcre_study() or is NULL
! 4179: subject points to the subject string
! 4180: length length of subject string (may contain binary zeros)
! 4181: start_offset where to start in the subject string
! 4182: options option bits
! 4183: offsets points to a vector of ints to be filled in with offsets
! 4184: offsetcount the number of elements in the vector
! 4185:
! 4186: Returns: > 0 => success; value is the number of elements filled in
! 4187: = 0 => success, but offsets is not big enough
! 4188: -1 => failed to match
! 4189: < -1 => some kind of unexpected problem
! 4190: */
! 4191:
! 4192: int
! 4193: pcre_exec(const pcre *external_re, const pcre_extra *external_extra,
! 4194: const char *subject, int length, int start_offset, int options, int *offsets,
! 4195: int offsetcount)
! 4196: {
! 4197: int resetcount, ocount;
! 4198: int first_char = -1;
! 4199: int req_char = -1;
! 4200: int req_char2 = -1;
! 4201: unsigned long int ims = 0;
! 4202: match_data match_block;
! 4203: const uschar *start_bits = NULL;
! 4204: const uschar *start_match = (const uschar *)subject + start_offset;
! 4205: const uschar *end_subject;
! 4206: const uschar *req_char_ptr = start_match - 1;
! 4207: const real_pcre *re = (const real_pcre *)external_re;
! 4208: const real_pcre_extra *extra = (const real_pcre_extra *)external_extra;
! 4209: BOOL using_temporary_offsets = FALSE;
! 4210: BOOL anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
! 4211: BOOL startline = (re->options & PCRE_STARTLINE) != 0;
! 4212:
! 4213: if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
! 4214:
! 4215: if (re == NULL || subject == NULL ||
! 4216: (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
! 4217: if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
! 4218:
! 4219: match_block.start_subject = (const uschar *)subject;
! 4220: match_block.end_subject = match_block.start_subject + length;
! 4221: end_subject = match_block.end_subject;
! 4222:
! 4223: match_block.endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
! 4224:
! 4225: match_block.notbol = (options & PCRE_NOTBOL) != 0;
! 4226: match_block.noteol = (options & PCRE_NOTEOL) != 0;
! 4227: match_block.notempty = (options & PCRE_NOTEMPTY) != 0;
! 4228:
! 4229: match_block.errorcode = PCRE_ERROR_NOMATCH; /* Default error */
! 4230:
! 4231: match_block.lcc = re->tables + lcc_offset;
! 4232: match_block.ctypes = re->tables + ctypes_offset;
! 4233:
! 4234: /* The ims options can vary during the matching as a result of the presence
! 4235: of (?ims) items in the pattern. They are kept in a local variable so that
! 4236: restoring at the exit of a group is easy. */
! 4237:
! 4238: ims = re->options & (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL);
! 4239:
! 4240: /* If the expression has got more back references than the offsets supplied can
! 4241: hold, we get a temporary bit of working store to use during the matching.
! 4242: Otherwise, we can use the vector supplied, rounding down its size to a multiple
! 4243: of 3. */
! 4244:
! 4245: ocount = offsetcount - (offsetcount % 3);
! 4246:
! 4247: if (re->top_backref > 0 && re->top_backref >= ocount/3)
! 4248: {
! 4249: ocount = re->top_backref * 3 + 3;
! 4250: match_block.offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));
! 4251: if (match_block.offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
! 4252: using_temporary_offsets = TRUE;
! 4253: DPRINTF(("Got memory to hold back references\n"));
! 4254: }
! 4255: else match_block.offset_vector = offsets;
! 4256:
! 4257: match_block.offset_end = ocount;
! 4258: match_block.offset_max = (2*ocount)/3;
! 4259: match_block.offset_overflow = FALSE;
! 4260:
! 4261: /* Compute the minimum number of offsets that we need to reset each time. Doing
! 4262: this makes a huge difference to execution time when there aren't many brackets
! 4263: in the pattern. */
! 4264:
! 4265: resetcount = 2 + re->top_bracket * 2;
! 4266: if (resetcount > offsetcount) resetcount = ocount;
! 4267:
! 4268: /* Reset the working variable associated with each extraction. These should
! 4269: never be used unless previously set, but they get saved and restored, and so we
! 4270: initialize them to avoid reading uninitialized locations. */
! 4271:
! 4272: if (match_block.offset_vector != NULL)
! 4273: {
! 4274: register int *iptr = match_block.offset_vector + ocount;
! 4275: register int *iend = iptr - resetcount/2 + 1;
! 4276: while (--iptr >= iend) *iptr = -1;
! 4277: }
! 4278:
! 4279: /* Set up the first character to match, if available. The first_char value is
! 4280: never set for an anchored regular expression, but the anchoring may be forced
! 4281: at run time, so we have to test for anchoring. The first char may be unset for
! 4282: an unanchored pattern, of course. If there's no first char and the pattern was
! 4283: studied, there may be a bitmap of possible first characters. */
! 4284:
! 4285: if (!anchored)
! 4286: {
! 4287: if ((re->options & PCRE_FIRSTSET) != 0)
! 4288: {
! 4289: first_char = re->first_char;
! 4290: if ((ims & PCRE_CASELESS) != 0) first_char = match_block.lcc[first_char];
! 4291: }
! 4292: else
! 4293: if (!startline && extra != NULL &&
! 4294: (extra->options & PCRE_STUDY_MAPPED) != 0)
! 4295: start_bits = extra->start_bits;
! 4296: }
! 4297:
! 4298: /* For anchored or unanchored matches, there may be a "last known required
! 4299: character" set. If the PCRE_CASELESS is set, implying that the match starts
! 4300: caselessly, or if there are any changes of this flag within the regex, set up
! 4301: both cases of the character. Otherwise set the two values the same, which will
! 4302: avoid duplicate testing (which takes significant time). This covers the vast
! 4303: majority of cases. It will be suboptimal when the case flag changes in a regex
! 4304: and the required character in fact is caseful. */
! 4305:
! 4306: if ((re->options & PCRE_REQCHSET) != 0)
! 4307: {
! 4308: req_char = re->req_char;
! 4309: req_char2 = ((re->options & (PCRE_CASELESS | PCRE_ICHANGED)) != 0)?
! 4310: (re->tables + fcc_offset)[req_char] : req_char;
! 4311: }
! 4312:
! 4313: /* Loop for handling unanchored repeated matching attempts; for anchored regexs
! 4314: the loop runs just once. */
! 4315:
! 4316: do
! 4317: {
! 4318: int rc;
! 4319: register int *iptr = match_block.offset_vector;
! 4320: register int *iend = iptr + resetcount;
! 4321:
! 4322: /* Reset the maximum number of extractions we might see. */
! 4323:
! 4324: while (iptr < iend) *iptr++ = -1;
! 4325:
! 4326: /* Advance to a unique first char if possible */
! 4327:
! 4328: if (first_char >= 0)
! 4329: {
! 4330: if ((ims & PCRE_CASELESS) != 0)
! 4331: while (start_match < end_subject &&
! 4332: match_block.lcc[*start_match] != first_char)
! 4333: start_match++;
! 4334: else
! 4335: while (start_match < end_subject && *start_match != first_char)
! 4336: start_match++;
! 4337: }
! 4338:
! 4339: /* Or to just after \n for a multiline match if possible */
! 4340:
! 4341: else if (startline)
! 4342: {
! 4343: if (start_match > match_block.start_subject + start_offset)
! 4344: {
! 4345: while (start_match < end_subject && start_match[-1] != '\n')
! 4346: start_match++;
! 4347: }
! 4348: }
! 4349:
! 4350: /* Or to a non-unique first char after study */
! 4351:
! 4352: else if (start_bits != NULL)
! 4353: {
! 4354: while (start_match < end_subject)
! 4355: {
! 4356: register int c = *start_match;
! 4357: if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;
! 4358: }
! 4359: }
! 4360:
! 4361: #ifdef DEBUG /* Sigh. Some compilers never learn. */
! 4362: printf(">>>> Match against: ");
! 4363: pchars(start_match, end_subject - start_match, TRUE, &match_block);
! 4364: printf("\n");
! 4365: #endif
! 4366:
! 4367: /* If req_char is set, we know that that character must appear in the subject
! 4368: for the match to succeed. If the first character is set, req_char must be
! 4369: later in the subject; otherwise the test starts at the match point. This
! 4370: optimization can save a huge amount of backtracking in patterns with nested
! 4371: unlimited repeats that aren't going to match. We don't know what the state of
! 4372: case matching may be when this character is hit, so test for it in both its
! 4373: cases if necessary. However, the different cased versions will not be set up
! 4374: unless PCRE_CASELESS was given or the casing state changes within the regex.
! 4375: Writing separate code makes it go faster, as does using an autoincrement and
! 4376: backing off on a match. */
! 4377:
! 4378: if (req_char >= 0)
! 4379: {
! 4380: register const uschar *p = start_match + ((first_char >= 0)? 1 : 0);
! 4381:
! 4382: /* We don't need to repeat the search if we haven't yet reached the
! 4383: place we found it at last time. */
! 4384:
! 4385: if (p > req_char_ptr)
! 4386: {
! 4387: /* Do a single test if no case difference is set up */
! 4388:
! 4389: if (req_char == req_char2)
! 4390: {
! 4391: while (p < end_subject)
! 4392: {
! 4393: if (*p++ == req_char) { p--; break; }
! 4394: }
! 4395: }
! 4396:
! 4397: /* Otherwise test for either case */
! 4398:
! 4399: else
! 4400: {
! 4401: while (p < end_subject)
! 4402: {
! 4403: register int pp = *p++;
! 4404: if (pp == req_char || pp == req_char2) { p--; break; }
! 4405: }
! 4406: }
! 4407:
! 4408: /* If we can't find the required character, break the matching loop */
! 4409:
! 4410: if (p >= end_subject) break;
! 4411:
! 4412: /* If we have found the required character, save the point where we
! 4413: found it, so that we don't search again next time round the loop if
! 4414: the start hasn't passed this character yet. */
! 4415:
! 4416: req_char_ptr = p;
! 4417: }
! 4418: }
! 4419:
! 4420: /* When a match occurs, substrings will be set for all internal extractions;
! 4421: we just need to set up the whole thing as substring 0 before returning. If
! 4422: there were too many extractions, set the return code to zero. In the case
! 4423: where we had to get some local store to hold offsets for backreferences, copy
! 4424: those back references that we can. In this case there need not be overflow
! 4425: if certain parts of the pattern were not used. */
! 4426:
! 4427: match_block.start_match = start_match;
! 4428: if (!match(start_match, re->code, 2, &match_block, ims, FALSE, start_match))
! 4429: continue;
! 4430:
! 4431: /* Copy the offset information from temporary store if necessary */
! 4432:
! 4433: if (using_temporary_offsets)
! 4434: {
! 4435: if (offsetcount >= 4)
! 4436: {
! 4437: memcpy(offsets + 2, match_block.offset_vector + 2,
! 4438: (offsetcount - 2) * sizeof(int));
! 4439: DPRINTF(("Copied offsets from temporary memory\n"));
! 4440: }
! 4441: if (match_block.end_offset_top > offsetcount)
! 4442: match_block.offset_overflow = TRUE;
! 4443:
! 4444: DPRINTF(("Freeing temporary memory\n"));
! 4445: (pcre_free)(match_block.offset_vector);
! 4446: }
! 4447:
! 4448: rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
! 4449:
! 4450: if (match_block.offset_end < 2) rc = 0; else
! 4451: {
! 4452: offsets[0] = start_match - match_block.start_subject;
! 4453: offsets[1] = match_block.end_match_ptr - match_block.start_subject;
! 4454: }
! 4455:
! 4456: DPRINTF((">>>> returning %d\n", rc));
! 4457: return rc;
! 4458: }
! 4459:
! 4460: /* This "while" is the end of the "do" above */
! 4461:
! 4462: while (!anchored &&
! 4463: match_block.errorcode == PCRE_ERROR_NOMATCH &&
! 4464: start_match++ < end_subject);
! 4465:
! 4466: if (using_temporary_offsets)
! 4467: {
! 4468: DPRINTF(("Freeing temporary memory\n"));
! 4469: (pcre_free)(match_block.offset_vector);
! 4470: }
! 4471:
! 4472: DPRINTF((">>>> returning %d\n", match_block.errorcode));
! 4473:
! 4474: return match_block.errorcode;
! 4475: }
! 4476:
! 4477: /* End of pcre.c */
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pcre.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / lib / pcre