Annotation of embedaddon/pcre/pcre_get.c, revision 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: #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:
! 68: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 69: pcre_get_stringnumber(const pcre *code, const char *stringname)
! 70: {
! 71: int rc;
! 72: int entrysize;
! 73: int top, bot;
! 74: uschar *nametable;
! 75:
! 76: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
! 77: return rc;
! 78: if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
! 79:
! 80: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
! 81: return rc;
! 82: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
! 83: return rc;
! 84:
! 85: bot = 0;
! 86: while (top > bot)
! 87: {
! 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;
! 93: }
! 94:
! 95: return PCRE_ERROR_NOSUBSTRING;
! 96: }
! 97:
! 98:
! 99:
! 100: /*************************************************
! 101: * Find (multiple) entries for named string *
! 102: *************************************************/
! 103:
! 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.
! 106:
! 107: Arguments:
! 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
! 112:
! 113: Returns: the length of each entry, or a negative number
! 114: (PCRE_ERROR_NOSUBSTRING) if not found
! 115: */
! 116:
! 117: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 118: pcre_get_stringtable_entries(const pcre *code, const char *stringname,
! 119: char **firstptr, char **lastptr)
! 120: {
! 121: int rc;
! 122: int entrysize;
! 123: int top, bot;
! 124: uschar *nametable, *lastentry;
! 125:
! 126: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
! 127: return rc;
! 128: if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
! 129:
! 130: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
! 131: return rc;
! 132: if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
! 133: return rc;
! 134:
! 135: lastentry = nametable + entrysize * (top - 1);
! 136: bot = 0;
! 137: while (top > bot)
! 138: {
! 139: int mid = (top + bot) / 2;
! 140: uschar *entry = nametable + entrysize*mid;
! 141: int c = strcmp(stringname, (char *)(entry + 2));
! 142: if (c == 0)
! 143: {
! 144: uschar *first = entry;
! 145: uschar *last = entry;
! 146: while (first > nametable)
! 147: {
! 148: if (strcmp(stringname, (char *)(first - entrysize + 2)) != 0) break;
! 149: first -= entrysize;
! 150: }
! 151: while (last < lastentry)
! 152: {
! 153: if (strcmp(stringname, (char *)(last + entrysize + 2)) != 0) break;
! 154: last += entrysize;
! 155: }
! 156: *firstptr = (char *)first;
! 157: *lastptr = (char *)last;
! 158: return entrysize;
! 159: }
! 160: if (c > 0) bot = mid + 1; else top = mid;
! 161: }
! 162:
! 163: return PCRE_ERROR_NOSUBSTRING;
! 164: }
! 165:
! 166:
! 167:
! 168: /*************************************************
! 169: * Find first set of multiple named strings *
! 170: *************************************************/
! 171:
! 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.
! 174:
! 175: Arguments:
! 176: code the compiled regex
! 177: stringname the name of the capturing substring
! 178: ovector the vector of matched substrings
! 179:
! 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
! 183: */
! 184:
! 185: static int
! 186: get_first_set(const pcre *code, const char *stringname, int *ovector)
! 187: {
! 188: const real_pcre *re = (const real_pcre *)code;
! 189: int entrysize;
! 190: char *first, *last;
! 191: uschar *entry;
! 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)
! 197: {
! 198: int n = (entry[0] << 8) + entry[1];
! 199: if (ovector[n*2] >= 0) return n;
! 200: }
! 201: return (first[0] << 8) + first[1];
! 202: }
! 203:
! 204:
! 205:
! 206:
! 207: /*************************************************
! 208: * Copy captured string to given buffer *
! 209: *************************************************/
! 210:
! 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
! 213: in the string.
! 214:
! 215: Arguments:
! 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
! 225:
! 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
! 229: if not successful:
! 230: PCRE_ERROR_NOMEMORY (-6) buffer too small
! 231: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
! 232: */
! 233:
! 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)
! 237: {
! 238: int yield;
! 239: if (stringnumber < 0 || stringnumber >= stringcount)
! 240: return PCRE_ERROR_NOSUBSTRING;
! 241: stringnumber *= 2;
! 242: yield = ovector[stringnumber+1] - ovector[stringnumber];
! 243: if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
! 244: memcpy(buffer, subject + ovector[stringnumber], yield);
! 245: buffer[yield] = 0;
! 246: return yield;
! 247: }
! 248:
! 249:
! 250:
! 251: /*************************************************
! 252: * Copy named captured string to given buffer *
! 253: *************************************************/
! 254:
! 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.
! 258:
! 259: Arguments:
! 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
! 270:
! 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
! 274: if not successful:
! 275: PCRE_ERROR_NOMEMORY (-6) buffer too small
! 276: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
! 277: */
! 278:
! 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)
! 282: {
! 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);
! 286: }
! 287:
! 288:
! 289:
! 290: /*************************************************
! 291: * Copy all captured strings to new store *
! 292: *************************************************/
! 293:
! 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.
! 296:
! 297: Arguments:
! 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
! 305:
! 306: Returns: if successful: 0
! 307: if not successful:
! 308: PCRE_ERROR_NOMEMORY (-6) failed to get store
! 309: */
! 310:
! 311: PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
! 312: pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
! 313: const char ***listptr)
! 314: {
! 315: int i;
! 316: int size = sizeof(char *);
! 317: int double_count = stringcount * 2;
! 318: char **stringlist;
! 319: char *p;
! 320:
! 321: for (i = 0; i < double_count; i += 2)
! 322: size += sizeof(char *) + ovector[i+1] - ovector[i] + 1;
! 323:
! 324: stringlist = (char **)(pcre_malloc)(size);
! 325: if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
! 326:
! 327: *listptr = (const char **)stringlist;
! 328: p = (char *)(stringlist + stringcount + 1);
! 329:
! 330: for (i = 0; i < double_count; i += 2)
! 331: {
! 332: int len = ovector[i+1] - ovector[i];
! 333: memcpy(p, subject + ovector[i], len);
! 334: *stringlist++ = p;
! 335: p += len;
! 336: *p++ = 0;
! 337: }
! 338:
! 339: *stringlist = NULL;
! 340: return 0;
! 341: }
! 342:
! 343:
! 344:
! 345: /*************************************************
! 346: * Free store obtained by get_substring_list *
! 347: *************************************************/
! 348:
! 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.
! 351:
! 352: Argument: the result of a previous pcre_get_substring_list()
! 353: Returns: nothing
! 354: */
! 355:
! 356: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
! 357: pcre_free_substring_list(const char **pointer)
! 358: {
! 359: (pcre_free)((void *)pointer);
! 360: }
! 361:
! 362:
! 363:
! 364: /*************************************************
! 365: * Copy captured string to new store *
! 366: *************************************************/
! 367:
! 368: /* This function copies a single captured substring into a piece of new
! 369: store
! 370:
! 371: Arguments:
! 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
! 380:
! 381: Returns: if successful:
! 382: the length of the string, not including the zero that
! 383: is put on the end; can be zero
! 384: if not successful:
! 385: PCRE_ERROR_NOMEMORY (-6) failed to get store
! 386: PCRE_ERROR_NOSUBSTRING (-7) substring not present
! 387: */
! 388:
! 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)
! 392: {
! 393: int yield;
! 394: char *substring;
! 395: if (stringnumber < 0 || stringnumber >= stringcount)
! 396: return PCRE_ERROR_NOSUBSTRING;
! 397: stringnumber *= 2;
! 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;
! 404: return yield;
! 405: }
! 406:
! 407:
! 408:
! 409: /*************************************************
! 410: * Copy named captured string to new store *
! 411: *************************************************/
! 412:
! 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
! 415: set is chosen.
! 416:
! 417: Arguments:
! 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
! 427:
! 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
! 431: if not successful:
! 432: PCRE_ERROR_NOMEMORY (-6) couldn't get memory
! 433: PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
! 434: */
! 435:
! 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)
! 439: {
! 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);
! 443: }
! 444:
! 445:
! 446:
! 447:
! 448: /*************************************************
! 449: * Free store obtained by get_substring *
! 450: *************************************************/
! 451:
! 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.
! 454:
! 455: Argument: the result of a previous pcre_get_substring()
! 456: Returns: nothing
! 457: */
! 458:
! 459: PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
! 460: pcre_free_substring(const char *pointer)
! 461: {
! 462: (pcre_free)((void *)pointer);
! 463: }
! 464:
! 465: /* 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