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