Annotation of embedaddon/php/ext/pcre/pcrelib/pcre_get.c, revision 1.1.1.1
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
9: Copyright (c) 1997-2008 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 "config.h"
47:
48: #include "pcre_internal.h"
49:
50:
51: /*************************************************
52: * Find number for named string *
53: *************************************************/
54:
55: /* This function is used by the get_first_set() function below, as well
56: as being generally available. It assumes that names are unique.
57:
58: Arguments:
59: code the compiled regex
60: stringname the name whose number is required
61:
62: Returns: the number of the named parentheses, or a negative number
63: (PCRE_ERROR_NOSUBSTRING) if not found
64: */
65:
66: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
67: pcre_get_stringnumber(const pcre *code, const char *stringname)
68: {
69: int rc;
70: int entrysize;
71: int top, bot;
72: uschar *nametable;
73:
74: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
75: return rc;
76: if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
77:
78: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
79: return rc;
80: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
81: return rc;
82:
83: bot = 0;
84: while (top > bot)
85: {
86: int mid = (top + bot) / 2;
87: uschar *entry = nametable + entrysize*mid;
88: int c = strcmp(stringname, (char *)(entry + 2));
89: if (c == 0) return (entry[0] << 8) + entry[1];
90: if (c > 0) bot = mid + 1; else top = mid;
91: }
92:
93: return PCRE_ERROR_NOSUBSTRING;
94: }
95:
96:
97:
98: /*************************************************
99: * Find (multiple) entries for named string *
100: *************************************************/
101:
102: /* This is used by the get_first_set() function below, as well as being
103: generally available. It is used when duplicated names are permitted.
104:
105: Arguments:
106: code the compiled regex
107: stringname the name whose entries required
108: firstptr where to put the pointer to the first entry
109: lastptr where to put the pointer to the last entry
110:
111: Returns: the length of each entry, or a negative number
112: (PCRE_ERROR_NOSUBSTRING) if not found
113: */
114:
115: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
116: pcre_get_stringtable_entries(const pcre *code, const char *stringname,
117: char **firstptr, char **lastptr)
118: {
119: int rc;
120: int entrysize;
121: int top, bot;
122: uschar *nametable, *lastentry;
123:
124: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
125: return rc;
126: if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
127:
128: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
129: return rc;
130: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
131: return rc;
132:
133: lastentry = nametable + entrysize * (top - 1);
134: bot = 0;
135: while (top > bot)
136: {
137: int mid = (top + bot) / 2;
138: uschar *entry = nametable + entrysize*mid;
139: int c = strcmp(stringname, (char *)(entry + 2));
140: if (c == 0)
141: {
142: uschar *first = entry;
143: uschar *last = entry;
144: while (first > nametable)
145: {
146: if (strcmp(stringname, (char *)(first - entrysize + 2)) != 0) break;
147: first -= entrysize;
148: }
149: while (last < lastentry)
150: {
151: if (strcmp(stringname, (char *)(last + entrysize + 2)) != 0) break;
152: last += entrysize;
153: }
154: *firstptr = (char *)first;
155: *lastptr = (char *)last;
156: return entrysize;
157: }
158: if (c > 0) bot = mid + 1; else top = mid;
159: }
160:
161: return PCRE_ERROR_NOSUBSTRING;
162: }
163:
164:
165:
166: /*************************************************
167: * Find first set of multiple named strings *
168: *************************************************/
169:
170: /* This function allows for duplicate names in the table of named substrings.
171: It returns the number of the first one that was set in a pattern match.
172:
173: Arguments:
174: code the compiled regex
175: stringname the name of the capturing substring
176: ovector the vector of matched substrings
177:
178: Returns: the number of the first that is set,
179: or the number of the last one if none are set,
180: or a negative number on error
181: */
182:
183: static int
184: get_first_set(const pcre *code, const char *stringname, int *ovector)
185: {
186: const real_pcre *re = (const real_pcre *)code;
187: int entrysize;
188: char *first, *last;
189: uschar *entry;
190: if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
191: return pcre_get_stringnumber(code, stringname);
192: entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last);
193: if (entrysize <= 0) return entrysize;
194: for (entry = (uschar *)first; entry <= (uschar *)last; entry += entrysize)
195: {
196: int n = (entry[0] << 8) + entry[1];
197: if (ovector[n*2] >= 0) return n;
198: }
199: return (first[0] << 8) + first[1];
200: }
201:
202:
203:
204:
205: /*************************************************
206: * Copy captured string to given buffer *
207: *************************************************/
208:
209: /* This function copies a single captured substring into a given buffer.
210: Note that we use memcpy() rather than strncpy() in case there are binary zeros
211: in the string.
212:
213: Arguments:
214: subject the subject string that was matched
215: ovector pointer to the offsets table
216: stringcount the number of substrings that were captured
217: (i.e. the yield of the pcre_exec call, unless
218: that was zero, in which case it should be 1/3
219: of the offset table size)
220: stringnumber the number of the required substring
221: buffer where to put the substring
222: size the size of the buffer
223:
224: Returns: if successful:
225: the length of the copied string, not including the zero
226: that is put on the end; can be zero
227: if not successful:
228: PCRE_ERROR_NOMEMORY (-6) buffer too small
229: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
230: */
231:
232: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
233: pcre_copy_substring(const char *subject, int *ovector, int stringcount,
234: int stringnumber, char *buffer, int size)
235: {
236: int yield;
237: if (stringnumber < 0 || stringnumber >= stringcount)
238: return PCRE_ERROR_NOSUBSTRING;
239: stringnumber *= 2;
240: yield = ovector[stringnumber+1] - ovector[stringnumber];
241: if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
242: memcpy(buffer, subject + ovector[stringnumber], yield);
243: buffer[yield] = 0;
244: return yield;
245: }
246:
247:
248:
249: /*************************************************
250: * Copy named captured string to given buffer *
251: *************************************************/
252:
253: /* This function copies a single captured substring into a given buffer,
254: identifying it by name. If the regex permits duplicate names, the first
255: substring that is set is chosen.
256:
257: Arguments:
258: code the compiled regex
259: subject the subject string that was matched
260: ovector pointer to the offsets table
261: stringcount the number of substrings that were captured
262: (i.e. the yield of the pcre_exec call, unless
263: that was zero, in which case it should be 1/3
264: of the offset table size)
265: stringname the name of the required substring
266: buffer where to put the substring
267: size the size of the buffer
268:
269: Returns: if successful:
270: the length of the copied string, not including the zero
271: that is put on the end; can be zero
272: if not successful:
273: PCRE_ERROR_NOMEMORY (-6) buffer too small
274: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
275: */
276:
277: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
278: pcre_copy_named_substring(const pcre *code, const char *subject, int *ovector,
279: int stringcount, const char *stringname, char *buffer, int size)
280: {
281: int n = get_first_set(code, stringname, ovector);
282: if (n <= 0) return n;
283: return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
284: }
285:
286:
287:
288: /*************************************************
289: * Copy all captured strings to new store *
290: *************************************************/
291:
292: /* This function gets one chunk of store and builds a list of pointers and all
293: of the captured substrings in it. A NULL pointer is put on the end of the list.
294:
295: Arguments:
296: subject the subject string that was matched
297: ovector pointer to the offsets table
298: stringcount the number of substrings that were captured
299: (i.e. the yield of the pcre_exec call, unless
300: that was zero, in which case it should be 1/3
301: of the offset table size)
302: listptr set to point to the list of pointers
303:
304: Returns: if successful: 0
305: if not successful:
306: PCRE_ERROR_NOMEMORY (-6) failed to get store
307: */
308:
309: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
310: pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
311: const char ***listptr)
312: {
313: int i;
314: int size = sizeof(char *);
315: int double_count = stringcount * 2;
316: char **stringlist;
317: char *p;
318:
319: for (i = 0; i < double_count; i += 2)
320: size += sizeof(char *) + ovector[i+1] - ovector[i] + 1;
321:
322: stringlist = (char **)(pcre_malloc)(size);
323: if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
324:
325: *listptr = (const char **)stringlist;
326: p = (char *)(stringlist + stringcount + 1);
327:
328: for (i = 0; i < double_count; i += 2)
329: {
330: int len = ovector[i+1] - ovector[i];
331: memcpy(p, subject + ovector[i], len);
332: *stringlist++ = p;
333: p += len;
334: *p++ = 0;
335: }
336:
337: *stringlist = NULL;
338: return 0;
339: }
340:
341:
342:
343: /*************************************************
344: * Free store obtained by get_substring_list *
345: *************************************************/
346:
347: /* This function exists for the benefit of people calling PCRE from non-C
348: programs that can call its functions, but not free() or (pcre_free)() directly.
349:
350: Argument: the result of a previous pcre_get_substring_list()
351: Returns: nothing
352: */
353:
354: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
355: pcre_free_substring_list(const char **pointer)
356: {
357: (pcre_free)((void *)pointer);
358: }
359:
360:
361:
362: /*************************************************
363: * Copy captured string to new store *
364: *************************************************/
365:
366: /* This function copies a single captured substring into a piece of new
367: store
368:
369: Arguments:
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: stringnumber the number of the required substring
377: stringptr where to put a pointer to the substring
378:
379: Returns: if successful:
380: the length of the string, not including the zero that
381: is put on the end; can be zero
382: if not successful:
383: PCRE_ERROR_NOMEMORY (-6) failed to get store
384: PCRE_ERROR_NOSUBSTRING (-7) substring not present
385: */
386:
387: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
388: pcre_get_substring(const char *subject, int *ovector, int stringcount,
389: int stringnumber, const char **stringptr)
390: {
391: int yield;
392: char *substring;
393: if (stringnumber < 0 || stringnumber >= stringcount)
394: return PCRE_ERROR_NOSUBSTRING;
395: stringnumber *= 2;
396: yield = ovector[stringnumber+1] - ovector[stringnumber];
397: substring = (char *)(pcre_malloc)(yield + 1);
398: if (substring == NULL) return PCRE_ERROR_NOMEMORY;
399: memcpy(substring, subject + ovector[stringnumber], yield);
400: substring[yield] = 0;
401: *stringptr = substring;
402: return yield;
403: }
404:
405:
406:
407: /*************************************************
408: * Copy named captured string to new store *
409: *************************************************/
410:
411: /* This function copies a single captured substring, identified by name, into
412: new store. If the regex permits duplicate names, the first substring that is
413: set is chosen.
414:
415: Arguments:
416: code the compiled regex
417: subject the subject string that was matched
418: ovector pointer to the offsets table
419: stringcount the number of substrings that were captured
420: (i.e. the yield of the pcre_exec call, unless
421: that was zero, in which case it should be 1/3
422: of the offset table size)
423: stringname the name of the required substring
424: stringptr where to put the pointer
425:
426: Returns: if successful:
427: the length of the copied string, not including the zero
428: that is put on the end; can be zero
429: if not successful:
430: PCRE_ERROR_NOMEMORY (-6) couldn't get memory
431: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
432: */
433:
434: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
435: pcre_get_named_substring(const pcre *code, const char *subject, int *ovector,
436: int stringcount, const char *stringname, const char **stringptr)
437: {
438: int n = get_first_set(code, stringname, ovector);
439: if (n <= 0) return n;
440: return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
441: }
442:
443:
444:
445:
446: /*************************************************
447: * Free store obtained by get_substring *
448: *************************************************/
449:
450: /* This function exists for the benefit of people calling PCRE from non-C
451: programs that can call its functions, but not free() or (pcre_free)() directly.
452:
453: Argument: the result of a previous pcre_get_substring()
454: Returns: nothing
455: */
456:
457: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
458: pcre_free_substring(const char *pointer)
459: {
460: (pcre_free)((void *)pointer);
461: }
462:
463: /* 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 / php / ext / pcre / pcrelib