tags/pcre-6.0/pcre_get.c

/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
           Copyright (c) 1997-2005 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


/* This module contains some convenience functions for extracting substrings
from the subject string after a regex match has succeeded. The original idea
for these functions came from Scott Wimer. */


#include "pcre_internal.h"


/*************************************************
*           Find number for named string         *
*************************************************/

/* This function is used by the two extraction functions below, as well
as being generally available.

Arguments:
  code        the compiled regex
  stringname  the name whose number is required

Returns:      the number of the named parentheses, or a negative number
                (PCRE_ERROR_NOSUBSTRING) if not found
*/

int
pcre_get_stringnumber(const pcre *code, const char *stringname)
{
int rc;
int entrysize;
int top, bot;
uschar *nametable;

if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
  return rc;
if (top <= 0) return PCRE_ERROR_NOSUBSTRING;

if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
  return rc;
if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
  return rc;

bot = 0;
while (top > bot)
  {
  int mid = (top + bot) / 2;
  uschar *entry = nametable + entrysize*mid;
  int c = strcmp(stringname, (char *)(entry + 2));
  if (c == 0) return (entry[0] << 8) + entry[1];
  if (c > 0) bot = mid + 1; else top = mid;
  }

return PCRE_ERROR_NOSUBSTRING;
}


/*************************************************
*      Copy captured string to given buffer      *
*************************************************/

/* This function copies a single captured substring into a given buffer.
Note that we use memcpy() rather than strncpy() in case there are binary zeros
in the string.

Arguments:
  subject        the subject string that was matched
  ovector        pointer to the offsets table
  stringcount    the number of substrings that were captured
                   (i.e. the yield of the pcre_exec call, unless
                   that was zero, in which case it should be 1/3
                   of the offset table size)
  stringnumber   the number of the required substring
  buffer         where to put the substring
  size           the size of the buffer

Returns:         if successful:
                   the length of the copied string, not including the zero
                   that is put on the end; can be zero
                 if not successful:
                   PCRE_ERROR_NOMEMORY (-6) buffer too small
                   PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
*/

int
pcre_copy_substring(const char *subject, int *ovector, int stringcount,
  int stringnumber, char *buffer, int size)
{
int yield;
if (stringnumber < 0 || stringnumber >= stringcount)
  return PCRE_ERROR_NOSUBSTRING;
stringnumber *= 2;
yield = ovector[stringnumber+1] - ovector[stringnumber];
if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
memcpy(buffer, subject + ovector[stringnumber], yield);
buffer[yield] = 0;
return yield;
}


/*************************************************
*   Copy named captured string to given buffer   *
*************************************************/

/* This function copies a single captured substring into a given buffer,
identifying it by name.

Arguments:
  code           the compiled regex
  subject        the subject string that was matched
  ovector        pointer to the offsets table
  stringcount    the number of substrings that were captured
                   (i.e. the yield of the pcre_exec call, unless
                   that was zero, in which case it should be 1/3
                   of the offset table size)
  stringname     the name of the required substring
  buffer         where to put the substring
  size           the size of the buffer

Returns:         if successful:
                   the length of the copied string, not including the zero
                   that is put on the end; can be zero
                 if not successful:
                   PCRE_ERROR_NOMEMORY (-6) buffer too small
                   PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
*/

int
pcre_copy_named_substring(const pcre *code, const char *subject, int *ovector,
  int stringcount, const char *stringname, char *buffer, int size)
{
int n = pcre_get_stringnumber(code, stringname);
if (n <= 0) return n;
return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
}


/*************************************************
*      Copy all captured strings to new store    *
*************************************************/

/* This function gets one chunk of store and builds a list of pointers and all
of the captured substrings in it. A NULL pointer is put on the end of the list.

Arguments:
  subject        the subject string that was matched
  ovector        pointer to the offsets table
  stringcount    the number of substrings that were captured
                   (i.e. the yield of the pcre_exec call, unless
                   that was zero, in which case it should be 1/3
                   of the offset table size)
  listptr        set to point to the list of pointers

Returns:         if successful: 0
                 if not successful:
                   PCRE_ERROR_NOMEMORY (-6) failed to get store
*/

