xref: /PHP-5.6/ext/pcre/pcrelib/pcre_get.c (revision 357ab3cb)
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
pcre_get_stringnumber(const pcre * code,const char * stringname)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
pcre_get_stringtable_entries(const pcre * code,const char * stringname,char ** firstptr,char ** lastptr)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 
254 Returns:       the number of the first that is set,
255                or the number of the last one if none are set,
256                or a negative number on error
257 */
258 
259 #if defined COMPILE_PCRE8
260 static int
get_first_set(const pcre * code,const char * stringname,int * ovector)261 get_first_set(const pcre *code, const char *stringname, int *ovector)
262 #elif defined COMPILE_PCRE16
263 static int
264 get_first_set(const pcre16 *code, PCRE_SPTR16 stringname, int *ovector)
265 #elif defined COMPILE_PCRE32
266 static int
267 get_first_set(const pcre32 *code, PCRE_SPTR32 stringname, int *ovector)
268 #endif
269 {
270 const REAL_PCRE *re = (const REAL_PCRE *)code;
271 int entrysize;
272 pcre_uchar *entry;
273 #if defined COMPILE_PCRE8
274 char *first, *last;
275 #elif defined COMPILE_PCRE16
276 PCRE_UCHAR16 *first, *last;
277 #elif defined COMPILE_PCRE32
278 PCRE_UCHAR32 *first, *last;
279 #endif
280 
281 #if defined COMPILE_PCRE8
282 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
283   return pcre_get_stringnumber(code, stringname);
284 entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last);
285 #elif defined COMPILE_PCRE16
286 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
287   return pcre16_get_stringnumber(code, stringname);
288 entrysize = pcre16_get_stringtable_entries(code, stringname, &first, &last);
289 #elif defined COMPILE_PCRE32
290 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
291   return pcre32_get_stringnumber(code, stringname);
292 entrysize = pcre32_get_stringtable_entries(code, stringname, &first, &last);
293 #endif
294 if (entrysize <= 0) return entrysize;
295 for (entry = (pcre_uchar *)first; entry <= (pcre_uchar *)last; entry += entrysize)
296   {
297   int n = GET2(entry, 0);
298   if (ovector[n*2] >= 0) return n;
299   }
300 return GET2(entry, 0);
301 }
302 
303 
304 
305 
306 /*************************************************
307 *      Copy captured string to given buffer      *
308 *************************************************/
309 
310 /* This function copies a single captured substring into a given buffer.
311 Note that we use memcpy() rather than strncpy() in case there are binary zeros
312 in the string.
313 
314 Arguments:
315   subject        the subject string that was matched
316   ovector        pointer to the offsets table
317   stringcount    the number of substrings that were captured
318                    (i.e. the yield of the pcre_exec call, unless
319                    that was zero, in which case it should be 1/3
320                    of the offset table size)
321   stringnumber   the number of the required substring
322   buffer         where to put the substring
323   size           the size of the buffer
324 
325 Returns:         if successful:
326                    the length of the copied string, not including the zero
327                    that is put on the end; can be zero
328                  if not successful:
329                    PCRE_ERROR_NOMEMORY (-6) buffer too small
330                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
331 */
332 
333 #if defined COMPILE_PCRE8
334 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
pcre_copy_substring(const char * subject,int * ovector,int stringcount,int stringnumber,char * buffer,int size)335 pcre_copy_substring(const char *subject, int *ovector, int stringcount,
336   int stringnumber, char *buffer, int size)
337 #elif defined COMPILE_PCRE16
338 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
339 pcre16_copy_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
340   int stringnumber, PCRE_UCHAR16 *buffer, int size)
341 #elif defined COMPILE_PCRE32
342 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
343 pcre32_copy_substring(PCRE_SPTR32 subject, int *ovector, int stringcount,
344   int stringnumber, PCRE_UCHAR32 *buffer, int size)
345 #endif
346 {
347 int yield;
348 if (stringnumber < 0 || stringnumber >= stringcount)
349   return PCRE_ERROR_NOSUBSTRING;
350 stringnumber *= 2;
351 yield = ovector[stringnumber+1] - ovector[stringnumber];
352 if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
353 memcpy(buffer, subject + ovector[stringnumber], IN_UCHARS(yield));
354 buffer[yield] = 0;
355 return yield;
356 }
357 
358 
359 
360 /*************************************************
361 *   Copy named captured string to given buffer   *
362 *************************************************/
363 
364 /* This function copies a single captured substring into a given buffer,
365 identifying it by name. If the regex permits duplicate names, the first
366 substring that is set is chosen.
367 
368 Arguments:
369   code           the compiled regex
370   subject        the subject string that was matched
371   ovector        pointer to the offsets table
372   stringcount    the number of substrings that were captured
373                    (i.e. the yield of the pcre_exec call, unless
374                    that was zero, in which case it should be 1/3
375                    of the offset table size)
376   stringname     the name of the required substring
377   buffer         where to put the substring
378   size           the size of the buffer
379 
380 Returns:         if successful:
381                    the length of the copied string, not including the zero
382                    that is put on the end; can be zero
383                  if not successful:
384                    PCRE_ERROR_NOMEMORY (-6) buffer too small
385                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
386 */
387 
388 #if defined COMPILE_PCRE8
389 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
pcre_copy_named_substring(const pcre * code,const char * subject,int * ovector,int stringcount,const char * stringname,char * buffer,int size)390 pcre_copy_named_substring(const pcre *code, const char *subject,
391   int *ovector, int stringcount, const char *stringname,
392   char *buffer, int size)
393 #elif defined COMPILE_PCRE16
394 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
395 pcre16_copy_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
396   int *ovector, int stringcount, PCRE_SPTR16 stringname,
397   PCRE_UCHAR16 *buffer, int size)
398 #elif defined COMPILE_PCRE32
399 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
400 pcre32_copy_named_substring(const pcre32 *code, PCRE_SPTR32 subject,
401   int *ovector, int stringcount, PCRE_SPTR32 stringname,
402   PCRE_UCHAR32 *buffer, int size)
403 #endif
404 {
405 int n = get_first_set(code, stringname, ovector);
406 if (n <= 0) return n;
407 #if defined COMPILE_PCRE8
408 return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
409 #elif defined COMPILE_PCRE16
410 return pcre16_copy_substring(subject, ovector, stringcount, n, buffer, size);
411 #elif defined COMPILE_PCRE32
412 return pcre32_copy_substring(subject, ovector, stringcount, n, buffer, size);
413 #endif
414 }
415 
416 
417 
418 /*************************************************
419 *      Copy all captured strings to new store    *
420 *************************************************/
421 
422 /* This function gets one chunk of store and builds a list of pointers and all
423 of the captured substrings in it. A NULL pointer is put on the end of the list.
424 
425 Arguments:
426   subject        the subject string that was matched
427   ovector        pointer to the offsets table
428   stringcount    the number of substrings that were captured
429                    (i.e. the yield of the pcre_exec call, unless
430                    that was zero, in which case it should be 1/3
431                    of the offset table size)
432   listptr        set to point to the list of pointers
433 
434 Returns:         if successful: 0
435                  if not successful:
436                    PCRE_ERROR_NOMEMORY (-6) failed to get store
437 */
438 
439 #if defined COMPILE_PCRE8
440 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
pcre_get_substring_list(const char * subject,int * ovector,int stringcount,const char *** listptr)441 pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
442   const char ***listptr)
443 #elif defined COMPILE_PCRE16
444 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
445 pcre16_get_substring_list(PCRE_SPTR16 subject, int *ovector, int stringcount,
446   PCRE_SPTR16 **listptr)
447 #elif defined COMPILE_PCRE32
448 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
449 pcre32_get_substring_list(PCRE_SPTR32 subject, int *ovector, int stringcount,
450   PCRE_SPTR32 **listptr)
451 #endif
452 {
453 int i;
454 int size = sizeof(pcre_uchar *);
455 int double_count = stringcount * 2;
456 pcre_uchar **stringlist;
457 pcre_uchar *p;
458 
459 for (i = 0; i < double_count; i += 2)
460   size += sizeof(pcre_uchar *) + IN_UCHARS(ovector[i+1] - ovector[i] + 1);
461 
462 stringlist = (pcre_uchar **)(PUBL(malloc))(size);
463 if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
464 
465 #if defined COMPILE_PCRE8
466 *listptr = (const char **)stringlist;
467 #elif defined COMPILE_PCRE16
468 *listptr = (PCRE_SPTR16 *)stringlist;
469 #elif defined COMPILE_PCRE32
470 *listptr = (PCRE_SPTR32 *)stringlist;
471 #endif
472 p = (pcre_uchar *)(stringlist + stringcount + 1);
473 
474 for (i = 0; i < double_count; i += 2)
475   {
476   int len = ovector[i+1] - ovector[i];
477   memcpy(p, subject + ovector[i], IN_UCHARS(len));
478   *stringlist++ = p;
479   p += len;
480   *p++ = 0;
481   }
482 
483 *stringlist = NULL;
484 return 0;
485 }
486 
487 
488 
489 /*************************************************
490 *   Free store obtained by get_substring_list    *
491 *************************************************/
492 
493 /* This function exists for the benefit of people calling PCRE from non-C
494 programs that can call its functions, but not free() or (PUBL(free))()
495 directly.
496 
497 Argument:   the result of a previous pcre_get_substring_list()
498 Returns:    nothing
499 */
500 
501 #if defined COMPILE_PCRE8
502 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
pcre_free_substring_list(const char ** pointer)503 pcre_free_substring_list(const char **pointer)
504 #elif defined COMPILE_PCRE16
505 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
506 pcre16_free_substring_list(PCRE_SPTR16 *pointer)
507 #elif defined COMPILE_PCRE32
508 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
509 pcre32_free_substring_list(PCRE_SPTR32 *pointer)
510 #endif
511 {
512 (PUBL(free))((void *)pointer);
513 }
514 
515 
516 
517 /*************************************************
518 *      Copy captured string to new store         *
519 *************************************************/
520 
521 /* This function copies a single captured substring into a piece of new
522 store
523 
524 Arguments:
525   subject        the subject string that was matched
526   ovector        pointer to the offsets table
527   stringcount    the number of substrings that were captured
528                    (i.e. the yield of the pcre_exec call, unless
529                    that was zero, in which case it should be 1/3
530                    of the offset table size)
531   stringnumber   the number of the required substring
532   stringptr      where to put a pointer to the substring
533 
534 Returns:         if successful:
535                    the length of the string, not including the zero that
536                    is put on the end; can be zero
537                  if not successful:
538                    PCRE_ERROR_NOMEMORY (-6) failed to get store
539                    PCRE_ERROR_NOSUBSTRING (-7) substring not present
540 */
541 
542 #if defined COMPILE_PCRE8
543 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
pcre_get_substring(const char * subject,int * ovector,int stringcount,int stringnumber,const char ** stringptr)544 pcre_get_substring(const char *subject, int *ovector, int stringcount,
545   int stringnumber, const char **stringptr)
546 #elif defined COMPILE_PCRE16
547 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
548 pcre16_get_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
549   int stringnumber, PCRE_SPTR16 *stringptr)
550 #elif defined COMPILE_PCRE32
551 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
552 pcre32_get_substring(PCRE_SPTR32 subject, int *ovector, int stringcount,
553   int stringnumber, PCRE_SPTR32 *stringptr)
554 #endif
555 {
556 int yield;
557 pcre_uchar *substring;
558 if (stringnumber < 0 || stringnumber >= stringcount)
559   return PCRE_ERROR_NOSUBSTRING;
560 stringnumber *= 2;
561 yield = ovector[stringnumber+1] - ovector[stringnumber];
562 substring = (pcre_uchar *)(PUBL(malloc))(IN_UCHARS(yield + 1));
563 if (substring == NULL) return PCRE_ERROR_NOMEMORY;
564 memcpy(substring, subject + ovector[stringnumber], IN_UCHARS(yield));
565 substring[yield] = 0;
566 #if defined COMPILE_PCRE8
567 *stringptr = (const char *)substring;
568 #elif defined COMPILE_PCRE16
569 *stringptr = (PCRE_SPTR16)substring;
570 #elif defined COMPILE_PCRE32
571 *stringptr = (PCRE_SPTR32)substring;
572 #endif
573 return yield;
574 }
575 
576 
577 
578 /*************************************************
579 *   Copy named captured string to new store      *
580 *************************************************/
581 
582 /* This function copies a single captured substring, identified by name, into
583 new store. If the regex permits duplicate names, the first substring that is
584 set is chosen.
585 
586 Arguments:
587   code           the compiled regex
588   subject        the subject string that was matched
589   ovector        pointer to the offsets table
590   stringcount    the number of substrings that were captured
591                    (i.e. the yield of the pcre_exec call, unless
592                    that was zero, in which case it should be 1/3
593                    of the offset table size)
594   stringname     the name of the required substring
595   stringptr      where to put the pointer
596 
597 Returns:         if successful:
598                    the length of the copied string, not including the zero
599                    that is put on the end; can be zero
600                  if not successful:
601                    PCRE_ERROR_NOMEMORY (-6) couldn't get memory
602                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
603 */
604 
605 #if defined COMPILE_PCRE8
606 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
pcre_get_named_substring(const pcre * code,const char * subject,int * ovector,int stringcount,const char * stringname,const char ** stringptr)607 pcre_get_named_substring(const pcre *code, const char *subject,
608   int *ovector, int stringcount, const char *stringname,
609   const char **stringptr)
610 #elif defined COMPILE_PCRE16
611 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
612 pcre16_get_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
613   int *ovector, int stringcount, PCRE_SPTR16 stringname,
614   PCRE_SPTR16 *stringptr)
615 #elif defined COMPILE_PCRE32
616 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
617 pcre32_get_named_substring(const pcre32 *code, PCRE_SPTR32 subject,
618   int *ovector, int stringcount, PCRE_SPTR32 stringname,
619   PCRE_SPTR32 *stringptr)
620 #endif
621 {
622 int n = get_first_set(code, stringname, ovector);
623 if (n <= 0) return n;
624 #if defined COMPILE_PCRE8
625 return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
626 #elif defined COMPILE_PCRE16
627 return pcre16_get_substring(subject, ovector, stringcount, n, stringptr);
628 #elif defined COMPILE_PCRE32
629 return pcre32_get_substring(subject, ovector, stringcount, n, stringptr);
630 #endif
631 }
632 
633 
634 
635 
636 /*************************************************
637 *       Free store obtained by get_substring     *
638 *************************************************/
639 
640 /* This function exists for the benefit of people calling PCRE from non-C
641 programs that can call its functions, but not free() or (PUBL(free))()
642 directly.
643 
644 Argument:   the result of a previous pcre_get_substring()
645 Returns:    nothing
646 */
647 
648 #if defined COMPILE_PCRE8
649 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
pcre_free_substring(const char * pointer)650 pcre_free_substring(const char *pointer)
651 #elif defined COMPILE_PCRE16
652 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
653 pcre16_free_substring(PCRE_SPTR16 pointer)
654 #elif defined COMPILE_PCRE32
655 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
656 pcre32_free_substring(PCRE_SPTR32 pointer)
657 #endif
658 {
659 (PUBL(free))((void *)pointer);
660 }
661 
662 /* End of pcre_get.c */
663