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

Contents of /code/trunk/pcre_exec.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 721 - (hide annotations) (download)
Fri Oct 7 15:51:39 2011 UTC (2 years, 10 months ago) by ph10
File MIME type: text/plain
File size: 198354 byte(s)
Comment correction and minor code improvement.

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 623 RM61, RM62, RM63 };
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 716 RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,
791     md, eptrb, RM58);
792 ph10 510 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
793 ph10 716 md->start_match_ptr = ecode;
794     md->mark = ecode + 2;
795 ph10 212 RRETURN(MATCH_THEN);
796 ph10 211
797 ph10 604 /* Handle a capturing bracket, other than those that are possessive with an
798     unlimited repeat. If there is space in the offset vector, save the current
799     subject position in the working slot at the top of the vector. We mustn't
800     change the current values of the data slot, because they may be set from a
801     previous iteration of this group, and be referred to by a reference inside
802 ph10 625 the group. A failure to match might occur after the group has succeeded,
803 ph10 617 if something later on doesn't match. For this reason, we need to restore
804     the working value and also the values of the final offsets, in case they
805     were set by a previous iteration of the same bracket.
806 nigel 77
807 nigel 93 If there isn't enough space in the offset vector, treat this as if it were
808     a non-capturing bracket. Don't worry about setting the flag for the error
809     case here; that is handled in the code for KET. */
810 nigel 77
811 nigel 93 case OP_CBRA:
812     case OP_SCBRA:
813     number = GET2(ecode, 1+LINK_SIZE);
814 nigel 77 offset = number << 1;
815 ph10 625
816 ph10 475 #ifdef PCRE_DEBUG
817 nigel 93 printf("start bracket %d\n", number);
818     printf("subject=");
819 nigel 77 pchars(eptr, 16, TRUE, md);
820     printf("\n");
821     #endif
822    
823     if (offset < md->offset_max)
824     {
825     save_offset1 = md->offset_vector[offset];
826     save_offset2 = md->offset_vector[offset+1];
827     save_offset3 = md->offset_vector[md->offset_end - number];
828     save_capture_last = md->capture_last;
829    
830     DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
831 ph10 531 md->offset_vector[md->offset_end - number] =
832 ph10 530 (int)(eptr - md->start_subject);
833 nigel 77
834 ph10 604 for (;;)
835 nigel 77 {
836 ph10 625 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
837     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
838 ph10 604 eptrb, RM1);
839 ph10 618 if (rrc == MATCH_ONCE) break; /* Backing up through an atomic group */
840 ph10 716
841     /* If we backed up to a THEN, check whether it is within the current
842     branch by comparing the address of the THEN that is passed back with
843     the end of the branch. If it is within the current branch, and the
844     branch is one of two or more alternatives (it either starts or ends
845     with OP_ALT), we have reached the limit of THEN's action, so convert
846     the return code to NOMATCH, which will cause normal backtracking to
847     happen from now on. Otherwise, THEN is passed back to an outer
848     alternative. This implements Perl's treatment of parenthesized groups,
849     where a group not containing | does not affect the current alternative,
850     that is, (X) is NOT the same as (X|(*F)). */
851    
852     if (rrc == MATCH_THEN)
853     {
854     next = ecode + GET(ecode,1);
855     if (md->start_match_ptr < next &&
856     (*ecode == OP_ALT || *next == OP_ALT))
857     rrc = MATCH_NOMATCH;
858     }
859    
860     /* Anything other than NOMATCH is passed back. */
861    
862     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
863 nigel 77 md->capture_last = save_capture_last;
864     ecode += GET(ecode, 1);
865 ph10 625 if (*ecode != OP_ALT) break;
866 nigel 77 }
867    
868     DPRINTF(("bracket %d failed\n", number));
869     md->offset_vector[offset] = save_offset1;
870     md->offset_vector[offset+1] = save_offset2;
871     md->offset_vector[md->offset_end - number] = save_offset3;
872 ph10 625
873 ph10 716 /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
874 nigel 77
875 ph10 716 if (md->mark == NULL) md->mark = markptr;
876     RRETURN(rrc);
877 nigel 77 }
878    
879 ph10 197 /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
880     as a non-capturing bracket. */
881 nigel 77
882 ph10 197 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
883     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
884    
885 nigel 93 DPRINTF(("insufficient capture room: treat as non-capturing\n"));
886 nigel 77
887 ph10 197 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
888     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
889    
890 ph10 618 /* Non-capturing or atomic group, except for possessive with unlimited
891 ph10 708 repeat. Loop for all the alternatives.
892    
893 ph10 702 When we get to the final alternative within the brackets, we used to return
894     the result of a recursive call to match() whatever happened so it was
895     possible to reduce stack usage by turning this into a tail recursion,
896     except in the case of a possibly empty group. However, now that there is
897     the possiblity of (*THEN) occurring in the final alternative, this
898     optimization is no longer always possible.
899 ph10 625
900 ph10 708 We can optimize if we know there are no (*THEN)s in the pattern; at present
901     this is the best that can be done.
902    
903 ph10 625 MATCH_ONCE is returned when the end of an atomic group is successfully
904     reached, but subsequent matching fails. It passes back up the tree (causing
905     captured values to be reset) until the original atomic group level is
906 ph10 618 reached. This is tested by comparing md->once_target with the start of the
907     group. At this point, the return is converted into MATCH_NOMATCH so that
908     previous backup points can be taken. */
909 nigel 77
910 ph10 618 case OP_ONCE:
911 nigel 93 case OP_BRA:
912     case OP_SBRA:
913     DPRINTF(("start non-capturing bracket\n"));
914 ph10 618
915 nigel 91 for (;;)
916 nigel 77 {
917 ph10 618 if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;
918 ph10 702
919     /* If this is not a possibly empty group, and there are no (*THEN)s in
920 ph10 708 the pattern, and this is the final alternative, optimize as described
921 ph10 702 above. */
922    
923     else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
924     {
925     ecode += _pcre_OP_lengths[*ecode];
926     goto TAIL_RECURSE;
927 ph10 708 }
928 ph10 702
929     /* In all other cases, we have to make another call to match(). */
930    
931 ph10 708 RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
932 ph10 604 RM2);
933 ph10 716
934     /* See comment in the code for capturing groups above about handling
935     THEN. */
936    
937     if (rrc == MATCH_THEN)
938 ph10 625 {
939 ph10 716 next = ecode + GET(ecode,1);
940     if (md->start_match_ptr < next &&
941     (*ecode == OP_ALT || *next == OP_ALT))
942     rrc = MATCH_NOMATCH;
943     }
944    
945     if (rrc != MATCH_NOMATCH)
946     {
947 ph10 618 if (rrc == MATCH_ONCE)
948     {
949     const uschar *scode = ecode;
950     if (*scode != OP_ONCE) /* If not at start, find it */
951     {
952     while (*scode == OP_ALT) scode += GET(scode, 1);
953     scode -= GET(scode, 1);
954 ph10 625 }
955 ph10 618 if (md->once_target == scode) rrc = MATCH_NOMATCH;
956 ph10 625 }
957 ph10 550 RRETURN(rrc);
958 ph10 625 }
959 nigel 77 ecode += GET(ecode, 1);
960 ph10 625 if (*ecode != OP_ALT) break;
961 nigel 77 }
962 ph10 716
963     if (md->mark == NULL) md->mark = markptr;
964 ph10 609 RRETURN(MATCH_NOMATCH);
965    
966 ph10 625 /* Handle possessive capturing brackets with an unlimited repeat. We come
967 ph10 604 here from BRAZERO with allow_zero set TRUE. The offset_vector values are
968     handled similarly to the normal case above. However, the matching is
969     different. The end of these brackets will always be OP_KETRPOS, which
970     returns MATCH_KETRPOS without going further in the pattern. By this means
971     we can handle the group by iteration rather than recursion, thereby
972     reducing the amount of stack needed. */
973 ph10 625
974 ph10 604 case OP_CBRAPOS:
975     case OP_SCBRAPOS:
976     allow_zero = FALSE;
977 ph10 625
978 ph10 604 POSSESSIVE_CAPTURE:
979     number = GET2(ecode, 1+LINK_SIZE);
980     offset = number << 1;
981    
982     #ifdef PCRE_DEBUG
983     printf("start possessive bracket %d\n", number);
984     printf("subject=");
985     pchars(eptr, 16, TRUE, md);
986     printf("\n");
987     #endif
988    
989     if (offset < md->offset_max)
990     {
991     matched_once = FALSE;
992 ph10 625 code_offset = ecode - md->start_code;
993 ph10 604
994     save_offset1 = md->offset_vector[offset];
995     save_offset2 = md->offset_vector[offset+1];
996     save_offset3 = md->offset_vector[md->offset_end - number];
997     save_capture_last = md->capture_last;
998    
999     DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
1000 ph10 625
1001     /* Each time round the loop, save the current subject position for use
1002     when the group matches. For MATCH_MATCH, the group has matched, so we
1003     restart it with a new subject starting position, remembering that we had
1004     at least one match. For MATCH_NOMATCH, carry on with the alternatives, as
1005     usual. If we haven't matched any alternatives in any iteration, check to
1006     see if a previous iteration matched. If so, the group has matched;
1007     continue from afterwards. Otherwise it has failed; restore the previous
1008 ph10 604 capture values before returning NOMATCH. */
1009 ph10 625
1010 ph10 604 for (;;)
1011     {
1012     md->offset_vector[md->offset_end - number] =
1013     (int)(eptr - md->start_subject);
1014 ph10 625 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1015 ph10 604 RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
1016     eptrb, RM63);
1017     if (rrc == MATCH_KETRPOS)
1018     {
1019     offset_top = md->end_offset_top;
1020     eptr = md->end_match_ptr;
1021 ph10 625 ecode = md->start_code + code_offset;
1022 ph10 604 save_capture_last = md->capture_last;
1023 ph10 625 matched_once = TRUE;
1024     continue;
1025     }
1026 ph10 716
1027     /* See comment in the code for capturing groups above about handling
1028     THEN. */
1029    
1030     if (rrc == MATCH_THEN)
1031     {
1032     next = ecode + GET(ecode,1);
1033     if (md->start_match_ptr < next &&
1034     (*ecode == OP_ALT || *next == OP_ALT))
1035     rrc = MATCH_NOMATCH;
1036     }
1037    
1038     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1039 ph10 604 md->capture_last = save_capture_last;
1040     ecode += GET(ecode, 1);
1041 ph10 625 if (*ecode != OP_ALT) break;
1042 ph10 604 }
1043 ph10 610
1044 ph10 604 if (!matched_once)
1045 ph10 625 {
1046 ph10 604 md->offset_vector[offset] = save_offset1;
1047     md->offset_vector[offset+1] = save_offset2;
1048     md->offset_vector[md->offset_end - number] = save_offset3;
1049     }
1050 ph10 625
1051 ph10 716 if (md->mark == NULL) md->mark = markptr;
1052 ph10 604 if (allow_zero || matched_once)
1053 ph10 625 {
1054 ph10 604 ecode += 1 + LINK_SIZE;
1055     break;
1056 ph10 625 }
1057    
1058 ph10 604 RRETURN(MATCH_NOMATCH);
1059     }
1060 ph10 625
1061 ph10 604 /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
1062     as a non-capturing bracket. */
1063    
1064     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1065     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1066    
1067     DPRINTF(("insufficient capture room: treat as non-capturing\n"));
1068    
1069     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1070     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1071    
1072 ph10 625 /* Non-capturing possessive bracket with unlimited repeat. We come here
1073 ph10 604 from BRAZERO with allow_zero = TRUE. The code is similar to the above,
1074     without the capturing complication. It is written out separately for speed
1075     and cleanliness. */
1076    
1077     case OP_BRAPOS:
1078     case OP_SBRAPOS:
1079 ph10 625 allow_zero = FALSE;
1080    
1081 ph10 604 POSSESSIVE_NON_CAPTURE:
1082     matched_once = FALSE;
1083 ph10 625 code_offset = ecode - md->start_code;
1084 ph10 604
1085     for (;;)
1086     {
1087 ph10 625 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1088 ph10 604 RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
1089 ph10 609 eptrb, RM48);
1090 ph10 604 if (rrc == MATCH_KETRPOS)
1091     {
1092 ph10 610 offset_top = md->end_offset_top;
1093 ph10 604 eptr = md->end_match_ptr;
1094 ph10 625 ecode = md->start_code + code_offset;
1095     matched_once = TRUE;
1096     continue;
1097     }
1098 ph10 716
1099     /* See comment in the code for capturing groups above about handling
1100     THEN. */
1101    
1102     if (rrc == MATCH_THEN)
1103     {
1104     next = ecode + GET(ecode,1);
1105     if (md->start_match_ptr < next &&
1106     (*ecode == OP_ALT || *next == OP_ALT))
1107     rrc = MATCH_NOMATCH;
1108     }
1109    
1110     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1111 ph10 604 ecode += GET(ecode, 1);
1112 ph10 625 if (*ecode != OP_ALT) break;
1113 ph10 604 }
1114 ph10 625
1115     if (matched_once || allow_zero)
1116 ph10 604 {
1117     ecode += 1 + LINK_SIZE;
1118     break;
1119 ph10 625 }
1120 ph10 604 RRETURN(MATCH_NOMATCH);
1121    
1122     /* Control never reaches here. */
1123    
1124 nigel 77 /* Conditional group: compilation checked that there are no more than
1125     two branches. If the condition is false, skipping the first branch takes us
1126     past the end if there is only one branch, but that's OK because that is
1127 ph10 609 exactly what going to the ket would do. */
1128 nigel 77
1129     case OP_COND:
1130 nigel 93 case OP_SCOND:
1131 ph10 604 codelink = GET(ecode, 1);
1132 ph10 406
1133 ph10 381 /* Because of the way auto-callout works during compile, a callout item is
1134     inserted between OP_COND and an assertion condition. */
1135 ph10 392
1136 ph10 381 if (ecode[LINK_SIZE+1] == OP_CALLOUT)
1137     {
1138     if (pcre_callout != NULL)
1139     {
1140     pcre_callout_block cb;
1141 ph10 645 cb.version = 2; /* Version 1 of the callout block */
1142 ph10 381 cb.callout_number = ecode[LINK_SIZE+2];
1143     cb.offset_vector = md->offset_vector;
1144     cb.subject = (PCRE_SPTR)md->start_subject;
1145 ph10 530 cb.subject_length = (int)(md->end_subject - md->start_subject);
1146     cb.start_match = (int)(mstart - md->start_subject);
1147     cb.current_position = (int)(eptr - md->start_subject);
1148 ph10 381 cb.pattern_position = GET(ecode, LINK_SIZE + 3);
1149     cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
1150     cb.capture_top = offset_top/2;
1151     cb.capture_last = md->capture_last;
1152     cb.callout_data = md->callout_data;
1153 ph10 654 cb.mark = markptr;
1154 ph10 510 if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1155 ph10 381 if (rrc < 0) RRETURN(rrc);
1156     }
1157     ecode += _pcre_OP_lengths[OP_CALLOUT];
1158     }
1159 ph10 392
1160 ph10 399 condcode = ecode[LINK_SIZE+1];
1161 ph10 406
1162 ph10 381 /* Now see what the actual condition is */
1163 ph10 392
1164 ph10 459 if (condcode == OP_RREF || condcode == OP_NRREF) /* Recursion test */
1165 nigel 77 {
1166 ph10 459 if (md->recursive == NULL) /* Not recursing => FALSE */
1167     {
1168 ph10 461 condition = FALSE;
1169     ecode += GET(ecode, 1);
1170     }
1171 ph10 459 else
1172 ph10 461 {
1173 ph10 459 int recno = GET2(ecode, LINK_SIZE + 2); /* Recursion group number*/
1174     condition = (recno == RREF_ANY || recno == md->recursive->group_num);
1175 ph10 461
1176 ph10 459 /* If the test is for recursion into a specific subpattern, and it is
1177     false, but the test was set up by name, scan the table to see if the
1178     name refers to any other numbers, and test them. The condition is true
1179     if any one is set. */
1180 ph10 461
1181 ph10 459 if (!condition && condcode == OP_NRREF && recno != RREF_ANY)
1182     {
1183     uschar *slotA = md->name_table;
1184     for (i = 0; i < md->name_count; i++)
1185 ph10 461 {
1186     if (GET2(slotA, 0) == recno) break;
1187 ph10 459 slotA += md->name_entry_size;
1188     }
1189 ph10 461
1190 ph10 459 /* Found a name for the number - there can be only one; duplicate
1191     names for different numbers are allowed, but not vice versa. First
1192     scan down for duplicates. */
1193 ph10 461
1194 ph10 459 if (i < md->name_count)
1195 ph10 461 {
1196 ph10 459 uschar *slotB = slotA;
1197     while (slotB > md->name_table)
1198     {
1199     slotB -= md->name_entry_size;
1200     if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1201     {
1202     condition = GET2(slotB, 0) == md->recursive->group_num;
1203 ph10 461 if (condition) break;
1204     }
1205 ph10 459 else break;
1206 ph10 461 }
1207    
1208 ph10 459 /* Scan up for duplicates */
1209 ph10 461
1210 ph10 459 if (!condition)
1211 ph10 461 {
1212 ph10 459 slotB = slotA;
1213     for (i++; i < md->name_count; i++)
1214     {
1215     slotB += md->name_entry_size;
1216     if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1217     {
1218     condition = GET2(slotB, 0) == md->recursive->group_num;
1219     if (condition) break;
1220 ph10 461 }
1221 ph10 459 else break;
1222 ph10 461 }
1223     }
1224 ph10 459 }
1225 ph10 461 }
1226    
1227 ph10 459 /* Chose branch according to the condition */
1228 ph10 461
1229 ph10 459 ecode += condition? 3 : GET(ecode, 1);
1230     }
1231 ph10 461 }
1232 nigel 93
1233 ph10 459 else if (condcode == OP_CREF || condcode == OP_NCREF) /* Group used test */
1234 nigel 93 {
1235 nigel 77 offset = GET2(ecode, LINK_SIZE+2) << 1; /* Doubled ref number */
1236 nigel 93 condition = offset < offset_top && md->offset_vector[offset] >= 0;
1237 ph10 461
1238 ph10 459 /* If the numbered capture is unset, but the reference was by name,
1239 ph10 461 scan the table to see if the name refers to any other numbers, and test
1240     them. The condition is true if any one is set. This is tediously similar
1241     to the code above, but not close enough to try to amalgamate. */
1242    
1243 ph10 459 if (!condition && condcode == OP_NCREF)
1244     {
1245 ph10 461 int refno = offset >> 1;
1246 ph10 459 uschar *slotA = md->name_table;
1247 ph10 461
1248 ph10 459 for (i = 0; i < md->name_count; i++)
1249 ph10 461 {
1250     if (GET2(slotA, 0) == refno) break;
1251 ph10 459 slotA += md->name_entry_size;
1252     }
1253 ph10 461
1254     /* Found a name for the number - there can be only one; duplicate names
1255     for different numbers are allowed, but not vice versa. First scan down
1256 ph10 459 for duplicates. */
1257 ph10 461
1258 ph10 459 if (i < md->name_count)
1259 ph10 461 {
1260 ph10 459 uschar *slotB = slotA;
1261     while (slotB > md->name_table)
1262     {
1263     slotB -= md->name_entry_size;
1264     if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1265     {
1266     offset = GET2(slotB, 0) << 1;
1267 ph10 461 condition = offset < offset_top &&
1268 ph10 459 md->offset_vector[offset] >= 0;
1269 ph10 461 if (condition) break;
1270     }
1271 ph10 459 else break;
1272 ph10 461 }
1273    
1274 ph10 459 /* Scan up for duplicates */
1275 ph10 461
1276 ph10 459 if (!condition)
1277 ph10 461 {
1278 ph10 459 slotB = slotA;
1279     for (i++; i < md->name_count; i++)
1280     {
1281     slotB += md->name_entry_size;
1282     if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1283     {
1284     offset = GET2(slotB, 0) << 1;
1285 ph10 461 condition = offset < offset_top &&
1286 ph10 459 md->offset_vector[offset] >= 0;
1287 ph10 461 if (condition) break;
1288     }
1289 ph10 459 else break;
1290 ph10 461 }
1291     }
1292 ph10 459 }
1293 ph10 461 }
1294    
1295 ph10 459 /* Chose branch according to the condition */
1296    
1297 nigel 93 ecode += condition? 3 : GET(ecode, 1);
1298 nigel 77 }
1299    
1300 ph10 399 else if (condcode == OP_DEF) /* DEFINE - always false */
1301 nigel 93 {
1302     condition = FALSE;
1303     ecode += GET(ecode, 1);
1304     }
1305    
1306 nigel 77 /* The condition is an assertion. Call match() to evaluate it - setting
1307 ph10 604 md->match_function_type to MATCH_CONDASSERT causes it to stop at the end of
1308     an assertion. */
1309 nigel 77
1310     else
1311     {
1312 ph10 625 md->match_function_type = MATCH_CONDASSERT;
1313 ph10 604 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM3);
1314 nigel 77 if (rrc == MATCH_MATCH)
1315     {
1316 ph10 619 if (md->end_offset_top > offset_top)
1317     offset_top = md->end_offset_top; /* Captures may have happened */
1318 nigel 93 condition = TRUE;
1319     ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
1320 nigel 77 while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1321     }
1322 ph10 716
1323     /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
1324     assertion; it is therefore treated as NOMATCH. */
1325    
1326     else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1327 nigel 77 {
1328     RRETURN(rrc); /* Need braces because of following else */
1329     }
1330 nigel 93 else
1331     {
1332     condition = FALSE;
1333 ph10 399 ecode += codelink;
1334 nigel 93 }
1335     }
1336 nigel 91
1337 ph10 716 /* We are now at the branch that is to be obeyed. As there is only one, can
1338     use tail recursion to avoid using another stack frame, except when there is
1339     unlimited repeat of a possibly empty group. In the latter case, a recursive
1340     call to match() is always required, unless the second alternative doesn't
1341     exist, in which case we can just plough on. Note that, for compatibility
1342     with Perl, the | in a conditional group is NOT treated as creating two
1343     alternatives. If a THEN is encountered in the branch, it propagates out to
1344     the enclosing alternative (unless nested in a deeper set of alternatives,
1345     of course). */
1346 nigel 91
1347 nigel 93 if (condition || *ecode == OP_ALT)
1348     {
1349 ph10 716 if (op != OP_SCOND)
1350 ph10 702 {
1351     ecode += 1 + LINK_SIZE;
1352     goto TAIL_RECURSE;
1353 ph10 708 }
1354 ph10 716
1355     md->match_function_type = MATCH_CBEGROUP;
1356 ph10 609 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
1357     RRETURN(rrc);
1358 nigel 77 }
1359 ph10 708
1360 ph10 702 /* Condition false & no alternative; continue after the group. */
1361 ph10 708
1362 ph10 702 else
1363 nigel 93 {
1364     ecode += 1 + LINK_SIZE;
1365     }
1366     break;
1367 nigel 77
1368 ph10 461
1369 ph10 447 /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1370     to close any currently open capturing brackets. */
1371 ph10 461
1372 ph10 447 case OP_CLOSE:
1373 ph10 461 number = GET2(ecode, 1);
1374 ph10 447 offset = number << 1;
1375 ph10 461
1376 ph10 475 #ifdef PCRE_DEBUG
1377 ph10 447 printf("end bracket %d at *ACCEPT", number);
1378     printf("\n");
1379     #endif
1380 nigel 77
1381 ph10 447 md->capture_last = number;
1382     if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1383     {
1384     md->offset_vector[offset] =
1385     md->offset_vector[md->offset_end - number];
1386 ph10 530 md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1387 ph10 447 if (offset_top <= offset) offset_top = offset + 2;
1388     }
1389     ecode += 3;
1390 ph10 461 break;
1391 ph10 447
1392    
1393 ph10 619 /* End of the pattern, either real or forced. */
1394 nigel 77
1395 ph10 619 case OP_END:
1396 ph10 210 case OP_ACCEPT:
1397 ph10 625 case OP_ASSERT_ACCEPT:
1398    
1399 ph10 619 /* If we have matched an empty string, fail if not in an assertion and not
1400     in a recursion if either PCRE_NOTEMPTY is set, or if PCRE_NOTEMPTY_ATSTART
1401 ph10 613 is set and we have matched at the start of the subject. In both cases,
1402     backtracking will then try other alternatives, if any. */
1403 ph10 443
1404 ph10 619 if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
1405 ph10 618 md->recursive == NULL &&
1406 ph10 619 (md->notempty ||
1407     (md->notempty_atstart &&
1408     mstart == md->start_subject + md->start_offset)))
1409 ph10 510 MRRETURN(MATCH_NOMATCH);
1410 ph10 443
1411 ph10 442 /* Otherwise, we have a match. */
1412 ph10 625
1413 ph10 168 md->end_match_ptr = eptr; /* Record where we ended */
1414     md->end_offset_top = offset_top; /* and how many extracts were taken */
1415 ph10 210 md->start_match_ptr = mstart; /* and the start (\K can modify) */
1416 nigel 77
1417 ph10 512 /* For some reason, the macros don't work properly if an expression is
1418     given as the argument to MRRETURN when the heap is in use. */
1419    
1420     rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1421     MRRETURN(rrc);
1422    
1423 nigel 77 /* Assertion brackets. Check the alternative branches in turn - the
1424     matching won't pass the KET for an assertion. If any one branch matches,
1425     the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
1426     start of each branch to move the current point backwards, so the code at
1427 ph10 625 this level is identical to the lookahead case. When the assertion is part
1428     of a condition, we want to return immediately afterwards. The caller of
1429     this incarnation of the match() function will have set MATCH_CONDASSERT in
1430     md->match_function type, and one of these opcodes will be the first opcode
1431     that is processed. We use a local variable that is preserved over calls to
1432 ph10 604 match() to remember this case. */
1433 nigel 77
1434     case OP_ASSERT:
1435     case OP_ASSERTBACK:
1436 ph10 604 if (md->match_function_type == MATCH_CONDASSERT)
1437     {
1438     condassert = TRUE;
1439     md->match_function_type = 0;
1440     }
1441 ph10 625 else condassert = FALSE;
1442    
1443 nigel 77 do
1444     {
1445 ph10 604 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM4);
1446 ph10 511 if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1447 ph10 500 {
1448     mstart = md->start_match_ptr; /* In case \K reset it */
1449 ph10 630 markptr = md->mark;
1450 ph10 500 break;
1451 ph10 501 }
1452 ph10 716
1453     /* PCRE does not allow THEN to escape beyond an assertion; it is treated
1454     as NOMATCH. */
1455    
1456     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1457 nigel 77 ecode += GET(ecode, 1);
1458     }
1459     while (*ecode == OP_ALT);
1460 ph10 625
1461 ph10 510 if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1462 nigel 77
1463     /* If checking an assertion for a condition, return MATCH_MATCH. */
1464    
1465 ph10 604 if (condassert) RRETURN(MATCH_MATCH);
1466 nigel 77
1467     /* Continue from after the assertion, updating the offsets high water
1468     mark, since extracts may have been taken during the assertion. */
1469    
1470     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1471     ecode += 1 + LINK_SIZE;
1472     offset_top = md->end_offset_top;
1473     continue;
1474    
1475 ph10 473 /* Negative assertion: all branches must fail to match. Encountering SKIP,
1476 ph10 482 PRUNE, or COMMIT means we must assume failure without checking subsequent
1477 ph10 473 branches. */
1478 nigel 77
1479     case OP_ASSERT_NOT:
1480     case OP_ASSERTBACK_NOT:
1481 ph10 604 if (md->match_function_type == MATCH_CONDASSERT)
1482     {
1483     condassert = TRUE;
1484     md->match_function_type = 0;
1485     }
1486 ph10 625 else condassert = FALSE;
1487 ph10 604
1488 nigel 77 do
1489     {
1490 ph10 604 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1491 ph10 511 if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1492 ph10 473 if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1493     {
1494     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1495 ph10 482 break;
1496     }
1497 ph10 716
1498     /* PCRE does not allow THEN to escape beyond an assertion; it is treated
1499     as NOMATCH. */
1500    
1501     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1502 nigel 77 ecode += GET(ecode,1);
1503     }
1504     while (*ecode == OP_ALT);
1505    
1506 ph10 604 if (condassert) RRETURN(MATCH_MATCH); /* Condition assertion */
1507 ph10 625
1508 nigel 77 ecode += 1 + LINK_SIZE;
1509     continue;
1510    
1511     /* Move the subject pointer back. This occurs only at the start of
1512     each branch of a lookbehind assertion. If we are too close to the start to
1513     move back, this match function fails. When working with UTF-8 we move
1514     back a number of characters, not bytes. */
1515    
1516     case OP_REVERSE:
1517     #ifdef SUPPORT_UTF8
1518     if (utf8)
1519     {
1520 nigel 93 i = GET(ecode, 1);
1521     while (i-- > 0)
1522 nigel 77 {
1523     eptr--;
1524 ph10 510 if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1525 ph10 207 BACKCHAR(eptr);
1526 nigel 77 }
1527     }
1528     else
1529     #endif
1530    
1531     /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
1532    
1533     {
1534 nigel 93 eptr -= GET(ecode, 1);
1535 ph10 510 if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1536 nigel 77 }
1537    
1538 ph10 435 /* Save the earliest consulted character, then skip to next op code */
1539 nigel 77
1540 ph10 435 if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
1541 nigel 77 ecode += 1 + LINK_SIZE;
1542     break;
1543    
1544     /* The callout item calls an external function, if one is provided, passing
1545     details of the match so far. This is mainly for debugging, though the
1546     function is able to force a failure. */
1547    
1548     case OP_CALLOUT:
1549     if (pcre_callout != NULL)
1550     {
1551     pcre_callout_block cb;
1552 ph10 645 cb.version = 2; /* Version 1 of the callout block */
1553 nigel 77 cb.callout_number = ecode[1];
1554     cb.offset_vector = md->offset_vector;
1555 nigel 87 cb.subject = (PCRE_SPTR)md->start_subject;
1556 ph10 530 cb.subject_length = (int)(md->end_subject - md->start_subject);
1557     cb.start_match = (int)(mstart - md->start_subject);
1558     cb.current_position = (int)(eptr - md->start_subject);
1559 nigel 77 cb.pattern_position = GET(ecode, 2);
1560     cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1561     cb.capture_top = offset_top/2;
1562     cb.capture_last = md->capture_last;
1563     cb.callout_data = md->callout_data;
1564 ph10 654 cb.mark = markptr;
1565 ph10 510 if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1566 nigel 77 if (rrc < 0) RRETURN(rrc);
1567     }
1568     ecode += 2 + 2*LINK_SIZE;
1569     break;
1570    
1571     /* Recursion either matches the current regex, or some subexpression. The
1572     offset data is the offset to the starting bracket from the start of the
1573     whole pattern. (This is so that it works from duplicated subpatterns.)
1574 ph10 625
1575 ph10 618 The state of the capturing groups is preserved over recursion, and
1576 ph10 625 re-instated afterwards. We don't know how many are started and not yet
1577 ph10 618 finished (offset_top records the completed total) so we just have to save
1578     all the potential data. There may be up to 65535 such values, which is too
1579     large to put on the stack, but using malloc for small numbers seems
1580     expensive. As a compromise, the stack is used when there are no more than
1581     REC_STACK_SAVE_MAX values to store; otherwise malloc is used.
1582 nigel 77
1583     There are also other values that have to be saved. We use a chained
1584     sequence of blocks that actually live on the stack. Thanks to Robin Houston
1585 ph10 625 for the original version of this logic. It has, however, been hacked around
1586 ph10 618 a lot, so he is not to blame for the current way it works. */
1587 nigel 77
1588     case OP_RECURSE:
1589     {
1590 ph10 642 recursion_info *ri;
1591     int recno;
1592 ph10 654
1593 nigel 77 callpat = md->start_code + GET(ecode, 1);
1594 ph10 642 recno = (callpat == md->start_code)? 0 :
1595 ph10 654 GET2(callpat, 1 + LINK_SIZE);
1596    
1597     /* Check for repeating a recursion without advancing the subject pointer.
1598 ph10 642 This should catch convoluted mutual recursions. (Some simple cases are
1599 ph10 654 caught at compile time.) */
1600    
1601 ph10 642 for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
1602 ph10 654 if (recno == ri->group_num && eptr == ri->subject_position)
1603 ph10 642 RRETURN(PCRE_ERROR_RECURSELOOP);
1604 nigel 77
1605     /* Add to "recursing stack" */
1606    
1607 ph10 642 new_recursive.group_num = recno;
1608     new_recursive.subject_position = eptr;
1609 nigel 77 new_recursive.prevrec = md->recursive;
1610     md->recursive = &new_recursive;
1611    
1612 ph10 618 /* Where to continue from afterwards */
1613 nigel 77
1614     ecode += 1 + LINK_SIZE;
1615    
1616 ph10 618 /* Now save the offset data */
1617 nigel 77
1618     new_recursive.saved_max = md->offset_end;
1619     if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
1620     new_recursive.offset_save = stacksave;
1621     else
1622     {
1623     new_recursive.offset_save =
1624     (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));
1625     if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
1626     }
1627     memcpy(new_recursive.offset_save, md->offset_vector,
1628     new_recursive.saved_max * sizeof(int));
1629 ph10 625
1630 ph10 618 /* OK, now we can do the recursion. After processing each alternative,
1631 ph10 625 restore the offset data. If there were nested recursions, md->recursive
1632 ph10 618 might be changed, so reset it before looping. */
1633 nigel 77
1634     DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
1635 ph10 604 cbegroup = (*callpat >= OP_SBRA);
1636 nigel 77 do
1637     {
1638 ph10 604 if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
1639 ph10 164 RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1640 ph10 604 md, eptrb, RM6);
1641 ph10 618 memcpy(md->offset_vector, new_recursive.offset_save,
1642     new_recursive.saved_max * sizeof(int));
1643 ph10 681 md->recursive = new_recursive.prevrec;
1644 ph10 511 if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1645 nigel 77 {
1646 nigel 87 DPRINTF(("Recursion matched\n"));
1647 nigel 77 if (new_recursive.offset_save != stacksave)
1648     (pcre_free)(new_recursive.offset_save);
1649 ph10 618
1650     /* Set where we got to in the subject, and reset the start in case
1651 ph10 625 it was changed by \K. This *is* propagated back out of a recursion,
1652     for Perl compatibility. */
1653    
1654 ph10 618 eptr = md->end_match_ptr;
1655     mstart = md->start_match_ptr;
1656     goto RECURSION_MATCHED; /* Exit loop; end processing */
1657 nigel 77 }
1658 ph10 716
1659     /* PCRE does not allow THEN to escape beyond a recursion; it is treated
1660     as NOMATCH. */
1661    
1662     else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1663 nigel 87 {
1664     DPRINTF(("Recursion gave error %d\n", rrc));
1665 ph10 400 if (new_recursive.offset_save != stacksave)
1666     (pcre_free)(new_recursive.offset_save);
1667 nigel 87 RRETURN(rrc);
1668     }
1669 nigel 77
1670     md->recursive = &new_recursive;
1671     callpat += GET(callpat, 1);
1672     }
1673     while (*callpat == OP_ALT);
1674    
1675     DPRINTF(("Recursion didn't match\n"));
1676     md->recursive = new_recursive.prevrec;
1677     if (new_recursive.offset_save != stacksave)
1678     (pcre_free)(new_recursive.offset_save);
1679 ph10 510 MRRETURN(MATCH_NOMATCH);
1680 nigel 77 }
1681 ph10 625
1682 ph10 618 RECURSION_MATCHED:
1683     break;
1684 nigel 77
1685     /* An alternation is the end of a branch; scan along to find the end of the
1686     bracketed group and go to there. */
1687    
1688     case OP_ALT:
1689     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1690     break;
1691    
1692 ph10 335 /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1693     indicating that it may occur zero times. It may repeat infinitely, or not
1694     at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
1695     with fixed upper repeat limits are compiled as a number of copies, with the
1696     optional ones preceded by BRAZERO or BRAMINZERO. */
1697 ph10 625
1698 nigel 77 case OP_BRAZERO:
1699 ph10 604 next = ecode + 1;
1700     RMATCH(eptr, next, offset_top, md, eptrb, RM10);
1701     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1702     do next += GET(next, 1); while (*next == OP_ALT);
1703     ecode = next + 1 + LINK_SIZE;
1704 nigel 77 break;
1705 ph10 625
1706 nigel 77 case OP_BRAMINZERO:
1707 ph10 604 next = ecode + 1;
1708     do next += GET(next, 1); while (*next == OP_ALT);
1709     RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, RM11);
1710     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1711     ecode++;
1712 nigel 77 break;
1713    
1714 ph10 335 case OP_SKIPZERO:
1715 ph10 604 next = ecode+1;
1716     do next += GET(next,1); while (*next == OP_ALT);
1717     ecode = next + 1 + LINK_SIZE;
1718 ph10 335 break;
1719 ph10 625
1720 ph10 604 /* BRAPOSZERO occurs before a possessive bracket group. Don't do anything
1721     here; just jump to the group, with allow_zero set TRUE. */
1722 ph10 625
1723 ph10 604 case OP_BRAPOSZERO:
1724 ph10 625 op = *(++ecode);
1725 ph10 604 allow_zero = TRUE;
1726     if (op == OP_CBRAPOS || op == OP_SCBRAPOS) goto POSSESSIVE_CAPTURE;
1727     goto POSSESSIVE_NON_CAPTURE;
1728 ph10 335
1729 nigel 93 /* End of a group, repeated or non-repeating. */
1730 nigel 77
1731     case OP_KET:
1732     case OP_KETRMIN:
1733     case OP_KETRMAX:
1734 ph10 625 case OP_KETRPOS:
1735 nigel 91 prev = ecode - GET(ecode, 1);
1736 ph10 625
1737 nigel 93 /* If this was a group that remembered the subject start, in order to break
1738     infinite repeats of empty string matches, retrieve the subject start from
1739     the chain. Otherwise, set it NULL. */
1740 nigel 77
1741 ph10 618 if (*prev >= OP_SBRA || *prev == OP_ONCE)
1742 nigel 93 {
1743     saved_eptr = eptrb->epb_saved_eptr; /* Value at start of group */
1744     eptrb = eptrb->epb_prev; /* Backup to previous group */
1745     }
1746     else saved_eptr = NULL;
1747 nigel 77
1748 ph10 618 /* If we are at the end of an assertion group, stop matching and return
1749     MATCH_MATCH, but record the current high water mark for use by positive
1750     assertions. We also need to record the match start in case it was changed
1751     by \K. */
1752 nigel 93
1753 ph10 721 if (*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT)
1754 nigel 91 {
1755     md->end_match_ptr = eptr; /* For ONCE */
1756     md->end_offset_top = offset_top;
1757 ph10 500 md->start_match_ptr = mstart;
1758 ph10 630 MRRETURN(MATCH_MATCH); /* Sets md->mark */
1759 nigel 91 }
1760 nigel 77
1761 nigel 93 /* For capturing groups we have to check the group number back at the start
1762     and if necessary complete handling an extraction by setting the offsets and
1763 ph10 618 bumping the high water mark. Whole-pattern recursion is coded as a recurse
1764     into group 0, so it won't be picked up here. Instead, we catch it when the
1765     OP_END is reached. Other recursion is handled here. We just have to record
1766     the current subject position and start match pointer and give a MATCH
1767     return. */
1768 nigel 77
1769 ph10 604 if (*prev == OP_CBRA || *prev == OP_SCBRA ||
1770     *prev == OP_CBRAPOS || *prev == OP_SCBRAPOS)
1771 nigel 91 {
1772 nigel 93 number = GET2(prev, 1+LINK_SIZE);
1773 nigel 91 offset = number << 1;
1774 ph10 461
1775 ph10 475 #ifdef PCRE_DEBUG
1776 nigel 91 printf("end bracket %d", number);
1777     printf("\n");
1778 nigel 77 #endif
1779    
1780 ph10 618 /* Handle a recursively called group. */
1781    
1782     if (md->recursive != NULL && md->recursive->group_num == number)
1783     {
1784     md->end_match_ptr = eptr;
1785     md->start_match_ptr = mstart;
1786     RRETURN(MATCH_MATCH);
1787     }
1788    
1789     /* Deal with capturing */
1790    
1791 nigel 93 md->capture_last = number;
1792     if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1793 nigel 91 {
1794 ph10 625 /* If offset is greater than offset_top, it means that we are
1795     "skipping" a capturing group, and that group's offsets must be marked
1796     unset. In earlier versions of PCRE, all the offsets were unset at the
1797     start of matching, but this doesn't work because atomic groups and
1798 ph10 615 assertions can cause a value to be set that should later be unset.
1799     Example: matching /(?>(a))b|(a)c/ against "ac". This sets group 1 as
1800 ph10 625 part of the atomic group, but this is not on the final matching path,
1801     so must be unset when 2 is set. (If there is no group 2, there is no
1802 ph10 615 problem, because offset_top will then be 2, indicating no capture.) */
1803 ph10 625
1804 ph10 615 if (offset > offset_top)
1805     {
1806     register int *iptr = md->offset_vector + offset_top;
1807     register int *iend = md->offset_vector + offset;
1808     while (iptr < iend) *iptr++ = -1;
1809 ph10 625 }
1810    
1811 ph10 615 /* Now make the extraction */
1812    
1813 nigel 93 md->offset_vector[offset] =
1814     md->offset_vector[md->offset_end - number];
1815 ph10 530 md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1816 nigel 93 if (offset_top <= offset) offset_top = offset + 2;
1817     }
1818 nigel 91 }
1819 nigel 77
1820 ph10 618 /* For an ordinary non-repeating ket, just continue at this level. This
1821     also happens for a repeating ket if no characters were matched in the
1822     group. This is the forcible breaking of infinite loops as implemented in
1823 ph10 625 Perl 5.005. For a non-repeating atomic group, establish a backup point by
1824     processing the rest of the pattern at a lower level. If this results in a
1825     NOMATCH return, pass MATCH_ONCE back to the original OP_ONCE level, thereby
1826     bypassing intermediate backup points, but resetting any captures that
1827 ph10 618 happened along the way. */
1828 nigel 77
1829 nigel 91 if (*ecode == OP_KET || eptr == saved_eptr)
1830     {
1831 ph10 618 if (*prev == OP_ONCE)
1832     {
1833     RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM12);
1834     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1835     md->once_target = prev; /* Level at which to change to MATCH_NOMATCH */
1836 ph10 625 RRETURN(MATCH_ONCE);
1837     }
1838 ph10 618 ecode += 1 + LINK_SIZE; /* Carry on at this level */
1839 nigel 91 break;
1840     }
1841 ph10 625
1842     /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
1843 ph10 604 and return the MATCH_KETRPOS. This makes it possible to do the repeats one
1844     at a time from the outer level, thus saving stack. */
1845 ph10 625
1846 ph10 604 if (*ecode == OP_KETRPOS)
1847 ph10 625 {
1848 ph10 604 md->end_match_ptr = eptr;
1849 ph10 625 md->end_offset_top = offset_top;
1850 ph10 604 RRETURN(MATCH_KETRPOS);
1851 ph10 625 }
1852 nigel 77
1853 ph10 604 /* The normal repeating kets try the rest of the pattern or restart from
1854     the preceding bracket, in the appropriate order. In the second case, we can
1855     use tail recursion to avoid using another stack frame, unless we have an
1856 ph10 618 an atomic group or an unlimited repeat of a group that can match an empty
1857     string. */
1858 nigel 77
1859 nigel 91 if (*ecode == OP_KETRMIN)
1860     {
1861 ph10 623 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM7);
1862 nigel 91 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1863 ph10 618 if (*prev == OP_ONCE)
1864     {
1865 ph10 623 RMATCH(eptr, prev, offset_top, md, eptrb, RM8);
1866 ph10 618 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1867     md->once_target = prev; /* Level at which to change to MATCH_NOMATCH */
1868 ph10 625 RRETURN(MATCH_ONCE);
1869     }
1870 ph10 604 if (*prev >= OP_SBRA) /* Could match an empty string */
1871 ph10 197 {
1872 ph10 625 md->match_function_type = MATCH_CBEGROUP;
1873 ph10 604 RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
1874 ph10 197 RRETURN(rrc);
1875     }
1876 nigel 91 ecode = prev;
1877     goto TAIL_RECURSE;
1878 nigel 77 }
1879 nigel 91 else /* OP_KETRMAX */
1880     {
1881 ph10 625 if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1882 ph10 604 RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
1883 ph10 618 if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
1884 nigel 91 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1885 ph10 618 if (*prev == OP_ONCE)
1886     {
1887 ph10 623 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM9);
1888 ph10 618 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1889     md->once_target = prev;
1890 ph10 625 RRETURN(MATCH_ONCE);
1891     }
1892 nigel 91 ecode += 1 + LINK_SIZE;
1893     goto TAIL_RECURSE;
1894     }
1895     /* Control never gets here */
1896 nigel 77
1897 ph10 602 /* Not multiline mode: start of subject assertion, unless notbol. */
1898 nigel 77
1899     case OP_CIRC:
1900 ph10 510 if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1901 ph10 625
1902 nigel 77 /* Start of subject assertion */
1903    
1904     case OP_SOD:
1905 ph10 510 if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1906 nigel 77 ecode++;
1907     break;
1908 ph10 625
1909 ph10 602 /* Multiline mode: start of subject unless notbol, or after any newline. */
1910 nigel 77
1911 ph10 602 case OP_CIRCM:
1912     if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1913     if (eptr != md->start_subject &&
1914     (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1915     MRRETURN(MATCH_NOMATCH);
1916     ecode++;
1917     break;
1918    
1919 nigel 77 /* Start of match assertion */
1920    
1921     case OP_SOM:
1922 ph10 510 if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1923 nigel 77 ecode++;
1924     break;
1925 ph10 172
1926 ph10 168 /* Reset the start of match point */
1927 ph10 172
1928 ph10 168 case OP_SET_SOM:
1929     mstart = eptr;
1930 ph10 172 ecode++;
1931     break;
1932 nigel 77
1933 ph10 602 /* Multiline mode: assert before any newline, or before end of subject
1934     unless noteol is set. */
1935 nigel 77
1936 ph10 602 case OP_DOLLM:
1937     if (eptr < md->end_subject)
1938     { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1939     else
1940 nigel 77 {
1941 ph10 510 if (md->noteol) MRRETURN(MATCH_NOMATCH);
1942 ph10 602 SCHECK_PARTIAL();
1943 nigel 77 }
1944 ph10 602 ecode++;
1945     break;
1946 ph10 579
1947 ph10 625 /* Not multiline mode: assert before a terminating newline or before end of
1948 ph10 602 subject unless noteol is set. */
1949    
1950     case OP_DOLL:
1951     if (md->noteol) MRRETURN(MATCH_NOMATCH);
1952     if (!md->endonly) goto ASSERT_NL_OR_EOS;
1953    
1954 nigel 91 /* ... else fall through for endonly */
1955 nigel 77
1956     /* End of subject assertion (\z) */
1957    
1958     case OP_EOD:
1959 ph10 510 if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1960 ph10 553 SCHECK_PARTIAL();
1961 nigel 77 ecode++;
1962     break;
1963    
1964     /* End of subject or ending \n assertion (\Z) */
1965    
1966     case OP_EODN:
1967 ph10 553 ASSERT_NL_OR_EOS:
1968     if (eptr < md->end_subject &&
1969 nigel 93 (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1970 ph10 510 MRRETURN(MATCH_NOMATCH);
1971 ph10 579
1972 ph10 553 /* Either at end of string or \n before end. */
1973 ph10 579
1974 ph10 553 SCHECK_PARTIAL();
1975 nigel 77 ecode++;
1976     break;
1977    
1978     /* Word boundary assertions */
1979    
1980     case OP_NOT_WORD_BOUNDARY:
1981     case OP_WORD_BOUNDARY:
1982     {
1983    
1984     /* Find out if the previous and current characters are "word" characters.
1985     It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
1986 ph10 443 be "non-word" characters. Remember the earliest consulted character for
1987 ph10 435 partial matching. */
1988 nigel 77
1989     #ifdef SUPPORT_UTF8
1990     if (utf8)
1991     {
1992 ph10 518 /* Get status of previous character */
1993 ph10 527
1994 nigel 77 if (eptr == md->start_subject) prev_is_word = FALSE; else
1995     {
1996 ph10 409 USPTR lastptr = eptr - 1;
1997 nigel 77 while((*lastptr & 0xc0) == 0x80) lastptr--;
1998 ph10 443 if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1999 nigel 77 GETCHAR(c, lastptr);
2000 ph10 527 #ifdef SUPPORT_UCP
2001 ph10 518 if (md->use_ucp)
2002     {
2003     if (c == '_') prev_is_word = TRUE; else
2004 ph10 527 {
2005 ph10 518 int cat = UCD_CATEGORY(c);
2006     prev_is_word = (cat == ucp_L || cat == ucp_N);
2007 ph10 527 }
2008     }
2009     else
2010     #endif
2011 nigel 77 prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
2012     }
2013 ph10 527
2014 ph10 518 /* Get status of next character */
2015 ph10 527
2016 ph10 443 if (eptr >= md->end_subject)
2017 nigel 77 {
2018 ph10 443 SCHECK_PARTIAL();
2019     cur_is_word = FALSE;
2020 ph10 428 }
2021     else
2022     {
2023 nigel 77 GETCHAR(c, eptr);
2024 ph10 527 #ifdef SUPPORT_UCP
2025 ph10 518 if (md->use_ucp)
2026     {
2027     if (c == '_') cur_is_word = TRUE; else
2028 ph10 527 {
2029 ph10 518 int cat = UCD_CATEGORY(c);
2030     cur_is_word = (cat == ucp_L || cat == ucp_N);
2031 ph10 527 }
2032     }
2033     else
2034     #endif
2035 nigel 77 cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
2036     }
2037     }
2038     else
2039     #endif
2040    
2041 ph10 527 /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
2042 ph10 518 consistency with the behaviour of \w we do use it in this case. */
2043 nigel 77
2044     {
2045 ph10 518 /* Get status of previous character */
2046 ph10 527
2047 ph10 435 if (eptr == md->start_subject) prev_is_word = FALSE; else
2048     {
2049 ph10 443 if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
2050 ph10 527 #ifdef SUPPORT_UCP
2051 ph10 518 if (md->use_ucp)
2052     {
2053 ph10 527 c = eptr[-1];
2054 ph10 518 if (c == '_') prev_is_word = TRUE; else
2055 ph10 527 {
2056 ph10 518 int cat = UCD_CATEGORY(c);
2057     prev_is_word = (cat == ucp_L || cat == ucp_N);
2058 ph10 527 }
2059     }
2060     else
2061     #endif
2062 ph10 435 prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
2063     }
2064 ph10 527
2065 ph10 518 /* Get status of next character */
2066 ph10 527
2067 ph10 443 if (eptr >= md->end_subject)
2068 ph10 428 {
2069 ph10 443 SCHECK_PARTIAL();
2070     cur_is_word = FALSE;
2071 ph10 428 }
2072 ph10 527 else
2073     #ifdef SUPPORT_UCP
2074 ph10 518 if (md->use_ucp)
2075     {
2076 ph10 527 c = *eptr;
2077 ph10 518 if (c == '_') cur_is_word = TRUE; else
2078 ph10 527 {
2079 ph10 518 int cat = UCD_CATEGORY(c);
2080     cur_is_word = (cat == ucp_L || cat == ucp_N);
2081 ph10 527 }
2082     }
2083     else
2084     #endif
2085 ph10 518 cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
2086 nigel 77 }
2087    
2088     /* Now see if the situation is what we want */
2089    
2090     if ((*ecode++ == OP_WORD_BOUNDARY)?
2091     cur_is_word == prev_is_word : cur_is_word != prev_is_word)
2092 ph10 510 MRRETURN(MATCH_NOMATCH);
2093 nigel 77 }
2094     break;
2095    
2096     /* Match a single character type; inline for speed */
2097    
2098     case OP_ANY:
2099 ph10 510 if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
2100 ph10 345 /* Fall through */
2101    
2102 ph10 341 case OP_ALLANY:
2103 ph10 648 if (eptr >= md->end_subject) /* DO NOT merge the eptr++ here; it must */
2104     { /* not be updated before SCHECK_PARTIAL. */
2105 ph10 443 SCHECK_PARTIAL();
2106 ph10 510 MRRETURN(MATCH_NOMATCH);
2107 ph10 443 }
2108 ph10 648 eptr++;
2109 ph10 342 if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
2110 nigel 77 ecode++;
2111     break;
2112    
2113     /* Match a single byte, even in UTF-8 mode. This opcode really does match
2114     any byte, even newline, independent of the setting of PCRE_DOTALL. */
2115    
2116     case OP_ANYBYTE:
2117 ph10 648 if (eptr >= md->end_subject) /* DO NOT merge the eptr++ here; it must */
2118     { /* not be updated before SCHECK_PARTIAL. */
2119 ph10 443 SCHECK_PARTIAL();
2120 ph10 510 MRRETURN(MATCH_NOMATCH);
2121 ph10 443 }
2122 ph10 654 eptr++;
2123 nigel 77 ecode++;
2124     break;
2125    
2126     case OP_NOT_DIGIT:
2127 ph10 443 if (eptr >= md->end_subject)
2128 ph10 428 {
2129 ph10 443 SCHECK_PARTIAL();
2130 ph10 510 MRRETURN(MATCH_NOMATCH);
2131 ph10 443 }
2132 nigel 77 GETCHARINCTEST(c, eptr);
2133     if (
2134     #ifdef SUPPORT_UTF8
2135     c < 256 &&
2136     #endif
2137     (md->ctypes[c] & ctype_digit) != 0
2138     )
2139 ph10 510 MRRETURN(MATCH_NOMATCH);
2140 nigel 77 ecode++;
2141     break;
2142    
2143     case OP_DIGIT:
2144 ph10 443 if (eptr >= md->end_subject)
2145 ph10 428 {
2146 ph10 443 SCHECK_PARTIAL();
2147 ph10 510 MRRETURN(MATCH_NOMATCH);
2148 ph10 443 }
2149 nigel 77 GETCHARINCTEST(c, eptr);
2150     if (
2151     #ifdef SUPPORT_UTF8
2152     c >= 256 ||
2153     #endif
2154     (md->ctypes[c] & ctype_digit) == 0
2155     )
2156 ph10 510 MRRETURN(MATCH_NOMATCH);
2157 nigel 77 ecode++;
2158     break;
2159    
2160     case OP_NOT_WHITESPACE:
2161 ph10 443 if (eptr >= md->end_subject)
2162 ph10 428 {
2163 ph10 443 SCHECK_PARTIAL();
2164 ph10 510 MRRETURN(MATCH_NOMATCH);
2165 ph10 443 }
2166 nigel 77 GETCHARINCTEST(c, eptr);
2167     if (
2168     #ifdef SUPPORT_UTF8
2169     c < 256 &&
2170     #endif
2171     (md->ctypes[c] & ctype_space) != 0
2172     )
2173 ph10 510 MRRETURN(MATCH_NOMATCH);
2174 nigel 77 ecode++;
2175     break;
2176    
2177     case OP_WHITESPACE:
2178 ph10 443 if (eptr >= md->end_subject)
2179 ph10 428 {
2180 ph10 443 SCHECK_PARTIAL();
2181 ph10 510 MRRETURN(MATCH_NOMATCH);
2182 ph10 443 }
2183 nigel 77 GETCHARINCTEST(c, eptr);
2184     if (
2185     #ifdef SUPPORT_UTF8
2186     c >= 256 ||
2187     #endif
2188     (md->ctypes[c] & ctype_space) == 0
2189     )
2190 ph10 510 MRRETURN(MATCH_NOMATCH);
2191 nigel 77 ecode++;
2192     break;
2193    
2194     case OP_NOT_WORDCHAR:
2195 ph10 443 if (eptr >= md->end_subject)
2196 ph10 428 {
2197 ph10 443 SCHECK_PARTIAL();
2198 ph10 510 MRRETURN(MATCH_NOMATCH);
2199 ph10 443 }
2200 nigel 77 GETCHARINCTEST(c, eptr);
2201     if (
2202     #ifdef SUPPORT_UTF8
2203     c < 256 &&
2204     #endif
2205     (md->ctypes[c] & ctype_word) != 0
2206     )
2207 ph10 510 MRRETURN(MATCH_NOMATCH);
2208 nigel 77 ecode++;
2209     break;
2210    
2211     case OP_WORDCHAR:
2212 ph10 443 if (eptr >= md->end_subject)
2213 ph10 428 {
2214 ph10 443 SCHECK_PARTIAL();
2215 ph10 510 MRRETURN(MATCH_NOMATCH);
2216 ph10 443 }
2217 nigel 77 GETCHARINCTEST(c, eptr);
2218     if (
2219     #ifdef SUPPORT_UTF8
2220     c >= 256 ||
2221     #endif
2222     (md->ctypes[c] & ctype_word) == 0
2223     )
2224 ph10 510 MRRETURN(MATCH_NOMATCH);
2225 nigel 77 ecode++;
2226     break;
2227    
2228 nigel 93 case OP_ANYNL:
2229 ph10 443 if (eptr >= md->end_subject)
2230 ph10 428 {
2231 ph10 443 SCHECK_PARTIAL();
2232 ph10 510 MRRETURN(MATCH_NOMATCH);
2233 ph10 443 }
2234 nigel 93 GETCHARINCTEST(c, eptr);
2235     switch(c)
2236     {
2237 ph10 510 default: MRRETURN(MATCH_NOMATCH);
2238 ph10 625
2239 nigel 93 case 0x000d:
2240     if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
2241     break;
2242 ph10 231
2243 nigel 93 case 0x000a:
2244 ph10 231 break;
2245    
2246 nigel 93 case 0x000b:
2247     case 0x000c:
2248     case 0x0085:
2249     case 0x2028:
2250     case 0x2029:
2251 ph10 510 if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
2252 nigel 93 break;
2253     }
2254     ecode++;
2255     break;
2256    
2257 ph10 178 case OP_NOT_HSPACE:
2258 ph10 443 if (eptr >= md->end_subject)
2259 ph10 428 {
2260 ph10 443 SCHECK_PARTIAL();
2261 ph10 510 MRRETURN(MATCH_NOMATCH);
2262 ph10 443 }
2263 ph10 178 GETCHARINCTEST(c, eptr);
2264     switch(c)
2265     {
2266     default: break;
2267     case 0x09: /* HT */
2268     case 0x20: /* SPACE */
2269     case 0xa0: /* NBSP */
2270     case 0x1680: /* OGHAM SPACE MARK */
2271     case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
2272     case 0x2000: /* EN QUAD */
2273     case 0x2001: /* EM QUAD */
2274     case 0x2002: /* EN SPACE */
2275     case 0x2003: /* EM SPACE */
2276     case 0x2004: /* THREE-PER-EM SPACE */
2277     case 0x2005: /* FOUR-PER-EM SPACE */
2278     case 0x2006: /* SIX-PER-EM SPACE */
2279     case 0x2007: /* FIGURE SPACE */
2280     case 0x2008: /* PUNCTUATION SPACE */
2281     case 0x2009: /* THIN SPACE */
2282     case 0x200A: /* HAIR SPACE */
2283     case 0x202f: /* NARROW NO-BREAK SPACE */
2284     case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
2285     case 0x3000: /* IDEOGRAPHIC SPACE */
2286 ph10 510 MRRETURN(MATCH_NOMATCH);
2287 ph10 178 }
2288     ecode++;
2289     break;
2290    
2291     case OP_HSPACE:
2292 ph10 443 if (eptr >= md->end_subject)
2293 ph10 428 {
2294 ph10 443 SCHECK_PARTIAL();
2295 ph10 510 MRRETURN(MATCH_NOMATCH);
2296 ph10 443 }
2297 ph10 178 GETCHARINCTEST(c, eptr);
2298     switch(c)
2299     {
2300 ph10 510 default: MRRETURN(MATCH_NOMATCH);
2301 ph10 178 case 0x09: /* HT */
2302     case 0x20: /* SPACE */
2303     case 0xa0: /* NBSP */
2304     case 0x1680: /* OGHAM SPACE MARK */
2305     case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
2306     case 0x2000: /* EN QUAD */
2307     case 0x2001: /* EM QUAD */
2308     case 0x2002: /* EN SPACE */
2309     case 0x2003: /* EM SPACE */
2310     case 0x2004: /* THREE-PER-EM SPACE */
2311     case 0x2005: /* FOUR-PER-EM SPACE */
2312     case 0x2006: /* SIX-PER-EM SPACE */
2313     case 0x2007: /* FIGURE SPACE */
2314     case 0x2008: /* PUNCTUATION SPACE */
2315     case 0x2009: /* THIN SPACE */
2316     case 0x200A: /* HAIR SPACE */
2317     case 0x202f: /* NARROW NO-BREAK SPACE */
2318     case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
2319     case 0x3000: /* IDEOGRAPHIC SPACE */
2320     break;
2321     }
2322     ecode++;
2323     break;
2324    
2325     case OP_NOT_VSPACE:
2326 ph10 443 if (eptr >= md->end_subject)
2327 ph10 428 {
2328 ph10 443 SCHECK_PARTIAL();
2329 ph10 510 MRRETURN(MATCH_NOMATCH);
2330 ph10 443 }
2331 ph10 178 GETCHARINCTEST(c, eptr);
2332     switch(c)
2333     {
2334     default: break;
2335     case 0x0a: /* LF */
2336     case 0x0b: /* VT */
2337     case 0x0c: /* FF */
2338     case 0x0d: /* CR */
2339     case 0x85: /* NEL */
2340     case 0x2028: /* LINE SEPARATOR */
2341     case 0x2029: /* PARAGRAPH SEPARATOR */
2342 ph10 510 MRRETURN(MATCH_NOMATCH);
2343 ph10 178 }
2344     ecode++;
2345     break;
2346    
2347     case OP_VSPACE:
2348 ph10 443 if (eptr >= md->end_subject)
2349 ph10 428 {
2350 ph10 443 SCHECK_PARTIAL();
2351 ph10 510 MRRETURN(MATCH_NOMATCH);
2352 ph10 443 }
2353 ph10 178 GETCHARINCTEST(c, eptr);
2354     switch(c)
2355     {
2356 ph10 510 default: MRRETURN(MATCH_NOMATCH);
2357 ph10 178 case 0x0a: /* LF */
2358     case 0x0b: /* VT */
2359     case 0x0c: /* FF */
2360     case 0x0d: /* CR */
2361     case 0x85: /* NEL */
2362     case 0x2028: /* LINE SEPARATOR */
2363     case 0x2029: /* PARAGRAPH SEPARATOR */
2364     break;
2365     }
2366     ecode++;
2367     break;
2368    
2369 nigel 77 #ifdef SUPPORT_UCP
2370     /* Check the next character by Unicode property. We will get here only
2371     if the support is in the binary; otherwise a compile-time error occurs. */
2372    
2373     case OP_PROP:
2374     case OP_NOTPROP:
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 nigel 77 GETCHARINCTEST(c, eptr);
2381     {
2382 ph10 384 const ucd_record *prop = GET_UCD(c);
2383 nigel 77
2384 nigel 87 switch(ecode[1])
2385     {
2386     case PT_ANY:
2387 ph10 510 if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2388 nigel 87 break;
2389 nigel 77
2390 nigel 87 case PT_LAMP:
2391 ph10 349 if ((prop->chartype == ucp_Lu ||
2392     prop->chartype == ucp_Ll ||
2393     prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2394 ph10 510 MRRETURN(MATCH_NOMATCH);
2395 ph10 517 break;
2396 nigel 87
2397     case PT_GC:
2398 ph10 351 if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2399 ph10 510 MRRETURN(MATCH_NOMATCH);
2400 nigel 87 break;
2401    
2402     case PT_PC:
2403 ph10 349 if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2404 ph10 510 MRRETURN(MATCH_NOMATCH);
2405 nigel 87 break;
2406    
2407     case PT_SC:
2408 ph10 349 if ((ecode[2] != prop->script) == (op == OP_PROP))
2409 ph10 510 MRRETURN(MATCH_NOMATCH);
2410 nigel 87 break;
2411 ph10 527
2412 ph10 517 /* These are specials */
2413 ph10 527
2414 ph10 517 case PT_ALNUM:
2415     if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2416     _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2417     MRRETURN(MATCH_NOMATCH);
2418 ph10 527 break;
2419    
2420 ph10 517 case PT_SPACE: /* Perl space */
2421     if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2422     c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2423     == (op == OP_NOTPROP))
2424     MRRETURN(MATCH_NOMATCH);
2425 ph10 527 break;
2426    
2427 ph10 517 case PT_PXSPACE: /* POSIX space */
2428     if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2429 ph10 527 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2430 ph10 517 c == CHAR_FF || c == CHAR_CR)
2431     == (op == OP_NOTPROP))
2432     MRRETURN(MATCH_NOMATCH);
2433 ph10 527 break;
2434 nigel 87
2435 ph10 527 case PT_WORD:
2436 ph10 517 if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2437 ph10 527 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2438 ph10 517 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2439     MRRETURN(MATCH_NOMATCH);
2440 ph10 527 break;
2441    
2442 ph10 517 /* This should never occur */
2443    
2444 nigel 87 default:
2445     RRETURN(PCRE_ERROR_INTERNAL);
2446 nigel 77 }
2447 nigel 87
2448     ecode += 3;
2449 nigel 77 }
2450     break;
2451    
2452     /* Match an extended Unicode sequence. We will get here only if the support
2453     is in the binary; otherwise a compile-time error occurs. */
2454    
2455     case OP_EXTUNI:
2456 ph10 443 if (eptr >= md->end_subject)
2457 ph10 428 {
2458 ph10 443 SCHECK_PARTIAL();
2459 ph10 510 MRRETURN(MATCH_NOMATCH);
2460 ph10 443 }
2461 nigel 77 GETCHARINCTEST(c, eptr);
2462 ph10 623 if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);
2463     while (eptr < md->end_subject)
2464 nigel 77 {
2465 ph10 623 int len = 1;
2466     if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2467     if (UCD_CATEGORY(c) != ucp_M) break;
2468     eptr += len;
2469 nigel 77 }
2470     ecode++;
2471     break;
2472     #endif
2473    
2474    
2475     /* Match a back reference, possibly repeatedly. Look past the end of the
2476     item to see if there is repeat information following. The code is similar
2477     to that for character classes, but repeated for efficiency. Then obey
2478     similar code to character type repeats - written out again for speed.
2479     However, if the referenced string is the empty string, always treat
2480     it as matched, any number of times (otherwise there could be infinite
2481     loops). */
2482    
2483     case OP_REF:
2484 ph10 625 case OP_REFI:
2485     caseless = op == OP_REFI;
2486 ph10 595 offset = GET2(ecode, 1) << 1; /* Doubled ref number */
2487     ecode += 3;
2488 ph10 345
2489 ph10 595 /* If the reference is unset, there are two possibilities:
2490 ph10 345
2491 ph10 595 (a) In the default, Perl-compatible state, set the length negative;
2492     this ensures that every attempt at a match fails. We can't just fail
2493     here, because of the possibility of quantifiers with zero minima.
2494 ph10 345
2495 ph10 595 (b) If the JavaScript compatibility flag is set, set the length to zero
2496     so that the back reference matches an empty string.
2497 ph10 345
2498 ph10 595 Otherwise, set the length to the length of what was matched by the
2499     referenced subpattern. */
2500 ph10 345
2501 ph10 595 if (offset >= offset_top || md->offset_vector[offset] < 0)
2502     length = (md->jscript_compat)? 0 : -1;
2503     else
2504     length = md->offset_vector[offset+1] - md->offset_vector[offset];
2505 nigel 77
2506 ph10 595 /* Set up for repetition, or handle the non-repeated case */
2507 nigel 77
2508 ph10 595 switch (*ecode)
2509     {
2510     case OP_CRSTAR:
2511     case OP_CRMINSTAR:
2512     case OP_CRPLUS:
2513     case OP_CRMINPLUS:
2514     case OP_CRQUERY:
2515     case OP_CRMINQUERY:
2516     c = *ecode++ - OP_CRSTAR;
2517     minimize = (c & 1) != 0;
2518     min = rep_min[c]; /* Pick up values from tables; */
2519     max = rep_max[c]; /* zero for max => infinity */
2520     if (max == 0) max = INT_MAX;
2521     break;
2522 nigel 77
2523 ph10 595 case OP_CRRANGE:
2524     case OP_CRMINRANGE:
2525     minimize = (*ecode == OP_CRMINRANGE);
2526     min = GET2(ecode, 1);
2527     max = GET2(ecode, 3);
2528     if (max == 0) max = INT_MAX;
2529     ecode += 5;
2530     break;
2531 nigel 77
2532 ph10 595 default: /* No repeat follows */
2533 ph10 602 if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2534 ph10 595 {
2535     CHECK_PARTIAL();
2536     MRRETURN(MATCH_NOMATCH);
2537 nigel 77 }
2538 ph10 595 eptr += length;
2539     continue; /* With the main loop */
2540     }
2541 nigel 77
2542 ph10 595 /* Handle repeated back references. If the length of the reference is
2543     zero, just continue with the main loop. */
2544 ph10 443
2545 ph10 595 if (length == 0) continue;
2546 nigel 77
2547 ph10 595 /* First, ensure the minimum number of matches are present. We get back
2548     the length of the reference string explicitly rather than passing the
2549     address of eptr, so that eptr can be a register variable. */
2550 nigel 77
2551 ph10 595 for (i = 1; i <= min; i++)
2552     {
2553 ph10 625 int slength;
2554 ph10 602 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2555 nigel 77 {
2556 ph10 595 CHECK_PARTIAL();
2557     MRRETURN(MATCH_NOMATCH);
2558 nigel 77 }
2559 ph10 595 eptr += slength;
2560     }
2561 nigel 77
2562 ph10 595 /* If min = max, continue at the same level without recursion.
2563     They are not both allowed to be zero. */
2564 nigel 77
2565 ph10 595 if (min == max) continue;
2566 nigel 77
2567 ph10 595 /* If minimizing, keep trying and advancing the pointer */
2568 nigel 77
2569 ph10 595 if (minimize)
2570     {
2571     for (fi = min;; fi++)
2572 nigel 77 {
2573 ph10 625 int slength;
2574 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
2575 ph10 595 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2576     if (fi >= max) MRRETURN(MATCH_NOMATCH);
2577 ph10 602 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2578 nigel 77 {
2579 ph10 595 CHECK_PARTIAL();
2580     MRRETURN(MATCH_NOMATCH);
2581 nigel 77 }
2582 ph10 595 eptr += slength;
2583 nigel 77 }
2584 ph10 595 /* Control never gets here */
2585     }
2586 nigel 77
2587 ph10 595 /* If maximizing, find the longest string and work backwards */
2588 nigel 77
2589 ph10 595 else
2590     {
2591     pp = eptr;
2592     for (i = min; i < max; i++)
2593 nigel 77 {
2594 ph10 625 int slength;
2595 ph10 602 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2596 nigel 77 {
2597 ph10 595 CHECK_PARTIAL();
2598     break;
2599 nigel 77 }
2600 ph10 595 eptr += slength;
2601 nigel 77 }
2602 ph10 595 while (eptr >= pp)
2603     {
2604 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
2605 ph10 595 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2606     eptr -= length;
2607     }
2608     MRRETURN(MATCH_NOMATCH);
2609 nigel 77 }
2610     /* Control never gets here */
2611    
2612     /* Match a bit-mapped character class, possibly repeatedly. This op code is
2613     used when all the characters in the class have values in the range 0-255,
2614     and either the matching is caseful, or the characters are in the range
2615     0-127 when UTF-8 processing is enabled. The only difference between
2616     OP_CLASS and OP_NCLASS occurs when a data character outside the range is
2617     encountered.
2618    
2619     First, look past the end of the item to see if there is repeat information
2620     following. Then obey similar code to character type repeats - written out
2621     again for speed. */
2622    
2623     case OP_NCLASS:
2624     case OP_CLASS:
2625     {
2626     data = ecode + 1; /* Save for matching */
2627     ecode += 33; /* Advance past the item */
2628    
2629     switch (*ecode)
2630     {
2631     case OP_CRSTAR:
2632     case OP_CRMINSTAR:
2633     case OP_CRPLUS:
2634     case OP_CRMINPLUS:
2635     case OP_CRQUERY:
2636     case OP_CRMINQUERY:
2637     c = *ecode++ - OP_CRSTAR;
2638     minimize = (c & 1) != 0;
2639     min = rep_min[c]; /* Pick up values from tables; */
2640     max = rep_max[c]; /* zero for max => infinity */
2641     if (max == 0) max = INT_MAX;
2642     break;
2643    
2644     case OP_CRRANGE:
2645     case OP_CRMINRANGE:
2646     minimize = (*ecode == OP_CRMINRANGE);
2647     min = GET2(ecode, 1);
2648     max = GET2(ecode, 3);
2649     if (max == 0) max = INT_MAX;
2650     ecode += 5;
2651     break;
2652    
2653     default: /* No repeat follows */
2654     min = max = 1;
2655     break;
2656     }
2657    
2658     /* First, ensure the minimum number of matches are present. */
2659    
2660     #ifdef SUPPORT_UTF8
2661     /* UTF-8 mode */
2662     if (utf8)
2663     {
2664     for (i = 1; i <= min; i++)
2665     {
2666 ph10 427 if (eptr >= md->end_subject)
2667 ph10 426 {
2668 ph10 428 SCHECK_PARTIAL();
2669 ph10 510 MRRETURN(MATCH_NOMATCH);
2670 ph10 427 }
2671 nigel 77 GETCHARINC(c, eptr);
2672     if (c > 255)
2673     {
2674 ph10 510 if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2675 nigel 77 }
2676     else
2677     {
2678 ph10 510 if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2679 nigel 77 }
2680     }
2681     }
2682     else
2683     #endif
2684     /* Not UTF-8 mode */
2685     {
2686     for (i = 1; i <= min; i++)
2687     {
2688 ph10 427 if (eptr >= md->end_subject)
2689 ph10 426 {
2690 ph10 428 SCHECK_PARTIAL();
2691 ph10 510 MRRETURN(MATCH_NOMATCH);
2692 ph10 427 }
2693 nigel 77 c = *eptr++;
2694 ph10 510 if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2695 nigel 77 }
2696     }
2697    
2698     /* If max == min we can continue with the main loop without the
2699     need to recurse. */
2700    
2701     if (min == max) continue;
2702    
2703     /* If minimizing, keep testing the rest of the expression and advancing
2704     the pointer while it matches the class. */
2705    
2706     if (minimize)
2707     {
2708     #ifdef SUPPORT_UTF8
2709     /* UTF-8 mode */
2710     if (utf8)
2711     {
2712     for (fi = min;; fi++)
2713     {
2714 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);
2715 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2716 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
2717 ph10 427 if (eptr >= md->end_subject)
2718 ph10 426 {
2719 ph10 427 SCHECK_PARTIAL();
2720 ph10 510 MRRETURN(MATCH_NOMATCH);
2721 ph10 427 }
2722 nigel 77 GETCHARINC(c, eptr);
2723     if (c > 255)
2724     {
2725 ph10 510 if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2726 nigel 77 }
2727     else
2728     {
2729 ph10 510 if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2730 nigel 77 }
2731     }
2732     }
2733     else
2734     #endif
2735     /* Not UTF-8 mode */
2736     {
2737     for (fi = min;; fi++)
2738     {
2739 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
2740 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2741 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
2742 ph10 427 if (eptr >= md->end_subject)
2743 ph10 426 {
2744 ph10 427 SCHECK_PARTIAL();
2745 ph10 510 MRRETURN(MATCH_NOMATCH);
2746 ph10 427 }
2747 nigel 77 c = *eptr++;
2748 ph10 510 if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2749 nigel 77 }
2750     }
2751     /* Control never gets here */
2752     }
2753    
2754     /* If maximizing, find the longest possible run, then work backwards. */
2755    
2756     else
2757     {
2758     pp = eptr;
2759    
2760     #ifdef SUPPORT_UTF8
2761     /* UTF-8 mode */
2762     if (utf8)
2763     {
2764     for (i = min; i < max; i++)
2765     {
2766     int len = 1;
2767 ph10 463 if (eptr >= md->end_subject)
2768 ph10 462 {
2769 ph10 463 SCHECK_PARTIAL();
2770 ph10 462 break;
2771 ph10 463 }
2772 nigel 77 GETCHARLEN(c, eptr, len);
2773     if (c > 255)
2774     {
2775     if (op == OP_CLASS) break;
2776     }
2777     else
2778     {
2779     if ((data[c/8] & (1 << (c&7))) == 0) break;
2780     }
2781     eptr += len;
2782     }
2783     for (;;)
2784     {
2785 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);
2786 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2787     if (eptr-- == pp) break; /* Stop if tried at original pos */
2788     BACKCHAR(eptr);
2789     }
2790     }
2791     else
2792     #endif
2793     /* Not UTF-8 mode */
2794     {
2795     for (i = min; i < max; i++)
2796     {
2797 ph10 463 if (eptr >= md->end_subject)
2798 ph10 462 {
2799 ph10 463 SCHECK_PARTIAL();
2800 ph10 462 break;
2801 ph10 463 }
2802 nigel 77 c = *eptr;
2803     if ((data[c/8] & (1 << (c&7))) == 0) break;
2804     eptr++;
2805     }
2806     while (eptr >= pp)
2807     {
2808 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);
2809 nigel 87 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2810 nigel 77 eptr--;
2811     }
2812     }
2813    
2814 ph10 510 MRRETURN(MATCH_NOMATCH);
2815 nigel 77 }
2816     }
2817     /* Control never gets here */
2818    
2819    
2820     /* Match an extended character class. This opcode is encountered only
2821 ph10 384 when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
2822     mode, because Unicode properties are supported in non-UTF-8 mode. */
2823 nigel 77
2824     #ifdef SUPPORT_UTF8
2825     case OP_XCLASS:
2826     {
2827     data = ecode + 1 + LINK_SIZE; /* Save for matching */
2828     ecode += GET(ecode, 1); /* Advance past the item */
2829    
2830     switch (*ecode)
2831     {
2832     case OP_CRSTAR:
2833     case OP_CRMINSTAR:
2834     case OP_CRPLUS:
2835     case OP_CRMINPLUS:
2836     case OP_CRQUERY:
2837     case OP_CRMINQUERY:
2838     c = *ecode++ - OP_CRSTAR;
2839     minimize = (c & 1) != 0;
2840     min = rep_min[c]; /* Pick up values from tables; */
2841     max = rep_max[c]; /* zero for max => infinity */
2842     if (max == 0) max = INT_MAX;
2843     break;
2844    
2845     case OP_CRRANGE:
2846     case OP_CRMINRANGE:
2847     minimize = (*ecode == OP_CRMINRANGE);
2848     min = GET2(ecode, 1);
2849     max = GET2(ecode, 3);
2850     if (max == 0) max = INT_MAX;
2851     ecode += 5;
2852     break;
2853    
2854     default: /* No repeat follows */
2855     min = max = 1;
2856     break;
2857     }
2858    
2859     /* First, ensure the minimum number of matches are present. */
2860    
2861     for (i = 1; i <= min; i++)
2862     {
2863 ph10 427 if (eptr >= md->end_subject)
2864 ph10 426 {
2865     SCHECK_PARTIAL();
2866 ph10 510 MRRETURN(MATCH_NOMATCH);
2867 ph10 427 }
2868 ph10 384 GETCHARINCTEST(c, eptr);
2869 ph10 510 if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2870 nigel 77 }
2871    
2872     /* If max == min we can continue with the main loop without the
2873     need to recurse. */
2874    
2875     if (min == max) continue;
2876    
2877     /* If minimizing, keep testing the rest of the expression and advancing
2878     the pointer while it matches the class. */
2879    
2880     if (minimize)
2881     {
2882     for (fi = min;; fi++)
2883     {
2884 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);
2885 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2886 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
2887 ph10 427 if (eptr >= md->end_subject)
2888 ph10 426 {
2889 ph10 427 SCHECK_PARTIAL();
2890 ph10 510 MRRETURN(MATCH_NOMATCH);
2891 ph10 427 }
2892 ph10 384 GETCHARINCTEST(c, eptr);
2893 ph10 510 if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2894 nigel 77 }
2895     /* Control never gets here */
2896     }
2897    
2898     /* If maximizing, find the longest possible run, then work backwards. */
2899    
2900     else
2901     {
2902     pp = eptr;
2903     for (i = min; i < max; i++)
2904     {
2905     int len = 1;
2906 ph10 463 if (eptr >= md->end_subject)
2907 ph10 462 {
2908 ph10 463 SCHECK_PARTIAL();
2909 ph10 462 break;
2910 ph10 463 }
2911 ph10 384 GETCHARLENTEST(c, eptr, len);
2912 nigel 77 if (!_pcre_xclass(c, data)) break;
2913     eptr += len;
2914     }
2915     for(;;)
2916     {
2917 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);
2918 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2919     if (eptr-- == pp) break; /* Stop if tried at original pos */
2920 ph10 214 if (utf8) BACKCHAR(eptr);
2921 nigel 77 }
2922 ph10 510 MRRETURN(MATCH_NOMATCH);
2923 nigel 77 }
2924    
2925     /* Control never gets here */
2926     }
2927     #endif /* End of XCLASS */
2928    
2929     /* Match a single character, casefully */
2930    
2931     case OP_CHAR:
2932     #ifdef SUPPORT_UTF8
2933     if (utf8)
2934     {
2935     length = 1;
2936     ecode++;
2937     GETCHARLEN(fc, ecode, length);
2938 ph10 443 if (length > md->end_subject - eptr)
2939 ph10 428 {
2940     CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */
2941 ph10 510 MRRETURN(MATCH_NOMATCH);
2942 ph10 443 }
2943 ph10 510 while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2944 nigel 77 }
2945     else
2946     #endif
2947    
2948     /* Non-UTF-8 mode */
2949     {
2950 ph10 443 if (md->end_subject - eptr < 1)
2951 ph10 428 {
2952     SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */
2953 ph10 510 MRRETURN(MATCH_NOMATCH);
2954 ph10 443 }
2955 ph10 510 if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2956 nigel 77 ecode += 2;
2957     }
2958     break;
2959    
2960     /* Match a single character, caselessly */
2961    
2962 ph10 602 case OP_CHARI:
2963 nigel 77 #ifdef SUPPORT_UTF8
2964     if (utf8)
2965     {
2966     length = 1;
2967     ecode++;
2968     GETCHARLEN(fc, ecode, length);
2969    
2970 ph10 443 if (length > md->end_subject - eptr)
2971 ph10 428 {
2972     CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */
2973 ph10 510 MRRETURN(MATCH_NOMATCH);
2974 ph10 443 }
2975 nigel 77
2976     /* If the pattern character's value is < 128, we have only one byte, and
2977     can use the fast lookup table. */
2978    
2979     if (fc < 128)
2980     {
2981 ph10 510 if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2982 nigel 77 }
2983    
2984     /* Otherwise we must pick up the subject character */
2985    
2986     else
2987     {
2988 nigel 93 unsigned int dc;
2989 nigel 77 GETCHARINC(dc, eptr);
2990     ecode += length;
2991    
2992     /* If we have Unicode property support, we can use it to test the other
2993 nigel 87 case of the character, if there is one. */
2994 nigel 77
2995     if (fc != dc)
2996     {
2997     #ifdef SUPPORT_UCP
2998 ph10 349 if (dc != UCD_OTHERCASE(fc))
2999 nigel 77 #endif
3000 ph10 510 MRRETURN(MATCH_NOMATCH);
3001 nigel 77 }
3002     }
3003     }
3004     else
3005     #endif /* SUPPORT_UTF8 */
3006    
3007     /* Non-UTF-8 mode */
3008     {
3009 ph10 443 if (md->end_subject - eptr < 1)
3010 ph10 428 {
3011 ph10 443 SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */
3012 ph10 510 MRRETURN(MATCH_NOMATCH);
3013 ph10 443 }
3014 ph10 510 if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3015 nigel 77 ecode += 2;
3016     }
3017     break;
3018    
3019 nigel 93 /* Match a single character repeatedly. */
3020 nigel 77
3021     case OP_EXACT:
3022 ph10 602 case OP_EXACTI:
3023 nigel 77 min = max = GET2(ecode, 1);
3024     ecode += 3;
3025     goto REPEATCHAR;
3026    
3027 nigel 93 case OP_POSUPTO:
3028 ph10 602 case OP_POSUPTOI:
3029 nigel 93 possessive = TRUE;
3030     /* Fall through */
3031    
3032 nigel 77 case OP_UPTO:
3033 ph10 602 case OP_UPTOI:
3034 nigel 77 case OP_MINUPTO:
3035 ph10 602 case OP_MINUPTOI:
3036 nigel 77 min = 0;
3037     max = GET2(ecode, 1);
3038 ph10 602 minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;
3039 nigel 77 ecode += 3;
3040     goto REPEATCHAR;
3041    
3042 nigel 93 case OP_POSSTAR:
3043 ph10 602 case OP_POSSTARI:
3044 nigel 93 possessive = TRUE;
3045     min = 0;
3046     max = INT_MAX;
3047     ecode++;
3048     goto REPEATCHAR;
3049    
3050     case OP_POSPLUS:
3051 ph10 602 case OP_POSPLUSI:
3052 nigel 93 possessive = TRUE;
3053     min = 1;
3054     max = INT_MAX;
3055     ecode++;
3056     goto REPEATCHAR;
3057    
3058     case OP_POSQUERY:
3059 ph10 602 case OP_POSQUERYI:
3060 nigel 93 possessive = TRUE;
3061     min = 0;
3062     max = 1;
3063     ecode++;
3064     goto REPEATCHAR;
3065    
3066 nigel 77 case OP_STAR:
3067 ph10 602 case OP_STARI:
3068 nigel 77 case OP_MINSTAR:
3069 ph10 602 case OP_MINSTARI:
3070 nigel 77 case OP_PLUS:
3071 ph10 602 case OP_PLUSI:
3072 nigel 77 case OP_MINPLUS:
3073 ph10 602 case OP_MINPLUSI:
3074 nigel 77 case OP_QUERY:
3075 ph10 602 case OP_QUERYI:
3076 nigel 77 case OP_MINQUERY:
3077 ph10 602 case OP_MINQUERYI:
3078     c = *ecode++ - ((op < OP_STARI)? OP_STAR : OP_STARI);
3079 nigel 77 minimize = (c & 1) != 0;
3080     min = rep_min[c]; /* Pick up values from tables; */
3081     max = rep_max[c]; /* zero for max => infinity */
3082     if (max == 0) max = INT_MAX;
3083    
3084 ph10 426 /* Common code for all repeated single-character matches. */
3085 nigel 77
3086     REPEATCHAR:
3087     #ifdef SUPPORT_UTF8
3088     if (utf8)
3089     {
3090     length = 1;
3091     charptr = ecode;
3092     GETCHARLEN(fc, ecode, length);
3093     ecode += length;
3094    
3095     /* Handle multibyte character matching specially here. There is
3096     support for caseless matching if UCP support is present. */
3097    
3098     if (length > 1)
3099     {
3100     #ifdef SUPPORT_UCP
3101 nigel 93 unsigned int othercase;
3102 ph10 602 if (op >= OP_STARI && /* Caseless */
3103 ph10 349 (othercase = UCD_OTHERCASE(fc)) != fc)
3104 nigel 77 oclength = _pcre_ord2utf8(othercase, occhars);
3105 ph10 115 else oclength = 0;
3106 nigel 77 #endif /* SUPPORT_UCP */
3107    
3108     for (i = 1; i <= min; i++)
3109     {
3110 ph10 426 if (eptr <= md->end_subject - length &&
3111     memcmp(eptr, charptr, length) == 0) eptr += length;
3112 ph10 123 #ifdef SUPPORT_UCP
3113 ph10 426 else if (oclength > 0 &&
3114     eptr <= md->end_subject - oclength &&
3115     memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
3116     #endif /* SUPPORT_UCP */
3117 nigel 77 else
3118     {
3119 ph10 426 CHECK_PARTIAL();
3120 ph10 510 MRRETURN(MATCH_NOMATCH);
3121 nigel 77 }
3122     }
3123    
3124     if (min == max) continue;
3125    
3126     if (minimize)
3127     {
3128     for (fi = min;; fi++)
3129     {
3130 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);
3131 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3132 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3133 ph10 426 if (eptr <= md->end_subject - length &&
3134     memcmp(eptr, charptr, length) == 0) eptr += length;
3135 ph10 123 #ifdef SUPPORT_UCP
3136 ph10 426 else if (oclength > 0 &&
3137     eptr <= md->end_subject - oclength &&
3138     memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
3139     #endif /* SUPPORT_UCP */
3140 nigel 77 else
3141     {
3142 ph10 426 CHECK_PARTIAL();
3143 ph10 510 MRRETURN(MATCH_NOMATCH);
3144 nigel 77 }
3145     }
3146     /* Control never gets here */
3147     }
3148 nigel 93
3149     else /* Maximize */
3150 nigel 77 {
3151     pp = eptr;
3152     for (i = min; i < max; i++)
3153     {
3154 ph10 426 if (eptr <= md->end_subject - length &&
3155     memcmp(eptr, charptr, length) == 0) eptr += length;
3156 ph10 123 #ifdef SUPPORT_UCP
3157 ph10 426 else if (oclength > 0 &&
3158     eptr <= md->end_subject - oclength &&
3159     memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
3160     #endif /* SUPPORT_UCP */
3161 ph10 463 else
3162 ph10 462 {
3163 ph10 463 CHECK_PARTIAL();
3164 ph10 462 break;
3165 ph10 463 }
3166 nigel 77 }
3167 nigel 93
3168     if (possessive) continue;
3169 ph10 427
3170 ph10 120 for(;;)
3171 ph10 426 {
3172 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
3173 ph10 426 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3174 ph10 510 if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
3175 ph10 115 #ifdef SUPPORT_UCP
3176 ph10 426 eptr--;
3177     BACKCHAR(eptr);
3178 ph10 123 #else /* without SUPPORT_UCP */
3179 ph10 426 eptr -= length;
3180 ph10 123 #endif /* SUPPORT_UCP */
3181 ph10 426 }
3182 nigel 77 }
3183     /* Control never gets here */
3184     }
3185    
3186     /* If the length of a UTF-8 character is 1, we fall through here, and
3187     obey the code as for non-UTF-8 characters below, though in this case the
3188     value of fc will always be < 128. */
3189     }
3190     else
3191     #endif /* SUPPORT_UTF8 */
3192    
3193     /* When not in UTF-8 mode, load a single-byte character. */
3194    
3195 ph10 426 fc = *ecode++;
3196 ph10 443
3197 nigel 77 /* The value of fc at this point is always less than 256, though we may or
3198     may not be in UTF-8 mode. The code is duplicated for the caseless and
3199     caseful cases, for speed, since matching characters is likely to be quite
3200     common. First, ensure the minimum number of matches are present. If min =
3201     max, continue at the same level without recursing. Otherwise, if
3202     minimizing, keep trying the rest of the expression and advancing one
3203     matching character if failing, up to the maximum. Alternatively, if
3204     maximizing, find the maximum number of characters and work backwards. */
3205    
3206     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3207     max, eptr));
3208    
3209 ph10 602 if (op >= OP_STARI) /* Caseless */
3210 nigel 77 {
3211     fc = md->lcc[fc];
3212     for (i = 1; i <= min; i++)
3213 ph10 426 {
3214     if (eptr >= md->end_subject)
3215     {
3216     SCHECK_PARTIAL();
3217 ph10 510 MRRETURN(MATCH_NOMATCH);
3218 ph10 426 }
3219 ph10 510 if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3220 ph10 426 }
3221 nigel 77 if (min == max) continue;
3222     if (minimize)
3223     {
3224     for (fi = min;; fi++)
3225     {
3226 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3227 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3228 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3229 ph10 426 if (eptr >= md->end_subject)
3230     {
3231 ph10 427 SCHECK_PARTIAL();
3232 ph10 510 MRRETURN(MATCH_NOMATCH);
3233 ph10 426 }
3234 ph10 510 if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3235 nigel 77 }
3236     /* Control never gets here */
3237     }
3238 nigel 93 else /* Maximize */
3239 nigel 77 {
3240     pp = eptr;
3241     for (i = min; i < max; i++)
3242     {
3243 ph10 463 if (eptr >= md->end_subject)
3244 ph10 462 {
3245     SCHECK_PARTIAL();
3246     break;
3247 ph10 463 }
3248 ph10 462 if (fc != md->lcc[*eptr]) break;
3249 nigel 77 eptr++;
3250     }
3251 ph10 427
3252 nigel 93 if (possessive) continue;
3253 ph10 427
3254 nigel 77 while (eptr >= pp)
3255     {
3256 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM25);
3257 nigel 77 eptr--;
3258     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3259     }
3260 ph10 510 MRRETURN(MATCH_NOMATCH);
3261 nigel 77 }
3262     /* Control never gets here */
3263     }
3264    
3265     /* Caseful comparisons (includes all multi-byte characters) */
3266    
3267     else
3268     {
3269 ph10 427 for (i = 1; i <= min; i++)
3270 ph10 426 {
3271     if (eptr >= md->end_subject)
3272     {
3273     SCHECK_PARTIAL();
3274 ph10 510 MRRETURN(MATCH_NOMATCH);
3275 ph10 426 }
3276 ph10 510 if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3277 ph10 427 }
3278 ph10 443
3279 nigel 77 if (min == max) continue;
3280 ph10 443
3281 nigel 77 if (minimize)
3282     {
3283     for (fi = min;; fi++)
3284     {
3285 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
3286 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3287 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3288 ph10 426 if (eptr >= md->end_subject)
3289 ph10 427 {
3290 ph10 426 SCHECK_PARTIAL();
3291 ph10 510 MRRETURN(MATCH_NOMATCH);
3292 ph10 427 }
3293 ph10 510 if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3294 nigel 77 }
3295     /* Control never gets here */
3296     }
3297 nigel 93 else /* Maximize */
3298 nigel 77 {
3299     pp = eptr;
3300     for (i = min; i < max; i++)
3301     {
3302 ph10 463 if (eptr >= md->end_subject)
3303 ph10 462 {
3304 ph10 463 SCHECK_PARTIAL();
3305 ph10 462 break;
3306 ph10 463 }
3307 ph10 462 if (fc != *eptr) break;
3308 nigel 77 eptr++;
3309     }
3310 nigel 93 if (possessive) continue;
3311 ph10 443
3312 nigel 77 while (eptr >= pp)
3313     {
3314 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM27);
3315 nigel 77 eptr--;
3316     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3317     }
3318 ph10 510 MRRETURN(MATCH_NOMATCH);
3319 nigel 77 }
3320     }
3321     /* Control never gets here */
3322    
3323     /* Match a negated single one-byte character. The character we are
3324     checking can be multibyte. */
3325    
3326     case OP_NOT:
3327 ph10 625 case OP_NOTI:
3328 ph10 443 if (eptr >= md->end_subject)
3329 ph10 428 {
3330 ph10 443 SCHECK_PARTIAL();
3331 ph10 510 MRRETURN(MATCH_NOMATCH);
3332 ph10 443 }
3333 nigel 77 ecode++;
3334     GETCHARINCTEST(c, eptr);
3335 ph10 602 if (op == OP_NOTI) /* The caseless case */
3336 nigel 77 {
3337     #ifdef SUPPORT_UTF8
3338     if (c < 256)
3339     #endif
3340     c = md->lcc[c];
3341 ph10 510 if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3342 nigel 77 }
3343 ph10 602 else /* Caseful */
3344 nigel 77 {
3345 ph10 510 if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3346 nigel 77 }
3347     break;
3348    
3349     /* Match a negated single one-byte character repeatedly. This is almost a
3350     repeat of the code for a repeated single character, but I haven't found a
3351     nice way of commoning these up that doesn't require a test of the
3352     positive/negative option for each character match. Maybe that wouldn't add
3353     very much to the time taken, but character matching *is* what this is all
3354     about... */
3355    
3356     case OP_NOTEXACT:
3357 ph10 602 case OP_NOTEXACTI:
3358 nigel 77 min = max = GET2(ecode, 1);
3359     ecode += 3;
3360     goto REPEATNOTCHAR;
3361    
3362     case OP_NOTUPTO:
3363 ph10 602 case OP_NOTUPTOI:
3364 nigel 77 case OP_NOTMINUPTO:
3365 ph10 602 case OP_NOTMINUPTOI:
3366 nigel 77 min = 0;
3367     max = GET2(ecode, 1);
3368 ph10 602 minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;
3369 nigel 77 ecode += 3;
3370     goto REPEATNOTCHAR;
3371    
3372 nigel 93 case OP_NOTPOSSTAR:
3373 ph10 602 case OP_NOTPOSSTARI:
3374 nigel 93 possessive = TRUE;
3375     min = 0;
3376     max = INT_MAX;
3377     ecode++;
3378     goto REPEATNOTCHAR;
3379    
3380     case OP_NOTPOSPLUS:
3381 ph10 602 case OP_NOTPOSPLUSI:
3382 nigel 93 possessive = TRUE;
3383     min = 1;
3384     max = INT_MAX;
3385     ecode++;
3386     goto REPEATNOTCHAR;
3387    
3388     case OP_NOTPOSQUERY:
3389 ph10 602 case OP_NOTPOSQUERYI:
3390 nigel 93 possessive = TRUE;
3391     min = 0;
3392     max = 1;
3393     ecode++;
3394     goto REPEATNOTCHAR;
3395    
3396     case OP_NOTPOSUPTO:
3397 ph10 602 case OP_NOTPOSUPTOI:
3398 nigel 93 possessive = TRUE;
3399     min = 0;
3400     max = GET2(ecode, 1);
3401     ecode += 3;
3402     goto REPEATNOTCHAR;
3403    
3404 nigel 77 case OP_NOTSTAR:
3405 ph10 602 case OP_NOTSTARI:
3406 nigel 77 case OP_NOTMINSTAR:
3407 ph10 602 case OP_NOTMINSTARI:
3408 nigel 77 case OP_NOTPLUS:
3409 ph10 602 case OP_NOTPLUSI:
3410 nigel 77 case OP_NOTMINPLUS:
3411 ph10 602 case OP_NOTMINPLUSI:
3412 nigel 77 case OP_NOTQUERY:
3413 ph10 602 case OP_NOTQUERYI:
3414 nigel 77 case OP_NOTMINQUERY:
3415 ph10 602 case OP_NOTMINQUERYI:
3416     c = *ecode++ - ((op >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR);
3417 nigel 77 minimize = (c & 1) != 0;
3418     min = rep_min[c]; /* Pick up values from tables; */
3419     max = rep_max[c]; /* zero for max => infinity */
3420     if (max == 0) max = INT_MAX;
3421    
3422 ph10 426 /* Common code for all repeated single-byte matches. */
3423 nigel 77
3424     REPEATNOTCHAR:
3425     fc = *ecode++;
3426    
3427     /* The code is duplicated for the caseless and caseful cases, for speed,
3428     since matching characters is likely to be quite common. First, ensure the
3429     minimum number of matches are present. If min = max, continue at the same
3430     level without recursing. Otherwise, if minimizing, keep trying the rest of
3431     the expression and advancing one matching character if failing, up to the
3432     maximum. Alternatively, if maximizing, find the maximum number of
3433     characters and work backwards. */
3434    
3435     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3436     max, eptr));
3437    
3438 ph10 602 if (op >= OP_NOTSTARI) /* Caseless */
3439 nigel 77 {
3440     fc = md->lcc[fc];
3441    
3442     #ifdef SUPPORT_UTF8
3443     /* UTF-8 mode */
3444     if (utf8)
3445     {
3446 nigel 93 register unsigned int d;
3447 nigel 77 for (i = 1; i <= min; i++)
3448     {
3449 ph10 426 if (eptr >= md->end_subject)
3450     {
3451     SCHECK_PARTIAL();
3452 ph10 510 MRRETURN(MATCH_NOMATCH);
3453 ph10 427 }
3454 nigel 77 GETCHARINC(d, eptr);
3455     if (d < 256) d = md->lcc[d];
3456 ph10 510 if (fc == d) MRRETURN(MATCH_NOMATCH);
3457 nigel 77 }
3458     }
3459     else
3460     #endif
3461    
3462     /* Not UTF-8 mode */
3463     {
3464     for (i = 1; i <= min; i++)
3465 ph10 426 {
3466     if (eptr >= md->end_subject)
3467     {
3468     SCHECK_PARTIAL();
3469 ph10 510 MRRETURN(MATCH_NOMATCH);
3470 ph10 427 }
3471 ph10 510 if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3472 ph10 427 }
3473 nigel 77 }
3474    
3475     if (min == max) continue;
3476    
3477     if (minimize)
3478     {
3479     #ifdef SUPPORT_UTF8
3480     /* UTF-8 mode */
3481     if (utf8)
3482     {
3483 nigel 93 register unsigned int d;
3484 nigel 77 for (fi = min;; fi++)
3485     {
3486 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
3487 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3488 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3489 ph10 427 if (eptr >= md->end_subject)
3490 ph10 426 {
3491 ph10 427 SCHECK_PARTIAL();
3492 ph10 510 MRRETURN(MATCH_NOMATCH);
3493 ph10 427 }
3494 nigel 77 GETCHARINC(d, eptr);
3495     if (d < 256) d = md->lcc[d];
3496 ph10 510 if (fc == d) MRRETURN(MATCH_NOMATCH);
3497 nigel 77 }
3498     }
3499     else
3500     #endif
3501     /* Not UTF-8 mode */
3502     {
3503     for (fi = min;; fi++)
3504     {
3505 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
3506 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3507 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3508 ph10 426 if (eptr >= md->end_subject)
3509     {
3510     SCHECK_PARTIAL();
3511 ph10 510 MRRETURN(MATCH_NOMATCH);
3512 ph10 426 }
3513 ph10 510 if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3514 nigel 77 }
3515     }
3516     /* Control never gets here */
3517     }
3518    
3519     /* Maximize case */
3520    
3521     else
3522     {
3523     pp = eptr;
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 = min; i < max; i++)
3531     {
3532     int len = 1;
3533 ph10 463 if (eptr >= md->end_subject)
3534 ph10 462 {
3535 ph10 463 SCHECK_PARTIAL();
3536 ph10 462 break;
3537 ph10 463 }
3538 nigel 77 GETCHARLEN(d, eptr, len);
3539     if (d < 256) d = md->lcc[d];
3540     if (fc == d) break;
3541     eptr += len;
3542     }
3543 nigel 93 if (possessive) continue;
3544     for(;;)
3545 nigel 77 {
3546 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
3547 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3548     if (eptr-- == pp) break; /* Stop if tried at original pos */
3549     BACKCHAR(eptr);
3550     }
3551     }
3552     else
3553     #endif
3554     /* Not UTF-8 mode */
3555     {
3556     for (i = min; i < max; i++)
3557     {
3558 ph10 463 if (eptr >= md->end_subject)
3559 ph10 462 {
3560     SCHECK_PARTIAL();
3561     break;
3562 ph10 463 }
3563 ph10 462 if (fc == md->lcc[*eptr]) break;
3564 nigel 77 eptr++;
3565     }
3566 nigel 93 if (possessive) continue;
3567 nigel 77 while (eptr >= pp)
3568     {
3569 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM31);
3570 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3571     eptr--;
3572     }
3573     }
3574    
3575 ph10 510 MRRETURN(MATCH_NOMATCH);
3576 nigel 77 }
3577     /* Control never gets here */
3578     }
3579    
3580     /* Caseful comparisons */
3581    
3582     else
3583     {
3584     #ifdef SUPPORT_UTF8
3585     /* UTF-8 mode */
3586     if (utf8)
3587     {
3588 nigel 93 register unsigned int d;
3589 nigel 77 for (i = 1; i <= min; i++)
3590     {
3591 ph10 426 if (eptr >= md->end_subject)
3592     {
3593     SCHECK_PARTIAL();
3594 ph10 510 MRRETURN(MATCH_NOMATCH);
3595 ph10 427 }
3596 nigel 77 GETCHARINC(d, eptr);
3597 ph10 510 if (fc == d) MRRETURN(MATCH_NOMATCH);
3598 nigel 77 }
3599     }
3600     else
3601     #endif
3602     /* Not UTF-8 mode */
3603     {
3604     for (i = 1; i <= min; i++)
3605 ph10 426 {
3606     if (eptr >= md->end_subject)
3607     {
3608     SCHECK_PARTIAL();
3609 ph10 510 MRRETURN(MATCH_NOMATCH);
3610 ph10 427 }
3611 ph10 510 if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3612 ph10 427 }
3613 nigel 77 }
3614    
3615     if (min == max) continue;
3616    
3617     if (minimize)
3618     {
3619     #ifdef SUPPORT_UTF8
3620     /* UTF-8 mode */
3621     if (utf8)
3622     {
3623 nigel 93 register unsigned int d;
3624 nigel 77 for (fi = min;; fi++)
3625     {
3626 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
3627 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3628 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3629 ph10 427 if (eptr >= md->end_subject)
3630 ph10 426 {
3631 ph10 427 SCHECK_PARTIAL();
3632 ph10 510 MRRETURN(MATCH_NOMATCH);
3633 ph10 427 }
3634 nigel 77 GETCHARINC(d, eptr);
3635 ph10 510 if (fc == d) MRRETURN(MATCH_NOMATCH);
3636 nigel 77 }
3637     }
3638     else
3639     #endif
3640     /* Not UTF-8 mode */
3641     {
3642     for (fi = min;; fi++)
3643     {
3644 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
3645 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3646 ph10 510 if (fi >= max) MRRETURN(MATCH_NOMATCH);
3647 ph10 426 if (eptr >= md->end_subject)
3648     {
3649     SCHECK_PARTIAL();
3650 ph10 510 MRRETURN(MATCH_NOMATCH);
3651 ph10 427 }
3652 ph10 510 if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3653 nigel 77 }
3654     }
3655     /* Control never gets here */
3656     }
3657    
3658     /* Maximize case */
3659    
3660     else
3661     {
3662     pp = eptr;
3663    
3664     #ifdef SUPPORT_UTF8
3665     /* UTF-8 mode */
3666     if (utf8)
3667     {
3668 nigel 93 register unsigned int d;
3669 nigel 77 for (i = min; i < max; i++)
3670     {
3671     int len = 1;
3672 ph10 463 if (eptr >= md->end_subject)
3673 ph10 462 {
3674 ph10 463 SCHECK_PARTIAL();
3675 ph10 462 break;
3676 ph10 463 }
3677 nigel 77 GETCHARLEN(d, eptr, len);
3678     if (fc == d) break;
3679     eptr += len;
3680     }
3681 nigel 93 if (possessive) continue;
3682 nigel 77 for(;;)
3683     {
3684 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM34);
3685 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3686     if (eptr-- == pp) break; /* Stop if tried at original pos */
3687     BACKCHAR(eptr);
3688     }
3689     }
3690     else
3691     #endif
3692     /* Not UTF-8 mode */
3693     {
3694     for (i = min; i < max; i++)
3695     {
3696 ph10 463 if (eptr >= md->end_subject)
3697 ph10 462 {
3698 ph10 463 SCHECK_PARTIAL();
3699 ph10 462 break;
3700 ph10 463 }
3701 ph10 462 if (fc == *eptr) break;
3702 nigel 77 eptr++;
3703     }
3704 nigel 93 if (possessive) continue;
3705 nigel 77 while (eptr >= pp)
3706     {
3707 ph10 604 RMATCH(eptr, ecode, offset_top, md, eptrb, RM35);
3708 nigel 77 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3709     eptr--;
3710     }
3711     }
3712    
3713 ph10 510 MRRETURN(MATCH_NOMATCH);
3714 nigel 77 }
3715     }
3716     /* Control never gets here */
3717    
3718     /* Match a single character type repeatedly; several different opcodes
3719     share code. This is very similar to the code for single characters, but we
3720     repeat it in the interests of efficiency. */
3721    
3722     case OP_TYPEEXACT:
3723     min = max = GET2(ecode, 1);
3724     minimize = TRUE;
3725     ecode += 3;
3726     goto REPEATTYPE;
3727    
3728     case OP_TYPEUPTO:
3729     case OP_TYPEMINUPTO:
3730     min = 0;
3731     max = GET2(ecode, 1);
3732     minimize = *ecode == OP_TYPEMINUPTO;
3733     ecode += 3;
3734     goto REPEATTYPE;
3735    
3736 nigel 93 case OP_TYPEPOSSTAR:
3737     possessive = TRUE;
3738     min = 0;
3739     max = INT_MAX;
3740     ecode++;
3741     goto REPEATTYPE;
3742    
3743     case OP_TYPEPOSPLUS:
3744     possessive = TRUE;
3745     min = 1;
3746     max = INT_MAX;
3747     ecode++;
3748     goto REPEATTYPE;
3749    
3750     case OP_TYPEPOSQUERY:
3751     possessive = TRUE;
3752     min = 0;
3753     max = 1;
3754     ecode++;
3755     goto REPEATTYPE;
3756    
3757     case OP_TYPEPOSUPTO:
3758     possessive = TRUE;
3759     min = 0;
3760     max = GET2(ecode, 1);
3761     ecode += 3;
3762     goto REPEATTYPE;
3763    
3764 nigel 77 case OP_TYPESTAR:
3765     case OP_TYPEMINSTAR:
3766     case OP_TYPEPLUS:
3767     case OP_TYPEMINPLUS:
3768     case OP_TYPEQUERY:
3769     case OP_TYPEMINQUERY:
3770     c = *ecode++ - OP_TYPESTAR;
3771     minimize = (c & 1) != 0;
3772     min = rep_min[c]; /* Pick up values from tables; */
3773     max = rep_max[c]; /* zero for max => infinity */
3774     if (max == 0) max = INT_MAX;
3775    
3776     /* Common code for all repeated single character type matches. Note that
3777     in UTF-8 mode, '.' matches a character of any length, but for the other
3778     character types, the valid characters are all one-byte long. */
3779    
3780     REPEATTYPE:
3781     ctype = *ecode++; /* Code for the character type */
3782    
3783     #ifdef SUPPORT_UCP
3784     if (ctype == OP_PROP || ctype == OP_NOTPROP)
3785     {
3786     prop_fail_result = ctype == OP_NOTPROP;
3787     prop_type = *ecode++;
3788 nigel 87 prop_value = *ecode++;
3789 nigel 77 }
3790     else prop_type = -1;
3791     #endif
3792    
3793     /* First, ensure the minimum number of matches are present. Use inline
3794     code for maximizing the speed, and do the type test once at the start
3795 ph10 426 (i.e. keep it out of the loop). Separate the UTF-8 code completely as that
3796 nigel 77 is tidier. Also separate the UCP code, which can be the same for both UTF-8
3797     and single-bytes. */
3798    
3799     if (min > 0)
3800     {
3801     #ifdef SUPPORT_UCP
3802 nigel 87 if (prop_type >= 0)
3803 nigel 77 {
3804 nigel 87 switch(prop_type)
3805 nigel 77 {
3806 nigel 87 case PT_ANY:
3807 ph10 510 if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3808 nigel 87 for (i = 1; i <= min; i++)
3809     {
3810 ph10 427 if (eptr >= md->end_subject)
3811 ph10 426 {
3812 ph10 427 SCHECK_PARTIAL();
3813 ph10 510 MRRETURN(MATCH_NOMATCH);
3814 ph10 427 }
3815 ph10 184 GETCHARINCTEST(c, eptr);
3816 nigel 87 }
3817     break;
3818    
3819     case PT_LAMP:
3820     for (i = 1; i <= min; i++)
3821     {
3822 ph10 625 int chartype;
3823 ph10 427 if (eptr >= md->end_subject)
3824 ph10 426 {
3825 ph10 427 SCHECK_PARTIAL();
3826 ph10 510 MRRETURN(MATCH_NOMATCH);
3827 ph10 427 }
3828 ph10 184 GETCHARINCTEST(c, eptr);
3829 ph10 623 chartype = UCD_CHARTYPE(c);
3830     if ((chartype == ucp_Lu ||
3831     chartype == ucp_Ll ||
3832     chartype == ucp_Lt) == prop_fail_result)
3833 ph10 510 MRRETURN(MATCH_NOMATCH);
3834 nigel 87 }
3835     break;
3836    
3837     case PT_GC:
3838     for (i = 1; i <= min; i++)
3839     {
3840 ph10 427 if (eptr >= md->end_subject)
3841 ph10 426 {
3842 ph10 427 SCHECK_PARTIAL();
3843 ph10 510 MRRETURN(MATCH_NOMATCH);
3844 ph10 427 }
3845 ph10 184 GETCHARINCTEST(c, eptr);
3846 ph10 623 if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
3847 ph10 510 MRRETURN(MATCH_NOMATCH);
3848 nigel 87 }
3849     break;
3850    
3851     case PT_PC:
3852     for (i = 1; i <= min; i++)
3853     {</