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-2023 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 or OP_VREVERSE for a lookbehind. The
45 function is called from pcre2_compile.c and also from pcre2_study.c when
46 finding the minimum 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
PRIV(find_bracket)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 || c == OP_VREVERSE)
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
