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:
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
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
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
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
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
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
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
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
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 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre_get.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre