| /************************************************* |
| * Perl-Compatible Regular Expressions * |
| *************************************************/ |
| |
| /* PCRE is a library of functions to support regular expressions whose syntax |
| and semantics are as close as possible to those of the Perl 5 language. |
| |
| Written by Philip Hazel |
| Original API code Copyright (c) 1997-2012 University of Cambridge |
| New API code Copyright (c) 2016-2022 University of Cambridge |
| |
| ----------------------------------------------------------------------------- |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions are met: |
| |
| * Redistributions of source code must retain the above copyright notice, |
| this list of conditions and the following disclaimer. |
| |
| * Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions and the following disclaimer in the |
| documentation and/or other materials provided with the distribution. |
| |
| * Neither the name of the University of Cambridge nor the names of its |
| contributors may be used to endorse or promote products derived from |
| this software without specific prior written permission. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| POSSIBILITY OF SUCH DAMAGE. |
| ----------------------------------------------------------------------------- |
| */ |
| |
| |
| /* This module contains the external function pcre2_dfa_match(), which is an |
| alternative matching function that uses a sort of DFA algorithm (not a true |
| FSM). This is NOT Perl-compatible, but it has advantages in certain |
| applications. */ |
| |
| |
| /* NOTE ABOUT PERFORMANCE: A user of this function sent some code that improved |
| the performance of his patterns greatly. I could not use it as it stood, as it |
| was not thread safe, and made assumptions about pattern sizes. Also, it caused |
| test 7 to loop, and test 9 to crash with a segfault. |
| |
| The issue is the check for duplicate states, which is done by a simple linear |
| search up the state list. (Grep for "duplicate" below to find the code.) For |
| many patterns, there will never be many states active at one time, so a simple |
| linear search is fine. In patterns that have many active states, it might be a |
| bottleneck. The suggested code used an indexing scheme to remember which states |
| had previously been used for each character, and avoided the linear search when |
| it knew there was no chance of a duplicate. This was implemented when adding |
| states to the state lists. |
| |
| I wrote some thread-safe, not-limited code to try something similar at the time |
| of checking for duplicates (instead of when adding states), using index vectors |
| on the stack. It did give a 13% improvement with one specially constructed |
| pattern for certain subject strings, but on other strings and on many of the |
| simpler patterns in the test suite it did worse. The major problem, I think, |
| was the extra time to initialize the index. This had to be done for each call |
| of internal_dfa_match(). (The supplied patch used a static vector, initialized |
| only once - I suspect this was the cause of the problems with the tests.) |
| |
| Overall, I concluded that the gains in some cases did not outweigh the losses |
| in others, so I abandoned this code. */ |
| |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #define NLBLOCK mb /* Block containing newline information */ |
| #define PSSTART start_subject /* Field containing processed string start */ |
| #define PSEND end_subject /* Field containing processed string end */ |
| |
| #include "pcre2_internal.h" |
| |
| #define PUBLIC_DFA_MATCH_OPTIONS \ |
| (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ |
| PCRE2_NOTEMPTY_ATSTART|PCRE2_NO_UTF_CHECK|PCRE2_PARTIAL_HARD| \ |
| PCRE2_PARTIAL_SOFT|PCRE2_DFA_SHORTEST|PCRE2_DFA_RESTART| \ |
| PCRE2_COPY_MATCHED_SUBJECT) |
| |
| |
| /************************************************* |
| * Code parameters and static tables * |
| *************************************************/ |
| |
| /* These are offsets that are used to turn the OP_TYPESTAR and friends opcodes |
| into others, under special conditions. A gap of 20 between the blocks should be |
| enough. The resulting opcodes don't have to be less than 256 because they are |
| never stored, so we push them well clear of the normal opcodes. */ |
| |
| #define OP_PROP_EXTRA 300 |
| #define OP_EXTUNI_EXTRA 320 |
| #define OP_ANYNL_EXTRA 340 |
| #define OP_HSPACE_EXTRA 360 |
| #define OP_VSPACE_EXTRA 380 |
| |
| |
| /* This table identifies those opcodes that are followed immediately by a |
| character that is to be tested in some way. This makes it possible to |
| centralize the loading of these characters. In the case of Type * etc, the |
| "character" is the opcode for \D, \d, \S, \s, \W, or \w, which will always be a |
| small value. Non-zero values in the table are the offsets from the opcode where |
| the character is to be found. ***NOTE*** If the start of this table is |
| modified, the three tables that follow must also be modified. */ |
| |
| static const uint8_t coptable[] = { |
| 0, /* End */ |
| 0, 0, 0, 0, 0, /* \A, \G, \K, \B, \b */ |
| 0, 0, 0, 0, 0, 0, /* \D, \d, \S, \s, \W, \w */ |
| 0, 0, 0, /* Any, AllAny, Anybyte */ |
| 0, 0, /* \P, \p */ |
| 0, 0, 0, 0, 0, /* \R, \H, \h, \V, \v */ |
| 0, /* \X */ |
| 0, 0, 0, 0, 0, 0, /* \Z, \z, $, $M, ^, ^M */ |
| 1, /* Char */ |
| 1, /* Chari */ |
| 1, /* not */ |
| 1, /* noti */ |
| /* Positive single-char repeats */ |
| 1, 1, 1, 1, 1, 1, /* *, *?, +, +?, ?, ?? */ |
| 1+IMM2_SIZE, 1+IMM2_SIZE, /* upto, minupto */ |
| 1+IMM2_SIZE, /* exact */ |
| 1, 1, 1, 1+IMM2_SIZE, /* *+, ++, ?+, upto+ */ |
| 1, 1, 1, 1, 1, 1, /* *I, *?I, +I, +?I, ?I, ??I */ |
| 1+IMM2_SIZE, 1+IMM2_SIZE, /* upto I, minupto I */ |
| 1+IMM2_SIZE, /* exact I */ |
| 1, 1, 1, 1+IMM2_SIZE, /* *+I, ++I, ?+I, upto+I */ |
| /* Negative single-char repeats - only for chars < 256 */ |
| 1, 1, 1, 1, 1, 1, /* NOT *, *?, +, +?, ?, ?? */ |
| 1+IMM2_SIZE, 1+IMM2_SIZE, /* NOT upto, minupto */ |
| 1+IMM2_SIZE, /* NOT exact */ |
| 1, 1, 1, 1+IMM2_SIZE, /* NOT *+, ++, ?+, upto+ */ |
| 1, 1, 1, 1, 1, 1, /* NOT *I, *?I, +I, +?I, ?I, ??I */ |
| 1+IMM2_SIZE, 1+IMM2_SIZE, /* NOT upto I, minupto I */ |
| 1+IMM2_SIZE, /* NOT exact I */ |
| 1, 1, 1, 1+IMM2_SIZE, /* NOT *+I, ++I, ?+I, upto+I */ |
| /* Positive type repeats */ |
| 1, 1, 1, 1, 1, 1, /* Type *, *?, +, +?, ?, ?? */ |
| 1+IMM2_SIZE, 1+IMM2_SIZE, /* Type upto, minupto */ |
| 1+IMM2_SIZE, /* Type exact */ |
| 1, 1, 1, 1+IMM2_SIZE, /* Type *+, ++, ?+, upto+ */ |
| /* Character class & ref repeats */ |
| 0, 0, 0, 0, 0, 0, /* *, *?, +, +?, ?, ?? */ |
| 0, 0, /* CRRANGE, CRMINRANGE */ |
| 0, 0, 0, 0, /* Possessive *+, ++, ?+, CRPOSRANGE */ |
| 0, /* CLASS */ |
| 0, /* NCLASS */ |
| 0, /* XCLASS - variable length */ |
| 0, /* REF */ |
| 0, /* REFI */ |
| 0, /* DNREF */ |
| 0, /* DNREFI */ |
| 0, /* RECURSE */ |
| 0, /* CALLOUT */ |
| 0, /* CALLOUT_STR */ |
| 0, /* Alt */ |
| 0, /* Ket */ |
| 0, /* KetRmax */ |
| 0, /* KetRmin */ |
| 0, /* KetRpos */ |
| 0, /* Reverse */ |
| 0, /* Assert */ |
| 0, /* Assert not */ |
| 0, /* Assert behind */ |
| 0, /* Assert behind not */ |
| 0, /* NA assert */ |
| 0, /* NA assert behind */ |
| 0, /* ONCE */ |
| 0, /* SCRIPT_RUN */ |
| 0, 0, 0, 0, 0, /* BRA, BRAPOS, CBRA, CBRAPOS, COND */ |
| 0, 0, 0, 0, 0, /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND */ |
| 0, 0, /* CREF, DNCREF */ |
| 0, 0, /* RREF, DNRREF */ |
| 0, 0, /* FALSE, TRUE */ |
| 0, 0, 0, /* BRAZERO, BRAMINZERO, BRAPOSZERO */ |
| 0, 0, 0, /* MARK, PRUNE, PRUNE_ARG */ |
| 0, 0, 0, 0, /* SKIP, SKIP_ARG, THEN, THEN_ARG */ |
| 0, 0, /* COMMIT, COMMIT_ARG */ |
| 0, 0, 0, /* FAIL, ACCEPT, ASSERT_ACCEPT */ |
| 0, 0, 0 /* CLOSE, SKIPZERO, DEFINE */ |
| }; |
| |
| /* This table identifies those opcodes that inspect a character. It is used to |
| remember the fact that a character could have been inspected when the end of |
| the subject is reached. ***NOTE*** If the start of this table is modified, the |
| two tables that follow must also be modified. */ |
| |
| static const uint8_t poptable[] = { |
| 0, /* End */ |
| 0, 0, 0, 1, 1, /* \A, \G, \K, \B, \b */ |
| 1, 1, 1, 1, 1, 1, /* \D, \d, \S, \s, \W, \w */ |
| 1, 1, 1, /* Any, AllAny, Anybyte */ |
| 1, 1, /* \P, \p */ |
| 1, 1, 1, 1, 1, /* \R, \H, \h, \V, \v */ |
| 1, /* \X */ |
| 0, 0, 0, 0, 0, 0, /* \Z, \z, $, $M, ^, ^M */ |
| 1, /* Char */ |
| 1, /* Chari */ |
| 1, /* not */ |
| 1, /* noti */ |
| /* Positive single-char repeats */ |
| 1, 1, 1, 1, 1, 1, /* *, *?, +, +?, ?, ?? */ |
| 1, 1, 1, /* upto, minupto, exact */ |
| 1, 1, 1, 1, /* *+, ++, ?+, upto+ */ |
| 1, 1, 1, 1, 1, 1, /* *I, *?I, +I, +?I, ?I, ??I */ |
| 1, 1, 1, /* upto I, minupto I, exact I */ |
| 1, 1, 1, 1, /* *+I, ++I, ?+I, upto+I */ |
| /* Negative single-char repeats - only for chars < 256 */ |
| 1, 1, 1, 1, 1, 1, /* NOT *, *?, +, +?, ?, ?? */ |
| 1, 1, 1, /* NOT upto, minupto, exact */ |
| 1, 1, 1, 1, /* NOT *+, ++, ?+, upto+ */ |
| 1, 1, 1, 1, 1, 1, /* NOT *I, *?I, +I, +?I, ?I, ??I */ |
| 1, 1, 1, /* NOT upto I, minupto I, exact I */ |
| 1, 1, 1, 1, /* NOT *+I, ++I, ?+I, upto+I */ |
| /* Positive type repeats */ |
| 1, 1, 1, 1, 1, 1, /* Type *, *?, +, +?, ?, ?? */ |
| 1, 1, 1, /* Type upto, minupto, exact */ |
| 1, 1, 1, 1, /* Type *+, ++, ?+, upto+ */ |
| /* Character class & ref repeats */ |
| 1, 1, 1, 1, 1, 1, /* *, *?, +, +?, ?, ?? */ |
| 1, 1, /* CRRANGE, CRMINRANGE */ |
| 1, 1, 1, 1, /* Possessive *+, ++, ?+, CRPOSRANGE */ |
| 1, /* CLASS */ |
| 1, /* NCLASS */ |
| 1, /* XCLASS - variable length */ |
| 0, /* REF */ |
| 0, /* REFI */ |
| 0, /* DNREF */ |
| 0, /* DNREFI */ |
| 0, /* RECURSE */ |
| 0, /* CALLOUT */ |
| 0, /* CALLOUT_STR */ |
| 0, /* Alt */ |
| 0, /* Ket */ |
| 0, /* KetRmax */ |
| 0, /* KetRmin */ |
| 0, /* KetRpos */ |
| 0, /* Reverse */ |
| 0, /* Assert */ |
| 0, /* Assert not */ |
| 0, /* Assert behind */ |
| 0, /* Assert behind not */ |
| 0, /* NA assert */ |
| 0, /* NA assert behind */ |
| 0, /* ONCE */ |
| 0, /* SCRIPT_RUN */ |
| 0, 0, 0, 0, 0, /* BRA, BRAPOS, CBRA, CBRAPOS, COND */ |
| 0, 0, 0, 0, 0, /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND */ |
| 0, 0, /* CREF, DNCREF */ |
| 0, 0, /* RREF, DNRREF */ |
| 0, 0, /* FALSE, TRUE */ |
| 0, 0, 0, /* BRAZERO, BRAMINZERO, BRAPOSZERO */ |
| 0, 0, 0, /* MARK, PRUNE, PRUNE_ARG */ |
| 0, 0, 0, 0, /* SKIP, SKIP_ARG, THEN, THEN_ARG */ |
| 0, 0, /* COMMIT, COMMIT_ARG */ |
| 0, 0, 0, /* FAIL, ACCEPT, ASSERT_ACCEPT */ |
| 0, 0, 0 /* CLOSE, SKIPZERO, DEFINE */ |
| }; |
| |
| /* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W, |
| and \w */ |
| |
| static const uint8_t toptable1[] = { |
| 0, 0, 0, 0, 0, 0, |
| ctype_digit, ctype_digit, |
| ctype_space, ctype_space, |
| ctype_word, ctype_word, |
| 0, 0 /* OP_ANY, OP_ALLANY */ |
| }; |
| |
| static const uint8_t toptable2[] = { |
| 0, 0, 0, 0, 0, 0, |
| ctype_digit, 0, |
| ctype_space, 0, |
| ctype_word, 0, |
| 1, 1 /* OP_ANY, OP_ALLANY */ |
| }; |
| |
| |
| /* Structure for holding data about a particular state, which is in effect the |
| current data for an active path through the match tree. It must consist |
| entirely of ints because the working vector we are passed, and which we put |
| these structures in, is a vector of ints. */ |
| |
| typedef struct stateblock { |
| int offset; /* Offset to opcode (-ve has meaning) */ |
| int count; /* Count for repeats */ |
| int data; /* Some use extra data */ |
| } stateblock; |
| |
| #define INTS_PER_STATEBLOCK (int)(sizeof(stateblock)/sizeof(int)) |
| |
| |
| /* Before version 10.32 the recursive calls of internal_dfa_match() were passed |
| local working space and output vectors that were created on the stack. This has |
| caused issues for some patterns, especially in small-stack environments such as |
| Windows. A new scheme is now in use which sets up a vector on the stack, but if |
| this is too small, heap memory is used, up to the heap_limit. The main |
| parameters are all numbers of ints because the workspace is a vector of ints. |
| |
| The size of the starting stack vector, DFA_START_RWS_SIZE, is in bytes, and is |
| defined in pcre2_internal.h so as to be available to pcre2test when it is |
| finding the minimum heap requirement for a match. */ |
| |
| #define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) |
| |
| #define RWS_BASE_SIZE (DFA_START_RWS_SIZE/sizeof(int)) /* Stack vector */ |
| #define RWS_RSIZE 1000 /* Work size for recursion */ |
| #define RWS_OVEC_RSIZE (1000*OVEC_UNIT) /* Ovector for recursion */ |
| #define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ |
| |
| /* This structure is at the start of each workspace block. */ |
| |
| typedef struct RWS_anchor { |
| struct RWS_anchor *next; |
| uint32_t size; /* Number of ints */ |
| uint32_t free; /* Number of ints */ |
| } RWS_anchor; |
| |
| #define RWS_ANCHOR_SIZE (sizeof(RWS_anchor)/sizeof(int)) |
| |
| |
| |
| /************************************************* |
| * Process a callout * |
| *************************************************/ |
| |
| /* This function is called to perform a callout. |
| |
| Arguments: |
| code current code pointer |
| offsets points to current capture offsets |
| current_subject start of current subject match |
| ptr current position in subject |
| mb the match block |
| extracode extra code offset when called from condition |
| lengthptr where to return the callout length |
| |
| Returns: the return from the callout |
| */ |
| |
| static int |
| do_callout(PCRE2_SPTR code, PCRE2_SIZE *offsets, PCRE2_SPTR current_subject, |
| PCRE2_SPTR ptr, dfa_match_block *mb, PCRE2_SIZE extracode, |
| PCRE2_SIZE *lengthptr) |
| { |
| pcre2_callout_block *cb = mb->cb; |
| |
| *lengthptr = (code[extracode] == OP_CALLOUT)? |
| (PCRE2_SIZE)PRIV(OP_lengths)[OP_CALLOUT] : |
| (PCRE2_SIZE)GET(code, 1 + 2*LINK_SIZE + extracode); |
| |
| if (mb->callout == NULL) return 0; /* No callout provided */ |
| |
| /* Fixed fields in the callout block are set once and for all at the start of |
| matching. */ |
| |
| cb->offset_vector = offsets; |
| cb->start_match = (PCRE2_SIZE)(current_subject - mb->start_subject); |
| cb->current_position = (PCRE2_SIZE)(ptr - mb->start_subject); |
| cb->pattern_position = GET(code, 1 + extracode); |
| cb->next_item_length = GET(code, 1 + LINK_SIZE + extracode); |
| |
| if (code[extracode] == OP_CALLOUT) |
| { |
| cb->callout_number = code[1 + 2*LINK_SIZE + extracode]; |
| cb->callout_string_offset = 0; |
| cb->callout_string = NULL; |
| cb->callout_string_length = 0; |
| } |
| else |
| { |
| cb->callout_number = 0; |
| cb->callout_string_offset = GET(code, 1 + 3*LINK_SIZE + extracode); |
| cb->callout_string = code + (1 + 4*LINK_SIZE + extracode) + 1; |
| cb->callout_string_length = *lengthptr - (1 + 4*LINK_SIZE) - 2; |
| } |
| |
| return (mb->callout)(cb, mb->callout_data); |
| } |
| |
| |
| |
| /************************************************* |
| * Expand local workspace memory * |
| *************************************************/ |
| |
| /* This function is called when internal_dfa_match() is about to be called |
| recursively and there is insufficient working space left in the current |
| workspace block. If there's an existing next block, use it; otherwise get a new |
| block unless the heap limit is reached. |
| |
| Arguments: |
| rwsptr pointer to block pointer (updated) |
| ovecsize space needed for an ovector |
| mb the match block |
| |
| Returns: 0 rwsptr has been updated |
| !0 an error code |
| */ |
| |
| static int |
| more_workspace(RWS_anchor **rwsptr, unsigned int ovecsize, dfa_match_block *mb) |
| { |
| RWS_anchor *rws = *rwsptr; |
| RWS_anchor *new; |
| |
| if (rws->next != NULL) |
| { |
| new = rws->next; |
| } |
| |
| /* Sizes in the RWS_anchor blocks are in units of sizeof(int), but |
| mb->heap_limit and mb->heap_used are in kibibytes. Play carefully, to avoid |
| overflow. */ |
| |
| else |
| { |
| uint32_t newsize = (rws->size >= UINT32_MAX/2)? UINT32_MAX/2 : rws->size * 2; |
| uint32_t newsizeK = newsize/(1024/sizeof(int)); |
| |
| if (newsizeK + mb->heap_used > mb->heap_limit) |
| newsizeK = (uint32_t)(mb->heap_limit - mb->heap_used); |
| newsize = newsizeK*(1024/sizeof(int)); |
| |
| if (newsize < RWS_RSIZE + ovecsize + RWS_ANCHOR_SIZE) |
| return PCRE2_ERROR_HEAPLIMIT; |
| new = mb->memctl.malloc(newsize*sizeof(int), mb->memctl.memory_data); |
| if (new == NULL) return PCRE2_ERROR_NOMEMORY; |
| mb->heap_used += newsizeK; |
| new->next = NULL; |
| new->size = newsize; |
| rws->next = new; |
| } |
| |
| new->free = new->size - RWS_ANCHOR_SIZE; |
| *rwsptr = new; |
| return 0; |
| } |
| |
| |
| |
| /************************************************* |
| * Match a Regular Expression - DFA engine * |
| *************************************************/ |
| |
| /* This internal function applies a compiled pattern to a subject string, |
| starting at a given point, using a DFA engine. This function is called from the |
| external one, possibly multiple times if the pattern is not anchored. The |
| function calls itself recursively for some kinds of subpattern. |
| |
| Arguments: |
| mb the match_data block with fixed information |
| this_start_code the opening bracket of this subexpression's code |
| current_subject where we currently are in the subject string |
| start_offset start offset in the subject string |
| offsets vector to contain the matching string offsets |
| offsetcount size of same |
| workspace vector of workspace |
| wscount size of same |
| rlevel function call recursion level |
| |
| Returns: > 0 => number of match offset pairs placed in offsets |
| = 0 => offsets overflowed; longest matches are present |
| -1 => failed to match |
| < -1 => some kind of unexpected problem |
| |
| The following macros are used for adding states to the two state vectors (one |
| for the current character, one for the following character). */ |
| |
| #define ADD_ACTIVE(x,y) \ |
| if (active_count++ < wscount) \ |
| { \ |
| next_active_state->offset = (x); \ |
| next_active_state->count = (y); \ |
| next_active_state++; \ |
| } \ |
| else return PCRE2_ERROR_DFA_WSSIZE |
| |
| #define ADD_ACTIVE_DATA(x,y,z) \ |
| if (active_count++ < wscount) \ |
| { \ |
| next_active_state->offset = (x); \ |
| next_active_state->count = (y); \ |
| next_active_state->data = (z); \ |
| next_active_state++; \ |
| } \ |
| else return PCRE2_ERROR_DFA_WSSIZE |
| |
| #define ADD_NEW(x,y) \ |
| if (new_count++ < wscount) \ |
| { \ |
| next_new_state->offset = (x); \ |
| next_new_state->count = (y); \ |
| next_new_state++; \ |
| } \ |
| else return PCRE2_ERROR_DFA_WSSIZE |
| |
| #define ADD_NEW_DATA(x,y,z) \ |
| if (new_count++ < wscount) \ |
| { \ |
| next_new_state->offset = (x); \ |
| next_new_state->count = (y); \ |
| next_new_state->data = (z); \ |
| next_new_state++; \ |
| } \ |
| else return PCRE2_ERROR_DFA_WSSIZE |
| |
| /* And now, here is the code */ |
| |
| static int |
| internal_dfa_match( |
| dfa_match_block *mb, |
| PCRE2_SPTR this_start_code, |
| PCRE2_SPTR current_subject, |
| PCRE2_SIZE start_offset, |
| PCRE2_SIZE *offsets, |
| uint32_t offsetcount, |
| int *workspace, |
| int wscount, |
| uint32_t rlevel, |
| int *RWS) |
| { |
| stateblock *active_states, *new_states, *temp_states; |
| stateblock *next_active_state, *next_new_state; |
| const uint8_t *ctypes, *lcc, *fcc; |
| PCRE2_SPTR ptr; |
| PCRE2_SPTR end_code; |
| dfa_recursion_info new_recursive; |
| int active_count, new_count, match_count; |
| |
| /* Some fields in the mb block are frequently referenced, so we load them into |
| independent variables in the hope that this will perform better. */ |
| |
| PCRE2_SPTR start_subject = mb->start_subject; |
| PCRE2_SPTR end_subject = mb->end_subject; |
| PCRE2_SPTR start_code = mb->start_code; |
| |
| #ifdef SUPPORT_UNICODE |
| BOOL utf = (mb->poptions & PCRE2_UTF) != 0; |
| BOOL utf_or_ucp = utf || (mb->poptions & PCRE2_UCP) != 0; |
| #else |
| BOOL utf = FALSE; |
| #endif |
| |
| BOOL reset_could_continue = FALSE; |
| |
| if (mb->match_call_count++ >= mb->match_limit) return PCRE2_ERROR_MATCHLIMIT; |
| if (rlevel++ > mb->match_limit_depth) return PCRE2_ERROR_DEPTHLIMIT; |
| offsetcount &= (uint32_t)(-2); /* Round down */ |
| |
| wscount -= 2; |
| wscount = (wscount - (wscount % (INTS_PER_STATEBLOCK * 2))) / |
| (2 * INTS_PER_STATEBLOCK); |
| |
| ctypes = mb->tables + ctypes_offset; |
| lcc = mb->tables + lcc_offset; |
| fcc = mb->tables + fcc_offset; |
| |
| match_count = PCRE2_ERROR_NOMATCH; /* A negative number */ |
| |
| active_states = (stateblock *)(workspace + 2); |
| next_new_state = new_states = active_states + wscount; |
| new_count = 0; |
| |
| /* The first thing in any (sub) pattern is a bracket of some sort. Push all |
| the alternative states onto the list, and find out where the end is. This |
| makes is possible to use this function recursively, when we want to stop at a |
| matching internal ket rather than at the end. |
| |
| If we are dealing with a backward assertion we have to find out the maximum |
| amount to move back, and set up each alternative appropriately. */ |
| |
| if (*this_start_code == OP_ASSERTBACK || *this_start_code == OP_ASSERTBACK_NOT) |
| { |
| size_t max_back = 0; |
| size_t gone_back; |
| |
| end_code = this_start_code; |
| do |
| { |
| size_t back = (size_t)GET(end_code, 2+LINK_SIZE); |
| if (back > max_back) max_back = back; |
| end_code += GET(end_code, 1); |
| } |
| while (*end_code == OP_ALT); |
| |
| /* If we can't go back the amount required for the longest lookbehind |
| pattern, go back as far as we can; some alternatives may still be viable. */ |
| |
| #ifdef SUPPORT_UNICODE |
| /* In character mode we have to step back character by character */ |
| |
| if (utf) |
| { |
| for (gone_back = 0; gone_back < max_back; gone_back++) |
| { |
| if (current_subject <= start_subject) break; |
| current_subject--; |
| ACROSSCHAR(current_subject > start_subject, current_subject, |
| current_subject--); |
| } |
| } |
| else |
| #endif |
| |
| /* In byte-mode we can do this quickly. */ |
| |
| { |
| size_t current_offset = (size_t)(current_subject - start_subject); |
| gone_back = (current_offset < max_back)? current_offset : max_back; |
| current_subject -= gone_back; |
| } |
| |
| /* Save the earliest consulted character */ |
| |
| if (current_subject < mb->start_used_ptr) |
| mb->start_used_ptr = current_subject; |
| |
| /* Now we can process the individual branches. There will be an OP_REVERSE at |
| the start of each branch, except when the length of the branch is zero. */ |
| |
| end_code = this_start_code; |
| do |
| { |
| uint32_t revlen = (end_code[1+LINK_SIZE] == OP_REVERSE)? 1 + LINK_SIZE : 0; |
| size_t back = (revlen == 0)? 0 : (size_t)GET(end_code, 2+LINK_SIZE); |
| if (back <= gone_back) |
| { |
| int bstate = (int)(end_code - start_code + 1 + LINK_SIZE + revlen); |
| ADD_NEW_DATA(-bstate, 0, (int)(gone_back - back)); |
| } |
| end_code += GET(end_code, 1); |
| } |
| while (*end_code == OP_ALT); |
| } |
| |
| /* This is the code for a "normal" subpattern (not a backward assertion). The |
| start of a whole pattern is always one of these. If we are at the top level, |
| we may be asked to restart matching from the same point that we reached for a |
| previous partial match. We still have to scan through the top-level branches to |
| find the end state. */ |
| |
| else |
| { |
| end_code = this_start_code; |
| |
| /* Restarting */ |
| |
| if (rlevel == 1 && (mb->moptions & PCRE2_DFA_RESTART) != 0) |
| { |
| do { end_code += GET(end_code, 1); } while (*end_code == OP_ALT); |
| new_count = workspace[1]; |
| if (!workspace[0]) |
| memcpy(new_states, active_states, (size_t)new_count * sizeof(stateblock)); |
| } |
| |
| /* Not restarting */ |
| |
| else |
| { |
| int length = 1 + LINK_SIZE + |
| ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA || |
| *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS) |
| ? IMM2_SIZE:0); |
| do |
| { |
| ADD_NEW((int)(end_code - start_code + length), 0); |
| end_code += GET(end_code, 1); |
| length = 1 + LINK_SIZE; |
| } |
| while (*end_code == OP_ALT); |
| } |
| } |
| |
| workspace[0] = 0; /* Bit indicating which vector is current */ |
| |
| /* Loop for scanning the subject */ |
| |
| ptr = current_subject; |
| for (;;) |
| { |
| int i, j; |
| int clen, dlen; |
| uint32_t c, d; |
| int forced_fail = 0; |
| BOOL partial_newline = FALSE; |
| BOOL could_continue = reset_could_continue; |
| reset_could_continue = FALSE; |
| |
| if (ptr > mb->last_used_ptr) mb->last_used_ptr = ptr; |
| |
| /* Make the new state list into the active state list and empty the |
| new state list. */ |
| |
| temp_states = active_states; |
| active_states = new_states; |
| new_states = temp_states; |
| active_count = new_count; |
| new_count = 0; |
| |
| workspace[0] ^= 1; /* Remember for the restarting feature */ |
| workspace[1] = active_count; |
| |
| /* Set the pointers for adding new states */ |
| |
| next_active_state = active_states + active_count; |
| next_new_state = new_states; |
| |
| /* Load the current character from the subject outside the loop, as many |
| different states may want to look at it, and we assume that at least one |
| will. */ |
| |
| if (ptr < end_subject) |
| { |
| clen = 1; /* Number of data items in the character */ |
| #ifdef SUPPORT_UNICODE |
| GETCHARLENTEST(c, ptr, clen); |
| #else |
| c = *ptr; |
| #endif /* SUPPORT_UNICODE */ |
| } |
| else |
| { |
| clen = 0; /* This indicates the end of the subject */ |
| c = NOTACHAR; /* This value should never actually be used */ |
| } |
| |
| /* Scan up the active states and act on each one. The result of an action |
| may be to add more states to the currently active list (e.g. on hitting a |
| parenthesis) or it may be to put states on the new list, for considering |
| when we move the character pointer on. */ |
| |
| for (i = 0; i < active_count; i++) |
| { |
| stateblock *current_state = active_states + i; |
| BOOL caseless = FALSE; |
| PCRE2_SPTR code; |
| uint32_t codevalue; |
| int state_offset = current_state->offset; |
| int rrc; |
| int count; |
| |
| /* A negative offset is a special case meaning "hold off going to this |
| (negated) state until the number of characters in the data field have |
| been skipped". If the could_continue flag was passed over from a previous |
| state, arrange for it to passed on. */ |
| |
| if (state_offset < 0) |
| { |
| if (current_state->data > 0) |
| { |
| ADD_NEW_DATA(state_offset, current_state->count, |
| current_state->data - 1); |
| if (could_continue) reset_could_continue = TRUE; |
| continue; |
| } |
| else |
| { |
| current_state->offset = state_offset = -state_offset; |
| } |
| } |
| |
| /* Check for a duplicate state with the same count, and skip if found. |
| See the note at the head of this module about the possibility of improving |
| performance here. */ |
| |
| for (j = 0; j < i; j++) |
| { |
| if (active_states[j].offset == state_offset && |
| active_states[j].count == current_state->count) |
| goto NEXT_ACTIVE_STATE; |
| } |
| |
| /* The state offset is the offset to the opcode */ |
| |
| code = start_code + state_offset; |
| codevalue = *code; |
| |
| /* If this opcode inspects a character, but we are at the end of the |
| subject, remember the fact for use when testing for a partial match. */ |
| |
| if (clen == 0 && poptable[codevalue] != 0) |
| could_continue = TRUE; |
| |
| /* If this opcode is followed by an inline character, load it. It is |
| tempting to test for the presence of a subject character here, but that |
| is wrong, because sometimes zero repetitions of the subject are |
| permitted. |
| |
| We also use this mechanism for opcodes such as OP_TYPEPLUS that take an |
| argument that is not a data character - but is always one byte long because |
| the values are small. We have to take special action to deal with \P, \p, |
| \H, \h, \V, \v and \X in this case. To keep the other cases fast, convert |
| these ones to new opcodes. */ |
| |
| if (coptable[codevalue] > 0) |
| { |
| dlen = 1; |
| #ifdef SUPPORT_UNICODE |
| if (utf) { GETCHARLEN(d, (code + coptable[codevalue]), dlen); } else |
| #endif /* SUPPORT_UNICODE */ |
| d = code[coptable[codevalue]]; |
| if (codevalue >= OP_TYPESTAR) |
| { |
| switch(d) |
| { |
| case OP_ANYBYTE: return PCRE2_ERROR_DFA_UITEM; |
| case OP_NOTPROP: |
| case OP_PROP: codevalue += OP_PROP_EXTRA; break; |
| case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break; |
| case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break; |
| case OP_NOT_HSPACE: |
| case OP_HSPACE: codevalue += OP_HSPACE_EXTRA; break; |
| case OP_NOT_VSPACE: |
| case OP_VSPACE: codevalue += OP_VSPACE_EXTRA; break; |
| default: break; |
| } |
| } |
| } |
| else |
| { |
| dlen = 0; /* Not strictly necessary, but compilers moan */ |
| d = NOTACHAR; /* if these variables are not set. */ |
| } |
| |
| |
| /* Now process the individual opcodes */ |
| |
| switch (codevalue) |
| { |
| /* ========================================================================== */ |
| /* These cases are never obeyed. This is a fudge that causes a compile- |
| time error if the vectors coptable or poptable, which are indexed by |
| opcode, are not the correct length. It seems to be the only way to do |
| such a check at compile time, as the sizeof() operator does not work |
| in the C preprocessor. */ |
| |
| case OP_TABLE_LENGTH: |
| case OP_TABLE_LENGTH + |
| ((sizeof(coptable) == OP_TABLE_LENGTH) && |
| (sizeof(poptable) == OP_TABLE_LENGTH)): |
| return 0; |
| |
| /* ========================================================================== */ |
| /* Reached a closing bracket. If not at the end of the pattern, carry |
| on with the next opcode. For repeating opcodes, also add the repeat |
| state. Note that KETRPOS will always be encountered at the end of the |
| subpattern, because the possessive subpattern repeats are always handled |
| using recursive calls. Thus, it never adds any new states. |
| |
| At the end of the (sub)pattern, unless we have an empty string and |
| PCRE2_NOTEMPTY is set, or PCRE2_NOTEMPTY_ATSTART is set and we are at the |
| start of the subject, save the match data, shifting up all previous |
| matches so we always have the longest first. */ |
| |
| case OP_KET: |
| case OP_KETRMIN: |
| case OP_KETRMAX: |
| case OP_KETRPOS: |
| if (code != end_code) |
| { |
| ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0); |
| if (codevalue != OP_KET) |
| { |
| ADD_ACTIVE(state_offset - (int)GET(code, 1), 0); |
| } |
| } |
| else |
| { |
| if (ptr > current_subject || |
| ((mb->moptions & PCRE2_NOTEMPTY) == 0 && |
| ((mb->moptions & PCRE2_NOTEMPTY_ATSTART) == 0 || |
| current_subject > start_subject + mb->start_offset))) |
| { |
| if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0; |
| else if (match_count > 0 && ++match_count * 2 > (int)offsetcount) |
| match_count = 0; |
| count = ((match_count == 0)? (int)offsetcount : match_count * 2) - 2; |
| if (count > 0) (void)memmove(offsets + 2, offsets, |
| (size_t)count * sizeof(PCRE2_SIZE)); |
| if (offsetcount >= 2) |
| { |
| offsets[0] = (PCRE2_SIZE)(current_subject - start_subject); |
| offsets[1] = (PCRE2_SIZE)(ptr - start_subject); |
| } |
| if ((mb->moptions & PCRE2_DFA_SHORTEST) != 0) return match_count; |
| } |
| } |
| break; |
| |
| /* ========================================================================== */ |
| /* These opcodes add to the current list of states without looking |
| at the current character. */ |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_ALT: |
| do { code += GET(code, 1); } while (*code == OP_ALT); |
| ADD_ACTIVE((int)(code - start_code), 0); |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_BRA: |
| case OP_SBRA: |
| do |
| { |
| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0); |
| code += GET(code, 1); |
| } |
| while (*code == OP_ALT); |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_CBRA: |
| case OP_SCBRA: |
| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE + IMM2_SIZE), 0); |
| code += GET(code, 1); |
| while (*code == OP_ALT) |
| { |
| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0); |
| code += GET(code, 1); |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_BRAZERO: |
| case OP_BRAMINZERO: |
| ADD_ACTIVE(state_offset + 1, 0); |
| code += 1 + GET(code, 2); |
| while (*code == OP_ALT) code += GET(code, 1); |
| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0); |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_SKIPZERO: |
| code += 1 + GET(code, 2); |
| while (*code == OP_ALT) code += GET(code, 1); |
| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0); |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_CIRC: |
| if (ptr == start_subject && (mb->moptions & PCRE2_NOTBOL) == 0) |
| { ADD_ACTIVE(state_offset + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_CIRCM: |
| if ((ptr == start_subject && (mb->moptions & PCRE2_NOTBOL) == 0) || |
| ((ptr != end_subject || (mb->poptions & PCRE2_ALT_CIRCUMFLEX) != 0 ) |
| && WAS_NEWLINE(ptr))) |
| { ADD_ACTIVE(state_offset + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_EOD: |
| if (ptr >= end_subject) |
| { |
| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| return PCRE2_ERROR_PARTIAL; |
| else { ADD_ACTIVE(state_offset + 1, 0); } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_SOD: |
| if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_SOM: |
| if (ptr == start_subject + start_offset) { ADD_ACTIVE(state_offset + 1, 0); } |
| break; |
| |
| |
| /* ========================================================================== */ |
| /* These opcodes inspect the next subject character, and sometimes |
| the previous one as well, but do not have an argument. The variable |
| clen contains the length of the current character and is zero if we are |
| at the end of the subject. */ |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_ANY: |
| if (clen > 0 && !IS_NEWLINE(ptr)) |
| { |
| if (ptr + 1 >= mb->end_subject && |
| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && |
| NLBLOCK->nltype == NLTYPE_FIXED && |
| NLBLOCK->nllen == 2 && |
| c == NLBLOCK->nl[0]) |
| { |
| could_continue = partial_newline = TRUE; |
| } |
| else |
| { |
| ADD_NEW(state_offset + 1, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_ALLANY: |
| if (clen > 0) |
| { ADD_NEW(state_offset + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_EODN: |
| if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - mb->nllen)) |
| { |
| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| return PCRE2_ERROR_PARTIAL; |
| ADD_ACTIVE(state_offset + 1, 0); |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_DOLL: |
| if ((mb->moptions & PCRE2_NOTEOL) == 0) |
| { |
| if (clen == 0 && (mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| could_continue = TRUE; |
| else if (clen == 0 || |
| ((mb->poptions & PCRE2_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) && |
| (ptr == end_subject - mb->nllen) |
| )) |
| { ADD_ACTIVE(state_offset + 1, 0); } |
| else if (ptr + 1 >= mb->end_subject && |
| (mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && |
| NLBLOCK->nltype == NLTYPE_FIXED && |
| NLBLOCK->nllen == 2 && |
| c == NLBLOCK->nl[0]) |
| { |
| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| { |
| reset_could_continue = TRUE; |
| ADD_NEW_DATA(-(state_offset + 1), 0, 1); |
| } |
| else could_continue = partial_newline = TRUE; |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_DOLLM: |
| if ((mb->moptions & PCRE2_NOTEOL) == 0) |
| { |
| if (clen == 0 && (mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| could_continue = TRUE; |
| else if (clen == 0 || |
| ((mb->poptions & PCRE2_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr))) |
| { ADD_ACTIVE(state_offset + 1, 0); } |
| else if (ptr + 1 >= mb->end_subject && |
| (mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && |
| NLBLOCK->nltype == NLTYPE_FIXED && |
| NLBLOCK->nllen == 2 && |
| c == NLBLOCK->nl[0]) |
| { |
| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| { |
| reset_could_continue = TRUE; |
| ADD_NEW_DATA(-(state_offset + 1), 0, 1); |
| } |
| else could_continue = partial_newline = TRUE; |
| } |
| } |
| else if (IS_NEWLINE(ptr)) |
| { ADD_ACTIVE(state_offset + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| |
| case OP_DIGIT: |
| case OP_WHITESPACE: |
| case OP_WORDCHAR: |
| if (clen > 0 && c < 256 && |
| ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0) |
| { ADD_NEW(state_offset + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_NOT_DIGIT: |
| case OP_NOT_WHITESPACE: |
| case OP_NOT_WORDCHAR: |
| if (clen > 0 && (c >= 256 || |
| ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0)) |
| { ADD_NEW(state_offset + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_WORD_BOUNDARY: |
| case OP_NOT_WORD_BOUNDARY: |
| { |
| int left_word, right_word; |
| |
| if (ptr > start_subject) |
| { |
| PCRE2_SPTR temp = ptr - 1; |
| if (temp < mb->start_used_ptr) mb->start_used_ptr = temp; |
| #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 |
| if (utf) { BACKCHAR(temp); } |
| #endif |
| GETCHARTEST(d, temp); |
| #ifdef SUPPORT_UNICODE |
| if ((mb->poptions & PCRE2_UCP) != 0) |
| { |
| if (d == '_') left_word = TRUE; else |
| { |
| uint32_t cat = UCD_CATEGORY(d); |
| left_word = (cat == ucp_L || cat == ucp_N); |
| } |
| } |
| else |
| #endif |
| left_word = d < 256 && (ctypes[d] & ctype_word) != 0; |
| } |
| else left_word = FALSE; |
| |
| if (clen > 0) |
| { |
| if (ptr >= mb->last_used_ptr) |
| { |
| PCRE2_SPTR temp = ptr + 1; |
| #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 |
| if (utf) { FORWARDCHARTEST(temp, mb->end_subject); } |
| #endif |
| mb->last_used_ptr = temp; |
| } |
| #ifdef SUPPORT_UNICODE |
| if ((mb->poptions & PCRE2_UCP) != 0) |
| { |
| if (c == '_') right_word = TRUE; else |
| { |
| uint32_t cat = UCD_CATEGORY(c); |
| right_word = (cat == ucp_L || cat == ucp_N); |
| } |
| } |
| else |
| #endif |
| right_word = c < 256 && (ctypes[c] & ctype_word) != 0; |
| } |
| else right_word = FALSE; |
| |
| if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY)) |
| { ADD_ACTIVE(state_offset + 1, 0); } |
| } |
| break; |
| |
| |
| /*-----------------------------------------------------------------*/ |
| /* Check the next character by Unicode property. We will get here only |
| if the support is in the binary; otherwise a compile-time error occurs. |
| */ |
| |
| #ifdef SUPPORT_UNICODE |
| case OP_PROP: |
| case OP_NOTPROP: |
| if (clen > 0) |
| { |
| BOOL OK; |
| const uint32_t *cp; |
| const ucd_record * prop = GET_UCD(c); |
| switch(code[1]) |
| { |
| case PT_ANY: |
| OK = TRUE; |
| break; |
| |
| case PT_LAMP: |
| OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || |
| prop->chartype == ucp_Lt; |
| break; |
| |
| case PT_GC: |
| OK = PRIV(ucp_gentype)[prop->chartype] == code[2]; |
| break; |
| |
| case PT_PC: |
| OK = prop->chartype == code[2]; |
| break; |
| |
| case PT_SC: |
| OK = prop->script == code[2]; |
| break; |
| |
| case PT_SCX: |
| OK = (prop->script == code[2] || |
| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), code[2]) != 0); |
| break; |
| |
| /* These are specials for combination cases. */ |
| |
| case PT_ALNUM: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || |
| PRIV(ucp_gentype)[prop->chartype] == ucp_N; |
| break; |
| |
| /* Perl space used to exclude VT, but from Perl 5.18 it is included, |
| which means that Perl space and POSIX space are now identical. PCRE |
| was changed at release 8.34. */ |
| |
| case PT_SPACE: /* Perl space */ |
| case PT_PXSPACE: /* POSIX space */ |
| switch(c) |
| { |
| HSPACE_CASES: |
| VSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z; |
| break; |
| } |
| break; |
| |
| case PT_WORD: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || |
| PRIV(ucp_gentype)[prop->chartype] == ucp_N || |
| c == CHAR_UNDERSCORE; |
| break; |
| |
| case PT_CLIST: |
| cp = PRIV(ucd_caseless_sets) + code[2]; |
| for (;;) |
| { |
| if (c < *cp) { OK = FALSE; break; } |
| if (c == *cp++) { OK = TRUE; break; } |
| } |
| break; |
| |
| case PT_UCNC: |
| OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || |
| c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) || |
| c >= 0xe000; |
| break; |
| |
| case PT_BIDICL: |
| OK = UCD_BIDICLASS(c) == code[2]; |
| break; |
| |
| case PT_BOOL: |
| OK = MAPBIT(PRIV(ucd_boolprop_sets) + |
| UCD_BPROPS_PROP(prop), code[2]) != 0; |
| break; |
| |
| /* Should never occur, but keep compilers from grumbling. */ |
| |
| default: |
| OK = codevalue != OP_PROP; |
| break; |
| } |
| |
| if (OK == (codevalue == OP_PROP)) { ADD_NEW(state_offset + 3, 0); } |
| } |
| break; |
| #endif |
| |
| |
| |
| /* ========================================================================== */ |
| /* These opcodes likewise inspect the subject character, but have an |
| argument that is not a data character. It is one of these opcodes: |
| OP_ANY, OP_ALLANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE, |
| OP_WORDCHAR, OP_NOT_WORDCHAR. The value is loaded into d. */ |
| |
| case OP_TYPEPLUS: |
| case OP_TYPEMINPLUS: |
| case OP_TYPEPOSPLUS: |
| count = current_state->count; /* Already matched */ |
| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } |
| if (clen > 0) |
| { |
| if (d == OP_ANY && ptr + 1 >= mb->end_subject && |
| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && |
| NLBLOCK->nltype == NLTYPE_FIXED && |
| NLBLOCK->nllen == 2 && |
| c == NLBLOCK->nl[0]) |
| { |
| could_continue = partial_newline = TRUE; |
| } |
| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || |
| (c < 256 && |
| (d != OP_ANY || !IS_NEWLINE(ptr)) && |
| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) |
| { |
| if (count > 0 && codevalue == OP_TYPEPOSPLUS) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| count++; |
| ADD_NEW(state_offset, count); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_TYPEQUERY: |
| case OP_TYPEMINQUERY: |
| case OP_TYPEPOSQUERY: |
| ADD_ACTIVE(state_offset + 2, 0); |
| if (clen > 0) |
| { |
| if (d == OP_ANY && ptr + 1 >= mb->end_subject && |
| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && |
| NLBLOCK->nltype == NLTYPE_FIXED && |
| NLBLOCK->nllen == 2 && |
| c == NLBLOCK->nl[0]) |
| { |
| could_continue = partial_newline = TRUE; |
| } |
| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || |
| (c < 256 && |
| (d != OP_ANY || !IS_NEWLINE(ptr)) && |
| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) |
| { |
| if (codevalue == OP_TYPEPOSQUERY) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW(state_offset + 2, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_TYPESTAR: |
| case OP_TYPEMINSTAR: |
| case OP_TYPEPOSSTAR: |
| ADD_ACTIVE(state_offset + 2, 0); |
| if (clen > 0) |
| { |
| if (d == OP_ANY && ptr + 1 >= mb->end_subject && |
| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && |
| NLBLOCK->nltype == NLTYPE_FIXED && |
| NLBLOCK->nllen == 2 && |
| c == NLBLOCK->nl[0]) |
| { |
| could_continue = partial_newline = TRUE; |
| } |
| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || |
| (c < 256 && |
| (d != OP_ANY || !IS_NEWLINE(ptr)) && |
| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) |
| { |
| if (codevalue == OP_TYPEPOSSTAR) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW(state_offset, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_TYPEEXACT: |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| if (d == OP_ANY && ptr + 1 >= mb->end_subject && |
| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && |
| NLBLOCK->nltype == NLTYPE_FIXED && |
| NLBLOCK->nllen == 2 && |
| c == NLBLOCK->nl[0]) |
| { |
| could_continue = partial_newline = TRUE; |
| } |
| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || |
| (c < 256 && |
| (d != OP_ANY || !IS_NEWLINE(ptr)) && |
| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) |
| { |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW(state_offset + 1 + IMM2_SIZE + 1, 0); } |
| else |
| { ADD_NEW(state_offset, count); } |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_TYPEUPTO: |
| case OP_TYPEMINUPTO: |
| case OP_TYPEPOSUPTO: |
| ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| if (d == OP_ANY && ptr + 1 >= mb->end_subject && |
| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && |
| NLBLOCK->nltype == NLTYPE_FIXED && |
| NLBLOCK->nllen == 2 && |
| c == NLBLOCK->nl[0]) |
| { |
| could_continue = partial_newline = TRUE; |
| } |
| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || |
| (c < 256 && |
| (d != OP_ANY || !IS_NEWLINE(ptr)) && |
| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) |
| { |
| if (codevalue == OP_TYPEPOSUPTO) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW(state_offset + 2 + IMM2_SIZE, 0); } |
| else |
| { ADD_NEW(state_offset, count); } |
| } |
| } |
| break; |
| |
| /* ========================================================================== */ |
| /* These are virtual opcodes that are used when something like |
| OP_TYPEPLUS has OP_PROP, OP_NOTPROP, OP_ANYNL, or OP_EXTUNI as its |
| argument. It keeps the code above fast for the other cases. The argument |
| is in the d variable. */ |
| |
| #ifdef SUPPORT_UNICODE |
| case OP_PROP_EXTRA + OP_TYPEPLUS: |
| case OP_PROP_EXTRA + OP_TYPEMINPLUS: |
| case OP_PROP_EXTRA + OP_TYPEPOSPLUS: |
| count = current_state->count; /* Already matched */ |
| if (count > 0) { ADD_ACTIVE(state_offset + 4, 0); } |
| if (clen > 0) |
| { |
| BOOL OK; |
| const uint32_t *cp; |
| const ucd_record * prop = GET_UCD(c); |
| switch(code[2]) |
| { |
| case PT_ANY: |
| OK = TRUE; |
| break; |
| |
| case PT_LAMP: |
| OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || |
| prop->chartype == ucp_Lt; |
| break; |
| |
| case PT_GC: |
| OK = PRIV(ucp_gentype)[prop->chartype] == code[3]; |
| break; |
| |
| case PT_PC: |
| OK = prop->chartype == code[3]; |
| break; |
| |
| case PT_SC: |
| OK = prop->script == code[3]; |
| break; |
| |
| case PT_SCX: |
| OK = (prop->script == code[3] || |
| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), code[3]) != 0); |
| break; |
| |
| /* These are specials for combination cases. */ |
| |
| case PT_ALNUM: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || |
| PRIV(ucp_gentype)[prop->chartype] == ucp_N; |
| break; |
| |
| /* Perl space used to exclude VT, but from Perl 5.18 it is included, |
| which means that Perl space and POSIX space are now identical. PCRE |
| was changed at release 8.34. */ |
| |
| case PT_SPACE: /* Perl space */ |
| case PT_PXSPACE: /* POSIX space */ |
| switch(c) |
| { |
| HSPACE_CASES: |
| VSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z; |
| break; |
| } |
| break; |
| |
| case PT_WORD: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || |
| PRIV(ucp_gentype)[prop->chartype] == ucp_N || |
| c == CHAR_UNDERSCORE; |
| break; |
| |
| case PT_CLIST: |
| cp = PRIV(ucd_caseless_sets) + code[3]; |
| for (;;) |
| { |
| if (c < *cp) { OK = FALSE; break; } |
| if (c == *cp++) { OK = TRUE; break; } |
| } |
| break; |
| |
| case PT_UCNC: |
| OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || |
| c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) || |
| c >= 0xe000; |
| break; |
| |
| case PT_BIDICL: |
| OK = UCD_BIDICLASS(c) == code[3]; |
| break; |
| |
| case PT_BOOL: |
| OK = MAPBIT(PRIV(ucd_boolprop_sets) + |
| UCD_BPROPS_PROP(prop), code[3]) != 0; |
| break; |
| |
| /* Should never occur, but keep compilers from grumbling. */ |
| |
| default: |
| OK = codevalue != OP_PROP; |
| break; |
| } |
| |
| if (OK == (d == OP_PROP)) |
| { |
| if (count > 0 && codevalue == OP_PROP_EXTRA + OP_TYPEPOSPLUS) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| count++; |
| ADD_NEW(state_offset, count); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_EXTUNI_EXTRA + OP_TYPEPLUS: |
| case OP_EXTUNI_EXTRA + OP_TYPEMINPLUS: |
| case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS: |
| count = current_state->count; /* Already matched */ |
| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } |
| if (clen > 0) |
| { |
| int ncount = 0; |
| if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| (void)PRIV(extuni)(c, ptr + clen, mb->start_subject, end_subject, utf, |
| &ncount); |
| count++; |
| ADD_NEW_DATA(-state_offset, count, ncount); |
| } |
| break; |
| #endif |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_ANYNL_EXTRA + OP_TYPEPLUS: |
| case OP_ANYNL_EXTRA + OP_TYPEMINPLUS: |
| case OP_ANYNL_EXTRA + OP_TYPEPOSPLUS: |
| count = current_state->count; /* Already matched */ |
| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } |
| if (clen > 0) |
| { |
| int ncount = 0; |
| switch (c) |
| { |
| case CHAR_VT: |
| case CHAR_FF: |
| case CHAR_NEL: |
| #ifndef EBCDIC |
| case 0x2028: |
| case 0x2029: |
| #endif /* Not EBCDIC */ |
| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) break; |
| goto ANYNL01; |
| |
| case CHAR_CR: |
| if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; |
| /* Fall through */ |
| |
| ANYNL01: |
| case CHAR_LF: |
| if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| count++; |
| ADD_NEW_DATA(-state_offset, count, ncount); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_VSPACE_EXTRA + OP_TYPEPLUS: |
| case OP_VSPACE_EXTRA + OP_TYPEMINPLUS: |
| case OP_VSPACE_EXTRA + OP_TYPEPOSPLUS: |
| count = current_state->count; /* Already matched */ |
| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } |
| if (clen > 0) |
| { |
| BOOL OK; |
| switch (c) |
| { |
| VSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = FALSE; |
| break; |
| } |
| |
| if (OK == (d == OP_VSPACE)) |
| { |
| if (count > 0 && codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSPLUS) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| count++; |
| ADD_NEW_DATA(-state_offset, count, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_HSPACE_EXTRA + OP_TYPEPLUS: |
| case OP_HSPACE_EXTRA + OP_TYPEMINPLUS: |
| case OP_HSPACE_EXTRA + OP_TYPEPOSPLUS: |
| count = current_state->count; /* Already matched */ |
| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } |
| if (clen > 0) |
| { |
| BOOL OK; |
| switch (c) |
| { |
| HSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = FALSE; |
| break; |
| } |
| |
| if (OK == (d == OP_HSPACE)) |
| { |
| if (count > 0 && codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSPLUS) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| count++; |
| ADD_NEW_DATA(-state_offset, count, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| #ifdef SUPPORT_UNICODE |
| case OP_PROP_EXTRA + OP_TYPEQUERY: |
| case OP_PROP_EXTRA + OP_TYPEMINQUERY: |
| case OP_PROP_EXTRA + OP_TYPEPOSQUERY: |
| count = 4; |
| goto QS1; |
| |
| case OP_PROP_EXTRA + OP_TYPESTAR: |
| case OP_PROP_EXTRA + OP_TYPEMINSTAR: |
| case OP_PROP_EXTRA + OP_TYPEPOSSTAR: |
| count = 0; |
| |
| QS1: |
| |
| ADD_ACTIVE(state_offset + 4, 0); |
| if (clen > 0) |
| { |
| BOOL OK; |
| const uint32_t *cp; |
| const ucd_record * prop = GET_UCD(c); |
| switch(code[2]) |
| { |
| case PT_ANY: |
| OK = TRUE; |
| break; |
| |
| case PT_LAMP: |
| OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || |
| prop->chartype == ucp_Lt; |
| break; |
| |
| case PT_GC: |
| OK = PRIV(ucp_gentype)[prop->chartype] == code[3]; |
| break; |
| |
| case PT_PC: |
| OK = prop->chartype == code[3]; |
| break; |
| |
| case PT_SC: |
| OK = prop->script == code[3]; |
| break; |
| |
| case PT_SCX: |
| OK = (prop->script == code[3] || |
| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), code[3]) != 0); |
| break; |
| |
| /* These are specials for combination cases. */ |
| |
| case PT_ALNUM: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || |
| PRIV(ucp_gentype)[prop->chartype] == ucp_N; |
| break; |
| |
| /* Perl space used to exclude VT, but from Perl 5.18 it is included, |
| which means that Perl space and POSIX space are now identical. PCRE |
| was changed at release 8.34. */ |
| |
| case PT_SPACE: /* Perl space */ |
| case PT_PXSPACE: /* POSIX space */ |
| switch(c) |
| { |
| HSPACE_CASES: |
| VSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z; |
| break; |
| } |
| break; |
| |
| case PT_WORD: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || |
| PRIV(ucp_gentype)[prop->chartype] == ucp_N || |
| c == CHAR_UNDERSCORE; |
| break; |
| |
| case PT_CLIST: |
| cp = PRIV(ucd_caseless_sets) + code[3]; |
| for (;;) |
| { |
| if (c < *cp) { OK = FALSE; break; } |
| if (c == *cp++) { OK = TRUE; break; } |
| } |
| break; |
| |
| case PT_UCNC: |
| OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || |
| c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) || |
| c >= 0xe000; |
| break; |
| |
| case PT_BIDICL: |
| OK = UCD_BIDICLASS(c) == code[3]; |
| break; |
| |
| case PT_BOOL: |
| OK = MAPBIT(PRIV(ucd_boolprop_sets) + |
| UCD_BPROPS_PROP(prop), code[3]) != 0; |
| break; |
| |
| /* Should never occur, but keep compilers from grumbling. */ |
| |
| default: |
| OK = codevalue != OP_PROP; |
| break; |
| } |
| |
| if (OK == (d == OP_PROP)) |
| { |
| if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSSTAR || |
| codevalue == OP_PROP_EXTRA + OP_TYPEPOSQUERY) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW(state_offset + count, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_EXTUNI_EXTRA + OP_TYPEQUERY: |
| case OP_EXTUNI_EXTRA + OP_TYPEMINQUERY: |
| case OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY: |
| count = 2; |
| goto QS2; |
| |
| case OP_EXTUNI_EXTRA + OP_TYPESTAR: |
| case OP_EXTUNI_EXTRA + OP_TYPEMINSTAR: |
| case OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR: |
| count = 0; |
| |
| QS2: |
| |
| ADD_ACTIVE(state_offset + 2, 0); |
| if (clen > 0) |
| { |
| int ncount = 0; |
| if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR || |
| codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| (void)PRIV(extuni)(c, ptr + clen, mb->start_subject, end_subject, utf, |
| &ncount); |
| ADD_NEW_DATA(-(state_offset + count), 0, ncount); |
| } |
| break; |
| #endif |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_ANYNL_EXTRA + OP_TYPEQUERY: |
| case OP_ANYNL_EXTRA + OP_TYPEMINQUERY: |
| case OP_ANYNL_EXTRA + OP_TYPEPOSQUERY: |
| count = 2; |
| goto QS3; |
| |
| case OP_ANYNL_EXTRA + OP_TYPESTAR: |
| case OP_ANYNL_EXTRA + OP_TYPEMINSTAR: |
| case OP_ANYNL_EXTRA + OP_TYPEPOSSTAR: |
| count = 0; |
| |
| QS3: |
| ADD_ACTIVE(state_offset + 2, 0); |
| if (clen > 0) |
| { |
| int ncount = 0; |
| switch (c) |
| { |
| case CHAR_VT: |
| case CHAR_FF: |
| case CHAR_NEL: |
| #ifndef EBCDIC |
| case 0x2028: |
| case 0x2029: |
| #endif /* Not EBCDIC */ |
| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) break; |
| goto ANYNL02; |
| |
| case CHAR_CR: |
| if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; |
| /* Fall through */ |
| |
| ANYNL02: |
| case CHAR_LF: |
| if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR || |
| codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW_DATA(-(state_offset + (int)count), 0, ncount); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_VSPACE_EXTRA + OP_TYPEQUERY: |
| case OP_VSPACE_EXTRA + OP_TYPEMINQUERY: |
| case OP_VSPACE_EXTRA + OP_TYPEPOSQUERY: |
| count = 2; |
| goto QS4; |
| |
| case OP_VSPACE_EXTRA + OP_TYPESTAR: |
| case OP_VSPACE_EXTRA + OP_TYPEMINSTAR: |
| case OP_VSPACE_EXTRA + OP_TYPEPOSSTAR: |
| count = 0; |
| |
| QS4: |
| ADD_ACTIVE(state_offset + 2, 0); |
| if (clen > 0) |
| { |
| BOOL OK; |
| switch (c) |
| { |
| VSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = FALSE; |
| break; |
| } |
| if (OK == (d == OP_VSPACE)) |
| { |
| if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSSTAR || |
| codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSQUERY) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW_DATA(-(state_offset + (int)count), 0, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_HSPACE_EXTRA + OP_TYPEQUERY: |
| case OP_HSPACE_EXTRA + OP_TYPEMINQUERY: |
| case OP_HSPACE_EXTRA + OP_TYPEPOSQUERY: |
| count = 2; |
| goto QS5; |
| |
| case OP_HSPACE_EXTRA + OP_TYPESTAR: |
| case OP_HSPACE_EXTRA + OP_TYPEMINSTAR: |
| case OP_HSPACE_EXTRA + OP_TYPEPOSSTAR: |
| count = 0; |
| |
| QS5: |
| ADD_ACTIVE(state_offset + 2, 0); |
| if (clen > 0) |
| { |
| BOOL OK; |
| switch (c) |
| { |
| HSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = FALSE; |
| break; |
| } |
| |
| if (OK == (d == OP_HSPACE)) |
| { |
| if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSSTAR || |
| codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSQUERY) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW_DATA(-(state_offset + (int)count), 0, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| #ifdef SUPPORT_UNICODE |
| case OP_PROP_EXTRA + OP_TYPEEXACT: |
| case OP_PROP_EXTRA + OP_TYPEUPTO: |
| case OP_PROP_EXTRA + OP_TYPEMINUPTO: |
| case OP_PROP_EXTRA + OP_TYPEPOSUPTO: |
| if (codevalue != OP_PROP_EXTRA + OP_TYPEEXACT) |
| { ADD_ACTIVE(state_offset + 1 + IMM2_SIZE + 3, 0); } |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| BOOL OK; |
| const uint32_t *cp; |
| const ucd_record * prop = GET_UCD(c); |
| switch(code[1 + IMM2_SIZE + 1]) |
| { |
| case PT_ANY: |
| OK = TRUE; |
| break; |
| |
| case PT_LAMP: |
| OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || |
| prop->chartype == ucp_Lt; |
| break; |
| |
| case PT_GC: |
| OK = PRIV(ucp_gentype)[prop->chartype] == code[1 + IMM2_SIZE + 2]; |
| break; |
| |
| case PT_PC: |
| OK = prop->chartype == code[1 + IMM2_SIZE + 2]; |
| break; |
| |
| case PT_SC: |
| OK = prop->script == code[1 + IMM2_SIZE + 2]; |
| break; |
| |
| case PT_SCX: |
| OK = (prop->script == code[1 + IMM2_SIZE + 2] || |
| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), |
| code[1 + IMM2_SIZE + 2]) != 0); |
| break; |
| |
| /* These are specials for combination cases. */ |
| |
| case PT_ALNUM: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || |
| PRIV(ucp_gentype)[prop->chartype] == ucp_N; |
| break; |
| |
| /* Perl space used to exclude VT, but from Perl 5.18 it is included, |
| which means that Perl space and POSIX space are now identical. PCRE |
| was changed at release 8.34. */ |
| |
| case PT_SPACE: /* Perl space */ |
| case PT_PXSPACE: /* POSIX space */ |
| switch(c) |
| { |
| HSPACE_CASES: |
| VSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z; |
| break; |
| } |
| break; |
| |
| case PT_WORD: |
| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || |
| PRIV(ucp_gentype)[prop->chartype] == ucp_N || |
| c == CHAR_UNDERSCORE; |
| break; |
| |
| case PT_CLIST: |
| cp = PRIV(ucd_caseless_sets) + code[1 + IMM2_SIZE + 2]; |
| for (;;) |
| { |
| if (c < *cp) { OK = FALSE; break; } |
| if (c == *cp++) { OK = TRUE; break; } |
| } |
| break; |
| |
| case PT_UCNC: |
| OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || |
| c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) || |
| c >= 0xe000; |
| break; |
| |
| case PT_BIDICL: |
| OK = UCD_BIDICLASS(c) == code[1 + IMM2_SIZE + 2]; |
| break; |
| |
| case PT_BOOL: |
| OK = MAPBIT(PRIV(ucd_boolprop_sets) + |
| UCD_BPROPS_PROP(prop), code[1 + IMM2_SIZE + 2]) != 0; |
| break; |
| |
| /* Should never occur, but keep compilers from grumbling. */ |
| |
| default: |
| OK = codevalue != OP_PROP; |
| break; |
| } |
| |
| if (OK == (d == OP_PROP)) |
| { |
| if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSUPTO) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW(state_offset + 1 + IMM2_SIZE + 3, 0); } |
| else |
| { ADD_NEW(state_offset, count); } |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_EXTUNI_EXTRA + OP_TYPEEXACT: |
| case OP_EXTUNI_EXTRA + OP_TYPEUPTO: |
| case OP_EXTUNI_EXTRA + OP_TYPEMINUPTO: |
| case OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO: |
| if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT) |
| { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); } |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| PCRE2_SPTR nptr; |
| int ncount = 0; |
| if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| nptr = PRIV(extuni)(c, ptr + clen, mb->start_subject, end_subject, utf, |
| &ncount); |
| if (nptr >= end_subject && (mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| reset_could_continue = TRUE; |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); } |
| else |
| { ADD_NEW_DATA(-state_offset, count, ncount); } |
| } |
| break; |
| #endif |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_ANYNL_EXTRA + OP_TYPEEXACT: |
| case OP_ANYNL_EXTRA + OP_TYPEUPTO: |
| case OP_ANYNL_EXTRA + OP_TYPEMINUPTO: |
| case OP_ANYNL_EXTRA + OP_TYPEPOSUPTO: |
| if (codevalue != OP_ANYNL_EXTRA + OP_TYPEEXACT) |
| { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); } |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| int ncount = 0; |
| switch (c) |
| { |
| case CHAR_VT: |
| case CHAR_FF: |
| case CHAR_NEL: |
| #ifndef EBCDIC |
| case 0x2028: |
| case 0x2029: |
| #endif /* Not EBCDIC */ |
| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) break; |
| goto ANYNL03; |
| |
| case CHAR_CR: |
| if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; |
| /* Fall through */ |
| |
| ANYNL03: |
| case CHAR_LF: |
| if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); } |
| else |
| { ADD_NEW_DATA(-state_offset, count, ncount); } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_VSPACE_EXTRA + OP_TYPEEXACT: |
| case OP_VSPACE_EXTRA + OP_TYPEUPTO: |
| case OP_VSPACE_EXTRA + OP_TYPEMINUPTO: |
| case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO: |
| if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT) |
| { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); } |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| BOOL OK; |
| switch (c) |
| { |
| VSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = FALSE; |
| } |
| |
| if (OK == (d == OP_VSPACE)) |
| { |
| if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSUPTO) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); } |
| else |
| { ADD_NEW_DATA(-state_offset, count, 0); } |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_HSPACE_EXTRA + OP_TYPEEXACT: |
| case OP_HSPACE_EXTRA + OP_TYPEUPTO: |
| case OP_HSPACE_EXTRA + OP_TYPEMINUPTO: |
| case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO: |
| if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT) |
| { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); } |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| BOOL OK; |
| switch (c) |
| { |
| HSPACE_CASES: |
| OK = TRUE; |
| break; |
| |
| default: |
| OK = FALSE; |
| break; |
| } |
| |
| if (OK == (d == OP_HSPACE)) |
| { |
| if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSUPTO) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); } |
| else |
| { ADD_NEW_DATA(-state_offset, count, 0); } |
| } |
| } |
| break; |
| |
| /* ========================================================================== */ |
| /* These opcodes are followed by a character that is usually compared |
| to the current subject character; it is loaded into d. We still get |
| here even if there is no subject character, because in some cases zero |
| repetitions are permitted. */ |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_CHAR: |
| if (clen > 0 && c == d) { ADD_NEW(state_offset + dlen + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_CHARI: |
| if (clen == 0) break; |
| |
| #ifdef SUPPORT_UNICODE |
| if (utf_or_ucp) |
| { |
| if (c == d) { ADD_NEW(state_offset + dlen + 1, 0); } else |
| { |
| unsigned int othercase; |
| if (c < 128) |
| othercase = fcc[c]; |
| else |
| othercase = UCD_OTHERCASE(c); |
| if (d == othercase) { ADD_NEW(state_offset + dlen + 1, 0); } |
| } |
| } |
| else |
| #endif /* SUPPORT_UNICODE */ |
| /* Not UTF or UCP mode */ |
| { |
| if (TABLE_GET(c, lcc, c) == TABLE_GET(d, lcc, d)) |
| { ADD_NEW(state_offset + 2, 0); } |
| } |
| break; |
| |
| |
| #ifdef SUPPORT_UNICODE |
| /*-----------------------------------------------------------------*/ |
| /* This is a tricky one because it can match more than one character. |
| Find out how many characters to skip, and then set up a negative state |
| to wait for them to pass before continuing. */ |
| |
| case OP_EXTUNI: |
| if (clen > 0) |
| { |
| int ncount = 0; |
| PCRE2_SPTR nptr = PRIV(extuni)(c, ptr + clen, mb->start_subject, |
| end_subject, utf, &ncount); |
| if (nptr >= end_subject && (mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| reset_could_continue = TRUE; |
| ADD_NEW_DATA(-(state_offset + 1), 0, ncount); |
| } |
| break; |
| #endif |
| |
| /*-----------------------------------------------------------------*/ |
| /* This is a tricky like EXTUNI because it too can match more than one |
| character (when CR is followed by LF). In this case, set up a negative |
| state to wait for one character to pass before continuing. */ |
| |
| case OP_ANYNL: |
| if (clen > 0) switch(c) |
| { |
| case CHAR_VT: |
| case CHAR_FF: |
| case CHAR_NEL: |
| #ifndef EBCDIC |
| case 0x2028: |
| case 0x2029: |
| #endif /* Not EBCDIC */ |
| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) break; |
| /* Fall through */ |
| |
| case CHAR_LF: |
| ADD_NEW(state_offset + 1, 0); |
| break; |
| |
| case CHAR_CR: |
| if (ptr + 1 >= end_subject) |
| { |
| ADD_NEW(state_offset + 1, 0); |
| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) |
| reset_could_continue = TRUE; |
| } |
| else if (UCHAR21TEST(ptr + 1) == CHAR_LF) |
| { |
| ADD_NEW_DATA(-(state_offset + 1), 0, 1); |
| } |
| else |
| { |
| ADD_NEW(state_offset + 1, 0); |
| } |
| break; |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_NOT_VSPACE: |
| if (clen > 0) switch(c) |
| { |
| VSPACE_CASES: |
| break; |
| |
| default: |
| ADD_NEW(state_offset + 1, 0); |
| break; |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_VSPACE: |
| if (clen > 0) switch(c) |
| { |
| VSPACE_CASES: |
| ADD_NEW(state_offset + 1, 0); |
| break; |
| |
| default: |
| break; |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_NOT_HSPACE: |
| if (clen > 0) switch(c) |
| { |
| HSPACE_CASES: |
| break; |
| |
| default: |
| ADD_NEW(state_offset + 1, 0); |
| break; |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_HSPACE: |
| if (clen > 0) switch(c) |
| { |
| HSPACE_CASES: |
| ADD_NEW(state_offset + 1, 0); |
| break; |
| |
| default: |
| break; |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| /* Match a negated single character casefully. */ |
| |
| case OP_NOT: |
| if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| /* Match a negated single character caselessly. */ |
| |
| case OP_NOTI: |
| if (clen > 0) |
| { |
| uint32_t otherd; |
| #ifdef SUPPORT_UNICODE |
| if (utf_or_ucp && d >= 128) |
| otherd = UCD_OTHERCASE(d); |
| else |
| #endif /* SUPPORT_UNICODE */ |
| otherd = TABLE_GET(d, fcc, d); |
| if (c != d && c != otherd) |
| { ADD_NEW(state_offset + dlen + 1, 0); } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_PLUSI: |
| case OP_MINPLUSI: |
| case OP_POSPLUSI: |
| case OP_NOTPLUSI: |
| case OP_NOTMINPLUSI: |
| case OP_NOTPOSPLUSI: |
| caseless = TRUE; |
| codevalue -= OP_STARI - OP_STAR; |
| |
| /* Fall through */ |
| case OP_PLUS: |
| case OP_MINPLUS: |
| case OP_POSPLUS: |
| case OP_NOTPLUS: |
| case OP_NOTMINPLUS: |
| case OP_NOTPOSPLUS: |
| count = current_state->count; /* Already matched */ |
| if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); } |
| if (clen > 0) |
| { |
| uint32_t otherd = NOTACHAR; |
| if (caseless) |
| { |
| #ifdef SUPPORT_UNICODE |
| if (utf_or_ucp && d >= 128) |
| otherd = UCD_OTHERCASE(d); |
| else |
| #endif /* SUPPORT_UNICODE */ |
| otherd = TABLE_GET(d, fcc, d); |
| } |
| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) |
| { |
| if (count > 0 && |
| (codevalue == OP_POSPLUS || codevalue == OP_NOTPOSPLUS)) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| count++; |
| ADD_NEW(state_offset, count); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_QUERYI: |
| case OP_MINQUERYI: |
| case OP_POSQUERYI: |
| case OP_NOTQUERYI: |
| case OP_NOTMINQUERYI: |
| case OP_NOTPOSQUERYI: |
| caseless = TRUE; |
| codevalue -= OP_STARI - OP_STAR; |
| /* Fall through */ |
| case OP_QUERY: |
| case OP_MINQUERY: |
| case OP_POSQUERY: |
| case OP_NOTQUERY: |
| case OP_NOTMINQUERY: |
| case OP_NOTPOSQUERY: |
| ADD_ACTIVE(state_offset + dlen + 1, 0); |
| if (clen > 0) |
| { |
| uint32_t otherd = NOTACHAR; |
| if (caseless) |
| { |
| #ifdef SUPPORT_UNICODE |
| if (utf_or_ucp && d >= 128) |
| otherd = UCD_OTHERCASE(d); |
| else |
| #endif /* SUPPORT_UNICODE */ |
| otherd = TABLE_GET(d, fcc, d); |
| } |
| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) |
| { |
| if (codevalue == OP_POSQUERY || codevalue == OP_NOTPOSQUERY) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW(state_offset + dlen + 1, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_STARI: |
| case OP_MINSTARI: |
| case OP_POSSTARI: |
| case OP_NOTSTARI: |
| case OP_NOTMINSTARI: |
| case OP_NOTPOSSTARI: |
| caseless = TRUE; |
| codevalue -= OP_STARI - OP_STAR; |
| /* Fall through */ |
| case OP_STAR: |
| case OP_MINSTAR: |
| case OP_POSSTAR: |
| case OP_NOTSTAR: |
| case OP_NOTMINSTAR: |
| case OP_NOTPOSSTAR: |
| ADD_ACTIVE(state_offset + dlen + 1, 0); |
| if (clen > 0) |
| { |
| uint32_t otherd = NOTACHAR; |
| if (caseless) |
| { |
| #ifdef SUPPORT_UNICODE |
| if (utf_or_ucp && d >= 128) |
| otherd = UCD_OTHERCASE(d); |
| else |
| #endif /* SUPPORT_UNICODE */ |
| otherd = TABLE_GET(d, fcc, d); |
| } |
| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) |
| { |
| if (codevalue == OP_POSSTAR || codevalue == OP_NOTPOSSTAR) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW(state_offset, 0); |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_EXACTI: |
| case OP_NOTEXACTI: |
| caseless = TRUE; |
| codevalue -= OP_STARI - OP_STAR; |
| /* Fall through */ |
| case OP_EXACT: |
| case OP_NOTEXACT: |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| uint32_t otherd = NOTACHAR; |
| if (caseless) |
| { |
| #ifdef SUPPORT_UNICODE |
| if (utf_or_ucp && d >= 128) |
| otherd = UCD_OTHERCASE(d); |
| else |
| #endif /* SUPPORT_UNICODE */ |
| otherd = TABLE_GET(d, fcc, d); |
| } |
| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) |
| { |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); } |
| else |
| { ADD_NEW(state_offset, count); } |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_UPTOI: |
| case OP_MINUPTOI: |
| case OP_POSUPTOI: |
| case OP_NOTUPTOI: |
| case OP_NOTMINUPTOI: |
| case OP_NOTPOSUPTOI: |
| caseless = TRUE; |
| codevalue -= OP_STARI - OP_STAR; |
| /* Fall through */ |
| case OP_UPTO: |
| case OP_MINUPTO: |
| case OP_POSUPTO: |
| case OP_NOTUPTO: |
| case OP_NOTMINUPTO: |
| case OP_NOTPOSUPTO: |
| ADD_ACTIVE(state_offset + dlen + 1 + IMM2_SIZE, 0); |
| count = current_state->count; /* Number already matched */ |
| if (clen > 0) |
| { |
| uint32_t otherd = NOTACHAR; |
| if (caseless) |
| { |
| #ifdef SUPPORT_UNICODE |
| if (utf_or_ucp && d >= 128) |
| otherd = UCD_OTHERCASE(d); |
| else |
| #endif /* SUPPORT_UNICODE */ |
| otherd = TABLE_GET(d, fcc, d); |
| } |
| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) |
| { |
| if (codevalue == OP_POSUPTO || codevalue == OP_NOTPOSUPTO) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| if (++count >= (int)GET2(code, 1)) |
| { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); } |
| else |
| { ADD_NEW(state_offset, count); } |
| } |
| } |
| break; |
| |
| |
| /* ========================================================================== */ |
| /* These are the class-handling opcodes */ |
| |
| case OP_CLASS: |
| case OP_NCLASS: |
| case OP_XCLASS: |
| { |
| BOOL isinclass = FALSE; |
| int next_state_offset; |
| PCRE2_SPTR ecode; |
| |
| /* For a simple class, there is always just a 32-byte table, and we |
| can set isinclass from it. */ |
| |
| if (codevalue != OP_XCLASS) |
| { |
| ecode = code + 1 + (32 / sizeof(PCRE2_UCHAR)); |
| if (clen > 0) |
| { |
| isinclass = (c > 255)? (codevalue == OP_NCLASS) : |
| ((((uint8_t *)(code + 1))[c/8] & (1u << (c&7))) != 0); |
| } |
| } |
| |
| /* An extended class may have a table or a list of single characters, |
| ranges, or both, and it may be positive or negative. There's a |
| function that sorts all this out. */ |
| |
| else |
| { |
| ecode = code + GET(code, 1); |
| if (clen > 0) isinclass = PRIV(xclass)(c, code + 1 + LINK_SIZE, utf); |
| } |
| |
| /* At this point, isinclass is set for all kinds of class, and ecode |
| points to the byte after the end of the class. If there is a |
| quantifier, this is where it will be. */ |
| |
| next_state_offset = (int)(ecode - start_code); |
| |
| switch (*ecode) |
| { |
| case OP_CRSTAR: |
| case OP_CRMINSTAR: |
| case OP_CRPOSSTAR: |
| ADD_ACTIVE(next_state_offset + 1, 0); |
| if (isinclass) |
| { |
| if (*ecode == OP_CRPOSSTAR) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW(state_offset, 0); |
| } |
| break; |
| |
| case OP_CRPLUS: |
| case OP_CRMINPLUS: |
| case OP_CRPOSPLUS: |
| count = current_state->count; /* Already matched */ |
| if (count > 0) { ADD_ACTIVE(next_state_offset + 1, 0); } |
| if (isinclass) |
| { |
| if (count > 0 && *ecode == OP_CRPOSPLUS) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| count++; |
| ADD_NEW(state_offset, count); |
| } |
| break; |
| |
| case OP_CRQUERY: |
| case OP_CRMINQUERY: |
| case OP_CRPOSQUERY: |
| ADD_ACTIVE(next_state_offset + 1, 0); |
| if (isinclass) |
| { |
| if (*ecode == OP_CRPOSQUERY) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| ADD_NEW(next_state_offset + 1, 0); |
| } |
| break; |
| |
| case OP_CRRANGE: |
| case OP_CRMINRANGE: |
| case OP_CRPOSRANGE: |
| count = current_state->count; /* Already matched */ |
| if (count >= (int)GET2(ecode, 1)) |
| { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); } |
| if (isinclass) |
| { |
| int max = (int)GET2(ecode, 1 + IMM2_SIZE); |
| |
| if (*ecode == OP_CRPOSRANGE && count >= (int)GET2(ecode, 1)) |
| { |
| active_count--; /* Remove non-match possibility */ |
| next_active_state--; |
| } |
| |
| if (++count >= max && max != 0) /* Max 0 => no limit */ |
| { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); } |
| else |
| { ADD_NEW(state_offset, count); } |
| } |
| break; |
| |
| default: |
| if (isinclass) { ADD_NEW(next_state_offset, 0); } |
| break; |
| } |
| } |
| break; |
| |
| /* ========================================================================== */ |
| /* These are the opcodes for fancy brackets of various kinds. We have |
| to use recursion in order to handle them. The "always failing" assertion |
| (?!) is optimised to OP_FAIL when compiling, so we have to support that, |
| though the other "backtracking verbs" are not supported. */ |
| |
| case OP_FAIL: |
| forced_fail++; /* Count FAILs for multiple states */ |
| break; |
| |
| case OP_ASSERT: |
| case OP_ASSERT_NOT: |
| case OP_ASSERTBACK: |
| case OP_ASSERTBACK_NOT: |
| { |
| int rc; |
| int *local_workspace; |
| PCRE2_SIZE *local_offsets; |
| PCRE2_SPTR endasscode = code + GET(code, 1); |
| RWS_anchor *rws = (RWS_anchor *)RWS; |
| |
| if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) |
| { |
| rc = more_workspace(&rws, RWS_OVEC_OSIZE, mb); |
| if (rc != 0) return rc; |
| RWS = (int *)rws; |
| } |
| |
| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); |
| local_workspace = ((int *)local_offsets) + RWS_OVEC_OSIZE; |
| rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; |
| |
| while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1); |
| |
| rc = internal_dfa_match( |
| mb, /* static match data */ |
| code, /* this subexpression's code */ |
| ptr, /* where we currently are */ |
| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ |
| local_offsets, /* offset vector */ |
| RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ |
| local_workspace, /* workspace vector */ |
| RWS_RSIZE, /* size of same */ |
| rlevel, /* function recursion level */ |
| RWS); /* recursion workspace */ |
| |
| rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; |
| |
| if (rc < 0 && rc != PCRE2_ERROR_NOMATCH) return rc; |
| if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK)) |
| { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_COND: |
| case OP_SCOND: |
| { |
| int codelink = (int)GET(code, 1); |
| PCRE2_UCHAR condcode; |
| |
| /* Because of the way auto-callout works during compile, a callout item |
| is inserted between OP_COND and an assertion condition. This does not |
| happen for the other conditions. */ |
| |
| if (code[LINK_SIZE + 1] == OP_CALLOUT |
| || code[LINK_SIZE + 1] == OP_CALLOUT_STR) |
| { |
| PCRE2_SIZE callout_length; |
| rrc = do_callout(code, offsets, current_subject, ptr, mb, |
| 1 + LINK_SIZE, &callout_length); |
| if (rrc < 0) return rrc; /* Abandon */ |
| if (rrc > 0) break; /* Fail this thread */ |
| code += callout_length; /* Skip callout data */ |
| } |
| |
| condcode = code[LINK_SIZE+1]; |
| |
| /* Back reference conditions and duplicate named recursion conditions |
| are not supported */ |
| |
| if (condcode == OP_CREF || condcode == OP_DNCREF || |
| condcode == OP_DNRREF) |
| return PCRE2_ERROR_DFA_UCOND; |
| |
| /* The DEFINE condition is always false, and the assertion (?!) is |
| converted to OP_FAIL. */ |
| |
| if (condcode == OP_FALSE || condcode == OP_FAIL) |
| { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); } |
| |
| /* There is also an always-true condition */ |
| |
| else if (condcode == OP_TRUE) |
| { ADD_ACTIVE(state_offset + LINK_SIZE + 2, 0); } |
| |
| /* The only supported version of OP_RREF is for the value RREF_ANY, |
| which means "test if in any recursion". We can't test for specifically |
| recursed groups. */ |
| |
| else if (condcode == OP_RREF) |
| { |
| unsigned int value = GET2(code, LINK_SIZE + 2); |
| if (value != RREF_ANY) return PCRE2_ERROR_DFA_UCOND; |
| if (mb->recursive != NULL) |
| { ADD_ACTIVE(state_offset + LINK_SIZE + 2 + IMM2_SIZE, 0); } |
| else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); } |
| } |
| |
| /* Otherwise, the condition is an assertion */ |
| |
| else |
| { |
| int rc; |
| int *local_workspace; |
| PCRE2_SIZE *local_offsets; |
| PCRE2_SPTR asscode = code + LINK_SIZE + 1; |
| PCRE2_SPTR endasscode = asscode + GET(asscode, 1); |
| RWS_anchor *rws = (RWS_anchor *)RWS; |
| |
| if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) |
| { |
| rc = more_workspace(&rws, RWS_OVEC_OSIZE, mb); |
| if (rc != 0) return rc; |
| RWS = (int *)rws; |
| } |
| |
| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); |
| local_workspace = ((int *)local_offsets) + RWS_OVEC_OSIZE; |
| rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; |
| |
| while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1); |
| |
| rc = internal_dfa_match( |
| mb, /* fixed match data */ |
| asscode, /* this subexpression's code */ |
| ptr, /* where we currently are */ |
| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ |
| local_offsets, /* offset vector */ |
| RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ |
| local_workspace, /* workspace vector */ |
| RWS_RSIZE, /* size of same */ |
| rlevel, /* function recursion level */ |
| RWS); /* recursion workspace */ |
| |
| rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; |
| |
| if (rc < 0 && rc != PCRE2_ERROR_NOMATCH) return rc; |
| if ((rc >= 0) == |
| (condcode == OP_ASSERT || condcode == OP_ASSERTBACK)) |
| { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); } |
| else |
| { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); } |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_RECURSE: |
| { |
| int rc; |
| int *local_workspace; |
| PCRE2_SIZE *local_offsets; |
| RWS_anchor *rws = (RWS_anchor *)RWS; |
| dfa_recursion_info *ri; |
| PCRE2_SPTR callpat = start_code + GET(code, 1); |
| uint32_t recno = (callpat == mb->start_code)? 0 : |
| GET2(callpat, 1 + LINK_SIZE); |
| |
| if (rws->free < RWS_RSIZE + RWS_OVEC_RSIZE) |
| { |
| rc = more_workspace(&rws, RWS_OVEC_RSIZE, mb); |
| if (rc != 0) return rc; |
| RWS = (int *)rws; |
| } |
| |
| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); |
| local_workspace = ((int *)local_offsets) + RWS_OVEC_RSIZE; |
| rws->free -= RWS_RSIZE + RWS_OVEC_RSIZE; |
| |
| /* Check for repeating a recursion without advancing the subject |
| pointer. This should catch convoluted mutual recursions. (Some simple |
| cases are caught at compile time.) */ |
| |
| for (ri = mb->recursive; ri != NULL; ri = ri->prevrec) |
| if (recno == ri->group_num && ptr == ri->subject_position) |
| return PCRE2_ERROR_RECURSELOOP; |
| |
| /* Remember this recursion and where we started it so as to |
| catch infinite loops. */ |
| |
| new_recursive.group_num = recno; |
| new_recursive.subject_position = ptr; |
| new_recursive.prevrec = mb->recursive; |
| mb->recursive = &new_recursive; |
| |
| rc = internal_dfa_match( |
| mb, /* fixed match data */ |
| callpat, /* this subexpression's code */ |
| ptr, /* where we currently are */ |
| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ |
| local_offsets, /* offset vector */ |
| RWS_OVEC_RSIZE/OVEC_UNIT, /* size of same */ |
| local_workspace, /* workspace vector */ |
| RWS_RSIZE, /* size of same */ |
| rlevel, /* function recursion level */ |
| RWS); /* recursion workspace */ |
| |
| rws->free += RWS_RSIZE + RWS_OVEC_RSIZE; |
| mb->recursive = new_recursive.prevrec; /* Done this recursion */ |
| |
| /* Ran out of internal offsets */ |
| |
| if (rc == 0) return PCRE2_ERROR_DFA_RECURSE; |
| |
| /* For each successful matched substring, set up the next state with a |
| count of characters to skip before trying it. Note that the count is in |
| characters, not bytes. */ |
| |
| if (rc > 0) |
| { |
| for (rc = rc*2 - 2; rc >= 0; rc -= 2) |
| { |
| PCRE2_SIZE charcount = local_offsets[rc+1] - local_offsets[rc]; |
| #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 |
| if (utf) |
| { |
| PCRE2_SPTR p = start_subject + local_offsets[rc]; |
| PCRE2_SPTR pp = start_subject + local_offsets[rc+1]; |
| while (p < pp) if (NOT_FIRSTCU(*p++)) charcount--; |
| } |
| #endif |
| if (charcount > 0) |
| { |
| ADD_NEW_DATA(-(state_offset + LINK_SIZE + 1), 0, |
| (int)(charcount - 1)); |
| } |
| else |
| { |
| ADD_ACTIVE(state_offset + LINK_SIZE + 1, 0); |
| } |
| } |
| } |
| else if (rc != PCRE2_ERROR_NOMATCH) return rc; |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_BRAPOS: |
| case OP_SBRAPOS: |
| case OP_CBRAPOS: |
| case OP_SCBRAPOS: |
| case OP_BRAPOSZERO: |
| { |
| int rc; |
| int *local_workspace; |
| PCRE2_SIZE *local_offsets; |
| PCRE2_SIZE charcount, matched_count; |
| PCRE2_SPTR local_ptr = ptr; |
| RWS_anchor *rws = (RWS_anchor *)RWS; |
| BOOL allow_zero; |
| |
| if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) |
| { |
| rc = more_workspace(&rws, RWS_OVEC_OSIZE, mb); |
| if (rc != 0) return rc; |
| RWS = (int *)rws; |
| } |
| |
| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); |
| local_workspace = ((int *)local_offsets) + RWS_OVEC_OSIZE; |
| rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; |
| |
| if (codevalue == OP_BRAPOSZERO) |
| { |
| allow_zero = TRUE; |
| codevalue = *(++code); /* Codevalue will be one of above BRAs */ |
| } |
| else allow_zero = FALSE; |
| |
| /* Loop to match the subpattern as many times as possible as if it were |
| a complete pattern. */ |
| |
| for (matched_count = 0;; matched_count++) |
| { |
| rc = internal_dfa_match( |
| mb, /* fixed match data */ |
| code, /* this subexpression's code */ |
| local_ptr, /* where we currently are */ |
| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ |
| local_offsets, /* offset vector */ |
| RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ |
| local_workspace, /* workspace vector */ |
| RWS_RSIZE, /* size of same */ |
| rlevel, /* function recursion level */ |
| RWS); /* recursion workspace */ |
| |
| /* Failed to match */ |
| |
| if (rc < 0) |
| { |
| if (rc != PCRE2_ERROR_NOMATCH) return rc; |
| break; |
| } |
| |
| /* Matched: break the loop if zero characters matched. */ |
| |
| charcount = local_offsets[1] - local_offsets[0]; |
| if (charcount == 0) break; |
| local_ptr += charcount; /* Advance temporary position ptr */ |
| } |
| |
| rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; |
| |
| /* At this point we have matched the subpattern matched_count |
| times, and local_ptr is pointing to the character after the end of the |
| last match. */ |
| |
| if (matched_count > 0 || allow_zero) |
| { |
| PCRE2_SPTR end_subpattern = code; |
| int next_state_offset; |
| |
| do { end_subpattern += GET(end_subpattern, 1); } |
| while (*end_subpattern == OP_ALT); |
| next_state_offset = |
| (int)(end_subpattern - start_code + LINK_SIZE + 1); |
| |
| /* Optimization: if there are no more active states, and there |
| are no new states yet set up, then skip over the subject string |
| right here, to save looping. Otherwise, set up the new state to swing |
| into action when the end of the matched substring is reached. */ |
| |
| if (i + 1 >= active_count && new_count == 0) |
| { |
| ptr = local_ptr; |
| clen = 0; |
| ADD_NEW(next_state_offset, 0); |
| } |
| else |
| { |
| PCRE2_SPTR p = ptr; |
| PCRE2_SPTR pp = local_ptr; |
| charcount = (PCRE2_SIZE)(pp - p); |
| #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 |
| if (utf) while (p < pp) if (NOT_FIRSTCU(*p++)) charcount--; |
| #endif |
| ADD_NEW_DATA(-next_state_offset, 0, (int)(charcount - 1)); |
| } |
| } |
| } |
| break; |
| |
| /*-----------------------------------------------------------------*/ |
| case OP_ONCE: |
| { |
| int rc; |
| int *local_workspace; |
| PCRE2_SIZE *local_offsets; |
| RWS_anchor *rws = (RWS_anchor *)RWS; |
| |
| if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) |
| { |
| rc = more_workspace(&rws, RWS_OVEC_OSIZE, mb); |
| if (rc != 0) return rc; |
| RWS = (int *)rws; |
| } |
| |
| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); |
| local_workspace = ((int *)local_offsets) + RWS_OVEC_OSIZE; |
| rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; |
| |
| rc = internal_dfa_match( |
| mb, /* fixed match data */ |
| code, /* this subexpression's code */ |
| ptr, /* where we currently are */ |
| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ |
| local_offsets, /* offset vector */ |
| RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ |
| local_workspace, /* workspace vector */ |
| RWS_RSIZE, /* size of same */ |
| rlevel, /* function recursion level */ |
| RWS); /* recursion workspace */ |
| |
| rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; |
| |
| if (rc >= 0) |
| { |
| PCRE2_SPTR end_subpattern = code; |
| PCRE2_SIZE charcount = local_offsets[1] - local_offsets[0]; |
| int next_state_offset, repeat_state_offset; |
| |
| do { end_subpattern += GET(end_subpattern, 1); } |
| while (*end_subpattern == OP_ALT); |
| next_state_offset = |
| (int)(end_subpattern - start_code + LINK_SIZE + 1); |
| |
| /* If the end of this subpattern is KETRMAX or KETRMIN, we must |
| arrange for the repeat state also to be added to the relevant list. |
| Calculate the offset, or set -1 for no repeat. */ |
| |
| repeat_state_offset = (*end_subpattern == OP_KETRMAX || |
| *end_subpattern == OP_KETRMIN)? |
| (int)(end_subpattern - start_code - GET(end_subpattern, 1)) : -1; |
| |
| /* If we have matched an empty string, add the next state at the |
| current character pointer. This is important so that the duplicate |
| checking kicks in, which is what breaks infinite loops that match an |
| empty string. */ |
| |
| if (charcount == 0) |
| { |
| ADD_ACTIVE(next_state_offset, 0); |
| } |
| |
| /* Optimization: if there are no more active states, and there |
| are no new states yet set up, then skip over the subject string |
| right here, to save looping. Otherwise, set up the new state to swing |
| into action when the end of the matched substring is reached. */ |
| |
| else if (i + 1 >= active_count && new_count == 0) |
| { |
| ptr += charcount; |
| clen = 0; |
| ADD_NEW(next_state_offset, 0); |
| |
| /* If we are adding a repeat state at the new character position, |
| we must fudge things so that it is the only current state. |
| Otherwise, it might be a duplicate of one we processed before, and |
| that would cause it to be skipped. */ |
| |
| if (repeat_state_offset >= 0) |
| { |
| next_active_state = active_states; |
| active_count = 0; |
| i = -1; |
| ADD_ACTIVE(repeat_state_offset, 0); |
| } |
| } |
| else |
| { |
| #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 |
| if (utf) |
| { |
| PCRE2_SPTR p = start_subject + local_offsets[0]; |
| PCRE2_SPTR pp = start_subject + local_offsets[1]; |
| while (p < pp) if (NOT_FIRSTCU(*p++)) charcount--; |
| } |
| #endif |
| ADD_NEW_DATA(-next_state_offset, 0, (int)(charcount - 1)); |
| if (repeat_state_offset >= 0) |
| { ADD_NEW_DATA(-repeat_state_offset, 0, (int)(charcount - 1)); } |
| } |
| } |
| else if (rc != PCRE2_ERROR_NOMATCH) return rc; |
| } |
| break; |
| |
| |
| /* ========================================================================== */ |
| /* Handle callouts */ |
| |
| case OP_CALLOUT: |
| case OP_CALLOUT_STR: |
| { |
| PCRE2_SIZE callout_length; |
| rrc = do_callout(code, offsets, current_subject, ptr, mb, 0, |
| &callout_length); |
| if (rrc < 0) return rrc; /* Abandon */ |
| if (rrc == 0) |
| { ADD_ACTIVE(state_offset + (int)callout_length, 0); } |
| } |
| break; |
| |
| |
| /* ========================================================================== */ |
| default: /* Unsupported opcode */ |
| return PCRE2_ERROR_DFA_UITEM; |
| } |
| |
| NEXT_ACTIVE_STATE: continue; |
| |
| } /* End of loop scanning active states */ |
| |
| /* We have finished the processing at the current subject character. If no |
| new states have been set for the next character, we have found all the |
| matches that we are going to find. If partial matching has been requested, |
| check for appropriate conditions. |
| |
| The "forced_ fail" variable counts the number of (*F) encountered for the |
| character. If it is equal to the original active_count (saved in |
| workspace[1]) it means that (*F) was found on every active state. In this |
| case we don't want to give a partial match. |
| |
| The "could_continue" variable is true if a state could have continued but |
| for the fact that the end of the subject was reached. */ |
| |
| if (new_count <= 0) |
| { |
| if (could_continue && /* Some could go on, and */ |
| forced_fail != workspace[1] && /* Not all forced fail & */ |
| ( /* either... */ |
| (mb->moptions & PCRE2_PARTIAL_HARD) != 0 /* Hard partial */ |
| || /* or... */ |
| ((mb->moptions & PCRE2_PARTIAL_SOFT) != 0 && /* Soft partial and */ |
| match_count < 0) /* no matches */ |
| ) && /* And... */ |
| ( |
| partial_newline || /* Either partial NL */ |
| ( /* or ... */ |
| ptr >= end_subject && /* End of subject and */ |
| ( /* either */ |
| ptr > mb->start_used_ptr || /* Inspected non-empty string */ |
| mb->allowemptypartial /* or pattern has lookbehind */ |
| ) /* or could match empty */ |
| ) |
| )) |
| match_count = PCRE2_ERROR_PARTIAL; |
| break; /* Exit from loop along the subject string */ |
| } |
| |
| /* One or more states are active for the next character. */ |
| |
| ptr += clen; /* Advance to next subject character */ |
| } /* Loop to move along the subject string */ |
| |
| /* Control gets here from "break" a few lines above. If we have a match and |
| PCRE2_ENDANCHORED is set, the match fails. */ |
| |
| if (match_count >= 0 && |
| ((mb->moptions | mb->poptions) & PCRE2_ENDANCHORED) != 0 && |
| ptr < end_subject) |
| match_count = PCRE2_ERROR_NOMATCH; |
| |
| return match_count; |
| } |
| |
| |
| |
| /************************************************* |
| * Match a pattern using the DFA algorithm * |
| *************************************************/ |
| |
| /* This function matches a compiled pattern to a subject string, using the |
| alternate matching algorithm that finds all matches at once. |
| |
| Arguments: |
| code points to the compiled pattern |
| subject subject string |
| length length of subject string |
| startoffset where to start matching in the subject |
| options option bits |
| match_data points to a match data structure |
| gcontext points to a match context |
| workspace pointer to workspace |
| wscount size of workspace |
| |
| Returns: > 0 => number of match offset pairs placed in offsets |
| = 0 => offsets overflowed; longest matches are present |
| -1 => failed to match |
| < -1 => some kind of unexpected problem |
| */ |
| |
| PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
| pcre2_dfa_match(const pcre2_code *code, PCRE2_SPTR subject, PCRE2_SIZE length, |
| PCRE2_SIZE start_offset, uint32_t options, pcre2_match_data *match_data, |
| pcre2_match_context *mcontext, int *workspace, PCRE2_SIZE wscount) |
| { |
| int rc; |
| int was_zero_terminated = 0; |
| |
| const pcre2_real_code *re = (const pcre2_real_code *)code; |
| |
| PCRE2_SPTR start_match; |
| PCRE2_SPTR end_subject; |
| PCRE2_SPTR bumpalong_limit; |
| PCRE2_SPTR req_cu_ptr; |
| |
| BOOL utf, anchored, startline, firstline; |
| BOOL has_first_cu = FALSE; |
| BOOL has_req_cu = FALSE; |
| |
| #if PCRE2_CODE_UNIT_WIDTH == 8 |
| PCRE2_SPTR memchr_found_first_cu = NULL; |
| PCRE2_SPTR memchr_found_first_cu2 = NULL; |
| #endif |
| |
| PCRE2_UCHAR first_cu = 0; |
| PCRE2_UCHAR first_cu2 = 0; |
| PCRE2_UCHAR req_cu = 0; |
| PCRE2_UCHAR req_cu2 = 0; |
| |
| const uint8_t *start_bits = NULL; |
| |
| /* We need to have mb pointing to a match block, because the IS_NEWLINE macro |
| is used below, and it expects NLBLOCK to be defined as a pointer. */ |
| |
| pcre2_callout_block cb; |
| dfa_match_block actual_match_block; |
| dfa_match_block *mb = &actual_match_block; |
| |
| /* Set up a starting block of memory for use during recursive calls to |
| internal_dfa_match(). By putting this on the stack, it minimizes resource use |
| in the case when it is not needed. If this is too small, more memory is |
| obtained from the heap. At the start of each block is an anchor structure.*/ |
| |
| int base_recursion_workspace[RWS_BASE_SIZE]; |
| RWS_anchor *rws = (RWS_anchor *)base_recursion_workspace; |
| rws->next = NULL; |
| rws->size = RWS_BASE_SIZE; |
| rws->free = RWS_BASE_SIZE - RWS_ANCHOR_SIZE; |
| |
| /* Recognize NULL, length 0 as an empty string. */ |
| |
| if (subject == NULL && length == 0) subject = (PCRE2_SPTR)""; |
| |
| /* Plausibility checks */ |
| |
| if ((options & ~PUBLIC_DFA_MATCH_OPTIONS) != 0) return PCRE2_ERROR_BADOPTION; |
| if (re == NULL || subject == NULL || workspace == NULL || match_data == NULL) |
| return PCRE2_ERROR_NULL; |
| |
| if (length == PCRE2_ZERO_TERMINATED) |
| { |
| length = PRIV(strlen)(subject); |
| was_zero_terminated = 1; |
| } |
| |
| if (wscount < 20) return PCRE2_ERROR_DFA_WSSIZE; |
| if (start_offset > length) return PCRE2_ERROR_BADOFFSET; |
| |
| /* Partial matching and PCRE2_ENDANCHORED are currently not allowed at the same |
| time. */ |
| |
| if ((options & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && |
| ((re->overall_options | options) & PCRE2_ENDANCHORED) != 0) |
| return PCRE2_ERROR_BADOPTION; |
| |
| /* Invalid UTF support is not available for DFA matching. */ |
| |
| if ((re->overall_options & PCRE2_MATCH_INVALID_UTF) != 0) |
| return PCRE2_ERROR_DFA_UINVALID_UTF; |
| |
| /* Check that the first field in the block is the magic number. If it is not, |
| return with PCRE2_ERROR_BADMAGIC. */ |
| |
| if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC; |
| |
| /* Check the code unit width. */ |
| |
| if ((re->flags & PCRE2_MODE_MASK) != PCRE2_CODE_UNIT_WIDTH/8) |
| return PCRE2_ERROR_BADMODE; |
| |
| /* PCRE2_NOTEMPTY and PCRE2_NOTEMPTY_ATSTART are match-time flags in the |
| options variable for this function. Users of PCRE2 who are not calling the |
| function directly would like to have a way of setting these flags, in the same |
| way that they can set pcre2_compile() flags like PCRE2_NO_AUTOPOSSESS with |
| constructions like (*NO_AUTOPOSSESS). To enable this, (*NOTEMPTY) and |
| (*NOTEMPTY_ATSTART) set bits in the pattern's "flag" function which can now be |
| transferred to the options for this function. The bits are guaranteed to be |
| adjacent, but do not have the same values. This bit of Boolean trickery assumes |
| that the match-time bits are not more significant than the flag bits. If by |
| accident this is not the case, a compile-time division by zero error will |
| occur. */ |
| |
| #define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) |
| #define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) |
| options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); |
| #undef FF |
| #undef OO |
| |
| /* If restarting after a partial match, do some sanity checks on the contents |
| of the workspace. */ |
| |
| if ((options & PCRE2_DFA_RESTART) != 0) |
| { |
| if ((workspace[0] & (-2)) != 0 || workspace[1] < 1 || |
| workspace[1] > (int)((wscount - 2)/INTS_PER_STATEBLOCK)) |
| return PCRE2_ERROR_DFA_BADRESTART; |
| } |
| |
| /* Set some local values */ |
| |
| utf = (re->overall_options & PCRE2_UTF) != 0; |
| start_match = subject + start_offset; |
| end_subject = subject + length; |
| req_cu_ptr = start_match - 1; |
| anchored = (options & (PCRE2_ANCHORED|PCRE2_DFA_RESTART)) != 0 || |
| (re->overall_options & PCRE2_ANCHORED) != 0; |
| |
| /* The "must be at the start of a line" flags are used in a loop when finding |
| where to start. */ |
| |
| startline = (re->flags & PCRE2_STARTLINE) != 0; |
| firstline = (re->overall_options & PCRE2_FIRSTLINE) != 0; |
| bumpalong_limit = end_subject; |
| |
| /* Initialize and set up the fixed fields in the callout block, with a pointer |
| in the match block. */ |
| |
| mb->cb = &cb; |
| cb.version = 2; |
| cb.subject = subject; |
| cb.subject_length = (PCRE2_SIZE)(end_subject - subject); |
| cb.callout_flags = 0; |
| cb.capture_top = 1; /* No capture support */ |
| cb.capture_last = 0; |
| cb.mark = NULL; /* No (*MARK) support */ |
| |
| /* Get data from the match context, if present, and fill in the remaining |
| fields in the match block. It is an error to set an offset limit without |
| setting the flag at compile time. */ |
| |
| if (mcontext == NULL) |
| { |
| mb->callout = NULL; |
| mb->memctl = re->memctl; |
| mb->match_limit = PRIV(default_match_context).match_limit; |
| mb->match_limit_depth = PRIV(default_match_context).depth_limit; |
| mb->heap_limit = PRIV(default_match_context).heap_limit; |
| } |
| else |
| { |
| if (mcontext->offset_limit != PCRE2_UNSET) |
| { |
| if ((re->overall_options & PCRE2_USE_OFFSET_LIMIT) == 0) |
| return PCRE2_ERROR_BADOFFSETLIMIT; |
| bumpalong_limit = subject + mcontext->offset_limit; |
| } |
| mb->callout = mcontext->callout; |
| mb->callout_data = mcontext->callout_data; |
| mb->memctl = mcontext->memctl; |
| mb->match_limit = mcontext->match_limit; |
| mb->match_limit_depth = mcontext->depth_limit; |
| mb->heap_limit = mcontext->heap_limit; |
| } |
| |
| if (mb->match_limit > re->limit_match) |
| mb->match_limit = re->limit_match; |
| |
| if (mb->match_limit_depth > re->limit_depth) |
| mb->match_limit_depth = re->limit_depth; |
| |
| if (mb->heap_limit > re->limit_heap) |
| mb->heap_limit = re->limit_heap; |
| |
| mb->start_code = (PCRE2_UCHAR *)((uint8_t *)re + sizeof(pcre2_real_code)) + |
| re->name_count * re->name_entry_size; |
| mb->tables = re->tables; |
| mb->start_subject = subject; |
| mb->end_subject = end_subject; |
| mb->start_offset = start_offset; |
| mb->allowemptypartial = (re->max_lookbehind > 0) || |
| (re->flags & PCRE2_MATCH_EMPTY) != 0; |
| mb->moptions = options; |
| mb->poptions = re->overall_options; |
| mb->match_call_count = 0; |
| mb->heap_used = 0; |
| |
| /* Process the \R and newline settings. */ |
| |
| mb->bsr_convention = re->bsr_convention; |
| mb->nltype = NLTYPE_FIXED; |
| switch(re->newline_convention) |
| { |
| case PCRE2_NEWLINE_CR: |
| mb->nllen = 1; |
| mb->nl[0] = CHAR_CR; |
| break; |
| |
| case PCRE2_NEWLINE_LF: |
| mb->nllen = 1; |
| mb->nl[0] = CHAR_NL; |
| break; |
| |
| case PCRE2_NEWLINE_NUL: |
| mb->nllen = 1; |
| mb->nl[0] = CHAR_NUL; |
| break; |
| |
| case PCRE2_NEWLINE_CRLF: |
| mb->nllen = 2; |
| mb->nl[0] = CHAR_CR; |
| mb->nl[1] = CHAR_NL; |
| break; |
| |
| case PCRE2_NEWLINE_ANY: |
| mb->nltype = NLTYPE_ANY; |
| break; |
| |
| case PCRE2_NEWLINE_ANYCRLF: |
| mb->nltype = NLTYPE_ANYCRLF; |
| break; |
| |
| default: return PCRE2_ERROR_INTERNAL; |
| } |
| |
| /* Check a UTF string for validity if required. For 8-bit and 16-bit strings, |
| we must also check that a starting offset does not point into the middle of a |
| multiunit character. We check only the portion of the subject that is going to |
| be inspected during matching - from the offset minus the maximum back reference |
| to the given length. This saves time when a small part of a large subject is |
| being matched by the use of a starting offset. Note that the maximum lookbehind |
| is a number of characters, not code units. */ |
| |
| #ifdef SUPPORT_UNICODE |
| if (utf && (options & PCRE2_NO_UTF_CHECK) == 0) |
| { |
| PCRE2_SPTR check_subject = start_match; /* start_match includes offset */ |
| |
| if (start_offset > 0) |
| { |
| #if PCRE2_CODE_UNIT_WIDTH != 32 |
| unsigned int i; |
| if (start_match < end_subject && NOT_FIRSTCU(*start_match)) |
| return PCRE2_ERROR_BADUTFOFFSET; |
| for (i = re->max_lookbehind; i > 0 && check_subject > subject; i--) |
| { |
| check_subject--; |
| while (check_subject > subject && |
| #if PCRE2_CODE_UNIT_WIDTH == 8 |
| (*check_subject & 0xc0) == 0x80) |
| #else /* 16-bit */ |
| (*check_subject & 0xfc00) == 0xdc00) |
| #endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ |
| check_subject--; |
| } |
| #else /* In the 32-bit library, one code unit equals one character. */ |
| check_subject -= re->max_lookbehind; |
| if (check_subject < subject) check_subject = subject; |
| #endif /* PCRE2_CODE_UNIT_WIDTH != 32 */ |
| } |
| |
| /* Validate the relevant portion of the subject. After an error, adjust the |
| offset to be an absolute offset in the whole string. */ |
| |
| match_data->rc = PRIV(valid_utf)(check_subject, |
| length - (PCRE2_SIZE)(check_subject - subject), &(match_data->startchar)); |
| if (match_data->rc != 0) |
| { |
| match_data->startchar += (PCRE2_SIZE)(check_subject - subject); |
| return match_data->rc; |
| } |
| } |
| #endif /* SUPPORT_UNICODE */ |
| |
| /* Set up the first code unit to match, if available. If there's no first code |
| unit there may be a bitmap of possible first characters. */ |
| |
| if ((re->flags & PCRE2_FIRSTSET) != 0) |
| { |
| has_first_cu = TRUE; |
| first_cu = first_cu2 = (PCRE2_UCHAR)(re->first_codeunit); |
| if ((re->flags & PCRE2_FIRSTCASELESS) != 0) |
| { |
| first_cu2 = TABLE_GET(first_cu, mb->tables + fcc_offset, first_cu); |
| #ifdef SUPPORT_UNICODE |
| #if PCRE2_CODE_UNIT_WIDTH == 8 |
| if (first_cu > 127 && !utf && (re->overall_options & PCRE2_UCP) != 0) |
| first_cu2 = (PCRE2_UCHAR)UCD_OTHERCASE(first_cu); |
| #else |
| if (first_cu > 127 && (utf || (re->overall_options & PCRE2_UCP) != 0)) |
| first_cu2 = (PCRE2_UCHAR)UCD_OTHERCASE(first_cu); |
| #endif |
| #endif /* SUPPORT_UNICODE */ |
| } |
| } |
| else |
| if (!startline && (re->flags & PCRE2_FIRSTMAPSET) != 0) |
| start_bits = re->start_bitmap; |
| |
| /* There may be a "last known required code unit" set. */ |
| |
| if ((re->flags & PCRE2_LASTSET) != 0) |
| { |
| has_req_cu = TRUE; |
| req_cu = req_cu2 = (PCRE2_UCHAR)(re->last_codeunit); |
| if ((re->flags & PCRE2_LASTCASELESS) != 0) |
| { |
| req_cu2 = TABLE_GET(req_cu, mb->tables + fcc_offset, req_cu); |
| #ifdef SUPPORT_UNICODE |
| #if PCRE2_CODE_UNIT_WIDTH == 8 |
| if (req_cu > 127 && !utf && (re->overall_options & PCRE2_UCP) != 0) |
| req_cu2 = (PCRE2_UCHAR)UCD_OTHERCASE(req_cu); |
| #else |
| if (req_cu > 127 && (utf || (re->overall_options & PCRE2_UCP) != 0)) |
| req_cu2 = (PCRE2_UCHAR)UCD_OTHERCASE(req_cu); |
| #endif |
| #endif /* SUPPORT_UNICODE */ |
| } |
| } |
| |
| /* If the match data block was previously used with PCRE2_COPY_MATCHED_SUBJECT, |
| free the memory that was obtained. */ |
| |
| if ((match_data->flags & PCRE2_MD_COPIED_SUBJECT) != 0) |
| { |
| match_data->memctl.free((void *)match_data->subject, |
| match_data->memctl.memory_data); |
| match_data->flags &= ~PCRE2_MD_COPIED_SUBJECT; |
| } |
| |
| /* Fill in fields that are always returned in the match data. */ |
| |
| match_data->code = re; |
| match_data->subject = NULL; /* Default for no match */ |
| match_data->mark = NULL; |
| match_data->matchedby = PCRE2_MATCHEDBY_DFA_INTERPRETER; |
| |
| /* Call the main matching function, looping for a non-anchored regex after a |
| failed match. If not restarting, perform certain optimizations at the start of |
| a match. */ |
| |
| for (;;) |
| { |
| /* ----------------- Start of match optimizations ---------------- */ |
| |
| /* There are some optimizations that avoid running the match if a known |
| starting point is not found, or if a known later code unit is not present. |
| However, there is an option (settable at compile time) that disables |
| these, for testing and for ensuring that all callouts do actually occur. |
| The optimizations must also be avoided when restarting a DFA match. */ |
| |
| if ((re->overall_options & PCRE2_NO_START_OPTIMIZE) == 0 && |
| (options & PCRE2_DFA_RESTART) == 0) |
| { |
| /* If firstline is TRUE, the start of the match is constrained to the first |
| line of a multiline string. That is, the match must be before or at the |
| first newline following the start of matching. Temporarily adjust |
| end_subject so that we stop the optimization scans for a first code unit |
| immediately after the first character of a newline (the first code unit can |
| legitimately be a newline). If the match fails at the newline, later code |
| breaks this loop. */ |
| |
| if (firstline) |
| { |
| PCRE2_SPTR t = start_match; |
| #ifdef SUPPORT_UNICODE |
| if (utf) |
| { |
| while (t < end_subject && !IS_NEWLINE(t)) |
| { |
| t++; |
| ACROSSCHAR(t < end_subject, t, t++); |
| } |
| } |
| else |
| #endif |
| while (t < end_subject && !IS_NEWLINE(t)) t++; |
| end_subject = t; |
| } |
| |
| /* Anchored: check the first code unit if one is recorded. This may seem |
| pointless but it can help in detecting a no match case without scanning for |
| the required code unit. */ |
| |
| if (anchored) |
| { |
| if (has_first_cu || start_bits != NULL) |
| { |
| BOOL ok = start_match < end_subject; |
| if (ok) |
| { |
| PCRE2_UCHAR c = UCHAR21TEST(start_match); |
| ok = has_first_cu && (c == first_cu || c == first_cu2); |
| if (!ok && start_bits != NULL) |
| { |
| #if PCRE2_CODE_UNIT_WIDTH != 8 |
| if (c > 255) c = 255; |
| #endif |
| ok = (start_bits[c/8] & (1u << (c&7))) != 0; |
| } |
| } |
| if (!ok) break; |
| } |
| } |
| |
| /* Not anchored. Advance to a unique first code unit if there is one. */ |
| |
| else |
| { |
| if (has_first_cu) |
| { |
| if (first_cu != first_cu2) /* Caseless */ |
| { |
| /* In 16-bit and 32_bit modes we have to do our own search, so can |
| look for both cases at once. */ |
| |
| #if PCRE2_CODE_UNIT_WIDTH != 8 |
| PCRE2_UCHAR smc; |
| while (start_match < end_subject && |
| (smc = UCHAR21TEST(start_match)) != first_cu && |
| smc != first_cu2) |
| start_match++; |
| #else |
| /* In 8-bit mode, the use of memchr() gives a big speed up, even |
| though we have to call it twice in order to find the earliest |
| occurrence of the code unit in either of its cases. Caching is used |
| to remember the positions of previously found code units. This can |
| make a huge difference when the strings are very long and only one |
| case is actually present. */ |
| |
| PCRE2_SPTR pp1 = NULL; |
| PCRE2_SPTR pp2 = NULL; |
| PCRE2_SIZE searchlength = end_subject - start_match; |
| |
| /* If we haven't got a previously found position for first_cu, or if |
| the current starting position is later, we need to do a search. If |
| the code unit is not found, set it to the end. */ |
| |
| if (memchr_found_first_cu == NULL || |
| start_match > memchr_found_first_cu) |
| { |
| pp1 = memchr(start_match, first_cu, searchlength); |
| memchr_found_first_cu = (pp1 == NULL)? end_subject : pp1; |
| } |
| |
| /* If the start is before a previously found position, use the |
| previous position, or NULL if a previous search failed. */ |
| |
| else pp1 = (memchr_found_first_cu == end_subject)? NULL : |
| memchr_found_first_cu; |
| |
| /* Do the same thing for the other case. */ |
| |
| if (memchr_found_first_cu2 == NULL || |
| start_match > memchr_found_first_cu2) |
| { |
| pp2 = memchr(start_match, first_cu2, searchlength); |
| memchr_found_first_cu2 = (pp2 == NULL)? end_subject : pp2; |
| } |
| |
| else pp2 = (memchr_found_first_cu2 == end_subject)? NULL : |
| memchr_found_first_cu2; |
| |
| /* Set the start to the end of the subject if neither case was found. |
| Otherwise, use the earlier found point. */ |
| |
| if (pp1 == NULL) |
| start_match = (pp2 == NULL)? end_subject : pp2; |
| else |
| start_match = (pp2 == NULL || pp1 < pp2)? pp1 : pp2; |
| |
| #endif /* 8-bit handling */ |
| } |
| |
| /* The caseful case is much simpler. */ |
| |
| else |
| { |
| #if PCRE2_CODE_UNIT_WIDTH != 8 |
| while (start_match < end_subject && UCHAR21TEST(start_match) != |
| first_cu) |
| start_match++; |
| #else /* 8-bit code units */ |
| start_match = memchr(start_match, first_cu, end_subject - start_match); |
| if (start_match == NULL) start_match = end_subject; |
| #endif |
| } |
| |
| /* If we can't find the required code unit, having reached the true end |
| of the subject, break the bumpalong loop, to force a match failure, |
| except when doing partial matching, when we let the next cycle run at |
| the end of the subject. To see why, consider the pattern /(?<=abc)def/, |
| which partially matches "abc", even though the string does not contain |
| the starting character "d". If we have not reached the true end of the |
| subject (PCRE2_FIRSTLINE caused end_subject to be temporarily modified) |
| we also let the cycle run, because the matching string is legitimately |
| allowed to start with the first code unit of a newline. */ |
| |
| if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0 && |
| start_match >= mb->end_subject) |
| break; |
| } |
| |
| /* If there's no first code unit, advance to just after a linebreak for a |
| multiline match if required. */ |
| |
| else if (startline) |
| { |
| if (start_match > mb->start_subject + start_offset) |
| { |
| #ifdef SUPPORT_UNICODE |
| if (utf) |
| { |
| while (start_match < end_subject && !WAS_NEWLINE(start_match)) |
| { |
| start_match++; |
| ACROSSCHAR(start_match < end_subject, start_match, start_match++); |
| } |
| } |
| else |
| #endif |
| while (start_match < end_subject && !WAS_NEWLINE(start_match)) |
| start_match++; |
| |
| /* If we have just passed a CR and the newline option is ANY or |
| ANYCRLF, and we are now at a LF, advance the match position by one |
| more code unit. */ |
| |
| if (start_match[-1] == CHAR_CR && |
| (mb->nltype == NLTYPE_ANY || mb->nltype == NLTYPE_ANYCRLF) && |
| start_match < end_subject && |
| UCHAR21TEST(start_match) == CHAR_NL) |
| start_match++; |
| } |
| } |
| |
| /* If there's no first code unit or a requirement for a multiline line |
| start, advance to a non-unique first code unit if any have been |
| identified. The bitmap contains only 256 bits. When code units are 16 or |
| 32 bits wide, all code units greater than 254 set the 255 bit. */ |
| |
| else if (start_bits != NULL) |
| { |
| while (start_match < end_subject) |
| { |
| uint32_t c = UCHAR21TEST(start_match); |
| #if PCRE2_CODE_UNIT_WIDTH != 8 |
| if (c > 255) c = 255; |
| #endif |
| if ((start_bits[c/8] & (1u << (c&7))) != 0) break; |
| start_match++; |
| } |
| |
| /* See comment above in first_cu checking about the next line. */ |
| |
| if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0 && |
| start_match >= mb->end_subject) |
| break; |
| } |
| } /* End of first code unit handling */ |
| |
| /* Restore fudged end_subject */ |
| |
| end_subject = mb->end_subject; |
| |
| /* The following two optimizations are disabled for partial matching. */ |
| |
| if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0) |
| { |
| PCRE2_SPTR p; |
| |
| /* The minimum matching length is a lower bound; no actual string of that |
| length may actually match the pattern. Although the value is, strictly, |
| in characters, we treat it as code units to avoid spending too much time |
| in this optimization. */ |
| |
| if (end_subject - start_match < re->minlength) goto NOMATCH_EXIT; |
| |
| /* If req_cu is set, we know that that code unit must appear in the |
| subject for the match to succeed. If the first code unit is set, req_cu |
| must be later in the subject; otherwise the test starts at the match |
| point. This optimization can save a huge amount of backtracking in |
| patterns with nested unlimited repeats that aren't going to match. |
| Writing separate code for cased/caseless versions makes it go faster, as |
| does using an autoincrement and backing off on a match. As in the case of |
| the first code unit, using memchr() in the 8-bit library gives a big |
| speed up. Unlike the first_cu check above, we do not need to call |
| memchr() twice in the caseless case because we only need to check for the |
| presence of the character in either case, not find the first occurrence. |
| |
| The search can be skipped if the code unit was found later than the |
| current starting point in a previous iteration of the bumpalong loop. |
| |
| HOWEVER: when the subject string is very, very long, searching to its end |
| can take a long time, and give bad performance on quite ordinary |
| patterns. This showed up when somebody was matching something like |
| /^\d+C/ on a 32-megabyte string... so we don't do this when the string is |
| sufficiently long, but it's worth searching a lot more for unanchored |
| patterns. */ |
| |
| p = start_match + (has_first_cu? 1:0); |
| if (has_req_cu && p > req_cu_ptr) |
| { |
| PCRE2_SIZE check_length = end_subject - start_match; |
| |
| if (check_length < REQ_CU_MAX || |
| (!anchored && check_length < REQ_CU_MAX * 1000)) |
| { |
| if (req_cu != req_cu2) /* Caseless */ |
| { |
| #if PCRE2_CODE_UNIT_WIDTH != 8 |
| while (p < end_subject) |
| { |
| uint32_t pp = UCHAR21INCTEST(p); |
| if (pp == req_cu || pp == req_cu2) { p--; break; } |
| } |
| #else /* 8-bit code units */ |
| PCRE2_SPTR pp = p; |
| p = memchr(pp, req_cu, end_subject - pp); |
| if (p == NULL) |
| { |
| p = memchr(pp, req_cu2, end_subject - pp); |
| if (p == NULL) p = end_subject; |
| } |
| #endif /* PCRE2_CODE_UNIT_WIDTH != 8 */ |
| } |
| |
| /* The caseful case */ |
| |
| else |
| { |
| #if PCRE2_CODE_UNIT_WIDTH != 8 |
| while (p < end_subject) |
| { |
| if (UCHAR21INCTEST(p) == req_cu) { p--; break; } |
| } |
| |
| #else /* 8-bit code units */ |
| p = memchr(p, req_cu, end_subject - p); |
| if (p == NULL) p = end_subject; |
| #endif |
| } |
| |
| /* If we can't find the required code unit, break the matching loop, |
| forcing a match failure. */ |
| |
| if (p >= end_subject) break; |
| |
| /* If we have found the required code unit, save the point where we |
| found it, so that we don't search again next time round the loop if |
| the start hasn't passed this code unit yet. */ |
| |
| req_cu_ptr = p; |
| } |
| } |
| } |
| } |
| |
| /* ------------ End of start of match optimizations ------------ */ |
| |
| /* Give no match if we have passed the bumpalong limit. */ |
| |
| if (start_match > bumpalong_limit) break; |
| |
| /* OK, now we can do the business */ |
| |
| mb->start_used_ptr = start_match; |
| mb->last_used_ptr = start_match; |
| mb->recursive = NULL; |
| |
| rc = internal_dfa_match( |
| mb, /* fixed match data */ |
| mb->start_code, /* this subexpression's code */ |
| start_match, /* where we currently are */ |
| start_offset, /* start offset in subject */ |
| match_data->ovector, /* offset vector */ |
| (uint32_t)match_data->oveccount * 2, /* actual size of same */ |
| workspace, /* workspace vector */ |
| (int)wscount, /* size of same */ |
| 0, /* function recurse level */ |
| base_recursion_workspace); /* initial workspace for recursion */ |
| |
| /* Anything other than "no match" means we are done, always; otherwise, carry |
| on only if not anchored. */ |
| |
| if (rc != PCRE2_ERROR_NOMATCH || anchored) |
| { |
| if (rc == PCRE2_ERROR_PARTIAL && match_data->oveccount > 0) |
| { |
| match_data->ovector[0] = (PCRE2_SIZE)(start_match - subject); |
| match_data->ovector[1] = (PCRE2_SIZE)(end_subject - subject); |
| } |
| match_data->leftchar = (PCRE2_SIZE)(mb->start_used_ptr - subject); |
| match_data->rightchar = (PCRE2_SIZE)( mb->last_used_ptr - subject); |
| match_data->startchar = (PCRE2_SIZE)(start_match - subject); |
| match_data->rc = rc; |
| |
| if (rc >= 0 &&(options & PCRE2_COPY_MATCHED_SUBJECT) != 0) |
| { |
| length = CU2BYTES(length + was_zero_terminated); |
| match_data->subject = match_data->memctl.malloc(length, |
| match_data->memctl.memory_data); |
| if (match_data->subject == NULL) return PCRE2_ERROR_NOMEMORY; |
| memcpy((void *)match_data->subject, subject, length); |
| match_data->flags |= PCRE2_MD_COPIED_SUBJECT; |
| } |
| else |
| { |
| if (rc >= 0 || rc == PCRE2_ERROR_PARTIAL) match_data->subject = subject; |
| } |
| goto EXIT; |
| } |
| |
| /* Advance to the next subject character unless we are at the end of a line |
| and firstline is set. */ |
| |
| if (firstline && IS_NEWLINE(start_match)) break; |
| start_match++; |
| #ifdef SUPPORT_UNICODE |
| if (utf) |
| { |
| ACROSSCHAR(start_match < end_subject, start_match, start_match++); |
| } |
| #endif |
| if (start_match > end_subject) break; |
| |
| /* If we have just passed a CR and we are now at a LF, and the pattern does |
| not contain any explicit matches for \r or \n, and the newline option is CRLF |
| or ANY or ANYCRLF, advance the match position by one more character. */ |
| |
| if (UCHAR21TEST(start_match - 1) == CHAR_CR && |
| start_match < end_subject && |
| UCHAR21TEST(start_match) == CHAR_NL && |
| (re->flags & PCRE2_HASCRORLF) == 0 && |
| (mb->nltype == NLTYPE_ANY || |
| mb->nltype == NLTYPE_ANYCRLF || |
| mb->nllen == 2)) |
| start_match++; |
| |
| } /* "Bumpalong" loop */ |
| |
| NOMATCH_EXIT: |
| rc = PCRE2_ERROR_NOMATCH; |
| |
| EXIT: |
| while (rws->next != NULL) |
| { |
| RWS_anchor *next = rws->next; |
| rws->next = next->next; |
| mb->memctl.free(next, mb->memctl.memory_data); |
| } |
| |
| return rc; |
| } |
| |
| /* End of pcre2_dfa_match.c */ |