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

Contents of /code/trunk/pcre_exec.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 751 - (hide annotations) (download)
Fri Nov 18 11:13:30 2011 UTC (2 years, 4 months ago) by ph10
File MIME type: text/plain
File size: 201321 byte(s)
Code tidies.

1 nigel 77 /*************************************************
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 ph10 598 Copyright (c) 1997-2011 University of Cambridge
10 nigel 77
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 ph10 200 #ifdef HAVE_CONFIG_H
46 ph10 236 #include "config.h"
47 ph10 200 #endif
48 ph10 199
49 nigel 93 #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 nigel 77 #include "pcre_internal.h"
54    
55 ph10 137 /* Undefine some potentially clashing cpp symbols */
56    
57     #undef min
58     #undef max
59    
60 ph10 625 /* 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 ph10 604 as stack usage is to be discouraged. */
63 nigel 77
64 ph10 604 #define MATCH_CONDASSERT 1 /* Called to check a condition assertion */
65     #define MATCH_CBEGROUP 2 /* Could-be-empty unlimited repeat group */
66 nigel 77
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 ph10 211 /* Special internal returns from the match() function. Make them sufficiently
74 ph10 210 negative to avoid the external error codes. */
75    
76 ph10 511 #define MATCH_ACCEPT (-999)
77     #define MATCH_COMMIT (-998)
78 ph10 604 #define MATCH_KETRPOS (-997)
79 ph10 618 #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 ph10 210
85 ph10 510 /* This is a convenience macro for code that occurs many times. */
86    
87     #define MRRETURN(ra) \
88     { \
89     md->mark = markptr; \
90     RRETURN(ra); \
91     }
92    
93 nigel 77 /* Maximum number of ints of offset to save on the stack for recursive calls.
94     If the offset vector is bigger, malloc is used. This should be a multiple of 3,
95     because the offset vector is always a multiple of 3 long. */
96    
97     #define REC_STACK_SAVE_MAX 30
98    
99     /* Min and max values for the common repeats; for the maxima, 0 => infinity */
100    
101     static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
102     static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
103    
104    
105    
106 ph10 475 #ifdef PCRE_DEBUG
107 nigel 77 /*************************************************
108     * Debugging function to print chars *
109     *************************************************/
110    
111     /* Print a sequence of chars in printable format, stopping at the end of the
112     subject if the requested.
113    
114     Arguments:
115     p points to characters
116     length number to print
117     is_subject TRUE if printing from within md->start_subject
118     md pointer to matching data block, if is_subject is TRUE
119    
120     Returns: nothing
121     */
122    
123     static void
124     pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
125     {
126 nigel 93 unsigned int c;
127 nigel 77 if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
128     while (length-- > 0)
129     if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);
130     }
131     #endif
132    
133    
134    
135     /*************************************************
136     * Match a back-reference *
137     *************************************************/
138    
139 ph10 595 /* Normally, if a back reference hasn't been set, the length that is passed is
140     negative, so the match always fails. However, in JavaScript compatibility mode,
141 ph10 625 the length passed is zero. Note that in caseless UTF-8 mode, the number of
142 ph10 595 subject bytes matched may be different to the number of reference bytes.
143 nigel 77
144     Arguments:
145     offset index into the offset vector
146 ph10 595 eptr pointer into the subject
147     length length of reference to be matched (number of bytes)
148 nigel 77 md points to match data block
149 ph10 602 caseless TRUE if caseless
150 nigel 77
151 ph10 595 Returns: < 0 if not matched, otherwise the number of subject bytes matched
152 nigel 77 */
153    
154 ph10 595 static int
155 nigel 87 match_ref(int offset, register USPTR eptr, int length, match_data *md,
156 ph10 602 BOOL caseless)
157 nigel 77 {
158 ph10 595 USPTR eptr_start = eptr;
159     register USPTR p = md->start_subject + md->offset_vector[offset];
160 nigel 77
161 ph10 475 #ifdef PCRE_DEBUG
162 nigel 77 if (eptr >= md->end_subject)
163     printf("matching subject <null>");
164     else
165     {
166     printf("matching subject ");
167     pchars(eptr, length, TRUE, md);
168     }
169     printf(" against backref ");
170     pchars(p, length, FALSE, md);
171     printf("\n");
172     #endif
173    
174 ph10 595 /* Always fail if reference not set (and not JavaScript compatible). */
175 nigel 77
176 ph10 595 if (length < 0) return -1;
177 nigel 77
178 ph10 354 /* Separate the caseless case for speed. In UTF-8 mode we can only do this
179     properly if Unicode properties are supported. Otherwise, we can check only
180     ASCII characters. */
181 nigel 77
182 ph10 602 if (caseless)
183 nigel 77 {
184 ph10 354 #ifdef SUPPORT_UTF8
185     #ifdef SUPPORT_UCP
186     if (md->utf8)
187     {
188 ph10 625 /* Match characters up to the end of the reference. NOTE: the number of
189 ph10 595 bytes matched may differ, because there are some characters whose upper and
190     lower case versions code as different numbers of bytes. For example, U+023A
191     (2 bytes in UTF-8) is the upper case version of U+2C65 (3 bytes in UTF-8);
192     a sequence of 3 of the former uses 6 bytes, as does a sequence of two of
193 ph10 625 the latter. It is important, therefore, to check the length along the
194 ph10 595 reference, not along the subject (earlier code did this wrong). */
195 ph10 625
196 ph10 595 USPTR endptr = p + length;
197     while (p < endptr)
198 ph10 354 {
199 ph10 358 int c, d;
200 ph10 597 if (eptr >= md->end_subject) return -1;
201 ph10 354 GETCHARINC(c, eptr);
202     GETCHARINC(d, p);
203 ph10 595 if (c != d && c != UCD_OTHERCASE(d)) return -1;
204 ph10 358 }
205     }
206 ph10 354 else
207     #endif
208     #endif
209    
210     /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
211     is no UCP support. */
212 ph10 597 {
213 ph10 625 if (eptr + length > md->end_subject) return -1;
214 ph10 597 while (length-- > 0)
215     { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }
216 ph10 625 }
217 nigel 77 }
218 ph10 358
219 ph10 354 /* In the caseful case, we can just compare the bytes, whether or not we
220     are in UTF-8 mode. */
221 ph10 358
222 nigel 77 else
223 ph10 625 {
224     if (eptr + length > md->end_subject) return -1;
225     while (length-- > 0) if (*p++ != *eptr++) return -1;
226 ph10 597 }
227 nigel 77
228 ph10 595 return eptr - eptr_start;
229 nigel 77 }
230    
231    
232    
233     /***************************************************************************
234     ****************************************************************************
235     RECURSION IN THE match() FUNCTION
236    
237 nigel 87 The match() function is highly recursive, though not every recursive call
238     increases the recursive depth. Nevertheless, some regular expressions can cause
239     it to recurse to a great depth. I was writing for Unix, so I just let it call
240     itself recursively. This uses the stack for saving everything that has to be
241     saved for a recursive call. On Unix, the stack can be large, and this works
242     fine.
243 nigel 77
244 nigel 87 It turns out that on some non-Unix-like systems there are problems with
245     programs that use a lot of stack. (This despite the fact that every last chip
246     has oodles of memory these days, and techniques for extending the stack have
247     been known for decades.) So....
248 nigel 77
249     There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
250     calls by keeping local variables that need to be preserved in blocks of memory
251 nigel 87 obtained from malloc() instead instead of on the stack. Macros are used to
252 nigel 77 achieve this so that the actual code doesn't look very different to what it
253     always used to.
254 ph10 164
255 ph10 165 The original heap-recursive code used longjmp(). However, it seems that this
256 ph10 164 can be very slow on some operating systems. Following a suggestion from Stan
257     Switzer, the use of longjmp() has been abolished, at the cost of having to
258     provide a unique number for each call to RMATCH. There is no way of generating
259     a sequence of numbers at compile time in C. I have given them names, to make
260     them stand out more clearly.
261    
262     Crude tests on x86 Linux show a small speedup of around 5-8%. However, on
263     FreeBSD, avoiding longjmp() more than halves the time taken to run the standard
264 ph10 165 tests. Furthermore, not using longjmp() means that local dynamic variables
265     don't have indeterminate values; this has meant that the frame size can be
266 ph10 164 reduced because the result can be "passed back" by straight setting of the
267     variable instead of being passed in the frame.
268 nigel 77 ****************************************************************************
269     ***************************************************************************/
270    
271 ph10 212 /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
272     below must be updated in sync. */
273 nigel 77
274 ph10 164 enum { RM1=1, RM2, RM3, RM4, RM5, RM6, RM7, RM8, RM9, RM10,
275     RM11, RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
276     RM21, RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
277     RM31, RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
278 ph10 210 RM41, RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
279 ph10 527 RM51, RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
280 ph10 723 RM61, RM62, RM63, RM64, RM65, RM66 };
281 ph10 164
282 nigel 87 /* These versions of the macros use the stack, as normal. There are debugging
283 ph10 165 versions and production versions. Note that the "rw" argument of RMATCH isn't
284 ph10 501 actually used in this definition. */
285 nigel 77
286     #ifndef NO_RECURSE
287     #define REGISTER register
288 ph10 164
289 ph10 475 #ifdef PCRE_DEBUG
290 ph10 604 #define RMATCH(ra,rb,rc,rd,re,rw) \
291 nigel 87 { \
292     printf("match() called in line %d\n", __LINE__); \
293 ph10 604 rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1); \
294 nigel 87 printf("to line %d\n", __LINE__); \
295     }
296     #define RRETURN(ra) \
297     { \
298     printf("match() returned %d from line %d ", ra, __LINE__); \
299     return ra; \
300     }
301     #else
302 ph10 604 #define RMATCH(ra,rb,rc,rd,re,rw) \
303     rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1)
304 nigel 77 #define RRETURN(ra) return ra
305 nigel 87 #endif
306    
307 nigel 77 #else
308    
309    
310 ph10 164 /* These versions of the macros manage a private stack on the heap. Note that
311     the "rd" argument of RMATCH isn't actually used in this definition. It's the md
312     argument of match(), which never changes. */
313 nigel 77
314     #define REGISTER
315    
316 ph10 604 #define RMATCH(ra,rb,rc,rd,re,rw)\
317 nigel 77 {\
318 ph10 563 heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
319 ph10 534 if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
320 ph10 164 frame->Xwhere = rw; \
321     newframe->Xeptr = ra;\
322     newframe->Xecode = rb;\
323 ph10 168 newframe->Xmstart = mstart;\
324 ph10 501 newframe->Xmarkptr = markptr;\
325 ph10 164 newframe->Xoffset_top = rc;\
326 ph10 602 newframe->Xeptrb = re;\
327 ph10 164 newframe->Xrdepth = frame->Xrdepth + 1;\
328     newframe->Xprevframe = frame;\
329     frame = newframe;\
330     DPRINTF(("restarting from line %d\n", __LINE__));\
331     goto HEAP_RECURSE;\
332     L_##rw:\
333     DPRINTF(("jumped back to line %d\n", __LINE__));\
334 nigel 77 }
335    
336     #define RRETURN(ra)\
337     {\
338 ph10 527 heapframe *oldframe = frame;\
339     frame = oldframe->Xprevframe;\
340     (pcre_stack_free)(oldframe);\
341 nigel 77 if (frame != NULL)\
342     {\
343 ph10 164 rrc = ra;\
344     goto HEAP_RETURN;\
345 nigel 77 }\
346     return ra;\
347     }
348    
349    
350     /* Structure for remembering the local variables in a private frame */
351    
352     typedef struct heapframe {
353     struct heapframe *Xprevframe;
354    
355     /* Function arguments that may change */
356    
357 ph10 409 USPTR Xeptr;
358 nigel 77 const uschar *Xecode;
359 ph10 409 USPTR Xmstart;
360 ph10 501 USPTR Xmarkptr;
361 nigel 77 int Xoffset_top;
362     eptrblock *Xeptrb;
363 nigel 91 unsigned int Xrdepth;
364 nigel 77
365     /* Function local variables */
366    
367 ph10 409 USPTR Xcallpat;
368 ph10 406 #ifdef SUPPORT_UTF8
369 ph10 409 USPTR Xcharptr;
370 ph10 406 #endif
371 ph10 409 USPTR Xdata;
372     USPTR Xnext;
373     USPTR Xpp;
374     USPTR Xprev;
375     USPTR Xsaved_eptr;
376 nigel 77
377     recursion_info Xnew_recursive;
378    
379     BOOL Xcur_is_word;
380     BOOL Xcondition;
381     BOOL Xprev_is_word;
382    
383     #ifdef SUPPORT_UCP
384     int Xprop_type;
385 nigel 87 int Xprop_value;
386 nigel 77 int Xprop_fail_result;
387 ph10 123 int Xoclength;
388     uschar Xocchars[8];
389 nigel 77 #endif
390    
391 ph10 403 int Xcodelink;
392 nigel 77 int Xctype;
393 nigel 93 unsigned int Xfc;
394 nigel 77 int Xfi;
395     int Xlength;
396     int Xmax;
397     int Xmin;
398     int Xnumber;
399     int Xoffset;
400     int Xop;
401     int Xsave_capture_last;
402     int Xsave_offset1, Xsave_offset2, Xsave_offset3;
403     int Xstacksave[REC_STACK_SAVE_MAX];
404    
405     eptrblock Xnewptrb;
406    
407 ph10 164 /* Where to jump back to */
408 nigel 77
409 ph10 164 int Xwhere;
410 ph10 165
411 nigel 77 } heapframe;
412    
413     #endif
414    
415    
416     /***************************************************************************
417     ***************************************************************************/
418    
419    
420    
421     /*************************************************
422     * Match from current position *
423     *************************************************/
424    
425 nigel 93 /* This function is called recursively in many circumstances. Whenever it
426 nigel 77 returns a negative (error) response, the outer incarnation must also return the
427 ph10 426 same response. */
428 nigel 77
429 ph10 426 /* These macros pack up tests that are used for partial matching, and which
430     appears several times in the code. We set the "hit end" flag if the pointer is
431     at the end of the subject and also past the start of the subject (i.e.
432 ph10 427 something has been matched). For hard partial matching, we then return
433     immediately. The second one is used when we already know we are past the end of
434     the subject. */
435 ph10 426
436     #define CHECK_PARTIAL()\
437 ph10 553 if (md->partial != 0 && eptr >= md->end_subject && \
438     eptr > md->start_used_ptr) \
439     { \
440     md->hitend = TRUE; \
441     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
442 ph10 427 }
443 ph10 426
444     #define SCHECK_PARTIAL()\
445 ph10 553 if (md->partial != 0 && eptr > md->start_used_ptr) \
446     { \
447     md->hitend = TRUE; \
448     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
449 ph10 427 }
450 ph10 426
451 ph10 427
452 ph10 426 /* Performance note: It might be tempting to extract commonly used fields from
453     the md structure (e.g. utf8, end_subject) into individual variables to improve
454 nigel 77 performance. Tests using gcc on a SPARC disproved this; in the first case, it
455     made performance worse.
456    
457     Arguments:
458 nigel 93 eptr pointer to current character in subject
459     ecode pointer to current position in compiled code
460 ph10 168 mstart pointer to the current match start position (can be modified
461 ph10 172 by encountering \K)
462 ph10 501 markptr pointer to the most recent MARK name, or NULL
463 nigel 77 offset_top current top pointer
464     md pointer to "static" info for the match
465     eptrb pointer to chain of blocks containing eptr at start of
466     brackets - for testing for empty matches
467 nigel 87 rdepth the recursion depth
468 nigel 77
469     Returns: MATCH_MATCH if matched ) these values are >= 0
470     MATCH_NOMATCH if failed to match )
471 ph10 510 a negative MATCH_xxx value for PRUNE, SKIP, etc
472 nigel 77 a negative PCRE_ERROR_xxx value if aborted by an error condition
473 nigel 87 (e.g. stopped by repeated call or recursion limit)
474 nigel 77 */
475    
476     static int
477 ph10 510 match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
478 ph10 625 const uschar *markptr, int offset_top, match_data *md, eptrblock *eptrb,
479 ph10 604 unsigned int rdepth)
480 nigel 77 {
481     /* These variables do not need to be preserved over recursion in this function,
482 nigel 93 so they can be ordinary variables in all cases. Mark some of them with
483     "register" because they are used a lot in loops. */
484 nigel 77
485 nigel 91 register int rrc; /* Returns from recursive calls */
486     register int i; /* Used for loops not involving calls to RMATCH() */
487 nigel 93 register unsigned int c; /* Character values not kept over RMATCH() calls */
488 nigel 91 register BOOL utf8; /* Local copy of UTF-8 flag for speed */
489 nigel 77
490 nigel 93 BOOL minimize, possessive; /* Quantifier options */
491 ph10 602 BOOL caseless;
492 ph10 403 int condcode;
493 nigel 93
494 nigel 77 /* When recursion is not being used, all "local" variables that have to be
495     preserved over calls to RMATCH() are part of a "frame" which is obtained from
496     heap storage. Set up the top-level frame here; others are obtained from the
497     heap whenever RMATCH() does a "recursion". See the macro definitions above. */
498    
499     #ifdef NO_RECURSE
500 ph10 563 heapframe *frame = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));
501 ph10 531 if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
502 nigel 77 frame->Xprevframe = NULL; /* Marks the top level */
503    
504     /* Copy in the original argument variables */
505    
506     frame->Xeptr = eptr;
507     frame->Xecode = ecode;
508 ph10 168 frame->Xmstart = mstart;
509 ph10 501 frame->Xmarkptr = markptr;
510 nigel 77 frame->Xoffset_top = offset_top;
511     frame->Xeptrb = eptrb;
512 nigel 87 frame->Xrdepth = rdepth;
513 nigel 77
514     /* This is where control jumps back to to effect "recursion" */
515    
516     HEAP_RECURSE:
517    
518     /* Macros make the argument variables come from the current frame */
519    
520     #define eptr frame->Xeptr
521     #define ecode frame->Xecode
522 ph10 168 #define mstart frame->Xmstart
523 ph10 501 #define markptr frame->Xmarkptr
524 nigel 77 #define offset_top frame->Xoffset_top
525     #define eptrb frame->Xeptrb
526 nigel 87 #define rdepth frame->Xrdepth
527 nigel 77
528     /* Ditto for the local variables */
529    
530     #ifdef SUPPORT_UTF8
531     #define charptr frame->Xcharptr
532     #endif
533     #define callpat frame->Xcallpat
534 ph10 403 #define codelink frame->Xcodelink
535 nigel 77 #define data frame->Xdata
536     #define next frame->Xnext
537     #define pp frame->Xpp
538     #define prev frame->Xprev
539     #define saved_eptr frame->Xsaved_eptr
540    
541     #define new_recursive frame->Xnew_recursive
542    
543     #define cur_is_word frame->Xcur_is_word
544     #define condition frame->Xcondition
545     #define prev_is_word frame->Xprev_is_word
546    
547     #ifdef SUPPORT_UCP
548     #define prop_type frame->Xprop_type
549 nigel 87 #define prop_value frame->Xprop_value
550 nigel 77 #define prop_fail_result frame->Xprop_fail_result
551 ph10 115 #define oclength frame->Xoclength
552     #define occhars frame->Xocchars
553 nigel 77 #endif
554    
555     #define ctype frame->Xctype
556     #define fc frame->Xfc
557     #define fi frame->Xfi
558     #define length frame->Xlength
559     #define max frame->Xmax
560     #define min frame->Xmin
561     #define number frame->Xnumber
562     #define offset frame->Xoffset
563     #define op frame->Xop
564     #define save_capture_last frame->Xsave_capture_last
565     #define save_offset1 frame->Xsave_offset1
566     #define save_offset2 frame->Xsave_offset2
567     #define save_offset3 frame->Xsave_offset3
568     #define stacksave frame->Xstacksave
569    
570     #define newptrb frame->Xnewptrb
571    
572     /* When recursion is being used, local variables are allocated on the stack and
573     get preserved during recursion in the normal way. In this environment, fi and
574     i, and fc and c, can be the same variables. */
575    
576 nigel 93 #else /* NO_RECURSE not defined */
577 nigel 77 #define fi i
578     #define fc c
579    
580 ph10 604 /* Many of the following variables are used only in small blocks of the code.
581     My normal style of coding would have declared them within each of those blocks.
582     However, in order to accommodate the version of this code that uses an external
583     "stack" implemented on the heap, it is easier to declare them all here, so the
584     declarations can be cut out in a block. The only declarations within blocks
585     below are for variables that do not have to be preserved over a recursive call
586     to RMATCH(). */
587 nigel 77
588 ph10 625 #ifdef SUPPORT_UTF8
589     const uschar *charptr;
590     #endif
591     const uschar *callpat;
592     const uschar *data;
593     const uschar *next;
594     USPTR pp;
595     const uschar *prev;
596     USPTR saved_eptr;
597    
598     recursion_info new_recursive;
599    
600     BOOL cur_is_word;
601 nigel 87 BOOL condition;
602 nigel 77 BOOL prev_is_word;
603    
604     #ifdef SUPPORT_UCP
605     int prop_type;
606 nigel 87 int prop_value;
607 nigel 77 int prop_fail_result;
608 ph10 115 int oclength;
609     uschar occhars[8];
610 nigel 77 #endif
611    
612 ph10 399 int codelink;
613 nigel 77 int ctype;
614     int length;
615     int max;
616     int min;
617     int number;
618     int offset;
619     int op;
620     int save_capture_last;
621     int save_offset1, save_offset2, save_offset3;
622     int stacksave[REC_STACK_SAVE_MAX];
623    
624     eptrblock newptrb;
625 nigel 93 #endif /* NO_RECURSE */
626 nigel 77
627 ph10 625 /* To save space on the stack and in the heap frame, I have doubled up on some
628     of the local variables that are used only in localised parts of the code, but
629     still need to be preserved over recursive calls of match(). These macros define
630 ph10 604 the alternative names that are used. */
631    
632     #define allow_zero cur_is_word
633     #define cbegroup condition
634     #define code_offset codelink
635     #define condassert condition
636     #define matched_once prev_is_word
637    
638 nigel 77 /* These statements are here to stop the compiler complaining about unitialized
639     variables. */
640    
641     #ifdef SUPPORT_UCP
642 nigel 87 prop_value = 0;
643 nigel 77 prop_fail_result = 0;
644     #endif
645    
646 nigel 93
647 nigel 91 /* This label is used for tail recursion, which is used in a few cases even
648     when NO_RECURSE is not defined, in order to reduce the amount of stack that is
649     used. Thanks to Ian Taylor for noticing this possibility and sending the
650     original patch. */
651    
652     TAIL_RECURSE:
653    
654 nigel 87 /* OK, now we can get on with the real code of the function. Recursive calls
655     are specified by the macro RMATCH and RRETURN is used to return. When
656     NO_RECURSE is *not* defined, these just turn into a recursive call to match()
657 ph10 475 and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
658 nigel 87 defined). However, RMATCH isn't like a function call because it's quite a
659     complicated macro. It has to be used in one particular way. This shouldn't,
660     however, impact performance when true recursion is being used. */
661 nigel 77
662 ph10 164 #ifdef SUPPORT_UTF8
663     utf8 = md->utf8; /* Local copy of the flag */
664     #else
665     utf8 = FALSE;
666     #endif
667    
668 nigel 87 /* First check that we haven't called match() too many times, or that we
669     haven't exceeded the recursive call limit. */
670    
671 nigel 77 if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
672 nigel 87 if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);
673 nigel 77
674 nigel 93 /* At the start of a group with an unlimited repeat that may match an empty
675 ph10 625 string, the variable md->match_function_type is set to MATCH_CBEGROUP. It is
676     done this way to save having to use another function argument, which would take
677 ph10 604 up space on the stack. See also MATCH_CONDASSERT below.
678 nigel 77
679 ph10 604 When MATCH_CBEGROUP is set, add the current subject pointer to the chain of
680     such remembered pointers, to be checked when we hit the closing ket, in order
681     to break infinite loops that match no characters. When match() is called in
682     other circumstances, don't add to the chain. The MATCH_CBEGROUP feature must
683     NOT be used with tail recursion, because the memory block that is used is on
684     the stack, so a new one may be required for each match(). */
685    
686     if (md->match_function_type == MATCH_CBEGROUP)
687 nigel 77 {
688 ph10 197 newptrb.epb_saved_eptr = eptr;
689     newptrb.epb_prev = eptrb;
690     eptrb = &newptrb;
691 ph10 604 md->match_function_type = 0;
692 nigel 77 }
693    
694 nigel 93 /* Now start processing the opcodes. */
695 nigel 77
696     for (;;)
697     {
698 nigel 93 minimize = possessive = FALSE;
699 nigel 77 op = *ecode;
700 ph10 625
701 nigel 93 switch(op)
702     {
703 ph10 510 case OP_MARK:
704     markptr = ecode + 2;
705     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
706 ph10 604 eptrb, RM55);
707 ph10 512
708     /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
709     argument, and we must check whether that argument matches this MARK's
710     argument. It is passed back in md->start_match_ptr (an overloading of that
711     variable). If it does match, we reset that variable to the current subject
712     position and return MATCH_SKIP. Otherwise, pass back the return code
713 ph10 510 unaltered. */
714 ph10 512
715     if (rrc == MATCH_SKIP_ARG &&
716 ph10 510 strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
717     {
718     md->start_match_ptr = eptr;
719     RRETURN(MATCH_SKIP);
720     }
721    
722 ph10 512 if (md->mark == NULL) md->mark = markptr;
723 ph10 510 RRETURN(rrc);
724    
725 ph10 210 case OP_FAIL:
726 ph10 510 MRRETURN(MATCH_NOMATCH);
727 ph10 211
728 ph10 551 /* COMMIT overrides PRUNE, SKIP, and THEN */
729 ph10 553
730 ph10 510 case OP_COMMIT:
731     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
732 ph10 604 eptrb, RM52);
733 ph10 551 if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&
734 ph10 553 rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
735     rrc != MATCH_THEN)
736 ph10 551 RRETURN(rrc);
737 ph10 510 MRRETURN(MATCH_COMMIT);
738    
739 ph10 551 /* PRUNE overrides THEN */
740 ph10 553
741 ph10 210 case OP_PRUNE:
742     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
743 ph10 604 eptrb, RM51);
744 ph10 551 if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
745 ph10 510 MRRETURN(MATCH_PRUNE);
746 ph10 211
747 ph10 510 case OP_PRUNE_ARG:
748     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
749 ph10 604 eptrb, RM56);
750 ph10 551 if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
751 ph10 510 md->mark = ecode + 2;
752     RRETURN(MATCH_PRUNE);
753 ph10 211
754 ph10 551 /* SKIP overrides PRUNE and THEN */
755 ph10 553
756 ph10 210 case OP_SKIP:
757     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
758 ph10 604 eptrb, RM53);
759 ph10 553 if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
760 ph10 551 RRETURN(rrc);
761 ph10 211 md->start_match_ptr = eptr; /* Pass back current position */
762 ph10 510 MRRETURN(MATCH_SKIP);
763 ph10 211
764 ph10 510 case OP_SKIP_ARG:
765     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
766 ph10 604 eptrb, RM57);
767 ph10 553 if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
768 ph10 551 RRETURN(rrc);
769 ph10 512
770     /* Pass back the current skip name by overloading md->start_match_ptr and
771     returning the special MATCH_SKIP_ARG return code. This will either be
772     caught by a matching MARK, or get to the top, where it is treated the same
773 ph10 510 as PRUNE. */
774 ph10 512
775 ph10 510 md->start_match_ptr = ecode + 2;
776 ph10 512 RRETURN(MATCH_SKIP_ARG);
777 ph10 553
778 ph10 716 /* For THEN (and THEN_ARG) we pass back the address of the opcode, so that
779     the branch in which it occurs can be determined. Overload the start of
780     match pointer to do this. */
781 ph10 512
782 ph10 210 case OP_THEN:
783     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
784 ph10 604 eptrb, RM54);
785 ph10 210 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
786 ph10 716 md->start_match_ptr = ecode;
787 ph10 510 MRRETURN(MATCH_THEN);
788    
789     case OP_THEN_ARG:
790 ph10 733 RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,
791 ph10 716 md, eptrb, RM58);
792 ph10 510 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
793 ph10 733 md->start_match_ptr = ecode;
794 ph10 716 md->mark = ecode + 2;
795 ph10 212 RRETURN(MATCH_THEN);
796 ph10 733
797 ph10 723 /* Handle an atomic group that does not contain any capturing parentheses.
798 ph10 733 This can be handled like an assertion. Prior to 8.13, all atomic groups
799     were handled this way. In 8.13, the code was changed as below for ONCE, so
800     that backups pass through the group and thereby reset captured values.
801     However, this uses a lot more stack, so in 8.20, atomic groups that do not
802     contain any captures generate OP_ONCE_NC, which can be handled in the old,
803 ph10 723 less stack intensive way.
804 ph10 211
805 ph10 723 Check the alternative branches in turn - the matching won't pass the KET
806     for this kind of subpattern. If any one branch matches, we carry on as at
807     the end of a normal bracket, leaving the subject pointer, but resetting
808     the start-of-match value in case it was changed by \K. */
809    
810     case OP_ONCE_NC:
811     prev = ecode;
812     saved_eptr = eptr;
813     do
814     {
815     RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
816     if (rrc == MATCH_MATCH) /* Note: _not_ MATCH_ACCEPT */
817     {
818     mstart = md->start_match_ptr;
819 ph10 743 markptr = md->mark;
820 ph10 723 break;
821     }
822     if (rrc == MATCH_THEN)
823     {
824     next = ecode + GET(ecode,1);
825 ph10 733 if (md->start_match_ptr < next &&
826 ph10 723 (*ecode == OP_ALT || *next == OP_ALT))
827     rrc = MATCH_NOMATCH;
828 ph10 733 }
829    
830 ph10 723 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
831     ecode += GET(ecode,1);
832     }
833     while (*ecode == OP_ALT);
834    
835     /* If hit the end of the group (which could be repeated), fail */
836    
837     if (*ecode != OP_ONCE_NC && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
838    
839     /* Continue as from after the group, updating the offsets high water
840     mark, since extracts may have been taken. */
841    
842     do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
843    
844     offset_top = md->end_offset_top;
845     eptr = md->end_match_ptr;
846    
847     /* For a non-repeating ket, just continue at this level. This also
848     happens for a repeating ket if no characters were matched in the group.
849     This is the forcible breaking of infinite loops as implemented in Perl
850     5.005. */
851    
852     if (*ecode == OP_KET || eptr == saved_eptr)
853     {
854     ecode += 1+LINK_SIZE;
855     break;
856     }
857    
858     /* The repeating kets try the rest of the pattern or restart from the
859     preceding bracket, in the appropriate order. The second "call" of match()
860     uses tail recursion, to avoid using another stack frame. */
861    
862     if (*ecode == OP_KETRMIN)
863     {
864     RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM65);
865     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
866     ecode = prev;
867     goto TAIL_RECURSE;
868     }
869     else /* OP_KETRMAX */
870     {
871 ph10 733 md->match_function_type = MATCH_CBEGROUP;
872 ph10 723 RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
873     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
874     ecode += 1 + LINK_SIZE;
875     goto TAIL_RECURSE;
876     }
877     /* Control never gets here */
878    
879 ph10 604 /* Handle a capturing bracket, other than those that are possessive with an
880     unlimited repeat. If there is space in the offset vector, save the current
881     subject position in the working slot at the top of the vector. We mustn't
882     change the current values of the data slot, because they may be set from a
883     previous iteration of this group, and be referred to by a reference inside
884 ph10 625 the group. A failure to match might occur after the group has succeeded,
885 ph10 617 if something later on doesn't match. For this reason, we need to restore
886     the working value and also the values of the final offsets, in case they
887     were set by a previous iteration of the same bracket.
888 nigel 77
889 nigel 93 If there isn't enough space in the offset vector, treat this as if it were
890     a non-capturing bracket. Don't worry about setting the flag for the error
891     case here; that is handled in the code for KET. */
892 nigel 77
893 nigel 93 case OP_CBRA:
894     case OP_SCBRA:
895     number = GET2(ecode, 1+LINK_SIZE);
896 nigel 77 offset = number << 1;
897 ph10 625
898 ph10 475 #ifdef PCRE_DEBUG
899 nigel 93 printf("start bracket %d\n", number);
900     printf("subject=");
901 nigel 77 pchars(eptr, 16, TRUE, md);
902     printf("\n");
903     #endif
904    
905     if (offset < md->offset_max)
906     {
907     save_offset1 = md->offset_vector[offset];
908     save_offset2 = md->offset_vector[offset+1];
909     save_offset3 = md->offset_vector[md->offset_end - number];
910     save_capture_last = md->capture_last;
911    
912     DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
913 ph10 531 md->offset_vector[md->offset_end - number] =
914 ph10 530 (int)(eptr - md->start_subject);
915 nigel 77
916 ph10 604 for (;;)
917 nigel 77 {
918 ph10 625 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
919     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
920 ph10 604 eptrb, RM1);
921 ph10 618 if (rrc == MATCH_ONCE) break; /* Backing up through an atomic group */
922 ph10 733
923     /* If we backed up to a THEN, check whether it is within the current
924     branch by comparing the address of the THEN that is passed back with
925 ph10 716 the end of the branch. If it is within the current branch, and the
926     branch is one of two or more alternatives (it either starts or ends
927 ph10 733 with OP_ALT), we have reached the limit of THEN's action, so convert
928     the return code to NOMATCH, which will cause normal backtracking to
929 ph10 716 happen from now on. Otherwise, THEN is passed back to an outer
930 ph10 733 alternative. This implements Perl's treatment of parenthesized groups,
931     where a group not containing | does not affect the current alternative,
932 ph10 716 that is, (X) is NOT the same as (X|(*F)). */
933    
934     if (rrc == MATCH_THEN)
935     {
936     next = ecode + GET(ecode,1);
937 ph10 733 if (md->start_match_ptr < next &&
938 ph10 716 (*ecode == OP_ALT || *next == OP_ALT))
939     rrc = MATCH_NOMATCH;
940 ph10 733 }
941    
942 ph10 716 /* Anything other than NOMATCH is passed back. */
943    
944     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
945 nigel 77 md->capture_last = save_capture_last;
946     ecode += GET(ecode, 1);
947 ph10 625 if (*ecode != OP_ALT) break;
948 nigel 77 }
949    
950     DPRINTF(("bracket %d failed\n", number));
951     md->offset_vector[offset] = save_offset1;
952     md->offset_vector[offset+1] = save_offset2;
953     md->offset_vector[md->offset_end - number] = save_offset3;
954 ph10 625
955 ph10 716 /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
956 nigel 77
957 ph10 716 if (md->mark == NULL) md->mark = markptr;
958     RRETURN(rrc);
959 nigel 77 }
960    
961 ph10 197 /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
962     as a non-capturing bracket. */
963 nigel 77
964 ph10 197 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
965     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
966    
967 nigel 93 DPRINTF(("insufficient capture room: treat as non-capturing\n"));
968 nigel 77
969 ph10 197 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
970     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
971    
972 ph10 618 /* Non-capturing or atomic group, except for possessive with unlimited
973 ph10 723 repeat and ONCE group with no captures. Loop for all the alternatives.
974 ph10 708
975 ph10 702 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 ph10 625
982 ph10 708 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 ph10 625 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 ph10 618 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 nigel 77
992 ph10 618 case OP_ONCE:
993 nigel 93 case OP_BRA:
994     case OP_SBRA:
995     DPRINTF(("start non-capturing bracket\n"));
996 ph10 618
997 nigel 91 for (;;)
998 nigel 77 {
999 ph10 618 if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;
1000 ph10 702
1001     /* If this is not a possibly empty group, and there are no (*THEN)s in
1002 ph10 708 the pattern, and this is the final alternative, optimize as described
1003 ph10 702 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 ph10 708 }
1010 ph10 702
1011     /* In all other cases, we have to make another call to match(). */
1012    
1013 ph10 708 RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
1014 ph10 604 RM2);
1015 ph10 733
1016 ph10 716 /* See comment in the code for capturing groups above about handling
1017     THEN. */
1018    
1019     if (rrc == MATCH_THEN)
1020 ph10 625 {
1021 ph10 716 next = ecode + GET(ecode,1);
1022 ph10 733 if (md->start_match_ptr < next &&
1023 ph10 716 (*ecode == OP_ALT || *next == OP_ALT))
1024     rrc = MATCH_NOMATCH;
1025 ph10 733 }
1026    
1027     if (rrc != MATCH_NOMATCH)
1028 ph10 716 {
1029 ph10 618 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 ph10 625 }
1037 ph10 618 if (md->once_target == scode) rrc = MATCH_NOMATCH;
1038 ph10 625 }
1039 ph10 550 RRETURN(rrc);
1040 ph10 625 }
1041 nigel 77 ecode += GET(ecode, 1);
1042 ph10 625 if (*ecode != OP_ALT) break;
1043 nigel 77 }
1044 ph10 733
1045 ph10 716 if (md->mark == NULL) md->mark = markptr;
1046 ph10 609 RRETURN(MATCH_NOMATCH);
1047    
1048 ph10 625 /* Handle possessive capturing brackets with an unlimited repeat. We come
1049 ph10 604 here from BRAZERO with allow_zero set TRUE. The offset_vector values are
1050     handled similarly to the normal case above. However, the matching is
1051     different. The end of these brackets will always be OP_KETRPOS, which
1052     returns MATCH_KETRPOS without going further in the pattern. By this means
1053     we can handle the group by iteration rather than recursion, thereby
1054     reducing the amount of stack needed. */
1055 ph10 625
1056 ph10 604 case OP_CBRAPOS:
1057     case OP_SCBRAPOS:
1058     allow_zero = FALSE;
1059 ph10 625
1060 ph10 604 POSSESSIVE_CAPTURE:
1061     number = GET2(ecode, 1+LINK_SIZE);
1062     offset = number << 1;
1063    
1064     #ifdef PCRE_DEBUG
1065     printf("start possessive bracket %d\n", number);
1066     printf("subject=");
1067     pchars(eptr, 16, TRUE, md);
1068     printf("\n");
1069     #endif
1070    
1071     if (offset < md->offset_max)
1072     {
1073     matched_once = FALSE;
1074 ph10 625 code_offset = ecode - md->start_code;
1075 ph10 604
1076     save_offset1 = md->offset_vector[offset];
1077     save_offset2 = md->offset_vector[offset+1];
1078     save_offset3 = md->offset_vector[md->offset_end - number];
1079     save_capture_last = md->capture_last;
1080    
1081     DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
1082 ph10 625
1083     /* Each time round the loop, save the current subject position for use
1084     when the group matches. For MATCH_MATCH, the group has matched, so we
1085     restart it with a new subject starting position, remembering that we had
1086     at least one match. For MATCH_NOMATCH, carry on with the alternatives, as
1087     usual. If we haven't matched any alternatives in any iteration, check to
1088     see if a previous iteration matched. If so, the group has matched;
1089     continue from afterwards. Otherwise it has failed; restore the previous
1090 ph10 604 capture values before returning NOMATCH. */
1091 ph10 625
1092 ph10 604 for (;;)
1093     {
1094     md->offset_vector[md->offset_end - number] =
1095     (int)(eptr - md->start_subject);
1096 ph10 625 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1097 ph10 604 RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
1098     eptrb, RM63);
1099     if (rrc == MATCH_KETRPOS)
1100     {
1101     offset_top = md->end_offset_top;
1102     eptr = md->end_match_ptr;
1103 ph10 625 ecode = md->start_code + code_offset;
1104 ph10 604 save_capture_last = md->capture_last;
1105 ph10 625 matched_once = TRUE;
1106     continue;
1107     }
1108 ph10 733
1109 ph10 716 /* See comment in the code for capturing groups above about handling
1110     THEN. */
1111    
1112     if (rrc == MATCH_THEN)
1113     {
1114     next = ecode + GET(ecode,1);
1115 ph10 733 if (md->start_match_ptr < next &&
1116 ph10 716 (*ecode == OP_ALT || *next == OP_ALT))
1117     rrc = MATCH_NOMATCH;
1118 ph10 733 }
1119 ph10 716
1120     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1121 ph10 604 md->capture_last = save_capture_last;
1122     ecode += GET(ecode, 1);
1123 ph10 625 if (*ecode != OP_ALT) break;
1124 ph10 604 }
1125 ph10 610
1126 ph10 604 if (!matched_once)
1127 ph10 625 {
1128 ph10 604 md->offset_vector[offset] = save_offset1;
1129     md->offset_vector[offset+1] = save_offset2;
1130     md->offset_vector[md->offset_end - number] = save_offset3;
1131     }
1132 ph10 625
1133 ph10 716 if (md->mark == NULL) md->mark = markptr;
1134 ph10 604 if (allow_zero || matched_once)
1135 ph10 625 {
1136 ph10 604 ecode += 1 + LINK_SIZE;
1137     break;
1138 ph10 625 }
1139    
1140 ph10 604 RRETURN(MATCH_NOMATCH);
1141     }
1142 ph10 625
1143 ph10 604 /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
1144     as a non-capturing bracket. */
1145    
1146     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1147     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1148    
1149     DPRINTF(("insufficient capture room: treat as non-capturing\n"));
1150    
1151     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1152     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1153    
1154 ph10 625 /* Non-capturing possessive bracket with unlimited repeat. We come here
1155 ph10 604 from BRAZERO with allow_zero = TRUE. The code is similar to the above,
1156     without the capturing complication. It is written out separately for speed
1157     and cleanliness. */
1158    
1159     case OP_BRAPOS:
1160     case OP_SBRAPOS:
1161 ph10 625 allow_zero = FALSE;
1162    
1163 ph10 604 POSSESSIVE_NON_CAPTURE:
1164     matched_once = FALSE;
1165 ph10 625 code_offset = ecode - md->start_code;
1166 ph10 604
1167     for (;;)
1168     {
1169 ph10 625 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1170 ph10 604 RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
1171 ph10 609 eptrb, RM48);
1172 ph10 604 if (rrc == MATCH_KETRPOS)
1173     {
1174 ph10 610 offset_top = md->end_offset_top;
1175 ph10 604 eptr = md->end_match_ptr;
1176 ph10 625 ecode = md->start_code + code_offset;
1177     matched_once = TRUE;
1178     continue;
1179     }
1180 ph10 733
1181 ph10 716 /* See comment in the code for capturing groups above about handling
1182     THEN. */
1183    
1184     if (rrc == MATCH_THEN)
1185     {
1186     next = ecode + GET(ecode,1);
1187 ph10 733 if (md->start_match_ptr < next &&
1188 ph10 716 (*ecode == OP_ALT || *next == OP_ALT))
1189     rrc = MATCH_NOMATCH;
1190 ph10 733 }
1191 ph10 716
1192     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1193 ph10 604 ecode += GET(ecode, 1);
1194 ph10 625 if (*ecode != OP_ALT) break;
1195 ph10 604 }
1196 ph10 625
1197     if (matched_once || allow_zero)
1198 ph10 604 {
1199     ecode += 1 + LINK_SIZE;
1200     break;
1201 ph10 625 }
1202 ph10 604 RRETURN(MATCH_NOMATCH);
1203    
1204     /* Control never reaches here. */
1205    
1206 nigel 77 /* Conditional group: compilation checked that there are no more than
1207     two branches. If the condition is false, skipping the first branch takes us
1208     past the end if there is only one branch, but that's OK because that is
1209 ph10 609 exactly what going to the ket would do. */
1210 nigel 77
1211     case OP_COND:
1212 nigel 93 case OP_SCOND:
1213 ph10 604 codelink = GET(ecode, 1);
1214 ph10 406
1215 ph10 381 /* Because of the way auto-callout works during compile, a callout item is
1216     inserted between OP_COND and an assertion condition. */
1217 ph10 392
1218 ph10 381 if (ecode[LINK_SIZE+1] == OP_CALLOUT)
1219     {
1220     if (pcre_callout != NULL)
1221     {
1222     pcre_callout_block cb;
1223 ph10 645 cb.version = 2; /* Version 1 of the callout block */
1224 ph10 381 cb.callout_number = ecode[LINK_SIZE+2];
1225     cb.offset_vector = md->offset_vector;
1226     cb.subject = (PCRE_SPTR)md->start_subject;
1227 ph10 530 cb.subject_length = (int)(md->end_subject - md->start_subject);
1228     cb.start_match = (int)(mstart - md->start_subject);
1229     cb.current_position = (int)(eptr - md->start_subject);
1230 ph10 381 cb.pattern_position = GET(ecode, LINK_SIZE + 3);
1231     cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
1232     cb.capture_top = offset_top/2;
1233     cb.capture_last = md->capture_last;
1234     cb.callout_data = md->callout_data;
1235 ph10 654 cb.mark = markptr;
1236 ph10 510 if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1237 ph10 381 if (rrc < 0) RRETURN(rrc);
1238     }
1239     ecode += _pcre_OP_lengths[OP_CALLOUT];
1240     }
1241 ph10 392
1242 ph10 399 condcode = ecode[LINK_SIZE+1];
1243 ph10 406
1244 ph10 381 /* Now see what the actual condition is */
1245 ph10 392
1246 ph10 459 if (condcode == OP_RREF || condcode == OP_NRREF) /* Recursion test */
1247 nigel 77 {
1248 ph10 459 if (md->recursive == NULL) /* Not recursing => FALSE */
1249     {
1250 ph10 461 condition = FALSE;
1251     ecode += GET(ecode, 1);
1252     }
1253 ph10 459 else
1254 ph10 461 {
1255 ph10 459 int recno = GET2(ecode, LINK_SIZE + 2); /* Recursion group number*/
1256 ph10 751 condition = (recno == RREF_ANY || recno == md->recursive->group_num);
1257 ph10 461
1258 ph10 459 /* If the test is for recursion into a specific subpattern, and it is
1259     false, but the test was set up by name, scan the table to see if the
1260     name refers to any other numbers, and test them. The condition is true
1261     if any one is set. */
1262 ph10 461
1263 ph10 751 if (!condition && condcode == OP_NRREF)
1264 ph10 459 {
1265     uschar *slotA = md->name_table;
1266     for (i = 0; i < md->name_count; i++)
1267 ph10 461 {
1268     if (GET2(slotA, 0) == recno) break;
1269 ph10 459 slotA += md->name_entry_size;
1270     }
1271 ph10 461
1272 ph10 459 /* Found a name for the number - there can be only one; duplicate
1273     names for different numbers are allowed, but not vice versa. First
1274     scan down for duplicates. */
1275 ph10 461
1276 ph10 459 if (i < md->name_count)
1277 ph10 461 {
1278 ph10 459 uschar *slotB = slotA;
1279     while (slotB > md->name_table)
1280     {
1281     slotB -= md->name_entry_size;
1282     if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1283     {
1284     condition = GET2(slotB, 0) == md->recursive->group_num;
1285 ph10 461 if (condition) break;
1286     }
1287 ph10 459 else break;
1288 ph10 461 }
1289    
1290 ph10 459 /* Scan up for duplicates */
1291 ph10 461
1292 ph10 459 if (!condition)
1293 ph10 461 {
1294 ph10 459 slotB = slotA;
1295     for (i++; i < md->name_count; i++)
1296     {
1297     slotB += md->name_entry_size;
1298     if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1299     {
1300     condition = GET2(slotB, 0) == md->recursive->group_num;
1301     if (condition) break;
1302 ph10 461 }
1303 ph10 459 else break;
1304 ph10 461 }
1305     }
1306 ph10 459 }
1307 ph10 461 }
1308    
1309 ph10 459 /* Chose branch according to the condition */
1310 ph10 461
1311 ph10 459 ecode += condition? 3 : GET(ecode, 1);
1312     }
1313 ph10 461 }
1314 nigel 93
1315 ph10 459 else if (condcode == OP_CREF || condcode == OP_NCREF) /* Group used test */
1316 nigel 93 {
1317 nigel 77 offset = GET2(ecode, LINK_SIZE+2) << 1; /* Doubled ref number */
1318 nigel 93 condition = offset < offset_top && md->offset_vector[offset] >= 0;
1319 ph10 461
1320 ph10 459 /* If the numbered capture is unset, but the reference was by name,
1321 ph10 461 scan the table to see if the name refers to any other numbers, and test
1322     them. The condition is true if any one is set. This is tediously similar
1323     to the code above, but not close enough to try to amalgamate. */
1324    
1325 ph10 459 if (!condition && condcode == OP_NCREF)
1326     {
1327 ph10 461 int refno = offset >> 1;
1328 ph10 459 uschar *slotA = md->name_table;
1329 ph10 461
1330 ph10 459 for (i = 0; i < md->name_count; i++)
1331 ph10 461 {
1332     if (GET2(slotA, 0) == refno) break;
1333 ph10 459 slotA += md->name_entry_size;
1334     }
1335 ph10 461
1336     /* Found a name for the number - there can be only one; duplicate names
1337     for different numbers are allowed, but not vice versa. First scan down
1338 ph10 459 for duplicates. */
1339 ph10 461
1340 ph10 459 if (i < md->name_count)
1341 ph10 461 {
1342 ph10 459 uschar *slotB = slotA;
1343     while (slotB > md->name_table)
1344     {
1345     slotB -= md->name_entry_size;
1346     if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1347     {
1348     offset = GET2(slotB, 0) << 1;
1349 ph10 461 condition = offset < offset_top &&
1350 ph10 459 md->offset_vector[offset] >= 0;
1351 ph10 461 if (condition) break;
1352     }
1353 ph10 459 else break;
1354 ph10 461 }
1355    
1356 ph10 459 /* Scan up for duplicates */
1357 ph10 461
1358 ph10 459 if (!condition)
1359 ph10 461 {
1360 ph10 459 slotB = slotA;
1361     for (i++; i < md->name_count; i++)
1362     {
1363     slotB += md->name_entry_size;
1364     if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1365     {
1366     offset = GET2(slotB, 0) << 1;
1367 ph10 461 condition = offset < offset_top &&
1368 ph10 459 md->offset_vector[offset] >= 0;
1369 ph10 461 if (condition) break;
1370     }
1371 ph10 459 else break;
1372 ph10 461 }
1373     }
1374 ph10 459 }
1375 ph10 461 }
1376    
1377 ph10 459 /* Chose branch according to the condition */
1378    
1379 nigel 93 ecode += condition? 3 : GET(ecode, 1);
1380 nigel 77 }
1381    
1382 ph10 399 else if (condcode == OP_DEF) /* DEFINE - always false */
1383 nigel 93 {
1384     condition = FALSE;
1385     ecode += GET(ecode, 1);
1386     }
1387    
1388 nigel 77 /* The condition is an assertion. Call match() to evaluate it - setting
1389 ph10 604 md->match_function_type to MATCH_CONDASSERT causes it to stop at the end of
1390     an assertion. */
1391 nigel 77
1392     else
1393     {
1394 ph10 625 md->match_function_type = MATCH_CONDASSERT;
1395 ph10 604 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM3);
1396 nigel 77 if (rrc == MATCH_MATCH)
1397     {
1398 ph10 619 if (md->end_offset_top > offset_top)
1399     offset_top = md->end_offset_top; /* Captures may have happened */
1400 nigel 93 condition = TRUE;
1401     ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
1402 nigel 77 while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1403     }
1404 ph10 733
1405 ph10 716 /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
1406 ph10 733 assertion; it is therefore treated as NOMATCH. */
1407 ph10 716
1408 ph10 733 else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1409 nigel 77 {
1410     RRETURN(rrc); /* Need braces because of following else */
1411     }
1412 nigel 93 else
1413     {
1414     condition = FALSE;
1415 ph10 399 ecode += codelink;
1416 nigel 93 }
1417     }
1418 nigel 91
1419 ph10 716 /* We are now at the branch that is to be obeyed. As there is only one, can
1420     use tail recursion to avoid using another stack frame, except when there is
1421     unlimited repeat of a possibly empty group. In the latter case, a recursive
1422     call to match() is always required, unless the second alternative doesn't
1423     exist, in which case we can just plough on. Note that, for compatibility
1424     with Perl, the | in a conditional group is NOT treated as creating two
1425     alternatives. If a THEN is encountered in the branch, it propagates out to
1426     the enclosing alternative (unless nested in a deeper set of alternatives,
1427     of course). */
1428 nigel 91
1429 nigel 93 if (condition || *ecode == OP_ALT)
1430     {
1431 ph10 716 if (op != OP_SCOND)
1432 ph10 702 {
1433     ecode += 1 + LINK_SIZE;
1434     goto TAIL_RECURSE;
1435 ph10 708 }
1436 ph10 733
1437 ph10 716 md->match_function_type = MATCH_CBEGROUP;
1438 ph10 609 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
1439     RRETURN(rrc);
1440 nigel 77 }
1441 ph10 708
1442 ph10 702 /* Condition false & no alternative; continue after the group. */
1443 ph10 708
1444 ph10 702 else
1445 nigel 93 {
1446     ecode += 1 + LINK_SIZE;
1447     }
1448     break;
1449 nigel 77
1450 ph10 461
1451 ph10 447 /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1452     to close any currently open capturing brackets. */
1453 ph10 461
1454 ph10 447 case OP_CLOSE:
1455 ph10 461 number = GET2(ecode, 1);
1456 ph10 447 offset = number << 1;
1457 ph10 461
1458 ph10 475 #ifdef PCRE_DEBUG
1459 ph10 447 printf("end bracket %d at *ACCEPT", number);
1460     printf("\n");
1461     #endif
1462 nigel 77
1463 ph10 447 md->capture_last = number;
1464     if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1465     {
1466     md->offset_vector[offset] =
1467     md->offset_vector[md->offset_end - number];
1468 ph10 530 md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1469 ph10 447 if (offset_top <= offset) offset_top = offset + 2;
1470     }
1471     ecode += 3;
1472 ph10 461 break;
1473 ph10 447
1474    
1475 ph10 619 /* End of the pattern, either real or forced. */
1476 nigel 77
1477 ph10 619 case OP_END:
1478 ph10 210 case OP_ACCEPT:
1479 ph10 625 case OP_ASSERT_ACCEPT:
1480    
1481 ph10 619 /* If we have matched an empty string, fail if not in an assertion and not
1482     in a recursion if either PCRE_NOTEMPTY is set, or if PCRE_NOTEMPTY_ATSTART
1483 ph10 613 is set and we have matched at the start of the subject. In both cases,
1484     backtracking will then try other alternatives, if any. */
1485 ph10 443
1486 ph10 619 if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
1487 ph10 618 md->recursive == NULL &&
1488 ph10 619 (md->notempty ||
1489     (md->notempty_atstart &&
1490     mstart == md->start_subject + md->start_offset)))
1491 ph10 510 MRRETURN(MATCH_NOMATCH);
1492 ph10 443
1493 ph10 442 /* Otherwise, we have a match. */
1494 ph10 625
1495 ph10 168 md->end_match_ptr = eptr; /* Record where we ended */
1496     md->end_offset_top = offset_top; /* and how many extracts were taken */
1497 ph10 210 md->start_match_ptr = mstart; /* and the start (\K can modify) */
1498 nigel 77
1499 ph10 512 /* For some reason, the macros don't work properly if an expression is
1500     given as the argument to MRRETURN when the heap is in use. */
1501    
1502     rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1503     MRRETURN(rrc);
1504    
1505 nigel 77 /* Assertion brackets. Check the alternative branches in turn - the
1506     matching won't pass the KET for an assertion. If any one branch matches,
1507     the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
1508     start of each branch to move the current point backwards, so the code at
1509 ph10 625 this level is identical to the lookahead case. When the assertion is part
1510     of a condition, we want to return immediately afterwards. The caller of
1511     this incarnation of the match() function will have set MATCH_CONDASSERT in
1512     md->match_function type, and one of these opcodes will be the first opcode
1513     that is processed. We use a local variable that is preserved over calls to
1514 ph10 604 match() to remember this case. */
1515 nigel 77
1516     case OP_ASSERT:
1517     case OP_ASSERTBACK:
1518 ph10 604 if (md->match_function_type == MATCH_CONDASSERT)
1519     {
1520     condassert = TRUE;
1521     md->match_function_type = 0;
1522     }
1523 ph10 625 else condassert = FALSE;
1524    
1525 nigel 77 do
1526     {
1527 ph10 604 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM4);
1528 ph10 511 if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1529 ph10 500 {
1530     mstart = md->start_match_ptr; /* In case \K reset it */
1531 ph10 630 markptr = md->mark;
1532 ph10 500 break;
1533 ph10 501 }
1534 ph10 733
1535     /* PCRE does not allow THEN to escape beyond an assertion; it is treated
1536 ph10 716 as NOMATCH. */
1537 ph10 733
1538 ph10 716 if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1539 nigel 77 ecode += GET(ecode, 1);
1540     }
1541     while (*ecode == OP_ALT);
1542 ph10 625
1543 ph10 510 if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1544 nigel 77
1545     /* If checking an assertion for a condition, return MATCH_MATCH. */
1546    
1547 ph10 604 if (condassert) RRETURN(MATCH_MATCH);
1548 nigel 77
1549     /* Continue from after the assertion, updating the offsets high water
1550     mark, since extracts may have been taken during the assertion. */
1551    
1552     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1553     ecode += 1 + LINK_SIZE;
1554     offset_top = md->end_offset_top;
1555     continue;
1556    
1557 ph10 473 /* Negative assertion: all branches must fail to match. Encountering SKIP,
1558 ph10 482 PRUNE, or COMMIT means we must assume failure without checking subsequent
1559 ph10 473 branches. */
1560 nigel 77
1561     case OP_ASSERT_NOT:
1562     case OP_ASSERTBACK_NOT:
1563 ph10 604 if (md->match_function_type == MATCH_CONDASSERT)
1564     {
1565     condassert = TRUE;
1566     md->match_function_type = 0;
1567     }
1568 ph10 625 else condassert = FALSE;
1569 ph10 604
1570 nigel 77 do
1571     {
1572 ph10 604 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1573 ph10 511 if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1574 ph10 473 if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1575     {
1576     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1577 ph10 482 break;
1578     }
1579 ph10 716
1580 ph10 733 /* PCRE does not allow THEN to escape beyond an assertion; it is treated
1581 ph10 716 as NOMATCH. */
1582    
1583     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1584 nigel 77 ecode += GET(ecode,1);
1585     }
1586     while (*ecode == OP_ALT);
1587    
1588 ph10 604 if (condassert) RRETURN(MATCH_MATCH); /* Condition assertion */
1589 ph10 625
1590 nigel 77 ecode += 1 + LINK_SIZE;
1591     continue;
1592    
1593     /* Move the subject pointer back. This occurs only at the start of
1594     each branch of a lookbehind assertion. If we are too close to the start to
1595     move back, this match function fails. When working with UTF-8 we move
1596     back a number of characters, not bytes. */
1597    
1598     case OP_REVERSE:
1599     #ifdef SUPPORT_UTF8
1600     if (utf8)
1601     {
1602 nigel 93 i = GET(ecode, 1);
1603     while (i-- > 0)
1604 nigel 77 {
1605     eptr--;
1606 ph10 510 if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1607 ph10 207 BACKCHAR(eptr);
1608 nigel 77 }
1609     }
1610     else
1611     #endif
1612    
1613     /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
1614    
1615     {
1616 nigel 93 eptr -= GET(ecode, 1);
1617 ph10 510 if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1618 nigel 77 }
1619    
1620 ph10 435 /* Save the earliest consulted character, then skip to next op code */
1621 nigel 77
1622 ph10 435 if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
1623 nigel 77 ecode += 1 + LINK_SIZE;
1624     break;
1625    
1626     /* The callout item calls an external function, if one is provided, passing
1627     details of the match so far. This is mainly for debugging, though the
1628     function is able to force a failure. */
1629    
1630     case OP_CALLOUT:
1631     if (pcre_callout != NULL)
1632     {
1633     pcre_callout_block cb;
1634 ph10 645 cb.version = 2; /* Version 1 of the callout block */
1635 nigel 77 cb.callout_number = ecode[1];
1636     cb.offset_vector = md->offset_vector;
1637 nigel 87 cb.subject = (PCRE_SPTR)md->start_subject;
1638 ph10 530 cb.subject_length = (int)(md->end_subject - md->start_subject);
1639     cb.start_match = (int)(mstart - md->start_subject);
1640     cb.current_position = (int)(eptr - md->start_subject);
1641 nigel 77 cb.pattern_position = GET(ecode, 2);
1642     cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1643     cb.capture_top = offset_top/2;
1644     cb.capture_last = md->capture_last;
1645     cb.callout_data = md->callout_data;
1646 ph10 654 cb.mark = markptr;
1647 ph10 510 if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1648 nigel 77 if (rrc < 0) RRETURN(rrc);
1649     }
1650     ecode += 2 + 2*LINK_SIZE;
1651     break;
1652    
1653     /* Recursion either matches the current regex, or some subexpression. The
1654     offset data is the offset to the starting bracket from the start of the
1655     whole pattern. (This is so that it works from duplicated subpatterns.)
1656 ph10 625
1657 ph10 618 The state of the capturing groups is preserved over recursion, and
1658 ph10 625 re-instated afterwards. We don't know how many are started and not yet
1659 ph10 618 finished (offset_top records the completed total) so we just have to save
1660     all the potential data. There may be up to 65535 such values, which is too
1661     large to put on the stack, but using malloc for small numbers seems
1662     expensive. As a compromise, the stack is used when there are no more than
1663     REC_STACK_SAVE_MAX values to store; otherwise malloc is used.
1664 nigel 77
1665     There are also other values that have to be saved. We use a chained
1666     sequence of blocks that actually live on the stack. Thanks to Robin Houston
1667 ph10 625 for the original version of this logic. It has, however, been hacked around
1668 ph10 618 a lot, so he is not to blame for the current way it works. */
1669 nigel 77
1670     case OP_RECURSE:
1671     {
1672 ph10 642 recursion_info *ri;
1673     int recno;
1674 ph10 654
1675 nigel 77 callpat = md->start_code + GET(ecode, 1);
1676 ph10 642 recno = (callpat == md->start_code)? 0 :
1677 ph10 654 GET2(callpat, 1 + LINK_SIZE);
1678    
1679     /* Check for repeating a recursion without advancing the subject pointer.
1680 ph10 642 This should catch convoluted mutual recursions. (Some simple cases are
1681 ph10 654 caught at compile time.) */
1682    
1683 ph10 642 for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
1684 ph10 654 if (recno == ri->group_num && eptr == ri->subject_position)
1685 ph10 642 RRETURN(PCRE_ERROR_RECURSELOOP);
1686 nigel 77
1687     /* Add to "recursing stack" */
1688    
1689 ph10 642 new_recursive.group_num = recno;
1690     new_recursive.subject_position = eptr;
1691 nigel 77 new_recursive.prevrec = md->recursive;
1692     md->recursive = &new_recursive;
1693    
1694 ph10 618 /* Where to continue from afterwards */
1695 nigel 77
1696     ecode += 1 + LINK_SIZE;
1697    
1698 ph10 618 /* Now save the offset data */
1699 nigel 77
1700     new_recursive.saved_max = md->offset_end;
1701     if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
1702     new_recursive.offset_save = stacksave;
1703     else
1704     {
1705     new_recursive.offset_save =
1706     (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));
1707     if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
1708     }
1709     memcpy(new_recursive.offset_save, md->offset_vector,
1710     new_recursive.saved_max * sizeof(int));
1711 ph10 625
1712 ph10 618 /* OK, now we can do the recursion. After processing each alternative,
1713 ph10 625 restore the offset data. If there were nested recursions, md->recursive
1714 ph10 618 might be changed, so reset it before looping. */
1715 nigel 77
1716     DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
1717 ph10 604 cbegroup = (*callpat >= OP_SBRA);
1718 nigel 77 do
1719     {
1720 ph10 604 if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
1721 ph10 164 RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1722 ph10 604 md, eptrb, RM6);
1723 ph10 618 memcpy(md->offset_vector, new_recursive.offset_save,
1724     new_recursive.saved_max * sizeof(int));
1725 ph10 681 md->recursive = new_recursive.prevrec;
1726 ph10 511 if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1727 nigel 77 {
1728 nigel 87 DPRINTF(("Recursion matched\n"));
1729 nigel 77 if (new_recursive.offset_save != stacksave)
1730     (pcre_free)(new_recursive.offset_save);
1731 ph10 618
1732     /* Set where we got to in the subject, and reset the start in case
1733 ph10 625 it was changed by \K. This *is* propagated back out of a recursion,
1734     for Perl compatibility. */
1735    
1736 ph10 618 eptr = md->end_match_ptr;
1737     mstart = md->start_match_ptr;
1738     goto RECURSION_MATCHED; /* Exit loop; end processing */
1739 nigel 77 }
1740 ph10 716
1741     /* PCRE does not allow THEN to escape beyond a recursion; it is treated
1742     as NOMATCH. */
1743    
1744 ph10 733 else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1745 nigel 87 {
1746     DPRINTF(("Recursion gave error %d\n", rrc));
1747 ph10 400 if (new_recursive.offset_save != stacksave)
1748     (pcre_free)(new_recursive.offset_save);
1749 nigel 87 RRETURN(rrc);
1750     }
1751 nigel 77
1752     md->recursive = &new_recursive;
1753     callpat += GET(callpat, 1);
1754     }
1755     while (*callpat == OP_ALT);
1756    
1757     DPRINTF(("Recursion didn't match\n"));
1758     md->recursive = new_recursive.prevrec;
1759     if (new_recursive.offset_save != stacksave)
1760     (pcre_free)(new_recursive.offset_save);
1761 ph10 510 MRRETURN(MATCH_NOMATCH);
1762 nigel 77 }
1763 ph10 625
1764 ph10 618 RECURSION_MATCHED:
1765     break;
1766 nigel 77
1767     /* An alternation is the end of a branch; scan along to find the end of the
1768     bracketed group and go to there. */
1769    
1770     case OP_ALT:
1771     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1772     break;
1773    
1774 ph10 335 /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1775     indicating that it may occur zero times. It may repeat infinitely, or not
1776     at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
1777     with fixed upper repeat limits are compiled as a number of copies, with the
1778     optional ones preceded by BRAZERO or BRAMINZERO. */
1779 ph10 625
1780 nigel 77 case OP_BRAZERO:
1781 ph10 604 next = ecode + 1;
1782     RMATCH(eptr, next, offset_top, md, eptrb, RM10);
1783     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1784     do next += GET(next, 1); while (*next == OP_ALT);
1785     ecode = next + 1 + LINK_SIZE;
1786 nigel 77 break;
1787 ph10 625
1788 nigel 77 case OP_BRAMINZERO:
1789 ph10 604 next = ecode + 1;
1790     do next += GET(next, 1); while (*next == OP_ALT);
1791     RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, RM11);
1792     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1793     ecode++;
1794 nigel 77 break;
1795    
1796 ph10 335 case OP_SKIPZERO:
1797 ph10 604 next = ecode+1;
1798     do next += GET(next,1); while (*next == OP_ALT);
1799     ecode = next + 1 + LINK_SIZE;
1800 ph10 335 break;
1801 ph10 625
1802 ph10 604 /* BRAPOSZERO occurs before a possessive bracket group. Don't do anything
1803     here; just jump to the group, with allow_zero set TRUE. */
1804 ph10 625
1805 ph10 604 case OP_BRAPOSZERO:
1806 ph10 625 op = *(++ecode);
1807 ph10 604 allow_zero = TRUE;
1808     if (op == OP_CBRAPOS || op == OP_SCBRAPOS) goto POSSESSIVE_CAPTURE;
1809     goto POSSESSIVE_NON_CAPTURE;
1810 ph10 335
1811 nigel 93 /* End of a group, repeated or non-repeating. */
1812 nigel 77
1813     case OP_KET:
1814     case OP_KETRMIN:
1815     case OP_KETRMAX:
1816 ph10 625 case OP_KETRPOS:
1817 nigel 91 prev = ecode - GET(ecode, 1);
1818 ph10 625
1819 nigel 93 /* If this was a group that remembered the subject start, in order to break
1820     infinite repeats of empty string matches, retrieve the subject start from
1821     the chain. Otherwise, set it NULL. */
1822 nigel 77
1823 ph10 618 if (*prev >= OP_SBRA || *prev == OP_ONCE)
1824 nigel 93 {
1825     saved_eptr = eptrb->epb_saved_eptr; /* Value at start of group */
1826     eptrb = eptrb->epb_prev; /* Backup to previous group */
1827     }
1828     else saved_eptr = NULL;
1829 nigel 77
1830 ph10 733 /* If we are at the end of an assertion group or a non-capturing atomic
1831 ph10 723 group, stop matching and return MATCH_MATCH, but record the current high
1832     water mark for use by positive assertions. We also need to record the match
1833     start in case it was changed by \K. */
1834 nigel 93
1835 ph10 723 if ((*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT) ||
1836 ph10 733 *prev == OP_ONCE_NC)
1837 nigel 91 {
1838 ph10 723 md->end_match_ptr = eptr; /* For ONCE_NC */
1839 nigel 91 md->end_offset_top = offset_top;
1840 ph10 500 md->start_match_ptr = mstart;
1841 ph10 630 MRRETURN(MATCH_MATCH); /* Sets md->mark */
1842 nigel 91 }
1843 nigel 77
1844 nigel 93 /* For capturing groups we have to check the group number back at the start
1845     and if necessary complete handling an extraction by setting the offsets and
1846 ph10 618 bumping the high water mark. Whole-pattern recursion is coded as a recurse
1847     into group 0, so it won't be picked up here. Instead, we catch it when the
1848     OP_END is reached. Other recursion is handled here. We just have to record
1849     the current subject position and start match pointer and give a MATCH
1850     return. */
1851 nigel 77
1852 ph10 604 if (*prev == OP_CBRA || *prev == OP_SCBRA ||
1853     *prev == OP_CBRAPOS || *prev == OP_SCBRAPOS)
1854 nigel 91 {
1855 nigel 93 number = GET2(prev, 1+LINK_SIZE);
1856 nigel 91 offset = number << 1;
1857 ph10 461
1858 ph10 475 #ifdef PCRE_DEBUG
1859 nigel 91 printf("end bracket %d", number);
1860     printf("\n");
1861 nigel 77 #endif
1862    
1863 ph10 618 /* Handle a recursively called group. */
1864    
1865     if (md->recursive != NULL && md->recursive->group_num == number)
1866     {
1867     md->end_match_ptr = eptr;
1868     md->start_match_ptr = mstart;
1869     RRETURN(MATCH_MATCH);
1870     }
1871    
1872     /* Deal with capturing */
1873    
1874 nigel 93 md->capture_last = number;
1875     if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1876 nigel 91 {
1877 ph10 625 /* If offset is greater than offset_top, it means that we are
1878     "skipping" a capturing group, and that group's offsets must be marked
1879     unset. In earlier versions of PCRE, all the offsets were unset at the
1880     start of matching, but this doesn't work because atomic groups and
1881 ph10 615 assertions can cause a value to be set that should later be unset.
1882     Example: matching /(?>(a))b|(a)c/ against "ac". This sets group 1 as
1883 ph10 625 part of the atomic group, but this is not on the final matching path,
1884     so must be unset when 2 is set. (If there is no group 2, there is no
1885 ph10 615 problem, because offset_top will then be 2, indicating no capture.) */
1886 ph10 625
1887 ph10 615 if (offset > offset_top)
1888     {
1889     register int *iptr = md->offset_vector + offset_top;
1890     register int *iend = md->offset_vector + offset;
1891     while (iptr < iend) *iptr++ = -1;
1892 ph10 625 }
1893    
1894 ph10 615 /* Now make the extraction */
1895    
1896 nigel 93 md->offset_vector[offset] =
1897     md->offset_vector[md->offset_end - number];
1898 ph10 530 md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1899 nigel 93 if (offset_top <= offset) offset_top = offset + 2;
1900     }
1901 nigel 91 }
1902 nigel 77
1903 ph10 618 /* For an ordinary non-repeating ket, just continue at this level. This
1904     also happens for a repeating ket if no characters were matched in the
1905     group. This is the forcible breaking of infinite loops as implemented in
1906 ph10 723 Perl 5.005. For a non-repeating atomic group that includes captures,
1907     establish a backup point by processing the rest of the pattern at a lower
1908     level. If this results in a NOMATCH return, pass MATCH_ONCE back to the
1909     original OP_ONCE level, thereby bypassing intermediate backup points, but
1910     resetting any captures that happened along the way. */
1911 nigel 77
1912 nigel 91 if (*ecode == OP_KET || eptr == saved_eptr)
1913     {
1914 ph10 618 if (*prev == OP_ONCE)
1915     {
1916     RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM12);
1917     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1918     md->once_target = prev; /* Level at which to change to MATCH_NOMATCH */
1919 ph10 625 RRETURN(MATCH_ONCE);
1920     }
1921 ph10 618 ecode += 1 + LINK_SIZE; /* Carry on at this level */
1922 nigel 91 break;
1923     }
1924 ph10 625
1925     /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
1926 ph10 604 and return the MATCH_KETRPOS. This makes it possible to do the repeats one
1927     at a time from the outer level, thus saving stack. */
1928 ph10 625
1929 ph10 604 if (*ecode == OP_KETRPOS)
1930 ph10 625 {
1931 ph10 604 md->end_match_ptr = eptr;
1932 ph10 625 md->end_offset_top = offset_top;
1933 ph10 604 RRETURN(MATCH_KETRPOS);
1934 ph10 625 }
1935 nigel 77
1936 ph10 604 /* The normal repeating kets try the rest of the pattern or restart from
1937     the preceding bracket, in the appropriate order. In the second case, we can
1938     use tail recursion to avoid using another stack frame, unless we have an
1939 ph10 618 an atomic group or an unlimited repeat of a group that can match an empty
1940     string. */
1941 nigel 77
1942 nigel 91 if (*ecode == OP_KETRMIN)
1943     {
1944 ph10 623 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM7);
1945 nigel 91 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1946 ph10 618 if (*prev == OP_ONCE)
1947     {
1948 ph10 623 RMATCH(eptr, prev, offset_top, md, eptrb, RM8);
1949 ph10 618 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1950     md->once_target = prev; /* Level at which to change to MATCH_NOMATCH */
1951 ph10 625 RRETURN(MATCH_ONCE);
1952     }
1953 ph10 604 if (*prev >= OP_SBRA) /* Could match an empty string */
1954 ph10 197 {
1955 ph10 625 md->match_function_type = MATCH_CBEGROUP;
1956 ph10 604 RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
1957 ph10 197 RRETURN(rrc);
1958     }
1959 nigel 91 ecode = prev;
1960     goto TAIL_RECURSE;
1961 nigel 77 }
1962 nigel 91 else /* OP_KETRMAX */
1963     {
1964 ph10 625 if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1965 ph10 604 RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
1966 ph10 618 if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
1967 nigel 91 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1968 ph10 618 if (*prev == OP_ONCE)
1969     {
1970 ph10 623 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM9);
1971 ph10 618 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1972     md->once_target = prev;
1973 ph10 625 RRETURN(MATCH_ONCE);
1974     }
1975 nigel 91 ecode += 1 + LINK_SIZE;
1976     goto TAIL_RECURSE;
1977     }
1978     /* Control never gets here */
1979 nigel 77
1980 ph10 602 /* Not multiline mode: start of subject assertion, unless notbol. */
1981 nigel 77
1982     case OP_CIRC:
1983 ph10 510 if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1984 ph10 625
1985 nigel 77 /* Start of subject assertion */
1986    
1987     case OP_SOD:
1988 ph10 510 if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1989 nigel 77 ecode++;
1990     break;
1991 ph10 625
1992 ph10 602 /* Multiline mode: start of subject unless notbol, or after any newline. */
1993 nigel 77
1994 ph10 602 case OP_CIRCM:
1995     if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1996     if (eptr != md->start_subject &&
1997     (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1998     MRRETURN(MATCH_NOMATCH);
1999     ecode++;
2000     break;
2001    
2002 nigel 77 /* Start of match assertion */
2003    
2004     case OP_SOM:
2005 ph10 510 if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
2006 nigel 77 ecode++;
2007     break;
2008 ph10 172
2009 ph10 168 /* Reset the start of match point */
2010 ph10 172
2011 ph10 168 case OP_SET_SOM:
2012     mstart = eptr;
2013 ph10 172 ecode++;
2014     break;
2015 nigel 77
2016 ph10 602 /* Multiline mode: assert before any newline, or before end of subject
2017     unless noteol is set. */
2018 nigel 77
2019 ph10 602 case OP_DOLLM:
2020     if (eptr < md->end_subject)
2021     { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
2022     else
2023 nigel 77 {
2024 ph10 510 if (md->noteol) MRRETURN(MATCH_NOMATCH);
2025 ph10 602 SCHECK_PARTIAL();
2026 nigel 77 }
2027 ph10 602 ecode++;
2028     break;
2029 ph10 579
2030 ph10 625 /* Not multiline mode: assert before a terminating newline or before end of
2031 ph10 602 subject unless noteol is set. */
2032    
2033     case OP_DOLL:
2034     if (md->noteol) MRRETURN(MATCH_NOMATCH);
2035     if (!md->endonly) goto ASSERT_NL_OR_EOS;
2036    
2037 nigel 91 /* ... else fall through for endonly */
2038 nigel 77
2039     /* End of subject assertion (\z) */
2040    
2041     case OP_EOD:
2042 ph10 510 if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
2043 ph10 553 SCHECK_PARTIAL();
2044 nigel 77 ecode++;
2045     break;
2046    
2047     /* End of subject or ending \n assertion (\Z) */
2048    
2049     case OP_EODN:
2050 ph10 553 ASSERT_NL_OR_EOS:
2051     if (eptr < md->end_subject &&
2052 nigel 93 (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2053 ph10 510 MRRETURN(MATCH_NOMATCH);
2054 ph10 579
2055 ph10 553 /* Either at end of string or \n before end. */
2056 ph10 579
2057 ph10 553 SCHECK_PARTIAL();
2058 nigel 77 ecode++;
2059     break;
2060    
2061     /* Word boundary assertions */
2062    
2063     case OP_NOT_WORD_BOUNDARY:
2064     case OP_WORD_BOUNDARY:
2065     {
2066    
2067     /* Find out if the previous and current characters are "word" characters.
2068     It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
2069 ph10 443 be "non-word" characters. Remember the earliest consulted character for
2070 ph10 435 partial matching. */
2071 nigel 77
2072     #ifdef SUPPORT_UTF8
2073     if (utf8)
2074     {
2075 ph10 518 /* Get status of previous character */
2076 ph10 527
2077 nigel 77 if (eptr == md->start_subject) prev_is_word = FALSE; else
2078     {
2079 ph10 409 USPTR lastptr = eptr - 1;
2080 nigel 77 while((*lastptr & 0xc0) == 0x80) lastptr--;
2081 ph10 443 if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
2082 nigel 77 GETCHAR(c, lastptr);
2083 ph10 527 #ifdef SUPPORT_UCP
2084 ph10 518 if (md->use_ucp)
2085     {
2086     if (c == '_') prev_is_word = TRUE; else
2087 ph10 527 {
2088 ph10 518 int cat = UCD_CATEGORY(c);
2089     prev_is_word = (cat == ucp_L || cat == ucp_N);
2090 ph10 527 }
2091     }
2092     else
2093     #endif
2094 nigel 77 prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
2095     }
2096 ph10 527
2097 ph10 518 /* Get status of next character */
2098 ph10 527
2099 ph10 443 if (eptr >= md->end_subject)
2100 nigel 77 {
2101 ph10 443 SCHECK_PARTIAL();
2102     cur_is_word = FALSE;
2103 ph10 428 }
2104     else
2105     {
2106 nigel 77 GETCHAR(c, eptr);
2107 ph10 527 #ifdef SUPPORT_UCP
2108 ph10 518 if (md->use_ucp)
2109     {
2110     if (c == '_') cur_is_word = TRUE; else
2111 ph10 527 {
2112 ph10 518 int cat = UCD_CATEGORY(c);
2113     cur_is_word = (cat == ucp_L || cat == ucp_N);
2114 ph10 527 }
2115     }
2116     else
2117     #endif
2118 nigel 77 cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
2119     }
2120     }
2121     else
2122     #endif
2123    
2124 ph10 527 /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
2125 ph10 518 consistency with the behaviour of \w we do use it in this case. */
2126 nigel 77
2127     {
2128 ph10 518 /* Get status of previous character */
2129 ph10 527
2130 ph10 435 if (eptr == md->start_subject) prev_is_word = FALSE; else
2131     {
2132 ph10 443 if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
2133 ph10 527 #ifdef SUPPORT_UCP
2134 ph10 518 if (md->use_ucp)
2135     {
2136 ph10 527 c = eptr[-1];
2137 ph10 518 if (c == '_') prev_is_word = TRUE; else
2138 ph10 527 {
2139 ph10 518 int cat = UCD_CATEGORY(c);
2140     prev_is_word = (cat == ucp_L || cat == ucp_N);
2141 ph10 527 }
2142     }
2143     else
2144     #endif
2145 ph10 435 prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
2146     }
2147 ph10 527
2148 ph10 518 /* Get status of next character */
2149 ph10 527
2150 ph10 443 if (eptr >= md->end_subject)
2151 ph10 428 {
2152 ph10 443 SCHECK_PARTIAL();
2153     cur_is_word = FALSE;
2154 ph10 428 }
2155 ph10 527 else
2156     #ifdef SUPPORT_UCP
2157 ph10 518 if (md->use_ucp)
2158     {
2159 ph10 527 c = *eptr;
2160 ph10 518 if (c == '_') cur_is_word = TRUE; else
2161 ph10 527 {
2162 ph10 518 int cat = UCD_CATEGORY(c);
2163     cur_is_word = (cat == ucp_L || cat == ucp_N);
2164 ph10 527 }
2165     }
2166     else
2167     #endif
2168 ph10 518 cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
2169 nigel 77 }
2170    
2171     /* Now see if the situation is what we want */
2172    
2173     if ((*ecode++ == OP_WORD_BOUNDARY)?
2174     cur_is_word == prev_is_word : cur_is_word != prev_is_word)
2175 ph10 510 MRRETURN(MATCH_NOMATCH);
2176 nigel 77 }
2177     break;
2178    
2179     /* Match a single character type; inline for speed */
2180    
2181     case OP_ANY:
2182 ph10 510 if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
2183 ph10 345 /* Fall through */
2184    
2185 ph10 341 case OP_ALLANY:
2186 ph10 648 if (eptr >= md->end_subject) /* DO NOT merge the eptr++ here; it must */
2187     { /* not be updated before SCHECK_PARTIAL. */
2188 ph10 443 SCHECK_PARTIAL();
2189 ph10 510 MRRETURN(MATCH_NOMATCH);
2190 ph10 443 }
2191 ph10 648 eptr++;
2192 ph10 342 if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
2193 nigel 77 ecode++;
2194     break;
2195    
2196     /* Match a single byte, even in UTF-8 mode. This opcode really does match
2197     any byte, even newline, independent of the setting of PCRE_DOTALL. */
2198    
2199     case OP_ANYBYTE:
2200 ph10 648 if (eptr >= md->end_subject) /* DO NOT merge the eptr++ here; it must */
2201     { /* not be updated before SCHECK_PARTIAL. */
2202 ph10 443 SCHECK_PARTIAL();
2203 ph10 510 MRRETURN(MATCH_NOMATCH);
2204 ph10 443 }
2205 ph10 654 eptr++;
2206 nigel 77 ecode++;
2207     break;
2208    
2209     case OP_NOT_DIGIT:
2210 ph10 443 if (eptr >= md->end_subject)
2211 ph10 428 {
2212 ph10 443 SCHECK_PARTIAL();
2213 ph10 510 MRRETURN(MATCH_NOMATCH);
2214 ph10 443 }
2215 nigel 77 GETCHARINCTEST(c, eptr);
2216     if (
2217     #ifdef SUPPORT_UTF8
2218     c < 256 &&
2219     #endif
2220     (md->ctypes[c] & ctype_digit) != 0
2221     )
2222 ph10 510 MRRETURN(MATCH_NOMATCH);
2223 nigel 77 ecode++;
2224     break;
2225    
2226     case OP_DIGIT:
2227 ph10 443 if (eptr >= md->end_subject)
2228 ph10 428 {
2229 ph10 443 SCHECK_PARTIAL();
2230 ph10 510 MRRETURN(MATCH_NOMATCH);
2231 ph10 443 }
2232 nigel 77 GETCHARINCTEST(c, eptr);
2233     if (
2234     #ifdef SUPPORT_UTF8
2235     c >= 256 ||
2236     #endif
2237     (md->ctypes[c] & ctype_digit) == 0
2238     )
2239 ph10 510 MRRETURN(MATCH_NOMATCH);
2240 nigel 77 ecode++;
2241     break;
2242    
2243     case OP_NOT_WHITESPACE:
2244 ph10 443 if (eptr >= md->end_subject)
2245 ph10 428 {
2246 ph10 443 SCHECK_PARTIAL();
2247 ph10 510 MRRETURN(MATCH_NOMATCH);
2248 ph10 443 }
2249 nigel 77 GETCHARINCTEST(c, eptr);
2250     if (
2251     #ifdef SUPPORT_UTF8
2252     c < 256 &&
2253     #endif
2254     (md->ctypes[c] & ctype_space) != 0
2255     )
2256 ph10 510 MRRETURN(MATCH_NOMATCH);
2257 nigel 77 ecode++;
2258     break;
2259    
2260     case OP_WHITESPACE:
2261 ph10 443 if (eptr >= md->end_subject)
2262 ph10 428 {
2263 ph10 443 SCHECK_PARTIAL();
2264 ph10 510 MRRETURN(MATCH_NOMATCH);
2265 ph10 443 }
2266 nigel 77 GETCHARINCTEST(c, eptr);
2267     if (
2268     #ifdef SUPPORT_UTF8
2269     c >= 256 ||
2270     #endif
2271     (md->ctypes[c] & ctype_space) == 0
2272     )
2273 ph10 510 MRRETURN(MATCH_NOMATCH);
2274 nigel 77 ecode++;
2275     break;
2276    
2277     case OP_NOT_WORDCHAR:
2278 ph10 443 if (eptr >= md->end_subject)
2279 ph10 428 {
2280 ph10 443 SCHECK_PARTIAL();
2281 ph10 510 MRRETURN(MATCH_NOMATCH);
2282 ph10 443 }
2283 nigel 77 GETCHARINCTEST(c, eptr);
2284     if (
2285     #ifdef SUPPORT_UTF8
2286     c < 256 &&
2287     #endif
2288     (md->ctypes[c] & ctype_word) != 0
2289     )
2290 ph10 510 MRRETURN(MATCH_NOMATCH);
2291 nigel 77 ecode++;
2292     break;
2293    
2294     case OP_WORDCHAR:
2295 ph10 443 if (eptr >= md->end_subject)
2296 ph10 428 {
2297 ph10 443 SCHECK_PARTIAL();
2298 ph10 510 MRRETURN(MATCH_NOMATCH);
2299 ph10 443 }
2300 nigel 77 GETCHARINCTEST(c, eptr);
2301     if (
2302     #ifdef SUPPORT_UTF8
2303     c >= 256 ||
2304     #endif
2305     (md->ctypes[c] & ctype_word) == 0
2306     )
2307 ph10 510 MRRETURN(MATCH_NOMATCH);
2308 nigel 77 ecode++;
2309     break;
2310    
2311 nigel 93 case OP_ANYNL:
2312 ph10 443 if (eptr >= md->end_subject)
2313 ph10 428 {
2314 ph10 443 SCHECK_PARTIAL();
2315 ph10 510 MRRETURN(MATCH_NOMATCH);
2316 ph10 443 }
2317 nigel 93 GETCHARINCTEST(c, eptr);
2318     switch(c)
2319     {
2320 ph10 510 default: MRRETURN(MATCH_NOMATCH);
2321 ph10 625
2322 nigel 93 case 0x000d:
2323     if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
2324     break;
2325 ph10 231
2326 nigel 93 case 0x000a:
2327 ph10 231 break;
2328    
2329 nigel 93 case 0x000b:
2330     case 0x000c:
2331     case 0x0085:
2332     case 0x2028:
2333     case 0x2029:
2334 ph10 510 if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
2335 nigel 93 break;
2336     }
2337     ecode++;
2338     break;
2339    
2340 ph10 178 case OP_NOT_HSPACE:
2341 ph10 443 if (eptr >= md->end_subject)
2342 ph10 428 {
2343 ph10 443 SCHECK_PARTIAL();
2344 ph10 510 MRRETURN(MATCH_NOMATCH);
2345 ph10 443 }
2346 ph10 178 GETCHARINCTEST(c, eptr);
2347     switch(c)
2348     {
2349     default: break;
2350     case 0x09: /* HT */
2351     case 0x20: /* SPACE */
2352     case 0xa0: /* NBSP */
2353     case 0x1680: /* OGHAM SPACE MARK */
2354     case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
2355     case 0x2000: /* EN QUAD */
2356     case 0x2001: /* EM QUAD */
2357     case 0x2002: /* EN SPACE */
2358     case 0x2003: /* EM SPACE */
2359     case 0x2004: /* THREE-PER-EM SPACE */
2360     case 0x2005: /* FOUR-PER-EM SPACE */
2361     case 0x2006: /* SIX-PER-EM SPACE */
2362     case 0x2007: /* FIGURE SPACE */
2363     case 0x2008: /* PUNCTUATION SPACE */
2364     case 0x2009: /* THIN SPACE */
2365     case 0x200A: /* HAIR SPACE */
2366     case 0x202f: /* NARROW NO-BREAK SPACE */
2367     case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
2368     case 0x3000: /* IDEOGRAPHIC SPACE */
2369 ph10 510 MRRETURN(MATCH_NOMATCH);
2370 ph10 178 }
2371     ecode++;
2372     break;
2373    
2374     case OP_HSPACE:
2375 ph10 443 if (eptr >= md->end_subject)
2376 ph10 428 {
2377 ph10 443 SCHECK_PARTIAL();
2378 ph10 510 MRRETURN(MATCH_NOMATCH);
2379 ph10 443 }
2380 ph10 178 GETCHARINCTEST(c, eptr);
2381     switch(c)
2382     {
2383 ph10 510 default: MRRETURN(MATCH_NOMATCH);
2384 ph10 178 case 0x09: /* HT */
2385     case 0x20: /* SPACE */
2386     case 0xa0: /* NBSP */
2387     case 0x1680: /* OGHAM SPACE MARK */
2388     case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
2389     case 0x2000: /* EN QUAD */
2390     case 0x2001: /* EM QUAD */
2391     case 0x2002: /* EN SPACE */
2392     case 0x2003: /* EM SPACE */
2393     case 0x2004: /* THREE-PER-EM SPACE */
2394     case 0x2005: /* FOUR-PER-EM SPACE */
2395     case 0x2006: /* SIX-PER-EM SPACE */
2396     case 0x2007: /* FIGURE SPACE */
2397     case 0x2008: /* PUNCTUATION SPACE */
2398     case 0x2009: /* THIN SPACE */
2399     case 0x200A: /* HAIR SPACE */
2400     case 0x202f: /* NARROW NO-BREAK SPACE */
2401     case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
2402     case 0x3000: /* IDEOGRAPHIC SPACE */
2403     break;
2404     }
2405     ecode++;
2406     break;
2407    
2408     case OP_NOT_VSPACE:
2409 ph10 443 if (eptr >= md->end_subject)
2410 ph10 428 {
2411 ph10 443 SCHECK_PARTIAL();
2412 ph10 510 MRRETURN(MATCH_NOMATCH);
2413 ph10 443 }
2414 ph10 178 GETCHARINCTEST(c, eptr);
2415     switch(c)
2416     {
2417     default: break;
2418     case 0x0a: /* LF */
2419     case 0x0b: /* VT */
2420     case 0x0c: /* FF */
2421     case 0x0d: /* CR */
2422     case 0x85: /* NEL */
2423     case 0x2028: /* LINE SEPARATOR */
2424     case 0x2029: /* PARAGRAPH SEPARATOR */
2425 ph10 510 MRRETURN(MATCH_NOMATCH);
2426 ph10 178 }
2427     ecode++;
2428     break;
2429    
2430     case OP_VSPACE:
2431 ph10 443 if (eptr >= md->end_subject)
2432 ph10 428 {
2433 ph10 443 SCHECK_PARTIAL();
2434 ph10 510 MRRETURN(MATCH_NOMATCH);
2435 ph10 443 }
2436 ph10 178 GETCHARINCTEST(c, eptr);
2437     switch(c)
2438     {
2439 ph10 510 default: MRRETURN(MATCH_NOMATCH);
2440 ph10 178 case 0x0a: /* LF */
2441     case 0x0b: /* VT */
2442     case 0x0c: /* FF */
2443     case 0x0d: /* CR */
2444     case 0x85: /* NEL */
2445     case 0x2028: /* LINE SEPARATOR */
2446     case 0x2029: /* PARAGRAPH SEPARATOR */
2447     break;
2448     }
2449     ecode++;
2450     break;
2451    
2452 nigel 77 #ifdef SUPPORT_UCP
2453     /* Check the next character by Unicode property. We will get here only
2454     if the support is in the binary; otherwise a compile-time error occurs. */
2455    
2456     case OP_PROP:
2457     case OP_NOTPROP:
2458 ph10 443 if (eptr >= md->end_subject)
2459 ph10 428 {
2460 ph10 443 SCHECK_PARTIAL();
2461 ph10 510 MRRETURN(MATCH_NOMATCH);
2462 ph10 443 }
2463 nigel 77 GETCHARINCTEST(c, eptr);
2464     {
2465 ph10 384 const ucd_record *prop = GET_UCD(c);
2466 nigel 77
2467 nigel 87 switch(ecode[1])
2468     {
2469     case PT_ANY:
2470 ph10 510 if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2471 nigel 87 break;
2472 nigel 77
2473 nigel 87 case PT_LAMP:
2474 ph10 349 if ((prop->chartype == ucp_Lu ||
2475     prop->chartype == ucp_Ll ||
2476     prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2477 ph10 510 MRRETURN(MATCH_NOMATCH);
2478 ph10 517 break;
2479 nigel 87
2480     case PT_GC:
2481 ph10 351 if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2482 ph10 510 MRRETURN(MATCH_NOMATCH);
2483 nigel 87 break;
2484    
2485     case PT_PC:
2486 ph10 349 if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2487 ph10 510 MRRETURN(MATCH_NOMATCH);
2488 nigel 87 break;
2489    
2490     case PT_SC:
2491 ph10 349 if ((ecode[2] != prop->script) == (op == OP_PROP))
2492 ph10 510 MRRETURN(MATCH_NOMATCH);
2493 nigel 87 break;
2494 ph10 527
2495 ph10 517 /* These are specials */
2496 ph10 527
2497 ph10 517 case PT_ALNUM:
2498     if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2499     _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2500     MRRETURN(MATCH_NOMATCH);
2501 ph10 527 break;
2502    
2503 ph10 517 case PT_SPACE: /* Perl space */
2504     if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2505     c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2506     == (op == OP_NOTPROP))
2507     MRRETURN(MATCH_NOMATCH);
2508 ph10 527 break;
2509    
2510 ph10 517 case PT_PXSPACE: /* POSIX space */
2511     if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2512 ph10 527 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2513 ph10 517 c == CHAR_FF || c == CHAR_CR)
2514     == (op == OP_NOTPROP))
2515     MRRETURN(MATCH_NOMATCH);
2516 ph10 527 break;
2517 nigel 87
2518 ph10 527 case PT_WORD:
2519 ph10 517 if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2520 ph10 527 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2521 ph10 517 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2522     MRRETURN(MATCH_NOMATCH);
2523 ph10 527 break;
2524    
2525 ph10 517 /* This should never occur */
2526    
2527 nigel 87 default:
2528     RRETURN(PCRE_ERROR_INTERNAL);
2529 nigel 77 }
2530 nigel 87
2531     ecode += 3;
2532 nigel 77 }
2533     break;
2534    
2535     /* Match an extended Unicode sequence. We will get here only if the support
2536     is in the binary; otherwise a compile-time error occurs. */
2537    
2538     case OP_EXTUNI:
2539 ph10 443 if (eptr >= md->end_subject)
2540 ph10 428 {
2541 ph10 443 SCHECK_PARTIAL();
2542 ph10 510 MRRETURN(MATCH_NOMATCH);
2543 ph10 443 }
2544 nigel 77 GETCHARINCTEST(c, eptr);
2545 ph10 623 if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);
2546     while (eptr < md->end_subject)
2547 nigel 77 {
2548 ph10 623 int len = 1;
2549     if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2550     if (UCD_CATEGORY(c) != ucp_M) break;
2551     eptr += len;
2552 nigel 77 }
2553     ecode++;
2554     break;
2555     #endif
2556    
2557    
2558     /* Match a back reference, possibly repeatedly. Look past the end of the
2559     item to see if there is repeat information following. The code is similar
2560     to that for character classes, but repeated for efficiency. Then obey
2561     similar code to character type repeats - written out again for speed.
2562     However, if the referenced string is the empty string, always treat
2563     it as matched, any number of times (otherwise there could be infinite
2564     loops). */
2565    
2566     case OP_REF:
2567 ph10 625 case OP_REFI:
2568     caseless = op == OP_REFI;
2569 ph10 595 offset = GET2(ecode, 1) << 1; /* Doubled ref number */
2570     ecode += 3;
2571 ph10 345
2572 ph10 595 /* If the reference is unset, there are two possibilities:
2573 ph10 345
2574 ph10 595 (a) In the default, Perl-compatible state, set the length negative;
2575     this ensures that every attempt at a match fails. We can't just fail
2576     here, because of the possibility of quantifiers with zero minima.
2577 ph10 345
2578 ph10 595 (b) If the JavaScript compatibility flag is set, set the length to zero
2579     so that the back reference matches an empty string.
2580 ph10 345
2581 ph10 595 Otherwise, set the length to the length of what was matched by the
2582     referenced subpattern. */
2583 ph10 345
2584 ph10 595 if (offset >= offset_top || md->offset_vector[offset] < 0)
2585     length = (md->jscript_compat)? 0 : -1;
2586     else
2587     length = md->offset_vector[offset+1] - md->offset_vector[offset];
2588 nigel 77
2589 ph10 595 /* Set up for repetition, or handle the non-repeated case */
2590 nigel 77
2591 ph10 595 switch (*ecode)
2592     {
2593     case OP_CRSTAR:
2594     case OP_CRMINSTAR:
2595     case OP_CRPLUS:
2596     case OP_CRMINPLUS:
2597     case OP_CRQUERY:
2598     case OP_CRMINQUERY:
2599     c = *ecode++ - OP_CRSTAR;
2600     minimize = (c & 1) != 0;
2601     min = rep_min[c]; /* Pick up values from tables; */
2602     max = rep_max[c]; /* zero for max => infinity */
2603     if (max == 0) max = INT_MAX;
2604     break;
2605 nigel 77
2606 ph10 595 case OP_CRRANGE:
2607     case OP_CRMINRANGE:
2608     minimize = (*ecode == OP_CRMINRANGE);
2609     min = GET2(ecode, 1);
2610     max = GET2(ecode, 3);
2611     if (max == 0) max = INT_MAX;
2612     ecode += 5;
2613     break;
2614 nigel 77
2615 ph10 595 default: /* No repeat follows */
2616 ph10 602 if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2617 ph10 595 {
2618     CHECK_PARTIAL();
2619     MRRETURN(MATCH_NOMATCH);
2620 nigel 77 }
2621 ph10 595 eptr += length;
2622     continue; /* With the main loop */
2623     }
2624 nigel 77
2625 ph10 595 /* Handle repeated back references. If the length of the reference is
2626     zero, just continue with the main loop. */
2627 ph10 443
2628 ph10 595 if (length == 0) continue;
2629 nigel 77
2630 ph10 595 /* First, ensure the minimum number of matches are present. We get back
2631     the length of the reference string explicitly rather than passing the
2632     address of eptr, so that eptr can be a register variable. */
2633 nigel 77
2634 ph10 595 for (i = 1; i <= min; i++)
2635     {
2636 ph10 625 int slength;
2637 ph10 602 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2638 nigel 77 {
2639 ph10 595 CHECK_PARTIAL();
2640     MRRETURN(MATCH_NOMATCH);
2641 nigel 77 }
2642 ph10 595 eptr += slength;
2643     }
2644 nigel 77
2645 ph10 595 /* If min = max, continue at the same level without recursion.
2646     They are not both allowed to be zero. */
2647 nigel 77
2648 ph10 595 if (min == max) continue;
2649 nigel 77
2650 ph10 595 /* If minimizing, keep trying and advancing the pointer */
2651 nigel 77
2652 ph10 595 if (minimize)
2653     {
2654     for (fi = min;; fi++)
2655 nigel 77 {
2656 ph10 625 int slength;
2657 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
2658 ph10 595 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2659     if (fi >= max) MRRETURN(MATCH_NOMATCH);
2660 ph10 602 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2661 nigel 77 {
2662 ph10 595 CHECK_PARTIAL();
2663     MRRETURN(MATCH_NOMATCH);
2664 nigel 77 }
2665 ph10 595 eptr += slength;
2666 nigel 77 }
2667 ph10 595 /* Control never gets here */
2668     }
2669 nigel 77
2670 ph10 595 /* If maximizing, find the longest string and work backwards */
2671 nigel 77
2672 ph10 595 else
2673     {
2674     pp = eptr;
2675     for (i = min; i < max; i++)
2676 nigel 77 {
2677 ph10 625 int slength;
2678 ph10 602 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2679 nigel 77 {
2680 ph10 595 CHECK_PARTIAL();
2681     break;
2682 nigel 77 }
2683 ph10 595 eptr += slength;
2684 nigel 77 }
2685 ph10 595 while (eptr >= pp)
2686     {
2687 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
2688 ph10 595 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2689     eptr -= length;
2690     }
2691     MRRETURN(MATCH_NOMATCH);
2692 nigel 77 }
2693     /* Control never gets here */
2694    
2695     /* Match a bit-mapped character class, possibly repeatedly. This op code is
2696     used when all the characters in the class have values in the range 0-255,
2697     and either the matching is caseful, or the characters are in the range
2698     0-127 when UTF-8 processing is enabled. The only difference between
2699     OP_CLASS and OP_NCLASS occurs when a data character outside the range is
2700     encountered.
2701    
2702     First, look past the end of the item to see if there is repeat information
2703     following. Then obey similar code to character type repeats - written out
2704     again for speed. */
2705    
2706     case OP_NCLASS:
2707     case OP_CLASS:
2708     {
2709     data = ecode + 1; /* Save for matching */
2710     ecode += 33; /* Advance past the item */
2711    
2712     switch (*ecode)
2713     {
2714     case OP_CRSTAR:
2715     case OP_CRMINSTAR:
2716     case OP_CRPLUS:
2717     case OP_CRMINPLUS:
2718     case OP_CRQUERY:
2719     case OP_CRMINQUERY:
2720     c = *ecode++ - OP_CRSTAR;
2721     minimize = (c & 1) != 0;
2722     min = rep_min[c]; /* Pick up values from tables; */
2723     max = rep_max[c]; /* zero for max => infinity */
2724     if (max == 0) max = INT_MAX;
2725     break;
2726    
2727     case OP_CRRANGE:
2728     case OP_CRMINRANGE:
2729     minimize = (*ecode == OP_CRMINRANGE);
2730     min = GET2(ecode, 1);
2731     max = GET2(ecode, 3);
2732     if (max == 0) max = INT_MAX;
2733     ecode += 5;
2734     break;
2735    
2736     default: /* No repeat follows */
2737     min = max = 1;
2738     break;
2739     }
2740    
2741     /* First, ensure the minimum number of matches are present. */
2742    
2743     #ifdef SUPPORT_UTF8
2744     /* UTF-8 mode */
2745     if (utf8)
2746     {
2747     for (i = 1; i <= min; i++)
2748     {
2749 ph10 427 if (eptr >= md->end_subject)
2750 ph10 426 {
2751 ph10 428 SCHECK_PARTIAL();
2752 ph10 510 MRRETURN(MATCH_NOMATCH);
2753 ph10 427 }
2754 nigel 77 GETCHARINC(c, eptr);
2755     if (c > 255)
2756     {
2757 ph10 510 if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2758 nigel 77 }
2759     else
2760     {
2761 ph10 510 if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2762 nigel 77 }
2763     }
2764     }
2765     else
2766     #endif
2767     /* Not UTF-8 mode */
2768     {
2769     for (i = 1; i <= min; i++)
2770     {
2771 ph10 427 if (eptr >= md->end_subject)
2772 ph10 426 {
2773 ph10 428 SCHECK_PARTIAL();
2774 ph10 510 MRRETURN(MATCH_NOMATCH);
2775 ph10 427 }
2776 nigel 77 c = *eptr++;
2777 ph10 510 if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2778 nigel 77 }
2779     }
2780    
2781     /* If max == min we can continue with the main loop without the
2782     need to recurse. */
2783    
2784     if (min == max) continue;
2785    
2786     /* If minimizing, keep testing the rest of the expression and advancing
2787     the pointer while it matches the class. */
2788    
2789     if (minimize)
2790     {
2791     #ifdef SUPPORT_UTF8
2792     /* UTF-8 mode */
2793     if (utf8)
2794     {
2795     for (fi = min;; fi++)
2796     {
2797 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);
2798 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2799 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
2800 ph10 427 if (eptr >= md->end_subject)
2801 ph10 426 {
2802 ph10 427 SCHECK_PARTIAL();
2803 ph10 510 MRRETURN(MATCH_NOMATCH);
2804 ph10 427 }
2805 nigel 77 GETCHARINC(c, eptr);
2806     if (c > 255)
2807     {
2808 ph10 510 if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2809 nigel 77 }
2810     else
2811     {
2812 ph10 510 if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2813 nigel 77 }
2814     }
2815     }
2816     else
2817     #endif
2818     /* Not UTF-8 mode */
2819     {
2820     for (fi = min;; fi++)
2821     {
2822 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
2823 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2824 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
2825 ph10 427 if (eptr >= md->end_subject)
2826 ph10 426 {
2827 ph10 427 SCHECK_PARTIAL();
2828 ph10 510 MRRETURN(MATCH_NOMATCH);
2829 ph10 427 }
2830 nigel 77 c = *eptr++;
2831 ph10 510 if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2832 nigel 77 }
2833     }
2834     /* Control never gets here */
2835     }
2836    
2837     /* If maximizing, find the longest possible run, then work backwards. */
2838    
2839     else
2840     {
2841     pp = eptr;
2842    
2843     #ifdef SUPPORT_UTF8
2844     /* UTF-8 mode */
2845     if (utf8)
2846     {
2847     for (i = min; i < max; i++)
2848     {
2849     int len = 1;
2850 ph10 463 if (eptr >= md->end_subject)
2851 ph10 462 {
2852 ph10 463 SCHECK_PARTIAL();
2853 ph10 462 break;
2854 ph10 463 }
2855 nigel 77 GETCHARLEN(c, eptr, len);
2856     if (c > 255)
2857     {
2858     if (op == OP_CLASS) break;
2859     }
2860     else
2861     {
2862     if ((data[c/8] & (1 << (c&7))) == 0) break;
2863     }
2864     eptr += len;
2865     }
2866     for (;;)
2867     {
2868 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);
2869 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2870     if (eptr-- == pp) break; /* Stop if tried at original pos */
2871     BACKCHAR(eptr);
2872     }
2873     }
2874     else
2875     #endif
2876     /* Not UTF-8 mode */
2877     {
2878     for (i = min; i < max; i++)
2879     {
2880 ph10 463 if (eptr >= md->end_subject)
2881 ph10 462 {
2882 ph10 463 SCHECK_PARTIAL();
2883 ph10 462 break;
2884 ph10 463 }
2885 nigel 77 c = *eptr;
2886     if ((data[c/8] & (1 << (c&7))) == 0) break;
2887     eptr++;
2888     }
2889     while (eptr >= pp)
2890     {
2891 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);
2892 nigel 87 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2893 nigel 77 eptr--;
2894     }
2895     }
2896    
2897 ph10 510 MRRETURN(MATCH_NOMATCH);
2898 nigel 77 }
2899     }
2900     /* Control never gets here */
2901    
2902    
2903     /* Match an extended character class. This opcode is encountered only
2904 ph10 384 when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
2905     mode, because Unicode properties are supported in non-UTF-8 mode. */
2906 nigel 77
2907     #ifdef SUPPORT_UTF8
2908     case OP_XCLASS:
2909     {
2910     data = ecode + 1 + LINK_SIZE; /* Save for matching */
2911     ecode += GET(ecode, 1); /* Advance past the item */
2912    
2913     switch (*ecode)
2914     {
2915     case OP_CRSTAR:
2916     case OP_CRMINSTAR:
2917     case OP_CRPLUS:
2918     case OP_CRMINPLUS:
2919     case OP_CRQUERY:
2920     case OP_CRMINQUERY:
2921     c = *ecode++ - OP_CRSTAR;
2922     minimize = (c & 1) != 0;
2923     min = rep_min[c]; /* Pick up values from tables; */
2924     max = rep_max[c]; /* zero for max => infinity */
2925     if (max == 0) max = INT_MAX;
2926     break;
2927    
2928     case OP_CRRANGE:
2929     case OP_CRMINRANGE:
2930     minimize = (*ecode == OP_CRMINRANGE);
2931     min = GET2(ecode, 1);
2932     max = GET2(ecode, 3);
2933     if (max == 0) max = INT_MAX;
2934     ecode += 5;
2935     break;
2936    
2937     default: /* No repeat follows */
2938     min = max = 1;
2939     break;
2940     }
2941    
2942     /* First, ensure the minimum number of matches are present. */
2943    
2944     for (i = 1; i <= min; i++)
2945     {
2946 ph10 427 if (eptr >= md->end_subject)
2947 ph10 426 {
2948     SCHECK_PARTIAL();
2949 ph10 510 MRRETURN(MATCH_NOMATCH);
2950 ph10 427 }
2951 ph10 384 GETCHARINCTEST(c, eptr);
2952 ph10 510 if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2953 nigel 77 }
2954    
2955     /* If max == min we can continue with the main loop without the
2956     need to recurse. */
2957    
2958     if (min == max) continue;
2959    
2960     /* If minimizing, keep testing the rest of the expression and advancing
2961     the pointer while it matches the class. */
2962    
2963     if (minimize)
2964     {
2965     for (fi = min;; fi++)
2966     {
2967 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);
2968 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2969 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
2970 ph10 427 if (eptr >= md->end_subject)
2971 ph10 426 {
2972 ph10 427 SCHECK_PARTIAL();
2973 ph10 510 MRRETURN(MATCH_NOMATCH);
2974 ph10 427 }
2975 ph10 384 GETCHARINCTEST(c, eptr);
2976 ph10 510 if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2977 nigel 77 }
2978     /* Control never gets here */
2979     }
2980    
2981     /* If maximizing, find the longest possible run, then work backwards. */
2982    
2983     else
2984     {
2985     pp = eptr;
2986     for (i = min; i < max; i++)
2987     {
2988     int len = 1;
2989 ph10 463 if (eptr >= md->end_subject)
2990 ph10 462 {
2991 ph10 463 SCHECK_PARTIAL();
2992 ph10 462 break;
2993 ph10 463 }
2994 ph10 384 GETCHARLENTEST(c, eptr, len);
2995 nigel 77 if (!_pcre_xclass(c, data)) break;
2996     eptr += len;
2997     }
2998     for(;;)
2999     {
3000 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);
3001 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3002     if (eptr-- == pp) break; /* Stop if tried at original pos */
3003 ph10 214 if (utf8) BACKCHAR(eptr);
3004 nigel 77 }
3005 ph10 510 MRRETURN(MATCH_NOMATCH);
3006 nigel 77 }
3007    
3008     /* Control never gets here */
3009     }
3010     #endif /* End of XCLASS */
3011    
3012     /* Match a single character, casefully */
3013    
3014     case OP_CHAR:
3015     #ifdef SUPPORT_UTF8
3016     if (utf8)
3017     {
3018     length = 1;
3019     ecode++;
3020     GETCHARLEN(fc, ecode, length);
3021 ph10 443 if (length > md->end_subject - eptr)
3022 ph10 428 {
3023     CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */
3024 ph10 510 MRRETURN(MATCH_NOMATCH);
3025 ph10 443 }
3026 ph10 510 while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
3027 nigel 77 }
3028     else
3029     #endif
3030    
3031     /* Non-UTF-8 mode */
3032     {
3033 ph10 443 if (md->end_subject - eptr < 1)
3034 ph10 428 {
3035     SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */
3036 ph10 510 MRRETURN(MATCH_NOMATCH);
3037 ph10 443 }
3038 ph10 510 if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
3039 nigel 77 ecode += 2;
3040     }
3041     break;
3042    
3043     /* Match a single character, caselessly */
3044    
3045 ph10 602 case OP_CHARI:
3046 nigel 77 #ifdef SUPPORT_UTF8
3047     if (utf8)
3048     {
3049     length = 1;
3050     ecode++;
3051     GETCHARLEN(fc, ecode, length);
3052    
3053 ph10 443 if (length > md->end_subject - eptr)
3054 ph10 428 {
3055     CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */
3056 ph10 510 MRRETURN(MATCH_NOMATCH);
3057 ph10 443 }
3058 nigel 77
3059     /* If the pattern character's value is < 128, we have only one byte, and
3060     can use the fast lookup table. */
3061    
3062     if (fc < 128)
3063     {
3064 ph10 510 if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3065 nigel 77 }
3066    
3067     /* Otherwise we must pick up the subject character */
3068    
3069     else
3070     {
3071 nigel 93 unsigned int dc;
3072 nigel 77 GETCHARINC(dc, eptr);
3073     ecode += length;
3074    
3075     /* If we have Unicode property support, we can use it to test the other
3076 nigel 87 case of the character, if there is one. */
3077 nigel 77
3078     if (fc != dc)
3079     {
3080     #ifdef SUPPORT_UCP
3081 ph10 349 if (dc != UCD_OTHERCASE(fc))
3082 nigel 77 #endif
3083 ph10 510 MRRETURN(MATCH_NOMATCH);
3084 nigel 77 }
3085     }
3086     }
3087     else
3088     #endif /* SUPPORT_UTF8 */
3089    
3090     /* Non-UTF-8 mode */
3091     {
3092 ph10 443 if (md->end_subject - eptr < 1)
3093 ph10 428 {
3094 ph10 443 SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */
3095 ph10 510 MRRETURN(MATCH_NOMATCH);
3096 ph10 443 }
3097 ph10 510 if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3098 nigel 77 ecode += 2;
3099     }
3100     break;
3101    
3102 nigel 93 /* Match a single character repeatedly. */
3103 nigel 77
3104     case OP_EXACT:
3105 ph10 602 case OP_EXACTI:
3106 nigel 77 min = max = GET2(ecode, 1);
3107     ecode += 3;
3108     goto REPEATCHAR;
3109    
3110 nigel 93 case OP_POSUPTO:
3111 ph10 602 case OP_POSUPTOI:
3112 nigel 93 possessive = TRUE;
3113     /* Fall through */
3114    
3115 nigel 77 case OP_UPTO:
3116 ph10 602 case OP_UPTOI:
3117 nigel 77 case OP_MINUPTO:
3118 ph10 602 case OP_MINUPTOI:
3119 nigel 77 min = 0;
3120     max = GET2(ecode, 1);
3121 ph10 602 minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;
3122 nigel 77 ecode += 3;
3123     goto REPEATCHAR;
3124    
3125 nigel 93 case OP_POSSTAR:
3126 ph10 602 case OP_POSSTARI:
3127 nigel 93 possessive = TRUE;
3128     min = 0;
3129     max = INT_MAX;
3130     ecode++;
3131     goto REPEATCHAR;
3132    
3133     case OP_POSPLUS:
3134 ph10 602 case OP_POSPLUSI:
3135 nigel 93 possessive = TRUE;
3136     min = 1;
3137     max = INT_MAX;
3138     ecode++;
3139     goto REPEATCHAR;
3140    
3141     case OP_POSQUERY:
3142 ph10 602 case OP_POSQUERYI:
3143 nigel 93 possessive = TRUE;
3144     min = 0;
3145     max = 1;
3146     ecode++;
3147     goto REPEATCHAR;
3148    
3149 nigel 77 case OP_STAR:
3150 ph10 602 case OP_STARI:
3151 nigel 77 case OP_MINSTAR:
3152 ph10 602 case OP_MINSTARI:
3153 nigel 77 case OP_PLUS:
3154 ph10 602 case OP_PLUSI:
3155 nigel 77 case OP_MINPLUS:
3156 ph10 602 case OP_MINPLUSI:
3157 nigel 77 case OP_QUERY:
3158 ph10 602 case OP_QUERYI:
3159 nigel 77 case OP_MINQUERY:
3160 ph10 602 case OP_MINQUERYI:
3161     c = *ecode++ - ((op < OP_STARI)? OP_STAR : OP_STARI);
3162 nigel 77 minimize = (c & 1) != 0;
3163     min = rep_min[c]; /* Pick up values from tables; */
3164     max = rep_max[c]; /* zero for max => infinity */
3165     if (max == 0) max = INT_MAX;
3166    
3167 ph10 426 /* Common code for all repeated single-character matches. */
3168 nigel 77
3169     REPEATCHAR:
3170     #ifdef SUPPORT_UTF8
3171     if (utf8)
3172     {
3173     length = 1;
3174     charptr = ecode;
3175     GETCHARLEN(fc, ecode, length);
3176     ecode += length;
3177    
3178     /* Handle multibyte character matching specially here. There is
3179     support for caseless matching if UCP support is present. */
3180    
3181     if (length > 1)
3182     {
3183     #ifdef SUPPORT_UCP
3184 nigel 93 unsigned int othercase;
3185 ph10 602 if (op >= OP_STARI && /* Caseless */
3186 ph10 349 (othercase = UCD_OTHERCASE(fc)) != fc)
3187 nigel 77 oclength = _pcre_ord2utf8(othercase, occhars);
3188 ph10 115 else oclength = 0;
3189 nigel 77 #endif /* SUPPORT_UCP */
3190    
3191     for (i = 1; i <= min; i++)
3192     {
3193 ph10 426 if (eptr <= md->end_subject - length &&
3194     memcmp(eptr, charptr, length) == 0) eptr += length;
3195 ph10 123 #ifdef SUPPORT_UCP
3196 ph10 426 else if (oclength > 0 &&
3197     eptr <= md->end_subject - oclength &&
3198     memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
3199     #endif /* SUPPORT_UCP */
3200 nigel 77 else
3201     {
3202 ph10 426 CHECK_PARTIAL();
3203 ph10 510 MRRETURN(MATCH_NOMATCH);
3204 nigel 77 }
3205     }
3206    
3207     if (min == max) continue;
3208    
3209     if (minimize)
3210     {
3211     for (fi = min;; fi++)
3212     {
3213 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);
3214 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3215 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3216 ph10 426 if (eptr <= md->end_subject - length &&
3217     memcmp(eptr, charptr, length) == 0) eptr += length;
3218 ph10 123 #ifdef SUPPORT_UCP
3219 ph10 426 else if (oclength > 0 &&
3220     eptr <= md->end_subject - oclength &&
3221     memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
3222     #endif /* SUPPORT_UCP */
3223 nigel 77 else
3224     {
3225 ph10 426 CHECK_PARTIAL();
3226 ph10 510 MRRETURN(MATCH_NOMATCH);
3227 nigel 77 }
3228     }
3229     /* Control never gets here */
3230     }
3231 nigel 93
3232     else /* Maximize */
3233 nigel 77 {
3234     pp = eptr;
3235     for (i = min; i < max; i++)
3236     {
3237 ph10 426 if (eptr <= md->end_subject - length &&
3238     memcmp(eptr, charptr, length) == 0) eptr += length;
3239 ph10 123 #ifdef SUPPORT_UCP
3240 ph10 426 else if (oclength > 0 &&
3241     eptr <= md->end_subject - oclength &&
3242     memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
3243     #endif /* SUPPORT_UCP */
3244 ph10 463 else
3245 ph10 462 {
3246 ph10 463 CHECK_PARTIAL();
3247 ph10 462 break;
3248 ph10 463 }
3249 nigel 77 }
3250 nigel 93
3251     if (possessive) continue;
3252 ph10 427
3253 ph10 120 for(;;)
3254 ph10 426 {
3255 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
3256 ph10 426 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3257 ph10 510 if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
3258 ph10 115 #ifdef SUPPORT_UCP
3259 ph10 426 eptr--;
3260     BACKCHAR(eptr);
3261 ph10 123 #else /* without SUPPORT_UCP */
3262 ph10 426 eptr -= length;
3263 ph10 123 #endif /* SUPPORT_UCP */
3264 ph10 426 }
3265 nigel 77 }
3266     /* Control never gets here */
3267     }
3268    
3269     /* If the length of a UTF-8 character is 1, we fall through here, and
3270     obey the code as for non-UTF-8 characters below, though in this case the
3271     value of fc will always be < 128. */
3272     }
3273     else
3274     #endif /* SUPPORT_UTF8 */
3275    
3276     /* When not in UTF-8 mode, load a single-byte character. */
3277    
3278 ph10 426 fc = *ecode++;
3279 ph10 443
3280 nigel 77 /* The value of fc at this point is always less than 256, though we may or
3281     may not be in UTF-8 mode. The code is duplicated for the caseless and
3282     caseful cases, for speed, since matching characters is likely to be quite
3283     common. First, ensure the minimum number of matches are present. If min =
3284     max, continue at the same level without recursing. Otherwise, if
3285     minimizing, keep trying the rest of the expression and advancing one
3286     matching character if failing, up to the maximum. Alternatively, if
3287     maximizing, find the maximum number of characters and work backwards. */
3288    
3289     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3290     max, eptr));
3291    
3292 ph10 602 if (op >= OP_STARI) /* Caseless */
3293 nigel 77 {
3294     fc = md->lcc[fc];
3295     for (i = 1; i <= min; i++)
3296 ph10 426 {
3297     if (eptr >= md->end_subject)
3298     {
3299     SCHECK_PARTIAL();
3300 ph10 510 MRRETURN(MATCH_NOMATCH);
3301 ph10 426 }
3302 ph10 510 if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3303 ph10 426 }
3304 nigel 77 if (min == max) continue;
3305     if (minimize)
3306     {
3307     for (fi = min;; fi++)
3308     {
3309 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3310 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3311 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3312 ph10 426 if (eptr >= md->end_subject)
3313     {
3314 ph10 427 SCHECK_PARTIAL();
3315 ph10 510 MRRETURN(MATCH_NOMATCH);
3316 ph10 426 }
3317 ph10 510 if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3318 nigel 77 }
3319     /* Control never gets here */
3320     }
3321 nigel 93 else /* Maximize */
3322 nigel 77 {
3323     pp = eptr;
3324     for (i = min; i < max; i++)
3325     {
3326 ph10 463 if (eptr >= md->end_subject)
3327 ph10 462 {
3328     SCHECK_PARTIAL();
3329     break;
3330 ph10 463 }
3331 ph10 462 if (fc != md->lcc[*eptr]) break;
3332 nigel 77 eptr++;
3333     }
3334 ph10 427
3335 nigel 93 if (possessive) continue;
3336 ph10 427
3337 nigel 77 while (eptr >= pp)
3338     {
3339 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM25);
3340 nigel 77 eptr--;
3341     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3342     }
3343 ph10 510 MRRETURN(MATCH_NOMATCH);
3344 nigel 77 }
3345     /* Control never gets here */
3346     }
3347    
3348     /* Caseful comparisons (includes all multi-byte characters) */
3349    
3350     else
3351     {
3352 ph10 427 for (i = 1; i <= min; i++)
3353 ph10 426 {
3354     if (eptr >= md->end_subject)
3355     {
3356     SCHECK_PARTIAL();
3357 ph10 510 MRRETURN(MATCH_NOMATCH);
3358 ph10 426 }
3359 ph10 510 if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3360 ph10 427 }
3361 ph10 443
3362 nigel 77 if (min == max) continue;
3363 ph10 443
3364 nigel 77 if (minimize)
3365     {
3366     for (fi = min;; fi++)
3367     {
3368 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
3369 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3370 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3371 ph10 426 if (eptr >= md->end_subject)
3372 ph10 427 {
3373 ph10 426 SCHECK_PARTIAL();
3374 ph10 510 MRRETURN(MATCH_NOMATCH);
3375 ph10 427 }
3376 ph10 510 if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3377 nigel 77 }
3378     /* Control never gets here */
3379     }
3380 nigel 93 else /* Maximize */
3381 nigel 77 {
3382     pp = eptr;
3383     for (i = min; i < max; i++)
3384     {
3385 ph10 463 if (eptr >= md->end_subject)
3386 ph10 462 {
3387 ph10 463 SCHECK_PARTIAL();
3388 ph10 462 break;
3389 ph10 463 }
3390 ph10 462 if (fc != *eptr) break;
3391 nigel 77 eptr++;
3392     }
3393 nigel 93 if (possessive) continue;
3394 ph10 443
3395 nigel 77 while (eptr >= pp)
3396     {
3397 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM27);
3398 nigel 77 eptr--;
3399     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3400     }
3401 ph10 510 MRRETURN(MATCH_NOMATCH);
3402 nigel 77 }
3403     }
3404     /* Control never gets here */
3405    
3406     /* Match a negated single one-byte character. The character we are
3407     checking can be multibyte. */
3408    
3409     case OP_NOT:
3410 ph10 625 case OP_NOTI:
3411 ph10 443 if (eptr >= md->end_subject)
3412 ph10 428 {
3413 ph10 443 SCHECK_PARTIAL();
3414 ph10 510 MRRETURN(MATCH_NOMATCH);
3415 ph10 443 }
3416 nigel 77 ecode++;
3417     GETCHARINCTEST(c, eptr);
3418 ph10 602 if (op == OP_NOTI) /* The caseless case */
3419 nigel 77 {
3420     #ifdef SUPPORT_UTF8
3421     if (c < 256)
3422     #endif
3423     c = md->lcc[c];
3424 ph10 510 if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3425 nigel 77 }
3426 ph10 602 else /* Caseful */
3427 nigel 77 {
3428 ph10 510 if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3429 nigel 77 }
3430     break;
3431    
3432     /* Match a negated single one-byte character repeatedly. This is almost a
3433     repeat of the code for a repeated single character, but I haven't found a
3434     nice way of commoning these up that doesn't require a test of the
3435     positive/negative option for each character match. Maybe that wouldn't add
3436     very much to the time taken, but character matching *is* what this is all
3437     about... */
3438    
3439     case OP_NOTEXACT:
3440 ph10 602 case OP_NOTEXACTI:
3441 nigel 77 min = max = GET2(ecode, 1);
3442     ecode += 3;
3443     goto REPEATNOTCHAR;
3444    
3445     case OP_NOTUPTO:
3446 ph10 602 case OP_NOTUPTOI:
3447 nigel 77 case OP_NOTMINUPTO:
3448 ph10 602 case OP_NOTMINUPTOI:
3449 nigel 77 min = 0;
3450     max = GET2(ecode, 1);
3451 ph10 602 minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;
3452 nigel 77 ecode += 3;
3453     goto REPEATNOTCHAR;
3454    
3455 nigel 93 case OP_NOTPOSSTAR:
3456 ph10 602 case OP_NOTPOSSTARI:
3457 nigel 93 possessive = TRUE;
3458     min = 0;
3459     max = INT_MAX;
3460     ecode++;
3461     goto REPEATNOTCHAR;
3462    
3463     case OP_NOTPOSPLUS:
3464 ph10 602 case OP_NOTPOSPLUSI:
3465 nigel 93 possessive = TRUE;
3466     min = 1;
3467     max = INT_MAX;
3468     ecode++;
3469     goto REPEATNOTCHAR;
3470    
3471     case OP_NOTPOSQUERY:
3472 ph10 602 case OP_NOTPOSQUERYI:
3473 nigel 93 possessive = TRUE;
3474     min = 0;
3475     max = 1;
3476     ecode++;
3477     goto REPEATNOTCHAR;
3478    
3479     case OP_NOTPOSUPTO:
3480 ph10 602 case OP_NOTPOSUPTOI:
3481 nigel 93 possessive = TRUE;
3482     min = 0;
3483     max = GET2(ecode, 1);
3484     ecode += 3;
3485     goto REPEATNOTCHAR;
3486    
3487 nigel 77 case OP_NOTSTAR:
3488 ph10 602 case OP_NOTSTARI:
3489 nigel 77 case OP_NOTMINSTAR:
3490 ph10 602 case OP_NOTMINSTARI:
3491 nigel 77 case OP_NOTPLUS:
3492 ph10 602 case OP_NOTPLUSI:
3493 nigel 77 case OP_NOTMINPLUS:
3494 ph10 602 case OP_NOTMINPLUSI:
3495 nigel 77 case OP_NOTQUERY:
3496 ph10 602 case OP_NOTQUERYI:
3497 nigel 77 case OP_NOTMINQUERY:
3498 ph10 602 case OP_NOTMINQUERYI:
3499     c = *ecode++ - ((op >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR);
3500 nigel 77 minimize = (c & 1) != 0;
3501     min = rep_min[c]; /* Pick up values from tables; */
3502     max = rep_max[c]; /* zero for max => infinity */
3503     if (max == 0) max = INT_MAX;
3504    
3505 ph10 426 /* Common code for all repeated single-byte matches. */
3506 nigel 77
3507     REPEATNOTCHAR:
3508     fc = *ecode++;
3509    
3510     /* The code is duplicated for the caseless and caseful cases, for speed,
3511     since matching characters is likely to be quite common. First, ensure the
3512     minimum number of matches are present. If min = max, continue at the same
3513     level without recursing. Otherwise, if minimizing, keep trying the rest of
3514     the expression and advancing one matching character if failing, up to the
3515     maximum. Alternatively, if maximizing, find the maximum number of
3516     characters and work backwards. */
3517    
3518     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3519     max, eptr));
3520    
3521 ph10 602 if (op >= OP_NOTSTARI) /* Caseless */
3522 nigel 77 {
3523     fc = md->lcc[fc];
3524    
3525     #ifdef SUPPORT_UTF8
3526     /* UTF-8 mode */
3527     if (utf8)
3528     {
3529 nigel 93 register unsigned int d;
3530 nigel 77 for (i = 1; i <= min; i++)
3531     {
3532 ph10 426 if (eptr >= md->end_subject)
3533     {
3534     SCHECK_PARTIAL();
3535 ph10 510 MRRETURN(MATCH_NOMATCH);
3536 ph10 427 }
3537 nigel 77 GETCHARINC(d, eptr);
3538     if (d < 256) d = md->lcc[d];
3539 ph10 510 if (fc == d) MRRETURN(MATCH_NOMATCH);
3540 nigel 77 }
3541     }
3542     else
3543     #endif
3544    
3545     /* Not UTF-8 mode */
3546     {
3547     for (i = 1; i <= min; i++)
3548 ph10 426 {
3549     if (eptr >= md->end_subject)
3550     {
3551     SCHECK_PARTIAL();
3552 ph10 510 MRRETURN(MATCH_NOMATCH);
3553 ph10 427 }
3554 ph10 510 if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3555 ph10 427 }
3556 nigel 77 }
3557    
3558     if (min == max) continue;
3559    
3560     if (minimize)
3561     {
3562     #ifdef SUPPORT_UTF8
3563     /* UTF-8 mode */
3564     if (utf8)
3565     {
3566 nigel 93 register unsigned int d;
3567 nigel 77 for (fi = min;; fi++)
3568     {
3569 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
3570 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3571 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3572 ph10 427 if (eptr >= md->end_subject)
3573 ph10 426 {
3574 ph10 427 SCHECK_PARTIAL();
3575 ph10 510 MRRETURN(MATCH_NOMATCH);
3576 ph10 427 }
3577 nigel 77 GETCHARINC(d, eptr);
3578     if (d < 256) d = md->lcc[d];
3579 ph10 510 if (fc == d) MRRETURN(MATCH_NOMATCH);
3580 nigel 77 }
3581     }
3582     else
3583     #endif
3584     /* Not UTF-8 mode */
3585     {
3586     for (fi = min;; fi++)
3587     {
3588 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
3589 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3590 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3591 ph10 426 if (eptr >= md->end_subject)
3592     {
3593     SCHECK_PARTIAL();
3594 ph10 510 MRRETURN(MATCH_NOMATCH);
3595 ph10 426 }
3596 ph10 510 if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3597 nigel 77 }
3598     }
3599     /* Control never gets here */
3600     }
3601    
3602     /* Maximize case */
3603    
3604     else
3605     {
3606     pp = eptr;
3607    
3608     #ifdef SUPPORT_UTF8
3609     /* UTF-8 mode */
3610     if (utf8)
3611     {
3612 nigel 93 register unsigned int d;
3613 nigel 77 for (i = min; i < max; i++)
3614     {
3615     int len = 1;
3616 ph10 463 if (eptr >= md->end_subject)
3617 ph10 462 {
3618 ph10 463 SCHECK_PARTIAL();
3619 ph10 462 break;
3620 ph10 463 }
3621 nigel 77 GETCHARLEN(d, eptr, len);
3622     if (d < 256) d = md->lcc[d];
3623     if (fc == d) break;
3624     eptr += len;
3625     }
3626 nigel 93 if (possessive) continue;
3627     for(;;)
3628 nigel 77 {
3629 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
3630 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3631     if (eptr-- == pp) break; /* Stop if tried at original pos */
3632     BACKCHAR(eptr);
3633     }
3634     }
3635     else
3636     #endif
3637     /* Not UTF-8 mode */
3638     {
3639     for (i = min; i < max; i++)
3640     {
3641 ph10 463 if (eptr >= md->end_subject)
3642 ph10 462 {
3643     SCHECK_PARTIAL();
3644     break;
3645 ph10 463 }
3646 ph10 462 if (fc == md->lcc[*eptr]) break;
3647 nigel 77 eptr++;
3648     }
3649 nigel 93 if (possessive) continue;
3650 nigel 77 while (eptr >= pp)
3651     {
3652 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM31);
3653 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3654     eptr--;
3655     }
3656     }
3657    
3658 ph10 510 MRRETURN(MATCH_NOMATCH);
3659 nigel 77 }
3660     /* Control never gets here */
3661     }
3662    
3663     /* Caseful comparisons */
3664    
3665     else
3666     {
3667     #ifdef SUPPORT_UTF8
3668     /* UTF-8 mode */
3669     if (utf8)
3670     {
3671 nigel 93 register unsigned int d;
3672 nigel 77 for (i = 1; i <= min; i++)
3673     {
3674 ph10 426 if (eptr >= md->end_subject)
3675     {
3676     SCHECK_PARTIAL();
3677 ph10 510 MRRETURN(MATCH_NOMATCH);
3678 ph10 427 }
3679 nigel 77 GETCHARINC(d, eptr);
3680 ph10 510 if (fc == d) MRRETURN(MATCH_NOMATCH);
3681 nigel 77 }
3682     }
3683     else
3684     #endif
3685     /* Not UTF-8 mode */
3686     {
3687     for (i = 1; i <= min; i++)
3688 ph10 426 {
3689     if (eptr >= md->end_subject)
3690     {
3691     SCHECK_PARTIAL();
3692 ph10 510 MRRETURN(MATCH_NOMATCH);
3693 ph10 427 }
3694 ph10 510 if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3695 ph10 427 }
3696 nigel 77 }
3697    
3698     if (min == max) continue;
3699    
3700     if (minimize)
3701     {
3702     #ifdef SUPPORT_UTF8
3703     /* UTF-8 mode */
3704     if (utf8)
3705     {
3706 nigel 93 register unsigned int d;
3707 nigel 77 for (fi = min;; fi++)
3708     {
3709 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
3710 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3711 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3712 ph10 427 if (eptr >= md->end_subject)
3713 ph10 426 {
3714 ph10 427 SCHECK_PARTIAL();
3715 ph10 510 MRRETURN(MATCH_NOMATCH);
3716 ph10 427 }
3717 nigel 77 GETCHARINC(d, eptr);
3718 ph10 510 if (fc == d) MRRETURN(MATCH_NOMATCH);
3719 nigel 77 }
3720     }
3721     else
3722     #endif
3723     /* Not UTF-8 mode */
3724     {
3725     for (fi = min;; fi++)
3726     {
3727 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
3728 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3729 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3730 ph10 426 if (eptr >= md->end_subject)
3731     {
3732     SCHECK_PARTIAL();
3733 ph10 510 MRRETURN(MATCH_NOMATCH);
3734 ph10 427 }
3735 ph10 510 if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3736 nigel 77 }
3737     }
3738     /* Control never gets here */
3739     }
3740    
3741     /* Maximize case */
3742    
3743     else
3744     {
3745     pp = eptr;
3746    
3747     #ifdef SUPPORT_UTF8
3748     /* UTF-8 mode */
3749     if (utf8)
3750     {
3751 nigel 93 register unsigned int d;
3752 nigel 77 for (i = min; i < max; i++)
3753     {
3754     int len = 1;
3755 ph10 463 if (eptr >= md->end_subject)
3756 ph10 462 {
3757 ph10 463 SCHECK_PARTIAL();
3758 ph10 462 break;
3759 ph10 463 }
3760 nigel 77 GETCHARLEN(d, eptr, len);
3761     if (fc == d) break;
3762     eptr += len;
3763     }
3764 nigel 93 if (possessive) continue;
3765 nigel 77 for(;;)
3766     {
3767 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM34);
3768 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3769     if (eptr-- == pp) break; /* Stop if tried at original pos */
3770     BACKCHAR(eptr);
3771     }
3772     }
3773     else
3774     #endif
3775     /* Not UTF-8 mode */
3776     {
3777     for (i = min; i < max; i++)
3778     {
3779 ph10 463 if (eptr >= md->end_subject)
3780 ph10 462 {
3781 ph10 463 SCHECK_PARTIAL();
3782 ph10 462 break;
3783 ph10 463 }
3784 ph10 462 if (fc == *eptr) break;
3785 nigel 77 eptr++;
3786     }
3787 nigel 93 if (possessive) continue;
3788 nigel 77 while (eptr >= pp)
3789     {
3790 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM35);
3791 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3792     eptr--;
3793     }
3794     }
3795    
3796 ph10 510 MRRETURN(MATCH_NOMATCH);
3797 nigel 77 }
3798     }
3799     /* Control never gets here */
3800    
3801     /* Match a single character type repeatedly; several different opcodes
3802     share code. This is very similar to the code for single characters, but we
3803     repeat it in the interests of efficiency. */
3804    
3805     case OP_TYPEEXACT:
3806     min = max = GET2(ecode, 1);
3807     minimize = TRUE;
3808     ecode += 3;
3809     goto REPEATTYPE;
3810    
3811     case OP_TYPEUPTO:
3812     case OP_TYPEMINUPTO:
3813     min = 0;
3814     max = GET2(ecode, 1);
3815     minimize = *ecode == OP_TYPEMINUPTO;
3816     ecode += 3;
3817     goto REPEATTYPE;
3818    
3819 nigel 93 case OP_TYPEPOSSTAR:
3820     possessive = TRUE;
3821     min = 0;
3822     max = INT_MAX;
3823     ecode++;
3824     goto REPEATTYPE;
3825    
3826     case OP_TYPEPOSPLUS:
3827     possessive = TRUE;
3828     min = 1;
3829     max = INT_MAX;
3830     ecode++;
3831     goto REPEATTYPE;
3832