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-2012 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 #if defined COMPILE_PCRE8
  69 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
  70 pcre_get_stringnumber(const pcre *code, const char *stringname)
  71 #elif defined COMPILE_PCRE16
  72 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
  73 pcre16_get_stringnumber(const pcre16 *code, PCRE_SPTR16 stringname)
  74 #elif defined COMPILE_PCRE32
  75 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
  76 pcre32_get_stringnumber(const pcre32 *code, PCRE_SPTR32 stringname)
  77 #endif
  78 {
  79 int rc;
  80 int entrysize;
  81 int top, bot;
  82 pcre_uchar *nametable;
  83
  84 #ifdef COMPILE_PCRE8
  85 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
  86   return rc;
  87 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
  88
  89 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
  90   return rc;
  91 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
  92   return rc;
  93 #endif
  94 #ifdef COMPILE_PCRE16
  95 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
  96   return rc;
  97 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
  98
  99 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
 100   return rc;
 101 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
 102   return rc;
 103 #endif
 104 #ifdef COMPILE_PCRE32
 105 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
 106   return rc;
 107 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
 108
 109 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
 110   return rc;
 111 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
 112   return rc;
 113 #endif
 114
 115 bot = 0;
 116 while (top > bot)
 117   {
 118   int mid = (top + bot) / 2;
 119   pcre_uchar *entry = nametable + entrysize*mid;
 120   int c = STRCMP_UC_UC((pcre_uchar *)stringname,
 121     (pcre_uchar *)(entry + IMM2_SIZE));
 122   if (c == 0) return GET2(entry, 0);
 123   if (c > 0) bot = mid + 1; else top = mid;
 124   }
 125
 126 return PCRE_ERROR_NOSUBSTRING;
 127 }
 128
 129
 130
 131 /*************************************************
 132 *     Find (multiple) entries for named string   *
 133 *************************************************/
 134
 135 /* This is used by the get_first_set() function below, as well as being
 136 generally available. It is used when duplicated names are permitted.
 137
 138 Arguments:
 139   code        the compiled regex
 140   stringname  the name whose entries required
 141   firstptr    where to put the pointer to the first entry
 142   lastptr     where to put the pointer to the last entry
 143
 144 Returns:      the length of each entry, or a negative number
 145                 (PCRE_ERROR_NOSUBSTRING) if not found
 146 */
 147
 148 #if defined COMPILE_PCRE8
 149 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 150 pcre_get_stringtable_entries(const pcre *code, const char *stringname,
 151   char **firstptr, char **lastptr)
 152 #elif defined COMPILE_PCRE16
 153 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 154 pcre16_get_stringtable_entries(const pcre16 *code, PCRE_SPTR16 stringname,
 155   PCRE_UCHAR16 **firstptr, PCRE_UCHAR16 **lastptr)
 156 #elif defined COMPILE_PCRE32
 157 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 158 pcre32_get_stringtable_entries(const pcre32 *code, PCRE_SPTR32 stringname,
 159   PCRE_UCHAR32 **firstptr, PCRE_UCHAR32 **lastptr)
 160 #endif
 161 {
 162 int rc;
 163 int entrysize;
 164 int top, bot;
 165 pcre_uchar *nametable, *lastentry;
 166
 167 #ifdef COMPILE_PCRE8
 168 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
 169   return rc;
 170 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
 171
 172 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
 173   return rc;
 174 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
 175   return rc;
 176 #endif
 177 #ifdef COMPILE_PCRE16
 178 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
 179   return rc;
 180 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
 181
 182 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
 183   return rc;
 184 if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
 185   return rc;
 186 #endif
 187 #ifdef COMPILE_PCRE32
 188 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
 189   return rc;
 190 if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
 191
 192 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
 193   return rc;
 194 if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
 195   return rc;
 196 #endif
 197
 198 lastentry = nametable + entrysize * (top - 1);
 199 bot = 0;
 200 while (top > bot)
 201   {
 202   int mid = (top + bot) / 2;
 203   pcre_uchar *entry = nametable + entrysize*mid;
 204   int c = STRCMP_UC_UC((pcre_uchar *)stringname,
 205     (pcre_uchar *)(entry + IMM2_SIZE));
 206   if (c == 0)
 207     {
 208     pcre_uchar *first = entry;
 209     pcre_uchar *last = entry;
 210     while (first > nametable)
 211       {
 212       if (STRCMP_UC_UC((pcre_uchar *)stringname,
 213         (pcre_uchar *)(first - entrysize + IMM2_SIZE)) != 0) break;
 214       first -= entrysize;
 215       }
 216     while (last < lastentry)
 217       {
 218       if (STRCMP_UC_UC((pcre_uchar *)stringname,
 219         (pcre_uchar *)(last + entrysize + IMM2_SIZE)) != 0) break;
 220       last += entrysize;
 221       }
 222 #if defined COMPILE_PCRE8
 223     *firstptr = (char *)first;
 224     *lastptr = (char *)last;
 225 #elif defined COMPILE_PCRE16
 226     *firstptr = (PCRE_UCHAR16 *)first;
 227     *lastptr = (PCRE_UCHAR16 *)last;
 228 #elif defined COMPILE_PCRE32
 229     *firstptr = (PCRE_UCHAR32 *)first;
 230     *lastptr = (PCRE_UCHAR32 *)last;
 231 #endif
 232     return entrysize;
 233     }
 234   if (c > 0) bot = mid + 1; else top = mid;
 235   }
 236
 237 return PCRE_ERROR_NOSUBSTRING;
 238 }
 239
 240
 241
 242 /*************************************************
 243 *    Find first set of multiple named strings    *
 244 *************************************************/
 245
 246 /* This function allows for duplicate names in the table of named substrings.
 247 It returns the number of the first one that was set in a pattern match.
 248
 249 Arguments:
 250   code         the compiled regex
 251   stringname   the name of the capturing substring
 252   ovector      the vector of matched substrings
 253
 254 Returns:       the number of the first that is set,
 255                or the number of the last one if none are set,
 256                or a negative number on error
 257 */
 258
 259 #if defined COMPILE_PCRE8
 260 static int
 261 get_first_set(const pcre *code, const char *stringname, int *ovector)
 262 #elif defined COMPILE_PCRE16
 263 static int
 264 get_first_set(const pcre16 *code, PCRE_SPTR16 stringname, int *ovector)
 265 #elif defined COMPILE_PCRE32
 266 static int
 267 get_first_set(const pcre32 *code, PCRE_SPTR32 stringname, int *ovector)
 268 #endif
 269 {
 270 const REAL_PCRE *re = (const REAL_PCRE *)code;
 271 int entrysize;
 272 pcre_uchar *entry;
 273 #if defined COMPILE_PCRE8
 274 char *first, *last;
 275 #elif defined COMPILE_PCRE16
 276 PCRE_UCHAR16 *first, *last;
 277 #elif defined COMPILE_PCRE32
 278 PCRE_UCHAR32 *first, *last;
 279 #endif
 280
 281 #if defined COMPILE_PCRE8
 282 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
 283   return pcre_get_stringnumber(code, stringname);
 284 entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last);
 285 #elif defined COMPILE_PCRE16
 286 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
 287   return pcre16_get_stringnumber(code, stringname);
 288 entrysize = pcre16_get_stringtable_entries(code, stringname, &first, &last);
 289 #elif defined COMPILE_PCRE32
 290 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
 291   return pcre32_get_stringnumber(code, stringname);
 292 entrysize = pcre32_get_stringtable_entries(code, stringname, &first, &last);
 293 #endif
 294 if (entrysize <= 0) return entrysize;
 295 for (entry = (pcre_uchar *)first; entry <= (pcre_uchar *)last; entry += entrysize)
 296   {
 297   int n = GET2(entry, 0);
 298   if (ovector[n*2] >= 0) return n;
 299   }
 300 return GET2(entry, 0);
 301 }
 302
 303
 304
 305
 306 /*************************************************
 307 *      Copy captured string to given buffer      *
 308 *************************************************/
 309
 310 /* This function copies a single captured substring into a given buffer.
 311 Note that we use memcpy() rather than strncpy() in case there are binary zeros
 312 in the string.
 313
 314 Arguments:
 315   subject        the subject string that was matched
 316   ovector        pointer to the offsets table
 317   stringcount    the number of substrings that were captured
 318                    (i.e. the yield of the pcre_exec call, unless
 319                    that was zero, in which case it should be 1/3
 320                    of the offset table size)
 321   stringnumber   the number of the required substring
 322   buffer         where to put the substring
 323   size           the size of the buffer
 324
 325 Returns:         if successful:
 326                    the length of the copied string, not including the zero
 327                    that is put on the end; can be zero
 328                  if not successful:
 329                    PCRE_ERROR_NOMEMORY (-6) buffer too small
 330                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
 331 */
 332
 333 #if defined COMPILE_PCRE8
 334 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 335 pcre_copy_substring(const char *subject, int *ovector, int stringcount,
 336   int stringnumber, char *buffer, int size)
 337 #elif defined COMPILE_PCRE16
 338 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 339 pcre16_copy_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
 340   int stringnumber, PCRE_UCHAR16 *buffer, int size)
 341 #elif defined COMPILE_PCRE32
 342 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 343 pcre32_copy_substring(PCRE_SPTR32 subject, int *ovector, int stringcount,
 344   int stringnumber, PCRE_UCHAR32 *buffer, int size)
 345 #endif
 346 {
 347 int yield;
 348 if (stringnumber < 0 || stringnumber >= stringcount)
 349   return PCRE_ERROR_NOSUBSTRING;
 350 stringnumber *= 2;
 351 yield = ovector[stringnumber+1] - ovector[stringnumber];
 352 if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
 353 memcpy(buffer, subject + ovector[stringnumber], IN_UCHARS(yield));
 354 buffer[yield] = 0;
 355 return yield;
 356 }
 357
 358
 359
 360 /*************************************************
 361 *   Copy named captured string to given buffer   *
 362 *************************************************/
 363
 364 /* This function copies a single captured substring into a given buffer,
 365 identifying it by name. If the regex permits duplicate names, the first
 366 substring that is set is chosen.
 367
 368 Arguments:
 369   code           the compiled regex
 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   stringname     the name of the required substring
 377   buffer         where to put the substring
 378   size           the size of the buffer
 379
 380 Returns:         if successful:
 381                    the length of the copied string, not including the zero
 382                    that is put on the end; can be zero
 383                  if not successful:
 384                    PCRE_ERROR_NOMEMORY (-6) buffer too small
 385                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
 386 */
 387
 388 #if defined COMPILE_PCRE8
 389 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 390 pcre_copy_named_substring(const pcre *code, const char *subject,
 391   int *ovector, int stringcount, const char *stringname,
 392   char *buffer, int size)
 393 #elif defined COMPILE_PCRE16
 394 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 395 pcre16_copy_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
 396   int *ovector, int stringcount, PCRE_SPTR16 stringname,
 397   PCRE_UCHAR16 *buffer, int size)
 398 #elif defined COMPILE_PCRE32
 399 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 400 pcre32_copy_named_substring(const pcre32 *code, PCRE_SPTR32 subject,
 401   int *ovector, int stringcount, PCRE_SPTR32 stringname,
 402   PCRE_UCHAR32 *buffer, int size)
 403 #endif
 404 {
 405 int n = get_first_set(code, stringname, ovector);
 406 if (n <= 0) return n;
 407 #if defined COMPILE_PCRE8
 408 return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
 409 #elif defined COMPILE_PCRE16
 410 return pcre16_copy_substring(subject, ovector, stringcount, n, buffer, size);
 411 #elif defined COMPILE_PCRE32
 412 return pcre32_copy_substring(subject, ovector, stringcount, n, buffer, size);
 413 #endif
 414 }
 415
 416
 417
 418 /*************************************************
 419 *      Copy all captured strings to new store    *
 420 *************************************************/
 421
 422 /* This function gets one chunk of store and builds a list of pointers and all
 423 of the captured substrings in it. A NULL pointer is put on the end of the list.
 424
 425 Arguments:
 426   subject        the subject string that was matched
 427   ovector        pointer to the offsets table
 428   stringcount    the number of substrings that were captured
 429                    (i.e. the yield of the pcre_exec call, unless
 430                    that was zero, in which case it should be 1/3
 431                    of the offset table size)
 432   listptr        set to point to the list of pointers
 433
 434 Returns:         if successful: 0
 435                  if not successful:
 436                    PCRE_ERROR_NOMEMORY (-6) failed to get store
 437 */
 438
 439 #if defined COMPILE_PCRE8
 440 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 441 pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
 442   const char ***listptr)
 443 #elif defined COMPILE_PCRE16
 444 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 445 pcre16_get_substring_list(PCRE_SPTR16 subject, int *ovector, int stringcount,
 446   PCRE_SPTR16 **listptr)
 447 #elif defined COMPILE_PCRE32
 448 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 449 pcre32_get_substring_list(PCRE_SPTR32 subject, int *ovector, int stringcount,
 450   PCRE_SPTR32 **listptr)
 451 #endif
 452 {
 453 int i;
 454 int size = sizeof(pcre_uchar *);
 455 int double_count = stringcount * 2;
 456 pcre_uchar **stringlist;
 457 pcre_uchar *p;
 458
 459 for (i = 0; i < double_count; i += 2)
 460   size += sizeof(pcre_uchar *) + IN_UCHARS(ovector[i+1] - ovector[i] + 1);
 461
 462 stringlist = (pcre_uchar **)(PUBL(malloc))(size);
 463 if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
 464
 465 #if defined COMPILE_PCRE8
 466 *listptr = (const char **)stringlist;
 467 #elif defined COMPILE_PCRE16
 468 *listptr = (PCRE_SPTR16 *)stringlist;
 469 #elif defined COMPILE_PCRE32
 470 *listptr = (PCRE_SPTR32 *)stringlist;
 471 #endif
 472 p = (pcre_uchar *)(stringlist + stringcount + 1);
 473
 474 for (i = 0; i < double_count; i += 2)
 475   {
 476   int len = ovector[i+1] - ovector[i];
 477   memcpy(p, subject + ovector[i], IN_UCHARS(len));
 478   *stringlist++ = p;
 479   p += len;
 480   *p++ = 0;
 481   }
 482
 483 *stringlist = NULL;
 484 return 0;
 485 }
 486
 487
 488
 489 /*************************************************
 490 *   Free store obtained by get_substring_list    *
 491 *************************************************/
 492
 493 /* This function exists for the benefit of people calling PCRE from non-C
 494 programs that can call its functions, but not free() or (PUBL(free))()
 495 directly.
 496
 497 Argument:   the result of a previous pcre_get_substring_list()
 498 Returns:    nothing
 499 */
 500
 501 #if defined COMPILE_PCRE8
 502 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
 503 pcre_free_substring_list(const char **pointer)
 504 #elif defined COMPILE_PCRE16
 505 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
 506 pcre16_free_substring_list(PCRE_SPTR16 *pointer)
 507 #elif defined COMPILE_PCRE32
 508 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
 509 pcre32_free_substring_list(PCRE_SPTR32 *pointer)
 510 #endif
 511 {
 512 (PUBL(free))((void *)pointer);
 513 }
 514
 515
 516
 517 /*************************************************
 518 *      Copy captured string to new store         *
 519 *************************************************/
 520
 521 /* This function copies a single captured substring into a piece of new
 522 store
 523
 524 Arguments:
 525   subject        the subject string that was matched
 526   ovector        pointer to the offsets table
 527   stringcount    the number of substrings that were captured
 528                    (i.e. the yield of the pcre_exec call, unless
 529                    that was zero, in which case it should be 1/3
 530                    of the offset table size)
 531   stringnumber   the number of the required substring
 532   stringptr      where to put a pointer to the substring
 533
 534 Returns:         if successful:
 535                    the length of the string, not including the zero that
 536                    is put on the end; can be zero
 537                  if not successful:
 538                    PCRE_ERROR_NOMEMORY (-6) failed to get store
 539                    PCRE_ERROR_NOSUBSTRING (-7) substring not present
 540 */
 541
 542 #if defined COMPILE_PCRE8
 543 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 544 pcre_get_substring(const char *subject, int *ovector, int stringcount,
 545   int stringnumber, const char **stringptr)
 546 #elif defined COMPILE_PCRE16
 547 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 548 pcre16_get_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
 549   int stringnumber, PCRE_SPTR16 *stringptr)
 550 #elif defined COMPILE_PCRE32
 551 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 552 pcre32_get_substring(PCRE_SPTR32 subject, int *ovector, int stringcount,
 553   int stringnumber, PCRE_SPTR32 *stringptr)
 554 #endif
 555 {
 556 int yield;
 557 pcre_uchar *substring;
 558 if (stringnumber < 0 || stringnumber >= stringcount)
 559   return PCRE_ERROR_NOSUBSTRING;
 560 stringnumber *= 2;
 561 yield = ovector[stringnumber+1] - ovector[stringnumber];
 562 substring = (pcre_uchar *)(PUBL(malloc))(IN_UCHARS(yield + 1));
 563 if (substring == NULL) return PCRE_ERROR_NOMEMORY;
 564 memcpy(substring, subject + ovector[stringnumber], IN_UCHARS(yield));
 565 substring[yield] = 0;
 566 #if defined COMPILE_PCRE8
 567 *stringptr = (const char *)substring;
 568 #elif defined COMPILE_PCRE16
 569 *stringptr = (PCRE_SPTR16)substring;
 570 #elif defined COMPILE_PCRE32
 571 *stringptr = (PCRE_SPTR32)substring;
 572 #endif
 573 return yield;
 574 }
 575
 576
 577
 578 /*************************************************
 579 *   Copy named captured string to new store      *
 580 *************************************************/
 581
 582 /* This function copies a single captured substring, identified by name, into
 583 new store. If the regex permits duplicate names, the first substring that is
 584 set is chosen.
 585
 586 Arguments:
 587   code           the compiled regex
 588   subject        the subject string that was matched
 589   ovector        pointer to the offsets table
 590   stringcount    the number of substrings that were captured
 591                    (i.e. the yield of the pcre_exec call, unless
 592                    that was zero, in which case it should be 1/3
 593                    of the offset table size)
 594   stringname     the name of the required substring
 595   stringptr      where to put the pointer
 596
 597 Returns:         if successful:
 598                    the length of the copied string, not including the zero
 599                    that is put on the end; can be zero
 600                  if not successful:
 601                    PCRE_ERROR_NOMEMORY (-6) couldn't get memory
 602                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
 603 */
 604
 605 #if defined COMPILE_PCRE8
 606 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 607 pcre_get_named_substring(const pcre *code, const char *subject,
 608   int *ovector, int stringcount, const char *stringname,
 609   const char **stringptr)
 610 #elif defined COMPILE_PCRE16
 611 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 612 pcre16_get_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
 613   int *ovector, int stringcount, PCRE_SPTR16 stringname,
 614   PCRE_SPTR16 *stringptr)
 615 #elif defined COMPILE_PCRE32
 616 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 617 pcre32_get_named_substring(const pcre32 *code, PCRE_SPTR32 subject,
 618   int *ovector, int stringcount, PCRE_SPTR32 stringname,
 619   PCRE_SPTR32 *stringptr)
 620 #endif
 621 {
 622 int n = get_first_set(code, stringname, ovector);
 623 if (n <= 0) return n;
 624 #if defined COMPILE_PCRE8
 625 return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
 626 #elif defined COMPILE_PCRE16
 627 return pcre16_get_substring(subject, ovector, stringcount, n, stringptr);
 628 #elif defined COMPILE_PCRE32
 629 return pcre32_get_substring(subject, ovector, stringcount, n, stringptr);
 630 #endif
 631 }
 632
 633
 634
 635
 636 /*************************************************
 637 *       Free store obtained by get_substring     *
 638 *************************************************/
 639
 640 /* This function exists for the benefit of people calling PCRE from non-C
 641 programs that can call its functions, but not free() or (PUBL(free))()
 642 directly.
 643
 644 Argument:   the result of a previous pcre_get_substring()
 645 Returns:    nothing
 646 */
 647
 648 #if defined COMPILE_PCRE8
 649 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
 650 pcre_free_substring(const char *pointer)
 651 #elif defined COMPILE_PCRE16
 652 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
 653 pcre16_free_substring(PCRE_SPTR16 pointer)
 654 #elif defined COMPILE_PCRE32
 655 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
 656 pcre32_free_substring(PCRE_SPTR32 pointer)
 657 #endif
 658 {
 659 (PUBL(free))((void *)pointer);
 660 }
 661
 662 /* End of pcre_get.c */