95a4152d2fdedb860cbc7db4611fe3305759adef
[WebKit-https.git] / JavaScriptCore / pcre / pcre_get.c
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-2005 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 #include "pcre_internal.h"
47 #include <wtf/UnusedParam.h>
48
49
50 /*************************************************
51 *           Find number for named string         *
52 *************************************************/
53
54 /* This function is used by the two extraction functions below, as well
55 as being generally available.
56
57 Arguments:
58   code        the compiled regex
59   stringname  the name whose number is required
60
61 Returns:      the number of the named parentheses, or a negative number
62                 (PCRE_ERROR_NOSUBSTRING) if not found
63 */
64
65 int
66 pcre_get_stringnumber(const pcre *code, const pcre_char *stringname)
67 {
68 // FIXME: This doesn't work for UTF-16 because the name table has 8-bit characters in it!
69 #if !PCRE_UTF16
70 int rc;
71 int entrysize;
72 int top, bot;
73 uschar *nametable;
74
75 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
76   return rc;
77 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
78
79 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
80   return rc;
81 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
82   return rc;
83
84 bot = 0;
85 while (top > bot)
86   {
87   int mid = (top + bot) / 2;
88   uschar *entry = nametable + entrysize*mid;
89   int c = strcmp(stringname, (char *)(entry + 2));
90   if (c == 0) return (entry[0] << 8) + entry[1];
91   if (c > 0) bot = mid + 1; else top = mid;
92   }
93 #else
94  UNUSED_PARAM(code);
95  UNUSED_PARAM(stringname);
96 #endif
97
98 return PCRE_ERROR_NOSUBSTRING;
99 }
100
101
102
103 /*************************************************
104 *      Copy captured string to given buffer      *
105 *************************************************/
106
107 /* This function copies a single captured substring into a given buffer.
108 Note that we use memcpy() rather than strncpy() in case there are binary zeros
109 in the string.
110
111 Arguments:
112   subject        the subject string that was matched
113   ovector        pointer to the offsets table
114   stringcount    the number of substrings that were captured
115                    (i.e. the yield of the pcre_exec call, unless
116                    that was zero, in which case it should be 1/3
117                    of the offset table size)
118   stringnumber   the number of the required substring
119   buffer         where to put the substring
120   size           the size of the buffer
121
122 Returns:         if successful:
123                    the length of the copied string, not including the zero
124                    that is put on the end; can be zero
125                  if not successful:
126                    PCRE_ERROR_NOMEMORY (-6) buffer too small
127                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
128 */
129
130 int
131 pcre_copy_substring(const pcre_char *subject, int *ovector, int stringcount,
132   int stringnumber, pcre_char *buffer, int size)
133 {
134 int yield;
135 if (stringnumber < 0 || stringnumber >= stringcount)
136   return PCRE_ERROR_NOSUBSTRING;
137 stringnumber *= 2;
138 yield = ovector[stringnumber+1] - ovector[stringnumber];
139 if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
140 memcpy(buffer, subject + ovector[stringnumber], yield);
141 buffer[yield] = 0;
142 return yield;
143 }
144
145
146
147 /*************************************************
148 *   Copy named captured string to given buffer   *
149 *************************************************/
150
151 /* This function copies a single captured substring into a given buffer,
152 identifying it by name.
153
154 Arguments:
155   code           the compiled regex
156   subject        the subject string that was matched
157   ovector        pointer to the offsets table
158   stringcount    the number of substrings that were captured
159                    (i.e. the yield of the pcre_exec call, unless
160                    that was zero, in which case it should be 1/3
161                    of the offset table size)
162   stringname     the name of the required substring
163   buffer         where to put the substring
164   size           the size of the buffer
165
166 Returns:         if successful:
167                    the length of the copied string, not including the zero
168                    that is put on the end; can be zero
169                  if not successful:
170                    PCRE_ERROR_NOMEMORY (-6) buffer too small
171                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
172 */
173
174 int
175 pcre_copy_named_substring(const pcre *code, const pcre_char *subject, int *ovector,
176   int stringcount, const pcre_char *stringname, pcre_char *buffer, int size)
177 {
178 int n = pcre_get_stringnumber(code, stringname);
179 if (n <= 0) return n;
180 return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
181 }
182
183
184
185 /*************************************************
186 *      Copy all captured strings to new store    *
187 *************************************************/
188
189 /* This function gets one chunk of store and builds a list of pointers and all
190 of the captured substrings in it. A NULL pointer is put on the end of the list.
191
192 Arguments:
193   subject        the subject string that was matched
194   ovector        pointer to the offsets table
195   stringcount    the number of substrings that were captured
196                    (i.e. the yield of the pcre_exec call, unless
197                    that was zero, in which case it should be 1/3
198                    of the offset table size)
199   listptr        set to point to the list of pointers
200
201 Returns:         if successful: 0
202                  if not successful:
203                    PCRE_ERROR_NOMEMORY (-6) failed to get store
204 */
205
206 int
207 pcre_get_substring_list(const pcre_char *subject, int *ovector, int stringcount,
208   const pcre_char ***listptr)
209 {
210 int i;
211 int size = sizeof(char *);
212 int double_count = stringcount * 2;
213 pcre_char **stringlist;
214 pcre_char *p;
215
216 for (i = 0; i < double_count; i += 2)
217   size += sizeof(pcre_char *) + (ovector[i+1] - ovector[i] + 1) * sizeof(pcre_char);
218
219 stringlist = (pcre_char **)(pcre_malloc)(size);
220 if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
221
222 *listptr = (const pcre_char **)stringlist;
223 p = (pcre_char *)(stringlist + stringcount + 1);
224
225 for (i = 0; i < double_count; i += 2)
226   {
227   int len = ovector[i+1] - ovector[i];
228   memcpy(p, subject + ovector[i], len * sizeof(pcre_char));
229   *stringlist++ = p;
230   p += len;
231   *p++ = 0;
232   }
233
234 *stringlist = NULL;
235 return 0;
236 }
237
238
239
240 /*************************************************
241 *   Free store obtained by get_substring_list    *
242 *************************************************/
243
244 /* This function exists for the benefit of people calling PCRE from non-C
245 programs that can call its functions, but not free() or (pcre_free)() directly.
246
247 Argument:   the result of a previous pcre_get_substring_list()
248 Returns:    nothing
249 */
250
251 void
252 pcre_free_substring_list(const pcre_char **pointer)
253 {
254 (pcre_free)((void *)pointer);
255 }
256
257
258
259 /*************************************************
260 *      Copy captured string to new store         *
261 *************************************************/
262
263 /* This function copies a single captured substring into a piece of new
264 store
265
266 Arguments:
267   subject        the subject string that was matched
268   ovector        pointer to the offsets table
269   stringcount    the number of substrings that were captured
270                    (i.e. the yield of the pcre_exec call, unless
271                    that was zero, in which case it should be 1/3
272                    of the offset table size)
273   stringnumber   the number of the required substring
274   stringptr      where to put a pointer to the substring
275
276 Returns:         if successful:
277                    the length of the string, not including the zero that
278                    is put on the end; can be zero
279                  if not successful:
280                    PCRE_ERROR_NOMEMORY (-6) failed to get store
281                    PCRE_ERROR_NOSUBSTRING (-7) substring not present
282 */
283
284 int
285 pcre_get_substring(const pcre_char *subject, int *ovector, int stringcount,
286   int stringnumber, const pcre_char **stringptr)
287 {
288 int yield;
289 pcre_char *substring;
290 if (stringnumber < 0 || stringnumber >= stringcount)
291   return PCRE_ERROR_NOSUBSTRING;
292 stringnumber *= 2;
293 yield = ovector[stringnumber+1] - ovector[stringnumber];
294 substring = (pcre_char *)(pcre_malloc)((yield + 1) * sizeof(pcre_char));
295 if (substring == NULL) return PCRE_ERROR_NOMEMORY;
296 memcpy(substring, subject + ovector[stringnumber], yield * sizeof(pcre_char));
297 substring[yield] = 0;
298 *stringptr = substring;
299 return yield;
300 }
301
302
303
304 /*************************************************
305 *   Copy named captured string to new store      *
306 *************************************************/
307
308 /* This function copies a single captured substring, identified by name, into
309 new store.
310
311 Arguments:
312   code           the compiled regex
313   subject        the subject string that was matched
314   ovector        pointer to the offsets table
315   stringcount    the number of substrings that were captured
316                    (i.e. the yield of the pcre_exec call, unless
317                    that was zero, in which case it should be 1/3
318                    of the offset table size)
319   stringname     the name of the required substring
320   stringptr      where to put the pointer
321
322 Returns:         if successful:
323                    the length of the copied string, not including the zero
324                    that is put on the end; can be zero
325                  if not successful:
326                    PCRE_ERROR_NOMEMORY (-6) couldn't get memory
327                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
328 */
329
330 int
331 pcre_get_named_substring(const pcre *code, const pcre_char *subject, int *ovector,
332   int stringcount, const pcre_char *stringname, const pcre_char **stringptr)
333 {
334 int n = pcre_get_stringnumber(code, stringname);
335 if (n <= 0) return n;
336 return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
337 }
338
339
340
341
342 /*************************************************
343 *       Free store obtained by get_substring     *
344 *************************************************/
345
346 /* This function exists for the benefit of people calling PCRE from non-C
347 programs that can call its functions, but not free() or (pcre_free)() directly.
348
349 Argument:   the result of a previous pcre_get_substring()
350 Returns:    nothing
351 */
352
353 void
354 pcre_free_substring(const pcre_char *pointer)
355 {
356 (pcre_free)((void *)pointer);
357 }
358
359 /* End of pcre_get.c */