Annotation of embedaddon/pcre/pcre_get.c, revision 1.1.1.3
1.1 misho 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
1.1.1.2 misho 9: Copyright (c) 1997-2012 University of Cambridge
1.1 misho 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:
1.1.1.3 ! misho 68: #if defined COMPILE_PCRE8
1.1 misho 69: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
70: pcre_get_stringnumber(const pcre *code, const char *stringname)
1.1.1.3 ! misho 71: #elif defined COMPILE_PCRE16
1.1.1.2 misho 72: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
73: pcre16_get_stringnumber(const pcre16 *code, PCRE_SPTR16 stringname)
1.1.1.3 ! misho 74: #elif defined COMPILE_PCRE32
! 75: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 76: pcre32_get_stringnumber(const pcre32 *code, PCRE_SPTR32 stringname)
1.1.1.2 misho 77: #endif
1.1 misho 78: {
79: int rc;
80: int entrysize;
81: int top, bot;
1.1.1.2 misho 82: pcre_uchar *nametable;
1.1 misho 83:
1.1.1.2 misho 84: #ifdef COMPILE_PCRE8
1.1 misho 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;
1.1.1.2 misho 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
1.1.1.3 ! misho 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
1.1 misho 114:
115: bot = 0;
116: while (top > bot)
117: {
118: int mid = (top + bot) / 2;
1.1.1.2 misho 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);
1.1 misho 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:
1.1.1.3 ! misho 148: #if defined COMPILE_PCRE8
1.1 misho 149: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
150: pcre_get_stringtable_entries(const pcre *code, const char *stringname,
151: char **firstptr, char **lastptr)
1.1.1.3 ! misho 152: #elif defined COMPILE_PCRE16
1.1.1.2 misho 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)
1.1.1.3 ! misho 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)
1.1.1.2 misho 160: #endif
1.1 misho 161: {
162: int rc;
163: int entrysize;
164: int top, bot;
1.1.1.2 misho 165: pcre_uchar *nametable, *lastentry;
1.1 misho 166:
1.1.1.2 misho 167: #ifdef COMPILE_PCRE8
1.1 misho 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;
1.1.1.2 misho 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
1.1.1.3 ! misho 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
1.1 misho 197:
198: lastentry = nametable + entrysize * (top - 1);
199: bot = 0;
200: while (top > bot)
201: {
202: int mid = (top + bot) / 2;
1.1.1.2 misho 203: pcre_uchar *entry = nametable + entrysize*mid;
204: int c = STRCMP_UC_UC((pcre_uchar *)stringname,
205: (pcre_uchar *)(entry + IMM2_SIZE));
1.1 misho 206: if (c == 0)
207: {
1.1.1.2 misho 208: pcre_uchar *first = entry;
209: pcre_uchar *last = entry;
1.1 misho 210: while (first > nametable)
211: {
1.1.1.2 misho 212: if (STRCMP_UC_UC((pcre_uchar *)stringname,
213: (pcre_uchar *)(first - entrysize + IMM2_SIZE)) != 0) break;
1.1 misho 214: first -= entrysize;
215: }
216: while (last < lastentry)
217: {
1.1.1.2 misho 218: if (STRCMP_UC_UC((pcre_uchar *)stringname,
219: (pcre_uchar *)(last + entrysize + IMM2_SIZE)) != 0) break;
1.1 misho 220: last += entrysize;
221: }
1.1.1.3 ! misho 222: #if defined COMPILE_PCRE8
1.1 misho 223: *firstptr = (char *)first;
224: *lastptr = (char *)last;
1.1.1.3 ! misho 225: #elif defined COMPILE_PCRE16
1.1.1.2 misho 226: *firstptr = (PCRE_UCHAR16 *)first;
227: *lastptr = (PCRE_UCHAR16 *)last;
1.1.1.3 ! misho 228: #elif defined COMPILE_PCRE32
! 229: *firstptr = (PCRE_UCHAR32 *)first;
! 230: *lastptr = (PCRE_UCHAR32 *)last;
1.1.1.2 misho 231: #endif
1.1 misho 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:
1.1.1.3 ! misho 259: #if defined COMPILE_PCRE8
1.1 misho 260: static int
261: get_first_set(const pcre *code, const char *stringname, int *ovector)
1.1.1.3 ! misho 262: #elif defined COMPILE_PCRE16
1.1.1.2 misho 263: static int
264: get_first_set(const pcre16 *code, PCRE_SPTR16 stringname, int *ovector)
1.1.1.3 ! misho 265: #elif defined COMPILE_PCRE32
! 266: static int
! 267: get_first_set(const pcre32 *code, PCRE_SPTR32 stringname, int *ovector)
1.1.1.2 misho 268: #endif
1.1 misho 269: {
1.1.1.2 misho 270: const REAL_PCRE *re = (const REAL_PCRE *)code;
1.1 misho 271: int entrysize;
1.1.1.2 misho 272: pcre_uchar *entry;
1.1.1.3 ! misho 273: #if defined COMPILE_PCRE8
1.1 misho 274: char *first, *last;
1.1.1.3 ! misho 275: #elif defined COMPILE_PCRE16
1.1.1.2 misho 276: PCRE_UCHAR16 *first, *last;
1.1.1.3 ! misho 277: #elif defined COMPILE_PCRE32
! 278: PCRE_UCHAR32 *first, *last;
1.1.1.2 misho 279: #endif
280:
1.1.1.3 ! misho 281: #if defined COMPILE_PCRE8
1.1 misho 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);
1.1.1.3 ! misho 285: #elif defined COMPILE_PCRE16
1.1.1.2 misho 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);
1.1.1.3 ! misho 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);
1.1.1.2 misho 293: #endif
1.1 misho 294: if (entrysize <= 0) return entrysize;
1.1.1.2 misho 295: for (entry = (pcre_uchar *)first; entry <= (pcre_uchar *)last; entry += entrysize)
1.1 misho 296: {
1.1.1.2 misho 297: int n = GET2(entry, 0);
1.1 misho 298: if (ovector[n*2] >= 0) return n;
299: }
1.1.1.2 misho 300: return GET2(entry, 0);
1.1 misho 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:
1.1.1.3 ! misho 333: #if defined COMPILE_PCRE8
1.1 misho 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)
1.1.1.3 ! misho 337: #elif defined COMPILE_PCRE16
1.1.1.2 misho 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)
1.1.1.3 ! misho 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)
1.1.1.2 misho 345: #endif
1.1 misho 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;
1.1.1.2 misho 353: memcpy(buffer, subject + ovector[stringnumber], IN_UCHARS(yield));
1.1 misho 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:
1.1.1.3 ! misho 388: #if defined COMPILE_PCRE8
1.1.1.2 misho 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)
1.1.1.3 ! misho 393: #elif defined COMPILE_PCRE16
1.1 misho 394: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
1.1.1.2 misho 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)
1.1.1.3 ! misho 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)
1.1.1.2 misho 403: #endif
1.1 misho 404: {
405: int n = get_first_set(code, stringname, ovector);
406: if (n <= 0) return n;
1.1.1.3 ! misho 407: #if defined COMPILE_PCRE8
1.1 misho 408: return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
1.1.1.3 ! misho 409: #elif defined COMPILE_PCRE16
1.1.1.2 misho 410: return pcre16_copy_substring(subject, ovector, stringcount, n, buffer, size);
1.1.1.3 ! misho 411: #elif defined COMPILE_PCRE32
! 412: return pcre32_copy_substring(subject, ovector, stringcount, n, buffer, size);
1.1.1.2 misho 413: #endif
1.1 misho 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:
1.1.1.3 ! misho 439: #if defined COMPILE_PCRE8
1.1 misho 440: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
441: pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
442: const char ***listptr)
1.1.1.3 ! misho 443: #elif defined COMPILE_PCRE16
1.1.1.2 misho 444: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
445: pcre16_get_substring_list(PCRE_SPTR16 subject, int *ovector, int stringcount,
446: PCRE_SPTR16 **listptr)
1.1.1.3 ! misho 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)
1.1.1.2 misho 451: #endif
1.1 misho 452: {
453: int i;
1.1.1.2 misho 454: int size = sizeof(pcre_uchar *);
1.1 misho 455: int double_count = stringcount * 2;
1.1.1.2 misho 456: pcre_uchar **stringlist;
457: pcre_uchar *p;
1.1 misho 458:
459: for (i = 0; i < double_count; i += 2)
1.1.1.2 misho 460: size += sizeof(pcre_uchar *) + IN_UCHARS(ovector[i+1] - ovector[i] + 1);
1.1 misho 461:
1.1.1.2 misho 462: stringlist = (pcre_uchar **)(PUBL(malloc))(size);
1.1 misho 463: if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
464:
1.1.1.3 ! misho 465: #if defined COMPILE_PCRE8
1.1 misho 466: *listptr = (const char **)stringlist;
1.1.1.3 ! misho 467: #elif defined COMPILE_PCRE16
1.1.1.2 misho 468: *listptr = (PCRE_SPTR16 *)stringlist;
1.1.1.3 ! misho 469: #elif defined COMPILE_PCRE32
! 470: *listptr = (PCRE_SPTR32 *)stringlist;
1.1.1.2 misho 471: #endif
472: p = (pcre_uchar *)(stringlist + stringcount + 1);
1.1 misho 473:
474: for (i = 0; i < double_count; i += 2)
475: {
476: int len = ovector[i+1] - ovector[i];
1.1.1.2 misho 477: memcpy(p, subject + ovector[i], IN_UCHARS(len));
1.1 misho 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
1.1.1.2 misho 494: programs that can call its functions, but not free() or (PUBL(free))()
495: directly.
1.1 misho 496:
497: Argument: the result of a previous pcre_get_substring_list()
498: Returns: nothing
499: */
500:
1.1.1.3 ! misho 501: #if defined COMPILE_PCRE8
1.1 misho 502: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
503: pcre_free_substring_list(const char **pointer)
1.1.1.3 ! misho 504: #elif defined COMPILE_PCRE16
1.1.1.2 misho 505: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
506: pcre16_free_substring_list(PCRE_SPTR16 *pointer)
1.1.1.3 ! misho 507: #elif defined COMPILE_PCRE32
! 508: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
! 509: pcre32_free_substring_list(PCRE_SPTR32 *pointer)
1.1.1.2 misho 510: #endif
1.1 misho 511: {
1.1.1.2 misho 512: (PUBL(free))((void *)pointer);
1.1 misho 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:
1.1.1.3 ! misho 542: #if defined COMPILE_PCRE8
1.1 misho 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)
1.1.1.3 ! misho 546: #elif defined COMPILE_PCRE16
1.1.1.2 misho 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)
1.1.1.3 ! misho 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)
1.1.1.2 misho 554: #endif
1.1 misho 555: {
556: int yield;
1.1.1.2 misho 557: pcre_uchar *substring;
1.1 misho 558: if (stringnumber < 0 || stringnumber >= stringcount)
559: return PCRE_ERROR_NOSUBSTRING;
560: stringnumber *= 2;
561: yield = ovector[stringnumber+1] - ovector[stringnumber];
1.1.1.2 misho 562: substring = (pcre_uchar *)(PUBL(malloc))(IN_UCHARS(yield + 1));
1.1 misho 563: if (substring == NULL) return PCRE_ERROR_NOMEMORY;
1.1.1.2 misho 564: memcpy(substring, subject + ovector[stringnumber], IN_UCHARS(yield));
1.1 misho 565: substring[yield] = 0;
1.1.1.3 ! misho 566: #if defined COMPILE_PCRE8
1.1.1.2 misho 567: *stringptr = (const char *)substring;
1.1.1.3 ! misho 568: #elif defined COMPILE_PCRE16
1.1.1.2 misho 569: *stringptr = (PCRE_SPTR16)substring;
1.1.1.3 ! misho 570: #elif defined COMPILE_PCRE32
! 571: *stringptr = (PCRE_SPTR32)substring;
1.1.1.2 misho 572: #endif
1.1 misho 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:
1.1.1.3 ! misho 605: #if defined COMPILE_PCRE8
1.1 misho 606: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
1.1.1.2 misho 607: pcre_get_named_substring(const pcre *code, const char *subject,
608: int *ovector, int stringcount, const char *stringname,
609: const char **stringptr)
1.1.1.3 ! misho 610: #elif defined COMPILE_PCRE16
1.1.1.2 misho 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)
1.1.1.3 ! misho 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)
1.1.1.2 misho 620: #endif
1.1 misho 621: {
622: int n = get_first_set(code, stringname, ovector);
623: if (n <= 0) return n;
1.1.1.3 ! misho 624: #if defined COMPILE_PCRE8
1.1 misho 625: return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
1.1.1.3 ! misho 626: #elif defined COMPILE_PCRE16
1.1.1.2 misho 627: return pcre16_get_substring(subject, ovector, stringcount, n, stringptr);
1.1.1.3 ! misho 628: #elif defined COMPILE_PCRE32
! 629: return pcre32_get_substring(subject, ovector, stringcount, n, stringptr);
1.1.1.2 misho 630: #endif
1.1 misho 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
1.1.1.2 misho 641: programs that can call its functions, but not free() or (PUBL(free))()
642: directly.
1.1 misho 643:
644: Argument: the result of a previous pcre_get_substring()
645: Returns: nothing
646: */
647:
1.1.1.3 ! misho 648: #if defined COMPILE_PCRE8
1.1 misho 649: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
650: pcre_free_substring(const char *pointer)
1.1.1.3 ! misho 651: #elif defined COMPILE_PCRE16
1.1.1.2 misho 652: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
653: pcre16_free_substring(PCRE_SPTR16 pointer)
1.1.1.3 ! misho 654: #elif defined COMPILE_PCRE32
! 655: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
! 656: pcre32_free_substring(PCRE_SPTR32 pointer)
1.1.1.2 misho 657: #endif
1.1 misho 658: {
1.1.1.2 misho 659: (PUBL(free))((void *)pointer);
1.1 misho 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