/[pcre]/code/trunk/pcre_get.c
ViewVC logotype

Contents of /code/trunk/pcre_get.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1620 - (show annotations)
Tue Dec 8 11:06:40 2015 UTC (2 months ago) by ph10
File MIME type: text/plain
File size: 22908 byte(s)
Fix get_substring_list() bug when \K is used in an assertion.
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 Copyright (c) 1997-2012 University of Cambridge
10
11 -----------------------------------------------------------------------------
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions are met:
14
15 * Redistributions of source code must retain the above copyright notice,
16 this list of conditions and the following disclaimer.
17
18 * Redistributions in binary form must reproduce the above copyright
19 notice, this list of conditions and the following disclaimer in the
20 documentation and/or other materials provided with the distribution.
21
22 * Neither the name of the University of Cambridge nor the names of its
23 contributors may be used to endorse or promote products derived from
24 this software without specific prior written permission.
25
26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 POSSIBILITY OF SUCH DAMAGE.
37 -----------------------------------------------------------------------------
38 */
39
40
41 /* This module contains some convenience functions for extracting substrings
42 from the subject string after a regex match has succeeded. The original idea
43 for these functions came from Scott Wimer. */
44
45
46 #ifdef HAVE_CONFIG_H
47 #include "config.h"
48 #endif
49
50 #include "pcre_internal.h"
51
52
53 /*************************************************
54 * Find number for named string *
55 *************************************************/
56
57 /* This function is used by the get_first_set() function below, as well
58 as being generally available. It assumes that names are unique.
59
60 Arguments:
61 code the compiled regex
62 stringname the name whose number is required
63
64 Returns: the number of the named parentheses, or a negative number
65 (PCRE_ERROR_NOSUBSTRING) if not found
66 */
67
68 #if defined COMPILE_PCRE8
69 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
70 pcre_get_stringnumber(const pcre *code, const char *stringname)
71 #elif defined COMPILE_PCRE16
72 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
73 pcre16_get_stringnumber(const pcre16 *code, PCRE_SPTR16 stringname)
74 #elif defined COMPILE_PCRE32
75 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
76 pcre32_get_stringnumber(const pcre32 *code, PCRE_SPTR32 stringname)
77 #endif
78 {
79 int rc;
80 int entrysize;
81 int top, bot;
82 pcre_uchar *nametable;
83
84 #ifdef COMPILE_PCRE8
85 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
86 return rc;
87 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
88
89 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
90 return rc;
91 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
92 return rc;
93 #endif
94 #ifdef COMPILE_PCRE16
95 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
96 return rc;
97 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
98
99 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
100 return rc;
101 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
102 return rc;
103 #endif
104 #ifdef COMPILE_PCRE32
105 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
106 return rc;
107 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
108
109 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
110 return rc;
111 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
112 return rc;
113 #endif
114
115 bot = 0;
116 while (top > bot)
117 {
118 int mid = (top + bot) / 2;
119 pcre_uchar *entry = nametable + entrysize*mid;
120 int c = STRCMP_UC_UC((pcre_uchar *)stringname,
121 (pcre_uchar *)(entry + IMM2_SIZE));
122 if (c == 0) return GET2(entry, 0);
123 if (c > 0) bot = mid + 1; else top = mid;
124 }
125
126 return PCRE_ERROR_NOSUBSTRING;
127 }
128
129
130
131 /*************************************************
132 * Find (multiple) entries for named string *
133 *************************************************/
134
135 /* This is used by the get_first_set() function below, as well as being
136 generally available. It is used when duplicated names are permitted.
137
138 Arguments:
139 code the compiled regex
140 stringname the name whose entries required
141 firstptr where to put the pointer to the first entry
142 lastptr where to put the pointer to the last entry
143
144 Returns: the length of each entry, or a negative number
145 (PCRE_ERROR_NOSUBSTRING) if not found
146 */
147
148 #if defined COMPILE_PCRE8
149 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
150 pcre_get_stringtable_entries(const pcre *code, const char *stringname,
151 char **firstptr, char **lastptr)
152 #elif defined COMPILE_PCRE16
153 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
154 pcre16_get_stringtable_entries(const pcre16 *code, PCRE_SPTR16 stringname,
155 PCRE_UCHAR16 **firstptr, PCRE_UCHAR16 **lastptr)
156 #elif defined COMPILE_PCRE32
157 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
158 pcre32_get_stringtable_entries(const pcre32 *code, PCRE_SPTR32 stringname,
159 PCRE_UCHAR32 **firstptr, PCRE_UCHAR32 **lastptr)
160 #endif
161 {
162 int rc;
163 int entrysize;
164 int top, bot;
165 pcre_uchar *nametable, *lastentry;
166
167 #ifdef COMPILE_PCRE8
168 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
169 return rc;
170 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
171
172 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
173 return rc;
174 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
175 return rc;
176 #endif
177 #ifdef COMPILE_PCRE16
178 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
179 return rc;
180 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
181
182 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
183 return rc;
184 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
185 return rc;
186 #endif
187 #ifdef COMPILE_PCRE32
188 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
189 return rc;
190 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
191
192 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
193 return rc;
194 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
195 return rc;
196 #endif
197
198 lastentry = nametable + entrysize * (top - 1);
199 bot = 0;
200 while (top > bot)
201 {
202 int mid = (top + bot) / 2;
203 pcre_uchar *entry = nametable + entrysize*mid;
204 int c = STRCMP_UC_UC((pcre_uchar *)stringname,
205 (pcre_uchar *)(entry + IMM2_SIZE));
206 if (c == 0)
207 {
208 pcre_uchar *first = entry;
209 pcre_uchar *last = entry;
210 while (first > nametable)
211 {
212 if (STRCMP_UC_UC((pcre_uchar *)stringname,
213 (pcre_uchar *)(first - entrysize + IMM2_SIZE)) != 0) break;
214 first -= entrysize;
215 }
216 while (last < lastentry)
217 {
218 if (STRCMP_UC_UC((pcre_uchar *)stringname,
219 (pcre_uchar *)(last + entrysize + IMM2_SIZE)) != 0) break;
220 last += entrysize;
221 }
222 #if defined COMPILE_PCRE8
223 *firstptr = (char *)first;
224 *lastptr = (char *)last;
225 #elif defined COMPILE_PCRE16
226 *firstptr = (PCRE_UCHAR16 *)first;
227 *lastptr = (PCRE_UCHAR16 *)last;
228 #elif defined COMPILE_PCRE32
229 *firstptr = (PCRE_UCHAR32 *)first;
230 *lastptr = (PCRE_UCHAR32 *)last;
231 #endif
232 return entrysize;
233 }
234 if (c > 0) bot = mid + 1; else top = mid;
235 }
236
237 return PCRE_ERROR_NOSUBSTRING;
238 }
239
240
241
242 /*************************************************
243 * Find first set of multiple named strings *
244 *************************************************/
245
246 /* This function allows for duplicate names in the table of named substrings.
247 It returns the number of the first one that was set in a pattern match.
248
249 Arguments:
250 code the compiled regex
251 stringname the name of the capturing substring
252 ovector the vector of matched substrings
253 stringcount number of captured substrings
254
255 Returns: the number of the first that is set,
256 or the number of the last one if none are set,
257 or a negative number on error
258 */
259
260 #if defined COMPILE_PCRE8
261 static int
262 get_first_set(const pcre *code, const char *stringname, int *ovector,
263 int stringcount)
264 #elif defined COMPILE_PCRE16
265 static int
266 get_first_set(const pcre16 *code, PCRE_SPTR16 stringname, int *ovector,
267 int stringcount)
268 #elif defined COMPILE_PCRE32
269 static int
270 get_first_set(const pcre32 *code, PCRE_SPTR32 stringname, int *ovector,
271 int stringcount)
272 #endif
273 {
274 const REAL_PCRE *re = (const REAL_PCRE *)code;
275 int entrysize;
276 pcre_uchar *entry;
277 #if defined COMPILE_PCRE8
278 char *first, *last;
279 #elif defined COMPILE_PCRE16
280 PCRE_UCHAR16 *first, *last;
281 #elif defined COMPILE_PCRE32
282 PCRE_UCHAR32 *first, *last;
283 #endif
284
285 #if defined COMPILE_PCRE8
286 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
287 return pcre_get_stringnumber(code, stringname);
288 entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last);
289 #elif defined COMPILE_PCRE16
290 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
291 return pcre16_get_stringnumber(code, stringname);
292 entrysize = pcre16_get_stringtable_entries(code, stringname, &first, &last);
293 #elif defined COMPILE_PCRE32
294 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
295 return pcre32_get_stringnumber(code, stringname);
296 entrysize = pcre32_get_stringtable_entries(code, stringname, &first, &last);
297 #endif
298 if (entrysize <= 0) return entrysize;
299 for (entry = (pcre_uchar *)first; entry <= (pcre_uchar *)last; entry += entrysize)
300 {
301 int n = GET2(entry, 0);
302 if (n < stringcount && ovector[n*2] >= 0) return n;
303 }
304 return GET2(entry, 0);
305 }
306
307
308
309
310 /*************************************************
311 * Copy captured string to given buffer *
312 *************************************************/
313
314 /* This function copies a single captured substring into a given buffer.
315 Note that we use memcpy() rather than strncpy() in case there are binary zeros
316 in the string.
317
318 Arguments:
319 subject the subject string that was matched
320 ovector pointer to the offsets table
321 stringcount the number of substrings that were captured
322 (i.e. the yield of the pcre_exec call, unless
323 that was zero, in which case it should be 1/3
324 of the offset table size)
325 stringnumber the number of the required substring
326 buffer where to put the substring
327 size the size of the buffer
328
329 Returns: if successful:
330 the length of the copied string, not including the zero
331 that is put on the end; can be zero
332 if not successful:
333 PCRE_ERROR_NOMEMORY (-6) buffer too small
334 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
335 */
336
337 #if defined COMPILE_PCRE8
338 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
339 pcre_copy_substring(const char *subject, int *ovector, int stringcount,
340 int stringnumber, char *buffer, int size)
341 #elif defined COMPILE_PCRE16
342 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
343 pcre16_copy_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
344 int stringnumber, PCRE_UCHAR16 *buffer, int size)
345 #elif defined COMPILE_PCRE32
346 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
347 pcre32_copy_substring(PCRE_SPTR32 subject, int *ovector, int stringcount,
348 int stringnumber, PCRE_UCHAR32 *buffer, int size)
349 #endif
350 {
351 int yield;
352 if (stringnumber < 0 || stringnumber >= stringcount)
353 return PCRE_ERROR_NOSUBSTRING;
354 stringnumber *= 2;
355 yield = ovector[stringnumber+1] - ovector[stringnumber];
356 if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
357 memcpy(buffer, subject + ovector[stringnumber], IN_UCHARS(yield));
358 buffer[yield] = 0;
359 return yield;
360 }
361
362
363
364 /*************************************************
365 * Copy named captured string to given buffer *
366 *************************************************/
367
368 /* This function copies a single captured substring into a given buffer,
369 identifying it by name. If the regex permits duplicate names, the first
370 substring that is set is chosen.
371
372 Arguments:
373 code the compiled regex
374 subject the subject string that was matched
375 ovector pointer to the offsets table
376 stringcount the number of substrings that were captured
377 (i.e. the yield of the pcre_exec call, unless
378 that was zero, in which case it should be 1/3
379 of the offset table size)
380 stringname the name of the required substring
381 buffer where to put the substring
382 size the size of the buffer
383
384 Returns: if successful:
385 the length of the copied string, not including the zero
386 that is put on the end; can be zero
387 if not successful:
388 PCRE_ERROR_NOMEMORY (-6) buffer too small
389 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
390 */
391
392 #if defined COMPILE_PCRE8
393 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
394 pcre_copy_named_substring(const pcre *code, const char *subject,
395 int *ovector, int stringcount, const char *stringname,
396 char *buffer, int size)
397 #elif defined COMPILE_PCRE16
398 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
399 pcre16_copy_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
400 int *ovector, int stringcount, PCRE_SPTR16 stringname,
401 PCRE_UCHAR16 *buffer, int size)
402 #elif defined COMPILE_PCRE32
403 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
404 pcre32_copy_named_substring(const pcre32 *code, PCRE_SPTR32 subject,
405 int *ovector, int stringcount, PCRE_SPTR32 stringname,
406 PCRE_UCHAR32 *buffer, int size)
407 #endif
408 {
409 int n = get_first_set(code, stringname, ovector, stringcount);
410 if (n <= 0) return n;
411 #if defined COMPILE_PCRE8
412 return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
413 #elif defined COMPILE_PCRE16
414 return pcre16_copy_substring(subject, ovector, stringcount, n, buffer, size);
415 #elif defined COMPILE_PCRE32
416 return pcre32_copy_substring(subject, ovector, stringcount, n, buffer, size);
417 #endif
418 }
419
420
421
422 /*************************************************
423 * Copy all captured strings to new store *
424 *************************************************/
425
426 /* This function gets one chunk of store and builds a list of pointers and all
427 of the captured substrings in it. A NULL pointer is put on the end of the list.
428
429 Arguments:
430 subject the subject string that was matched
431 ovector pointer to the offsets table
432 stringcount the number of substrings that were captured
433 (i.e. the yield of the pcre_exec call, unless
434 that was zero, in which case it should be 1/3
435 of the offset table size)
436 listptr set to point to the list of pointers
437
438 Returns: if successful: 0
439 if not successful:
440 PCRE_ERROR_NOMEMORY (-6) failed to get store
441 */
442
443 #if defined COMPILE_PCRE8
444 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
445 pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
446 const char ***listptr)
447 #elif defined COMPILE_PCRE16
448 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
449 pcre16_get_substring_list(PCRE_SPTR16 subject, int *ovector, int stringcount,
450 PCRE_SPTR16 **listptr)
451 #elif defined COMPILE_PCRE32
452 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
453 pcre32_get_substring_list(PCRE_SPTR32 subject, int *ovector, int stringcount,
454 PCRE_SPTR32 **listptr)
455 #endif
456 {
457 int i;
458 int size = sizeof(pcre_uchar *);
459 int double_count = stringcount * 2;
460 pcre_uchar **stringlist;
461 pcre_uchar *p;
462
463 for (i = 0; i < double_count; i += 2)
464 {
465 size += sizeof(pcre_uchar *) + IN_UCHARS(1);
466 if (ovector[i+1] > ovector[i]) size += IN_UCHARS(ovector[i+1] - ovector[i]);
467 }
468
469 stringlist = (pcre_uchar **)(PUBL(malloc))(size);
470 if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
471
472 #if defined COMPILE_PCRE8
473 *listptr = (const char **)stringlist;
474 #elif defined COMPILE_PCRE16
475 *listptr = (PCRE_SPTR16 *)stringlist;
476 #elif defined COMPILE_PCRE32
477 *listptr = (PCRE_SPTR32 *)stringlist;
478 #endif
479 p = (pcre_uchar *)(stringlist + stringcount + 1);
480
481 for (i = 0; i < double_count; i += 2)
482 {
483 int len = (ovector[i+1] > ovector[i])? (ovector[i+1] - ovector[i]) : 0;
484 memcpy(p, subject + ovector[i], IN_UCHARS(len));
485 *stringlist++ = p;
486 p += len;
487 *p++ = 0;
488 }
489
490 *stringlist = NULL;
491 return 0;
492 }
493
494
495
496 /*************************************************
497 * Free store obtained by get_substring_list *
498 *************************************************/
499
500 /* This function exists for the benefit of people calling PCRE from non-C
501 programs that can call its functions, but not free() or (PUBL(free))()
502 directly.
503
504 Argument: the result of a previous pcre_get_substring_list()
505 Returns: nothing
506 */
507
508 #if defined COMPILE_PCRE8
509 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
510 pcre_free_substring_list(const char **pointer)
511 #elif defined COMPILE_PCRE16
512 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
513 pcre16_free_substring_list(PCRE_SPTR16 *pointer)
514 #elif defined COMPILE_PCRE32
515 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
516 pcre32_free_substring_list(PCRE_SPTR32 *pointer)
517 #endif
518 {
519 (PUBL(free))((void *)pointer);
520 }
521
522
523
524 /*************************************************
525 * Copy captured string to new store *
526 *************************************************/
527
528 /* This function copies a single captured substring into a piece of new
529 store
530
531 Arguments:
532 subject the subject string that was matched
533 ovector pointer to the offsets table
534 stringcount the number of substrings that were captured
535 (i.e. the yield of the pcre_exec call, unless
536 that was zero, in which case it should be 1/3
537 of the offset table size)
538 stringnumber the number of the required substring
539 stringptr where to put a pointer to the substring
540
541 Returns: if successful:
542 the length of the string, not including the zero that
543 is put on the end; can be zero
544 if not successful:
545 PCRE_ERROR_NOMEMORY (-6) failed to get store
546 PCRE_ERROR_NOSUBSTRING (-7) substring not present
547 */
548
549 #if defined COMPILE_PCRE8
550 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
551 pcre_get_substring(const char *subject, int *ovector, int stringcount,
552 int stringnumber, const char **stringptr)
553 #elif defined COMPILE_PCRE16
554 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
555 pcre16_get_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
556 int stringnumber, PCRE_SPTR16 *stringptr)
557 #elif defined COMPILE_PCRE32
558 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
559 pcre32_get_substring(PCRE_SPTR32 subject, int *ovector, int stringcount,
560 int stringnumber, PCRE_SPTR32 *stringptr)
561 #endif
562 {
563 int yield;
564 pcre_uchar *substring;
565 if (stringnumber < 0 || stringnumber >= stringcount)
566 return PCRE_ERROR_NOSUBSTRING;
567 stringnumber *= 2;
568 yield = ovector[stringnumber+1] - ovector[stringnumber];
569 substring = (pcre_uchar *)(PUBL(malloc))(IN_UCHARS(yield + 1));
570 if (substring == NULL) return PCRE_ERROR_NOMEMORY;
571 memcpy(substring, subject + ovector[stringnumber], IN_UCHARS(yield));
572 substring[yield] = 0;
573 #if defined COMPILE_PCRE8
574 *stringptr = (const char *)substring;
575 #elif defined COMPILE_PCRE16
576 *stringptr = (PCRE_SPTR16)substring;
577 #elif defined COMPILE_PCRE32
578 *stringptr = (PCRE_SPTR32)substring;
579 #endif
580 return yield;
581 }
582
583
584
585 /*************************************************
586 * Copy named captured string to new store *
587 *************************************************/
588
589 /* This function copies a single captured substring, identified by name, into
590 new store. If the regex permits duplicate names, the first substring that is
591 set is chosen.
592
593 Arguments:
594 code the compiled regex
595 subject the subject string that was matched
596 ovector pointer to the offsets table
597 stringcount the number of substrings that were captured
598 (i.e. the yield of the pcre_exec call, unless
599 that was zero, in which case it should be 1/3
600 of the offset table size)
601 stringname the name of the required substring
602 stringptr where to put the pointer
603
604 Returns: if successful:
605 the length of the copied string, not including the zero
606 that is put on the end; can be zero
607 if not successful:
608 PCRE_ERROR_NOMEMORY (-6) couldn't get memory
609 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
610 */
611
612 #if defined COMPILE_PCRE8
613 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
614 pcre_get_named_substring(const pcre *code, const char *subject,
615 int *ovector, int stringcount, const char *stringname,
616 const char **stringptr)
617 #elif defined COMPILE_PCRE16
618 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
619 pcre16_get_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
620 int *ovector, int stringcount, PCRE_SPTR16 stringname,
621 PCRE_SPTR16 *stringptr)
622 #elif defined COMPILE_PCRE32
623 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
624 pcre32_get_named_substring(const pcre32 *code, PCRE_SPTR32 subject,
625 int *ovector, int stringcount, PCRE_SPTR32 stringname,
626 PCRE_SPTR32 *stringptr)
627 #endif
628 {
629 int n = get_first_set(code, stringname, ovector, stringcount);
630 if (n <= 0) return n;
631 #if defined COMPILE_PCRE8
632 return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
633 #elif defined COMPILE_PCRE16
634 return pcre16_get_substring(subject, ovector, stringcount, n, stringptr);
635 #elif defined COMPILE_PCRE32
636 return pcre32_get_substring(subject, ovector, stringcount, n, stringptr);
637 #endif
638 }
639
640
641
642
643 /*************************************************
644 * Free store obtained by get_substring *
645 *************************************************/
646
647 /* This function exists for the benefit of people calling PCRE from non-C
648 programs that can call its functions, but not free() or (PUBL(free))()
649 directly.
650
651 Argument: the result of a previous pcre_get_substring()
652 Returns: nothing
653 */
654
655 #if defined COMPILE_PCRE8
656 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
657 pcre_free_substring(const char *pointer)
658 #elif defined COMPILE_PCRE16
659 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
660 pcre16_free_substring(PCRE_SPTR16 pointer)
661 #elif defined COMPILE_PCRE32
662 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
663 pcre32_free_substring(PCRE_SPTR32 pointer)
664 #endif
665 {
666 (PUBL(free))((void *)pointer);
667 }
668
669 /* End of pcre_get.c */

Properties

Name Value
svn:eol-style native
svn:keywords "Author Date Id Revision Url"

  ViewVC Help
Powered by ViewVC 1.1.5