1 /*************************************************
2 * Perl-Compatible Regular Expressions *
3 *************************************************/
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.
8 Written by Philip Hazel
9 Copyright (c) 1997-2008 University of Cambridge
11 -----------------------------------------------------------------------------
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions are met:
15 * Redistributions of source code must retain the above copyright notice,
16 this list of conditions and the following disclaimer.
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.
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.
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 -----------------------------------------------------------------------------
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. */
50 #include "pcre_internal.h"
53 /*************************************************
54 * Find number for named string *
55 *************************************************/
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.
61 code the compiled regex
62 stringname the name whose number is required
64 Returns: the number of the named parentheses, or a negative number
65 (PCRE_ERROR_NOSUBSTRING) if not found
68 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
69 pcre_get_stringnumber(const pcre *code, const char *stringname)
76 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
78 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
80 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
82 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
88 int mid = (top + bot) / 2;
89 uschar *entry = nametable + entrysize*mid;
90 int c = strcmp(stringname, (char *)(entry + 2));
91 if (c == 0) return (entry[0] << 8) + entry[1];
92 if (c > 0) bot = mid + 1; else top = mid;
95 return PCRE_ERROR_NOSUBSTRING;
100 /*************************************************
101 * Find (multiple) entries for named string *
102 *************************************************/
104 /* This is used by the get_first_set() function below, as well as being
105 generally available. It is used when duplicated names are permitted.
108 code the compiled regex
109 stringname the name whose entries required
110 firstptr where to put the pointer to the first entry
111 lastptr where to put the pointer to the last entry
113 Returns: the length of each entry, or a negative number
114 (PCRE_ERROR_NOSUBSTRING) if not found
117 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
118 pcre_get_stringtable_entries(const pcre *code, const char *stringname,
119 char **firstptr, char **lastptr)
124 uschar *nametable, *lastentry;
126 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
128 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
130 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
132 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
135 lastentry = nametable + entrysize * (top - 1);
139 int mid = (top + bot) / 2;
140 uschar *entry = nametable + entrysize*mid;
141 int c = strcmp(stringname, (char *)(entry + 2));
144 uschar *first = entry;
145 uschar *last = entry;
146 while (first > nametable)
148 if (strcmp(stringname, (char *)(first - entrysize + 2)) != 0) break;
151 while (last < lastentry)
153 if (strcmp(stringname, (char *)(last + entrysize + 2)) != 0) break;
156 *firstptr = (char *)first;
157 *lastptr = (char *)last;
160 if (c > 0) bot = mid + 1; else top = mid;
163 return PCRE_ERROR_NOSUBSTRING;
168 /*************************************************
169 * Find first set of multiple named strings *
170 *************************************************/
172 /* This function allows for duplicate names in the table of named substrings.
173 It returns the number of the first one that was set in a pattern match.
176 code the compiled regex
177 stringname the name of the capturing substring
178 ovector the vector of matched substrings
180 Returns: the number of the first that is set,
181 or the number of the last one if none are set,
182 or a negative number on error
186 get_first_set(const pcre *code, const char *stringname, int *ovector)
188 const real_pcre *re = (const real_pcre *)code;
192 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
193 return pcre_get_stringnumber(code, stringname);
194 entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last);
195 if (entrysize <= 0) return entrysize;
196 for (entry = (uschar *)first; entry <= (uschar *)last; entry += entrysize)
198 int n = (entry[0] << 8) + entry[1];
199 if (ovector[n*2] >= 0) return n;
201 return (first[0] << 8) + first[1];
207 /*************************************************
208 * Copy captured string to given buffer *
209 *************************************************/
211 /* This function copies a single captured substring into a given buffer.
212 Note that we use memcpy() rather than strncpy() in case there are binary zeros
216 subject the subject string that was matched
217 ovector pointer to the offsets table
218 stringcount the number of substrings that were captured
219 (i.e. the yield of the pcre_exec call, unless
220 that was zero, in which case it should be 1/3
221 of the offset table size)
222 stringnumber the number of the required substring
223 buffer where to put the substring
224 size the size of the buffer
226 Returns: if successful:
227 the length of the copied string, not including the zero
228 that is put on the end; can be zero
230 PCRE_ERROR_NOMEMORY (-6) buffer too small
231 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
234 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
235 pcre_copy_substring(const char *subject, int *ovector, int stringcount,
236 int stringnumber, char *buffer, int size)
239 if (stringnumber < 0 || stringnumber >= stringcount)
240 return PCRE_ERROR_NOSUBSTRING;
242 yield = ovector[stringnumber+1] - ovector[stringnumber];
243 if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
244 memcpy(buffer, subject + ovector[stringnumber], yield);
251 /*************************************************
252 * Copy named captured string to given buffer *
253 *************************************************/
255 /* This function copies a single captured substring into a given buffer,
256 identifying it by name. If the regex permits duplicate names, the first
257 substring that is set is chosen.
260 code the compiled regex
261 subject the subject string that was matched
262 ovector pointer to the offsets table
263 stringcount the number of substrings that were captured
264 (i.e. the yield of the pcre_exec call, unless
265 that was zero, in which case it should be 1/3
266 of the offset table size)
267 stringname the name of the required substring
268 buffer where to put the substring
269 size the size of the buffer
271 Returns: if successful:
272 the length of the copied string, not including the zero
273 that is put on the end; can be zero
275 PCRE_ERROR_NOMEMORY (-6) buffer too small
276 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
279 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
280 pcre_copy_named_substring(const pcre *code, const char *subject, int *ovector,
281 int stringcount, const char *stringname, char *buffer, int size)
283 int n = get_first_set(code, stringname, ovector);
284 if (n <= 0) return n;
285 return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
290 /*************************************************
291 * Copy all captured strings to new store *
292 *************************************************/
294 /* This function gets one chunk of store and builds a list of pointers and all
295 of the captured substrings in it. A NULL pointer is put on the end of the list.
298 subject the subject string that was matched
299 ovector pointer to the offsets table
300 stringcount the number of substrings that were captured
301 (i.e. the yield of the pcre_exec call, unless
302 that was zero, in which case it should be 1/3
303 of the offset table size)
304 listptr set to point to the list of pointers
306 Returns: if successful: 0
308 PCRE_ERROR_NOMEMORY (-6) failed to get store
311 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
312 pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
313 const char ***listptr)
316 int size = sizeof(char *);
317 int double_count = stringcount * 2;
321 for (i = 0; i < double_count; i += 2)
322 size += sizeof(char *) + ovector[i+1] - ovector[i] + 1;
324 stringlist = (char **)(pcre_malloc)(size);
325 if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
327 *listptr = (const char **)stringlist;
328 p = (char *)(stringlist + stringcount + 1);
330 for (i = 0; i < double_count; i += 2)
332 int len = ovector[i+1] - ovector[i];
333 memcpy(p, subject + ovector[i], len);
345 /*************************************************
346 * Free store obtained by get_substring_list *
347 *************************************************/
349 /* This function exists for the benefit of people calling PCRE from non-C
350 programs that can call its functions, but not free() or (pcre_free)() directly.
352 Argument: the result of a previous pcre_get_substring_list()
356 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
357 pcre_free_substring_list(const char **pointer)
359 (pcre_free)((void *)pointer);
364 /*************************************************
365 * Copy captured string to new store *
366 *************************************************/
368 /* This function copies a single captured substring into a piece of new
372 subject the subject string that was matched
373 ovector pointer to the offsets table
374 stringcount the number of substrings that were captured
375 (i.e. the yield of the pcre_exec call, unless
376 that was zero, in which case it should be 1/3
377 of the offset table size)
378 stringnumber the number of the required substring
379 stringptr where to put a pointer to the substring
381 Returns: if successful:
382 the length of the string, not including the zero that
383 is put on the end; can be zero
385 PCRE_ERROR_NOMEMORY (-6) failed to get store
386 PCRE_ERROR_NOSUBSTRING (-7) substring not present
389 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
390 pcre_get_substring(const char *subject, int *ovector, int stringcount,
391 int stringnumber, const char **stringptr)
395 if (stringnumber < 0 || stringnumber >= stringcount)
396 return PCRE_ERROR_NOSUBSTRING;
398 yield = ovector[stringnumber+1] - ovector[stringnumber];
399 substring = (char *)(pcre_malloc)(yield + 1);
400 if (substring == NULL) return PCRE_ERROR_NOMEMORY;
401 memcpy(substring, subject + ovector[stringnumber], yield);
402 substring[yield] = 0;
403 *stringptr = substring;
409 /*************************************************
410 * Copy named captured string to new store *
411 *************************************************/
413 /* This function copies a single captured substring, identified by name, into
414 new store. If the regex permits duplicate names, the first substring that is
418 code the compiled regex
419 subject the subject string that was matched
420 ovector pointer to the offsets table
421 stringcount the number of substrings that were captured
422 (i.e. the yield of the pcre_exec call, unless
423 that was zero, in which case it should be 1/3
424 of the offset table size)
425 stringname the name of the required substring
426 stringptr where to put the pointer
428 Returns: if successful:
429 the length of the copied string, not including the zero
430 that is put on the end; can be zero
432 PCRE_ERROR_NOMEMORY (-6) couldn't get memory
433 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
436 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
437 pcre_get_named_substring(const pcre *code, const char *subject, int *ovector,
438 int stringcount, const char *stringname, const char **stringptr)
440 int n = get_first_set(code, stringname, ovector);
441 if (n <= 0) return n;
442 return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
448 /*************************************************
449 * Free store obtained by get_substring *
450 *************************************************/
452 /* This function exists for the benefit of people calling PCRE from non-C
453 programs that can call its functions, but not free() or (pcre_free)() directly.
455 Argument: the result of a previous pcre_get_substring()
459 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
460 pcre_free_substring(const char *pointer)
462 (pcre_free)((void *)pointer);
465 /* End of pcre_get.c */