Annotation of embedaddon/pcre/pcre_dfa_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 (but see
7: below for why this module is different).
8:
9: Written by Philip Hazel
10: Copyright (c) 1997-2011 University of Cambridge
11:
12: -----------------------------------------------------------------------------
13: Redistribution and use in source and binary forms, with or without
14: modification, are permitted provided that the following conditions are met:
15:
16: * Redistributions of source code must retain the above copyright notice,
17: this list of conditions and the following disclaimer.
18:
19: * Redistributions in binary form must reproduce the above copyright
20: notice, this list of conditions and the following disclaimer in the
21: documentation and/or other materials provided with the distribution.
22:
23: * Neither the name of the University of Cambridge nor the names of its
24: contributors may be used to endorse or promote products derived from
25: this software without specific prior written permission.
26:
27: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: POSSIBILITY OF SUCH DAMAGE.
38: -----------------------------------------------------------------------------
39: */
40:
41:
42: /* This module contains the external function pcre_dfa_exec(), which is an
43: alternative matching function that uses a sort of DFA algorithm (not a true
44: FSM). This is NOT Perl- compatible, but it has advantages in certain
45: applications. */
46:
47:
48: /* NOTE ABOUT PERFORMANCE: A user of this function sent some code that improved
49: the performance of his patterns greatly. I could not use it as it stood, as it
50: was not thread safe, and made assumptions about pattern sizes. Also, it caused
51: test 7 to loop, and test 9 to crash with a segfault.
52:
53: The issue is the check for duplicate states, which is done by a simple linear
54: search up the state list. (Grep for "duplicate" below to find the code.) For
55: many patterns, there will never be many states active at one time, so a simple
56: linear search is fine. In patterns that have many active states, it might be a
57: bottleneck. The suggested code used an indexing scheme to remember which states
58: had previously been used for each character, and avoided the linear search when
59: it knew there was no chance of a duplicate. This was implemented when adding
60: states to the state lists.
61:
62: I wrote some thread-safe, not-limited code to try something similar at the time
63: of checking for duplicates (instead of when adding states), using index vectors
64: on the stack. It did give a 13% improvement with one specially constructed
65: pattern for certain subject strings, but on other strings and on many of the
66: simpler patterns in the test suite it did worse. The major problem, I think,
67: was the extra time to initialize the index. This had to be done for each call
68: of internal_dfa_exec(). (The supplied patch used a static vector, initialized
69: only once - I suspect this was the cause of the problems with the tests.)
70:
71: Overall, I concluded that the gains in some cases did not outweigh the losses
72: in others, so I abandoned this code. */
73:
74:
75:
76: #ifdef HAVE_CONFIG_H
77: #include "config.h"
78: #endif
79:
80: #define NLBLOCK md /* Block containing newline information */
81: #define PSSTART start_subject /* Field containing processed string start */
82: #define PSEND end_subject /* Field containing processed string end */
83:
84: #include "pcre_internal.h"
85:
86:
87: /* For use to indent debugging output */
88:
89: #define SP " "
90:
91:
92: /*************************************************
93: * Code parameters and static tables *
94: *************************************************/
95:
96: /* These are offsets that are used to turn the OP_TYPESTAR and friends opcodes
97: into others, under special conditions. A gap of 20 between the blocks should be
98: enough. The resulting opcodes don't have to be less than 256 because they are
99: never stored, so we push them well clear of the normal opcodes. */
100:
101: #define OP_PROP_EXTRA 300
102: #define OP_EXTUNI_EXTRA 320
103: #define OP_ANYNL_EXTRA 340
104: #define OP_HSPACE_EXTRA 360
105: #define OP_VSPACE_EXTRA 380
106:
107:
108: /* This table identifies those opcodes that are followed immediately by a
109: character that is to be tested in some way. This makes it possible to
110: centralize the loading of these characters. In the case of Type * etc, the
111: "character" is the opcode for \D, \d, \S, \s, \W, or \w, which will always be a
112: small value. Non-zero values in the table are the offsets from the opcode where
113: the character is to be found. ***NOTE*** If the start of this table is
114: modified, the three tables that follow must also be modified. */
115:
116: static const uschar coptable[] = {
117: 0, /* End */
118: 0, 0, 0, 0, 0, /* \A, \G, \K, \B, \b */
119: 0, 0, 0, 0, 0, 0, /* \D, \d, \S, \s, \W, \w */
120: 0, 0, 0, /* Any, AllAny, Anybyte */
121: 0, 0, /* \P, \p */
122: 0, 0, 0, 0, 0, /* \R, \H, \h, \V, \v */
123: 0, /* \X */
124: 0, 0, 0, 0, 0, 0, /* \Z, \z, ^, ^M, $, $M */
125: 1, /* Char */
126: 1, /* Chari */
127: 1, /* not */
128: 1, /* noti */
129: /* Positive single-char repeats */
130: 1, 1, 1, 1, 1, 1, /* *, *?, +, +?, ?, ?? */
131: 3, 3, 3, /* upto, minupto, exact */
132: 1, 1, 1, 3, /* *+, ++, ?+, upto+ */
133: 1, 1, 1, 1, 1, 1, /* *I, *?I, +I, +?I, ?I, ??I */
134: 3, 3, 3, /* upto I, minupto I, exact I */
135: 1, 1, 1, 3, /* *+I, ++I, ?+I, upto+I */
136: /* Negative single-char repeats - only for chars < 256 */
137: 1, 1, 1, 1, 1, 1, /* NOT *, *?, +, +?, ?, ?? */
138: 3, 3, 3, /* NOT upto, minupto, exact */
139: 1, 1, 1, 3, /* NOT *+, ++, ?+, upto+ */
140: 1, 1, 1, 1, 1, 1, /* NOT *I, *?I, +I, +?I, ?I, ??I */
141: 3, 3, 3, /* NOT upto I, minupto I, exact I */
142: 1, 1, 1, 3, /* NOT *+I, ++I, ?+I, upto+I */
143: /* Positive type repeats */
144: 1, 1, 1, 1, 1, 1, /* Type *, *?, +, +?, ?, ?? */
145: 3, 3, 3, /* Type upto, minupto, exact */
146: 1, 1, 1, 3, /* Type *+, ++, ?+, upto+ */
147: /* Character class & ref repeats */
148: 0, 0, 0, 0, 0, 0, /* *, *?, +, +?, ?, ?? */
149: 0, 0, /* CRRANGE, CRMINRANGE */
150: 0, /* CLASS */
151: 0, /* NCLASS */
152: 0, /* XCLASS - variable length */
153: 0, /* REF */
154: 0, /* REFI */
155: 0, /* RECURSE */
156: 0, /* CALLOUT */
157: 0, /* Alt */
158: 0, /* Ket */
159: 0, /* KetRmax */
160: 0, /* KetRmin */
161: 0, /* KetRpos */
162: 0, /* Reverse */
163: 0, /* Assert */
164: 0, /* Assert not */
165: 0, /* Assert behind */
166: 0, /* Assert behind not */
167: 0, 0, /* ONCE, ONCE_NC */
168: 0, 0, 0, 0, 0, /* BRA, BRAPOS, CBRA, CBRAPOS, COND */
169: 0, 0, 0, 0, 0, /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND */
170: 0, 0, /* CREF, NCREF */
171: 0, 0, /* RREF, NRREF */
172: 0, /* DEF */
173: 0, 0, 0, /* BRAZERO, BRAMINZERO, BRAPOSZERO */
174: 0, 0, 0, /* MARK, PRUNE, PRUNE_ARG */
175: 0, 0, 0, 0, /* SKIP, SKIP_ARG, THEN, THEN_ARG */
176: 0, 0, 0, 0, /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT */
177: 0, 0 /* CLOSE, SKIPZERO */
178: };
179:
180: /* This table identifies those opcodes that inspect a character. It is used to
181: remember the fact that a character could have been inspected when the end of
182: the subject is reached. ***NOTE*** If the start of this table is modified, the
183: two tables that follow must also be modified. */
184:
185: static const uschar poptable[] = {
186: 0, /* End */
187: 0, 0, 0, 1, 1, /* \A, \G, \K, \B, \b */
188: 1, 1, 1, 1, 1, 1, /* \D, \d, \S, \s, \W, \w */
189: 1, 1, 1, /* Any, AllAny, Anybyte */
190: 1, 1, /* \P, \p */
191: 1, 1, 1, 1, 1, /* \R, \H, \h, \V, \v */
192: 1, /* \X */
193: 0, 0, 0, 0, 0, 0, /* \Z, \z, ^, ^M, $, $M */
194: 1, /* Char */
195: 1, /* Chari */
196: 1, /* not */
197: 1, /* noti */
198: /* Positive single-char repeats */
199: 1, 1, 1, 1, 1, 1, /* *, *?, +, +?, ?, ?? */
200: 1, 1, 1, /* upto, minupto, exact */
201: 1, 1, 1, 1, /* *+, ++, ?+, upto+ */
202: 1, 1, 1, 1, 1, 1, /* *I, *?I, +I, +?I, ?I, ??I */
203: 1, 1, 1, /* upto I, minupto I, exact I */
204: 1, 1, 1, 1, /* *+I, ++I, ?+I, upto+I */
205: /* Negative single-char repeats - only for chars < 256 */
206: 1, 1, 1, 1, 1, 1, /* NOT *, *?, +, +?, ?, ?? */
207: 1, 1, 1, /* NOT upto, minupto, exact */
208: 1, 1, 1, 1, /* NOT *+, ++, ?+, upto+ */
209: 1, 1, 1, 1, 1, 1, /* NOT *I, *?I, +I, +?I, ?I, ??I */
210: 1, 1, 1, /* NOT upto I, minupto I, exact I */
211: 1, 1, 1, 1, /* NOT *+I, ++I, ?+I, upto+I */
212: /* Positive type repeats */
213: 1, 1, 1, 1, 1, 1, /* Type *, *?, +, +?, ?, ?? */
214: 1, 1, 1, /* Type upto, minupto, exact */
215: 1, 1, 1, 1, /* Type *+, ++, ?+, upto+ */
216: /* Character class & ref repeats */
217: 1, 1, 1, 1, 1, 1, /* *, *?, +, +?, ?, ?? */
218: 1, 1, /* CRRANGE, CRMINRANGE */
219: 1, /* CLASS */
220: 1, /* NCLASS */
221: 1, /* XCLASS - variable length */
222: 0, /* REF */
223: 0, /* REFI */
224: 0, /* RECURSE */
225: 0, /* CALLOUT */
226: 0, /* Alt */
227: 0, /* Ket */
228: 0, /* KetRmax */
229: 0, /* KetRmin */
230: 0, /* KetRpos */
231: 0, /* Reverse */
232: 0, /* Assert */
233: 0, /* Assert not */
234: 0, /* Assert behind */
235: 0, /* Assert behind not */
236: 0, 0, /* ONCE, ONCE_NC */
237: 0, 0, 0, 0, 0, /* BRA, BRAPOS, CBRA, CBRAPOS, COND */
238: 0, 0, 0, 0, 0, /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND */
239: 0, 0, /* CREF, NCREF */
240: 0, 0, /* RREF, NRREF */
241: 0, /* DEF */
242: 0, 0, 0, /* BRAZERO, BRAMINZERO, BRAPOSZERO */
243: 0, 0, 0, /* MARK, PRUNE, PRUNE_ARG */
244: 0, 0, 0, 0, /* SKIP, SKIP_ARG, THEN, THEN_ARG */
245: 0, 0, 0, 0, /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT */
246: 0, 0 /* CLOSE, SKIPZERO */
247: };
248:
249: /* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,
250: and \w */
251:
252: static const uschar toptable1[] = {
253: 0, 0, 0, 0, 0, 0,
254: ctype_digit, ctype_digit,
255: ctype_space, ctype_space,
256: ctype_word, ctype_word,
257: 0, 0 /* OP_ANY, OP_ALLANY */
258: };
259:
260: static const uschar toptable2[] = {
261: 0, 0, 0, 0, 0, 0,
262: ctype_digit, 0,
263: ctype_space, 0,
264: ctype_word, 0,
265: 1, 1 /* OP_ANY, OP_ALLANY */
266: };
267:
268:
269: /* Structure for holding data about a particular state, which is in effect the
270: current data for an active path through the match tree. It must consist
271: entirely of ints because the working vector we are passed, and which we put
272: these structures in, is a vector of ints. */
273:
274: typedef struct stateblock {
275: int offset; /* Offset to opcode */
276: int count; /* Count for repeats */
277: int data; /* Some use extra data */
278: } stateblock;
279:
280: #define INTS_PER_STATEBLOCK (sizeof(stateblock)/sizeof(int))
281:
282:
283: #ifdef PCRE_DEBUG
284: /*************************************************
285: * Print character string *
286: *************************************************/
287:
288: /* Character string printing function for debugging.
289:
290: Arguments:
291: p points to string
292: length number of bytes
293: f where to print
294:
295: Returns: nothing
296: */
297:
298: static void
299: pchars(unsigned char *p, int length, FILE *f)
300: {
301: int c;
302: while (length-- > 0)
303: {
304: if (isprint(c = *(p++)))
305: fprintf(f, "%c", c);
306: else
307: fprintf(f, "\\x%02x", c);
308: }
309: }
310: #endif
311:
312:
313:
314: /*************************************************
315: * Execute a Regular Expression - DFA engine *
316: *************************************************/
317:
318: /* This internal function applies a compiled pattern to a subject string,
319: starting at a given point, using a DFA engine. This function is called from the
320: external one, possibly multiple times if the pattern is not anchored. The
321: function calls itself recursively for some kinds of subpattern.
322:
323: Arguments:
324: md the match_data block with fixed information
325: this_start_code the opening bracket of this subexpression's code
326: current_subject where we currently are in the subject string
327: start_offset start offset in the subject string
328: offsets vector to contain the matching string offsets
329: offsetcount size of same
330: workspace vector of workspace
331: wscount size of same
332: rlevel function call recursion level
333:
334: Returns: > 0 => number of match offset pairs placed in offsets
335: = 0 => offsets overflowed; longest matches are present
336: -1 => failed to match
337: < -1 => some kind of unexpected problem
338:
339: The following macros are used for adding states to the two state vectors (one
340: for the current character, one for the following character). */
341:
342: #define ADD_ACTIVE(x,y) \
343: if (active_count++ < wscount) \
344: { \
345: next_active_state->offset = (x); \
346: next_active_state->count = (y); \
347: next_active_state++; \
348: DPRINTF(("%.*sADD_ACTIVE(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \
349: } \
350: else return PCRE_ERROR_DFA_WSSIZE
351:
352: #define ADD_ACTIVE_DATA(x,y,z) \
353: if (active_count++ < wscount) \
354: { \
355: next_active_state->offset = (x); \
356: next_active_state->count = (y); \
357: next_active_state->data = (z); \
358: next_active_state++; \
359: DPRINTF(("%.*sADD_ACTIVE_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \
360: } \
361: else return PCRE_ERROR_DFA_WSSIZE
362:
363: #define ADD_NEW(x,y) \
364: if (new_count++ < wscount) \
365: { \
366: next_new_state->offset = (x); \
367: next_new_state->count = (y); \
368: next_new_state++; \
369: DPRINTF(("%.*sADD_NEW(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \
370: } \
371: else return PCRE_ERROR_DFA_WSSIZE
372:
373: #define ADD_NEW_DATA(x,y,z) \
374: if (new_count++ < wscount) \
375: { \
376: next_new_state->offset = (x); \
377: next_new_state->count = (y); \
378: next_new_state->data = (z); \
379: next_new_state++; \
380: DPRINTF(("%.*sADD_NEW_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \
381: } \
382: else return PCRE_ERROR_DFA_WSSIZE
383:
384: /* And now, here is the code */
385:
386: static int
387: internal_dfa_exec(
388: dfa_match_data *md,
389: const uschar *this_start_code,
390: const uschar *current_subject,
391: int start_offset,
392: int *offsets,
393: int offsetcount,
394: int *workspace,
395: int wscount,
396: int rlevel)
397: {
398: stateblock *active_states, *new_states, *temp_states;
399: stateblock *next_active_state, *next_new_state;
400:
401: const uschar *ctypes, *lcc, *fcc;
402: const uschar *ptr;
403: const uschar *end_code, *first_op;
404:
405: dfa_recursion_info new_recursive;
406:
407: int active_count, new_count, match_count;
408:
409: /* Some fields in the md block are frequently referenced, so we load them into
410: independent variables in the hope that this will perform better. */
411:
412: const uschar *start_subject = md->start_subject;
413: const uschar *end_subject = md->end_subject;
414: const uschar *start_code = md->start_code;
415:
416: #ifdef SUPPORT_UTF8
417: BOOL utf8 = (md->poptions & PCRE_UTF8) != 0;
418: #else
419: BOOL utf8 = FALSE;
420: #endif
421:
422: rlevel++;
423: offsetcount &= (-2);
424:
425: wscount -= 2;
426: wscount = (wscount - (wscount % (INTS_PER_STATEBLOCK * 2))) /
427: (2 * INTS_PER_STATEBLOCK);
428:
429: DPRINTF(("\n%.*s---------------------\n"
430: "%.*sCall to internal_dfa_exec f=%d\n",
431: rlevel*2-2, SP, rlevel*2-2, SP, rlevel));
432:
433: ctypes = md->tables + ctypes_offset;
434: lcc = md->tables + lcc_offset;
435: fcc = md->tables + fcc_offset;
436:
437: match_count = PCRE_ERROR_NOMATCH; /* A negative number */
438:
439: active_states = (stateblock *)(workspace + 2);
440: next_new_state = new_states = active_states + wscount;
441: new_count = 0;
442:
443: first_op = this_start_code + 1 + LINK_SIZE +
444: ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA ||
445: *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS)? 2:0);
446:
447: /* The first thing in any (sub) pattern is a bracket of some sort. Push all
448: the alternative states onto the list, and find out where the end is. This
449: makes is possible to use this function recursively, when we want to stop at a
450: matching internal ket rather than at the end.
451:
452: If the first opcode in the first alternative is OP_REVERSE, we are dealing with
453: a backward assertion. In that case, we have to find out the maximum amount to
454: move back, and set up each alternative appropriately. */
455:
456: if (*first_op == OP_REVERSE)
457: {
458: int max_back = 0;
459: int gone_back;
460:
461: end_code = this_start_code;
462: do
463: {
464: int back = GET(end_code, 2+LINK_SIZE);
465: if (back > max_back) max_back = back;
466: end_code += GET(end_code, 1);
467: }
468: while (*end_code == OP_ALT);
469:
470: /* If we can't go back the amount required for the longest lookbehind
471: pattern, go back as far as we can; some alternatives may still be viable. */
472:
473: #ifdef SUPPORT_UTF8
474: /* In character mode we have to step back character by character */
475:
476: if (utf8)
477: {
478: for (gone_back = 0; gone_back < max_back; gone_back++)
479: {
480: if (current_subject <= start_subject) break;
481: current_subject--;
482: while (current_subject > start_subject &&
483: (*current_subject & 0xc0) == 0x80)
484: current_subject--;
485: }
486: }
487: else
488: #endif
489:
490: /* In byte-mode we can do this quickly. */
491:
492: {
493: gone_back = (current_subject - max_back < start_subject)?
494: (int)(current_subject - start_subject) : max_back;
495: current_subject -= gone_back;
496: }
497:
498: /* Save the earliest consulted character */
499:
500: if (current_subject < md->start_used_ptr)
501: md->start_used_ptr = current_subject;
502:
503: /* Now we can process the individual branches. */
504:
505: end_code = this_start_code;
506: do
507: {
508: int back = GET(end_code, 2+LINK_SIZE);
509: if (back <= gone_back)
510: {
511: int bstate = (int)(end_code - start_code + 2 + 2*LINK_SIZE);
512: ADD_NEW_DATA(-bstate, 0, gone_back - back);
513: }
514: end_code += GET(end_code, 1);
515: }
516: while (*end_code == OP_ALT);
517: }
518:
519: /* This is the code for a "normal" subpattern (not a backward assertion). The
520: start of a whole pattern is always one of these. If we are at the top level,
521: we may be asked to restart matching from the same point that we reached for a
522: previous partial match. We still have to scan through the top-level branches to
523: find the end state. */
524:
525: else
526: {
527: end_code = this_start_code;
528:
529: /* Restarting */
530:
531: if (rlevel == 1 && (md->moptions & PCRE_DFA_RESTART) != 0)
532: {
533: do { end_code += GET(end_code, 1); } while (*end_code == OP_ALT);
534: new_count = workspace[1];
535: if (!workspace[0])
536: memcpy(new_states, active_states, new_count * sizeof(stateblock));
537: }
538:
539: /* Not restarting */
540:
541: else
542: {
543: int length = 1 + LINK_SIZE +
544: ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA ||
545: *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS)?
546: 2:0);
547: do
548: {
549: ADD_NEW((int)(end_code - start_code + length), 0);
550: end_code += GET(end_code, 1);
551: length = 1 + LINK_SIZE;
552: }
553: while (*end_code == OP_ALT);
554: }
555: }
556:
557: workspace[0] = 0; /* Bit indicating which vector is current */
558:
559: DPRINTF(("%.*sEnd state = %d\n", rlevel*2-2, SP, end_code - start_code));
560:
561: /* Loop for scanning the subject */
562:
563: ptr = current_subject;
564: for (;;)
565: {
566: int i, j;
567: int clen, dlen;
568: unsigned int c, d;
569: int forced_fail = 0;
570: BOOL could_continue = FALSE;
571:
572: /* Make the new state list into the active state list and empty the
573: new state list. */
574:
575: temp_states = active_states;
576: active_states = new_states;
577: new_states = temp_states;
578: active_count = new_count;
579: new_count = 0;
580:
581: workspace[0] ^= 1; /* Remember for the restarting feature */
582: workspace[1] = active_count;
583:
584: #ifdef PCRE_DEBUG
585: printf("%.*sNext character: rest of subject = \"", rlevel*2-2, SP);
586: pchars((uschar *)ptr, strlen((char *)ptr), stdout);
587: printf("\"\n");
588:
589: printf("%.*sActive states: ", rlevel*2-2, SP);
590: for (i = 0; i < active_count; i++)
591: printf("%d/%d ", active_states[i].offset, active_states[i].count);
592: printf("\n");
593: #endif
594:
595: /* Set the pointers for adding new states */
596:
597: next_active_state = active_states + active_count;
598: next_new_state = new_states;
599:
600: /* Load the current character from the subject outside the loop, as many
601: different states may want to look at it, and we assume that at least one
602: will. */
603:
604: if (ptr < end_subject)
605: {
606: clen = 1; /* Number of bytes in the character */
607: #ifdef SUPPORT_UTF8
608: if (utf8) { GETCHARLEN(c, ptr, clen); } else
609: #endif /* SUPPORT_UTF8 */
610: c = *ptr;
611: }
612: else
613: {
614: clen = 0; /* This indicates the end of the subject */
615: c = NOTACHAR; /* This value should never actually be used */
616: }
617:
618: /* Scan up the active states and act on each one. The result of an action
619: may be to add more states to the currently active list (e.g. on hitting a
620: parenthesis) or it may be to put states on the new list, for considering
621: when we move the character pointer on. */
622:
623: for (i = 0; i < active_count; i++)
624: {
625: stateblock *current_state = active_states + i;
626: BOOL caseless = FALSE;
627: const uschar *code;
628: int state_offset = current_state->offset;
629: int count, codevalue, rrc;
630:
631: #ifdef PCRE_DEBUG
632: printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
633: if (clen == 0) printf("EOL\n");
634: else if (c > 32 && c < 127) printf("'%c'\n", c);
635: else printf("0x%02x\n", c);
636: #endif
637:
638: /* A negative offset is a special case meaning "hold off going to this
639: (negated) state until the number of characters in the data field have
640: been skipped". */
641:
642: if (state_offset < 0)
643: {
644: if (current_state->data > 0)
645: {
646: DPRINTF(("%.*sSkipping this character\n", rlevel*2-2, SP));
647: ADD_NEW_DATA(state_offset, current_state->count,
648: current_state->data - 1);
649: continue;
650: }
651: else
652: {
653: current_state->offset = state_offset = -state_offset;
654: }
655: }
656:
657: /* Check for a duplicate state with the same count, and skip if found.
658: See the note at the head of this module about the possibility of improving
659: performance here. */
660:
661: for (j = 0; j < i; j++)
662: {
663: if (active_states[j].offset == state_offset &&
664: active_states[j].count == current_state->count)
665: {
666: DPRINTF(("%.*sDuplicate state: skipped\n", rlevel*2-2, SP));
667: goto NEXT_ACTIVE_STATE;
668: }
669: }
670:
671: /* The state offset is the offset to the opcode */
672:
673: code = start_code + state_offset;
674: codevalue = *code;
675:
676: /* If this opcode inspects a character, but we are at the end of the
677: subject, remember the fact for use when testing for a partial match. */
678:
679: if (clen == 0 && poptable[codevalue] != 0)
680: could_continue = TRUE;
681:
682: /* If this opcode is followed by an inline character, load it. It is
683: tempting to test for the presence of a subject character here, but that
684: is wrong, because sometimes zero repetitions of the subject are
685: permitted.
686:
687: We also use this mechanism for opcodes such as OP_TYPEPLUS that take an
688: argument that is not a data character - but is always one byte long. We
689: have to take special action to deal with \P, \p, \H, \h, \V, \v and \X in
690: this case. To keep the other cases fast, convert these ones to new opcodes.
691: */
692:
693: if (coptable[codevalue] > 0)
694: {
695: dlen = 1;
696: #ifdef SUPPORT_UTF8
697: if (utf8) { GETCHARLEN(d, (code + coptable[codevalue]), dlen); } else
698: #endif /* SUPPORT_UTF8 */
699: d = code[coptable[codevalue]];
700: if (codevalue >= OP_TYPESTAR)
701: {
702: switch(d)
703: {
704: case OP_ANYBYTE: return PCRE_ERROR_DFA_UITEM;
705: case OP_NOTPROP:
706: case OP_PROP: codevalue += OP_PROP_EXTRA; break;
707: case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;
708: case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break;
709: case OP_NOT_HSPACE:
710: case OP_HSPACE: codevalue += OP_HSPACE_EXTRA; break;
711: case OP_NOT_VSPACE:
712: case OP_VSPACE: codevalue += OP_VSPACE_EXTRA; break;
713: default: break;
714: }
715: }
716: }
717: else
718: {
719: dlen = 0; /* Not strictly necessary, but compilers moan */
720: d = NOTACHAR; /* if these variables are not set. */
721: }
722:
723:
724: /* Now process the individual opcodes */
725:
726: switch (codevalue)
727: {
728: /* ========================================================================== */
729: /* These cases are never obeyed. This is a fudge that causes a compile-
730: time error if the vectors coptable or poptable, which are indexed by
731: opcode, are not the correct length. It seems to be the only way to do
732: such a check at compile time, as the sizeof() operator does not work
733: in the C preprocessor. */
734:
735: case OP_TABLE_LENGTH:
736: case OP_TABLE_LENGTH +
737: ((sizeof(coptable) == OP_TABLE_LENGTH) &&
738: (sizeof(poptable) == OP_TABLE_LENGTH)):
739: break;
740:
741: /* ========================================================================== */
742: /* Reached a closing bracket. If not at the end of the pattern, carry
743: on with the next opcode. For repeating opcodes, also add the repeat
744: state. Note that KETRPOS will always be encountered at the end of the
745: subpattern, because the possessive subpattern repeats are always handled
746: using recursive calls. Thus, it never adds any new states.
747:
748: At the end of the (sub)pattern, unless we have an empty string and
749: PCRE_NOTEMPTY is set, or PCRE_NOTEMPTY_ATSTART is set and we are at the
750: start of the subject, save the match data, shifting up all previous
751: matches so we always have the longest first. */
752:
753: case OP_KET:
754: case OP_KETRMIN:
755: case OP_KETRMAX:
756: case OP_KETRPOS:
757: if (code != end_code)
758: {
759: ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);
760: if (codevalue != OP_KET)
761: {
762: ADD_ACTIVE(state_offset - GET(code, 1), 0);
763: }
764: }
765: else
766: {
767: if (ptr > current_subject ||
768: ((md->moptions & PCRE_NOTEMPTY) == 0 &&
769: ((md->moptions & PCRE_NOTEMPTY_ATSTART) == 0 ||
770: current_subject > start_subject + md->start_offset)))
771: {
772: if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;
773: else if (match_count > 0 && ++match_count * 2 > offsetcount)
774: match_count = 0;
775: count = ((match_count == 0)? offsetcount : match_count * 2) - 2;
776: if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));
777: if (offsetcount >= 2)
778: {
779: offsets[0] = (int)(current_subject - start_subject);
780: offsets[1] = (int)(ptr - start_subject);
781: DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,
782: offsets[1] - offsets[0], current_subject));
783: }
784: if ((md->moptions & PCRE_DFA_SHORTEST) != 0)
785: {
786: DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
787: "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,
788: match_count, rlevel*2-2, SP));
789: return match_count;
790: }
791: }
792: }
793: break;
794:
795: /* ========================================================================== */
796: /* These opcodes add to the current list of states without looking
797: at the current character. */
798:
799: /*-----------------------------------------------------------------*/
800: case OP_ALT:
801: do { code += GET(code, 1); } while (*code == OP_ALT);
802: ADD_ACTIVE((int)(code - start_code), 0);
803: break;
804:
805: /*-----------------------------------------------------------------*/
806: case OP_BRA:
807: case OP_SBRA:
808: do
809: {
810: ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
811: code += GET(code, 1);
812: }
813: while (*code == OP_ALT);
814: break;
815:
816: /*-----------------------------------------------------------------*/
817: case OP_CBRA:
818: case OP_SCBRA:
819: ADD_ACTIVE((int)(code - start_code + 3 + LINK_SIZE), 0);
820: code += GET(code, 1);
821: while (*code == OP_ALT)
822: {
823: ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
824: code += GET(code, 1);
825: }
826: break;
827:
828: /*-----------------------------------------------------------------*/
829: case OP_BRAZERO:
830: case OP_BRAMINZERO:
831: ADD_ACTIVE(state_offset + 1, 0);
832: code += 1 + GET(code, 2);
833: while (*code == OP_ALT) code += GET(code, 1);
834: ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
835: break;
836:
837: /*-----------------------------------------------------------------*/
838: case OP_SKIPZERO:
839: code += 1 + GET(code, 2);
840: while (*code == OP_ALT) code += GET(code, 1);
841: ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
842: break;
843:
844: /*-----------------------------------------------------------------*/
845: case OP_CIRC:
846: if (ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0)
847: { ADD_ACTIVE(state_offset + 1, 0); }
848: break;
849:
850: /*-----------------------------------------------------------------*/
851: case OP_CIRCM:
852: if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||
853: (ptr != end_subject && WAS_NEWLINE(ptr)))
854: { ADD_ACTIVE(state_offset + 1, 0); }
855: break;
856:
857: /*-----------------------------------------------------------------*/
858: case OP_EOD:
859: if (ptr >= end_subject)
860: {
861: if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
862: could_continue = TRUE;
863: else { ADD_ACTIVE(state_offset + 1, 0); }
864: }
865: break;
866:
867: /*-----------------------------------------------------------------*/
868: case OP_SOD:
869: if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); }
870: break;
871:
872: /*-----------------------------------------------------------------*/
873: case OP_SOM:
874: if (ptr == start_subject + start_offset) { ADD_ACTIVE(state_offset + 1, 0); }
875: break;
876:
877:
878: /* ========================================================================== */
879: /* These opcodes inspect the next subject character, and sometimes
880: the previous one as well, but do not have an argument. The variable
881: clen contains the length of the current character and is zero if we are
882: at the end of the subject. */
883:
884: /*-----------------------------------------------------------------*/
885: case OP_ANY:
886: if (clen > 0 && !IS_NEWLINE(ptr))
887: { ADD_NEW(state_offset + 1, 0); }
888: break;
889:
890: /*-----------------------------------------------------------------*/
891: case OP_ALLANY:
892: if (clen > 0)
893: { ADD_NEW(state_offset + 1, 0); }
894: break;
895:
896: /*-----------------------------------------------------------------*/
897: case OP_EODN:
898: if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
899: could_continue = TRUE;
900: else if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))
901: { ADD_ACTIVE(state_offset + 1, 0); }
902: break;
903:
904: /*-----------------------------------------------------------------*/
905: case OP_DOLL:
906: if ((md->moptions & PCRE_NOTEOL) == 0)
907: {
908: if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
909: could_continue = TRUE;
910: else if (clen == 0 ||
911: ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
912: (ptr == end_subject - md->nllen)
913: ))
914: { ADD_ACTIVE(state_offset + 1, 0); }
915: }
916: break;
917:
918: /*-----------------------------------------------------------------*/
919: case OP_DOLLM:
920: if ((md->moptions & PCRE_NOTEOL) == 0)
921: {
922: if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
923: could_continue = TRUE;
924: else if (clen == 0 ||
925: ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr)))
926: { ADD_ACTIVE(state_offset + 1, 0); }
927: }
928: else if (IS_NEWLINE(ptr))
929: { ADD_ACTIVE(state_offset + 1, 0); }
930: break;
931:
932: /*-----------------------------------------------------------------*/
933:
934: case OP_DIGIT:
935: case OP_WHITESPACE:
936: case OP_WORDCHAR:
937: if (clen > 0 && c < 256 &&
938: ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0)
939: { ADD_NEW(state_offset + 1, 0); }
940: break;
941:
942: /*-----------------------------------------------------------------*/
943: case OP_NOT_DIGIT:
944: case OP_NOT_WHITESPACE:
945: case OP_NOT_WORDCHAR:
946: if (clen > 0 && (c >= 256 ||
947: ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0))
948: { ADD_NEW(state_offset + 1, 0); }
949: break;
950:
951: /*-----------------------------------------------------------------*/
952: case OP_WORD_BOUNDARY:
953: case OP_NOT_WORD_BOUNDARY:
954: {
955: int left_word, right_word;
956:
957: if (ptr > start_subject)
958: {
959: const uschar *temp = ptr - 1;
960: if (temp < md->start_used_ptr) md->start_used_ptr = temp;
961: #ifdef SUPPORT_UTF8
962: if (utf8) BACKCHAR(temp);
963: #endif
964: GETCHARTEST(d, temp);
965: #ifdef SUPPORT_UCP
966: if ((md->poptions & PCRE_UCP) != 0)
967: {
968: if (d == '_') left_word = TRUE; else
969: {
970: int cat = UCD_CATEGORY(d);
971: left_word = (cat == ucp_L || cat == ucp_N);
972: }
973: }
974: else
975: #endif
976: left_word = d < 256 && (ctypes[d] & ctype_word) != 0;
977: }
978: else left_word = FALSE;
979:
980: if (clen > 0)
981: {
982: #ifdef SUPPORT_UCP
983: if ((md->poptions & PCRE_UCP) != 0)
984: {
985: if (c == '_') right_word = TRUE; else
986: {
987: int cat = UCD_CATEGORY(c);
988: right_word = (cat == ucp_L || cat == ucp_N);
989: }
990: }
991: else
992: #endif
993: right_word = c < 256 && (ctypes[c] & ctype_word) != 0;
994: }
995: else right_word = FALSE;
996:
997: if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))
998: { ADD_ACTIVE(state_offset + 1, 0); }
999: }
1000: break;
1001:
1002:
1003: /*-----------------------------------------------------------------*/
1004: /* Check the next character by Unicode property. We will get here only
1005: if the support is in the binary; otherwise a compile-time error occurs.
1006: */
1007:
1008: #ifdef SUPPORT_UCP
1009: case OP_PROP:
1010: case OP_NOTPROP:
1011: if (clen > 0)
1012: {
1013: BOOL OK;
1014: const ucd_record * prop = GET_UCD(c);
1015: switch(code[1])
1016: {
1017: case PT_ANY:
1018: OK = TRUE;
1019: break;
1020:
1021: case PT_LAMP:
1022: OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1023: prop->chartype == ucp_Lt;
1024: break;
1025:
1026: case PT_GC:
1027: OK = _pcre_ucp_gentype[prop->chartype] == code[2];
1028: break;
1029:
1030: case PT_PC:
1031: OK = prop->chartype == code[2];
1032: break;
1033:
1034: case PT_SC:
1035: OK = prop->script == code[2];
1036: break;
1037:
1038: /* These are specials for combination cases. */
1039:
1040: case PT_ALNUM:
1041: OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1042: _pcre_ucp_gentype[prop->chartype] == ucp_N;
1043: break;
1044:
1045: case PT_SPACE: /* Perl space */
1046: OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1047: c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1048: break;
1049:
1050: case PT_PXSPACE: /* POSIX space */
1051: OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1052: c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1053: c == CHAR_FF || c == CHAR_CR;
1054: break;
1055:
1056: case PT_WORD:
1057: OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1058: _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1059: c == CHAR_UNDERSCORE;
1060: break;
1061:
1062: /* Should never occur, but keep compilers from grumbling. */
1063:
1064: default:
1065: OK = codevalue != OP_PROP;
1066: break;
1067: }
1068:
1069: if (OK == (codevalue == OP_PROP)) { ADD_NEW(state_offset + 3, 0); }
1070: }
1071: break;
1072: #endif
1073:
1074:
1075:
1076: /* ========================================================================== */
1077: /* These opcodes likewise inspect the subject character, but have an
1078: argument that is not a data character. It is one of these opcodes:
1079: OP_ANY, OP_ALLANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE,
1080: OP_WORDCHAR, OP_NOT_WORDCHAR. The value is loaded into d. */
1081:
1082: case OP_TYPEPLUS:
1083: case OP_TYPEMINPLUS:
1084: case OP_TYPEPOSPLUS:
1085: count = current_state->count; /* Already matched */
1086: if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1087: if (clen > 0)
1088: {
1089: if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1090: (c < 256 &&
1091: (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1092: ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
1093: {
1094: if (count > 0 && codevalue == OP_TYPEPOSPLUS)
1095: {
1096: active_count--; /* Remove non-match possibility */
1097: next_active_state--;
1098: }
1099: count++;
1100: ADD_NEW(state_offset, count);
1101: }
1102: }
1103: break;
1104:
1105: /*-----------------------------------------------------------------*/
1106: case OP_TYPEQUERY:
1107: case OP_TYPEMINQUERY:
1108: case OP_TYPEPOSQUERY:
1109: ADD_ACTIVE(state_offset + 2, 0);
1110: if (clen > 0)
1111: {
1112: if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1113: (c < 256 &&
1114: (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1115: ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
1116: {
1117: if (codevalue == OP_TYPEPOSQUERY)
1118: {
1119: active_count--; /* Remove non-match possibility */
1120: next_active_state--;
1121: }
1122: ADD_NEW(state_offset + 2, 0);
1123: }
1124: }
1125: break;
1126:
1127: /*-----------------------------------------------------------------*/
1128: case OP_TYPESTAR:
1129: case OP_TYPEMINSTAR:
1130: case OP_TYPEPOSSTAR:
1131: ADD_ACTIVE(state_offset + 2, 0);
1132: if (clen > 0)
1133: {
1134: if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1135: (c < 256 &&
1136: (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1137: ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
1138: {
1139: if (codevalue == OP_TYPEPOSSTAR)
1140: {
1141: active_count--; /* Remove non-match possibility */
1142: next_active_state--;
1143: }
1144: ADD_NEW(state_offset, 0);
1145: }
1146: }
1147: break;
1148:
1149: /*-----------------------------------------------------------------*/
1150: case OP_TYPEEXACT:
1151: count = current_state->count; /* Number already matched */
1152: if (clen > 0)
1153: {
1154: if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1155: (c < 256 &&
1156: (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1157: ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
1158: {
1159: if (++count >= GET2(code, 1))
1160: { ADD_NEW(state_offset + 4, 0); }
1161: else
1162: { ADD_NEW(state_offset, count); }
1163: }
1164: }
1165: break;
1166:
1167: /*-----------------------------------------------------------------*/
1168: case OP_TYPEUPTO:
1169: case OP_TYPEMINUPTO:
1170: case OP_TYPEPOSUPTO:
1171: ADD_ACTIVE(state_offset + 4, 0);
1172: count = current_state->count; /* Number already matched */
1173: if (clen > 0)
1174: {
1175: if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1176: (c < 256 &&
1177: (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1178: ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
1179: {
1180: if (codevalue == OP_TYPEPOSUPTO)
1181: {
1182: active_count--; /* Remove non-match possibility */
1183: next_active_state--;
1184: }
1185: if (++count >= GET2(code, 1))
1186: { ADD_NEW(state_offset + 4, 0); }
1187: else
1188: { ADD_NEW(state_offset, count); }
1189: }
1190: }
1191: break;
1192:
1193: /* ========================================================================== */
1194: /* These are virtual opcodes that are used when something like
1195: OP_TYPEPLUS has OP_PROP, OP_NOTPROP, OP_ANYNL, or OP_EXTUNI as its
1196: argument. It keeps the code above fast for the other cases. The argument
1197: is in the d variable. */
1198:
1199: #ifdef SUPPORT_UCP
1200: case OP_PROP_EXTRA + OP_TYPEPLUS:
1201: case OP_PROP_EXTRA + OP_TYPEMINPLUS:
1202: case OP_PROP_EXTRA + OP_TYPEPOSPLUS:
1203: count = current_state->count; /* Already matched */
1204: if (count > 0) { ADD_ACTIVE(state_offset + 4, 0); }
1205: if (clen > 0)
1206: {
1207: BOOL OK;
1208: const ucd_record * prop = GET_UCD(c);
1209: switch(code[2])
1210: {
1211: case PT_ANY:
1212: OK = TRUE;
1213: break;
1214:
1215: case PT_LAMP:
1216: OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1217: prop->chartype == ucp_Lt;
1218: break;
1219:
1220: case PT_GC:
1221: OK = _pcre_ucp_gentype[prop->chartype] == code[3];
1222: break;
1223:
1224: case PT_PC:
1225: OK = prop->chartype == code[3];
1226: break;
1227:
1228: case PT_SC:
1229: OK = prop->script == code[3];
1230: break;
1231:
1232: /* These are specials for combination cases. */
1233:
1234: case PT_ALNUM:
1235: OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1236: _pcre_ucp_gentype[prop->chartype] == ucp_N;
1237: break;
1238:
1239: case PT_SPACE: /* Perl space */
1240: OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1241: c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1242: break;
1243:
1244: case PT_PXSPACE: /* POSIX space */
1245: OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1246: c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1247: c == CHAR_FF || c == CHAR_CR;
1248: break;
1249:
1250: case PT_WORD:
1251: OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1252: _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1253: c == CHAR_UNDERSCORE;
1254: break;
1255:
1256: /* Should never occur, but keep compilers from grumbling. */
1257:
1258: default:
1259: OK = codevalue != OP_PROP;
1260: break;
1261: }
1262:
1263: if (OK == (d == OP_PROP))
1264: {
1265: if (count > 0 && codevalue == OP_PROP_EXTRA + OP_TYPEPOSPLUS)
1266: {
1267: active_count--; /* Remove non-match possibility */
1268: next_active_state--;
1269: }
1270: count++;
1271: ADD_NEW(state_offset, count);
1272: }
1273: }
1274: break;
1275:
1276: /*-----------------------------------------------------------------*/
1277: case OP_EXTUNI_EXTRA + OP_TYPEPLUS:
1278: case OP_EXTUNI_EXTRA + OP_TYPEMINPLUS:
1279: case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:
1280: count = current_state->count; /* Already matched */
1281: if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1282: if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
1283: {
1284: const uschar *nptr = ptr + clen;
1285: int ncount = 0;
1286: if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)
1287: {
1288: active_count--; /* Remove non-match possibility */
1289: next_active_state--;
1290: }
1291: while (nptr < end_subject)
1292: {
1293: int nd;
1294: int ndlen = 1;
1295: GETCHARLEN(nd, nptr, ndlen);
1296: if (UCD_CATEGORY(nd) != ucp_M) break;
1297: ncount++;
1298: nptr += ndlen;
1299: }
1300: count++;
1301: ADD_NEW_DATA(-state_offset, count, ncount);
1302: }
1303: break;
1304: #endif
1305:
1306: /*-----------------------------------------------------------------*/
1307: case OP_ANYNL_EXTRA + OP_TYPEPLUS:
1308: case OP_ANYNL_EXTRA + OP_TYPEMINPLUS:
1309: case OP_ANYNL_EXTRA + OP_TYPEPOSPLUS:
1310: count = current_state->count; /* Already matched */
1311: if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1312: if (clen > 0)
1313: {
1314: int ncount = 0;
1315: switch (c)
1316: {
1317: case 0x000b:
1318: case 0x000c:
1319: case 0x0085:
1320: case 0x2028:
1321: case 0x2029:
1322: if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1323: goto ANYNL01;
1324:
1325: case 0x000d:
1326: if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1327: /* Fall through */
1328:
1329: ANYNL01:
1330: case 0x000a:
1331: if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
1332: {
1333: active_count--; /* Remove non-match possibility */
1334: next_active_state--;
1335: }
1336: count++;
1337: ADD_NEW_DATA(-state_offset, count, ncount);
1338: break;
1339:
1340: default:
1341: break;
1342: }
1343: }
1344: break;
1345:
1346: /*-----------------------------------------------------------------*/
1347: case OP_VSPACE_EXTRA + OP_TYPEPLUS:
1348: case OP_VSPACE_EXTRA + OP_TYPEMINPLUS:
1349: case OP_VSPACE_EXTRA + OP_TYPEPOSPLUS:
1350: count = current_state->count; /* Already matched */
1351: if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1352: if (clen > 0)
1353: {
1354: BOOL OK;
1355: switch (c)
1356: {
1357: case 0x000a:
1358: case 0x000b:
1359: case 0x000c:
1360: case 0x000d:
1361: case 0x0085:
1362: case 0x2028:
1363: case 0x2029:
1364: OK = TRUE;
1365: break;
1366:
1367: default:
1368: OK = FALSE;
1369: break;
1370: }
1371:
1372: if (OK == (d == OP_VSPACE))
1373: {
1374: if (count > 0 && codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSPLUS)
1375: {
1376: active_count--; /* Remove non-match possibility */
1377: next_active_state--;
1378: }
1379: count++;
1380: ADD_NEW_DATA(-state_offset, count, 0);
1381: }
1382: }
1383: break;
1384:
1385: /*-----------------------------------------------------------------*/
1386: case OP_HSPACE_EXTRA + OP_TYPEPLUS:
1387: case OP_HSPACE_EXTRA + OP_TYPEMINPLUS:
1388: case OP_HSPACE_EXTRA + OP_TYPEPOSPLUS:
1389: count = current_state->count; /* Already matched */
1390: if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1391: if (clen > 0)
1392: {
1393: BOOL OK;
1394: switch (c)
1395: {
1396: case 0x09: /* HT */
1397: case 0x20: /* SPACE */
1398: case 0xa0: /* NBSP */
1399: case 0x1680: /* OGHAM SPACE MARK */
1400: case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
1401: case 0x2000: /* EN QUAD */
1402: case 0x2001: /* EM QUAD */
1403: case 0x2002: /* EN SPACE */
1404: case 0x2003: /* EM SPACE */
1405: case 0x2004: /* THREE-PER-EM SPACE */
1406: case 0x2005: /* FOUR-PER-EM SPACE */
1407: case 0x2006: /* SIX-PER-EM SPACE */
1408: case 0x2007: /* FIGURE SPACE */
1409: case 0x2008: /* PUNCTUATION SPACE */
1410: case 0x2009: /* THIN SPACE */
1411: case 0x200A: /* HAIR SPACE */
1412: case 0x202f: /* NARROW NO-BREAK SPACE */
1413: case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
1414: case 0x3000: /* IDEOGRAPHIC SPACE */
1415: OK = TRUE;
1416: break;
1417:
1418: default:
1419: OK = FALSE;
1420: break;
1421: }
1422:
1423: if (OK == (d == OP_HSPACE))
1424: {
1425: if (count > 0 && codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSPLUS)
1426: {
1427: active_count--; /* Remove non-match possibility */
1428: next_active_state--;
1429: }
1430: count++;
1431: ADD_NEW_DATA(-state_offset, count, 0);
1432: }
1433: }
1434: break;
1435:
1436: /*-----------------------------------------------------------------*/
1437: #ifdef SUPPORT_UCP
1438: case OP_PROP_EXTRA + OP_TYPEQUERY:
1439: case OP_PROP_EXTRA + OP_TYPEMINQUERY:
1440: case OP_PROP_EXTRA + OP_TYPEPOSQUERY:
1441: count = 4;
1442: goto QS1;
1443:
1444: case OP_PROP_EXTRA + OP_TYPESTAR:
1445: case OP_PROP_EXTRA + OP_TYPEMINSTAR:
1446: case OP_PROP_EXTRA + OP_TYPEPOSSTAR:
1447: count = 0;
1448:
1449: QS1:
1450:
1451: ADD_ACTIVE(state_offset + 4, 0);
1452: if (clen > 0)
1453: {
1454: BOOL OK;
1455: const ucd_record * prop = GET_UCD(c);
1456: switch(code[2])
1457: {
1458: case PT_ANY:
1459: OK = TRUE;
1460: break;
1461:
1462: case PT_LAMP:
1463: OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1464: prop->chartype == ucp_Lt;
1465: break;
1466:
1467: case PT_GC:
1468: OK = _pcre_ucp_gentype[prop->chartype] == code[3];
1469: break;
1470:
1471: case PT_PC:
1472: OK = prop->chartype == code[3];
1473: break;
1474:
1475: case PT_SC:
1476: OK = prop->script == code[3];
1477: break;
1478:
1479: /* These are specials for combination cases. */
1480:
1481: case PT_ALNUM:
1482: OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1483: _pcre_ucp_gentype[prop->chartype] == ucp_N;
1484: break;
1485:
1486: case PT_SPACE: /* Perl space */
1487: OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1488: c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1489: break;
1490:
1491: case PT_PXSPACE: /* POSIX space */
1492: OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1493: c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1494: c == CHAR_FF || c == CHAR_CR;
1495: break;
1496:
1497: case PT_WORD:
1498: OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1499: _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1500: c == CHAR_UNDERSCORE;
1501: break;
1502:
1503: /* Should never occur, but keep compilers from grumbling. */
1504:
1505: default:
1506: OK = codevalue != OP_PROP;
1507: break;
1508: }
1509:
1510: if (OK == (d == OP_PROP))
1511: {
1512: if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSSTAR ||
1513: codevalue == OP_PROP_EXTRA + OP_TYPEPOSQUERY)
1514: {
1515: active_count--; /* Remove non-match possibility */
1516: next_active_state--;
1517: }
1518: ADD_NEW(state_offset + count, 0);
1519: }
1520: }
1521: break;
1522:
1523: /*-----------------------------------------------------------------*/
1524: case OP_EXTUNI_EXTRA + OP_TYPEQUERY:
1525: case OP_EXTUNI_EXTRA + OP_TYPEMINQUERY:
1526: case OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY:
1527: count = 2;
1528: goto QS2;
1529:
1530: case OP_EXTUNI_EXTRA + OP_TYPESTAR:
1531: case OP_EXTUNI_EXTRA + OP_TYPEMINSTAR:
1532: case OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR:
1533: count = 0;
1534:
1535: QS2:
1536:
1537: ADD_ACTIVE(state_offset + 2, 0);
1538: if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
1539: {
1540: const uschar *nptr = ptr + clen;
1541: int ncount = 0;
1542: if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR ||
1543: codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY)
1544: {
1545: active_count--; /* Remove non-match possibility */
1546: next_active_state--;
1547: }
1548: while (nptr < end_subject)
1549: {
1550: int nd;
1551: int ndlen = 1;
1552: GETCHARLEN(nd, nptr, ndlen);
1553: if (UCD_CATEGORY(nd) != ucp_M) break;
1554: ncount++;
1555: nptr += ndlen;
1556: }
1557: ADD_NEW_DATA(-(state_offset + count), 0, ncount);
1558: }
1559: break;
1560: #endif
1561:
1562: /*-----------------------------------------------------------------*/
1563: case OP_ANYNL_EXTRA + OP_TYPEQUERY:
1564: case OP_ANYNL_EXTRA + OP_TYPEMINQUERY:
1565: case OP_ANYNL_EXTRA + OP_TYPEPOSQUERY:
1566: count = 2;
1567: goto QS3;
1568:
1569: case OP_ANYNL_EXTRA + OP_TYPESTAR:
1570: case OP_ANYNL_EXTRA + OP_TYPEMINSTAR:
1571: case OP_ANYNL_EXTRA + OP_TYPEPOSSTAR:
1572: count = 0;
1573:
1574: QS3:
1575: ADD_ACTIVE(state_offset + 2, 0);
1576: if (clen > 0)
1577: {
1578: int ncount = 0;
1579: switch (c)
1580: {
1581: case 0x000b:
1582: case 0x000c:
1583: case 0x0085:
1584: case 0x2028:
1585: case 0x2029:
1586: if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1587: goto ANYNL02;
1588:
1589: case 0x000d:
1590: if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1591: /* Fall through */
1592:
1593: ANYNL02:
1594: case 0x000a:
1595: if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||
1596: codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
1597: {
1598: active_count--; /* Remove non-match possibility */
1599: next_active_state--;
1600: }
1601: ADD_NEW_DATA(-(state_offset + count), 0, ncount);
1602: break;
1603:
1604: default:
1605: break;
1606: }
1607: }
1608: break;
1609:
1610: /*-----------------------------------------------------------------*/
1611: case OP_VSPACE_EXTRA + OP_TYPEQUERY:
1612: case OP_VSPACE_EXTRA + OP_TYPEMINQUERY:
1613: case OP_VSPACE_EXTRA + OP_TYPEPOSQUERY:
1614: count = 2;
1615: goto QS4;
1616:
1617: case OP_VSPACE_EXTRA + OP_TYPESTAR:
1618: case OP_VSPACE_EXTRA + OP_TYPEMINSTAR:
1619: case OP_VSPACE_EXTRA + OP_TYPEPOSSTAR:
1620: count = 0;
1621:
1622: QS4:
1623: ADD_ACTIVE(state_offset + 2, 0);
1624: if (clen > 0)
1625: {
1626: BOOL OK;
1627: switch (c)
1628: {
1629: case 0x000a:
1630: case 0x000b:
1631: case 0x000c:
1632: case 0x000d:
1633: case 0x0085:
1634: case 0x2028:
1635: case 0x2029:
1636: OK = TRUE;
1637: break;
1638:
1639: default:
1640: OK = FALSE;
1641: break;
1642: }
1643: if (OK == (d == OP_VSPACE))
1644: {
1645: if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSSTAR ||
1646: codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSQUERY)
1647: {
1648: active_count--; /* Remove non-match possibility */
1649: next_active_state--;
1650: }
1651: ADD_NEW_DATA(-(state_offset + count), 0, 0);
1652: }
1653: }
1654: break;
1655:
1656: /*-----------------------------------------------------------------*/
1657: case OP_HSPACE_EXTRA + OP_TYPEQUERY:
1658: case OP_HSPACE_EXTRA + OP_TYPEMINQUERY:
1659: case OP_HSPACE_EXTRA + OP_TYPEPOSQUERY:
1660: count = 2;
1661: goto QS5;
1662:
1663: case OP_HSPACE_EXTRA + OP_TYPESTAR:
1664: case OP_HSPACE_EXTRA + OP_TYPEMINSTAR:
1665: case OP_HSPACE_EXTRA + OP_TYPEPOSSTAR:
1666: count = 0;
1667:
1668: QS5:
1669: ADD_ACTIVE(state_offset + 2, 0);
1670: if (clen > 0)
1671: {
1672: BOOL OK;
1673: switch (c)
1674: {
1675: case 0x09: /* HT */
1676: case 0x20: /* SPACE */
1677: case 0xa0: /* NBSP */
1678: case 0x1680: /* OGHAM SPACE MARK */
1679: case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
1680: case 0x2000: /* EN QUAD */
1681: case 0x2001: /* EM QUAD */
1682: case 0x2002: /* EN SPACE */
1683: case 0x2003: /* EM SPACE */
1684: case 0x2004: /* THREE-PER-EM SPACE */
1685: case 0x2005: /* FOUR-PER-EM SPACE */
1686: case 0x2006: /* SIX-PER-EM SPACE */
1687: case 0x2007: /* FIGURE SPACE */
1688: case 0x2008: /* PUNCTUATION SPACE */
1689: case 0x2009: /* THIN SPACE */
1690: case 0x200A: /* HAIR SPACE */
1691: case 0x202f: /* NARROW NO-BREAK SPACE */
1692: case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
1693: case 0x3000: /* IDEOGRAPHIC SPACE */
1694: OK = TRUE;
1695: break;
1696:
1697: default:
1698: OK = FALSE;
1699: break;
1700: }
1701:
1702: if (OK == (d == OP_HSPACE))
1703: {
1704: if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSSTAR ||
1705: codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSQUERY)
1706: {
1707: active_count--; /* Remove non-match possibility */
1708: next_active_state--;
1709: }
1710: ADD_NEW_DATA(-(state_offset + count), 0, 0);
1711: }
1712: }
1713: break;
1714:
1715: /*-----------------------------------------------------------------*/
1716: #ifdef SUPPORT_UCP
1717: case OP_PROP_EXTRA + OP_TYPEEXACT:
1718: case OP_PROP_EXTRA + OP_TYPEUPTO:
1719: case OP_PROP_EXTRA + OP_TYPEMINUPTO:
1720: case OP_PROP_EXTRA + OP_TYPEPOSUPTO:
1721: if (codevalue != OP_PROP_EXTRA + OP_TYPEEXACT)
1722: { ADD_ACTIVE(state_offset + 6, 0); }
1723: count = current_state->count; /* Number already matched */
1724: if (clen > 0)
1725: {
1726: BOOL OK;
1727: const ucd_record * prop = GET_UCD(c);
1728: switch(code[4])
1729: {
1730: case PT_ANY:
1731: OK = TRUE;
1732: break;
1733:
1734: case PT_LAMP:
1735: OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1736: prop->chartype == ucp_Lt;
1737: break;
1738:
1739: case PT_GC:
1740: OK = _pcre_ucp_gentype[prop->chartype] == code[5];
1741: break;
1742:
1743: case PT_PC:
1744: OK = prop->chartype == code[5];
1745: break;
1746:
1747: case PT_SC:
1748: OK = prop->script == code[5];
1749: break;
1750:
1751: /* These are specials for combination cases. */
1752:
1753: case PT_ALNUM:
1754: OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1755: _pcre_ucp_gentype[prop->chartype] == ucp_N;
1756: break;
1757:
1758: case PT_SPACE: /* Perl space */
1759: OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1760: c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1761: break;
1762:
1763: case PT_PXSPACE: /* POSIX space */
1764: OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1765: c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1766: c == CHAR_FF || c == CHAR_CR;
1767: break;
1768:
1769: case PT_WORD:
1770: OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1771: _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1772: c == CHAR_UNDERSCORE;
1773: break;
1774:
1775: /* Should never occur, but keep compilers from grumbling. */
1776:
1777: default:
1778: OK = codevalue != OP_PROP;
1779: break;
1780: }
1781:
1782: if (OK == (d == OP_PROP))
1783: {
1784: if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSUPTO)
1785: {
1786: active_count--; /* Remove non-match possibility */
1787: next_active_state--;
1788: }
1789: if (++count >= GET2(code, 1))
1790: { ADD_NEW(state_offset + 6, 0); }
1791: else
1792: { ADD_NEW(state_offset, count); }
1793: }
1794: }
1795: break;
1796:
1797: /*-----------------------------------------------------------------*/
1798: case OP_EXTUNI_EXTRA + OP_TYPEEXACT:
1799: case OP_EXTUNI_EXTRA + OP_TYPEUPTO:
1800: case OP_EXTUNI_EXTRA + OP_TYPEMINUPTO:
1801: case OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO:
1802: if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)
1803: { ADD_ACTIVE(state_offset + 4, 0); }
1804: count = current_state->count; /* Number already matched */
1805: if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
1806: {
1807: const uschar *nptr = ptr + clen;
1808: int ncount = 0;
1809: if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)
1810: {
1811: active_count--; /* Remove non-match possibility */
1812: next_active_state--;
1813: }
1814: while (nptr < end_subject)
1815: {
1816: int nd;
1817: int ndlen = 1;
1818: GETCHARLEN(nd, nptr, ndlen);
1819: if (UCD_CATEGORY(nd) != ucp_M) break;
1820: ncount++;
1821: nptr += ndlen;
1822: }
1823: if (++count >= GET2(code, 1))
1824: { ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }
1825: else
1826: { ADD_NEW_DATA(-state_offset, count, ncount); }
1827: }
1828: break;
1829: #endif
1830:
1831: /*-----------------------------------------------------------------*/
1832: case OP_ANYNL_EXTRA + OP_TYPEEXACT:
1833: case OP_ANYNL_EXTRA + OP_TYPEUPTO:
1834: case OP_ANYNL_EXTRA + OP_TYPEMINUPTO:
1835: case OP_ANYNL_EXTRA + OP_TYPEPOSUPTO:
1836: if (codevalue != OP_ANYNL_EXTRA + OP_TYPEEXACT)
1837: { ADD_ACTIVE(state_offset + 4, 0); }
1838: count = current_state->count; /* Number already matched */
1839: if (clen > 0)
1840: {
1841: int ncount = 0;
1842: switch (c)
1843: {
1844: case 0x000b:
1845: case 0x000c:
1846: case 0x0085:
1847: case 0x2028:
1848: case 0x2029:
1849: if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1850: goto ANYNL03;
1851:
1852: case 0x000d:
1853: if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1854: /* Fall through */
1855:
1856: ANYNL03:
1857: case 0x000a:
1858: if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
1859: {
1860: active_count--; /* Remove non-match possibility */
1861: next_active_state--;
1862: }
1863: if (++count >= GET2(code, 1))
1864: { ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }
1865: else
1866: { ADD_NEW_DATA(-state_offset, count, ncount); }
1867: break;
1868:
1869: default:
1870: break;
1871: }
1872: }
1873: break;
1874:
1875: /*-----------------------------------------------------------------*/
1876: case OP_VSPACE_EXTRA + OP_TYPEEXACT:
1877: case OP_VSPACE_EXTRA + OP_TYPEUPTO:
1878: case OP_VSPACE_EXTRA + OP_TYPEMINUPTO:
1879: case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO:
1880: if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT)
1881: { ADD_ACTIVE(state_offset + 4, 0); }
1882: count = current_state->count; /* Number already matched */
1883: if (clen > 0)
1884: {
1885: BOOL OK;
1886: switch (c)
1887: {
1888: case 0x000a:
1889: case 0x000b:
1890: case 0x000c:
1891: case 0x000d:
1892: case 0x0085:
1893: case 0x2028:
1894: case 0x2029:
1895: OK = TRUE;
1896: break;
1897:
1898: default:
1899: OK = FALSE;
1900: }
1901:
1902: if (OK == (d == OP_VSPACE))
1903: {
1904: if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSUPTO)
1905: {
1906: active_count--; /* Remove non-match possibility */
1907: next_active_state--;
1908: }
1909: if (++count >= GET2(code, 1))
1910: { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
1911: else
1912: { ADD_NEW_DATA(-state_offset, count, 0); }
1913: }
1914: }
1915: break;
1916:
1917: /*-----------------------------------------------------------------*/
1918: case OP_HSPACE_EXTRA + OP_TYPEEXACT:
1919: case OP_HSPACE_EXTRA + OP_TYPEUPTO:
1920: case OP_HSPACE_EXTRA + OP_TYPEMINUPTO:
1921: case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO:
1922: if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT)
1923: { ADD_ACTIVE(state_offset + 4, 0); }
1924: count = current_state->count; /* Number already matched */
1925: if (clen > 0)
1926: {
1927: BOOL OK;
1928: switch (c)
1929: {
1930: case 0x09: /* HT */
1931: case 0x20: /* SPACE */
1932: case 0xa0: /* NBSP */
1933: case 0x1680: /* OGHAM SPACE MARK */
1934: case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
1935: case 0x2000: /* EN QUAD */
1936: case 0x2001: /* EM QUAD */
1937: case 0x2002: /* EN SPACE */
1938: case 0x2003: /* EM SPACE */
1939: case 0x2004: /* THREE-PER-EM SPACE */
1940: case 0x2005: /* FOUR-PER-EM SPACE */
1941: case 0x2006: /* SIX-PER-EM SPACE */
1942: case 0x2007: /* FIGURE SPACE */
1943: case 0x2008: /* PUNCTUATION SPACE */
1944: case 0x2009: /* THIN SPACE */
1945: case 0x200A: /* HAIR SPACE */
1946: case 0x202f: /* NARROW NO-BREAK SPACE */
1947: case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
1948: case 0x3000: /* IDEOGRAPHIC SPACE */
1949: OK = TRUE;
1950: break;
1951:
1952: default:
1953: OK = FALSE;
1954: break;
1955: }
1956:
1957: if (OK == (d == OP_HSPACE))
1958: {
1959: if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSUPTO)
1960: {
1961: active_count--; /* Remove non-match possibility */
1962: next_active_state--;
1963: }
1964: if (++count >= GET2(code, 1))
1965: { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
1966: else
1967: { ADD_NEW_DATA(-state_offset, count, 0); }
1968: }
1969: }
1970: break;
1971:
1972: /* ========================================================================== */
1973: /* These opcodes are followed by a character that is usually compared
1974: to the current subject character; it is loaded into d. We still get
1975: here even if there is no subject character, because in some cases zero
1976: repetitions are permitted. */
1977:
1978: /*-----------------------------------------------------------------*/
1979: case OP_CHAR:
1980: if (clen > 0 && c == d) { ADD_NEW(state_offset + dlen + 1, 0); }
1981: break;
1982:
1983: /*-----------------------------------------------------------------*/
1984: case OP_CHARI:
1985: if (clen == 0) break;
1986:
1987: #ifdef SUPPORT_UTF8
1988: if (utf8)
1989: {
1990: if (c == d) { ADD_NEW(state_offset + dlen + 1, 0); } else
1991: {
1992: unsigned int othercase;
1993: if (c < 128) othercase = fcc[c]; else
1994:
1995: /* If we have Unicode property support, we can use it to test the
1996: other case of the character. */
1997:
1998: #ifdef SUPPORT_UCP
1999: othercase = UCD_OTHERCASE(c);
2000: #else
2001: othercase = NOTACHAR;
2002: #endif
2003:
2004: if (d == othercase) { ADD_NEW(state_offset + dlen + 1, 0); }
2005: }
2006: }
2007: else
2008: #endif /* SUPPORT_UTF8 */
2009:
2010: /* Non-UTF-8 mode */
2011: {
2012: if (lcc[c] == lcc[d]) { ADD_NEW(state_offset + 2, 0); }
2013: }
2014: break;
2015:
2016:
2017: #ifdef SUPPORT_UCP
2018: /*-----------------------------------------------------------------*/
2019: /* This is a tricky one because it can match more than one character.
2020: Find out how many characters to skip, and then set up a negative state
2021: to wait for them to pass before continuing. */
2022:
2023: case OP_EXTUNI:
2024: if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
2025: {
2026: const uschar *nptr = ptr + clen;
2027: int ncount = 0;
2028: while (nptr < end_subject)
2029: {
2030: int nclen = 1;
2031: GETCHARLEN(c, nptr, nclen);
2032: if (UCD_CATEGORY(c) != ucp_M) break;
2033: ncount++;
2034: nptr += nclen;
2035: }
2036: ADD_NEW_DATA(-(state_offset + 1), 0, ncount);
2037: }
2038: break;
2039: #endif
2040:
2041: /*-----------------------------------------------------------------*/
2042: /* This is a tricky like EXTUNI because it too can match more than one
2043: character (when CR is followed by LF). In this case, set up a negative
2044: state to wait for one character to pass before continuing. */
2045:
2046: case OP_ANYNL:
2047: if (clen > 0) switch(c)
2048: {
2049: case 0x000b:
2050: case 0x000c:
2051: case 0x0085:
2052: case 0x2028:
2053: case 0x2029:
2054: if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
2055:
2056: case 0x000a:
2057: ADD_NEW(state_offset + 1, 0);
2058: break;
2059:
2060: case 0x000d:
2061: if (ptr + 1 < end_subject && ptr[1] == 0x0a)
2062: {
2063: ADD_NEW_DATA(-(state_offset + 1), 0, 1);
2064: }
2065: else
2066: {
2067: ADD_NEW(state_offset + 1, 0);
2068: }
2069: break;
2070: }
2071: break;
2072:
2073: /*-----------------------------------------------------------------*/
2074: case OP_NOT_VSPACE:
2075: if (clen > 0) switch(c)
2076: {
2077: case 0x000a:
2078: case 0x000b:
2079: case 0x000c:
2080: case 0x000d:
2081: case 0x0085:
2082: case 0x2028:
2083: case 0x2029:
2084: break;
2085:
2086: default:
2087: ADD_NEW(state_offset + 1, 0);
2088: break;
2089: }
2090: break;
2091:
2092: /*-----------------------------------------------------------------*/
2093: case OP_VSPACE:
2094: if (clen > 0) switch(c)
2095: {
2096: case 0x000a:
2097: case 0x000b:
2098: case 0x000c:
2099: case 0x000d:
2100: case 0x0085:
2101: case 0x2028:
2102: case 0x2029:
2103: ADD_NEW(state_offset + 1, 0);
2104: break;
2105:
2106: default: break;
2107: }
2108: break;
2109:
2110: /*-----------------------------------------------------------------*/
2111: case OP_NOT_HSPACE:
2112: if (clen > 0) switch(c)
2113: {
2114: case 0x09: /* HT */
2115: case 0x20: /* SPACE */
2116: case 0xa0: /* NBSP */
2117: case 0x1680: /* OGHAM SPACE MARK */
2118: case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
2119: case 0x2000: /* EN QUAD */
2120: case 0x2001: /* EM QUAD */
2121: case 0x2002: /* EN SPACE */
2122: case 0x2003: /* EM SPACE */
2123: case 0x2004: /* THREE-PER-EM SPACE */
2124: case 0x2005: /* FOUR-PER-EM SPACE */
2125: case 0x2006: /* SIX-PER-EM SPACE */
2126: case 0x2007: /* FIGURE SPACE */
2127: case 0x2008: /* PUNCTUATION SPACE */
2128: case 0x2009: /* THIN SPACE */
2129: case 0x200A: /* HAIR SPACE */
2130: case 0x202f: /* NARROW NO-BREAK SPACE */
2131: case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
2132: case 0x3000: /* IDEOGRAPHIC SPACE */
2133: break;
2134:
2135: default:
2136: ADD_NEW(state_offset + 1, 0);
2137: break;
2138: }
2139: break;
2140:
2141: /*-----------------------------------------------------------------*/
2142: case OP_HSPACE:
2143: if (clen > 0) switch(c)
2144: {
2145: case 0x09: /* HT */
2146: case 0x20: /* SPACE */
2147: case 0xa0: /* NBSP */
2148: case 0x1680: /* OGHAM SPACE MARK */
2149: case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
2150: case 0x2000: /* EN QUAD */
2151: case 0x2001: /* EM QUAD */
2152: case 0x2002: /* EN SPACE */
2153: case 0x2003: /* EM SPACE */
2154: case 0x2004: /* THREE-PER-EM SPACE */
2155: case 0x2005: /* FOUR-PER-EM SPACE */
2156: case 0x2006: /* SIX-PER-EM SPACE */
2157: case 0x2007: /* FIGURE SPACE */
2158: case 0x2008: /* PUNCTUATION SPACE */
2159: case 0x2009: /* THIN SPACE */
2160: case 0x200A: /* HAIR SPACE */
2161: case 0x202f: /* NARROW NO-BREAK SPACE */
2162: case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
2163: case 0x3000: /* IDEOGRAPHIC SPACE */
2164: ADD_NEW(state_offset + 1, 0);
2165: break;
2166: }
2167: break;
2168:
2169: /*-----------------------------------------------------------------*/
2170: /* Match a negated single character casefully. This is only used for
2171: one-byte characters, that is, we know that d < 256. The character we are
2172: checking (c) can be multibyte. */
2173:
2174: case OP_NOT:
2175: if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); }
2176: break;
2177:
2178: /*-----------------------------------------------------------------*/
2179: /* Match a negated single character caselessly. This is only used for
2180: one-byte characters, that is, we know that d < 256. The character we are
2181: checking (c) can be multibyte. */
2182:
2183: case OP_NOTI:
2184: if (clen > 0 && c != d && c != fcc[d])
2185: { ADD_NEW(state_offset + dlen + 1, 0); }
2186: break;
2187:
2188: /*-----------------------------------------------------------------*/
2189: case OP_PLUSI:
2190: case OP_MINPLUSI:
2191: case OP_POSPLUSI:
2192: case OP_NOTPLUSI:
2193: case OP_NOTMINPLUSI:
2194: case OP_NOTPOSPLUSI:
2195: caseless = TRUE;
2196: codevalue -= OP_STARI - OP_STAR;
2197:
2198: /* Fall through */
2199: case OP_PLUS:
2200: case OP_MINPLUS:
2201: case OP_POSPLUS:
2202: case OP_NOTPLUS:
2203: case OP_NOTMINPLUS:
2204: case OP_NOTPOSPLUS:
2205: count = current_state->count; /* Already matched */
2206: if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }
2207: if (clen > 0)
2208: {
2209: unsigned int otherd = NOTACHAR;
2210: if (caseless)
2211: {
2212: #ifdef SUPPORT_UTF8
2213: if (utf8 && d >= 128)
2214: {
2215: #ifdef SUPPORT_UCP
2216: otherd = UCD_OTHERCASE(d);
2217: #endif /* SUPPORT_UCP */
2218: }
2219: else
2220: #endif /* SUPPORT_UTF8 */
2221: otherd = fcc[d];
2222: }
2223: if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2224: {
2225: if (count > 0 &&
2226: (codevalue == OP_POSPLUS || codevalue == OP_NOTPOSPLUS))
2227: {
2228: active_count--; /* Remove non-match possibility */
2229: next_active_state--;
2230: }
2231: count++;
2232: ADD_NEW(state_offset, count);
2233: }
2234: }
2235: break;
2236:
2237: /*-----------------------------------------------------------------*/
2238: case OP_QUERYI:
2239: case OP_MINQUERYI:
2240: case OP_POSQUERYI:
2241: case OP_NOTQUERYI:
2242: case OP_NOTMINQUERYI:
2243: case OP_NOTPOSQUERYI:
2244: caseless = TRUE;
2245: codevalue -= OP_STARI - OP_STAR;
2246: /* Fall through */
2247: case OP_QUERY:
2248: case OP_MINQUERY:
2249: case OP_POSQUERY:
2250: case OP_NOTQUERY:
2251: case OP_NOTMINQUERY:
2252: case OP_NOTPOSQUERY:
2253: ADD_ACTIVE(state_offset + dlen + 1, 0);
2254: if (clen > 0)
2255: {
2256: unsigned int otherd = NOTACHAR;
2257: if (caseless)
2258: {
2259: #ifdef SUPPORT_UTF8
2260: if (utf8 && d >= 128)
2261: {
2262: #ifdef SUPPORT_UCP
2263: otherd = UCD_OTHERCASE(d);
2264: #endif /* SUPPORT_UCP */
2265: }
2266: else
2267: #endif /* SUPPORT_UTF8 */
2268: otherd = fcc[d];
2269: }
2270: if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2271: {
2272: if (codevalue == OP_POSQUERY || codevalue == OP_NOTPOSQUERY)
2273: {
2274: active_count--; /* Remove non-match possibility */
2275: next_active_state--;
2276: }
2277: ADD_NEW(state_offset + dlen + 1, 0);
2278: }
2279: }
2280: break;
2281:
2282: /*-----------------------------------------------------------------*/
2283: case OP_STARI:
2284: case OP_MINSTARI:
2285: case OP_POSSTARI:
2286: case OP_NOTSTARI:
2287: case OP_NOTMINSTARI:
2288: case OP_NOTPOSSTARI:
2289: caseless = TRUE;
2290: codevalue -= OP_STARI - OP_STAR;
2291: /* Fall through */
2292: case OP_STAR:
2293: case OP_MINSTAR:
2294: case OP_POSSTAR:
2295: case OP_NOTSTAR:
2296: case OP_NOTMINSTAR:
2297: case OP_NOTPOSSTAR:
2298: ADD_ACTIVE(state_offset + dlen + 1, 0);
2299: if (clen > 0)
2300: {
2301: unsigned int otherd = NOTACHAR;
2302: if (caseless)
2303: {
2304: #ifdef SUPPORT_UTF8
2305: if (utf8 && d >= 128)
2306: {
2307: #ifdef SUPPORT_UCP
2308: otherd = UCD_OTHERCASE(d);
2309: #endif /* SUPPORT_UCP */
2310: }
2311: else
2312: #endif /* SUPPORT_UTF8 */
2313: otherd = fcc[d];
2314: }
2315: if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2316: {
2317: if (codevalue == OP_POSSTAR || codevalue == OP_NOTPOSSTAR)
2318: {
2319: active_count--; /* Remove non-match possibility */
2320: next_active_state--;
2321: }
2322: ADD_NEW(state_offset, 0);
2323: }
2324: }
2325: break;
2326:
2327: /*-----------------------------------------------------------------*/
2328: case OP_EXACTI:
2329: case OP_NOTEXACTI:
2330: caseless = TRUE;
2331: codevalue -= OP_STARI - OP_STAR;
2332: /* Fall through */
2333: case OP_EXACT:
2334: case OP_NOTEXACT:
2335: count = current_state->count; /* Number already matched */
2336: if (clen > 0)
2337: {
2338: unsigned int otherd = NOTACHAR;
2339: if (caseless)
2340: {
2341: #ifdef SUPPORT_UTF8
2342: if (utf8 && d >= 128)
2343: {
2344: #ifdef SUPPORT_UCP
2345: otherd = UCD_OTHERCASE(d);
2346: #endif /* SUPPORT_UCP */
2347: }
2348: else
2349: #endif /* SUPPORT_UTF8 */
2350: otherd = fcc[d];
2351: }
2352: if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2353: {
2354: if (++count >= GET2(code, 1))
2355: { ADD_NEW(state_offset + dlen + 3, 0); }
2356: else
2357: { ADD_NEW(state_offset, count); }
2358: }
2359: }
2360: break;
2361:
2362: /*-----------------------------------------------------------------*/
2363: case OP_UPTOI:
2364: case OP_MINUPTOI:
2365: case OP_POSUPTOI:
2366: case OP_NOTUPTOI:
2367: case OP_NOTMINUPTOI:
2368: case OP_NOTPOSUPTOI:
2369: caseless = TRUE;
2370: codevalue -= OP_STARI - OP_STAR;
2371: /* Fall through */
2372: case OP_UPTO:
2373: case OP_MINUPTO:
2374: case OP_POSUPTO:
2375: case OP_NOTUPTO:
2376: case OP_NOTMINUPTO:
2377: case OP_NOTPOSUPTO:
2378: ADD_ACTIVE(state_offset + dlen + 3, 0);
2379: count = current_state->count; /* Number already matched */
2380: if (clen > 0)
2381: {
2382: unsigned int otherd = NOTACHAR;
2383: if (caseless)
2384: {
2385: #ifdef SUPPORT_UTF8
2386: if (utf8 && d >= 128)
2387: {
2388: #ifdef SUPPORT_UCP
2389: otherd = UCD_OTHERCASE(d);
2390: #endif /* SUPPORT_UCP */
2391: }
2392: else
2393: #endif /* SUPPORT_UTF8 */
2394: otherd = fcc[d];
2395: }
2396: if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2397: {
2398: if (codevalue == OP_POSUPTO || codevalue == OP_NOTPOSUPTO)
2399: {
2400: active_count--; /* Remove non-match possibility */
2401: next_active_state--;
2402: }
2403: if (++count >= GET2(code, 1))
2404: { ADD_NEW(state_offset + dlen + 3, 0); }
2405: else
2406: { ADD_NEW(state_offset, count); }
2407: }
2408: }
2409: break;
2410:
2411:
2412: /* ========================================================================== */
2413: /* These are the class-handling opcodes */
2414:
2415: case OP_CLASS:
2416: case OP_NCLASS:
2417: case OP_XCLASS:
2418: {
2419: BOOL isinclass = FALSE;
2420: int next_state_offset;
2421: const uschar *ecode;
2422:
2423: /* For a simple class, there is always just a 32-byte table, and we
2424: can set isinclass from it. */
2425:
2426: if (codevalue != OP_XCLASS)
2427: {
2428: ecode = code + 33;
2429: if (clen > 0)
2430: {
2431: isinclass = (c > 255)? (codevalue == OP_NCLASS) :
2432: ((code[1 + c/8] & (1 << (c&7))) != 0);
2433: }
2434: }
2435:
2436: /* An extended class may have a table or a list of single characters,
2437: ranges, or both, and it may be positive or negative. There's a
2438: function that sorts all this out. */
2439:
2440: else
2441: {
2442: ecode = code + GET(code, 1);
2443: if (clen > 0) isinclass = _pcre_xclass(c, code + 1 + LINK_SIZE);
2444: }
2445:
2446: /* At this point, isinclass is set for all kinds of class, and ecode
2447: points to the byte after the end of the class. If there is a
2448: quantifier, this is where it will be. */
2449:
2450: next_state_offset = (int)(ecode - start_code);
2451:
2452: switch (*ecode)
2453: {
2454: case OP_CRSTAR:
2455: case OP_CRMINSTAR:
2456: ADD_ACTIVE(next_state_offset + 1, 0);
2457: if (isinclass) { ADD_NEW(state_offset, 0); }
2458: break;
2459:
2460: case OP_CRPLUS:
2461: case OP_CRMINPLUS:
2462: count = current_state->count; /* Already matched */
2463: if (count > 0) { ADD_ACTIVE(next_state_offset + 1, 0); }
2464: if (isinclass) { count++; ADD_NEW(state_offset, count); }
2465: break;
2466:
2467: case OP_CRQUERY:
2468: case OP_CRMINQUERY:
2469: ADD_ACTIVE(next_state_offset + 1, 0);
2470: if (isinclass) { ADD_NEW(next_state_offset + 1, 0); }
2471: break;
2472:
2473: case OP_CRRANGE:
2474: case OP_CRMINRANGE:
2475: count = current_state->count; /* Already matched */
2476: if (count >= GET2(ecode, 1))
2477: { ADD_ACTIVE(next_state_offset + 5, 0); }
2478: if (isinclass)
2479: {
2480: int max = GET2(ecode, 3);
2481: if (++count >= max && max != 0) /* Max 0 => no limit */
2482: { ADD_NEW(next_state_offset + 5, 0); }
2483: else
2484: { ADD_NEW(state_offset, count); }
2485: }
2486: break;
2487:
2488: default:
2489: if (isinclass) { ADD_NEW(next_state_offset, 0); }
2490: break;
2491: }
2492: }
2493: break;
2494:
2495: /* ========================================================================== */
2496: /* These are the opcodes for fancy brackets of various kinds. We have
2497: to use recursion in order to handle them. The "always failing" assertion
2498: (?!) is optimised to OP_FAIL when compiling, so we have to support that,
2499: though the other "backtracking verbs" are not supported. */
2500:
2501: case OP_FAIL:
2502: forced_fail++; /* Count FAILs for multiple states */
2503: break;
2504:
2505: case OP_ASSERT:
2506: case OP_ASSERT_NOT:
2507: case OP_ASSERTBACK:
2508: case OP_ASSERTBACK_NOT:
2509: {
2510: int rc;
2511: int local_offsets[2];
2512: int local_workspace[1000];
2513: const uschar *endasscode = code + GET(code, 1);
2514:
2515: while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1);
2516:
2517: rc = internal_dfa_exec(
2518: md, /* static match data */
2519: code, /* this subexpression's code */
2520: ptr, /* where we currently are */
2521: (int)(ptr - start_subject), /* start offset */
2522: local_offsets, /* offset vector */
2523: sizeof(local_offsets)/sizeof(int), /* size of same */
2524: local_workspace, /* workspace vector */
2525: sizeof(local_workspace)/sizeof(int), /* size of same */
2526: rlevel); /* function recursion level */
2527:
2528: if (rc == PCRE_ERROR_DFA_UITEM) return rc;
2529: if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK))
2530: { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
2531: }
2532: break;
2533:
2534: /*-----------------------------------------------------------------*/
2535: case OP_COND:
2536: case OP_SCOND:
2537: {
2538: int local_offsets[1000];
2539: int local_workspace[1000];
2540: int codelink = GET(code, 1);
2541: int condcode;
2542:
2543: /* Because of the way auto-callout works during compile, a callout item
2544: is inserted between OP_COND and an assertion condition. This does not
2545: happen for the other conditions. */
2546:
2547: if (code[LINK_SIZE+1] == OP_CALLOUT)
2548: {
2549: rrc = 0;
2550: if (pcre_callout != NULL)
2551: {
2552: pcre_callout_block cb;
2553: cb.version = 1; /* Version 1 of the callout block */
2554: cb.callout_number = code[LINK_SIZE+2];
2555: cb.offset_vector = offsets;
2556: cb.subject = (PCRE_SPTR)start_subject;
2557: cb.subject_length = (int)(end_subject - start_subject);
2558: cb.start_match = (int)(current_subject - start_subject);
2559: cb.current_position = (int)(ptr - start_subject);
2560: cb.pattern_position = GET(code, LINK_SIZE + 3);
2561: cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);
2562: cb.capture_top = 1;
2563: cb.capture_last = -1;
2564: cb.callout_data = md->callout_data;
2565: cb.mark = NULL; /* No (*MARK) support */
2566: if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc; /* Abandon */
2567: }
2568: if (rrc > 0) break; /* Fail this thread */
2569: code += _pcre_OP_lengths[OP_CALLOUT]; /* Skip callout data */
2570: }
2571:
2572: condcode = code[LINK_SIZE+1];
2573:
2574: /* Back reference conditions are not supported */
2575:
2576: if (condcode == OP_CREF || condcode == OP_NCREF)
2577: return PCRE_ERROR_DFA_UCOND;
2578:
2579: /* The DEFINE condition is always false */
2580:
2581: if (condcode == OP_DEF)
2582: { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2583:
2584: /* The only supported version of OP_RREF is for the value RREF_ANY,
2585: which means "test if in any recursion". We can't test for specifically
2586: recursed groups. */
2587:
2588: else if (condcode == OP_RREF || condcode == OP_NRREF)
2589: {
2590: int value = GET2(code, LINK_SIZE+2);
2591: if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;
2592: if (md->recursive != NULL)
2593: { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }
2594: else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2595: }
2596:
2597: /* Otherwise, the condition is an assertion */
2598:
2599: else
2600: {
2601: int rc;
2602: const uschar *asscode = code + LINK_SIZE + 1;
2603: const uschar *endasscode = asscode + GET(asscode, 1);
2604:
2605: while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1);
2606:
2607: rc = internal_dfa_exec(
2608: md, /* fixed match data */
2609: asscode, /* this subexpression's code */
2610: ptr, /* where we currently are */
2611: (int)(ptr - start_subject), /* start offset */
2612: local_offsets, /* offset vector */
2613: sizeof(local_offsets)/sizeof(int), /* size of same */
2614: local_workspace, /* workspace vector */
2615: sizeof(local_workspace)/sizeof(int), /* size of same */
2616: rlevel); /* function recursion level */
2617:
2618: if (rc == PCRE_ERROR_DFA_UITEM) return rc;
2619: if ((rc >= 0) ==
2620: (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))
2621: { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
2622: else
2623: { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2624: }
2625: }
2626: break;
2627:
2628: /*-----------------------------------------------------------------*/
2629: case OP_RECURSE:
2630: {
2631: dfa_recursion_info *ri;
2632: int local_offsets[1000];
2633: int local_workspace[1000];
2634: const uschar *callpat = start_code + GET(code, 1);
2635: int recno = (callpat == md->start_code)? 0 :
2636: GET2(callpat, 1 + LINK_SIZE);
2637: int rc;
2638:
2639: DPRINTF(("%.*sStarting regex recursion\n", rlevel*2-2, SP));
2640:
2641: /* Check for repeating a recursion without advancing the subject
2642: pointer. This should catch convoluted mutual recursions. (Some simple
2643: cases are caught at compile time.) */
2644:
2645: for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
2646: if (recno == ri->group_num && ptr == ri->subject_position)
2647: return PCRE_ERROR_RECURSELOOP;
2648:
2649: /* Remember this recursion and where we started it so as to
2650: catch infinite loops. */
2651:
2652: new_recursive.group_num = recno;
2653: new_recursive.subject_position = ptr;
2654: new_recursive.prevrec = md->recursive;
2655: md->recursive = &new_recursive;
2656:
2657: rc = internal_dfa_exec(
2658: md, /* fixed match data */
2659: callpat, /* this subexpression's code */
2660: ptr, /* where we currently are */
2661: (int)(ptr - start_subject), /* start offset */
2662: local_offsets, /* offset vector */
2663: sizeof(local_offsets)/sizeof(int), /* size of same */
2664: local_workspace, /* workspace vector */
2665: sizeof(local_workspace)/sizeof(int), /* size of same */
2666: rlevel); /* function recursion level */
2667:
2668: md->recursive = new_recursive.prevrec; /* Done this recursion */
2669:
2670: DPRINTF(("%.*sReturn from regex recursion: rc=%d\n", rlevel*2-2, SP,
2671: rc));
2672:
2673: /* Ran out of internal offsets */
2674:
2675: if (rc == 0) return PCRE_ERROR_DFA_RECURSE;
2676:
2677: /* For each successful matched substring, set up the next state with a
2678: count of characters to skip before trying it. Note that the count is in
2679: characters, not bytes. */
2680:
2681: if (rc > 0)
2682: {
2683: for (rc = rc*2 - 2; rc >= 0; rc -= 2)
2684: {
2685: const uschar *p = start_subject + local_offsets[rc];
2686: const uschar *pp = start_subject + local_offsets[rc+1];
2687: int charcount = local_offsets[rc+1] - local_offsets[rc];
2688: while (p < pp) if ((*p++ & 0xc0) == 0x80) charcount--;
2689: if (charcount > 0)
2690: {
2691: ADD_NEW_DATA(-(state_offset + LINK_SIZE + 1), 0, (charcount - 1));
2692: }
2693: else
2694: {
2695: ADD_ACTIVE(state_offset + LINK_SIZE + 1, 0);
2696: }
2697: }
2698: }
2699: else if (rc != PCRE_ERROR_NOMATCH) return rc;
2700: }
2701: break;
2702:
2703: /*-----------------------------------------------------------------*/
2704: case OP_BRAPOS:
2705: case OP_SBRAPOS:
2706: case OP_CBRAPOS:
2707: case OP_SCBRAPOS:
2708: case OP_BRAPOSZERO:
2709: {
2710: int charcount, matched_count;
2711: const uschar *local_ptr = ptr;
2712: BOOL allow_zero;
2713:
2714: if (codevalue == OP_BRAPOSZERO)
2715: {
2716: allow_zero = TRUE;
2717: codevalue = *(++code); /* Codevalue will be one of above BRAs */
2718: }
2719: else allow_zero = FALSE;
2720:
2721: /* Loop to match the subpattern as many times as possible as if it were
2722: a complete pattern. */
2723:
2724: for (matched_count = 0;; matched_count++)
2725: {
2726: int local_offsets[2];
2727: int local_workspace[1000];
2728:
2729: int rc = internal_dfa_exec(
2730: md, /* fixed match data */
2731: code, /* this subexpression's code */
2732: local_ptr, /* where we currently are */
2733: (int)(ptr - start_subject), /* start offset */
2734: local_offsets, /* offset vector */
2735: sizeof(local_offsets)/sizeof(int), /* size of same */
2736: local_workspace, /* workspace vector */
2737: sizeof(local_workspace)/sizeof(int), /* size of same */
2738: rlevel); /* function recursion level */
2739:
2740: /* Failed to match */
2741:
2742: if (rc < 0)
2743: {
2744: if (rc != PCRE_ERROR_NOMATCH) return rc;
2745: break;
2746: }
2747:
2748: /* Matched: break the loop if zero characters matched. */
2749:
2750: charcount = local_offsets[1] - local_offsets[0];
2751: if (charcount == 0) break;
2752: local_ptr += charcount; /* Advance temporary position ptr */
2753: }
2754:
2755: /* At this point we have matched the subpattern matched_count
2756: times, and local_ptr is pointing to the character after the end of the
2757: last match. */
2758:
2759: if (matched_count > 0 || allow_zero)
2760: {
2761: const uschar *end_subpattern = code;
2762: int next_state_offset;
2763:
2764: do { end_subpattern += GET(end_subpattern, 1); }
2765: while (*end_subpattern == OP_ALT);
2766: next_state_offset =
2767: (int)(end_subpattern - start_code + LINK_SIZE + 1);
2768:
2769: /* Optimization: if there are no more active states, and there
2770: are no new states yet set up, then skip over the subject string
2771: right here, to save looping. Otherwise, set up the new state to swing
2772: into action when the end of the matched substring is reached. */
2773:
2774: if (i + 1 >= active_count && new_count == 0)
2775: {
2776: ptr = local_ptr;
2777: clen = 0;
2778: ADD_NEW(next_state_offset, 0);
2779: }
2780: else
2781: {
2782: const uschar *p = ptr;
2783: const uschar *pp = local_ptr;
2784: charcount = (int)(pp - p);
2785: while (p < pp) if ((*p++ & 0xc0) == 0x80) charcount--;
2786: ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
2787: }
2788: }
2789: }
2790: break;
2791:
2792: /*-----------------------------------------------------------------*/
2793: case OP_ONCE:
2794: case OP_ONCE_NC:
2795: {
2796: int local_offsets[2];
2797: int local_workspace[1000];
2798:
2799: int rc = internal_dfa_exec(
2800: md, /* fixed match data */
2801: code, /* this subexpression's code */
2802: ptr, /* where we currently are */
2803: (int)(ptr - start_subject), /* start offset */
2804: local_offsets, /* offset vector */
2805: sizeof(local_offsets)/sizeof(int), /* size of same */
2806: local_workspace, /* workspace vector */
2807: sizeof(local_workspace)/sizeof(int), /* size of same */
2808: rlevel); /* function recursion level */
2809:
2810: if (rc >= 0)
2811: {
2812: const uschar *end_subpattern = code;
2813: int charcount = local_offsets[1] - local_offsets[0];
2814: int next_state_offset, repeat_state_offset;
2815:
2816: do { end_subpattern += GET(end_subpattern, 1); }
2817: while (*end_subpattern == OP_ALT);
2818: next_state_offset =
2819: (int)(end_subpattern - start_code + LINK_SIZE + 1);
2820:
2821: /* If the end of this subpattern is KETRMAX or KETRMIN, we must
2822: arrange for the repeat state also to be added to the relevant list.
2823: Calculate the offset, or set -1 for no repeat. */
2824:
2825: repeat_state_offset = (*end_subpattern == OP_KETRMAX ||
2826: *end_subpattern == OP_KETRMIN)?
2827: (int)(end_subpattern - start_code - GET(end_subpattern, 1)) : -1;
2828:
2829: /* If we have matched an empty string, add the next state at the
2830: current character pointer. This is important so that the duplicate
2831: checking kicks in, which is what breaks infinite loops that match an
2832: empty string. */
2833:
2834: if (charcount == 0)
2835: {
2836: ADD_ACTIVE(next_state_offset, 0);
2837: }
2838:
2839: /* Optimization: if there are no more active states, and there
2840: are no new states yet set up, then skip over the subject string
2841: right here, to save looping. Otherwise, set up the new state to swing
2842: into action when the end of the matched substring is reached. */
2843:
2844: else if (i + 1 >= active_count && new_count == 0)
2845: {
2846: ptr += charcount;
2847: clen = 0;
2848: ADD_NEW(next_state_offset, 0);
2849:
2850: /* If we are adding a repeat state at the new character position,
2851: we must fudge things so that it is the only current state.
2852: Otherwise, it might be a duplicate of one we processed before, and
2853: that would cause it to be skipped. */
2854:
2855: if (repeat_state_offset >= 0)
2856: {
2857: next_active_state = active_states;
2858: active_count = 0;
2859: i = -1;
2860: ADD_ACTIVE(repeat_state_offset, 0);
2861: }
2862: }
2863: else
2864: {
2865: const uschar *p = start_subject + local_offsets[0];
2866: const uschar *pp = start_subject + local_offsets[1];
2867: while (p < pp) if ((*p++ & 0xc0) == 0x80) charcount--;
2868: ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
2869: if (repeat_state_offset >= 0)
2870: { ADD_NEW_DATA(-repeat_state_offset, 0, (charcount - 1)); }
2871: }
2872: }
2873: else if (rc != PCRE_ERROR_NOMATCH) return rc;
2874: }
2875: break;
2876:
2877:
2878: /* ========================================================================== */
2879: /* Handle callouts */
2880:
2881: case OP_CALLOUT:
2882: rrc = 0;
2883: if (pcre_callout != NULL)
2884: {
2885: pcre_callout_block cb;
2886: cb.version = 1; /* Version 1 of the callout block */
2887: cb.callout_number = code[1];
2888: cb.offset_vector = offsets;
2889: cb.subject = (PCRE_SPTR)start_subject;
2890: cb.subject_length = (int)(end_subject - start_subject);
2891: cb.start_match = (int)(current_subject - start_subject);
2892: cb.current_position = (int)(ptr - start_subject);
2893: cb.pattern_position = GET(code, 2);
2894: cb.next_item_length = GET(code, 2 + LINK_SIZE);
2895: cb.capture_top = 1;
2896: cb.capture_last = -1;
2897: cb.callout_data = md->callout_data;
2898: cb.mark = NULL; /* No (*MARK) support */
2899: if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc; /* Abandon */
2900: }
2901: if (rrc == 0)
2902: { ADD_ACTIVE(state_offset + _pcre_OP_lengths[OP_CALLOUT], 0); }
2903: break;
2904:
2905:
2906: /* ========================================================================== */
2907: default: /* Unsupported opcode */
2908: return PCRE_ERROR_DFA_UITEM;
2909: }
2910:
2911: NEXT_ACTIVE_STATE: continue;
2912:
2913: } /* End of loop scanning active states */
2914:
2915: /* We have finished the processing at the current subject character. If no
2916: new states have been set for the next character, we have found all the
2917: matches that we are going to find. If we are at the top level and partial
2918: matching has been requested, check for appropriate conditions.
2919:
2920: The "forced_ fail" variable counts the number of (*F) encountered for the
2921: character. If it is equal to the original active_count (saved in
2922: workspace[1]) it means that (*F) was found on every active state. In this
2923: case we don't want to give a partial match.
2924:
2925: The "could_continue" variable is true if a state could have continued but
2926: for the fact that the end of the subject was reached. */
2927:
2928: if (new_count <= 0)
2929: {
2930: if (rlevel == 1 && /* Top level, and */
2931: could_continue && /* Some could go on */
2932: forced_fail != workspace[1] && /* Not all forced fail & */
2933: ( /* either... */
2934: (md->moptions & PCRE_PARTIAL_HARD) != 0 /* Hard partial */
2935: || /* or... */
2936: ((md->moptions & PCRE_PARTIAL_SOFT) != 0 && /* Soft partial and */
2937: match_count < 0) /* no matches */
2938: ) && /* And... */
2939: ptr >= end_subject && /* Reached end of subject */
2940: ptr > md->start_used_ptr) /* Inspected non-empty string */
2941: {
2942: if (offsetcount >= 2)
2943: {
2944: offsets[0] = (int)(md->start_used_ptr - start_subject);
2945: offsets[1] = (int)(end_subject - start_subject);
2946: }
2947: match_count = PCRE_ERROR_PARTIAL;
2948: }
2949:
2950: DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
2951: "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel, match_count,
2952: rlevel*2-2, SP));
2953: break; /* In effect, "return", but see the comment below */
2954: }
2955:
2956: /* One or more states are active for the next character. */
2957:
2958: ptr += clen; /* Advance to next subject character */
2959: } /* Loop to move along the subject string */
2960:
2961: /* Control gets here from "break" a few lines above. We do it this way because
2962: if we use "return" above, we have compiler trouble. Some compilers warn if
2963: there's nothing here because they think the function doesn't return a value. On
2964: the other hand, if we put a dummy statement here, some more clever compilers
2965: complain that it can't be reached. Sigh. */
2966:
2967: return match_count;
2968: }
2969:
2970:
2971:
2972:
2973: /*************************************************
2974: * Execute a Regular Expression - DFA engine *
2975: *************************************************/
2976:
2977: /* This external function applies a compiled re to a subject string using a DFA
2978: engine. This function calls the internal function multiple times if the pattern
2979: is not anchored.
2980:
2981: Arguments:
2982: argument_re points to the compiled expression
2983: extra_data points to extra data or is NULL
2984: subject points to the subject string
2985: length length of subject string (may contain binary zeros)
2986: start_offset where to start in the subject string
2987: options option bits
2988: offsets vector of match offsets
2989: offsetcount size of same
2990: workspace workspace vector
2991: wscount size of same
2992:
2993: Returns: > 0 => number of match offset pairs placed in offsets
2994: = 0 => offsets overflowed; longest matches are present
2995: -1 => failed to match
2996: < -1 => some kind of unexpected problem
2997: */
2998:
2999: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
3000: pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,
3001: const char *subject, int length, int start_offset, int options, int *offsets,
3002: int offsetcount, int *workspace, int wscount)
3003: {
3004: real_pcre *re = (real_pcre *)argument_re;
3005: dfa_match_data match_block;
3006: dfa_match_data *md = &match_block;
3007: BOOL utf8, anchored, startline, firstline;
3008: const uschar *current_subject, *end_subject, *lcc;
3009:
3010: pcre_study_data internal_study;
3011: const pcre_study_data *study = NULL;
3012: real_pcre internal_re;
3013:
3014: const uschar *req_byte_ptr;
3015: const uschar *start_bits = NULL;
3016: BOOL first_byte_caseless = FALSE;
3017: BOOL req_byte_caseless = FALSE;
3018: int first_byte = -1;
3019: int req_byte = -1;
3020: int req_byte2 = -1;
3021: int newline;
3022:
3023: /* Plausibility checks */
3024:
3025: if ((options & ~PUBLIC_DFA_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
3026: if (re == NULL || subject == NULL || workspace == NULL ||
3027: (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
3028: if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
3029: if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;
3030: if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
3031:
3032: /* We need to find the pointer to any study data before we test for byte
3033: flipping, so we scan the extra_data block first. This may set two fields in the
3034: match block, so we must initialize them beforehand. However, the other fields
3035: in the match block must not be set until after the byte flipping. */
3036:
3037: md->tables = re->tables;
3038: md->callout_data = NULL;
3039:
3040: if (extra_data != NULL)
3041: {
3042: unsigned int flags = extra_data->flags;
3043: if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
3044: study = (const pcre_study_data *)extra_data->study_data;
3045: if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0) return PCRE_ERROR_DFA_UMLIMIT;
3046: if ((flags & PCRE_EXTRA_MATCH_LIMIT_RECURSION) != 0)
3047: return PCRE_ERROR_DFA_UMLIMIT;
3048: if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
3049: md->callout_data = extra_data->callout_data;
3050: if ((flags & PCRE_EXTRA_TABLES) != 0)
3051: md->tables = extra_data->tables;
3052: }
3053:
3054: /* Check that the first field in the block is the magic number. If it is not,
3055: test for a regex that was compiled on a host of opposite endianness. If this is
3056: the case, flipped values are put in internal_re and internal_study if there was
3057: study data too. */
3058:
3059: if (re->magic_number != MAGIC_NUMBER)
3060: {
3061: re = _pcre_try_flipped(re, &internal_re, study, &internal_study);
3062: if (re == NULL) return PCRE_ERROR_BADMAGIC;
3063: if (study != NULL) study = &internal_study;
3064: }
3065:
3066: /* Set some local values */
3067:
3068: current_subject = (const unsigned char *)subject + start_offset;
3069: end_subject = (const unsigned char *)subject + length;
3070: req_byte_ptr = current_subject - 1;
3071:
3072: #ifdef SUPPORT_UTF8
3073: utf8 = (re->options & PCRE_UTF8) != 0;
3074: #else
3075: utf8 = FALSE;
3076: #endif
3077:
3078: anchored = (options & (PCRE_ANCHORED|PCRE_DFA_RESTART)) != 0 ||
3079: (re->options & PCRE_ANCHORED) != 0;
3080:
3081: /* The remaining fixed data for passing around. */
3082:
3083: md->start_code = (const uschar *)argument_re +
3084: re->name_table_offset + re->name_count * re->name_entry_size;
3085: md->start_subject = (const unsigned char *)subject;
3086: md->end_subject = end_subject;
3087: md->start_offset = start_offset;
3088: md->moptions = options;
3089: md->poptions = re->options;
3090:
3091: /* If the BSR option is not set at match time, copy what was set
3092: at compile time. */
3093:
3094: if ((md->moptions & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) == 0)
3095: {
3096: if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
3097: md->moptions |= re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE);
3098: #ifdef BSR_ANYCRLF
3099: else md->moptions |= PCRE_BSR_ANYCRLF;
3100: #endif
3101: }
3102:
3103: /* Handle different types of newline. The three bits give eight cases. If
3104: nothing is set at run time, whatever was used at compile time applies. */
3105:
3106: switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &
3107: PCRE_NEWLINE_BITS)
3108: {
3109: case 0: newline = NEWLINE; break; /* Compile-time default */
3110: case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
3111: case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
3112: case PCRE_NEWLINE_CR+
3113: PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
3114: case PCRE_NEWLINE_ANY: newline = -1; break;
3115: case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
3116: default: return PCRE_ERROR_BADNEWLINE;
3117: }
3118:
3119: if (newline == -2)
3120: {
3121: md->nltype = NLTYPE_ANYCRLF;
3122: }
3123: else if (newline < 0)
3124: {
3125: md->nltype = NLTYPE_ANY;
3126: }
3127: else
3128: {
3129: md->nltype = NLTYPE_FIXED;
3130: if (newline > 255)
3131: {
3132: md->nllen = 2;
3133: md->nl[0] = (newline >> 8) & 255;
3134: md->nl[1] = newline & 255;
3135: }
3136: else
3137: {
3138: md->nllen = 1;
3139: md->nl[0] = newline;
3140: }
3141: }
3142:
3143: /* Check a UTF-8 string if required. Unfortunately there's no way of passing
3144: back the character offset. */
3145:
3146: #ifdef SUPPORT_UTF8
3147: if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
3148: {
3149: int erroroffset;
3150: int errorcode = _pcre_valid_utf8((uschar *)subject, length, &erroroffset);
3151: if (errorcode != 0)
3152: {
3153: if (offsetcount >= 2)
3154: {
3155: offsets[0] = erroroffset;
3156: offsets[1] = errorcode;
3157: }
3158: return (errorcode <= PCRE_UTF8_ERR5 && (options & PCRE_PARTIAL_HARD) != 0)?
3159: PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
3160: }
3161: if (start_offset > 0 && start_offset < length &&
3162: (((USPTR)subject)[start_offset] & 0xc0) == 0x80)
3163: return PCRE_ERROR_BADUTF8_OFFSET;
3164: }
3165: #endif
3166:
3167: /* If the exec call supplied NULL for tables, use the inbuilt ones. This
3168: is a feature that makes it possible to save compiled regex and re-use them
3169: in other programs later. */
3170:
3171: if (md->tables == NULL) md->tables = _pcre_default_tables;
3172:
3173: /* The lower casing table and the "must be at the start of a line" flag are
3174: used in a loop when finding where to start. */
3175:
3176: lcc = md->tables + lcc_offset;
3177: startline = (re->flags & PCRE_STARTLINE) != 0;
3178: firstline = (re->options & PCRE_FIRSTLINE) != 0;
3179:
3180: /* Set up the first character to match, if available. The first_byte value is
3181: never set for an anchored regular expression, but the anchoring may be forced
3182: at run time, so we have to test for anchoring. The first char may be unset for
3183: an unanchored pattern, of course. If there's no first char and the pattern was
3184: studied, there may be a bitmap of possible first characters. */
3185:
3186: if (!anchored)
3187: {
3188: if ((re->flags & PCRE_FIRSTSET) != 0)
3189: {
3190: first_byte = re->first_byte & 255;
3191: if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
3192: first_byte = lcc[first_byte];
3193: }
3194: else
3195: {
3196: if (!startline && study != NULL &&
3197: (study->flags & PCRE_STUDY_MAPPED) != 0)
3198: start_bits = study->start_bits;
3199: }
3200: }
3201:
3202: /* For anchored or unanchored matches, there may be a "last known required
3203: character" set. */
3204:
3205: if ((re->flags & PCRE_REQCHSET) != 0)
3206: {
3207: req_byte = re->req_byte & 255;
3208: req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
3209: req_byte2 = (md->tables + fcc_offset)[req_byte]; /* case flipped */
3210: }
3211:
3212: /* Call the main matching function, looping for a non-anchored regex after a
3213: failed match. If not restarting, perform certain optimizations at the start of
3214: a match. */
3215:
3216: for (;;)
3217: {
3218: int rc;
3219:
3220: if ((options & PCRE_DFA_RESTART) == 0)
3221: {
3222: const uschar *save_end_subject = end_subject;
3223:
3224: /* If firstline is TRUE, the start of the match is constrained to the first
3225: line of a multiline string. Implement this by temporarily adjusting
3226: end_subject so that we stop scanning at a newline. If the match fails at
3227: the newline, later code breaks this loop. */
3228:
3229: if (firstline)
3230: {
3231: USPTR t = current_subject;
3232: #ifdef SUPPORT_UTF8
3233: if (utf8)
3234: {
3235: while (t < md->end_subject && !IS_NEWLINE(t))
3236: {
3237: t++;
3238: while (t < end_subject && (*t & 0xc0) == 0x80) t++;
3239: }
3240: }
3241: else
3242: #endif
3243: while (t < md->end_subject && !IS_NEWLINE(t)) t++;
3244: end_subject = t;
3245: }
3246:
3247: /* There are some optimizations that avoid running the match if a known
3248: starting point is not found. However, there is an option that disables
3249: these, for testing and for ensuring that all callouts do actually occur.
3250: The option can be set in the regex by (*NO_START_OPT) or passed in
3251: match-time options. */
3252:
3253: if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
3254: {
3255: /* Advance to a known first byte. */
3256:
3257: if (first_byte >= 0)
3258: {
3259: if (first_byte_caseless)
3260: while (current_subject < end_subject &&
3261: lcc[*current_subject] != first_byte)
3262: current_subject++;
3263: else
3264: while (current_subject < end_subject &&
3265: *current_subject != first_byte)
3266: current_subject++;
3267: }
3268:
3269: /* Or to just after a linebreak for a multiline match if possible */
3270:
3271: else if (startline)
3272: {
3273: if (current_subject > md->start_subject + start_offset)
3274: {
3275: #ifdef SUPPORT_UTF8
3276: if (utf8)
3277: {
3278: while (current_subject < end_subject &&
3279: !WAS_NEWLINE(current_subject))
3280: {
3281: current_subject++;
3282: while(current_subject < end_subject &&
3283: (*current_subject & 0xc0) == 0x80)
3284: current_subject++;
3285: }
3286: }
3287: else
3288: #endif
3289: while (current_subject < end_subject && !WAS_NEWLINE(current_subject))
3290: current_subject++;
3291:
3292: /* If we have just passed a CR and the newline option is ANY or
3293: ANYCRLF, and we are now at a LF, advance the match position by one
3294: more character. */
3295:
3296: if (current_subject[-1] == CHAR_CR &&
3297: (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
3298: current_subject < end_subject &&
3299: *current_subject == CHAR_NL)
3300: current_subject++;
3301: }
3302: }
3303:
3304: /* Or to a non-unique first char after study */
3305:
3306: else if (start_bits != NULL)
3307: {
3308: while (current_subject < end_subject)
3309: {
3310: register unsigned int c = *current_subject;
3311: if ((start_bits[c/8] & (1 << (c&7))) == 0)
3312: {
3313: current_subject++;
3314: #ifdef SUPPORT_UTF8
3315: if (utf8)
3316: while(current_subject < end_subject &&
3317: (*current_subject & 0xc0) == 0x80) current_subject++;
3318: #endif
3319: }
3320: else break;
3321: }
3322: }
3323: }
3324:
3325: /* Restore fudged end_subject */
3326:
3327: end_subject = save_end_subject;
3328:
3329: /* The following two optimizations are disabled for partial matching or if
3330: disabling is explicitly requested (and of course, by the test above, this
3331: code is not obeyed when restarting after a partial match). */
3332:
3333: if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0 &&
3334: (options & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) == 0)
3335: {
3336: /* If the pattern was studied, a minimum subject length may be set. This
3337: is a lower bound; no actual string of that length may actually match the
3338: pattern. Although the value is, strictly, in characters, we treat it as
3339: bytes to avoid spending too much time in this optimization. */
3340:
3341: if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
3342: (pcre_uint32)(end_subject - current_subject) < study->minlength)
3343: return PCRE_ERROR_NOMATCH;
3344:
3345: /* If req_byte is set, we know that that character must appear in the
3346: subject for the match to succeed. If the first character is set, req_byte
3347: must be later in the subject; otherwise the test starts at the match
3348: point. This optimization can save a huge amount of work in patterns with
3349: nested unlimited repeats that aren't going to match. Writing separate
3350: code for cased/caseless versions makes it go faster, as does using an
3351: autoincrement and backing off on a match.
3352:
3353: HOWEVER: when the subject string is very, very long, searching to its end
3354: can take a long time, and give bad performance on quite ordinary
3355: patterns. This showed up when somebody was matching /^C/ on a 32-megabyte
3356: string... so we don't do this when the string is sufficiently long. */
3357:
3358: if (req_byte >= 0 && end_subject - current_subject < REQ_BYTE_MAX)
3359: {
3360: register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);
3361:
3362: /* We don't need to repeat the search if we haven't yet reached the
3363: place we found it at last time. */
3364:
3365: if (p > req_byte_ptr)
3366: {
3367: if (req_byte_caseless)
3368: {
3369: while (p < end_subject)
3370: {
3371: register int pp = *p++;
3372: if (pp == req_byte || pp == req_byte2) { p--; break; }
3373: }
3374: }
3375: else
3376: {
3377: while (p < end_subject)
3378: {
3379: if (*p++ == req_byte) { p--; break; }
3380: }
3381: }
3382:
3383: /* If we can't find the required character, break the matching loop,
3384: which will cause a return or PCRE_ERROR_NOMATCH. */
3385:
3386: if (p >= end_subject) break;
3387:
3388: /* If we have found the required character, save the point where we
3389: found it, so that we don't search again next time round the loop if
3390: the start hasn't passed this character yet. */
3391:
3392: req_byte_ptr = p;
3393: }
3394: }
3395: }
3396: } /* End of optimizations that are done when not restarting */
3397:
3398: /* OK, now we can do the business */
3399:
3400: md->start_used_ptr = current_subject;
3401: md->recursive = NULL;
3402:
3403: rc = internal_dfa_exec(
3404: md, /* fixed match data */
3405: md->start_code, /* this subexpression's code */
3406: current_subject, /* where we currently are */
3407: start_offset, /* start offset in subject */
3408: offsets, /* offset vector */
3409: offsetcount, /* size of same */
3410: workspace, /* workspace vector */
3411: wscount, /* size of same */
3412: 0); /* function recurse level */
3413:
3414: /* Anything other than "no match" means we are done, always; otherwise, carry
3415: on only if not anchored. */
3416:
3417: if (rc != PCRE_ERROR_NOMATCH || anchored) return rc;
3418:
3419: /* Advance to the next subject character unless we are at the end of a line
3420: and firstline is set. */
3421:
3422: if (firstline && IS_NEWLINE(current_subject)) break;
3423: current_subject++;
3424: if (utf8)
3425: {
3426: while (current_subject < end_subject && (*current_subject & 0xc0) == 0x80)
3427: current_subject++;
3428: }
3429: if (current_subject > end_subject) break;
3430:
3431: /* If we have just passed a CR and we are now at a LF, and the pattern does
3432: not contain any explicit matches for \r or \n, and the newline option is CRLF
3433: or ANY or ANYCRLF, advance the match position by one more character. */
3434:
3435: if (current_subject[-1] == CHAR_CR &&
3436: current_subject < end_subject &&
3437: *current_subject == CHAR_NL &&
3438: (re->flags & PCRE_HASCRORLF) == 0 &&
3439: (md->nltype == NLTYPE_ANY ||
3440: md->nltype == NLTYPE_ANYCRLF ||
3441: md->nllen == 2))
3442: current_subject++;
3443:
3444: } /* "Bumpalong" loop */
3445:
3446: return PCRE_ERROR_NOMATCH;
3447: }
3448:
3449: /* End of pcre_dfa_exec.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre_dfa_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