Annotation of embedaddon/pcre/pcre_get.c, revision 1.1.1.2
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.2 ! misho 68: #ifdef 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.2 ! misho 71: #else
! 72: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 73: pcre16_get_stringnumber(const pcre16 *code, PCRE_SPTR16 stringname)
! 74: #endif
1.1 misho 75: {
76: int rc;
77: int entrysize;
78: int top, bot;
1.1.1.2 ! misho 79: pcre_uchar *nametable;
1.1 misho 80:
1.1.1.2 ! misho 81: #ifdef COMPILE_PCRE8
1.1 misho 82: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
83: return rc;
84: if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
85:
86: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
87: return rc;
88: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
89: return rc;
1.1.1.2 ! misho 90: #endif
! 91: #ifdef COMPILE_PCRE16
! 92: if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
! 93: return rc;
! 94: if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
! 95:
! 96: if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
! 97: return rc;
! 98: if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
! 99: return rc;
! 100: #endif
1.1 misho 101:
102: bot = 0;
103: while (top > bot)
104: {
105: int mid = (top + bot) / 2;
1.1.1.2 ! misho 106: pcre_uchar *entry = nametable + entrysize*mid;
! 107: int c = STRCMP_UC_UC((pcre_uchar *)stringname,
! 108: (pcre_uchar *)(entry + IMM2_SIZE));
! 109: if (c == 0) return GET2(entry, 0);
1.1 misho 110: if (c > 0) bot = mid + 1; else top = mid;
111: }
112:
113: return PCRE_ERROR_NOSUBSTRING;
114: }
115:
116:
117:
118: /*************************************************
119: * Find (multiple) entries for named string *
120: *************************************************/
121:
122: /* This is used by the get_first_set() function below, as well as being
123: generally available. It is used when duplicated names are permitted.
124:
125: Arguments:
126: code the compiled regex
127: stringname the name whose entries required
128: firstptr where to put the pointer to the first entry
129: lastptr where to put the pointer to the last entry
130:
131: Returns: the length of each entry, or a negative number
132: (PCRE_ERROR_NOSUBSTRING) if not found
133: */
134:
1.1.1.2 ! misho 135: #ifdef COMPILE_PCRE8
1.1 misho 136: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
137: pcre_get_stringtable_entries(const pcre *code, const char *stringname,
138: char **firstptr, char **lastptr)
1.1.1.2 ! misho 139: #else
! 140: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 141: pcre16_get_stringtable_entries(const pcre16 *code, PCRE_SPTR16 stringname,
! 142: PCRE_UCHAR16 **firstptr, PCRE_UCHAR16 **lastptr)
! 143: #endif
1.1 misho 144: {
145: int rc;
146: int entrysize;
147: int top, bot;
1.1.1.2 ! misho 148: pcre_uchar *nametable, *lastentry;
1.1 misho 149:
1.1.1.2 ! misho 150: #ifdef COMPILE_PCRE8
1.1 misho 151: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
152: return rc;
153: if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
154:
155: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
156: return rc;
157: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
158: return rc;
1.1.1.2 ! misho 159: #endif
! 160: #ifdef COMPILE_PCRE16
! 161: if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
! 162: return rc;
! 163: if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
! 164:
! 165: if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
! 166: return rc;
! 167: if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
! 168: return rc;
! 169: #endif
1.1 misho 170:
171: lastentry = nametable + entrysize * (top - 1);
172: bot = 0;
173: while (top > bot)
174: {
175: int mid = (top + bot) / 2;
1.1.1.2 ! misho 176: pcre_uchar *entry = nametable + entrysize*mid;
! 177: int c = STRCMP_UC_UC((pcre_uchar *)stringname,
! 178: (pcre_uchar *)(entry + IMM2_SIZE));
1.1 misho 179: if (c == 0)
180: {
1.1.1.2 ! misho 181: pcre_uchar *first = entry;
! 182: pcre_uchar *last = entry;
1.1 misho 183: while (first > nametable)
184: {
1.1.1.2 ! misho 185: if (STRCMP_UC_UC((pcre_uchar *)stringname,
! 186: (pcre_uchar *)(first - entrysize + IMM2_SIZE)) != 0) break;
1.1 misho 187: first -= entrysize;
188: }
189: while (last < lastentry)
190: {
1.1.1.2 ! misho 191: if (STRCMP_UC_UC((pcre_uchar *)stringname,
! 192: (pcre_uchar *)(last + entrysize + IMM2_SIZE)) != 0) break;
1.1 misho 193: last += entrysize;
194: }
1.1.1.2 ! misho 195: #ifdef COMPILE_PCRE8
1.1 misho 196: *firstptr = (char *)first;
197: *lastptr = (char *)last;
1.1.1.2 ! misho 198: #else
! 199: *firstptr = (PCRE_UCHAR16 *)first;
! 200: *lastptr = (PCRE_UCHAR16 *)last;
! 201: #endif
1.1 misho 202: return entrysize;
203: }
204: if (c > 0) bot = mid + 1; else top = mid;
205: }
206:
207: return PCRE_ERROR_NOSUBSTRING;
208: }
209:
210:
211:
212: /*************************************************
213: * Find first set of multiple named strings *
214: *************************************************/
215:
216: /* This function allows for duplicate names in the table of named substrings.
217: It returns the number of the first one that was set in a pattern match.
218:
219: Arguments:
220: code the compiled regex
221: stringname the name of the capturing substring
222: ovector the vector of matched substrings
223:
224: Returns: the number of the first that is set,
225: or the number of the last one if none are set,
226: or a negative number on error
227: */
228:
1.1.1.2 ! misho 229: #ifdef COMPILE_PCRE8
1.1 misho 230: static int
231: get_first_set(const pcre *code, const char *stringname, int *ovector)
1.1.1.2 ! misho 232: #else
! 233: static int
! 234: get_first_set(const pcre16 *code, PCRE_SPTR16 stringname, int *ovector)
! 235: #endif
1.1 misho 236: {
1.1.1.2 ! misho 237: const REAL_PCRE *re = (const REAL_PCRE *)code;
1.1 misho 238: int entrysize;
1.1.1.2 ! misho 239: pcre_uchar *entry;
! 240: #ifdef COMPILE_PCRE8
1.1 misho 241: char *first, *last;
1.1.1.2 ! misho 242: #else
! 243: PCRE_UCHAR16 *first, *last;
! 244: #endif
! 245:
! 246: #ifdef COMPILE_PCRE8
1.1 misho 247: if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
248: return pcre_get_stringnumber(code, stringname);
249: entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last);
1.1.1.2 ! misho 250: #else
! 251: if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
! 252: return pcre16_get_stringnumber(code, stringname);
! 253: entrysize = pcre16_get_stringtable_entries(code, stringname, &first, &last);
! 254: #endif
1.1 misho 255: if (entrysize <= 0) return entrysize;
1.1.1.2 ! misho 256: for (entry = (pcre_uchar *)first; entry <= (pcre_uchar *)last; entry += entrysize)
1.1 misho 257: {
1.1.1.2 ! misho 258: int n = GET2(entry, 0);
1.1 misho 259: if (ovector[n*2] >= 0) return n;
260: }
1.1.1.2 ! misho 261: return GET2(entry, 0);
1.1 misho 262: }
263:
264:
265:
266:
267: /*************************************************
268: * Copy captured string to given buffer *
269: *************************************************/
270:
271: /* This function copies a single captured substring into a given buffer.
272: Note that we use memcpy() rather than strncpy() in case there are binary zeros
273: in the string.
274:
275: Arguments:
276: subject the subject string that was matched
277: ovector pointer to the offsets table
278: stringcount the number of substrings that were captured
279: (i.e. the yield of the pcre_exec call, unless
280: that was zero, in which case it should be 1/3
281: of the offset table size)
282: stringnumber the number of the required substring
283: buffer where to put the substring
284: size the size of the buffer
285:
286: Returns: if successful:
287: the length of the copied string, not including the zero
288: that is put on the end; can be zero
289: if not successful:
290: PCRE_ERROR_NOMEMORY (-6) buffer too small
291: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
292: */
293:
1.1.1.2 ! misho 294: #ifdef COMPILE_PCRE8
1.1 misho 295: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
296: pcre_copy_substring(const char *subject, int *ovector, int stringcount,
297: int stringnumber, char *buffer, int size)
1.1.1.2 ! misho 298: #else
! 299: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 300: pcre16_copy_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
! 301: int stringnumber, PCRE_UCHAR16 *buffer, int size)
! 302: #endif
1.1 misho 303: {
304: int yield;
305: if (stringnumber < 0 || stringnumber >= stringcount)
306: return PCRE_ERROR_NOSUBSTRING;
307: stringnumber *= 2;
308: yield = ovector[stringnumber+1] - ovector[stringnumber];
309: if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
1.1.1.2 ! misho 310: memcpy(buffer, subject + ovector[stringnumber], IN_UCHARS(yield));
1.1 misho 311: buffer[yield] = 0;
312: return yield;
313: }
314:
315:
316:
317: /*************************************************
318: * Copy named captured string to given buffer *
319: *************************************************/
320:
321: /* This function copies a single captured substring into a given buffer,
322: identifying it by name. If the regex permits duplicate names, the first
323: substring that is set is chosen.
324:
325: Arguments:
326: code the compiled regex
327: subject the subject string that was matched
328: ovector pointer to the offsets table
329: stringcount the number of substrings that were captured
330: (i.e. the yield of the pcre_exec call, unless
331: that was zero, in which case it should be 1/3
332: of the offset table size)
333: stringname the name of the required substring
334: buffer where to put the substring
335: size the size of the buffer
336:
337: Returns: if successful:
338: the length of the copied string, not including the zero
339: that is put on the end; can be zero
340: if not successful:
341: PCRE_ERROR_NOMEMORY (-6) buffer too small
342: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
343: */
344:
1.1.1.2 ! misho 345: #ifdef COMPILE_PCRE8
! 346: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 347: pcre_copy_named_substring(const pcre *code, const char *subject,
! 348: int *ovector, int stringcount, const char *stringname,
! 349: char *buffer, int size)
! 350: #else
1.1 misho 351: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
1.1.1.2 ! misho 352: pcre16_copy_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
! 353: int *ovector, int stringcount, PCRE_SPTR16 stringname,
! 354: PCRE_UCHAR16 *buffer, int size)
! 355: #endif
1.1 misho 356: {
357: int n = get_first_set(code, stringname, ovector);
358: if (n <= 0) return n;
1.1.1.2 ! misho 359: #ifdef COMPILE_PCRE8
1.1 misho 360: return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
1.1.1.2 ! misho 361: #else
! 362: return pcre16_copy_substring(subject, ovector, stringcount, n, buffer, size);
! 363: #endif
1.1 misho 364: }
365:
366:
367:
368: /*************************************************
369: * Copy all captured strings to new store *
370: *************************************************/
371:
372: /* This function gets one chunk of store and builds a list of pointers and all
373: of the captured substrings in it. A NULL pointer is put on the end of the list.
374:
375: Arguments:
376: subject the subject string that was matched
377: ovector pointer to the offsets table
378: stringcount the number of substrings that were captured
379: (i.e. the yield of the pcre_exec call, unless
380: that was zero, in which case it should be 1/3
381: of the offset table size)
382: listptr set to point to the list of pointers
383:
384: Returns: if successful: 0
385: if not successful:
386: PCRE_ERROR_NOMEMORY (-6) failed to get store
387: */
388:
1.1.1.2 ! misho 389: #ifdef COMPILE_PCRE8
1.1 misho 390: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
391: pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
392: const char ***listptr)
1.1.1.2 ! misho 393: #else
! 394: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 395: pcre16_get_substring_list(PCRE_SPTR16 subject, int *ovector, int stringcount,
! 396: PCRE_SPTR16 **listptr)
! 397: #endif
1.1 misho 398: {
399: int i;
1.1.1.2 ! misho 400: int size = sizeof(pcre_uchar *);
1.1 misho 401: int double_count = stringcount * 2;
1.1.1.2 ! misho 402: pcre_uchar **stringlist;
! 403: pcre_uchar *p;
1.1 misho 404:
405: for (i = 0; i < double_count; i += 2)
1.1.1.2 ! misho 406: size += sizeof(pcre_uchar *) + IN_UCHARS(ovector[i+1] - ovector[i] + 1);
1.1 misho 407:
1.1.1.2 ! misho 408: stringlist = (pcre_uchar **)(PUBL(malloc))(size);
1.1 misho 409: if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
410:
1.1.1.2 ! misho 411: #ifdef COMPILE_PCRE8
1.1 misho 412: *listptr = (const char **)stringlist;
1.1.1.2 ! misho 413: #else
! 414: *listptr = (PCRE_SPTR16 *)stringlist;
! 415: #endif
! 416: p = (pcre_uchar *)(stringlist + stringcount + 1);
1.1 misho 417:
418: for (i = 0; i < double_count; i += 2)
419: {
420: int len = ovector[i+1] - ovector[i];
1.1.1.2 ! misho 421: memcpy(p, subject + ovector[i], IN_UCHARS(len));
1.1 misho 422: *stringlist++ = p;
423: p += len;
424: *p++ = 0;
425: }
426:
427: *stringlist = NULL;
428: return 0;
429: }
430:
431:
432:
433: /*************************************************
434: * Free store obtained by get_substring_list *
435: *************************************************/
436:
437: /* This function exists for the benefit of people calling PCRE from non-C
1.1.1.2 ! misho 438: programs that can call its functions, but not free() or (PUBL(free))()
! 439: directly.
1.1 misho 440:
441: Argument: the result of a previous pcre_get_substring_list()
442: Returns: nothing
443: */
444:
1.1.1.2 ! misho 445: #ifdef COMPILE_PCRE8
1.1 misho 446: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
447: pcre_free_substring_list(const char **pointer)
1.1.1.2 ! misho 448: #else
! 449: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
! 450: pcre16_free_substring_list(PCRE_SPTR16 *pointer)
! 451: #endif
1.1 misho 452: {
1.1.1.2 ! misho 453: (PUBL(free))((void *)pointer);
1.1 misho 454: }
455:
456:
457:
458: /*************************************************
459: * Copy captured string to new store *
460: *************************************************/
461:
462: /* This function copies a single captured substring into a piece of new
463: store
464:
465: Arguments:
466: subject the subject string that was matched
467: ovector pointer to the offsets table
468: stringcount the number of substrings that were captured
469: (i.e. the yield of the pcre_exec call, unless
470: that was zero, in which case it should be 1/3
471: of the offset table size)
472: stringnumber the number of the required substring
473: stringptr where to put a pointer to the substring
474:
475: Returns: if successful:
476: the length of the string, not including the zero that
477: is put on the end; can be zero
478: if not successful:
479: PCRE_ERROR_NOMEMORY (-6) failed to get store
480: PCRE_ERROR_NOSUBSTRING (-7) substring not present
481: */
482:
1.1.1.2 ! misho 483: #ifdef COMPILE_PCRE8
1.1 misho 484: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
485: pcre_get_substring(const char *subject, int *ovector, int stringcount,
486: int stringnumber, const char **stringptr)
1.1.1.2 ! misho 487: #else
! 488: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 489: pcre16_get_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
! 490: int stringnumber, PCRE_SPTR16 *stringptr)
! 491: #endif
1.1 misho 492: {
493: int yield;
1.1.1.2 ! misho 494: pcre_uchar *substring;
1.1 misho 495: if (stringnumber < 0 || stringnumber >= stringcount)
496: return PCRE_ERROR_NOSUBSTRING;
497: stringnumber *= 2;
498: yield = ovector[stringnumber+1] - ovector[stringnumber];
1.1.1.2 ! misho 499: substring = (pcre_uchar *)(PUBL(malloc))(IN_UCHARS(yield + 1));
1.1 misho 500: if (substring == NULL) return PCRE_ERROR_NOMEMORY;
1.1.1.2 ! misho 501: memcpy(substring, subject + ovector[stringnumber], IN_UCHARS(yield));
1.1 misho 502: substring[yield] = 0;
1.1.1.2 ! misho 503: #ifdef COMPILE_PCRE8
! 504: *stringptr = (const char *)substring;
! 505: #else
! 506: *stringptr = (PCRE_SPTR16)substring;
! 507: #endif
1.1 misho 508: return yield;
509: }
510:
511:
512:
513: /*************************************************
514: * Copy named captured string to new store *
515: *************************************************/
516:
517: /* This function copies a single captured substring, identified by name, into
518: new store. If the regex permits duplicate names, the first substring that is
519: set is chosen.
520:
521: Arguments:
522: code the compiled regex
523: subject the subject string that was matched
524: ovector pointer to the offsets table
525: stringcount the number of substrings that were captured
526: (i.e. the yield of the pcre_exec call, unless
527: that was zero, in which case it should be 1/3
528: of the offset table size)
529: stringname the name of the required substring
530: stringptr where to put the pointer
531:
532: Returns: if successful:
533: the length of the copied string, not including the zero
534: that is put on the end; can be zero
535: if not successful:
536: PCRE_ERROR_NOMEMORY (-6) couldn't get memory
537: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
538: */
539:
1.1.1.2 ! misho 540: #ifdef COMPILE_PCRE8
1.1 misho 541: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
1.1.1.2 ! misho 542: pcre_get_named_substring(const pcre *code, const char *subject,
! 543: int *ovector, int stringcount, const char *stringname,
! 544: const char **stringptr)
! 545: #else
! 546: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 547: pcre16_get_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
! 548: int *ovector, int stringcount, PCRE_SPTR16 stringname,
! 549: PCRE_SPTR16 *stringptr)
! 550: #endif
1.1 misho 551: {
552: int n = get_first_set(code, stringname, ovector);
553: if (n <= 0) return n;
1.1.1.2 ! misho 554: #ifdef COMPILE_PCRE8
1.1 misho 555: return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
1.1.1.2 ! misho 556: #else
! 557: return pcre16_get_substring(subject, ovector, stringcount, n, stringptr);
! 558: #endif
1.1 misho 559: }
560:
561:
562:
563:
564: /*************************************************
565: * Free store obtained by get_substring *
566: *************************************************/
567:
568: /* This function exists for the benefit of people calling PCRE from non-C
1.1.1.2 ! misho 569: programs that can call its functions, but not free() or (PUBL(free))()
! 570: directly.
1.1 misho 571:
572: Argument: the result of a previous pcre_get_substring()
573: Returns: nothing
574: */
575:
1.1.1.2 ! misho 576: #ifdef COMPILE_PCRE8
1.1 misho 577: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
578: pcre_free_substring(const char *pointer)
1.1.1.2 ! misho 579: #else
! 580: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
! 581: pcre16_free_substring(PCRE_SPTR16 pointer)
! 582: #endif
1.1 misho 583: {
1.1.1.2 ! misho 584: (PUBL(free))((void *)pointer);
1.1 misho 585: }
586:
587: /* 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