pcre_exec.c

   1 /*************************************************
   2 *      Perl-Compatible Regular Expressions       *
   3 *************************************************/
   4
   5 /* PCRE is a library of functions to support regular expressions whose syntax
   6 and semantics are as close as possible to those of the Perl 5 language.
   7
   8                        Written by Philip Hazel
   9            Copyright (c) 1997-2010 University of Cambridge
  10
  11 -----------------------------------------------------------------------------
  12 Redistribution and use in source and binary forms, with or without
  13 modification, are permitted provided that the following conditions are met:
  14
  15     * Redistributions of source code must retain the above copyright notice,
  16       this list of conditions and the following disclaimer.
  17
  18     * Redistributions in binary form must reproduce the above copyright
  19       notice, this list of conditions and the following disclaimer in the
  20       documentation and/or other materials provided with the distribution.
  21
  22     * Neither the name of the University of Cambridge nor the names of its
  23       contributors may be used to endorse or promote products derived from
  24       this software without specific prior written permission.
  25
  26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  27 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  30 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36 POSSIBILITY OF SUCH DAMAGE.
  37 -----------------------------------------------------------------------------
  38 */
  39
  40
  41 /* This module contains pcre_exec(), the externally visible function that does
  42 pattern matching using an NFA algorithm, trying to mimic Perl as closely as
  43 possible. There are also some static supporting functions. */
  44
  45 #ifdef HAVE_CONFIG_H
  46 #include "config.h"
  47 #endif
  48
  49 #define NLBLOCK md             /* Block containing newline information */
  50 #define PSSTART start_subject  /* Field containing processed string start */
  51 #define PSEND   end_subject    /* Field containing processed string end */
  52
  53 #include "pcre_internal.h"
  54
  55 /* Undefine some potentially clashing cpp symbols */
  56
  57 #undef min
  58 #undef max
  59
  60 /* Flag bits for the match() function */
  61
  62 #define match_condassert     0x01  /* Called to check a condition assertion */
  63 #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */
  64
  65 /* Non-error returns from the match() function. Error returns are externally
  66 defined PCRE_ERROR_xxx codes, which are all negative. */
  67
  68 #define MATCH_MATCH        1
  69 #define MATCH_NOMATCH      0
  70
  71 /* Special internal returns from the match() function. Make them sufficiently
  72 negative to avoid the external error codes. */
  73
  74 #define MATCH_ACCEPT       (-999)
  75 #define MATCH_COMMIT       (-998)
  76 #define MATCH_PRUNE        (-997)
  77 #define MATCH_SKIP         (-996)
  78 #define MATCH_SKIP_ARG     (-995)
  79 #define MATCH_THEN         (-994)
  80
  81 /* This is a convenience macro for code that occurs many times. */
  82
  83 #define MRRETURN(ra) \
  84   { \
  85   md->mark = markptr; \
  86   RRETURN(ra); \
  87   }
  88
  89 /* Maximum number of ints of offset to save on the stack for recursive calls.
  90 If the offset vector is bigger, malloc is used. This should be a multiple of 3,
  91 because the offset vector is always a multiple of 3 long. */
  92
  93 #define REC_STACK_SAVE_MAX 30
  94
  95 /* Min and max values for the common repeats; for the maxima, 0 => infinity */
  96
  97 static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
  98 static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
  99
 100
 101
 102 #ifdef PCRE_DEBUG
 103 /*************************************************
 104 *        Debugging function to print chars       *
 105 *************************************************/
 106
 107 /* Print a sequence of chars in printable format, stopping at the end of the
 108 subject if the requested.
 109
 110 Arguments:
 111   p           points to characters
 112   length      number to print
 113   is_subject  TRUE if printing from within md->start_subject
 114   md          pointer to matching data block, if is_subject is TRUE
 115
 116 Returns:     nothing
 117 */
 118
 119 static void
 120 pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
 121 {
 122 unsigned int c;
 123 if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
 124 while (length-- > 0)
 125   if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);
 126 }
 127 #endif
 128
 129
 130
 131 /*************************************************
 132 *          Match a back-reference                *
 133 *************************************************/
 134
 135 /* If a back reference hasn't been set, the length that is passed is greater
 136 than the number of characters left in the string, so the match fails.
 137
 138 Arguments:
 139   offset      index into the offset vector
 140   eptr        points into the subject
 141   length      length to be matched
 142   md          points to match data block
 143   ims         the ims flags
 144
 145 Returns:      TRUE if matched
 146 */
 147
 148 static BOOL
 149 match_ref(int offset, register USPTR eptr, int length, match_data *md,
 150   unsigned long int ims)
 151 {
 152 USPTR p = md->start_subject + md->offset_vector[offset];
 153
 154 #ifdef PCRE_DEBUG
 155 if (eptr >= md->end_subject)
 156   printf("matching subject <null>");
 157 else
 158   {
 159   printf("matching subject ");
 160   pchars(eptr, length, TRUE, md);
 161   }
 162 printf(" against backref ");
 163 pchars(p, length, FALSE, md);
 164 printf("\n");
 165 #endif
 166
 167 /* Always fail if not enough characters left */
 168
 169 if (length > md->end_subject - eptr) return FALSE;
 170
 171 /* Separate the caseless case for speed. In UTF-8 mode we can only do this
 172 properly if Unicode properties are supported. Otherwise, we can check only
 173 ASCII characters. */
 174
 175 if ((ims & PCRE_CASELESS) != 0)
 176   {
 177 #ifdef SUPPORT_UTF8
 178 #ifdef SUPPORT_UCP
 179   if (md->utf8)
 180     {
 181     USPTR endptr = eptr + length;
 182     while (eptr < endptr)
 183       {
 184       int c, d;
 185       GETCHARINC(c, eptr);
 186       GETCHARINC(d, p);
 187       if (c != d && c != UCD_OTHERCASE(d)) return FALSE;
 188       }
 189     }
 190   else
 191 #endif
 192 #endif
 193
 194   /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
 195   is no UCP support. */
 196
 197   while (length-- > 0)
 198     { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }
 199   }
 200
 201 /* In the caseful case, we can just compare the bytes, whether or not we
 202 are in UTF-8 mode. */
 203
 204 else
 205   { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
 206
 207 return TRUE;
 208 }
 209
 210
 211
 212 /***************************************************************************
 213 ****************************************************************************
 214                    RECURSION IN THE match() FUNCTION
 215
 216 The match() function is highly recursive, though not every recursive call
 217 increases the recursive depth. Nevertheless, some regular expressions can cause
 218 it to recurse to a great depth. I was writing for Unix, so I just let it call
 219 itself recursively. This uses the stack for saving everything that has to be
 220 saved for a recursive call. On Unix, the stack can be large, and this works
 221 fine.
 222
 223 It turns out that on some non-Unix-like systems there are problems with
 224 programs that use a lot of stack. (This despite the fact that every last chip
 225 has oodles of memory these days, and techniques for extending the stack have
 226 been known for decades.) So....
 227
 228 There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
 229 calls by keeping local variables that need to be preserved in blocks of memory
 230 obtained from malloc() instead instead of on the stack. Macros are used to
 231 achieve this so that the actual code doesn't look very different to what it
 232 always used to.
 233
 234 The original heap-recursive code used longjmp(). However, it seems that this
 235 can be very slow on some operating systems. Following a suggestion from Stan
 236 Switzer, the use of longjmp() has been abolished, at the cost of having to
 237 provide a unique number for each call to RMATCH. There is no way of generating
 238 a sequence of numbers at compile time in C. I have given them names, to make
 239 them stand out more clearly.
 240
 241 Crude tests on x86 Linux show a small speedup of around 5-8%. However, on
 242 FreeBSD, avoiding longjmp() more than halves the time taken to run the standard
 243 tests. Furthermore, not using longjmp() means that local dynamic variables
 244 don't have indeterminate values; this has meant that the frame size can be
 245 reduced because the result can be "passed back" by straight setting of the
 246 variable instead of being passed in the frame.
 247 ****************************************************************************
 248 ***************************************************************************/
 249
 250 /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
 251 below must be updated in sync.  */
 252
 253 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
 254        RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
 255        RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
 256        RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
 257        RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
 258        RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
 259        RM61,  RM62 };
 260
 261 /* These versions of the macros use the stack, as normal. There are debugging
 262 versions and production versions. Note that the "rw" argument of RMATCH isn't
 263 actually used in this definition. */
 264
 265 #ifndef NO_RECURSE
 266 #define REGISTER register
 267
 268 #ifdef PCRE_DEBUG
 269 #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
 270   { \
 271   printf("match() called in line %d\n", __LINE__); \
 272   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1); \
 273   printf("to line %d\n", __LINE__); \
 274   }
 275 #define RRETURN(ra) \
 276   { \
 277   printf("match() returned %d from line %d ", ra, __LINE__); \
 278   return ra; \
 279   }
 280 #else
 281 #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
 282   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1)
 283 #define RRETURN(ra) return ra
 284 #endif
 285
 286 #else
 287
 288
 289 /* These versions of the macros manage a private stack on the heap. Note that
 290 the "rd" argument of RMATCH isn't actually used in this definition. It's the md
 291 argument of match(), which never changes. */
 292
 293 #define REGISTER
 294
 295 #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
 296   {\
 297   heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
 298   if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
 299   frame->Xwhere = rw; \
 300   newframe->Xeptr = ra;\
 301   newframe->Xecode = rb;\
 302   newframe->Xmstart = mstart;\
 303   newframe->Xmarkptr = markptr;\
 304   newframe->Xoffset_top = rc;\
 305   newframe->Xims = re;\
 306   newframe->Xeptrb = rf;\
 307   newframe->Xflags = rg;\
 308   newframe->Xrdepth = frame->Xrdepth + 1;\
 309   newframe->Xprevframe = frame;\
 310   frame = newframe;\
 311   DPRINTF(("restarting from line %d\n", __LINE__));\
 312   goto HEAP_RECURSE;\
 313   L_##rw:\
 314   DPRINTF(("jumped back to line %d\n", __LINE__));\
 315   }
 316
 317 #define RRETURN(ra)\
 318   {\
 319   heapframe *oldframe = frame;\
 320   frame = oldframe->Xprevframe;\
 321   (pcre_stack_free)(oldframe);\
 322   if (frame != NULL)\
 323     {\
 324     rrc = ra;\
 325     goto HEAP_RETURN;\
 326     }\
 327   return ra;\
 328   }
 329
 330
 331 /* Structure for remembering the local variables in a private frame */
 332
 333 typedef struct heapframe {
 334   struct heapframe *Xprevframe;
 335
 336   /* Function arguments that may change */
 337
 338   USPTR Xeptr;
 339   const uschar *Xecode;
 340   USPTR Xmstart;
 341   USPTR Xmarkptr;
 342   int Xoffset_top;
 343   long int Xims;
 344   eptrblock *Xeptrb;
 345   int Xflags;
 346   unsigned int Xrdepth;
 347
 348   /* Function local variables */
 349
 350   USPTR Xcallpat;
 351 #ifdef SUPPORT_UTF8
 352   USPTR Xcharptr;
 353 #endif
 354   USPTR Xdata;
 355   USPTR Xnext;
 356   USPTR Xpp;
 357   USPTR Xprev;
 358   USPTR Xsaved_eptr;
 359
 360   recursion_info Xnew_recursive;
 361
 362   BOOL Xcur_is_word;
 363   BOOL Xcondition;
 364   BOOL Xprev_is_word;
 365
 366   unsigned long int Xoriginal_ims;
 367
 368 #ifdef SUPPORT_UCP
 369   int Xprop_type;
 370   int Xprop_value;
 371   int Xprop_fail_result;
 372   int Xprop_category;
 373   int Xprop_chartype;
 374   int Xprop_script;
 375   int Xoclength;
 376   uschar Xocchars[8];
 377 #endif
 378
 379   int Xcodelink;
 380   int Xctype;
 381   unsigned int Xfc;
 382   int Xfi;
 383   int Xlength;
 384   int Xmax;
 385   int Xmin;
 386   int Xnumber;
 387   int Xoffset;
 388   int Xop;
 389   int Xsave_capture_last;
 390   int Xsave_offset1, Xsave_offset2, Xsave_offset3;
 391   int Xstacksave[REC_STACK_SAVE_MAX];
 392
 393   eptrblock Xnewptrb;
 394
 395   /* Where to jump back to */
 396
 397   int Xwhere;
 398
 399 } heapframe;
 400
 401 #endif
 402
 403
 404 /***************************************************************************
 405 ***************************************************************************/
 406
 407
 408
 409 /*************************************************
 410 *         Match from current position            *
 411 *************************************************/
 412
 413 /* This function is called recursively in many circumstances. Whenever it
 414 returns a negative (error) response, the outer incarnation must also return the
 415 same response. */
 416
 417 /* These macros pack up tests that are used for partial matching, and which
 418 appears several times in the code. We set the "hit end" flag if the pointer is
 419 at the end of the subject and also past the start of the subject (i.e.
 420 something has been matched). For hard partial matching, we then return
 421 immediately. The second one is used when we already know we are past the end of
 422 the subject. */
 423
 424 #define CHECK_PARTIAL()\
 425   if (md->partial != 0 && eptr >= md->end_subject && \
 426       eptr > md->start_used_ptr) \
 427     { \
 428     md->hitend = TRUE; \
 429     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
 430     }
 431
 432 #define SCHECK_PARTIAL()\
 433   if (md->partial != 0 && eptr > md->start_used_ptr) \
 434     { \
 435     md->hitend = TRUE; \
 436     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
 437     }
 438
 439
 440 /* Performance note: It might be tempting to extract commonly used fields from
 441 the md structure (e.g. utf8, end_subject) into individual variables to improve
 442 performance. Tests using gcc on a SPARC disproved this; in the first case, it
 443 made performance worse.
 444
 445 Arguments:
 446    eptr        pointer to current character in subject
 447    ecode       pointer to current position in compiled code
 448    mstart      pointer to the current match start position (can be modified
 449                  by encountering \K)
 450    markptr     pointer to the most recent MARK name, or NULL
 451    offset_top  current top pointer
 452    md          pointer to "static" info for the match
 453    ims         current /i, /m, and /s options
 454    eptrb       pointer to chain of blocks containing eptr at start of
 455                  brackets - for testing for empty matches
 456    flags       can contain
 457                  match_condassert - this is an assertion condition
 458                  match_cbegroup - this is the start of an unlimited repeat
 459                    group that can match an empty string
 460    rdepth      the recursion depth
 461
 462 Returns:       MATCH_MATCH if matched            )  these values are >= 0
 463                MATCH_NOMATCH if failed to match  )
 464                a negative MATCH_xxx value for PRUNE, SKIP, etc
 465                a negative PCRE_ERROR_xxx value if aborted by an error condition
 466                  (e.g. stopped by repeated call or recursion limit)
 467 */
 468
 469 static int
 470 match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
 471   const uschar *markptr, int offset_top, match_data *md, unsigned long int ims,
 472   eptrblock *eptrb, int flags, unsigned int rdepth)
 473 {
 474 /* These variables do not need to be preserved over recursion in this function,
 475 so they can be ordinary variables in all cases. Mark some of them with
 476 "register" because they are used a lot in loops. */
 477
 478 register int  rrc;         /* Returns from recursive calls */
 479 register int  i;           /* Used for loops not involving calls to RMATCH() */
 480 register unsigned int c;   /* Character values not kept over RMATCH() calls */
 481 register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
 482
 483 BOOL minimize, possessive; /* Quantifier options */
 484 int condcode;
 485
 486 /* When recursion is not being used, all "local" variables that have to be
 487 preserved over calls to RMATCH() are part of a "frame" which is obtained from
 488 heap storage. Set up the top-level frame here; others are obtained from the
 489 heap whenever RMATCH() does a "recursion". See the macro definitions above. */
 490
 491 #ifdef NO_RECURSE
 492 heapframe *frame = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));
 493 if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
 494 frame->Xprevframe = NULL;            /* Marks the top level */
 495
 496 /* Copy in the original argument variables */
 497
 498 frame->Xeptr = eptr;
 499 frame->Xecode = ecode;
 500 frame->Xmstart = mstart;
 501 frame->Xmarkptr = markptr;
 502 frame->Xoffset_top = offset_top;
 503 frame->Xims = ims;
 504 frame->Xeptrb = eptrb;
 505 frame->Xflags = flags;
 506 frame->Xrdepth = rdepth;
 507
 508 /* This is where control jumps back to to effect "recursion" */
 509
 510 HEAP_RECURSE:
 511
 512 /* Macros make the argument variables come from the current frame */
 513
 514 #define eptr               frame->Xeptr
 515 #define ecode              frame->Xecode
 516 #define mstart             frame->Xmstart
 517 #define markptr            frame->Xmarkptr
 518 #define offset_top         frame->Xoffset_top
 519 #define ims                frame->Xims
 520 #define eptrb              frame->Xeptrb
 521 #define flags              frame->Xflags
 522 #define rdepth             frame->Xrdepth
 523
 524 /* Ditto for the local variables */
 525
 526 #ifdef SUPPORT_UTF8
 527 #define charptr            frame->Xcharptr
 528 #endif
 529 #define callpat            frame->Xcallpat
 530 #define codelink           frame->Xcodelink
 531 #define data               frame->Xdata
 532 #define next               frame->Xnext
 533 #define pp                 frame->Xpp
 534 #define prev               frame->Xprev
 535 #define saved_eptr         frame->Xsaved_eptr
 536
 537 #define new_recursive      frame->Xnew_recursive
 538
 539 #define cur_is_word        frame->Xcur_is_word
 540 #define condition          frame->Xcondition
 541 #define prev_is_word       frame->Xprev_is_word
 542
 543 #define original_ims       frame->Xoriginal_ims
 544
 545 #ifdef SUPPORT_UCP
 546 #define prop_type          frame->Xprop_type
 547 #define prop_value         frame->Xprop_value
 548 #define prop_fail_result   frame->Xprop_fail_result
 549 #define prop_category      frame->Xprop_category
 550 #define prop_chartype      frame->Xprop_chartype
 551 #define prop_script        frame->Xprop_script
 552 #define oclength           frame->Xoclength
 553 #define occhars            frame->Xocchars
 554 #endif
 555
 556 #define ctype              frame->Xctype
 557 #define fc                 frame->Xfc
 558 #define fi                 frame->Xfi
 559 #define length             frame->Xlength
 560 #define max                frame->Xmax
 561 #define min                frame->Xmin
 562 #define number             frame->Xnumber
 563 #define offset             frame->Xoffset
 564 #define op                 frame->Xop
 565 #define save_capture_last  frame->Xsave_capture_last
 566 #define save_offset1       frame->Xsave_offset1
 567 #define save_offset2       frame->Xsave_offset2
 568 #define save_offset3       frame->Xsave_offset3
 569 #define stacksave          frame->Xstacksave
 570
 571 #define newptrb            frame->Xnewptrb
 572
 573 /* When recursion is being used, local variables are allocated on the stack and
 574 get preserved during recursion in the normal way. In this environment, fi and
 575 i, and fc and c, can be the same variables. */
 576
 577 #else         /* NO_RECURSE not defined */
 578 #define fi i
 579 #define fc c
 580
 581
 582 #ifdef SUPPORT_UTF8                /* Many of these variables are used only  */
 583 const uschar *charptr;             /* in small blocks of the code. My normal */
 584 #endif                             /* style of coding would have declared    */
 585 const uschar *callpat;             /* them within each of those blocks.      */
 586 const uschar *data;                /* However, in order to accommodate the   */
 587 const uschar *next;                /* version of this code that uses an      */
 588 USPTR         pp;                  /* external "stack" implemented on the    */
 589 const uschar *prev;                /* heap, it is easier to declare them all */
 590 USPTR         saved_eptr;          /* here, so the declarations can be cut   */
 591                                    /* out in a block. The only declarations  */
 592 recursion_info new_recursive;      /* within blocks below are for variables  */
 593                                    /* that do not have to be preserved over  */
 594 BOOL cur_is_word;                  /* a recursive call to RMATCH().          */
 595 BOOL condition;
 596 BOOL prev_is_word;
 597
 598 unsigned long int original_ims;
 599
 600 #ifdef SUPPORT_UCP
 601 int prop_type;
 602 int prop_value;
 603 int prop_fail_result;
 604 int prop_category;
 605 int prop_chartype;
 606 int prop_script;
 607 int oclength;
 608 uschar occhars[8];
 609 #endif
 610
 611 int codelink;
 612 int ctype;
 613 int length;
 614 int max;
 615 int min;
 616 int number;
 617 int offset;
 618 int op;
 619 int save_capture_last;
 620 int save_offset1, save_offset2, save_offset3;
 621 int stacksave[REC_STACK_SAVE_MAX];
 622
 623 eptrblock newptrb;
 624 #endif     /* NO_RECURSE */
 625
 626 /* These statements are here to stop the compiler complaining about unitialized
 627 variables. */
 628
 629 #ifdef SUPPORT_UCP
 630 prop_value = 0;
 631 prop_fail_result = 0;
 632 #endif
 633
 634
 635 /* This label is used for tail recursion, which is used in a few cases even
 636 when NO_RECURSE is not defined, in order to reduce the amount of stack that is
 637 used. Thanks to Ian Taylor for noticing this possibility and sending the
 638 original patch. */
 639
 640 TAIL_RECURSE:
 641
 642 /* OK, now we can get on with the real code of the function. Recursive calls
 643 are specified by the macro RMATCH and RRETURN is used to return. When
 644 NO_RECURSE is *not* defined, these just turn into a recursive call to match()
 645 and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
 646 defined). However, RMATCH isn't like a function call because it's quite a
 647 complicated macro. It has to be used in one particular way. This shouldn't,
 648 however, impact performance when true recursion is being used. */
 649
 650 #ifdef SUPPORT_UTF8
 651 utf8 = md->utf8;       /* Local copy of the flag */
 652 #else
 653 utf8 = FALSE;
 654 #endif
 655
 656 /* First check that we haven't called match() too many times, or that we
 657 haven't exceeded the recursive call limit. */
 658
 659 if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
 660 if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);
 661
 662 original_ims = ims;    /* Save for resetting on ')' */
 663
 664 /* At the start of a group with an unlimited repeat that may match an empty
 665 string, the match_cbegroup flag is set. When this is the case, add the current
 666 subject pointer to the chain of such remembered pointers, to be checked when we
 667 hit the closing ket, in order to break infinite loops that match no characters.
 668 When match() is called in other circumstances, don't add to the chain. The
 669 match_cbegroup flag must NOT be used with tail recursion, because the memory
 670 block that is used is on the stack, so a new one may be required for each
 671 match(). */
 672
 673 if ((flags & match_cbegroup) != 0)
 674   {
 675   newptrb.epb_saved_eptr = eptr;
 676   newptrb.epb_prev = eptrb;
 677   eptrb = &newptrb;
 678   }
 679
 680 /* Now start processing the opcodes. */
 681
 682 for (;;)
 683   {
 684   minimize = possessive = FALSE;
 685   op = *ecode;
 686
 687   switch(op)
 688     {
 689     case OP_MARK:
 690     markptr = ecode + 2;
 691     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
 692       ims, eptrb, flags, RM55);
 693
 694     /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
 695     argument, and we must check whether that argument matches this MARK's
 696     argument. It is passed back in md->start_match_ptr (an overloading of that
 697     variable). If it does match, we reset that variable to the current subject
 698     position and return MATCH_SKIP. Otherwise, pass back the return code
 699     unaltered. */
 700
 701     if (rrc == MATCH_SKIP_ARG &&
 702         strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
 703       {
 704       md->start_match_ptr = eptr;
 705       RRETURN(MATCH_SKIP);
 706       }
 707
 708     if (md->mark == NULL) md->mark = markptr;
 709     RRETURN(rrc);
 710
 711     case OP_FAIL:
 712     MRRETURN(MATCH_NOMATCH);
 713
 714     /* COMMIT overrides PRUNE, SKIP, and THEN */
 715
 716     case OP_COMMIT:
 717     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
 718       ims, eptrb, flags, RM52);
 719     if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&
 720         rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
 721         rrc != MATCH_THEN)
 722       RRETURN(rrc);
 723     MRRETURN(MATCH_COMMIT);
 724
 725     /* PRUNE overrides THEN */
 726
 727     case OP_PRUNE:
 728     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
 729       ims, eptrb, flags, RM51);
 730     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
 731     MRRETURN(MATCH_PRUNE);
 732
 733     case OP_PRUNE_ARG:
 734     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
 735       ims, eptrb, flags, RM56);
 736     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
 737     md->mark = ecode + 2;
 738     RRETURN(MATCH_PRUNE);
 739
 740     /* SKIP overrides PRUNE and THEN */
 741
 742     case OP_SKIP:
 743     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
 744       ims, eptrb, flags, RM53);
 745     if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
 746       RRETURN(rrc);
 747     md->start_match_ptr = eptr;   /* Pass back current position */
 748     MRRETURN(MATCH_SKIP);
 749
 750     case OP_SKIP_ARG:
 751     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
 752       ims, eptrb, flags, RM57);
 753     if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
 754       RRETURN(rrc);
 755
 756     /* Pass back the current skip name by overloading md->start_match_ptr and
 757     returning the special MATCH_SKIP_ARG return code. This will either be
 758     caught by a matching MARK, or get to the top, where it is treated the same
 759     as PRUNE. */
 760
 761     md->start_match_ptr = ecode + 2;
 762     RRETURN(MATCH_SKIP_ARG);
 763
 764     /* For THEN (and THEN_ARG) we pass back the address of the bracket or
 765     the alt that is at the start of the current branch. This makes it possible
 766     to skip back past alternatives that precede the THEN within the current
 767     branch. */
 768
 769     case OP_THEN:
 770     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
 771       ims, eptrb, flags, RM54);
 772     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
 773     md->start_match_ptr = ecode - GET(ecode, 1);
 774     MRRETURN(MATCH_THEN);
 775
 776     case OP_THEN_ARG:
 777     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
 778       offset_top, md, ims, eptrb, flags, RM58);
 779     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
 780     md->start_match_ptr = ecode - GET(ecode, 1);
 781     md->mark = ecode + LINK_SIZE + 2;
 782     RRETURN(MATCH_THEN);
 783
 784     /* Handle a capturing bracket. If there is space in the offset vector, save
 785     the current subject position in the working slot at the top of the vector.
 786     We mustn't change the current values of the data slot, because they may be
 787     set from a previous iteration of this group, and be referred to by a
 788     reference inside the group.
 789
 790     If the bracket fails to match, we need to restore this value and also the
 791     values of the final offsets, in case they were set by a previous iteration
 792     of the same bracket.
 793
 794     If there isn't enough space in the offset vector, treat this as if it were
 795     a non-capturing bracket. Don't worry about setting the flag for the error
 796     case here; that is handled in the code for KET. */
 797
 798     case OP_CBRA:
 799     case OP_SCBRA:
 800     number = GET2(ecode, 1+LINK_SIZE);
 801     offset = number << 1;
 802
 803 #ifdef PCRE_DEBUG
 804     printf("start bracket %d\n", number);
 805     printf("subject=");
 806     pchars(eptr, 16, TRUE, md);
 807     printf("\n");
 808 #endif
 809
 810     if (offset < md->offset_max)
 811       {
 812       save_offset1 = md->offset_vector[offset];
 813       save_offset2 = md->offset_vector[offset+1];
 814       save_offset3 = md->offset_vector[md->offset_end - number];
 815       save_capture_last = md->capture_last;
 816
 817       DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
 818       md->offset_vector[md->offset_end - number] =
 819         (int)(eptr - md->start_subject);
 820
 821       flags = (op == OP_SCBRA)? match_cbegroup : 0;
 822       do
 823         {
 824         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
 825           ims, eptrb, flags, RM1);
 826         if (rrc != MATCH_NOMATCH &&
 827             (rrc != MATCH_THEN || md->start_match_ptr != ecode))
 828           RRETURN(rrc);
 829         md->capture_last = save_capture_last;
 830         ecode += GET(ecode, 1);
 831         }
 832       while (*ecode == OP_ALT);
 833
 834       DPRINTF(("bracket %d failed\n", number));
 835
 836       md->offset_vector[offset] = save_offset1;
 837       md->offset_vector[offset+1] = save_offset2;
 838       md->offset_vector[md->offset_end - number] = save_offset3;
 839
 840       if (rrc != MATCH_THEN) md->mark = markptr;
 841       RRETURN(MATCH_NOMATCH);
 842       }
 843
 844     /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
 845     as a non-capturing bracket. */
 846
 847     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
 848     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
 849
 850     DPRINTF(("insufficient capture room: treat as non-capturing\n"));
 851
 852     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
 853     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
 854
 855     /* Non-capturing bracket. Loop for all the alternatives. When we get to the
 856     final alternative within the brackets, we would return the result of a
 857     recursive call to match() whatever happened. We can reduce stack usage by
 858     turning this into a tail recursion, except in the case when match_cbegroup
 859     is set.*/
 860
 861     case OP_BRA:
 862     case OP_SBRA:
 863     DPRINTF(("start non-capturing bracket\n"));
 864     flags = (op >= OP_SBRA)? match_cbegroup : 0;
 865     for (;;)
 866       {
 867       if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */
 868         {
 869         if (flags == 0)    /* Not a possibly empty group */
 870           {
 871           ecode += _pcre_OP_lengths[*ecode];
 872           DPRINTF(("bracket 0 tail recursion\n"));
 873           goto TAIL_RECURSE;
 874           }
 875
 876         /* Possibly empty group; can't use tail recursion. */
 877
 878         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
 879           eptrb, flags, RM48);
 880         if (rrc == MATCH_NOMATCH) md->mark = markptr;
 881         RRETURN(rrc);
 882         }
 883
 884       /* For non-final alternatives, continue the loop for a NOMATCH result;
 885       otherwise return. */
 886
 887       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
 888         eptrb, flags, RM2);
 889       if (rrc != MATCH_NOMATCH &&
 890           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
 891         RRETURN(rrc);
 892       ecode += GET(ecode, 1);
 893       }
 894     /* Control never reaches here. */
 895
 896     /* Conditional group: compilation checked that there are no more than
 897     two branches. If the condition is false, skipping the first branch takes us
 898     past the end if there is only one branch, but that's OK because that is
 899     exactly what going to the ket would do. As there is only one branch to be
 900     obeyed, we can use tail recursion to avoid using another stack frame. */
 901
 902     case OP_COND:
 903     case OP_SCOND:
 904     codelink= GET(ecode, 1);
 905
 906     /* Because of the way auto-callout works during compile, a callout item is
 907     inserted between OP_COND and an assertion condition. */
 908
 909     if (ecode[LINK_SIZE+1] == OP_CALLOUT)
 910       {
 911       if (pcre_callout != NULL)
 912         {
 913         pcre_callout_block cb;
 914         cb.version          = 1;   /* Version 1 of the callout block */
 915         cb.callout_number   = ecode[LINK_SIZE+2];
 916         cb.offset_vector    = md->offset_vector;
 917         cb.subject          = (PCRE_SPTR)md->start_subject;
 918         cb.subject_length   = (int)(md->end_subject - md->start_subject);
 919         cb.start_match      = (int)(mstart - md->start_subject);
 920         cb.current_position = (int)(eptr - md->start_subject);
 921         cb.pattern_position = GET(ecode, LINK_SIZE + 3);
 922         cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
 923         cb.capture_top      = offset_top/2;
 924         cb.capture_last     = md->capture_last;
 925         cb.callout_data     = md->callout_data;
 926         if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
 927         if (rrc < 0) RRETURN(rrc);
 928         }
 929       ecode += _pcre_OP_lengths[OP_CALLOUT];
 930       }
 931
 932     condcode = ecode[LINK_SIZE+1];
 933
 934     /* Now see what the actual condition is */
 935
 936     if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */
 937       {
 938       if (md->recursive == NULL)                /* Not recursing => FALSE */
 939         {
 940         condition = FALSE;
 941         ecode += GET(ecode, 1);
 942         }
 943       else
 944         {
 945         int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
 946         condition =  (recno == RREF_ANY || recno == md->recursive->group_num);
 947
 948         /* If the test is for recursion into a specific subpattern, and it is
 949         false, but the test was set up by name, scan the table to see if the
 950         name refers to any other numbers, and test them. The condition is true
 951         if any one is set. */
 952
 953         if (!condition && condcode == OP_NRREF && recno != RREF_ANY)
 954           {
 955           uschar *slotA = md->name_table;
 956           for (i = 0; i < md->name_count; i++)
 957             {
 958             if (GET2(slotA, 0) == recno) break;
 959             slotA += md->name_entry_size;
 960             }
 961
 962           /* Found a name for the number - there can be only one; duplicate
 963           names for different numbers are allowed, but not vice versa. First
 964           scan down for duplicates. */
 965
 966           if (i < md->name_count)
 967             {
 968             uschar *slotB = slotA;
 969             while (slotB > md->name_table)
 970               {
 971               slotB -= md->name_entry_size;
 972               if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
 973                 {
 974                 condition = GET2(slotB, 0) == md->recursive->group_num;
 975                 if (condition) break;
 976                 }
 977               else break;
 978               }
 979
 980             /* Scan up for duplicates */
 981
 982             if (!condition)
 983               {
 984               slotB = slotA;
 985               for (i++; i < md->name_count; i++)
 986                 {
 987                 slotB += md->name_entry_size;
 988                 if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
 989                   {
 990                   condition = GET2(slotB, 0) == md->recursive->group_num;
 991                   if (condition) break;
 992                   }
 993                 else break;
 994                 }
 995               }
 996             }
 997           }
 998
 999         /* Chose branch according to the condition */
1000
1001         ecode += condition? 3 : GET(ecode, 1);
1002         }
1003       }
1004
1005     else if (condcode == OP_CREF || condcode == OP_NCREF)  /* Group used test */
1006       {
1007       offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
1008       condition = offset < offset_top && md->offset_vector[offset] >= 0;
1009
1010       /* If the numbered capture is unset, but the reference was by name,
1011       scan the table to see if the name refers to any other numbers, and test
1012       them. The condition is true if any one is set. This is tediously similar
1013       to the code above, but not close enough to try to amalgamate. */
1014
1015       if (!condition && condcode == OP_NCREF)
1016         {
1017         int refno = offset >> 1;
1018         uschar *slotA = md->name_table;
1019
1020         for (i = 0; i < md->name_count; i++)
1021           {
1022           if (GET2(slotA, 0) == refno) break;
1023           slotA += md->name_entry_size;
1024           }
1025
1026         /* Found a name for the number - there can be only one; duplicate names
1027         for different numbers are allowed, but not vice versa. First scan down
1028         for duplicates. */
1029
1030         if (i < md->name_count)
1031           {
1032           uschar *slotB = slotA;
1033           while (slotB > md->name_table)
1034             {
1035             slotB -= md->name_entry_size;
1036             if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1037               {
1038               offset = GET2(slotB, 0) << 1;
1039               condition = offset < offset_top &&
1040                 md->offset_vector[offset] >= 0;
1041               if (condition) break;
1042               }
1043             else break;
1044             }
1045
1046           /* Scan up for duplicates */
1047
1048           if (!condition)
1049             {
1050             slotB = slotA;
1051             for (i++; i < md->name_count; i++)
1052               {
1053               slotB += md->name_entry_size;
1054               if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1055                 {
1056                 offset = GET2(slotB, 0) << 1;
1057                 condition = offset < offset_top &&
1058                   md->offset_vector[offset] >= 0;
1059                 if (condition) break;
1060                 }
1061               else break;
1062               }
1063             }
1064           }
1065         }
1066
1067       /* Chose branch according to the condition */
1068
1069       ecode += condition? 3 : GET(ecode, 1);
1070       }
1071
1072     else if (condcode == OP_DEF)     /* DEFINE - always false */
1073       {
1074       condition = FALSE;
1075       ecode += GET(ecode, 1);
1076       }
1077
1078     /* The condition is an assertion. Call match() to evaluate it - setting
1079     the final argument match_condassert causes it to stop at the end of an
1080     assertion. */
1081
1082     else
1083       {
1084       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
1085           match_condassert, RM3);
1086       if (rrc == MATCH_MATCH)
1087         {
1088         condition = TRUE;
1089         ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
1090         while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1091         }
1092       else if (rrc != MATCH_NOMATCH &&
1093               (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1094         {
1095         RRETURN(rrc);         /* Need braces because of following else */
1096         }
1097       else
1098         {
1099         condition = FALSE;
1100         ecode += codelink;
1101         }
1102       }
1103
1104     /* We are now at the branch that is to be obeyed. As there is only one,
1105     we can use tail recursion to avoid using another stack frame, except when
1106     match_cbegroup is required for an unlimited repeat of a possibly empty
1107     group. If the second alternative doesn't exist, we can just plough on. */
1108
1109     if (condition || *ecode == OP_ALT)
1110       {
1111       ecode += 1 + LINK_SIZE;
1112       if (op == OP_SCOND)        /* Possibly empty group */
1113         {
1114         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);
1115         RRETURN(rrc);
1116         }
1117       else                       /* Group must match something */
1118         {
1119         flags = 0;
1120         goto TAIL_RECURSE;
1121         }
1122       }
1123     else                         /* Condition false & no alternative */
1124       {
1125       ecode += 1 + LINK_SIZE;
1126       }
1127     break;
1128
1129
1130     /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1131     to close any currently open capturing brackets. */
1132
1133     case OP_CLOSE:
1134     number = GET2(ecode, 1);
1135     offset = number << 1;
1136
1137 #ifdef PCRE_DEBUG
1138       printf("end bracket %d at *ACCEPT", number);
1139       printf("\n");
1140 #endif
1141
1142     md->capture_last = number;
1143     if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1144       {
1145       md->offset_vector[offset] =
1146         md->offset_vector[md->offset_end - number];
1147       md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1148       if (offset_top <= offset) offset_top = offset + 2;
1149       }
1150     ecode += 3;
1151     break;
1152
1153
1154     /* End of the pattern, either real or forced. If we are in a top-level
1155     recursion, we should restore the offsets appropriately and continue from
1156     after the call. */
1157
1158     case OP_ACCEPT:
1159     case OP_END:
1160     if (md->recursive != NULL && md->recursive->group_num == 0)
1161       {
1162       recursion_info *rec = md->recursive;
1163       DPRINTF(("End of pattern in a (?0) recursion\n"));
1164       md->recursive = rec->prevrec;
1165       memmove(md->offset_vector, rec->offset_save,
1166         rec->saved_max * sizeof(int));
1167       offset_top = rec->save_offset_top;
1168       ims = original_ims;
1169       ecode = rec->after_call;
1170       break;
1171       }
1172
1173     /* Otherwise, if we have matched an empty string, fail if PCRE_NOTEMPTY is
1174     set, or if PCRE_NOTEMPTY_ATSTART is set and we have matched at the start of
1175     the subject. In both cases, backtracking will then try other alternatives,
1176     if any. */
1177
1178     if (eptr == mstart &&
1179         (md->notempty ||
1180           (md->notempty_atstart &&
1181             mstart == md->start_subject + md->start_offset)))
1182       MRRETURN(MATCH_NOMATCH);
1183
1184     /* Otherwise, we have a match. */
1185
1186     md->end_match_ptr = eptr;           /* Record where we ended */
1187     md->end_offset_top = offset_top;    /* and how many extracts were taken */
1188     md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1189
1190     /* For some reason, the macros don't work properly if an expression is
1191     given as the argument to MRRETURN when the heap is in use. */
1192
1193     rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1194     MRRETURN(rrc);
1195
1196     /* Change option settings */
1197
1198     case OP_OPT:
1199     ims = ecode[1];
1200     ecode += 2;
1201     DPRINTF(("ims set to %02lx\n", ims));
1202     break;
1203
1204     /* Assertion brackets. Check the alternative branches in turn - the
1205     matching won't pass the KET for an assertion. If any one branch matches,
1206     the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
1207     start of each branch to move the current point backwards, so the code at
1208     this level is identical to the lookahead case. */
1209
1210     case OP_ASSERT:
1211     case OP_ASSERTBACK:
1212     do
1213       {
1214       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1215         RM4);
1216       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1217         {
1218         mstart = md->start_match_ptr;   /* In case \K reset it */
1219         break;
1220         }
1221       if (rrc != MATCH_NOMATCH &&
1222           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1223         RRETURN(rrc);
1224       ecode += GET(ecode, 1);
1225       }
1226     while (*ecode == OP_ALT);
1227     if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1228
1229     /* If checking an assertion for a condition, return MATCH_MATCH. */
1230
1231     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
1232
1233     /* Continue from after the assertion, updating the offsets high water
1234     mark, since extracts may have been taken during the assertion. */
1235
1236     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1237     ecode += 1 + LINK_SIZE;
1238     offset_top = md->end_offset_top;
1239     continue;
1240
1241     /* Negative assertion: all branches must fail to match. Encountering SKIP,
1242     PRUNE, or COMMIT means we must assume failure without checking subsequent
1243     branches. */
1244
1245     case OP_ASSERT_NOT:
1246     case OP_ASSERTBACK_NOT:
1247     do
1248       {
1249       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1250         RM5);
1251       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1252       if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1253         {
1254         do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1255         break;
1256         }
1257       if (rrc != MATCH_NOMATCH &&
1258           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1259         RRETURN(rrc);
1260       ecode += GET(ecode,1);
1261       }
1262     while (*ecode == OP_ALT);
1263
1264     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
1265
1266     ecode += 1 + LINK_SIZE;
1267     continue;
1268
1269     /* Move the subject pointer back. This occurs only at the start of
1270     each branch of a lookbehind assertion. If we are too close to the start to
1271     move back, this match function fails. When working with UTF-8 we move
1272     back a number of characters, not bytes. */
1273
1274     case OP_REVERSE:
1275 #ifdef SUPPORT_UTF8
1276     if (utf8)
1277       {
1278       i = GET(ecode, 1);
1279       while (i-- > 0)
1280         {
1281         eptr--;
1282         if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1283         BACKCHAR(eptr);
1284         }
1285       }
1286     else
1287 #endif
1288
1289     /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
1290
1291       {
1292       eptr -= GET(ecode, 1);
1293       if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1294       }
1295
1296     /* Save the earliest consulted character, then skip to next op code */
1297
1298     if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
1299     ecode += 1 + LINK_SIZE;
1300     break;
1301
1302     /* The callout item calls an external function, if one is provided, passing
1303     details of the match so far. This is mainly for debugging, though the
1304     function is able to force a failure. */
1305
1306     case OP_CALLOUT:
1307     if (pcre_callout != NULL)
1308       {
1309       pcre_callout_block cb;
1310       cb.version          = 1;   /* Version 1 of the callout block */
1311       cb.callout_number   = ecode[1];
1312       cb.offset_vector    = md->offset_vector;
1313       cb.subject          = (PCRE_SPTR)md->start_subject;
1314       cb.subject_length   = (int)(md->end_subject - md->start_subject);
1315       cb.start_match      = (int)(mstart - md->start_subject);
1316       cb.current_position = (int)(eptr - md->start_subject);
1317       cb.pattern_position = GET(ecode, 2);
1318       cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1319       cb.capture_top      = offset_top/2;
1320       cb.capture_last     = md->capture_last;
1321       cb.callout_data     = md->callout_data;
1322       if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1323       if (rrc < 0) RRETURN(rrc);
1324       }
1325     ecode += 2 + 2*LINK_SIZE;
1326     break;
1327
1328     /* Recursion either matches the current regex, or some subexpression. The
1329     offset data is the offset to the starting bracket from the start of the
1330     whole pattern. (This is so that it works from duplicated subpatterns.)
1331
1332     If there are any capturing brackets started but not finished, we have to
1333     save their starting points and reinstate them after the recursion. However,
1334     we don't know how many such there are (offset_top records the completed
1335     total) so we just have to save all the potential data. There may be up to
1336     65535 such values, which is too large to put on the stack, but using malloc
1337     for small numbers seems expensive. As a compromise, the stack is used when
1338     there are no more than REC_STACK_SAVE_MAX values to store; otherwise malloc
1339     is used. A problem is what to do if the malloc fails ... there is no way of
1340     returning to the top level with an error. Save the top REC_STACK_SAVE_MAX
1341     values on the stack, and accept that the rest may be wrong.
1342
1343     There are also other values that have to be saved. We use a chained
1344     sequence of blocks that actually live on the stack. Thanks to Robin Houston
1345     for the original version of this logic. */
1346
1347     case OP_RECURSE:
1348       {
1349       callpat = md->start_code + GET(ecode, 1);
1350       new_recursive.group_num = (callpat == md->start_code)? 0 :
1351         GET2(callpat, 1 + LINK_SIZE);
1352
1353       /* Add to "recursing stack" */
1354
1355       new_recursive.prevrec = md->recursive;
1356       md->recursive = &new_recursive;
1357
1358       /* Find where to continue from afterwards */
1359
1360       ecode += 1 + LINK_SIZE;
1361       new_recursive.after_call = ecode;
1362
1363       /* Now save the offset data. */
1364
1365       new_recursive.saved_max = md->offset_end;
1366       if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
1367         new_recursive.offset_save = stacksave;
1368       else
1369         {
1370         new_recursive.offset_save =
1371           (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));
1372         if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
1373         }
1374
1375       memcpy(new_recursive.offset_save, md->offset_vector,
1376             new_recursive.saved_max * sizeof(int));
1377       new_recursive.save_offset_top = offset_top;
1378
1379       /* OK, now we can do the recursion. For each top-level alternative we
1380       restore the offset and recursion data. */
1381
1382       DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
1383       flags = (*callpat >= OP_SBRA)? match_cbegroup : 0;
1384       do
1385         {
1386         RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1387           md, ims, eptrb, flags, RM6);
1388         if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1389           {
1390           DPRINTF(("Recursion matched\n"));
1391           md->recursive = new_recursive.prevrec;
1392           if (new_recursive.offset_save != stacksave)
1393             (pcre_free)(new_recursive.offset_save);
1394           MRRETURN(MATCH_MATCH);
1395           }
1396         else if (rrc != MATCH_NOMATCH &&
1397                 (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1398           {
1399           DPRINTF(("Recursion gave error %d\n", rrc));
1400           if (new_recursive.offset_save != stacksave)
1401             (pcre_free)(new_recursive.offset_save);
1402           RRETURN(rrc);
1403           }
1404
1405         md->recursive = &new_recursive;
1406         memcpy(md->offset_vector, new_recursive.offset_save,
1407             new_recursive.saved_max * sizeof(int));
1408         callpat += GET(callpat, 1);
1409         }
1410       while (*callpat == OP_ALT);
1411
1412       DPRINTF(("Recursion didn't match\n"));
1413       md->recursive = new_recursive.prevrec;
1414       if (new_recursive.offset_save != stacksave)
1415         (pcre_free)(new_recursive.offset_save);
1416       MRRETURN(MATCH_NOMATCH);
1417       }
1418     /* Control never reaches here */
1419
1420     /* "Once" brackets are like assertion brackets except that after a match,
1421     the point in the subject string is not moved back. Thus there can never be
1422     a move back into the brackets. Friedl calls these "atomic" subpatterns.
1423     Check the alternative branches in turn - the matching won't pass the KET
1424     for this kind of subpattern. If any one branch matches, we carry on as at
1425     the end of a normal bracket, leaving the subject pointer, but resetting
1426     the start-of-match value in case it was changed by \K. */
1427
1428     case OP_ONCE:
1429     prev = ecode;
1430     saved_eptr = eptr;
1431
1432     do
1433       {
1434       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
1435       if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
1436         {
1437         mstart = md->start_match_ptr;
1438         break;
1439         }
1440       if (rrc != MATCH_NOMATCH &&
1441           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1442         RRETURN(rrc);
1443       ecode += GET(ecode,1);
1444       }
1445     while (*ecode == OP_ALT);
1446
1447     /* If hit the end of the group (which could be repeated), fail */
1448
1449     if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
1450
1451     /* Continue as from after the assertion, updating the offsets high water
1452     mark, since extracts may have been taken. */
1453
1454     do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
1455
1456     offset_top = md->end_offset_top;
1457     eptr = md->end_match_ptr;
1458
1459     /* For a non-repeating ket, just continue at this level. This also
1460     happens for a repeating ket if no characters were matched in the group.
1461     This is the forcible breaking of infinite loops as implemented in Perl
1462     5.005. If there is an options reset, it will get obeyed in the normal
1463     course of events. */
1464
1465     if (*ecode == OP_KET || eptr == saved_eptr)
1466       {
1467       ecode += 1+LINK_SIZE;
1468       break;
1469       }
1470
1471     /* The repeating kets try the rest of the pattern or restart from the
1472     preceding bracket, in the appropriate order. The second "call" of match()
1473     uses tail recursion, to avoid using another stack frame. We need to reset
1474     any options that changed within the bracket before re-running it, so
1475     check the next opcode. */
1476
1477     if (ecode[1+LINK_SIZE] == OP_OPT)
1478       {
1479       ims = (ims & ~PCRE_IMS) | ecode[4];
1480       DPRINTF(("ims set to %02lx at group repeat\n", ims));
1481       }
1482
1483     if (*ecode == OP_KETRMIN)
1484       {
1485       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM8);
1486       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1487       ecode = prev;
1488       flags = 0;
1489       goto TAIL_RECURSE;
1490       }
1491     else  /* OP_KETRMAX */
1492       {
1493       RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);
1494       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1495       ecode += 1 + LINK_SIZE;
1496       flags = 0;
1497       goto TAIL_RECURSE;
1498       }
1499     /* Control never gets here */
1500
1501     /* An alternation is the end of a branch; scan along to find the end of the
1502     bracketed group and go to there. */
1503
1504     case OP_ALT:
1505     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1506     break;
1507
1508     /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1509     indicating that it may occur zero times. It may repeat infinitely, or not
1510     at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
1511     with fixed upper repeat limits are compiled as a number of copies, with the
1512     optional ones preceded by BRAZERO or BRAMINZERO. */
1513
1514     case OP_BRAZERO:
1515       {
1516       next = ecode+1;
1517       RMATCH(eptr, next, offset_top, md, ims, eptrb, 0, RM10);
1518       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1519       do next += GET(next,1); while (*next == OP_ALT);
1520       ecode = next + 1 + LINK_SIZE;
1521       }
1522     break;
1523
1524     case OP_BRAMINZERO:
1525       {
1526       next = ecode+1;
1527       do next += GET(next, 1); while (*next == OP_ALT);
1528       RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0, RM11);
1529       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1530       ecode++;
1531       }
1532     break;
1533
1534     case OP_SKIPZERO:
1535       {
1536       next = ecode+1;
1537       do next += GET(next,1); while (*next == OP_ALT);
1538       ecode = next + 1 + LINK_SIZE;
1539       }
1540     break;
1541
1542     /* End of a group, repeated or non-repeating. */
1543
1544     case OP_KET:
1545     case OP_KETRMIN:
1546     case OP_KETRMAX:
1547     prev = ecode - GET(ecode, 1);
1548
1549     /* If this was a group that remembered the subject start, in order to break
1550     infinite repeats of empty string matches, retrieve the subject start from
1551     the chain. Otherwise, set it NULL. */
1552
1553     if (*prev >= OP_SBRA)
1554       {
1555       saved_eptr = eptrb->epb_saved_eptr;   /* Value at start of group */
1556       eptrb = eptrb->epb_prev;              /* Backup to previous group */
1557       }
1558     else saved_eptr = NULL;
1559
1560     /* If we are at the end of an assertion group or an atomic group, stop
1561     matching and return MATCH_MATCH, but record the current high water mark for
1562     use by positive assertions. We also need to record the match start in case
1563     it was changed by \K. */
1564
1565     if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1566         *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
1567         *prev == OP_ONCE)
1568       {
1569       md->end_match_ptr = eptr;      /* For ONCE */
1570       md->end_offset_top = offset_top;
1571       md->start_match_ptr = mstart;
1572       MRRETURN(MATCH_MATCH);
1573       }
1574
1575     /* For capturing groups we have to check the group number back at the start
1576     and if necessary complete handling an extraction by setting the offsets and
1577     bumping the high water mark. Note that whole-pattern recursion is coded as
1578     a recurse into group 0, so it won't be picked up here. Instead, we catch it
1579     when the OP_END is reached. Other recursion is handled here. */
1580
1581     if (*prev == OP_CBRA || *prev == OP_SCBRA)
1582       {
1583       number = GET2(prev, 1+LINK_SIZE);
1584       offset = number << 1;
1585
1586 #ifdef PCRE_DEBUG
1587       printf("end bracket %d", number);
1588       printf("\n");
1589 #endif
1590
1591       md->capture_last = number;
1592       if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1593         {
1594         md->offset_vector[offset] =
1595           md->offset_vector[md->offset_end - number];
1596         md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1597         if (offset_top <= offset) offset_top = offset + 2;
1598         }
1599
1600       /* Handle a recursively called group. Restore the offsets
1601       appropriately and continue from after the call. */
1602
1603       if (md->recursive != NULL && md->recursive->group_num == number)
1604         {
1605         recursion_info *rec = md->recursive;
1606         DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1607         md->recursive = rec->prevrec;
1608         memcpy(md->offset_vector, rec->offset_save,
1609           rec->saved_max * sizeof(int));
1610         offset_top = rec->save_offset_top;
1611         ecode = rec->after_call;
1612         ims = original_ims;
1613         break;
1614         }
1615       }
1616
1617     /* For both capturing and non-capturing groups, reset the value of the ims
1618     flags, in case they got changed during the group. */
1619
1620     ims = original_ims;
1621     DPRINTF(("ims reset to %02lx\n", ims));
1622
1623     /* For a non-repeating ket, just continue at this level. This also
1624     happens for a repeating ket if no characters were matched in the group.
1625     This is the forcible breaking of infinite loops as implemented in Perl
1626     5.005. If there is an options reset, it will get obeyed in the normal
1627     course of events. */
1628
1629     if (*ecode == OP_KET || eptr == saved_eptr)
1630       {
1631       ecode += 1 + LINK_SIZE;
1632       break;
1633       }
1634
1635     /* The repeating kets try the rest of the pattern or restart from the
1636     preceding bracket, in the appropriate order. In the second case, we can use
1637     tail recursion to avoid using another stack frame, unless we have an
1638     unlimited repeat of a group that can match an empty string. */
1639
1640     flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
1641
1642     if (*ecode == OP_KETRMIN)
1643       {
1644       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);
1645       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1646       if (flags != 0)    /* Could match an empty string */
1647         {
1648         RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);
1649         RRETURN(rrc);
1650         }
1651       ecode = prev;
1652       goto TAIL_RECURSE;
1653       }
1654     else  /* OP_KETRMAX */
1655       {
1656       RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);
1657       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1658       ecode += 1 + LINK_SIZE;
1659       flags = 0;
1660       goto TAIL_RECURSE;
1661       }
1662     /* Control never gets here */
1663
1664     /* Start of subject unless notbol, or after internal newline if multiline */
1665
1666     case OP_CIRC:
1667     if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1668     if ((ims & PCRE_MULTILINE) != 0)
1669       {
1670       if (eptr != md->start_subject &&
1671           (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1672         MRRETURN(MATCH_NOMATCH);
1673       ecode++;
1674       break;
1675       }
1676     /* ... else fall through */
1677
1678     /* Start of subject assertion */
1679
1680     case OP_SOD:
1681     if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1682     ecode++;
1683     break;
1684
1685     /* Start of match assertion */
1686
1687     case OP_SOM:
1688     if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1689     ecode++;
1690     break;
1691
1692     /* Reset the start of match point */
1693
1694     case OP_SET_SOM:
1695     mstart = eptr;
1696     ecode++;
1697     break;
1698
1699     /* Assert before internal newline if multiline, or before a terminating
1700     newline unless endonly is set, else end of subject unless noteol is set. */
1701
1702     case OP_DOLL:
1703     if ((ims & PCRE_MULTILINE) != 0)
1704       {
1705       if (eptr < md->end_subject)
1706         { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1707       else
1708         {
1709         if (md->noteol) MRRETURN(MATCH_NOMATCH);
1710         SCHECK_PARTIAL();
1711         }
1712       ecode++;
1713       break;
1714       }
1715     else  /* Not multiline */
1716       {
1717       if (md->noteol) MRRETURN(MATCH_NOMATCH);
1718       if (!md->endonly) goto ASSERT_NL_OR_EOS;
1719       }
1720
1721     /* ... else fall through for endonly */
1722
1723     /* End of subject assertion (\z) */
1724
1725     case OP_EOD:
1726     if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1727     SCHECK_PARTIAL();
1728     ecode++;
1729     break;
1730
1731     /* End of subject or ending \n assertion (\Z) */
1732
1733     case OP_EODN:
1734     ASSERT_NL_OR_EOS:
1735     if (eptr < md->end_subject &&
1736         (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1737       MRRETURN(MATCH_NOMATCH);
1738
1739     /* Either at end of string or \n before end. */
1740
1741     SCHECK_PARTIAL();
1742     ecode++;
1743     break;
1744
1745     /* Word boundary assertions */
1746
1747     case OP_NOT_WORD_BOUNDARY:
1748     case OP_WORD_BOUNDARY:
1749       {
1750
1751       /* Find out if the previous and current characters are "word" characters.
1752       It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
1753       be "non-word" characters. Remember the earliest consulted character for
1754       partial matching. */
1755
1756 #ifdef SUPPORT_UTF8
1757       if (utf8)
1758         {
1759         /* Get status of previous character */
1760
1761         if (eptr == md->start_subject) prev_is_word = FALSE; else
1762           {
1763           USPTR lastptr = eptr - 1;
1764           while((*lastptr & 0xc0) == 0x80) lastptr--;
1765           if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1766           GETCHAR(c, lastptr);
1767 #ifdef SUPPORT_UCP
1768           if (md->use_ucp)
1769             {
1770             if (c == '_') prev_is_word = TRUE; else
1771               {
1772               int cat = UCD_CATEGORY(c);
1773               prev_is_word = (cat == ucp_L || cat == ucp_N);
1774               }
1775             }
1776           else
1777 #endif
1778           prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1779           }
1780
1781         /* Get status of next character */
1782
1783         if (eptr >= md->end_subject)
1784           {
1785           SCHECK_PARTIAL();
1786           cur_is_word = FALSE;
1787           }
1788         else
1789           {
1790           GETCHAR(c, eptr);
1791 #ifdef SUPPORT_UCP
1792           if (md->use_ucp)
1793             {
1794             if (c == '_') cur_is_word = TRUE; else
1795               {
1796               int cat = UCD_CATEGORY(c);
1797               cur_is_word = (cat == ucp_L || cat == ucp_N);
1798               }
1799             }
1800           else
1801 #endif
1802           cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1803           }
1804         }
1805       else
1806 #endif
1807
1808       /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
1809       consistency with the behaviour of \w we do use it in this case. */
1810
1811         {
1812         /* Get status of previous character */
1813
1814         if (eptr == md->start_subject) prev_is_word = FALSE; else
1815           {
1816           if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
1817 #ifdef SUPPORT_UCP
1818           if (md->use_ucp)
1819             {
1820             c = eptr[-1];
1821             if (c == '_') prev_is_word = TRUE; else
1822               {
1823               int cat = UCD_CATEGORY(c);
1824               prev_is_word = (cat == ucp_L || cat == ucp_N);
1825               }
1826             }
1827           else
1828 #endif
1829           prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1830           }
1831
1832         /* Get status of next character */
1833
1834         if (eptr >= md->end_subject)
1835           {
1836           SCHECK_PARTIAL();
1837           cur_is_word = FALSE;
1838           }
1839         else
1840 #ifdef SUPPORT_UCP
1841         if (md->use_ucp)
1842           {
1843           c = *eptr;
1844           if (c == '_') cur_is_word = TRUE; else
1845             {
1846             int cat = UCD_CATEGORY(c);
1847             cur_is_word = (cat == ucp_L || cat == ucp_N);
1848             }
1849           }
1850         else
1851 #endif
1852         cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
1853         }
1854
1855       /* Now see if the situation is what we want */
1856
1857       if ((*ecode++ == OP_WORD_BOUNDARY)?
1858            cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1859         MRRETURN(MATCH_NOMATCH);
1860       }
1861     break;
1862
1863     /* Match a single character type; inline for speed */
1864
1865     case OP_ANY:
1866     if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1867     /* Fall through */
1868
1869     case OP_ALLANY:
1870     if (eptr++ >= md->end_subject)
1871       {
1872       SCHECK_PARTIAL();
1873       MRRETURN(MATCH_NOMATCH);
1874       }
1875     if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1876     ecode++;
1877     break;
1878
1879     /* Match a single byte, even in UTF-8 mode. This opcode really does match
1880     any byte, even newline, independent of the setting of PCRE_DOTALL. */
1881
1882     case OP_ANYBYTE:
1883     if (eptr++ >= md->end_subject)
1884       {
1885       SCHECK_PARTIAL();
1886       MRRETURN(MATCH_NOMATCH);
1887       }
1888     ecode++;
1889     break;
1890
1891     case OP_NOT_DIGIT:
1892     if (eptr >= md->end_subject)
1893       {
1894       SCHECK_PARTIAL();
1895       MRRETURN(MATCH_NOMATCH);
1896       }
1897     GETCHARINCTEST(c, eptr);
1898     if (
1899 #ifdef SUPPORT_UTF8
1900        c < 256 &&
1901 #endif
1902        (md->ctypes[c] & ctype_digit) != 0
1903        )
1904       MRRETURN(MATCH_NOMATCH);
1905     ecode++;
1906     break;
1907
1908     case OP_DIGIT:
1909     if (eptr >= md->end_subject)
1910       {
1911       SCHECK_PARTIAL();
1912       MRRETURN(MATCH_NOMATCH);
1913       }
1914     GETCHARINCTEST(c, eptr);
1915     if (
1916 #ifdef SUPPORT_UTF8
1917        c >= 256 ||
1918 #endif
1919        (md->ctypes[c] & ctype_digit) == 0
1920        )
1921       MRRETURN(MATCH_NOMATCH);
1922     ecode++;
1923     break;
1924
1925     case OP_NOT_WHITESPACE:
1926     if (eptr >= md->end_subject)
1927       {
1928       SCHECK_PARTIAL();
1929       MRRETURN(MATCH_NOMATCH);
1930       }
1931     GETCHARINCTEST(c, eptr);
1932     if (
1933 #ifdef SUPPORT_UTF8
1934        c < 256 &&
1935 #endif
1936        (md->ctypes[c] & ctype_space) != 0
1937        )
1938       MRRETURN(MATCH_NOMATCH);
1939     ecode++;
1940     break;
1941
1942     case OP_WHITESPACE:
1943     if (eptr >= md->end_subject)
1944       {
1945       SCHECK_PARTIAL();
1946       MRRETURN(MATCH_NOMATCH);
1947       }
1948     GETCHARINCTEST(c, eptr);
1949     if (
1950 #ifdef SUPPORT_UTF8
1951        c >= 256 ||
1952 #endif
1953        (md->ctypes[c] & ctype_space) == 0
1954        )
1955       MRRETURN(MATCH_NOMATCH);
1956     ecode++;
1957     break;
1958
1959     case OP_NOT_WORDCHAR:
1960     if (eptr >= md->end_subject)
1961       {
1962       SCHECK_PARTIAL();
1963       MRRETURN(MATCH_NOMATCH);
1964       }
1965     GETCHARINCTEST(c, eptr);
1966     if (
1967 #ifdef SUPPORT_UTF8
1968        c < 256 &&
1969 #endif
1970        (md->ctypes[c] & ctype_word) != 0
1971        )
1972       MRRETURN(MATCH_NOMATCH);
1973     ecode++;
1974     break;
1975
1976     case OP_WORDCHAR:
1977     if (eptr >= md->end_subject)
1978       {
1979       SCHECK_PARTIAL();
1980       MRRETURN(MATCH_NOMATCH);
1981       }
1982     GETCHARINCTEST(c, eptr);
1983     if (
1984 #ifdef SUPPORT_UTF8
1985        c >= 256 ||
1986 #endif
1987        (md->ctypes[c] & ctype_word) == 0
1988        )
1989       MRRETURN(MATCH_NOMATCH);
1990     ecode++;
1991     break;
1992
1993     case OP_ANYNL:
1994     if (eptr >= md->end_subject)
1995       {
1996       SCHECK_PARTIAL();
1997       MRRETURN(MATCH_NOMATCH);
1998       }
1999     GETCHARINCTEST(c, eptr);
2000     switch(c)
2001       {
2002       default: MRRETURN(MATCH_NOMATCH);
2003       case 0x000d:
2004       if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
2005       break;
2006
2007       case 0x000a:
2008       break;
2009
2010       case 0x000b:
2011       case 0x000c:
2012       case 0x0085:
2013       case 0x2028:
2014       case 0x2029:
2015       if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
2016       break;
2017       }
2018     ecode++;
2019     break;
2020
2021     case OP_NOT_HSPACE:
2022     if (eptr >= md->end_subject)
2023       {
2024       SCHECK_PARTIAL();
2025       MRRETURN(MATCH_NOMATCH);
2026       }
2027     GETCHARINCTEST(c, eptr);
2028     switch(c)
2029       {
2030       default: break;
2031       case 0x09:      /* HT */
2032       case 0x20:      /* SPACE */
2033       case 0xa0:      /* NBSP */
2034       case 0x1680:    /* OGHAM SPACE MARK */
2035       case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
2036       case 0x2000:    /* EN QUAD */
2037       case 0x2001:    /* EM QUAD */
2038       case 0x2002:    /* EN SPACE */
2039       case 0x2003:    /* EM SPACE */
2040       case 0x2004:    /* THREE-PER-EM SPACE */
2041       case 0x2005:    /* FOUR-PER-EM SPACE */
2042       case 0x2006:    /* SIX-PER-EM SPACE */
2043       case 0x2007:    /* FIGURE SPACE */
2044       case 0x2008:    /* PUNCTUATION SPACE */
2045       case 0x2009:    /* THIN SPACE */
2046       case 0x200A:    /* HAIR SPACE */
2047       case 0x202f:    /* NARROW NO-BREAK SPACE */
2048       case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2049       case 0x3000:    /* IDEOGRAPHIC SPACE */
2050       MRRETURN(MATCH_NOMATCH);
2051       }
2052     ecode++;
2053     break;
2054
2055     case OP_HSPACE:
2056     if (eptr >= md->end_subject)
2057       {
2058       SCHECK_PARTIAL();
2059       MRRETURN(MATCH_NOMATCH);
2060       }
2061     GETCHARINCTEST(c, eptr);
2062     switch(c)
2063       {
2064       default: MRRETURN(MATCH_NOMATCH);
2065       case 0x09:      /* HT */
2066       case 0x20:      /* SPACE */
2067       case 0xa0:      /* NBSP */
2068       case 0x1680:    /* OGHAM SPACE MARK */
2069       case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
2070       case 0x2000:    /* EN QUAD */
2071       case 0x2001:    /* EM QUAD */
2072       case 0x2002:    /* EN SPACE */
2073       case 0x2003:    /* EM SPACE */
2074       case 0x2004:    /* THREE-PER-EM SPACE */
2075       case 0x2005:    /* FOUR-PER-EM SPACE */
2076       case 0x2006:    /* SIX-PER-EM SPACE */
2077       case 0x2007:    /* FIGURE SPACE */
2078       case 0x2008:    /* PUNCTUATION SPACE */
2079       case 0x2009:    /* THIN SPACE */
2080       case 0x200A:    /* HAIR SPACE */
2081       case 0x202f:    /* NARROW NO-BREAK SPACE */
2082       case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2083       case 0x3000:    /* IDEOGRAPHIC SPACE */
2084       break;
2085       }
2086     ecode++;
2087     break;
2088
2089     case OP_NOT_VSPACE:
2090     if (eptr >= md->end_subject)
2091       {
2092       SCHECK_PARTIAL();
2093       MRRETURN(MATCH_NOMATCH);
2094       }
2095     GETCHARINCTEST(c, eptr);
2096     switch(c)
2097       {
2098       default: break;
2099       case 0x0a:      /* LF */
2100       case 0x0b:      /* VT */
2101       case 0x0c:      /* FF */
2102       case 0x0d:      /* CR */
2103       case 0x85:      /* NEL */
2104       case 0x2028:    /* LINE SEPARATOR */
2105       case 0x2029:    /* PARAGRAPH SEPARATOR */
2106       MRRETURN(MATCH_NOMATCH);
2107       }
2108     ecode++;
2109     break;
2110
2111     case OP_VSPACE:
2112     if (eptr >= md->end_subject)
2113       {
2114       SCHECK_PARTIAL();
2115       MRRETURN(MATCH_NOMATCH);
2116       }
2117     GETCHARINCTEST(c, eptr);
2118     switch(c)
2119       {
2120       default: MRRETURN(MATCH_NOMATCH);
2121       case 0x0a:      /* LF */
2122       case 0x0b:      /* VT */
2123       case 0x0c:      /* FF */
2124       case 0x0d:      /* CR */
2125       case 0x85:      /* NEL */
2126       case 0x2028:    /* LINE SEPARATOR */
2127       case 0x2029:    /* PARAGRAPH SEPARATOR */
2128       break;
2129       }
2130     ecode++;
2131     break;
2132
2133 #ifdef SUPPORT_UCP
2134     /* Check the next character by Unicode property. We will get here only
2135     if the support is in the binary; otherwise a compile-time error occurs. */
2136
2137     case OP_PROP:
2138     case OP_NOTPROP:
2139     if (eptr >= md->end_subject)
2140       {
2141       SCHECK_PARTIAL();
2142       MRRETURN(MATCH_NOMATCH);
2143       }
2144     GETCHARINCTEST(c, eptr);
2145       {
2146       const ucd_record *prop = GET_UCD(c);
2147
2148       switch(ecode[1])
2149         {
2150         case PT_ANY:
2151         if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2152         break;
2153
2154         case PT_LAMP:
2155         if ((prop->chartype == ucp_Lu ||
2156              prop->chartype == ucp_Ll ||
2157              prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2158           MRRETURN(MATCH_NOMATCH);
2159         break;
2160
2161         case PT_GC:
2162         if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2163           MRRETURN(MATCH_NOMATCH);
2164         break;
2165
2166         case PT_PC:
2167         if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2168           MRRETURN(MATCH_NOMATCH);
2169         break;
2170
2171         case PT_SC:
2172         if ((ecode[2] != prop->script) == (op == OP_PROP))
2173           MRRETURN(MATCH_NOMATCH);
2174         break;
2175
2176         /* These are specials */
2177
2178         case PT_ALNUM:
2179         if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2180              _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2181           MRRETURN(MATCH_NOMATCH);
2182         break;
2183
2184         case PT_SPACE:    /* Perl space */
2185         if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2186              c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2187                == (op == OP_NOTPROP))
2188           MRRETURN(MATCH_NOMATCH);
2189         break;
2190
2191         case PT_PXSPACE:  /* POSIX space */
2192         if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2193              c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2194              c == CHAR_FF || c == CHAR_CR)
2195                == (op == OP_NOTPROP))
2196           MRRETURN(MATCH_NOMATCH);
2197         break;
2198
2199         case PT_WORD:
2200         if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2201              _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2202              c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2203           MRRETURN(MATCH_NOMATCH);
2204         break;
2205
2206         /* This should never occur */
2207
2208         default:
2209         RRETURN(PCRE_ERROR_INTERNAL);
2210         }
2211
2212       ecode += 3;
2213       }
2214     break;
2215
2216     /* Match an extended Unicode sequence. We will get here only if the support
2217     is in the binary; otherwise a compile-time error occurs. */
2218
2219     case OP_EXTUNI:
2220     if (eptr >= md->end_subject)
2221       {
2222       SCHECK_PARTIAL();
2223       MRRETURN(MATCH_NOMATCH);
2224       }
2225     GETCHARINCTEST(c, eptr);
2226       {
2227       int category = UCD_CATEGORY(c);
2228       if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2229       while (eptr < md->end_subject)
2230         {
2231         int len = 1;
2232         if (!utf8) c = *eptr; else
2233           {
2234           GETCHARLEN(c, eptr, len);
2235           }
2236         category = UCD_CATEGORY(c);
2237         if (category != ucp_M) break;
2238         eptr += len;
2239         }
2240       }
2241     ecode++;
2242     break;
2243 #endif
2244
2245
2246     /* Match a back reference, possibly repeatedly. Look past the end of the
2247     item to see if there is repeat information following. The code is similar
2248     to that for character classes, but repeated for efficiency. Then obey
2249     similar code to character type repeats - written out again for speed.
2250     However, if the referenced string is the empty string, always treat
2251     it as matched, any number of times (otherwise there could be infinite
2252     loops). */
2253
2254     case OP_REF:
2255       {
2256       offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
2257       ecode += 3;
2258
2259       /* If the reference is unset, there are two possibilities:
2260
2261       (a) In the default, Perl-compatible state, set the length to be longer
2262       than the amount of subject left; this ensures that every attempt at a
2263       match fails. We can't just fail here, because of the possibility of
2264       quantifiers with zero minima.
2265
2266       (b) If the JavaScript compatibility flag is set, set the length to zero
2267       so that the back reference matches an empty string.
2268
2269       Otherwise, set the length to the length of what was matched by the
2270       referenced subpattern. */
2271
2272       if (offset >= offset_top || md->offset_vector[offset] < 0)
2273         length = (md->jscript_compat)? 0 : (int)(md->end_subject - eptr + 1);
2274       else
2275         length = md->offset_vector[offset+1] - md->offset_vector[offset];
2276
2277       /* Set up for repetition, or handle the non-repeated case */
2278
2279       switch (*ecode)
2280         {
2281         case OP_CRSTAR:
2282         case OP_CRMINSTAR:
2283         case OP_CRPLUS:
2284         case OP_CRMINPLUS:
2285         case OP_CRQUERY:
2286         case OP_CRMINQUERY:
2287         c = *ecode++ - OP_CRSTAR;
2288         minimize = (c & 1) != 0;
2289         min = rep_min[c];                 /* Pick up values from tables; */
2290         max = rep_max[c];                 /* zero for max => infinity */
2291         if (max == 0) max = INT_MAX;
2292         break;
2293
2294         case OP_CRRANGE:
2295         case OP_CRMINRANGE:
2296         minimize = (*ecode == OP_CRMINRANGE);
2297         min = GET2(ecode, 1);
2298         max = GET2(ecode, 3);
2299         if (max == 0) max = INT_MAX;
2300         ecode += 5;
2301         break;
2302
2303         default:               /* No repeat follows */
2304         if (!match_ref(offset, eptr, length, md, ims))
2305           {
2306           CHECK_PARTIAL();
2307           MRRETURN(MATCH_NOMATCH);
2308           }
2309         eptr += length;
2310         continue;              /* With the main loop */
2311         }
2312
2313       /* If the length of the reference is zero, just continue with the
2314       main loop. */
2315
2316       if (length == 0) continue;
2317
2318       /* First, ensure the minimum number of matches are present. We get back
2319       the length of the reference string explicitly rather than passing the
2320       address of eptr, so that eptr can be a register variable. */
2321
2322       for (i = 1; i <= min; i++)
2323         {
2324         if (!match_ref(offset, eptr, length, md, ims))
2325           {
2326           CHECK_PARTIAL();
2327           MRRETURN(MATCH_NOMATCH);
2328           }
2329         eptr += length;
2330         }
2331
2332       /* If min = max, continue at the same level without recursion.
2333       They are not both allowed to be zero. */
2334
2335       if (min == max) continue;
2336
2337       /* If minimizing, keep trying and advancing the pointer */
2338
2339       if (minimize)
2340         {
2341         for (fi = min;; fi++)
2342           {
2343           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2344           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2345           if (fi >= max) MRRETURN(MATCH_NOMATCH);
2346           if (!match_ref(offset, eptr, length, md, ims))
2347             {
2348             CHECK_PARTIAL();
2349             MRRETURN(MATCH_NOMATCH);
2350             }
2351           eptr += length;
2352           }
2353         /* Control never gets here */
2354         }
2355
2356       /* If maximizing, find the longest string and work backwards */
2357
2358       else
2359         {
2360         pp = eptr;
2361         for (i = min; i < max; i++)
2362           {
2363           if (!match_ref(offset, eptr, length, md, ims))
2364             {
2365             CHECK_PARTIAL();
2366             break;
2367             }
2368           eptr += length;
2369           }
2370         while (eptr >= pp)
2371           {
2372           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
2373           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2374           eptr -= length;
2375           }
2376         MRRETURN(MATCH_NOMATCH);
2377         }
2378       }
2379     /* Control never gets here */
2380
2381     /* Match a bit-mapped character class, possibly repeatedly. This op code is
2382     used when all the characters in the class have values in the range 0-255,
2383     and either the matching is caseful, or the characters are in the range
2384     0-127 when UTF-8 processing is enabled. The only difference between
2385     OP_CLASS and OP_NCLASS occurs when a data character outside the range is
2386     encountered.
2387
2388     First, look past the end of the item to see if there is repeat information
2389     following. Then obey similar code to character type repeats - written out
2390     again for speed. */
2391
2392     case OP_NCLASS:
2393     case OP_CLASS:
2394       {
2395       data = ecode + 1;                /* Save for matching */
2396       ecode += 33;                     /* Advance past the item */
2397
2398       switch (*ecode)
2399         {
2400         case OP_CRSTAR:
2401         case OP_CRMINSTAR:
2402         case OP_CRPLUS:
2403         case OP_CRMINPLUS:
2404         case OP_CRQUERY:
2405         case OP_CRMINQUERY:
2406         c = *ecode++ - OP_CRSTAR;
2407         minimize = (c & 1) != 0;
2408         min = rep_min[c];                 /* Pick up values from tables; */
2409         max = rep_max[c];                 /* zero for max => infinity */
2410         if (max == 0) max = INT_MAX;
2411         break;
2412
2413         case OP_CRRANGE:
2414         case OP_CRMINRANGE:
2415         minimize = (*ecode == OP_CRMINRANGE);
2416         min = GET2(ecode, 1);
2417         max = GET2(ecode, 3);
2418         if (max == 0) max = INT_MAX;
2419         ecode += 5;
2420         break;
2421
2422         default:               /* No repeat follows */
2423         min = max = 1;
2424         break;
2425         }
2426
2427       /* First, ensure the minimum number of matches are present. */
2428
2429 #ifdef SUPPORT_UTF8
2430       /* UTF-8 mode */
2431       if (utf8)
2432         {
2433         for (i = 1; i <= min; i++)
2434           {
2435           if (eptr >= md->end_subject)
2436             {
2437             SCHECK_PARTIAL();
2438             MRRETURN(MATCH_NOMATCH);
2439             }
2440           GETCHARINC(c, eptr);
2441           if (c > 255)
2442             {
2443             if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2444             }
2445           else
2446             {
2447             if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2448             }
2449           }
2450         }
2451       else
2452 #endif
2453       /* Not UTF-8 mode */
2454         {
2455         for (i = 1; i <= min; i++)
2456           {
2457           if (eptr >= md->end_subject)
2458             {
2459             SCHECK_PARTIAL();
2460             MRRETURN(MATCH_NOMATCH);
2461             }
2462           c = *eptr++;
2463           if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2464           }
2465         }
2466
2467       /* If max == min we can continue with the main loop without the
2468       need to recurse. */
2469
2470       if (min == max) continue;
2471
2472       /* If minimizing, keep testing the rest of the expression and advancing
2473       the pointer while it matches the class. */
2474
2475       if (minimize)
2476         {
2477 #ifdef SUPPORT_UTF8
2478         /* UTF-8 mode */
2479         if (utf8)
2480           {
2481           for (fi = min;; fi++)
2482             {
2483             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2484             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2485             if (fi >= max) MRRETURN(MATCH_NOMATCH);
2486             if (eptr >= md->end_subject)
2487               {
2488               SCHECK_PARTIAL();
2489               MRRETURN(MATCH_NOMATCH);
2490               }
2491             GETCHARINC(c, eptr);
2492             if (c > 255)
2493               {
2494               if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2495               }
2496             else
2497               {
2498               if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2499               }
2500             }
2501           }
2502         else
2503 #endif
2504         /* Not UTF-8 mode */
2505           {
2506           for (fi = min;; fi++)
2507             {
2508             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2509             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2510             if (fi >= max) MRRETURN(MATCH_NOMATCH);
2511             if (eptr >= md->end_subject)
2512               {
2513               SCHECK_PARTIAL();
2514               MRRETURN(MATCH_NOMATCH);
2515               }
2516             c = *eptr++;
2517             if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2518             }
2519           }
2520         /* Control never gets here */
2521         }
2522
2523       /* If maximizing, find the longest possible run, then work backwards. */
2524
2525       else
2526         {
2527         pp = eptr;
2528
2529 #ifdef SUPPORT_UTF8
2530         /* UTF-8 mode */
2531         if (utf8)
2532           {
2533           for (i = min; i < max; i++)
2534             {
2535             int len = 1;
2536             if (eptr >= md->end_subject)
2537               {
2538               SCHECK_PARTIAL();
2539               break;
2540               }
2541             GETCHARLEN(c, eptr, len);
2542             if (c > 255)
2543               {
2544               if (op == OP_CLASS) break;
2545               }
2546             else
2547               {
2548               if ((data[c/8] & (1 << (c&7))) == 0) break;
2549               }
2550             eptr += len;
2551             }
2552           for (;;)
2553             {
2554             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
2555             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2556             if (eptr-- == pp) break;        /* Stop if tried at original pos */
2557             BACKCHAR(eptr);
2558             }
2559           }
2560         else
2561 #endif
2562           /* Not UTF-8 mode */
2563           {
2564           for (i = min; i < max; i++)
2565             {
2566             if (eptr >= md->end_subject)
2567               {
2568               SCHECK_PARTIAL();
2569               break;
2570               }
2571             c = *eptr;
2572             if ((data[c/8] & (1 << (c&7))) == 0) break;
2573             eptr++;
2574             }
2575           while (eptr >= pp)
2576             {
2577             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
2578             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2579             eptr--;
2580             }
2581           }
2582
2583         MRRETURN(MATCH_NOMATCH);
2584         }
2585       }
2586     /* Control never gets here */
2587
2588
2589     /* Match an extended character class. This opcode is encountered only
2590     when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
2591     mode, because Unicode properties are supported in non-UTF-8 mode. */
2592
2593 #ifdef SUPPORT_UTF8
2594     case OP_XCLASS:
2595       {
2596       data = ecode + 1 + LINK_SIZE;                /* Save for matching */
2597       ecode += GET(ecode, 1);                      /* Advance past the item */
2598
2599       switch (*ecode)
2600         {
2601         case OP_CRSTAR:
2602         case OP_CRMINSTAR:
2603         case OP_CRPLUS:
2604         case OP_CRMINPLUS:
2605         case OP_CRQUERY:
2606         case OP_CRMINQUERY:
2607         c = *ecode++ - OP_CRSTAR;
2608         minimize = (c & 1) != 0;
2609         min = rep_min[c];                 /* Pick up values from tables; */
2610         max = rep_max[c];                 /* zero for max => infinity */
2611         if (max == 0) max = INT_MAX;
2612         break;
2613
2614         case OP_CRRANGE:
2615         case OP_CRMINRANGE:
2616         minimize = (*ecode == OP_CRMINRANGE);
2617         min = GET2(ecode, 1);
2618         max = GET2(ecode, 3);
2619         if (max == 0) max = INT_MAX;
2620         ecode += 5;
2621         break;
2622
2623         default:               /* No repeat follows */
2624         min = max = 1;
2625         break;
2626         }
2627
2628       /* First, ensure the minimum number of matches are present. */
2629
2630       for (i = 1; i <= min; i++)
2631         {
2632         if (eptr >= md->end_subject)
2633           {
2634           SCHECK_PARTIAL();
2635           MRRETURN(MATCH_NOMATCH);
2636           }
2637         GETCHARINCTEST(c, eptr);
2638         if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2639         }
2640
2641       /* If max == min we can continue with the main loop without the
2642       need to recurse. */
2643
2644       if (min == max) continue;
2645
2646       /* If minimizing, keep testing the rest of the expression and advancing
2647       the pointer while it matches the class. */
2648
2649       if (minimize)
2650         {
2651         for (fi = min;; fi++)
2652           {
2653           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2654           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2655           if (fi >= max) MRRETURN(MATCH_NOMATCH);
2656           if (eptr >= md->end_subject)
2657             {
2658             SCHECK_PARTIAL();
2659             MRRETURN(MATCH_NOMATCH);
2660             }
2661           GETCHARINCTEST(c, eptr);
2662           if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2663           }
2664         /* Control never gets here */
2665         }
2666
2667       /* If maximizing, find the longest possible run, then work backwards. */
2668
2669       else
2670         {
2671         pp = eptr;
2672         for (i = min; i < max; i++)
2673           {
2674           int len = 1;
2675           if (eptr >= md->end_subject)
2676             {
2677             SCHECK_PARTIAL();
2678             break;
2679             }
2680           GETCHARLENTEST(c, eptr, len);
2681           if (!_pcre_xclass(c, data)) break;
2682           eptr += len;
2683           }
2684         for(;;)
2685           {
2686           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
2687           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2688           if (eptr-- == pp) break;        /* Stop if tried at original pos */
2689           if (utf8) BACKCHAR(eptr);
2690           }
2691         MRRETURN(MATCH_NOMATCH);
2692         }
2693
2694       /* Control never gets here */
2695       }
2696 #endif    /* End of XCLASS */
2697
2698     /* Match a single character, casefully */
2699
2700     case OP_CHAR:
2701 #ifdef SUPPORT_UTF8
2702     if (utf8)
2703       {
2704       length = 1;
2705       ecode++;
2706       GETCHARLEN(fc, ecode, length);
2707       if (length > md->end_subject - eptr)
2708         {
2709         CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2710         MRRETURN(MATCH_NOMATCH);
2711         }
2712       while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2713       }
2714     else
2715 #endif
2716
2717     /* Non-UTF-8 mode */
2718       {
2719       if (md->end_subject - eptr < 1)
2720         {
2721         SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2722         MRRETURN(MATCH_NOMATCH);
2723         }
2724       if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2725       ecode += 2;
2726       }
2727     break;
2728
2729     /* Match a single character, caselessly */
2730
2731     case OP_CHARNC:
2732 #ifdef SUPPORT_UTF8
2733     if (utf8)
2734       {
2735       length = 1;
2736       ecode++;
2737       GETCHARLEN(fc, ecode, length);
2738
2739       if (length > md->end_subject - eptr)
2740         {
2741         CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2742         MRRETURN(MATCH_NOMATCH);
2743         }
2744
2745       /* If the pattern character's value is < 128, we have only one byte, and
2746       can use the fast lookup table. */
2747
2748       if (fc < 128)
2749         {
2750         if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2751         }
2752
2753       /* Otherwise we must pick up the subject character */
2754
2755       else
2756         {
2757         unsigned int dc;
2758         GETCHARINC(dc, eptr);
2759         ecode += length;
2760
2761         /* If we have Unicode property support, we can use it to test the other
2762         case of the character, if there is one. */
2763
2764         if (fc != dc)
2765           {
2766 #ifdef SUPPORT_UCP
2767           if (dc != UCD_OTHERCASE(fc))
2768 #endif
2769             MRRETURN(MATCH_NOMATCH);
2770           }
2771         }
2772       }
2773     else
2774 #endif   /* SUPPORT_UTF8 */
2775
2776     /* Non-UTF-8 mode */
2777       {
2778       if (md->end_subject - eptr < 1)
2779         {
2780         SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2781         MRRETURN(MATCH_NOMATCH);
2782         }
2783       if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2784       ecode += 2;
2785       }
2786     break;
2787
2788     /* Match a single character repeatedly. */
2789
2790     case OP_EXACT:
2791     min = max = GET2(ecode, 1);
2792     ecode += 3;
2793     goto REPEATCHAR;
2794
2795     case OP_POSUPTO:
2796     possessive = TRUE;
2797     /* Fall through */
2798
2799     case OP_UPTO:
2800     case OP_MINUPTO:
2801     min = 0;
2802     max = GET2(ecode, 1);
2803     minimize = *ecode == OP_MINUPTO;
2804     ecode += 3;
2805     goto REPEATCHAR;
2806
2807     case OP_POSSTAR:
2808     possessive = TRUE;
2809     min = 0;
2810     max = INT_MAX;
2811     ecode++;
2812     goto REPEATCHAR;
2813
2814     case OP_POSPLUS:
2815     possessive = TRUE;
2816     min = 1;
2817     max = INT_MAX;
2818     ecode++;
2819     goto REPEATCHAR;
2820
2821     case OP_POSQUERY:
2822     possessive = TRUE;
2823     min = 0;
2824     max = 1;
2825     ecode++;
2826     goto REPEATCHAR;
2827
2828     case OP_STAR:
2829     case OP_MINSTAR:
2830     case OP_PLUS:
2831     case OP_MINPLUS:
2832     case OP_QUERY:
2833     case OP_MINQUERY:
2834     c = *ecode++ - OP_STAR;
2835     minimize = (c & 1) != 0;
2836
2837     min = rep_min[c];                 /* Pick up values from tables; */
2838     max = rep_max[c];                 /* zero for max => infinity */
2839     if (max == 0) max = INT_MAX;
2840
2841     /* Common code for all repeated single-character matches. */
2842
2843     REPEATCHAR:
2844 #ifdef SUPPORT_UTF8
2845     if (utf8)
2846       {
2847       length = 1;
2848       charptr = ecode;
2849       GETCHARLEN(fc, ecode, length);
2850       ecode += length;
2851
2852       /* Handle multibyte character matching specially here. There is
2853       support for caseless matching if UCP support is present. */
2854
2855       if (length > 1)
2856         {
2857 #ifdef SUPPORT_UCP
2858         unsigned int othercase;
2859         if ((ims & PCRE_CASELESS) != 0 &&
2860             (othercase = UCD_OTHERCASE(fc)) != fc)
2861           oclength = _pcre_ord2utf8(othercase, occhars);
2862         else oclength = 0;
2863 #endif  /* SUPPORT_UCP */
2864
2865         for (i = 1; i <= min; i++)
2866           {
2867           if (eptr <= md->end_subject - length &&
2868             memcmp(eptr, charptr, length) == 0) eptr += length;
2869 #ifdef SUPPORT_UCP
2870           else if (oclength > 0 &&
2871                    eptr <= md->end_subject - oclength &&
2872                    memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
2873 #endif  /* SUPPORT_UCP */
2874           else
2875             {
2876             CHECK_PARTIAL();
2877             MRRETURN(MATCH_NOMATCH);
2878             }
2879           }
2880
2881         if (min == max) continue;
2882
2883         if (minimize)
2884           {
2885           for (fi = min;; fi++)
2886             {
2887             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2888             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2889             if (fi >= max) MRRETURN(MATCH_NOMATCH);
2890             if (eptr <= md->end_subject - length &&
2891               memcmp(eptr, charptr, length) == 0) eptr += length;
2892 #ifdef SUPPORT_UCP
2893             else if (oclength > 0 &&
2894                      eptr <= md->end_subject - oclength &&
2895                      memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
2896 #endif  /* SUPPORT_UCP */
2897             else
2898               {
2899               CHECK_PARTIAL();
2900               MRRETURN(MATCH_NOMATCH);
2901               }
2902             }
2903           /* Control never gets here */
2904           }
2905
2906         else  /* Maximize */
2907           {
2908           pp = eptr;
2909           for (i = min; i < max; i++)
2910             {
2911             if (eptr <= md->end_subject - length &&
2912                 memcmp(eptr, charptr, length) == 0) eptr += length;
2913 #ifdef SUPPORT_UCP
2914             else if (oclength > 0 &&
2915                      eptr <= md->end_subject - oclength &&
2916                      memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
2917 #endif  /* SUPPORT_UCP */
2918             else
2919               {
2920               CHECK_PARTIAL();
2921               break;
2922               }
2923             }
2924
2925           if (possessive) continue;
2926
2927           for(;;)
2928             {
2929             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2930             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2931             if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2932 #ifdef SUPPORT_UCP
2933             eptr--;
2934             BACKCHAR(eptr);
2935 #else   /* without SUPPORT_UCP */
2936             eptr -= length;
2937 #endif  /* SUPPORT_UCP */
2938             }
2939           }
2940         /* Control never gets here */
2941         }
2942
2943       /* If the length of a UTF-8 character is 1, we fall through here, and
2944       obey the code as for non-UTF-8 characters below, though in this case the
2945       value of fc will always be < 128. */
2946       }
2947     else
2948 #endif  /* SUPPORT_UTF8 */
2949
2950     /* When not in UTF-8 mode, load a single-byte character. */
2951
2952     fc = *ecode++;
2953
2954     /* The value of fc at this point is always less than 256, though we may or
2955     may not be in UTF-8 mode. The code is duplicated for the caseless and
2956     caseful cases, for speed, since matching characters is likely to be quite
2957     common. First, ensure the minimum number of matches are present. If min =
2958     max, continue at the same level without recursing. Otherwise, if
2959     minimizing, keep trying the rest of the expression and advancing one
2960     matching character if failing, up to the maximum. Alternatively, if
2961     maximizing, find the maximum number of characters and work backwards. */
2962
2963     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
2964       max, eptr));
2965
2966     if ((ims & PCRE_CASELESS) != 0)
2967       {
2968       fc = md->lcc[fc];
2969       for (i = 1; i <= min; i++)
2970         {
2971         if (eptr >= md->end_subject)
2972           {
2973           SCHECK_PARTIAL();
2974           MRRETURN(MATCH_NOMATCH);
2975           }
2976         if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2977         }
2978       if (min == max) continue;
2979       if (minimize)
2980         {
2981         for (fi = min;; fi++)
2982           {
2983           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2984           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2985           if (fi >= max) MRRETURN(MATCH_NOMATCH);
2986           if (eptr >= md->end_subject)
2987             {
2988             SCHECK_PARTIAL();
2989             MRRETURN(MATCH_NOMATCH);
2990             }
2991           if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2992           }
2993         /* Control never gets here */
2994         }
2995       else  /* Maximize */
2996         {
2997         pp = eptr;
2998         for (i = min; i < max; i++)
2999           {
3000           if (eptr >= md->end_subject)
3001             {
3002             SCHECK_PARTIAL();
3003             break;
3004             }
3005           if (fc != md->lcc[*eptr]) break;
3006           eptr++;
3007           }
3008
3009         if (possessive) continue;
3010
3011         while (eptr >= pp)
3012           {
3013           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
3014           eptr--;
3015           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3016           }
3017         MRRETURN(MATCH_NOMATCH);
3018         }
3019       /* Control never gets here */
3020       }
3021
3022     /* Caseful comparisons (includes all multi-byte characters) */
3023
3024     else
3025       {
3026       for (i = 1; i <= min; i++)
3027         {
3028         if (eptr >= md->end_subject)
3029           {
3030           SCHECK_PARTIAL();
3031           MRRETURN(MATCH_NOMATCH);
3032           }
3033         if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3034         }
3035
3036       if (min == max) continue;
3037
3038       if (minimize)
3039         {
3040         for (fi = min;; fi++)
3041           {
3042           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
3043           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3044           if (fi >= max) MRRETURN(MATCH_NOMATCH);
3045           if (eptr >= md->end_subject)
3046             {
3047             SCHECK_PARTIAL();
3048             MRRETURN(MATCH_NOMATCH);
3049             }
3050           if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3051           }
3052         /* Control never gets here */
3053         }
3054       else  /* Maximize */
3055         {
3056         pp = eptr;
3057         for (i = min; i < max; i++)
3058           {
3059           if (eptr >= md->end_subject)
3060             {
3061             SCHECK_PARTIAL();
3062             break;
3063             }
3064           if (fc != *eptr) break;
3065           eptr++;
3066           }
3067         if (possessive) continue;
3068
3069         while (eptr >= pp)
3070           {
3071           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
3072           eptr--;
3073           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3074           }
3075         MRRETURN(MATCH_NOMATCH);
3076         }
3077       }
3078     /* Control never gets here */
3079
3080     /* Match a negated single one-byte character. The character we are
3081     checking can be multibyte. */
3082
3083     case OP_NOT:
3084     if (eptr >= md->end_subject)
3085       {
3086       SCHECK_PARTIAL();
3087       MRRETURN(MATCH_NOMATCH);
3088       }
3089     ecode++;
3090     GETCHARINCTEST(c, eptr);
3091     if ((ims & PCRE_CASELESS) != 0)
3092       {
3093 #ifdef SUPPORT_UTF8
3094       if (c < 256)
3095 #endif
3096       c = md->lcc[c];
3097       if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3098       }
3099     else
3100       {
3101       if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3102       }
3103     break;
3104
3105     /* Match a negated single one-byte character repeatedly. This is almost a
3106     repeat of the code for a repeated single character, but I haven't found a
3107     nice way of commoning these up that doesn't require a test of the
3108     positive/negative option for each character match. Maybe that wouldn't add
3109     very much to the time taken, but character matching *is* what this is all
3110     about... */
3111
3112     case OP_NOTEXACT:
3113     min = max = GET2(ecode, 1);
3114     ecode += 3;
3115     goto REPEATNOTCHAR;
3116
3117     case OP_NOTUPTO:
3118     case OP_NOTMINUPTO:
3119     min = 0;
3120     max = GET2(ecode, 1);
3121     minimize = *ecode == OP_NOTMINUPTO;
3122     ecode += 3;
3123     goto REPEATNOTCHAR;
3124
3125     case OP_NOTPOSSTAR:
3126     possessive = TRUE;
3127     min = 0;
3128     max = INT_MAX;
3129     ecode++;
3130     goto REPEATNOTCHAR;
3131
3132     case OP_NOTPOSPLUS:
3133     possessive = TRUE;
3134     min = 1;
3135     max = INT_MAX;
3136     ecode++;
3137     goto REPEATNOTCHAR;
3138
3139     case OP_NOTPOSQUERY:
3140     possessive = TRUE;
3141     min = 0;
3142     max = 1;
3143     ecode++;
3144     goto REPEATNOTCHAR;
3145
3146     case OP_NOTPOSUPTO:
3147     possessive = TRUE;
3148     min = 0;
3149     max = GET2(ecode, 1);
3150     ecode += 3;
3151     goto REPEATNOTCHAR;
3152
3153     case OP_NOTSTAR:
3154     case OP_NOTMINSTAR:
3155     case OP_NOTPLUS:
3156     case OP_NOTMINPLUS:
3157     case OP_NOTQUERY:
3158     case OP_NOTMINQUERY:
3159     c = *ecode++ - OP_NOTSTAR;
3160     minimize = (c & 1) != 0;
3161     min = rep_min[c];                 /* Pick up values from tables; */
3162     max = rep_max[c];                 /* zero for max => infinity */
3163     if (max == 0) max = INT_MAX;
3164
3165     /* Common code for all repeated single-byte matches. */
3166
3167     REPEATNOTCHAR:
3168     fc = *ecode++;
3169
3170     /* The code is duplicated for the caseless and caseful cases, for speed,
3171     since matching characters is likely to be quite common. First, ensure the
3172     minimum number of matches are present. If min = max, continue at the same
3173     level without recursing. Otherwise, if minimizing, keep trying the rest of
3174     the expression and advancing one matching character if failing, up to the
3175     maximum. Alternatively, if maximizing, find the maximum number of
3176     characters and work backwards. */
3177
3178     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3179       max, eptr));
3180
3181     if ((ims & PCRE_CASELESS) != 0)
3182       {
3183       fc = md->lcc[fc];
3184
3185 #ifdef SUPPORT_UTF8
3186       /* UTF-8 mode */
3187       if (utf8)
3188         {
3189         register unsigned int d;
3190         for (i = 1; i <= min; i++)
3191           {
3192           if (eptr >= md->end_subject)
3193             {
3194             SCHECK_PARTIAL();
3195             MRRETURN(MATCH_NOMATCH);
3196             }
3197           GETCHARINC(d, eptr);
3198           if (d < 256) d = md->lcc[d];
3199           if (fc == d) MRRETURN(MATCH_NOMATCH);
3200           }
3201         }
3202       else
3203 #endif
3204
3205       /* Not UTF-8 mode */
3206         {
3207         for (i = 1; i <= min; i++)
3208           {
3209           if (eptr >= md->end_subject)
3210             {
3211             SCHECK_PARTIAL();
3212             MRRETURN(MATCH_NOMATCH);
3213             }
3214           if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3215           }
3216         }
3217
3218       if (min == max) continue;
3219
3220       if (minimize)
3221         {
3222 #ifdef SUPPORT_UTF8
3223         /* UTF-8 mode */
3224         if (utf8)
3225           {
3226           register unsigned int d;
3227           for (fi = min;; fi++)
3228             {
3229             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3230             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3231             if (fi >= max) MRRETURN(MATCH_NOMATCH);
3232             if (eptr >= md->end_subject)
3233               {
3234               SCHECK_PARTIAL();
3235               MRRETURN(MATCH_NOMATCH);
3236               }
3237             GETCHARINC(d, eptr);
3238             if (d < 256) d = md->lcc[d];
3239             if (fc == d) MRRETURN(MATCH_NOMATCH);
3240             }
3241           }
3242         else
3243 #endif
3244         /* Not UTF-8 mode */
3245           {
3246           for (fi = min;; fi++)
3247             {
3248             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3249             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3250             if (fi >= max) MRRETURN(MATCH_NOMATCH);
3251             if (eptr >= md->end_subject)
3252               {
3253               SCHECK_PARTIAL();
3254               MRRETURN(MATCH_NOMATCH);
3255               }
3256             if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3257             }
3258           }
3259         /* Control never gets here */
3260         }
3261
3262       /* Maximize case */
3263
3264       else
3265         {
3266         pp = eptr;
3267
3268 #ifdef SUPPORT_UTF8
3269         /* UTF-8 mode */
3270         if (utf8)
3271           {
3272           register unsigned int d;
3273           for (i = min; i < max; i++)
3274             {
3275             int len = 1;
3276             if (eptr >= md->end_subject)
3277               {
3278               SCHECK_PARTIAL();
3279               break;
3280               }
3281             GETCHARLEN(d, eptr, len);
3282             if (d < 256) d = md->lcc[d];
3283             if (fc == d) break;
3284             eptr += len;
3285             }
3286         if (possessive) continue;
3287         for(;;)
3288             {
3289             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM30);
3290             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3291             if (eptr-- == pp) break;        /* Stop if tried at original pos */
3292             BACKCHAR(eptr);
3293             }
3294           }
3295         else
3296 #endif
3297         /* Not UTF-8 mode */
3298           {
3299           for (i = min; i < max; i++)
3300             {
3301             if (eptr >= md->end_subject)
3302               {
3303               SCHECK_PARTIAL();
3304               break;
3305               }
3306             if (fc == md->lcc[*eptr]) break;
3307             eptr++;
3308             }
3309           if (possessive) continue;
3310           while (eptr >= pp)
3311             {
3312             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM31);
3313             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3314             eptr--;
3315             }
3316           }
3317
3318         MRRETURN(MATCH_NOMATCH);
3319         }
3320       /* Control never gets here */
3321       }
3322
3323     /* Caseful comparisons */
3324
3325     else
3326       {
3327 #ifdef SUPPORT_UTF8
3328       /* UTF-8 mode */
3329       if (utf8)
3330         {
3331         register unsigned int d;
3332         for (i = 1; i <= min; i++)
3333           {
3334           if (eptr >= md->end_subject)
3335             {
3336             SCHECK_PARTIAL();
3337             MRRETURN(MATCH_NOMATCH);
3338             }
3339           GETCHARINC(d, eptr);
3340           if (fc == d) MRRETURN(MATCH_NOMATCH);
3341           }
3342         }
3343       else
3344 #endif
3345       /* Not UTF-8 mode */
3346         {
3347         for (i = 1; i <= min; i++)
3348           {
3349           if (eptr >= md->end_subject)
3350             {
3351             SCHECK_PARTIAL();
3352             MRRETURN(MATCH_NOMATCH);
3353             }
3354           if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3355           }
3356         }
3357
3358       if (min == max) continue;
3359
3360       if (minimize)
3361         {
3362 #ifdef SUPPORT_UTF8
3363         /* UTF-8 mode */
3364         if (utf8)
3365           {
3366           register unsigned int d;
3367           for (fi = min;; fi++)
3368             {
3369             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3370             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3371             if (fi >= max) MRRETURN(MATCH_NOMATCH);
3372             if (eptr >= md->end_subject)
3373               {
3374               SCHECK_PARTIAL();
3375               MRRETURN(MATCH_NOMATCH);
3376               }
3377             GETCHARINC(d, eptr);
3378             if (fc == d) MRRETURN(MATCH_NOMATCH);
3379             }
3380           }
3381         else
3382 #endif
3383         /* Not UTF-8 mode */
3384           {
3385           for (fi = min;; fi++)
3386             {
3387             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3388             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3389             if (fi >= max) MRRETURN(MATCH_NOMATCH);
3390             if (eptr >= md->end_subject)
3391               {
3392               SCHECK_PARTIAL();
3393               MRRETURN(MATCH_NOMATCH);
3394               }
3395             if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3396             }
3397           }
3398         /* Control never gets here */
3399         }
3400
3401       /* Maximize case */
3402
3403       else
3404         {
3405         pp = eptr;
3406
3407 #ifdef SUPPORT_UTF8
3408         /* UTF-8 mode */
3409         if (utf8)
3410           {
3411           register unsigned int d;
3412           for (i = min; i < max; i++)
3413             {
3414             int len = 1;
3415             if (eptr >= md->end_subject)
3416               {
3417               SCHECK_PARTIAL();
3418               break;
3419               }
3420             GETCHARLEN(d, eptr, len);
3421             if (fc == d) break;
3422             eptr += len;
3423             }
3424           if (possessive) continue;
3425           for(;;)
3426             {
3427             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM34);
3428             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3429             if (eptr-- == pp) break;        /* Stop if tried at original pos */
3430             BACKCHAR(eptr);
3431             }
3432           }
3433         else
3434 #endif
3435         /* Not UTF-8 mode */
3436           {
3437           for (i = min; i < max; i++)
3438             {
3439             if (eptr >= md->end_subject)
3440               {
3441               SCHECK_PARTIAL();
3442               break;
3443               }
3444             if (fc == *eptr) break;
3445             eptr++;
3446             }
3447           if (possessive) continue;
3448           while (eptr >= pp)
3449             {
3450             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM35);
3451             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3452             eptr--;
3453             }
3454           }
3455
3456         MRRETURN(MATCH_NOMATCH);
3457         }
3458       }
3459     /* Control never gets here */
3460
3461     /* Match a single character type repeatedly; several different opcodes
3462     share code. This is very similar to the code for single characters, but we
3463     repeat it in the interests of efficiency. */
3464
3465     case OP_TYPEEXACT:
3466     min = max = GET2(ecode, 1);
3467     minimize = TRUE;
3468     ecode += 3;
3469     goto REPEATTYPE;
3470
3471     case OP_TYPEUPTO:
3472     case OP_TYPEMINUPTO:
3473     min = 0;
3474     max = GET2(ecode, 1);
3475     minimize = *ecode == OP_TYPEMINUPTO;
3476     ecode += 3;
3477     goto REPEATTYPE;
3478
3479     case OP_TYPEPOSSTAR:
3480     possessive = TRUE;
3481     min = 0;
3482     max = INT_MAX;
3483     ecode++;
3484     goto REPEATTYPE;
3485
3486     case OP_TYPEPOSPLUS:
3487     possessive = TRUE;
3488     min = 1;
3489     max = INT_MAX;
3490     ecode++;
3491     goto REPEATTYPE;
3492
3493     case OP_TYPEPOSQUERY:
3494     possessive = TRUE;
3495     min = 0;
3496     max = 1;
3497     ecode++;
3498     goto REPEATTYPE;
3499
3500     case OP_TYPEPOSUPTO:
3501     possessive = TRUE;
3502     min = 0;
3503     max = GET2(ecode, 1);
3504     ecode += 3;
3505     goto REPEATTYPE;
3506
3507     case OP_TYPESTAR:
3508     case OP_TYPEMINSTAR:
3509     case OP_TYPEPLUS:
3510     case OP_TYPEMINPLUS:
3511     case OP_TYPEQUERY:
3512     case OP_TYPEMINQUERY:
3513     c = *ecode++ - OP_TYPESTAR;
3514     minimize = (c & 1) != 0;
3515     min = rep_min[c];                 /* Pick up values from tables; */
3516     max = rep_max[c];                 /* zero for max => infinity */
3517     if (max == 0) max = INT_MAX;
3518
3519     /* Common code for all repeated single character type matches. Note that
3520     in UTF-8 mode, '.' matches a character of any length, but for the other
3521     character types, the valid characters are all one-byte long. */
3522
3523     REPEATTYPE:
3524     ctype = *ecode++;      /* Code for the character type */
3525
3526 #ifdef SUPPORT_UCP
3527     if (ctype == OP_PROP || ctype == OP_NOTPROP)
3528       {
3529       prop_fail_result = ctype == OP_NOTPROP;
3530       prop_type = *ecode++;
3531       prop_value = *ecode++;
3532       }
3533     else prop_type = -1;
3534 #endif
3535
3536     /* First, ensure the minimum number of matches are present. Use inline
3537     code for maximizing the speed, and do the type test once at the start
3538     (i.e. keep it out of the loop). Separate the UTF-8 code completely as that
3539     is tidier. Also separate the UCP code, which can be the same for both UTF-8
3540     and single-bytes. */
3541
3542     if (min > 0)
3543       {
3544 #ifdef SUPPORT_UCP
3545       if (prop_type >= 0)
3546         {
3547         switch(prop_type)
3548           {
3549           case PT_ANY:
3550           if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3551           for (i = 1; i <= min; i++)
3552             {
3553             if (eptr >= md->end_subject)
3554               {
3555               SCHECK_PARTIAL();
3556               MRRETURN(MATCH_NOMATCH);
3557               }
3558             GETCHARINCTEST(c, eptr);
3559             }
3560           break;
3561
3562           case PT_LAMP:
3563           for (i = 1; i <= min; i++)
3564             {
3565             if (eptr >= md->end_subject)
3566               {
3567               SCHECK_PARTIAL();
3568               MRRETURN(MATCH_NOMATCH);
3569               }
3570             GETCHARINCTEST(c, eptr);
3571             prop_chartype = UCD_CHARTYPE(c);
3572             if ((prop_chartype == ucp_Lu ||
3573                  prop_chartype == ucp_Ll ||
3574                  prop_chartype == ucp_Lt) == prop_fail_result)
3575               MRRETURN(MATCH_NOMATCH);
3576             }
3577           break;
3578
3579           case PT_GC:
3580           for (i = 1; i <= min; i++)
3581             {
3582             if (eptr >= md->end_subject)
3583               {
3584               SCHECK_PARTIAL();
3585               MRRETURN(MATCH_NOMATCH);
3586               }
3587             GETCHARINCTEST(c, eptr);
3588             prop_category = UCD_CATEGORY(c);
3589             if ((prop_category == prop_value) == prop_fail_result)
3590               MRRETURN(MATCH_NOMATCH);
3591             }
3592           break;
3593
3594           case PT_PC:
3595           for (i = 1; i <= min; i++)
3596             {
3597             if (eptr >= md->end_subject)
3598               {
3599               SCHECK_PARTIAL();
3600               MRRETURN(MATCH_NOMATCH);
3601               }
3602             GETCHARINCTEST(c, eptr);
3603             prop_chartype = UCD_CHARTYPE(c);
3604             if ((prop_chartype == prop_value) == prop_fail_result)
3605               MRRETURN(MATCH_NOMATCH);
3606             }
3607           break;
3608
3609           case PT_SC:
3610           for (i = 1; i <= min; i++)
3611             {
3612             if (eptr >= md->end_subject)
3613               {
3614               SCHECK_PARTIAL();
3615               MRRETURN(MATCH_NOMATCH);
3616               }
3617             GETCHARINCTEST(c, eptr);
3618             prop_script = UCD_SCRIPT(c);
3619             if ((prop_script == prop_value) == prop_fail_result)
3620               MRRETURN(MATCH_NOMATCH);
3621             }
3622           break;
3623
3624           case PT_ALNUM:
3625           for (i = 1; i <= min; i++)
3626             {
3627             if (eptr >= md->end_subject)
3628               {
3629               SCHECK_PARTIAL();
3630               MRRETURN(MATCH_NOMATCH);
3631               }
3632             GETCHARINCTEST(c, eptr);
3633             prop_category = UCD_CATEGORY(c);
3634             if ((prop_category == ucp_L || prop_category == ucp_N)
3635                    == prop_fail_result)
3636               MRRETURN(MATCH_NOMATCH);
3637             }
3638           break;
3639
3640           case PT_SPACE:    /* Perl space */
3641           for (i = 1; i <= min; i++)
3642             {
3643             if (eptr >= md->end_subject)
3644               {
3645               SCHECK_PARTIAL();
3646               MRRETURN(MATCH_NOMATCH);
3647               }
3648             GETCHARINCTEST(c, eptr);
3649             prop_category = UCD_CATEGORY(c);
3650             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3651                  c == CHAR_FF || c == CHAR_CR)
3652                    == prop_fail_result)
3653               MRRETURN(MATCH_NOMATCH);
3654             }
3655           break;
3656
3657           case PT_PXSPACE:  /* POSIX space */
3658           for (i = 1; i <= min; i++)
3659             {
3660             if (eptr >= md->end_subject)
3661               {
3662               SCHECK_PARTIAL();
3663               MRRETURN(MATCH_NOMATCH);
3664               }
3665             GETCHARINCTEST(c, eptr);
3666             prop_category = UCD_CATEGORY(c);
3667             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3668                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
3669                    == prop_fail_result)
3670               MRRETURN(MATCH_NOMATCH);
3671             }
3672           break;
3673
3674           case PT_WORD:
3675           for (i = 1; i <= min; i++)
3676             {
3677             if (eptr >= md->end_subject)
3678               {
3679               SCHECK_PARTIAL();
3680               MRRETURN(MATCH_NOMATCH);
3681               }
3682             GETCHARINCTEST(c, eptr);
3683             prop_category = UCD_CATEGORY(c);
3684             if ((prop_category == ucp_L || prop_category == ucp_N ||
3685                  c == CHAR_UNDERSCORE)
3686                    == prop_fail_result)
3687               MRRETURN(MATCH_NOMATCH);
3688             }
3689           break;
3690
3691           /* This should not occur */
3692
3693           default:
3694           RRETURN(PCRE_ERROR_INTERNAL);
3695           }
3696         }
3697
3698       /* Match extended Unicode sequences. We will get here only if the
3699       support is in the binary; otherwise a compile-time error occurs. */
3700
3701       else if (ctype == OP_EXTUNI)
3702         {
3703         for (i = 1; i <= min; i++)
3704           {
3705           if (eptr >= md->end_subject)
3706             {
3707             SCHECK_PARTIAL();
3708             MRRETURN(MATCH_NOMATCH);
3709             }
3710           GETCHARINCTEST(c, eptr);
3711           prop_category = UCD_CATEGORY(c);
3712           if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3713           while (eptr < md->end_subject)
3714             {
3715             int len = 1;
3716             if (!utf8) c = *eptr;
3717               else { GETCHARLEN(c, eptr, len); }
3718             prop_category = UCD_CATEGORY(c);
3719             if (prop_category != ucp_M) break;
3720             eptr += len;
3721             }
3722           }
3723         }
3724
3725       else
3726 #endif     /* SUPPORT_UCP */
3727
3728 /* Handle all other cases when the coding is UTF-8 */
3729
3730 #ifdef SUPPORT_UTF8
3731       if (utf8) switch(ctype)
3732         {
3733         case OP_ANY:
3734         for (i = 1; i <= min; i++)
3735           {
3736           if (eptr >= md->end_subject)
3737             {
3738             SCHECK_PARTIAL();
3739             MRRETURN(MATCH_NOMATCH);
3740             }
3741           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3742           eptr++;
3743           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3744           }
3745         break;
3746
3747         case OP_ALLANY:
3748         for (i = 1; i <= min; i++)
3749           {
3750           if (eptr >= md->end_subject)
3751             {
3752             SCHECK_PARTIAL();
3753             MRRETURN(MATCH_NOMATCH);
3754             }
3755           eptr++;
3756           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3757           }
3758         break;
3759
3760         case OP_ANYBYTE:
3761         if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3762         eptr += min;
3763         break;
3764
3765         case OP_ANYNL:
3766         for (i = 1; i <= min; i++)
3767           {
3768           if (eptr >= md->end_subject)
3769             {
3770             SCHECK_PARTIAL();
3771             MRRETURN(MATCH_NOMATCH);
3772             }
3773           GETCHARINC(c, eptr);
3774           switch(c)
3775             {
3776             default: MRRETURN(MATCH_NOMATCH);
3777             case 0x000d:
3778             if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3779             break;
3780
3781             case 0x000a:
3782             break;
3783
3784             case 0x000b:
3785             case 0x000c:
3786             case 0x0085:
3787             case 0x2028:
3788             case 0x2029:
3789             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3790             break;
3791             }
3792           }
3793         break;
3794
3795         case OP_NOT_HSPACE:
3796         for (i = 1; i <= min; i++)
3797           {
3798           if (eptr >= md->end_subject)
3799             {
3800             SCHECK_PARTIAL();
3801             MRRETURN(MATCH_NOMATCH);
3802             }
3803           GETCHARINC(c, eptr);
3804           switch(c)
3805             {
3806             default: break;
3807             case 0x09:      /* HT */
3808             case 0x20:      /* SPACE */
3809             case 0xa0:      /* NBSP */
3810             case 0x1680:    /* OGHAM SPACE MARK */
3811             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3812             case 0x2000:    /* EN QUAD */
3813             case 0x2001:    /* EM QUAD */
3814             case 0x2002:    /* EN SPACE */
3815             case 0x2003:    /* EM SPACE */
3816             case 0x2004:    /* THREE-PER-EM SPACE */
3817             case 0x2005:    /* FOUR-PER-EM SPACE */
3818             case 0x2006:    /* SIX-PER-EM SPACE */
3819             case 0x2007:    /* FIGURE SPACE */
3820             case 0x2008:    /* PUNCTUATION SPACE */
3821             case 0x2009:    /* THIN SPACE */
3822             case 0x200A:    /* HAIR SPACE */
3823             case 0x202f:    /* NARROW NO-BREAK SPACE */
3824             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3825             case 0x3000:    /* IDEOGRAPHIC SPACE */
3826             MRRETURN(MATCH_NOMATCH);
3827             }
3828           }
3829         break;
3830
3831         case OP_HSPACE:
3832         for (i = 1; i <= min; i++)
3833           {
3834           if (eptr >= md->end_subject)
3835             {
3836             SCHECK_PARTIAL();
3837             MRRETURN(MATCH_NOMATCH);
3838             }
3839           GETCHARINC(c, eptr);
3840           switch(c)
3841             {
3842             default: MRRETURN(MATCH_NOMATCH);
3843             case 0x09:      /* HT */
3844             case 0x20:      /* SPACE */
3845             case 0xa0:      /* NBSP */
3846             case 0x1680:    /* OGHAM SPACE MARK */
3847             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3848             case 0x2000:    /* EN QUAD */
3849             case 0x2001:    /* EM QUAD */
3850             case 0x2002:    /* EN SPACE */
3851             case 0x2003:    /* EM SPACE */
3852             case 0x2004:    /* THREE-PER-EM SPACE */
3853             case 0x2005:    /* FOUR-PER-EM SPACE */
3854             case 0x2006:    /* SIX-PER-EM SPACE */
3855             case 0x2007:    /* FIGURE SPACE */
3856             case 0x2008:    /* PUNCTUATION SPACE */
3857             case 0x2009:    /* THIN SPACE */
3858             case 0x200A:    /* HAIR SPACE */
3859             case 0x202f:    /* NARROW NO-BREAK SPACE */
3860             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3861             case 0x3000:    /* IDEOGRAPHIC SPACE */
3862             break;
3863             }
3864           }
3865         break;
3866
3867         case OP_NOT_VSPACE:
3868         for (i = 1; i <= min; i++)
3869           {
3870           if (eptr >= md->end_subject)
3871             {
3872             SCHECK_PARTIAL();
3873             MRRETURN(MATCH_NOMATCH);
3874             }
3875           GETCHARINC(c, eptr);
3876           switch(c)
3877             {
3878             default: break;
3879             case 0x0a:      /* LF */
3880             case 0x0b:      /* VT */
3881             case 0x0c:      /* FF */
3882             case 0x0d:      /* CR */
3883             case 0x85:      /* NEL */
3884             case 0x2028:    /* LINE SEPARATOR */
3885             case 0x2029:    /* PARAGRAPH SEPARATOR */
3886             MRRETURN(MATCH_NOMATCH);
3887             }
3888           }
3889         break;
3890
3891         case OP_VSPACE:
3892         for (i = 1; i <= min; i++)
3893           {
3894           if (eptr >= md->end_subject)
3895             {
3896             SCHECK_PARTIAL();
3897             MRRETURN(MATCH_NOMATCH);
3898             }
3899           GETCHARINC(c, eptr);
3900           switch(c)
3901             {
3902             default: MRRETURN(MATCH_NOMATCH);
3903             case 0x0a:      /* LF */
3904             case 0x0b:      /* VT */
3905             case 0x0c:      /* FF */
3906             case 0x0d:      /* CR */
3907             case 0x85:      /* NEL */
3908             case 0x2028:    /* LINE SEPARATOR */
3909             case 0x2029:    /* PARAGRAPH SEPARATOR */
3910             break;
3911             }
3912           }
3913         break;
3914
3915         case OP_NOT_DIGIT:
3916         for (i = 1; i <= min; i++)
3917           {
3918           if (eptr >= md->end_subject)
3919             {
3920             SCHECK_PARTIAL();
3921             MRRETURN(MATCH_NOMATCH);
3922             }
3923           GETCHARINC(c, eptr);
3924           if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3925             MRRETURN(MATCH_NOMATCH);
3926           }
3927         break;
3928
3929         case OP_DIGIT:
3930         for (i = 1; i <= min; i++)
3931           {
3932           if (eptr >= md->end_subject)
3933             {
3934             SCHECK_PARTIAL();
3935             MRRETURN(MATCH_NOMATCH);
3936             }
3937           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3938             MRRETURN(MATCH_NOMATCH);
3939           /* No need to skip more bytes - we know it's a 1-byte character */
3940           }
3941         break;
3942
3943         case OP_NOT_WHITESPACE:
3944         for (i = 1; i <= min; i++)
3945           {
3946           if (eptr >= md->end_subject)
3947             {
3948             SCHECK_PARTIAL();
3949             MRRETURN(MATCH_NOMATCH);
3950             }
3951           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3952             MRRETURN(MATCH_NOMATCH);
3953           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3954           }
3955         break;
3956
3957         case OP_WHITESPACE:
3958         for (i = 1; i <= min; i++)
3959           {
3960           if (eptr >= md->end_subject)
3961             {
3962             SCHECK_PARTIAL();
3963             MRRETURN(MATCH_NOMATCH);
3964             }
3965           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3966             MRRETURN(MATCH_NOMATCH);
3967           /* No need to skip more bytes - we know it's a 1-byte character */
3968           }
3969         break;
3970
3971         case OP_NOT_WORDCHAR:
3972         for (i = 1; i <= min; i++)
3973           {
3974           if (eptr >= md->end_subject)
3975             {
3976             SCHECK_PARTIAL();
3977             MRRETURN(MATCH_NOMATCH);
3978             }
3979           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3980             MRRETURN(MATCH_NOMATCH);
3981           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3982           }
3983         break;
3984
3985         case OP_WORDCHAR:
3986         for (i = 1; i <= min; i++)
3987           {
3988           if (eptr >= md->end_subject)
3989             {
3990             SCHECK_PARTIAL();
3991             MRRETURN(MATCH_NOMATCH);
3992             }
3993           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3994             MRRETURN(MATCH_NOMATCH);
3995           /* No need to skip more bytes - we know it's a 1-byte character */
3996           }
3997         break;
3998
3999         default:
4000         RRETURN(PCRE_ERROR_INTERNAL);
4001         }  /* End switch(ctype) */
4002
4003       else
4004 #endif     /* SUPPORT_UTF8 */
4005
4006       /* Code for the non-UTF-8 case for minimum matching of operators other
4007       than OP_PROP and OP_NOTPROP. */
4008
4009       switch(ctype)
4010         {
4011         case OP_ANY:
4012         for (i = 1; i <= min; i++)
4013           {
4014           if (eptr >= md->end_subject)
4015             {
4016             SCHECK_PARTIAL();
4017             MRRETURN(MATCH_NOMATCH);
4018             }
4019           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
4020           eptr++;
4021           }
4022         break;
4023
4024         case OP_ALLANY:
4025         if (eptr > md->end_subject - min)
4026           {
4027           SCHECK_PARTIAL();
4028           MRRETURN(MATCH_NOMATCH);
4029           }
4030         eptr += min;
4031         break;
4032
4033         case OP_ANYBYTE:
4034         if (eptr > md->end_subject - min)
4035           {
4036           SCHECK_PARTIAL();
4037           MRRETURN(MATCH_NOMATCH);
4038           }
4039         eptr += min;
4040         break;
4041
4042         case OP_ANYNL:
4043         for (i = 1; i <= min; i++)
4044           {
4045           if (eptr >= md->end_subject)
4046             {
4047             SCHECK_PARTIAL();
4048             MRRETURN(MATCH_NOMATCH);
4049             }
4050           switch(*eptr++)
4051             {
4052             default: MRRETURN(MATCH_NOMATCH);
4053             case 0x000d:
4054             if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4055             break;
4056             case 0x000a:
4057             break;
4058
4059             case 0x000b:
4060             case 0x000c:
4061             case 0x0085:
4062             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4063             break;
4064             }
4065           }
4066         break;
4067
4068         case OP_NOT_HSPACE:
4069         for (i = 1; i <= min; i++)
4070           {
4071           if (eptr >= md->end_subject)
4072             {
4073             SCHECK_PARTIAL();
4074             MRRETURN(MATCH_NOMATCH);
4075             }
4076           switch(*eptr++)
4077             {
4078             default: break;
4079             case 0x09:      /* HT */
4080             case 0x20:      /* SPACE */
4081             case 0xa0:      /* NBSP */
4082             MRRETURN(MATCH_NOMATCH);
4083             }
4084           }
4085         break;
4086
4087         case OP_HSPACE:
4088         for (i = 1; i <= min; i++)
4089           {
4090           if (eptr >= md->end_subject)
4091             {
4092             SCHECK_PARTIAL();
4093             MRRETURN(MATCH_NOMATCH);
4094             }
4095           switch(*eptr++)
4096             {
4097             default: MRRETURN(MATCH_NOMATCH);
4098             case 0x09:      /* HT */
4099             case 0x20:      /* SPACE */
4100             case 0xa0:      /* NBSP */
4101             break;
4102             }
4103           }
4104         break;
4105
4106         case OP_NOT_VSPACE:
4107         for (i = 1; i <= min; i++)
4108           {
4109           if (eptr >= md->end_subject)
4110             {
4111             SCHECK_PARTIAL();
4112             MRRETURN(MATCH_NOMATCH);
4113             }
4114           switch(*eptr++)
4115             {
4116             default: break;
4117             case 0x0a:      /* LF */
4118             case 0x0b:      /* VT */
4119             case 0x0c:      /* FF */
4120             case 0x0d:      /* CR */
4121             case 0x85:      /* NEL */
4122             MRRETURN(MATCH_NOMATCH);
4123             }
4124           }
4125         break;
4126
4127         case OP_VSPACE:
4128         for (i = 1; i <= min; i++)
4129           {
4130           if (eptr >= md->end_subject)
4131             {
4132             SCHECK_PARTIAL();
4133             MRRETURN(MATCH_NOMATCH);
4134             }
4135           switch(*eptr++)
4136             {
4137             default: MRRETURN(MATCH_NOMATCH);
4138             case 0x0a:      /* LF */
4139             case 0x0b:      /* VT */
4140             case 0x0c:      /* FF */
4141             case 0x0d:      /* CR */
4142             case 0x85:      /* NEL */
4143             break;
4144             }
4145           }
4146         break;
4147
4148         case OP_NOT_DIGIT:
4149         for (i = 1; i <= min; i++)
4150           {
4151           if (eptr >= md->end_subject)
4152             {
4153             SCHECK_PARTIAL();
4154             MRRETURN(MATCH_NOMATCH);
4155             }
4156           if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4157           }
4158         break;
4159
4160         case OP_DIGIT:
4161         for (i = 1; i <= min; i++)
4162           {
4163           if (eptr >= md->end_subject)
4164             {
4165             SCHECK_PARTIAL();
4166             MRRETURN(MATCH_NOMATCH);
4167             }
4168           if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4169           }
4170         break;
4171
4172         case OP_NOT_WHITESPACE:
4173         for (i = 1; i <= min; i++)
4174           {
4175           if (eptr >= md->end_subject)
4176             {
4177             SCHECK_PARTIAL();
4178             MRRETURN(MATCH_NOMATCH);
4179             }
4180           if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4181           }
4182         break;
4183
4184         case OP_WHITESPACE:
4185         for (i = 1; i <= min; i++)
4186           {
4187           if (eptr >= md->end_subject)
4188             {
4189             SCHECK_PARTIAL();
4190             MRRETURN(MATCH_NOMATCH);
4191             }
4192           if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4193           }
4194         break;
4195
4196         case OP_NOT_WORDCHAR:
4197         for (i = 1; i <= min; i++)
4198           {
4199           if (eptr >= md->end_subject)
4200             {
4201             SCHECK_PARTIAL();
4202             MRRETURN(MATCH_NOMATCH);
4203             }
4204           if ((md->ctypes[*eptr++] & ctype_word) != 0)
4205             MRRETURN(MATCH_NOMATCH);
4206           }
4207         break;
4208
4209         case OP_WORDCHAR:
4210         for (i = 1; i <= min; i++)
4211           {
4212           if (eptr >= md->end_subject)
4213             {
4214             SCHECK_PARTIAL();
4215             MRRETURN(MATCH_NOMATCH);
4216             }
4217           if ((md->ctypes[*eptr++] & ctype_word) == 0)
4218             MRRETURN(MATCH_NOMATCH);
4219           }
4220         break;
4221
4222         default:
4223         RRETURN(PCRE_ERROR_INTERNAL);
4224         }
4225       }
4226
4227     /* If min = max, continue at the same level without recursing */
4228
4229     if (min == max) continue;
4230
4231     /* If minimizing, we have to test the rest of the pattern before each
4232     subsequent match. Again, separate the UTF-8 case for speed, and also
4233     separate the UCP cases. */
4234
4235     if (minimize)
4236       {
4237 #ifdef SUPPORT_UCP
4238       if (prop_type >= 0)
4239         {
4240         switch(prop_type)
4241           {
4242           case PT_ANY:
4243           for (fi = min;; fi++)
4244             {
4245             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4246             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4247             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4248             if (eptr >= md->end_subject)
4249               {
4250               SCHECK_PARTIAL();
4251               MRRETURN(MATCH_NOMATCH);
4252               }
4253             GETCHARINCTEST(c, eptr);
4254             if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4255             }
4256           /* Control never gets here */
4257
4258           case PT_LAMP:
4259           for (fi = min;; fi++)
4260             {
4261             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4262             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4263             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4264             if (eptr >= md->end_subject)
4265               {
4266               SCHECK_PARTIAL();
4267               MRRETURN(MATCH_NOMATCH);
4268               }
4269             GETCHARINCTEST(c, eptr);
4270             prop_chartype = UCD_CHARTYPE(c);
4271             if ((prop_chartype == ucp_Lu ||
4272                  prop_chartype == ucp_Ll ||
4273                  prop_chartype == ucp_Lt) == prop_fail_result)
4274               MRRETURN(MATCH_NOMATCH);
4275             }
4276           /* Control never gets here */
4277
4278           case PT_GC:
4279           for (fi = min;; fi++)
4280             {
4281             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4282             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4283             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4284             if (eptr >= md->end_subject)
4285               {
4286               SCHECK_PARTIAL();
4287               MRRETURN(MATCH_NOMATCH);
4288               }
4289             GETCHARINCTEST(c, eptr);
4290             prop_category = UCD_CATEGORY(c);
4291             if ((prop_category == prop_value) == prop_fail_result)
4292               MRRETURN(MATCH_NOMATCH);
4293             }
4294           /* Control never gets here */
4295
4296           case PT_PC:
4297           for (fi = min;; fi++)
4298             {
4299             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4300             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4301             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4302             if (eptr >= md->end_subject)
4303               {
4304               SCHECK_PARTIAL();
4305               MRRETURN(MATCH_NOMATCH);
4306               }
4307             GETCHARINCTEST(c, eptr);
4308             prop_chartype = UCD_CHARTYPE(c);
4309             if ((prop_chartype == prop_value) == prop_fail_result)
4310               MRRETURN(MATCH_NOMATCH);
4311             }
4312           /* Control never gets here */
4313
4314           case PT_SC:
4315           for (fi = min;; fi++)
4316             {
4317             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4318             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4319             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4320             if (eptr >= md->end_subject)
4321               {
4322               SCHECK_PARTIAL();
4323               MRRETURN(MATCH_NOMATCH);
4324               }
4325             GETCHARINCTEST(c, eptr);
4326             prop_script = UCD_SCRIPT(c);
4327             if ((prop_script == prop_value) == prop_fail_result)
4328               MRRETURN(MATCH_NOMATCH);
4329             }
4330           /* Control never gets here */
4331
4332           case PT_ALNUM:
4333           for (fi = min;; fi++)
4334             {
4335             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM59);
4336             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4337             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4338             if (eptr >= md->end_subject)
4339               {
4340               SCHECK_PARTIAL();
4341               MRRETURN(MATCH_NOMATCH);
4342               }
4343             GETCHARINCTEST(c, eptr);
4344             prop_category = UCD_CATEGORY(c);
4345             if ((prop_category == ucp_L || prop_category == ucp_N)
4346                    == prop_fail_result)
4347               MRRETURN(MATCH_NOMATCH);
4348             }
4349           /* Control never gets here */
4350
4351           case PT_SPACE:    /* Perl space */
4352           for (fi = min;; fi++)
4353             {
4354             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM60);
4355             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4356             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4357             if (eptr >= md->end_subject)
4358               {
4359               SCHECK_PARTIAL();
4360               MRRETURN(MATCH_NOMATCH);
4361               }
4362             GETCHARINCTEST(c, eptr);
4363             prop_category = UCD_CATEGORY(c);
4364             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4365                  c == CHAR_FF || c == CHAR_CR)
4366                    == prop_fail_result)
4367               MRRETURN(MATCH_NOMATCH);
4368             }
4369           /* Control never gets here */
4370
4371           case PT_PXSPACE:  /* POSIX space */
4372           for (fi = min;; fi++)
4373             {
4374             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM61);
4375             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4376             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4377             if (eptr >= md->end_subject)
4378               {
4379               SCHECK_PARTIAL();
4380               MRRETURN(MATCH_NOMATCH);
4381               }
4382             GETCHARINCTEST(c, eptr);
4383             prop_category = UCD_CATEGORY(c);
4384             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4385                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4386                    == prop_fail_result)
4387               MRRETURN(MATCH_NOMATCH);
4388             }
4389           /* Control never gets here */
4390
4391           case PT_WORD:
4392           for (fi = min;; fi++)
4393             {
4394             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM62);
4395             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4396             if (fi >= max) MRRETURN(MATCH_NOMATCH);
4397             if (eptr >= md->end_subject)
4398               {
4399               SCHECK_PARTIAL();
4400               MRRETURN(MATCH_NOMATCH);
4401               }
4402             GETCHARINCTEST(c, eptr);
4403             prop_category = UCD_CATEGORY(c);
4404             if ((prop_category == ucp_L ||
4405                  prop_category == ucp_N ||
4406                  c == CHAR_UNDERSCORE)
4407                    == prop_fail_result)
4408               MRRETURN(MATCH_NOMATCH);
4409             }
4410           /* Control never gets here */
4411
4412           /* This should never occur */
4413
4414           default:
4415           RRETURN(PCRE_ERROR_INTERNAL);
4416           }
4417         }
4418
4419       /* Match extended Unicode sequences. We will get here only if the
4420       support is in the binary; otherwise a compile-time error occurs. */
4421
4422       else if (ctype == OP_EXTUNI)
4423         {
4424         for (fi = min;; fi++)
4425           {
4426           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4427           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4428           if (fi >= max) MRRETURN(MATCH_NOMATCH);
4429           if (eptr >= md->end_subject)
4430             {
4431             SCHECK_PARTIAL();
4432             MRRETURN(MATCH_NOMATCH);
4433             }
4434           GETCHARINCTEST(c, eptr);
4435           prop_category = UCD_CATEGORY(c);
4436           if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4437           while (eptr < md->end_subject)
4438             {
4439             int len = 1;
4440             if (!utf8) c = *eptr;
4441               else { GETCHARLEN(c, eptr, len); }
4442             prop_category = UCD_CATEGORY(c);
4443             if (prop_category != ucp_M) break;
4444             eptr += len;
4445             }
4446           }
4447         }
4448
4449       else
4450 #endif     /* SUPPORT_UCP */
4451
4452 #ifdef SUPPORT_UTF8
4453       /* UTF-8 mode */
4454       if (utf8)
4455         {
4456         for (fi = min;; fi++)
4457           {
4458           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4459           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4460           if (fi >= max) MRRETURN(MATCH_NOMATCH);
4461           if (eptr >= md->end_subject)
4462             {
4463             SCHECK_PARTIAL();
4464             MRRETURN(MATCH_NOMATCH);
4465             }
4466           if (ctype == OP_ANY && IS_NEWLINE(eptr))
4467             MRRETURN(MATCH_NOMATCH);
4468           GETCHARINC(c, eptr);
4469           switch(ctype)
4470             {
4471             case OP_ANY:        /* This is the non-NL case */
4472             case OP_ALLANY:
4473             case OP_ANYBYTE:
4474             break;
4475
4476             case OP_ANYNL:
4477             switch(c)
4478               {
4479               default: MRRETURN(MATCH_NOMATCH);
4480               case 0x000d:
4481               if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4482               break;
4483               case 0x000a:
4484               break;
4485
4486               case 0x000b:
4487               case 0x000c:
4488               case 0x0085:
4489               case 0x2028:
4490               case 0x2029:
4491               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4492               break;
4493               }
4494             break;
4495
4496             case OP_NOT_HSPACE:
4497             switch(c)
4498               {
4499               default: break;
4500               case 0x09:      /* HT */
4501               case 0x20:      /* SPACE */
4502               case 0xa0:      /* NBSP */
4503               case 0x1680:    /* OGHAM SPACE MARK */
4504               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
4505               case 0x2000:    /* EN QUAD */
4506               case 0x2001:    /* EM QUAD */
4507               case 0x2002:    /* EN SPACE */
4508               case 0x2003:    /* EM SPACE */
4509               case 0x2004:    /* THREE-PER-EM SPACE */
4510               case 0x2005:    /* FOUR-PER-EM SPACE */
4511               case 0x2006:    /* SIX-PER-EM SPACE */
4512               case 0x2007:    /* FIGURE SPACE */
4513               case 0x2008:    /* PUNCTUATION SPACE */
4514               case 0x2009:    /* THIN SPACE */
4515               case 0x200A:    /* HAIR SPACE */
4516               case 0x202f:    /* NARROW NO-BREAK SPACE */
4517               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4518               case 0x3000:    /* IDEOGRAPHIC SPACE */
4519               MRRETURN(MATCH_NOMATCH);
4520               }
4521             break;
4522
4523             case OP_HSPACE:
4524             switch(c)
4525               {
4526               default: MRRETURN(MATCH_NOMATCH);
4527               case 0x09:      /* HT */
4528               case 0x20:      /* SPACE */
4529               case 0xa0:      /* NBSP */
4530               case 0x1680:    /* OGHAM SPACE MARK */
4531               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
4532               case 0x2000:    /* EN QUAD */
4533               case 0x2001:    /* EM QUAD */
4534               case 0x2002:    /* EN SPACE */
4535               case 0x2003:    /* EM SPACE */
4536               case 0x2004:    /* THREE-PER-EM SPACE */
4537               case 0x2005:    /* FOUR-PER-EM SPACE */
4538               case 0x2006:    /* SIX-PER-EM SPACE */
4539               case 0x2007:    /* FIGURE SPACE */
4540               case 0x2008:    /* PUNCTUATION SPACE */
4541               case 0x2009:    /* THIN SPACE */
4542               case 0x200A:    /* HAIR SPACE */
4543               case 0x202f:    /* NARROW NO-BREAK SPACE */
4544               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4545               case 0x3000:    /* IDEOGRAPHIC SPACE */
4546               break;
4547               }
4548             break;
4549
4550             case OP_NOT_VSPACE:
4551             switch(c)
4552               {
4553               default: break;
4554               case 0x0a:      /* LF */
4555               case 0x0b:      /* VT */
4556               case 0x0c:      /* FF */
4557               case 0x0d:      /* CR */
4558               case 0x85:      /* NEL */
4559               case 0x2028:    /* LINE SEPARATOR */
4560               case 0x2029:    /* PARAGRAPH SEPARATOR */
4561               MRRETURN(MATCH_NOMATCH);
4562               }
4563             break;
4564
4565             case OP_VSPACE:
4566             switch(c)
4567               {
4568               default: MRRETURN(MATCH_NOMATCH);
4569               case 0x0a:      /* LF */
4570               case 0x0b:      /* VT */
4571               case 0x0c:      /* FF */
4572               case 0x0d:      /* CR */
4573               case 0x85:      /* NEL */
4574               case 0x2028:    /* LINE SEPARATOR */
4575               case 0x2029:    /* PARAGRAPH SEPARATOR */
4576               break;
4577               }
4578             break;
4579
4580             case OP_NOT_DIGIT:
4581             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4582               MRRETURN(MATCH_NOMATCH);
4583             break;
4584
4585             case OP_DIGIT:
4586             if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4587               MRRETURN(MATCH_NOMATCH);
4588             break;
4589
4590             case OP_NOT_WHITESPACE:
4591             if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4592               MRRETURN(MATCH_NOMATCH);
4593             break;
4594
4595             case OP_WHITESPACE:
4596             if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4597               MRRETURN(MATCH_NOMATCH);
4598             break;
4599
4600             case OP_NOT_WORDCHAR:
4601             if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4602               MRRETURN(MATCH_NOMATCH);
4603             break;
4604
4605             case OP_WORDCHAR:
4606             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4607               MRRETURN(MATCH_NOMATCH);
4608             break;
4609
4610             default:
4611             RRETURN(PCRE_ERROR_INTERNAL);
4612             }
4613           }
4614         }
4615       else
4616 #endif
4617       /* Not UTF-8 mode */
4618         {
4619         for (fi = min;; fi++)
4620           {
4621           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4622           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4623           if (fi >= max) MRRETURN(MATCH_NOMATCH);
4624           if (eptr >= md->end_subject)
4625             {
4626             SCHECK_PARTIAL();
4627             MRRETURN(MATCH_NOMATCH);
4628             }
4629           if (ctype == OP_ANY && IS_NEWLINE(eptr))
4630             MRRETURN(MATCH_NOMATCH);
4631           c = *eptr++;
4632           switch(ctype)
4633             {
4634             case OP_ANY:     /* This is the non-NL case */
4635             case OP_ALLANY:
4636             case OP_ANYBYTE:
4637             break;
4638
4639             case OP_ANYNL:
4640             switch(c)
4641               {
4642               default: MRRETURN(MATCH_NOMATCH);
4643               case 0x000d:
4644               if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4645               break;
4646
4647               case 0x000a:
4648               break;
4649
4650               case 0x000b:
4651               case 0x000c:
4652               case 0x0085:
4653               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4654               break;
4655               }
4656             break;
4657
4658             case OP_NOT_HSPACE:
4659             switch(c)
4660               {
4661               default: break;
4662               case 0x09:      /* HT */
4663               case 0x20:      /* SPACE */
4664               case 0xa0:      /* NBSP */
4665               MRRETURN(MATCH_NOMATCH);
4666               }
4667             break;
4668
4669             case OP_HSPACE:
4670             switch(c)
4671               {
4672               default: MRRETURN(MATCH_NOMATCH);
4673               case 0x09:      /* HT */
4674               case 0x20:      /* SPACE */
4675               case 0xa0:      /* NBSP */
4676               break;
4677               }
4678             break;
4679
4680             case OP_NOT_VSPACE:
4681             switch(c)
4682               {
4683               default: break;
4684               case 0x0a:      /* LF */
4685               case 0x0b:      /* VT */
4686               case 0x0c:      /* FF */
4687               case 0x0d:      /* CR */
4688               case 0x85:      /* NEL */
4689               MRRETURN(MATCH_NOMATCH);
4690               }
4691             break;
4692
4693             case OP_VSPACE:
4694             switch(c)
4695               {
4696               default: MRRETURN(MATCH_NOMATCH);
4697               case 0x0a:      /* LF */
4698               case 0x0b:      /* VT */
4699               case 0x0c:      /* FF */
4700               case 0x0d:      /* CR */
4701               case 0x85:      /* NEL */
4702               break;
4703               }
4704             break;
4705
4706             case OP_NOT_DIGIT:
4707             if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4708             break;
4709
4710             case OP_DIGIT:
4711             if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4712             break;
4713
4714             case OP_NOT_WHITESPACE:
4715             if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4716             break;
4717
4718             case OP_WHITESPACE:
4719             if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4720             break;
4721
4722             case OP_NOT_WORDCHAR:
4723             if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4724             break;
4725
4726             case OP_WORDCHAR:
4727             if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4728             break;
4729
4730             default:
4731             RRETURN(PCRE_ERROR_INTERNAL);
4732             }
4733           }
4734         }
4735       /* Control never gets here */
4736       }
4737
4738     /* If maximizing, it is worth using inline code for speed, doing the type
4739     test once at the start (i.e. keep it out of the loop). Again, keep the
4740     UTF-8 and UCP stuff separate. */
4741
4742     else
4743       {
4744       pp = eptr;  /* Remember where we started */
4745
4746 #ifdef SUPPORT_UCP
4747       if (prop_type >= 0)
4748         {
4749         switch(prop_type)
4750           {
4751           case PT_ANY:
4752           for (i = min; i < max; i++)
4753             {
4754             int len = 1;
4755             if (eptr >= md->end_subject)
4756               {
4757               SCHECK_PARTIAL();
4758               break;
4759               }
4760             GETCHARLENTEST(c, eptr, len);
4761             if (prop_fail_result) break;
4762             eptr+= len;
4763             }
4764           break;
4765
4766           case PT_LAMP:
4767           for (i = min; i < max; i++)
4768             {
4769             int len = 1;
4770             if (eptr >= md->end_subject)
4771               {
4772               SCHECK_PARTIAL();
4773               break;
4774               }
4775             GETCHARLENTEST(c, eptr, len);
4776             prop_chartype = UCD_CHARTYPE(c);
4777             if ((prop_chartype == ucp_Lu ||
4778                  prop_chartype == ucp_Ll ||
4779                  prop_chartype == ucp_Lt) == prop_fail_result)
4780               break;
4781             eptr+= len;
4782             }
4783           break;
4784
4785           case PT_GC:
4786           for (i = min; i < max; i++)
4787             {
4788             int len = 1;
4789             if (eptr >= md->end_subject)
4790               {
4791               SCHECK_PARTIAL();
4792               break;
4793               }
4794             GETCHARLENTEST(c, eptr, len);
4795             prop_category = UCD_CATEGORY(c);
4796             if ((prop_category == prop_value) == prop_fail_result)
4797               break;
4798             eptr+= len;
4799             }
4800           break;
4801
4802           case PT_PC:
4803           for (i = min; i < max; i++)
4804             {
4805             int len = 1;
4806             if (eptr >= md->end_subject)
4807               {
4808               SCHECK_PARTIAL();
4809               break;
4810               }
4811             GETCHARLENTEST(c, eptr, len);
4812             prop_chartype = UCD_CHARTYPE(c);
4813             if ((prop_chartype == prop_value) == prop_fail_result)
4814               break;
4815             eptr+= len;
4816             }
4817           break;
4818
4819           case PT_SC:
4820           for (i = min; i < max; i++)
4821             {
4822             int len = 1;
4823             if (eptr >= md->end_subject)
4824               {
4825               SCHECK_PARTIAL();
4826               break;
4827               }
4828             GETCHARLENTEST(c, eptr, len);
4829             prop_script = UCD_SCRIPT(c);
4830             if ((prop_script == prop_value) == prop_fail_result)
4831               break;
4832             eptr+= len;
4833             }
4834           break;
4835
4836           case PT_ALNUM:
4837           for (i = min; i < max; i++)
4838             {
4839             int len = 1;
4840             if (eptr >= md->end_subject)
4841               {
4842               SCHECK_PARTIAL();
4843               break;
4844               }
4845             GETCHARLENTEST(c, eptr, len);
4846             prop_category = UCD_CATEGORY(c);
4847             if ((prop_category == ucp_L || prop_category == ucp_N)
4848                  == prop_fail_result)
4849               break;
4850             eptr+= len;
4851             }
4852           break;
4853
4854           case PT_SPACE:    /* Perl space */
4855           for (i = min; i < max; i++)
4856             {
4857             int len = 1;
4858             if (eptr >= md->end_subject)
4859               {
4860               SCHECK_PARTIAL();
4861               break;
4862               }
4863             GETCHARLENTEST(c, eptr, len);
4864             prop_category = UCD_CATEGORY(c);
4865             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4866                  c == CHAR_FF || c == CHAR_CR)
4867                  == prop_fail_result)
4868               break;
4869             eptr+= len;
4870             }
4871           break;
4872
4873           case PT_PXSPACE:  /* POSIX space */
4874           for (i = min; i < max; i++)
4875             {
4876             int len = 1;
4877             if (eptr >= md->end_subject)
4878               {
4879               SCHECK_PARTIAL();
4880               break;
4881               }
4882             GETCHARLENTEST(c, eptr, len);
4883             prop_category = UCD_CATEGORY(c);
4884             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4885                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4886                  == prop_fail_result)
4887               break;
4888             eptr+= len;
4889             }
4890           break;
4891
4892           case PT_WORD:
4893           for (i = min; i < max; i++)
4894             {
4895             int len = 1;
4896             if (eptr >= md->end_subject)
4897               {
4898               SCHECK_PARTIAL();
4899               break;
4900               }
4901             GETCHARLENTEST(c, eptr, len);
4902             prop_category = UCD_CATEGORY(c);
4903             if ((prop_category == ucp_L || prop_category == ucp_N ||
4904                  c == CHAR_UNDERSCORE) == prop_fail_result)
4905               break;
4906             eptr+= len;
4907             }
4908           break;
4909
4910           default:
4911           RRETURN(PCRE_ERROR_INTERNAL);
4912           }
4913
4914         /* eptr is now past the end of the maximum run */
4915
4916         if (possessive) continue;
4917         for(;;)
4918           {
4919           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
4920           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4921           if (eptr-- == pp) break;        /* Stop if tried at original pos */
4922           if (utf8) BACKCHAR(eptr);
4923           }
4924         }
4925
4926       /* Match extended Unicode sequences. We will get here only if the
4927       support is in the binary; otherwise a compile-time error occurs. */
4928
4929       else if (ctype == OP_EXTUNI)
4930         {
4931         for (i = min; i < max; i++)
4932           {
4933           if (eptr >= md->end_subject)
4934             {
4935             SCHECK_PARTIAL();
4936             break;
4937             }
4938           GETCHARINCTEST(c, eptr);
4939           prop_category = UCD_CATEGORY(c);
4940           if (prop_category == ucp_M) break;
4941           while (eptr < md->end_subject)
4942             {
4943             int len = 1;
4944             if (!utf8) c = *eptr; else
4945               {
4946               GETCHARLEN(c, eptr, len);
4947               }
4948             prop_category = UCD_CATEGORY(c);
4949             if (prop_category != ucp_M) break;
4950             eptr += len;
4951             }
4952           }
4953
4954         /* eptr is now past the end of the maximum run */
4955
4956         if (possessive) continue;
4957
4958         for(;;)
4959           {
4960           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
4961           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4962           if (eptr-- == pp) break;        /* Stop if tried at original pos */
4963           for (;;)                        /* Move back over one extended */
4964             {
4965             int len = 1;
4966             if (!utf8) c = *eptr; else
4967               {
4968               BACKCHAR(eptr);
4969               GETCHARLEN(c, eptr, len);
4970               }
4971             prop_category = UCD_CATEGORY(c);
4972             if (prop_category != ucp_M) break;
4973             eptr--;
4974             }
4975           }
4976         }
4977
4978       else
4979 #endif   /* SUPPORT_UCP */
4980
4981 #ifdef SUPPORT_UTF8
4982       /* UTF-8 mode */
4983
4984       if (utf8)
4985         {
4986         switch(ctype)
4987           {
4988           case OP_ANY:
4989           if (max < INT_MAX)
4990             {
4991             for (i = min; i < max; i++)
4992               {
4993               if (eptr >= md->end_subject)
4994                 {
4995                 SCHECK_PARTIAL();
4996                 break;
4997                 }
4998               if (IS_NEWLINE(eptr)) break;
4999               eptr++;
5000               while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
5001               }
5002             }
5003
5004           /* Handle unlimited UTF-8 repeat */
5005
5006           else
5007             {
5008             for (i = min; i < max; i++)
5009               {
5010               if (eptr >= md->end_subject)
5011                 {
5012                 SCHECK_PARTIAL();
5013                 break;
5014                 }
5015               if (IS_NEWLINE(eptr)) break;
5016               eptr++;
5017               while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
5018               }
5019             }
5020           break;
5021
5022           case OP_ALLANY:
5023           if (max < INT_MAX)
5024             {
5025             for (i = min; i < max; i++)
5026               {
5027               if (eptr >= md->end_subject)
5028                 {
5029                 SCHECK_PARTIAL();
5030                 break;
5031                 }
5032               eptr++;
5033               while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
5034               }
5035             }
5036           else eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
5037           break;
5038
5039           /* The byte case is the same as non-UTF8 */
5040
5041           case OP_ANYBYTE:
5042           c = max - min;
5043           if (c > (unsigned int)(md->end_subject - eptr))
5044             {
5045             eptr = md->end_subject;
5046             SCHECK_PARTIAL();
5047             }
5048           else eptr += c;
5049           break;
5050
5051           case OP_ANYNL:
5052           for (i = min; i < max; i++)
5053             {
5054             int len = 1;
5055             if (eptr >= md->end_subject)
5056               {
5057               SCHECK_PARTIAL();
5058               break;
5059               }
5060             GETCHARLEN(c, eptr, len);
5061             if (c == 0x000d)
5062               {
5063               if (++eptr >= md->end_subject) break;
5064               if (*eptr == 0x000a) eptr++;
5065               }
5066             else
5067               {
5068               if (c != 0x000a &&
5069                   (md->bsr_anycrlf ||
5070                    (c != 0x000b && c != 0x000c &&
5071                     c != 0x0085 && c != 0x2028 && c != 0x2029)))
5072                 break;
5073               eptr += len;
5074               }
5075             }
5076           break;
5077
5078           case OP_NOT_HSPACE:
5079           case OP_HSPACE:
5080           for (i = min; i < max; i++)
5081             {
5082             BOOL gotspace;
5083             int len = 1;
5084             if (eptr >= md->end_subject)
5085               {
5086               SCHECK_PARTIAL();
5087               break;
5088               }
5089             GETCHARLEN(c, eptr, len);
5090             switch(c)
5091               {
5092               default: gotspace = FALSE; break;
5093               case 0x09:      /* HT */
5094               case 0x20:      /* SPACE */
5095               case 0xa0:      /* NBSP */
5096               case 0x1680:    /* OGHAM SPACE MARK */
5097               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
5098               case 0x2000:    /* EN QUAD */
5099               case 0x2001:    /* EM QUAD */
5100               case 0x2002:    /* EN SPACE */
5101               case 0x2003:    /* EM SPACE */
5102               case 0x2004:    /* THREE-PER-EM SPACE */
5103               case 0x2005:    /* FOUR-PER-EM SPACE */
5104               case 0x2006:    /* SIX-PER-EM SPACE */
5105               case 0x2007:    /* FIGURE SPACE */
5106               case 0x2008:    /* PUNCTUATION SPACE */
5107               case 0x2009:    /* THIN SPACE */
5108               case 0x200A:    /* HAIR SPACE */
5109               case 0x202f:    /* NARROW NO-BREAK SPACE */
5110               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5111               case 0x3000:    /* IDEOGRAPHIC SPACE */
5112               gotspace = TRUE;
5113               break;
5114               }
5115             if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5116             eptr += len;
5117             }
5118           break;
5119
5120           case OP_NOT_VSPACE:
5121           case OP_VSPACE:
5122           for (i = min; i < max; i++)
5123             {
5124             BOOL gotspace;
5125             int len = 1;
5126             if (eptr >= md->end_subject)
5127               {
5128               SCHECK_PARTIAL();
5129               break;
5130               }
5131             GETCHARLEN(c, eptr, len);
5132             switch(c)
5133               {
5134               default: gotspace = FALSE; break;
5135               case 0x0a:      /* LF */
5136               case 0x0b:      /* VT */
5137               case 0x0c:      /* FF */
5138               case 0x0d:      /* CR */
5139               case 0x85:      /* NEL */
5140               case 0x2028:    /* LINE SEPARATOR */
5141               case 0x2029:    /* PARAGRAPH SEPARATOR */
5142               gotspace = TRUE;
5143               break;
5144               }
5145             if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5146             eptr += len;
5147             }
5148           break;
5149
5150           case OP_NOT_DIGIT:
5151           for (i = min; i < max; i++)
5152             {
5153             int len = 1;
5154             if (eptr >= md->end_subject)
5155               {
5156               SCHECK_PARTIAL();
5157               break;
5158               }
5159             GETCHARLEN(c, eptr, len);
5160             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
5161             eptr+= len;
5162             }
5163           break;
5164
5165           case OP_DIGIT:
5166           for (i = min; i < max; i++)
5167             {
5168             int len = 1;
5169             if (eptr >= md->end_subject)
5170               {
5171               SCHECK_PARTIAL();
5172               break;
5173               }
5174             GETCHARLEN(c, eptr, len);
5175             if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
5176             eptr+= len;
5177             }
5178           break;
5179
5180           case OP_NOT_WHITESPACE:
5181           for (i = min; i < max; i++)
5182             {
5183             int len = 1;
5184             if (eptr >= md->end_subject)
5185               {
5186               SCHECK_PARTIAL();
5187               break;
5188               }
5189             GETCHARLEN(c, eptr, len);
5190             if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
5191             eptr+= len;
5192             }
5193           break;
5194
5195           case OP_WHITESPACE:
5196           for (i = min; i < max; i++)
5197             {
5198             int len = 1;
5199             if (eptr >= md->end_subject)
5200               {
5201               SCHECK_PARTIAL();
5202               break;
5203               }
5204             GETCHARLEN(c, eptr, len);
5205             if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
5206             eptr+= len;
5207             }
5208           break;
5209
5210           case OP_NOT_WORDCHAR:
5211           for (i = min; i < max; i++)
5212             {
5213             int len = 1;
5214             if (eptr >= md->end_subject)
5215               {
5216               SCHECK_PARTIAL();
5217               break;
5218               }
5219             GETCHARLEN(c, eptr, len);
5220             if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
5221             eptr+= len;
5222             }
5223           break;
5224
5225           case OP_WORDCHAR:
5226           for (i = min; i < max; i++)
5227             {
5228             int len = 1;
5229             if (eptr >= md->end_subject)
5230               {
5231               SCHECK_PARTIAL();
5232               break;
5233               }
5234             GETCHARLEN(c, eptr, len);
5235             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
5236             eptr+= len;
5237             }
5238           break;
5239
5240           default:
5241           RRETURN(PCRE_ERROR_INTERNAL);
5242           }
5243
5244         /* eptr is now past the end of the maximum run */
5245
5246         if (possessive) continue;
5247         for(;;)
5248           {
5249           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM46);
5250           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5251           if (eptr-- == pp) break;        /* Stop if tried at original pos */
5252           BACKCHAR(eptr);
5253           }
5254         }
5255       else
5256 #endif  /* SUPPORT_UTF8 */
5257
5258       /* Not UTF-8 mode */
5259         {
5260         switch(ctype)
5261           {
5262           case OP_ANY:
5263           for (i = min; i < max; i++)
5264             {
5265             if (eptr >= md->end_subject)
5266               {
5267               SCHECK_PARTIAL();
5268               break;
5269               }
5270             if (IS_NEWLINE(eptr)) break;
5271             eptr++;
5272             }
5273           break;
5274
5275           case OP_ALLANY:
5276           case OP_ANYBYTE:
5277           c = max - min;
5278           if (c > (unsigned int)(md->end_subject - eptr))
5279             {
5280             eptr = md->end_subject;
5281             SCHECK_PARTIAL();
5282             }
5283           else eptr += c;
5284           break;
5285
5286           case OP_ANYNL:
5287           for (i = min; i < max; i++)
5288             {
5289             if (eptr >= md->end_subject)
5290               {
5291               SCHECK_PARTIAL();
5292               break;
5293               }
5294             c = *eptr;
5295             if (c == 0x000d)
5296               {
5297               if (++eptr >= md->end_subject) break;
5298               if (*eptr == 0x000a) eptr++;
5299               }
5300             else
5301               {
5302               if (c != 0x000a &&
5303                   (md->bsr_anycrlf ||
5304                     (c != 0x000b && c != 0x000c && c != 0x0085)))
5305                 break;
5306               eptr++;
5307               }
5308             }
5309           break;
5310
5311           case OP_NOT_HSPACE:
5312           for (i = min; i < max; i++)
5313             {
5314             if (eptr >= md->end_subject)
5315               {
5316               SCHECK_PARTIAL();
5317               break;
5318               }
5319             c = *eptr;
5320             if (c == 0x09 || c == 0x20 || c == 0xa0) break;
5321             eptr++;
5322             }
5323           break;
5324
5325           case OP_HSPACE:
5326           for (i = min; i < max; i++)
5327             {
5328             if (eptr >= md->end_subject)
5329               {
5330               SCHECK_PARTIAL();
5331               break;
5332               }
5333             c = *eptr;
5334             if (c != 0x09 && c != 0x20 && c != 0xa0) break;
5335             eptr++;
5336             }
5337           break;
5338
5339           case OP_NOT_VSPACE:
5340           for (i = min; i < max; i++)
5341             {
5342             if (eptr >= md->end_subject)
5343               {
5344               SCHECK_PARTIAL();
5345               break;
5346               }
5347             c = *eptr;
5348             if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
5349               break;
5350             eptr++;
5351             }
5352           break;
5353
5354           case OP_VSPACE:
5355           for (i = min; i < max; i++)
5356             {
5357             if (eptr >= md->end_subject)
5358               {
5359               SCHECK_PARTIAL();
5360               break;
5361               }
5362             c = *eptr;
5363             if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
5364               break;
5365             eptr++;
5366             }
5367           break;
5368
5369           case OP_NOT_DIGIT:
5370           for (i = min; i < max; i++)
5371             {
5372             if (eptr >= md->end_subject)
5373               {
5374               SCHECK_PARTIAL();
5375               break;
5376               }
5377             if ((md->ctypes[*eptr] & ctype_digit) != 0) break;
5378             eptr++;
5379             }
5380           break;
5381
5382           case OP_DIGIT:
5383           for (i = min; i < max; i++)
5384             {
5385             if (eptr >= md->end_subject)
5386               {
5387               SCHECK_PARTIAL();
5388               break;
5389               }
5390             if ((md->ctypes[*eptr] & ctype_digit) == 0) break;
5391             eptr++;
5392             }
5393           break;
5394
5395           case OP_NOT_WHITESPACE:
5396           for (i = min; i < max; i++)
5397             {
5398             if (eptr >= md->end_subject)
5399               {
5400               SCHECK_PARTIAL();
5401               break;
5402               }
5403             if ((md->ctypes[*eptr] & ctype_space) != 0) break;
5404             eptr++;
5405             }
5406           break;
5407
5408           case OP_WHITESPACE:
5409           for (i = min; i < max; i++)
5410             {
5411             if (eptr >= md->end_subject)
5412               {
5413               SCHECK_PARTIAL();
5414               break;
5415               }
5416             if ((md->ctypes[*eptr] & ctype_space) == 0) break;
5417             eptr++;
5418             }
5419           break;
5420
5421           case OP_NOT_WORDCHAR:
5422           for (i = min; i < max; i++)
5423             {
5424             if (eptr >= md->end_subject)
5425               {
5426               SCHECK_PARTIAL();
5427               break;
5428               }
5429             if ((md->ctypes[*eptr] & ctype_word) != 0) break;
5430             eptr++;
5431             }
5432           break;
5433
5434           case OP_WORDCHAR:
5435           for (i = min; i < max; i++)
5436             {
5437             if (eptr >= md->end_subject)
5438               {
5439               SCHECK_PARTIAL();
5440               break;
5441               }
5442             if ((md->ctypes[*eptr] & ctype_word) == 0) break;
5443             eptr++;
5444             }
5445           break;
5446
5447           default:
5448           RRETURN(PCRE_ERROR_INTERNAL);
5449           }
5450
5451         /* eptr is now past the end of the maximum run */
5452
5453         if (possessive) continue;
5454         while (eptr >= pp)
5455           {
5456           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM47);
5457           eptr--;
5458           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5459           }
5460         }
5461
5462       /* Get here if we can't make it match with any permitted repetitions */
5463
5464       MRRETURN(MATCH_NOMATCH);
5465       }
5466     /* Control never gets here */
5467
5468     /* There's been some horrible disaster. Arrival here can only mean there is
5469     something seriously wrong in the code above or the OP_xxx definitions. */
5470
5471     default:
5472     DPRINTF(("Unknown opcode %d\n", *ecode));
5473     RRETURN(PCRE_ERROR_UNKNOWN_OPCODE);
5474     }
5475
5476   /* Do not stick any code in here without much thought; it is assumed
5477   that "continue" in the code above comes out to here to repeat the main
5478   loop. */
5479
5480   }             /* End of main loop */
5481 /* Control never reaches here */
5482
5483
5484 /* When compiling to use the heap rather than the stack for recursive calls to
5485 match(), the RRETURN() macro jumps here. The number that is saved in
5486 frame->Xwhere indicates which label we actually want to return to. */
5487
5488 #ifdef NO_RECURSE
5489 #define LBL(val) case val: goto L_RM##val;
5490 HEAP_RETURN:
5491 switch (frame->Xwhere)
5492   {
5493   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
5494   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
5495   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
5496   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
5497   LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
5498 #ifdef SUPPORT_UTF8
5499   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
5500   LBL(32) LBL(34) LBL(42) LBL(46)
5501 #ifdef SUPPORT_UCP
5502   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
5503   LBL(59) LBL(60) LBL(61) LBL(62)
5504 #endif  /* SUPPORT_UCP */
5505 #endif  /* SUPPORT_UTF8 */
5506   default:
5507   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
5508   return PCRE_ERROR_INTERNAL;
5509   }
5510 #undef LBL
5511 #endif  /* NO_RECURSE */
5512 }
5513
5514
5515 /***************************************************************************
5516 ****************************************************************************
5517                    RECURSION IN THE match() FUNCTION
5518
5519 Undefine all the macros that were defined above to handle this. */
5520
5521 #ifdef NO_RECURSE
5522 #undef eptr
5523 #undef ecode
5524 #undef mstart
5525 #undef offset_top
5526 #undef ims
5527 #undef eptrb
5528 #undef flags
5529
5530 #undef callpat
5531 #undef charptr
5532 #undef data
5533 #undef next
5534 #undef pp
5535 #undef prev
5536 #undef saved_eptr
5537
5538 #undef new_recursive
5539
5540 #undef cur_is_word
5541 #undef condition
5542 #undef prev_is_word
5543
5544 #undef original_ims
5545
5546 #undef ctype
5547 #undef length
5548 #undef max
5549 #undef min
5550 #undef number
5551 #undef offset
5552 #undef op
5553 #undef save_capture_last
5554 #undef save_offset1
5555 #undef save_offset2
5556 #undef save_offset3
5557 #undef stacksave
5558
5559 #undef newptrb
5560
5561 #endif
5562
5563 /* These two are defined as macros in both cases */
5564
5565 #undef fc
5566 #undef fi
5567
5568 /***************************************************************************
5569 ***************************************************************************/
5570
5571
5572
5573 /*************************************************
5574 *         Execute a Regular Expression           *
5575 *************************************************/
5576
5577 /* This function applies a compiled re to a subject string and picks out
5578 portions of the string if it matches. Two elements in the vector are set for
5579 each substring: the offsets to the start and end of the substring.
5580
5581 Arguments:
5582   argument_re     points to the compiled expression
5583   extra_data      points to extra data or is NULL
5584   subject         points to the subject string
5585   length          length of subject string (may contain binary zeros)
5586   start_offset    where to start in the subject string
5587   options         option bits
5588   offsets         points to a vector of ints to be filled in with offsets
5589   offsetcount     the number of elements in the vector
5590
5591 Returns:          > 0 => success; value is the number of elements filled in
5592                   = 0 => success, but offsets is not big enough
5593                    -1 => failed to match
5594                  < -1 => some kind of unexpected problem
5595 */
5596
5597 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
5598 pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
5599   PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
5600   int offsetcount)
5601 {
5602 int rc, resetcount, ocount;
5603 int first_byte = -1;
5604 int req_byte = -1;
5605 int req_byte2 = -1;
5606 int newline;
5607 unsigned long int ims;
5608 BOOL using_temporary_offsets = FALSE;
5609 BOOL anchored;
5610 BOOL startline;
5611 BOOL firstline;
5612 BOOL first_byte_caseless = FALSE;
5613 BOOL req_byte_caseless = FALSE;
5614 BOOL utf8;
5615 match_data match_block;
5616 match_data *md = &match_block;
5617 const uschar *tables;
5618 const uschar *start_bits = NULL;
5619 USPTR start_match = (USPTR)subject + start_offset;
5620 USPTR end_subject;
5621 USPTR start_partial = NULL;
5622 USPTR req_byte_ptr = start_match - 1;
5623
5624 pcre_study_data internal_study;
5625 const pcre_study_data *study;
5626
5627 real_pcre internal_re;
5628 const real_pcre *external_re = (const real_pcre *)argument_re;
5629 const real_pcre *re = external_re;
5630
5631 /* Plausibility checks */
5632
5633 if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
5634 if (re == NULL || subject == NULL ||
5635    (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
5636 if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
5637 if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
5638
5639 /* This information is for finding all the numbers associated with a given
5640 name, for condition testing. */
5641
5642 md->name_table = (uschar *)re + re->name_table_offset;
5643 md->name_count = re->name_count;
5644 md->name_entry_size = re->name_entry_size;
5645
5646 /* Fish out the optional data from the extra_data structure, first setting
5647 the default values. */
5648
5649 study = NULL;
5650 md->match_limit = MATCH_LIMIT;
5651 md->match_limit_recursion = MATCH_LIMIT_RECURSION;
5652 md->callout_data = NULL;
5653
5654 /* The table pointer is always in native byte order. */
5655
5656 tables = external_re->tables;
5657
5658 if (extra_data != NULL)
5659   {
5660   register unsigned int flags = extra_data->flags;
5661   if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
5662     study = (const pcre_study_data *)extra_data->study_data;
5663   if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)
5664     md->match_limit = extra_data->match_limit;
5665   if ((flags & PCRE_EXTRA_MATCH_LIMIT_RECURSION) != 0)
5666     md->match_limit_recursion = extra_data->match_limit_recursion;
5667   if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
5668     md->callout_data = extra_data->callout_data;
5669   if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;
5670   }
5671
5672 /* If the exec call supplied NULL for tables, use the inbuilt ones. This
5673 is a feature that makes it possible to save compiled regex and re-use them
5674 in other programs later. */
5675
5676 if (tables == NULL) tables = _pcre_default_tables;
5677
5678 /* Check that the first field in the block is the magic number. If it is not,
5679 test for a regex that was compiled on a host of opposite endianness. If this is
5680 the case, flipped values are put in internal_re and internal_study if there was
5681 study data too. */
5682
5683 if (re->magic_number != MAGIC_NUMBER)
5684   {
5685   re = _pcre_try_flipped(re, &internal_re, study, &internal_study);
5686   if (re == NULL) return PCRE_ERROR_BADMAGIC;
5687   if (study != NULL) study = &internal_study;
5688   }
5689
5690 /* Set up other data */
5691
5692 anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
5693 startline = (re->flags & PCRE_STARTLINE) != 0;
5694 firstline = (re->options & PCRE_FIRSTLINE) != 0;
5695
5696 /* The code starts after the real_pcre block and the capture name table. */
5697
5698 md->start_code = (const uschar *)external_re + re->name_table_offset +
5699   re->name_count * re->name_entry_size;
5700
5701 md->start_subject = (USPTR)subject;
5702 md->start_offset = start_offset;
5703 md->end_subject = md->start_subject + length;
5704 end_subject = md->end_subject;
5705
5706 md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
5707 utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
5708 md->use_ucp = (re->options & PCRE_UCP) != 0;
5709 md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
5710
5711 md->notbol = (options & PCRE_NOTBOL) != 0;
5712 md->noteol = (options & PCRE_NOTEOL) != 0;
5713 md->notempty = (options & PCRE_NOTEMPTY) != 0;
5714 md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
5715 md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5716               ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5717 md->hitend = FALSE;
5718 md->mark = NULL;                        /* In case never set */
5719
5720 md->recursive = NULL;                   /* No recursion at top level */
5721
5722 md->lcc = tables + lcc_offset;
5723 md->ctypes = tables + ctypes_offset;
5724
5725 /* Handle different \R options. */
5726
5727 switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
5728   {
5729   case 0:
5730   if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
5731     md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
5732   else
5733 #ifdef BSR_ANYCRLF
5734   md->bsr_anycrlf = TRUE;
5735 #else
5736   md->bsr_anycrlf = FALSE;
5737 #endif
5738   break;
5739
5740   case PCRE_BSR_ANYCRLF:
5741   md->bsr_anycrlf = TRUE;
5742   break;
5743
5744   case PCRE_BSR_UNICODE:
5745   md->bsr_anycrlf = FALSE;
5746   break;
5747
5748   default: return PCRE_ERROR_BADNEWLINE;
5749   }
5750
5751 /* Handle different types of newline. The three bits give eight cases. If
5752 nothing is set at run time, whatever was used at compile time applies. */
5753
5754 switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
5755         (pcre_uint32)options) & PCRE_NEWLINE_BITS)
5756   {
5757   case 0: newline = NEWLINE; break;   /* Compile-time default */
5758   case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
5759   case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
5760   case PCRE_NEWLINE_CR+
5761        PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
5762   case PCRE_NEWLINE_ANY: newline = -1; break;
5763   case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
5764   default: return PCRE_ERROR_BADNEWLINE;
5765   }
5766
5767 if (newline == -2)
5768   {
5769   md->nltype = NLTYPE_ANYCRLF;
5770   }
5771 else if (newline < 0)
5772   {
5773   md->nltype = NLTYPE_ANY;
5774   }
5775 else
5776   {
5777   md->nltype = NLTYPE_FIXED;
5778   if (newline > 255)
5779     {
5780     md->nllen = 2;
5781     md->nl[0] = (newline >> 8) & 255;
5782     md->nl[1] = newline & 255;
5783     }
5784   else
5785     {
5786     md->nllen = 1;
5787     md->nl[0] = newline;
5788     }
5789   }
5790
5791 /* Partial matching was originally supported only for a restricted set of
5792 regexes; from release 8.00 there are no restrictions, but the bits are still
5793 defined (though never set). So there's no harm in leaving this code. */
5794
5795 if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
5796   return PCRE_ERROR_BADPARTIAL;
5797
5798 /* Check a UTF-8 string if required. Unfortunately there's no way of passing
5799 back the character offset. */
5800
5801 #ifdef SUPPORT_UTF8
5802 if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
5803   {
5804   int tb;
5805   if ((tb = _pcre_valid_utf8((USPTR)subject, length)) >= 0)
5806     return (tb == length && md->partial > 1)?
5807       PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
5808   if (start_offset > 0 && start_offset < length)
5809     {
5810     tb = ((USPTR)subject)[start_offset] & 0xc0;
5811     if (tb == 0x80) return PCRE_ERROR_BADUTF8_OFFSET;
5812     }
5813   }
5814 #endif
5815
5816 /* The ims options can vary during the matching as a result of the presence
5817 of (?ims) items in the pattern. They are kept in a local variable so that
5818 restoring at the exit of a group is easy. */
5819
5820 ims = re->options & (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL);
5821
5822 /* If the expression has got more back references than the offsets supplied can
5823 hold, we get a temporary chunk of working store to use during the matching.
5824 Otherwise, we can use the vector supplied, rounding down its size to a multiple
5825 of 3. */
5826
5827 ocount = offsetcount - (offsetcount % 3);
5828
5829 if (re->top_backref > 0 && re->top_backref >= ocount/3)
5830   {
5831   ocount = re->top_backref * 3 + 3;
5832   md->offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));
5833   if (md->offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
5834   using_temporary_offsets = TRUE;
5835   DPRINTF(("Got memory to hold back references\n"));
5836   }
5837 else md->offset_vector = offsets;
5838
5839 md->offset_end = ocount;
5840 md->offset_max = (2*ocount)/3;
5841 md->offset_overflow = FALSE;
5842 md->capture_last = -1;
5843
5844 /* Compute the minimum number of offsets that we need to reset each time. Doing
5845 this makes a huge difference to execution time when there aren't many brackets
5846 in the pattern. */
5847
5848 resetcount = 2 + re->top_bracket * 2;
5849 if (resetcount > offsetcount) resetcount = ocount;
5850
5851 /* Reset the working variable associated with each extraction. These should
5852 never be used unless previously set, but they get saved and restored, and so we
5853 initialize them to avoid reading uninitialized locations. */
5854
5855 if (md->offset_vector != NULL)
5856   {
5857   register int *iptr = md->offset_vector + ocount;
5858   register int *iend = iptr - resetcount/2 + 1;
5859   while (--iptr >= iend) *iptr = -1;
5860   }
5861
5862 /* Set up the first character to match, if available. The first_byte value is
5863 never set for an anchored regular expression, but the anchoring may be forced
5864 at run time, so we have to test for anchoring. The first char may be unset for
5865 an unanchored pattern, of course. If there's no first char and the pattern was
5866 studied, there may be a bitmap of possible first characters. */
5867
5868 if (!anchored)
5869   {
5870   if ((re->flags & PCRE_FIRSTSET) != 0)
5871     {
5872     first_byte = re->first_byte & 255;
5873     if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
5874       first_byte = md->lcc[first_byte];
5875     }
5876   else
5877     if (!startline && study != NULL &&
5878       (study->flags & PCRE_STUDY_MAPPED) != 0)
5879         start_bits = study->start_bits;
5880   }
5881
5882 /* For anchored or unanchored matches, there may be a "last known required
5883 character" set. */
5884
5885 if ((re->flags & PCRE_REQCHSET) != 0)
5886   {
5887   req_byte = re->req_byte & 255;
5888   req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
5889   req_byte2 = (tables + fcc_offset)[req_byte];  /* case flipped */
5890   }
5891
5892
5893 /* ==========================================================================*/
5894
5895 /* Loop for handling unanchored repeated matching attempts; for anchored regexs
5896 the loop runs just once. */
5897
5898 for(;;)
5899   {
5900   USPTR save_end_subject = end_subject;
5901   USPTR new_start_match;
5902
5903   /* Reset the maximum number of extractions we might see. */
5904
5905   if (md->offset_vector != NULL)
5906     {
5907     register int *iptr = md->offset_vector;
5908     register int *iend = iptr + resetcount;
5909     while (iptr < iend) *iptr++ = -1;
5910     }
5911
5912   /* If firstline is TRUE, the start of the match is constrained to the first
5913   line of a multiline string. That is, the match must be before or at the first
5914   newline. Implement this by temporarily adjusting end_subject so that we stop
5915   scanning at a newline. If the match fails at the newline, later code breaks
5916   this loop. */
5917
5918   if (firstline)
5919     {
5920     USPTR t = start_match;
5921 #ifdef SUPPORT_UTF8
5922     if (utf8)
5923       {
5924       while (t < md->end_subject && !IS_NEWLINE(t))
5925         {
5926         t++;
5927         while (t < end_subject && (*t & 0xc0) == 0x80) t++;
5928         }
5929       }
5930     else
5931 #endif
5932     while (t < md->end_subject && !IS_NEWLINE(t)) t++;
5933     end_subject = t;
5934     }
5935
5936   /* There are some optimizations that avoid running the match if a known
5937   starting point is not found, or if a known later character is not present.
5938   However, there is an option that disables these, for testing and for ensuring
5939   that all callouts do actually occur. The option can be set in the regex by
5940   (*NO_START_OPT) or passed in match-time options. */
5941
5942   if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
5943     {
5944     /* Advance to a unique first byte if there is one. */
5945
5946     if (first_byte >= 0)
5947       {
5948       if (first_byte_caseless)
5949         while (start_match < end_subject && md->lcc[*start_match] != first_byte)
5950           start_match++;
5951       else
5952         while (start_match < end_subject && *start_match != first_byte)
5953           start_match++;
5954       }
5955
5956     /* Or to just after a linebreak for a multiline match */
5957
5958     else if (startline)
5959       {
5960       if (start_match > md->start_subject + start_offset)
5961         {
5962 #ifdef SUPPORT_UTF8
5963         if (utf8)
5964           {
5965           while (start_match < end_subject && !WAS_NEWLINE(start_match))
5966             {
5967             start_match++;
5968             while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
5969               start_match++;
5970             }
5971           }
5972         else
5973 #endif
5974         while (start_match < end_subject && !WAS_NEWLINE(start_match))
5975           start_match++;
5976
5977         /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
5978         and we are now at a LF, advance the match position by one more character.
5979         */
5980
5981         if (start_match[-1] == CHAR_CR &&
5982              (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
5983              start_match < end_subject &&
5984              *start_match == CHAR_NL)
5985           start_match++;
5986         }
5987       }
5988
5989     /* Or to a non-unique first byte after study */
5990
5991     else if (start_bits != NULL)
5992       {
5993       while (start_match < end_subject)
5994         {
5995         register unsigned int c = *start_match;
5996         if ((start_bits[c/8] & (1 << (c&7))) == 0)
5997           {
5998           start_match++;
5999 #ifdef SUPPORT_UTF8
6000           if (utf8)
6001             while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
6002               start_match++;
6003 #endif
6004           }
6005         else break;
6006         }
6007       }
6008     }   /* Starting optimizations */
6009
6010   /* Restore fudged end_subject */
6011
6012   end_subject = save_end_subject;
6013
6014   /* The following two optimizations are disabled for partial matching or if
6015   disabling is explicitly requested. */
6016
6017   if ((options & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
6018     {
6019     /* If the pattern was studied, a minimum subject length may be set. This is
6020     a lower bound; no actual string of that length may actually match the
6021     pattern. Although the value is, strictly, in characters, we treat it as
6022     bytes to avoid spending too much time in this optimization. */
6023
6024     if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
6025         (pcre_uint32)(end_subject - start_match) < study->minlength)
6026       {
6027       rc = MATCH_NOMATCH;
6028       break;
6029       }
6030
6031     /* If req_byte is set, we know that that character must appear in the
6032     subject for the match to succeed. If the first character is set, req_byte
6033     must be later in the subject; otherwise the test starts at the match point.
6034     This optimization can save a huge amount of backtracking in patterns with
6035     nested unlimited repeats that aren't going to match. Writing separate code
6036     for cased/caseless versions makes it go faster, as does using an
6037     autoincrement and backing off on a match.
6038
6039     HOWEVER: when the subject string is very, very long, searching to its end
6040     can take a long time, and give bad performance on quite ordinary patterns.
6041     This showed up when somebody was matching something like /^\d+C/ on a
6042     32-megabyte string... so we don't do this when the string is sufficiently
6043     long. */
6044
6045     if (req_byte >= 0 && end_subject - start_match < REQ_BYTE_MAX)
6046       {
6047       register USPTR p = start_match + ((first_byte >= 0)? 1 : 0);
6048
6049       /* We don't need to repeat the search if we haven't yet reached the
6050       place we found it at last time. */
6051
6052       if (p > req_byte_ptr)
6053         {
6054         if (req_byte_caseless)
6055           {
6056           while (p < end_subject)
6057             {
6058             register int pp = *p++;
6059             if (pp == req_byte || pp == req_byte2) { p--; break; }
6060             }
6061           }
6062         else
6063           {
6064           while (p < end_subject)
6065             {
6066             if (*p++ == req_byte) { p--; break; }
6067             }
6068           }
6069
6070         /* If we can't find the required character, break the matching loop,
6071         forcing a match failure. */
6072
6073         if (p >= end_subject)
6074           {
6075           rc = MATCH_NOMATCH;
6076           break;
6077           }
6078
6079         /* If we have found the required character, save the point where we
6080         found it, so that we don't search again next time round the loop if
6081         the start hasn't passed this character yet. */
6082
6083         req_byte_ptr = p;
6084         }
6085       }
6086     }
6087
6088 #ifdef PCRE_DEBUG  /* Sigh. Some compilers never learn. */
6089   printf(">>>> Match against: ");
6090   pchars(start_match, end_subject - start_match, TRUE, md);
6091   printf("\n");
6092 #endif
6093
6094   /* OK, we can now run the match. If "hitend" is set afterwards, remember the
6095   first starting point for which a partial match was found. */
6096
6097   md->start_match_ptr = start_match;
6098   md->start_used_ptr = start_match;
6099   md->match_call_count = 0;
6100   rc = match(start_match, md->start_code, start_match, NULL, 2, md, ims, NULL,
6101     0, 0);
6102   if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
6103
6104   switch(rc)
6105     {
6106     /* SKIP passes back the next starting point explicitly, but if it is the
6107     same as the match we have just done, treat it as NOMATCH. */
6108
6109     case MATCH_SKIP:
6110     if (md->start_match_ptr != start_match)
6111       {
6112       new_start_match = md->start_match_ptr;
6113       break;
6114       }
6115     /* Fall through */
6116
6117     /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched
6118     the SKIP's arg was not found. We also treat this as NOMATCH. */
6119
6120     case MATCH_SKIP_ARG:
6121     /* Fall through */
6122
6123     /* NOMATCH and PRUNE advance by one character. THEN at this level acts
6124     exactly like PRUNE. */
6125
6126     case MATCH_NOMATCH:
6127     case MATCH_PRUNE:
6128     case MATCH_THEN:
6129     new_start_match = start_match + 1;
6130 #ifdef SUPPORT_UTF8
6131     if (utf8)
6132       while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)
6133         new_start_match++;
6134 #endif
6135     break;
6136
6137     /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
6138
6139     case MATCH_COMMIT:
6140     rc = MATCH_NOMATCH;
6141     goto ENDLOOP;
6142
6143     /* Any other return is either a match, or some kind of error. */
6144
6145     default:
6146     goto ENDLOOP;
6147     }
6148
6149   /* Control reaches here for the various types of "no match at this point"
6150   result. Reset the code to MATCH_NOMATCH for subsequent checking. */
6151
6152   rc = MATCH_NOMATCH;
6153
6154   /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
6155   newline in the subject (though it may continue over the newline). Therefore,
6156   if we have just failed to match, starting at a newline, do not continue. */
6157
6158   if (firstline && IS_NEWLINE(start_match)) break;
6159
6160   /* Advance to new matching position */
6161
6162   start_match = new_start_match;
6163
6164   /* Break the loop if the pattern is anchored or if we have passed the end of
6165   the subject. */
6166
6167   if (anchored || start_match > end_subject) break;
6168
6169   /* If we have just passed a CR and we are now at a LF, and the pattern does
6170   not contain any explicit matches for \r or \n, and the newline option is CRLF
6171   or ANY or ANYCRLF, advance the match position by one more character. */
6172
6173   if (start_match[-1] == CHAR_CR &&
6174       start_match < end_subject &&
6175       *start_match == CHAR_NL &&
6176       (re->flags & PCRE_HASCRORLF) == 0 &&
6177         (md->nltype == NLTYPE_ANY ||
6178          md->nltype == NLTYPE_ANYCRLF ||
6179          md->nllen == 2))
6180     start_match++;
6181
6182   md->mark = NULL;   /* Reset for start of next match attempt */
6183   }                  /* End of for(;;) "bumpalong" loop */
6184
6185 /* ==========================================================================*/
6186
6187 /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
6188 conditions is true:
6189
6190 (1) The pattern is anchored or the match was failed by (*COMMIT);
6191
6192 (2) We are past the end of the subject;
6193
6194 (3) PCRE_FIRSTLINE is set and we have failed to match at a newline, because
6195     this option requests that a match occur at or before the first newline in
6196     the subject.
6197
6198 When we have a match and the offset vector is big enough to deal with any
6199 backreferences, captured substring offsets will already be set up. In the case
6200 where we had to get some local store to hold offsets for backreference
6201 processing, copy those that we can. In this case there need not be overflow if
6202 certain parts of the pattern were not used, even though there are more
6203 capturing parentheses than vector slots. */
6204
6205 ENDLOOP:
6206
6207 if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
6208   {
6209   if (using_temporary_offsets)
6210     {
6211     if (offsetcount >= 4)
6212       {
6213       memcpy(offsets + 2, md->offset_vector + 2,
6214         (offsetcount - 2) * sizeof(int));
6215       DPRINTF(("Copied offsets from temporary memory\n"));
6216       }
6217     if (md->end_offset_top > offsetcount) md->offset_overflow = TRUE;
6218     DPRINTF(("Freeing temporary memory\n"));
6219     (pcre_free)(md->offset_vector);
6220     }
6221
6222   /* Set the return code to the number of captured strings, or 0 if there are
6223   too many to fit into the vector. */
6224
6225   rc = md->offset_overflow? 0 : md->end_offset_top/2;
6226
6227   /* If there is space, set up the whole thing as substring 0. The value of
6228   md->start_match_ptr might be modified if \K was encountered on the success
6229   matching path. */
6230
6231   if (offsetcount < 2) rc = 0; else
6232     {
6233     offsets[0] = (int)(md->start_match_ptr - md->start_subject);
6234     offsets[1] = (int)(md->end_match_ptr - md->start_subject);
6235     }
6236
6237   DPRINTF((">>>> returning %d\n", rc));
6238   goto RETURN_MARK;
6239   }
6240
6241 /* Control gets here if there has been an error, or if the overall match
6242 attempt has failed at all permitted starting positions. */
6243
6244 if (using_temporary_offsets)
6245   {
6246   DPRINTF(("Freeing temporary memory\n"));
6247   (pcre_free)(md->offset_vector);
6248   }
6249
6250 /* For anything other than nomatch or partial match, just return the code. */
6251
6252 if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6253   {
6254   DPRINTF((">>>> error: returning %d\n", rc));
6255   return rc;
6256   }
6257
6258 /* Handle partial matches - disable any mark data */
6259
6260 if (start_partial != NULL)
6261   {
6262   DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
6263   md->mark = NULL;
6264   if (offsetcount > 1)
6265     {
6266     offsets[0] = (int)(start_partial - (USPTR)subject);
6267     offsets[1] = (int)(end_subject - (USPTR)subject);
6268     }
6269   rc = PCRE_ERROR_PARTIAL;
6270   }
6271
6272 /* This is the classic nomatch case */
6273
6274 else
6275   {
6276   DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
6277   rc = PCRE_ERROR_NOMATCH;
6278   }
6279
6280 /* Return the MARK data if it has been requested. */
6281
6282 RETURN_MARK:
6283
6284 if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6285   *(extra_data->mark) = (unsigned char *)(md->mark);
6286 return rc;
6287 }
6288
6289 /* End of pcre_exec.c */