/src/php-src/ext/pcre/pcre2lib/pcre2_substring.c
Line | Count | Source (jump to first uncovered line) |
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-2024 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 | | #ifdef HAVE_CONFIG_H |
43 | | #include "config.h" |
44 | | #endif |
45 | | |
46 | | #include "pcre2_internal.h" |
47 | | |
48 | | |
49 | | |
50 | | /************************************************* |
51 | | * Copy named captured string to given buffer * |
52 | | *************************************************/ |
53 | | |
54 | | /* This function copies a single captured substring into a given buffer, |
55 | | identifying it by name. If the regex permits duplicate names, the first |
56 | | substring that is set is chosen. |
57 | | |
58 | | Arguments: |
59 | | match_data points to the match data |
60 | | stringname the name of the required substring |
61 | | buffer where to put the substring |
62 | | sizeptr the size of the buffer, updated to the size of the substring |
63 | | |
64 | | Returns: if successful: zero |
65 | | if not successful, a negative error code: |
66 | | (1) an error from nametable_scan() |
67 | | (2) an error from copy_bynumber() |
68 | | (3) PCRE2_ERROR_UNAVAILABLE: no group is in ovector |
69 | | (4) PCRE2_ERROR_UNSET: all named groups in ovector are unset |
70 | | */ |
71 | | |
72 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
73 | | pcre2_substring_copy_byname(pcre2_match_data *match_data, PCRE2_SPTR stringname, |
74 | | PCRE2_UCHAR *buffer, PCRE2_SIZE *sizeptr) |
75 | 0 | { |
76 | 0 | PCRE2_SPTR first, last, entry; |
77 | 0 | int failrc, entrysize; |
78 | 0 | if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER) |
79 | 0 | return PCRE2_ERROR_DFA_UFUNC; |
80 | 0 | entrysize = pcre2_substring_nametable_scan(match_data->code, stringname, |
81 | 0 | &first, &last); |
82 | 0 | if (entrysize < 0) return entrysize; |
83 | 0 | failrc = PCRE2_ERROR_UNAVAILABLE; |
84 | 0 | for (entry = first; entry <= last; entry += entrysize) |
85 | 0 | { |
86 | 0 | uint32_t n = GET2(entry, 0); |
87 | 0 | if (n < match_data->oveccount) |
88 | 0 | { |
89 | 0 | if (match_data->ovector[n*2] != PCRE2_UNSET) |
90 | 0 | return pcre2_substring_copy_bynumber(match_data, n, buffer, sizeptr); |
91 | 0 | failrc = PCRE2_ERROR_UNSET; |
92 | 0 | } |
93 | 0 | } |
94 | 0 | return failrc; |
95 | 0 | } |
96 | | |
97 | | |
98 | | |
99 | | /************************************************* |
100 | | * Copy numbered captured string to given buffer * |
101 | | *************************************************/ |
102 | | |
103 | | /* This function copies a single captured substring into a given buffer, |
104 | | identifying it by number. |
105 | | |
106 | | Arguments: |
107 | | match_data points to the match data |
108 | | stringnumber the number of the required substring |
109 | | buffer where to put the substring |
110 | | sizeptr the size of the buffer, updated to the size of the substring |
111 | | |
112 | | Returns: if successful: 0 |
113 | | if not successful, a negative error code: |
114 | | PCRE2_ERROR_NOMEMORY: buffer too small |
115 | | PCRE2_ERROR_NOSUBSTRING: no such substring |
116 | | PCRE2_ERROR_UNAVAILABLE: ovector too small |
117 | | PCRE2_ERROR_UNSET: substring is not set |
118 | | */ |
119 | | |
120 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
121 | | pcre2_substring_copy_bynumber(pcre2_match_data *match_data, |
122 | | uint32_t stringnumber, PCRE2_UCHAR *buffer, PCRE2_SIZE *sizeptr) |
123 | 0 | { |
124 | 0 | int rc; |
125 | 0 | PCRE2_SIZE size; |
126 | 0 | rc = pcre2_substring_length_bynumber(match_data, stringnumber, &size); |
127 | 0 | if (rc < 0) return rc; |
128 | 0 | if (size + 1 > *sizeptr) return PCRE2_ERROR_NOMEMORY; |
129 | 0 | memcpy(buffer, match_data->subject + match_data->ovector[stringnumber*2], |
130 | 0 | CU2BYTES(size)); |
131 | 0 | buffer[size] = 0; |
132 | 0 | *sizeptr = size; |
133 | 0 | return 0; |
134 | 0 | } |
135 | | |
136 | | |
137 | | |
138 | | /************************************************* |
139 | | * Extract named captured string * |
140 | | *************************************************/ |
141 | | |
142 | | /* This function copies a single captured substring, identified by name, into |
143 | | new memory. If the regex permits duplicate names, the first substring that is |
144 | | set is chosen. |
145 | | |
146 | | Arguments: |
147 | | match_data pointer to match_data |
148 | | stringname the name of the required substring |
149 | | stringptr where to put the pointer to the new memory |
150 | | sizeptr where to put the length of the substring |
151 | | |
152 | | Returns: if successful: zero |
153 | | if not successful, a negative value: |
154 | | (1) an error from nametable_scan() |
155 | | (2) an error from get_bynumber() |
156 | | (3) PCRE2_ERROR_UNAVAILABLE: no group is in ovector |
157 | | (4) PCRE2_ERROR_UNSET: all named groups in ovector are unset |
158 | | */ |
159 | | |
160 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
161 | | pcre2_substring_get_byname(pcre2_match_data *match_data, |
162 | | PCRE2_SPTR stringname, PCRE2_UCHAR **stringptr, PCRE2_SIZE *sizeptr) |
163 | 0 | { |
164 | 0 | PCRE2_SPTR first, last, entry; |
165 | 0 | int failrc, entrysize; |
166 | 0 | if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER) |
167 | 0 | return PCRE2_ERROR_DFA_UFUNC; |
168 | 0 | entrysize = pcre2_substring_nametable_scan(match_data->code, stringname, |
169 | 0 | &first, &last); |
170 | 0 | if (entrysize < 0) return entrysize; |
171 | 0 | failrc = PCRE2_ERROR_UNAVAILABLE; |
172 | 0 | for (entry = first; entry <= last; entry += entrysize) |
173 | 0 | { |
174 | 0 | uint32_t n = GET2(entry, 0); |
175 | 0 | if (n < match_data->oveccount) |
176 | 0 | { |
177 | 0 | if (match_data->ovector[n*2] != PCRE2_UNSET) |
178 | 0 | return pcre2_substring_get_bynumber(match_data, n, stringptr, sizeptr); |
179 | 0 | failrc = PCRE2_ERROR_UNSET; |
180 | 0 | } |
181 | 0 | } |
182 | 0 | return failrc; |
183 | 0 | } |
184 | | |
185 | | |
186 | | |
187 | | /************************************************* |
188 | | * Extract captured string to new memory * |
189 | | *************************************************/ |
190 | | |
191 | | /* This function copies a single captured substring into a piece of new |
192 | | memory. |
193 | | |
194 | | Arguments: |
195 | | match_data points to match data |
196 | | stringnumber the number of the required substring |
197 | | stringptr where to put a pointer to the new memory |
198 | | sizeptr where to put the size of the substring |
199 | | |
200 | | Returns: if successful: 0 |
201 | | if not successful, a negative error code: |
202 | | PCRE2_ERROR_NOMEMORY: failed to get memory |
203 | | PCRE2_ERROR_NOSUBSTRING: no such substring |
204 | | PCRE2_ERROR_UNAVAILABLE: ovector too small |
205 | | PCRE2_ERROR_UNSET: substring is not set |
206 | | */ |
207 | | |
208 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
209 | | pcre2_substring_get_bynumber(pcre2_match_data *match_data, |
210 | | uint32_t stringnumber, PCRE2_UCHAR **stringptr, PCRE2_SIZE *sizeptr) |
211 | 0 | { |
212 | 0 | int rc; |
213 | 0 | PCRE2_SIZE size; |
214 | 0 | PCRE2_UCHAR *yield; |
215 | 0 | rc = pcre2_substring_length_bynumber(match_data, stringnumber, &size); |
216 | 0 | if (rc < 0) return rc; |
217 | 0 | yield = PRIV(memctl_malloc)(sizeof(pcre2_memctl) + |
218 | 0 | (size + 1)*PCRE2_CODE_UNIT_WIDTH, (pcre2_memctl *)match_data); |
219 | 0 | if (yield == NULL) return PCRE2_ERROR_NOMEMORY; |
220 | 0 | yield = (PCRE2_UCHAR *)(((char *)yield) + sizeof(pcre2_memctl)); |
221 | 0 | memcpy(yield, match_data->subject + match_data->ovector[stringnumber*2], |
222 | 0 | CU2BYTES(size)); |
223 | 0 | yield[size] = 0; |
224 | 0 | *stringptr = yield; |
225 | 0 | *sizeptr = size; |
226 | 0 | return 0; |
227 | 0 | } |
228 | | |
229 | | |
230 | | |
231 | | /************************************************* |
232 | | * Free memory obtained by get_substring * |
233 | | *************************************************/ |
234 | | |
235 | | /* |
236 | | Argument: the result of a previous pcre2_substring_get_byxxx() |
237 | | Returns: nothing |
238 | | */ |
239 | | |
240 | | PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION |
241 | | pcre2_substring_free(PCRE2_UCHAR *string) |
242 | 0 | { |
243 | 0 | if (string != NULL) |
244 | 0 | { |
245 | 0 | pcre2_memctl *memctl = (pcre2_memctl *)((char *)string - sizeof(pcre2_memctl)); |
246 | 0 | memctl->free(memctl, memctl->memory_data); |
247 | 0 | } |
248 | 0 | } |
249 | | |
250 | | |
251 | | |
252 | | /************************************************* |
253 | | * Get length of a named substring * |
254 | | *************************************************/ |
255 | | |
256 | | /* This function returns the length of a named captured substring. If the regex |
257 | | permits duplicate names, the first substring that is set is chosen. |
258 | | |
259 | | Arguments: |
260 | | match_data pointer to match data |
261 | | stringname the name of the required substring |
262 | | sizeptr where to put the length |
263 | | |
264 | | Returns: 0 if successful, else a negative error number |
265 | | */ |
266 | | |
267 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
268 | | pcre2_substring_length_byname(pcre2_match_data *match_data, |
269 | | PCRE2_SPTR stringname, PCRE2_SIZE *sizeptr) |
270 | 0 | { |
271 | 0 | PCRE2_SPTR first, last, entry; |
272 | 0 | int failrc, entrysize; |
273 | 0 | if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER) |
274 | 0 | return PCRE2_ERROR_DFA_UFUNC; |
275 | 0 | entrysize = pcre2_substring_nametable_scan(match_data->code, stringname, |
276 | 0 | &first, &last); |
277 | 0 | if (entrysize < 0) return entrysize; |
278 | 0 | failrc = PCRE2_ERROR_UNAVAILABLE; |
279 | 0 | for (entry = first; entry <= last; entry += entrysize) |
280 | 0 | { |
281 | 0 | uint32_t n = GET2(entry, 0); |
282 | 0 | if (n < match_data->oveccount) |
283 | 0 | { |
284 | 0 | if (match_data->ovector[n*2] != PCRE2_UNSET) |
285 | 0 | return pcre2_substring_length_bynumber(match_data, n, sizeptr); |
286 | 0 | failrc = PCRE2_ERROR_UNSET; |
287 | 0 | } |
288 | 0 | } |
289 | 0 | return failrc; |
290 | 0 | } |
291 | | |
292 | | |
293 | | |
294 | | /************************************************* |
295 | | * Get length of a numbered substring * |
296 | | *************************************************/ |
297 | | |
298 | | /* This function returns the length of a captured substring. If the start is |
299 | | beyond the end (which can happen when \K is used in an assertion), it sets the |
300 | | length to zero. |
301 | | |
302 | | Arguments: |
303 | | match_data pointer to match data |
304 | | stringnumber the number of the required substring |
305 | | sizeptr where to put the length, if not NULL |
306 | | |
307 | | Returns: if successful: 0 |
308 | | if not successful, a negative error code: |
309 | | PCRE2_ERROR_NOSUBSTRING: no such substring |
310 | | PCRE2_ERROR_UNAVAILABLE: ovector is too small |
311 | | PCRE2_ERROR_UNSET: substring is not set |
312 | | PCRE2_ERROR_INVALIDOFFSET: internal error, should not occur |
313 | | */ |
314 | | |
315 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
316 | | pcre2_substring_length_bynumber(pcre2_match_data *match_data, |
317 | | uint32_t stringnumber, PCRE2_SIZE *sizeptr) |
318 | 0 | { |
319 | 0 | PCRE2_SIZE left, right; |
320 | 0 | int count = match_data->rc; |
321 | 0 | if (count == PCRE2_ERROR_PARTIAL) |
322 | 0 | { |
323 | 0 | if (stringnumber > 0) return PCRE2_ERROR_PARTIAL; |
324 | 0 | count = 0; |
325 | 0 | } |
326 | 0 | else if (count < 0) return count; /* Match failed */ |
327 | | |
328 | 0 | if (match_data->matchedby != PCRE2_MATCHEDBY_DFA_INTERPRETER) |
329 | 0 | { |
330 | 0 | if (stringnumber > match_data->code->top_bracket) |
331 | 0 | return PCRE2_ERROR_NOSUBSTRING; |
332 | 0 | if (stringnumber >= match_data->oveccount) |
333 | 0 | return PCRE2_ERROR_UNAVAILABLE; |
334 | 0 | if (match_data->ovector[stringnumber*2] == PCRE2_UNSET) |
335 | 0 | return PCRE2_ERROR_UNSET; |
336 | 0 | } |
337 | 0 | else /* Matched using pcre2_dfa_match() */ |
338 | 0 | { |
339 | 0 | if (stringnumber >= match_data->oveccount) return PCRE2_ERROR_UNAVAILABLE; |
340 | 0 | if (count != 0 && stringnumber >= (uint32_t)count) return PCRE2_ERROR_UNSET; |
341 | 0 | } |
342 | | |
343 | 0 | left = match_data->ovector[stringnumber*2]; |
344 | 0 | right = match_data->ovector[stringnumber*2+1]; |
345 | 0 | if (left > match_data->subject_length || right > match_data->subject_length) |
346 | 0 | return PCRE2_ERROR_INVALIDOFFSET; |
347 | 0 | if (sizeptr != NULL) *sizeptr = (left > right)? 0 : right - left; |
348 | 0 | return 0; |
349 | 0 | } |
350 | | |
351 | | |
352 | | |
353 | | /************************************************* |
354 | | * Extract all captured strings to new memory * |
355 | | *************************************************/ |
356 | | |
357 | | /* This function gets one chunk of memory and builds a list of pointers and all |
358 | | the captured substrings in it. A NULL pointer is put on the end of the list. |
359 | | The substrings are zero-terminated, but also, if the final argument is |
360 | | non-NULL, a list of lengths is also returned. This allows binary data to be |
361 | | handled. |
362 | | |
363 | | Arguments: |
364 | | match_data points to the match data |
365 | | listptr set to point to the list of pointers |
366 | | lengthsptr set to point to the list of lengths (may be NULL) |
367 | | |
368 | | Returns: if successful: 0 |
369 | | if not successful, a negative error code: |
370 | | PCRE2_ERROR_NOMEMORY: failed to get memory, |
371 | | or a match failure code |
372 | | */ |
373 | | |
374 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
375 | | pcre2_substring_list_get(pcre2_match_data *match_data, PCRE2_UCHAR ***listptr, |
376 | | PCRE2_SIZE **lengthsptr) |
377 | 0 | { |
378 | 0 | int i, count, count2; |
379 | 0 | PCRE2_SIZE size; |
380 | 0 | PCRE2_SIZE *lensp; |
381 | 0 | pcre2_memctl *memp; |
382 | 0 | PCRE2_UCHAR **listp; |
383 | 0 | PCRE2_UCHAR *sp; |
384 | 0 | PCRE2_SIZE *ovector; |
385 | |
|
386 | 0 | if ((count = match_data->rc) < 0) return count; /* Match failed */ |
387 | 0 | if (count == 0) count = match_data->oveccount; /* Ovector too small */ |
388 | |
|
389 | 0 | count2 = 2*count; |
390 | 0 | ovector = match_data->ovector; |
391 | 0 | size = sizeof(pcre2_memctl) + sizeof(PCRE2_UCHAR *); /* For final NULL */ |
392 | 0 | if (lengthsptr != NULL) size += sizeof(PCRE2_SIZE) * count; /* For lengths */ |
393 | |
|
394 | 0 | for (i = 0; i < count2; i += 2) |
395 | 0 | { |
396 | 0 | size += sizeof(PCRE2_UCHAR *) + CU2BYTES(1); |
397 | 0 | if (ovector[i+1] > ovector[i]) size += CU2BYTES(ovector[i+1] - ovector[i]); |
398 | 0 | } |
399 | |
|
400 | 0 | memp = PRIV(memctl_malloc)(size, (pcre2_memctl *)match_data); |
401 | 0 | if (memp == NULL) return PCRE2_ERROR_NOMEMORY; |
402 | | |
403 | 0 | *listptr = listp = (PCRE2_UCHAR **)((char *)memp + sizeof(pcre2_memctl)); |
404 | 0 | lensp = (PCRE2_SIZE *)((char *)listp + sizeof(PCRE2_UCHAR *) * (count + 1)); |
405 | |
|
406 | 0 | if (lengthsptr == NULL) |
407 | 0 | { |
408 | 0 | sp = (PCRE2_UCHAR *)lensp; |
409 | 0 | lensp = NULL; |
410 | 0 | } |
411 | 0 | else |
412 | 0 | { |
413 | 0 | *lengthsptr = lensp; |
414 | 0 | sp = (PCRE2_UCHAR *)((char *)lensp + sizeof(PCRE2_SIZE) * count); |
415 | 0 | } |
416 | |
|
417 | 0 | for (i = 0; i < count2; i += 2) |
418 | 0 | { |
419 | 0 | size = (ovector[i+1] > ovector[i])? (ovector[i+1] - ovector[i]) : 0; |
420 | | |
421 | | /* Size == 0 includes the case when the capture is unset. Avoid adding |
422 | | PCRE2_UNSET to match_data->subject because it overflows, even though with |
423 | | zero size calling memcpy() is harmless. */ |
424 | |
|
425 | 0 | if (size != 0) memcpy(sp, match_data->subject + ovector[i], CU2BYTES(size)); |
426 | 0 | *listp++ = sp; |
427 | 0 | if (lensp != NULL) *lensp++ = size; |
428 | 0 | sp += size; |
429 | 0 | *sp++ = 0; |
430 | 0 | } |
431 | |
|
432 | 0 | *listp = NULL; |
433 | 0 | return 0; |
434 | 0 | } |
435 | | |
436 | | |
437 | | |
438 | | /************************************************* |
439 | | * Free memory obtained by substring_list_get * |
440 | | *************************************************/ |
441 | | |
442 | | /* |
443 | | Argument: the result of a previous pcre2_substring_list_get() |
444 | | Returns: nothing |
445 | | */ |
446 | | |
447 | | PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION |
448 | | pcre2_substring_list_free(PCRE2_UCHAR **list) |
449 | 0 | { |
450 | 0 | if (list != NULL) |
451 | 0 | { |
452 | 0 | pcre2_memctl *memctl = (pcre2_memctl *)((char *)list - sizeof(pcre2_memctl)); |
453 | 0 | memctl->free(memctl, memctl->memory_data); |
454 | 0 | } |
455 | 0 | } |
456 | | |
457 | | |
458 | | |
459 | | /************************************************* |
460 | | * Find (multiple) entries for named string * |
461 | | *************************************************/ |
462 | | |
463 | | /* This function scans the nametable for a given name, using binary chop. It |
464 | | returns either two pointers to the entries in the table, or, if no pointers are |
465 | | given, the number of a unique group with the given name. If duplicate names are |
466 | | permitted, and the name is not unique, an error is generated. |
467 | | |
468 | | Arguments: |
469 | | code the compiled regex |
470 | | stringname the name whose entries required |
471 | | firstptr where to put the pointer to the first entry |
472 | | lastptr where to put the pointer to the last entry |
473 | | |
474 | | Returns: PCRE2_ERROR_NOSUBSTRING if the name is not found |
475 | | otherwise, if firstptr and lastptr are NULL: |
476 | | a group number for a unique substring |
477 | | else PCRE2_ERROR_NOUNIQUESUBSTRING |
478 | | otherwise: |
479 | | the length of each entry, having set firstptr and lastptr |
480 | | */ |
481 | | |
482 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
483 | | pcre2_substring_nametable_scan(const pcre2_code *code, PCRE2_SPTR stringname, |
484 | | PCRE2_SPTR *firstptr, PCRE2_SPTR *lastptr) |
485 | 0 | { |
486 | 0 | uint16_t bot = 0; |
487 | 0 | uint16_t top = code->name_count; |
488 | 0 | uint16_t entrysize = code->name_entry_size; |
489 | 0 | PCRE2_SPTR nametable = (PCRE2_SPTR)((const char *)code + sizeof(pcre2_real_code)); |
490 | |
|
491 | 0 | while (top > bot) |
492 | 0 | { |
493 | 0 | uint16_t mid = (top + bot) / 2; |
494 | 0 | PCRE2_SPTR entry = nametable + entrysize*mid; |
495 | 0 | int c = PRIV(strcmp)(stringname, entry + IMM2_SIZE); |
496 | 0 | if (c == 0) |
497 | 0 | { |
498 | 0 | PCRE2_SPTR first; |
499 | 0 | PCRE2_SPTR last; |
500 | 0 | PCRE2_SPTR lastentry; |
501 | 0 | lastentry = nametable + entrysize * (code->name_count - 1); |
502 | 0 | first = last = entry; |
503 | 0 | while (first > nametable) |
504 | 0 | { |
505 | 0 | if (PRIV(strcmp)(stringname, (first - entrysize + IMM2_SIZE)) != 0) break; |
506 | 0 | first -= entrysize; |
507 | 0 | } |
508 | 0 | while (last < lastentry) |
509 | 0 | { |
510 | 0 | if (PRIV(strcmp)(stringname, (last + entrysize + IMM2_SIZE)) != 0) break; |
511 | 0 | last += entrysize; |
512 | 0 | } |
513 | 0 | if (firstptr == NULL) return (first == last)? |
514 | 0 | (int)GET2(entry, 0) : PCRE2_ERROR_NOUNIQUESUBSTRING; |
515 | 0 | *firstptr = first; |
516 | 0 | *lastptr = last; |
517 | 0 | return entrysize; |
518 | 0 | } |
519 | 0 | if (c > 0) bot = mid + 1; else top = mid; |
520 | 0 | } |
521 | | |
522 | 0 | return PCRE2_ERROR_NOSUBSTRING; |
523 | 0 | } |
524 | | |
525 | | |
526 | | /************************************************* |
527 | | * Find number for named string * |
528 | | *************************************************/ |
529 | | |
530 | | /* This function is a convenience wrapper for pcre2_substring_nametable_scan() |
531 | | when it is known that names are unique. If there are duplicate names, it is not |
532 | | defined which number is returned. |
533 | | |
534 | | Arguments: |
535 | | code the compiled regex |
536 | | stringname the name whose number is required |
537 | | |
538 | | Returns: the number of the named parenthesis, or a negative number |
539 | | PCRE2_ERROR_NOSUBSTRING if not found |
540 | | PCRE2_ERROR_NOUNIQUESUBSTRING if not unique |
541 | | */ |
542 | | |
543 | | PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION |
544 | | pcre2_substring_number_from_name(const pcre2_code *code, |
545 | | PCRE2_SPTR stringname) |
546 | 0 | { |
547 | 0 | return pcre2_substring_nametable_scan(code, stringname, NULL, NULL); |
548 | 0 | } |
549 | | |
550 | | /* End of pcre2_substring.c */ |