/[pcre]/code/trunk/pcre_exec.c
ViewVC logotype

Contents of /code/trunk/pcre_exec.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 779 - (show annotations) (download)
Fri Dec 2 10:39:32 2011 UTC (3 years ago) by ph10
File MIME type: text/plain
File size: 202181 byte(s)
Added (int) casts to reduce 64-bit warnings.

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

Properties

Name Value
svn:eol-style native
svn:keywords "Author Date Id Revision Url"

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12