int
pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
  const char ***listptr)
{
int i;
int size = sizeof(char *);
int double_count = stringcount * 2;
char **stringlist;
char *p;

for (i = 0; i < double_count; i += 2)
  size += sizeof(char *) + ovector[i+1] - ovector[i] + 1;

stringlist = (char **)(pcre_malloc)(size);
if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;

*listptr = (const char **)stringlist;
p = (char *)(stringlist + stringcount + 1);

for (i = 0; i < double_count; i += 2)
  {
  int len = ovector[i+1] - ovector[i];
  memcpy(p, subject + ovector[i], len);
  *stringlist++ = p;
  p += len;
  *p++ = 0;
  }

*stringlist = NULL;
return 0;
}


/*************************************************
*   Free store obtained by get_substring_list    *
*************************************************/

/* This function exists for the benefit of people calling PCRE from non-C
programs that can call its functions, but not free() or (pcre_free)() directly.

Argument:   the result of a previous pcre_get_substring_list()
Returns:    nothing
*/

void
pcre_free_substring_list(const char **pointer)
{
(pcre_free)((void *)pointer);
}


/*************************************************
*      Copy captured string to new store         *
*************************************************/

/* This function copies a single captured substring into a piece of new
store

Arguments:
  subject        the subject string that was matched
  ovector        pointer to the offsets table
  stringcount    the number of substrings that were captured
                   (i.e. the yield of the pcre_exec call, unless
                   that was zero, in which case it should be 1/3
                   of the offset table size)
  stringnumber   the number of the required substring
  stringptr      where to put a pointer to the substring

Returns:         if successful:
                   the length of the string, not including the zero that
                   is put on the end; can be zero
                 if not successful:
                   PCRE_ERROR_NOMEMORY (-6) failed to get store
                   PCRE_ERROR_NOSUBSTRING (-7) substring not present
*/

int
pcre_get_substring(const char *subject, int *ovector, int stringcount,
  int stringnumber, const char **stringptr)
{
int yield;
char *substring;
if (stringnumber < 0 || stringnumber >= stringcount)
  return PCRE_ERROR_NOSUBSTRING;
stringnumber *= 2;
yield = ovector[stringnumber+1] - ovector[stringnumber];
substring = (char *)(pcre_malloc)(yield + 1);
if (substring == NULL) return PCRE_ERROR_NOMEMORY;
memcpy(substring, subject + ovector[stringnumber], yield);
substring[yield] = 0;
*stringptr = substring;
return yield;
}


/*************************************************
*   Copy named captured string to new store      *
*************************************************/

/* This function copies a single captured substring, identified by name, into
new store.

Arguments:
  code           the compiled regex
  subject        the subject string that was matched
  ovector        pointer to the offsets table
  stringcount    the number of substrings that were captured
                   (i.e. the yield of the pcre_exec call, unless
                   that was zero, in which case it should be 1/3
                   of the offset table size)
  stringname     the name of the required substring
  stringptr      where to put the pointer

Returns:         if successful:
                   the length of the copied string, not including the zero
                   that is put on the end; can be zero
                 if not successful:
                   PCRE_ERROR_NOMEMORY (-6) couldn't get memory
                   PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
*/

int
pcre_get_named_substring(const pcre *code, const char *subject, int *ovector,
  int stringcount, const char *stringname, const char **stringptr)
{
int n = pcre_get_stringnumber(code, stringname);
if (n <= 0) return n;
return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
}


/*************************************************
*       Free store obtained by get_substring     *
*************************************************/

/* This function exists for the benefit of people calling PCRE from non-C
programs that can call its functions, but not free() or (pcre_free)() directly.

Argument:   the result of a previous pcre_get_substring()
Returns:    nothing
*/

void
pcre_free_substring(const char *pointer)
{
(pcre_free)((void *)pointer);
}

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