1 /************************************************* 2 * Perl-Compatible Regular Expressions * 3 *************************************************/ 4 5 /* PCRE is a library of functions to support regular expressions whose syntax 6 and semantics are as close as possible to those of the Perl 5 language. 7 8 Written by Philip Hazel 9 Original API code Copyright (c) 1997-2012 University of Cambridge 10 New API code Copyright (c) 2016-2018 University of Cambridge 11 12 ----------------------------------------------------------------------------- 13 Redistribution and use in source and binary forms, with or without 14 modification, are permitted provided that the following conditions are met: 15 16 * Redistributions of source code must retain the above copyright notice, 17 this list of conditions and the following disclaimer. 18 19 * Redistributions in binary form must reproduce the above copyright 20 notice, this list of conditions and the following disclaimer in the 21 documentation and/or other materials provided with the distribution. 22 23 * Neither the name of the University of Cambridge nor the names of its 24 contributors may be used to endorse or promote products derived from 25 this software without specific prior written permission. 26 27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 POSSIBILITY OF SUCH DAMAGE. 38 ----------------------------------------------------------------------------- 39 */ 40 41 42 /* This module contains a single function that scans through a compiled pattern 43 until it finds a capturing bracket with the given number, or, if the number is 44 negative, an instance of OP_REVERSE for a lookbehind. The function is called 45 from pcre2_compile.c and also from pcre2_study.c when finding the minimum 46 matching length. */ 47 48 49 #ifdef HAVE_CONFIG_H 50 #include "config.h" 51 #endif 52 53 #include "pcre2_internal.h" 54 55 56 /************************************************* 57 * Scan compiled regex for specific bracket * 58 *************************************************/ 59 60 /* 61 Arguments: 62 code points to start of expression 63 utf TRUE in UTF mode 64 number the required bracket number or negative to find a lookbehind 65 66 Returns: pointer to the opcode for the bracket, or NULL if not found 67 */ 68 69 PCRE2_SPTR 70 PRIV(find_bracket)(PCRE2_SPTR code, BOOL utf, int number) 71 { 72 for (;;) 73 { 74 PCRE2_UCHAR c = *code; 75 76 if (c == OP_END) return NULL; 77 78 /* XCLASS is used for classes that cannot be represented just by a bit map. 79 This includes negated single high-valued characters. CALLOUT_STR is used for 80 callouts with string arguments. In both cases the length in the table is 81 zero; the actual length is stored in the compiled code. */ 82 83 if (c == OP_XCLASS) code += GET(code, 1); 84 else if (c == OP_CALLOUT_STR) code += GET(code, 1 + 2*LINK_SIZE); 85 86 /* Handle lookbehind */ 87 88 else if (c == OP_REVERSE) 89 { 90 if (number < 0) return (PCRE2_UCHAR *)code; 91 code += PRIV(OP_lengths)[c]; 92 } 93 94 /* Handle capturing bracket */ 95 96 else if (c == OP_CBRA || c == OP_SCBRA || 97 c == OP_CBRAPOS || c == OP_SCBRAPOS) 98 { 99 int n = (int)GET2(code, 1+LINK_SIZE); 100 if (n == number) return (PCRE2_UCHAR *)code; 101 code += PRIV(OP_lengths)[c]; 102 } 103 104 /* Otherwise, we can get the item's length from the table, except that for 105 repeated character types, we have to test for \p and \P, which have an extra 106 two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we 107 must add in its length. */ 108 109 else 110 { 111 switch(c) 112 { 113 case OP_TYPESTAR: 114 case OP_TYPEMINSTAR: 115 case OP_TYPEPLUS: 116 case OP_TYPEMINPLUS: 117 case OP_TYPEQUERY: 118 case OP_TYPEMINQUERY: 119 case OP_TYPEPOSSTAR: 120 case OP_TYPEPOSPLUS: 121 case OP_TYPEPOSQUERY: 122 if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2; 123 break; 124 125 case OP_TYPEUPTO: 126 case OP_TYPEMINUPTO: 127 case OP_TYPEEXACT: 128 case OP_TYPEPOSUPTO: 129 if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP) 130 code += 2; 131 break; 132 133 case OP_MARK: 134 case OP_COMMIT_ARG: 135 case OP_PRUNE_ARG: 136 case OP_SKIP_ARG: 137 case OP_THEN_ARG: 138 code += code[1]; 139 break; 140 } 141 142 /* Add in the fixed length from the table */ 143 144 code += PRIV(OP_lengths)[c]; 145 146 /* In UTF-8 and UTF-16 modes, opcodes that are followed by a character may be 147 followed by a multi-byte character. The length in the table is a minimum, so 148 we have to arrange to skip the extra bytes. */ 149 150 #ifdef MAYBE_UTF_MULTI 151 if (utf) switch(c) 152 { 153 case OP_CHAR: 154 case OP_CHARI: 155 case OP_NOT: 156 case OP_NOTI: 157 case OP_EXACT: 158 case OP_EXACTI: 159 case OP_NOTEXACT: 160 case OP_NOTEXACTI: 161 case OP_UPTO: 162 case OP_UPTOI: 163 case OP_NOTUPTO: 164 case OP_NOTUPTOI: 165 case OP_MINUPTO: 166 case OP_MINUPTOI: 167 case OP_NOTMINUPTO: 168 case OP_NOTMINUPTOI: 169 case OP_POSUPTO: 170 case OP_POSUPTOI: 171 case OP_NOTPOSUPTO: 172 case OP_NOTPOSUPTOI: 173 case OP_STAR: 174 case OP_STARI: 175 case OP_NOTSTAR: 176 case OP_NOTSTARI: 177 case OP_MINSTAR: 178 case OP_MINSTARI: 179 case OP_NOTMINSTAR: 180 case OP_NOTMINSTARI: 181 case OP_POSSTAR: 182 case OP_POSSTARI: 183 case OP_NOTPOSSTAR: 184 case OP_NOTPOSSTARI: 185 case OP_PLUS: 186 case OP_PLUSI: 187 case OP_NOTPLUS: 188 case OP_NOTPLUSI: 189 case OP_MINPLUS: 190 case OP_MINPLUSI: 191 case OP_NOTMINPLUS: 192 case OP_NOTMINPLUSI: 193 case OP_POSPLUS: 194 case OP_POSPLUSI: 195 case OP_NOTPOSPLUS: 196 case OP_NOTPOSPLUSI: 197 case OP_QUERY: 198 case OP_QUERYI: 199 case OP_NOTQUERY: 200 case OP_NOTQUERYI: 201 case OP_MINQUERY: 202 case OP_MINQUERYI: 203 case OP_NOTMINQUERY: 204 case OP_NOTMINQUERYI: 205 case OP_POSQUERY: 206 case OP_POSQUERYI: 207 case OP_NOTPOSQUERY: 208 case OP_NOTPOSQUERYI: 209 if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]); 210 break; 211 } 212 #else 213 (void)(utf); /* Keep compiler happy by referencing function argument */ 214 #endif /* MAYBE_UTF_MULTI */ 215 } 216 } 217 } 218 219 /* End of pcre2_find_bracket.c */ 220