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