glib/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-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 #ifdef NOT_USED_IN_GLIB
 168
 169 /*************************************************
 170 *    Find first set of multiple named strings    *
 171 *************************************************/
 172
 173 /* This function allows for duplicate names in the table of named substrings.
 174 It returns the number of the first one that was set in a pattern match.
 175
 176 Arguments:
 177   code         the compiled regex
 178   stringname   the name of the capturing substring
 179   ovector      the vector of matched substrings
 180
 181 Returns:       the number of the first that is set,
 182                or the number of the last one if none are set,
 183                or a negative number on error
 184 */
 185
 186 static int
 187 get_first_set(const pcre *code, const char *stringname, int *ovector)
 188 {
 189 const real_pcre *re = (const real_pcre *)code;
 190 int entrysize;
 191 char *first, *last;
 192 uschar *entry;
 193 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
 194   return pcre_get_stringnumber(code, stringname);
 195 entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last);
 196 if (entrysize <= 0) return entrysize;
 197 for (entry = (uschar *)first; entry <= (uschar *)last; entry += entrysize)
 198   {
 199   int n = (entry[0] << 8) + entry[1];
 200   if (ovector[n*2] >= 0) return n;
 201   }
 202 return (first[0] << 8) + first[1];
 203 }
 204
 205
 206
 207
 208 /*************************************************
 209 *      Copy captured string to given buffer      *
 210 *************************************************/
 211
 212 /* This function copies a single captured substring into a given buffer.
 213 Note that we use memcpy() rather than strncpy() in case there are binary zeros
 214 in the string.
 215
 216 Arguments:
 217   subject        the subject string that was matched
 218   ovector        pointer to the offsets table
 219   stringcount    the number of substrings that were captured
 220                    (i.e. the yield of the pcre_exec call, unless
 221                    that was zero, in which case it should be 1/3
 222                    of the offset table size)
 223   stringnumber   the number of the required substring
 224   buffer         where to put the substring
 225   size           the size of the buffer
 226
 227 Returns:         if successful:
 228                    the length of the copied string, not including the zero
 229                    that is put on the end; can be zero
 230                  if not successful:
 231                    PCRE_ERROR_NOMEMORY (-6) buffer too small
 232                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
 233 */
 234
 235 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 236 pcre_copy_substring(const char *subject, int *ovector, int stringcount,
 237   int stringnumber, char *buffer, int size)
 238 {
 239 int yield;
 240 if (stringnumber < 0 || stringnumber >= stringcount)
 241   return PCRE_ERROR_NOSUBSTRING;
 242 stringnumber *= 2;
 243 yield = ovector[stringnumber+1] - ovector[stringnumber];
 244 if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
 245 memcpy(buffer, subject + ovector[stringnumber], yield);
 246 buffer[yield] = 0;
 247 return yield;
 248 }
 249
 250
 251
 252 /*************************************************
 253 *   Copy named captured string to given buffer   *
 254 *************************************************/
 255
 256 /* This function copies a single captured substring into a given buffer,
 257 identifying it by name. If the regex permits duplicate names, the first
 258 substring that is set is chosen.
 259
 260 Arguments:
 261   code           the compiled regex
 262   subject        the subject string that was matched
 263   ovector        pointer to the offsets table
 264   stringcount    the number of substrings that were captured
 265                    (i.e. the yield of the pcre_exec call, unless
 266                    that was zero, in which case it should be 1/3
 267                    of the offset table size)
 268   stringname     the name of the required substring
 269   buffer         where to put the substring
 270   size           the size of the buffer
 271
 272 Returns:         if successful:
 273                    the length of the copied string, not including the zero
 274                    that is put on the end; can be zero
 275                  if not successful:
 276                    PCRE_ERROR_NOMEMORY (-6) buffer too small
 277                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
 278 */
 279
 280 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 281 pcre_copy_named_substring(const pcre *code, const char *subject, int *ovector,
 282   int stringcount, const char *stringname, char *buffer, int size)
 283 {
 284 int n = get_first_set(code, stringname, ovector);
 285 if (n <= 0) return n;
 286 return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
 287 }
 288
 289
 290
 291 /*************************************************
 292 *      Copy all captured strings to new store    *
 293 *************************************************/
 294
 295 /* This function gets one chunk of store and builds a list of pointers and all
 296 of the captured substrings in it. A NULL pointer is put on the end of the list.
 297
 298 Arguments:
 299   subject        the subject string that was matched
 300   ovector        pointer to the offsets table
 301   stringcount    the number of substrings that were captured
 302                    (i.e. the yield of the pcre_exec call, unless
 303                    that was zero, in which case it should be 1/3
 304                    of the offset table size)
 305   listptr        set to point to the list of pointers
 306
 307 Returns:         if successful: 0
 308                  if not successful:
 309                    PCRE_ERROR_NOMEMORY (-6) failed to get store
 310 */
 311
 312 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 313 pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
 314   const char ***listptr)
 315 {
 316 int i;
 317 int size = sizeof(char *);
 318 int double_count = stringcount * 2;
 319 char **stringlist;
 320 char *p;
 321
 322 for (i = 0; i < double_count; i += 2)
 323   size += sizeof(char *) + ovector[i+1] - ovector[i] + 1;
 324
 325 stringlist = (char **)(pcre_malloc)(size);
 326 if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
 327
 328 *listptr = (const char **)stringlist;
 329 p = (char *)(stringlist + stringcount + 1);
 330
 331 for (i = 0; i < double_count; i += 2)
 332   {
 333   int len = ovector[i+1] - ovector[i];
 334   memcpy(p, subject + ovector[i], len);
 335   *stringlist++ = p;
 336   p += len;
 337   *p++ = 0;
 338   }
 339
 340 *stringlist = NULL;
 341 return 0;
 342 }
 343
 344
 345
 346 /*************************************************
 347 *   Free store obtained by get_substring_list    *
 348 *************************************************/
 349
 350 /* This function exists for the benefit of people calling PCRE from non-C
 351 programs that can call its functions, but not free() or (pcre_free)() directly.
 352
 353 Argument:   the result of a previous pcre_get_substring_list()
 354 Returns:    nothing
 355 */
 356
 357 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
 358 pcre_free_substring_list(const char **pointer)
 359 {
 360 (pcre_free)((void *)pointer);
 361 }
 362
 363
 364
 365 /*************************************************
 366 *      Copy captured string to new store         *
 367 *************************************************/
 368
 369 /* This function copies a single captured substring into a piece of new
 370 store
 371
 372 Arguments:
 373   subject        the subject string that was matched
 374   ovector        pointer to the offsets table
 375   stringcount    the number of substrings that were captured
 376                    (i.e. the yield of the pcre_exec call, unless
 377                    that was zero, in which case it should be 1/3
 378                    of the offset table size)
 379   stringnumber   the number of the required substring
 380   stringptr      where to put a pointer to the substring
 381
 382 Returns:         if successful:
 383                    the length of the string, not including the zero that
 384                    is put on the end; can be zero
 385                  if not successful:
 386                    PCRE_ERROR_NOMEMORY (-6) failed to get store
 387                    PCRE_ERROR_NOSUBSTRING (-7) substring not present
 388 */
 389
 390 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 391 pcre_get_substring(const char *subject, int *ovector, int stringcount,
 392   int stringnumber, const char **stringptr)
 393 {
 394 int yield;
 395 char *substring;
 396 if (stringnumber < 0 || stringnumber >= stringcount)
 397   return PCRE_ERROR_NOSUBSTRING;
 398 stringnumber *= 2;
 399 yield = ovector[stringnumber+1] - ovector[stringnumber];
 400 substring = (char *)(pcre_malloc)(yield + 1);
 401 if (substring == NULL) return PCRE_ERROR_NOMEMORY;
 402 memcpy(substring, subject + ovector[stringnumber], yield);
 403 substring[yield] = 0;
 404 *stringptr = substring;
 405 return yield;
 406 }
 407
 408
 409
 410 /*************************************************
 411 *   Copy named captured string to new store      *
 412 *************************************************/
 413
 414 /* This function copies a single captured substring, identified by name, into
 415 new store. If the regex permits duplicate names, the first substring that is
 416 set is chosen.
 417
 418 Arguments:
 419   code           the compiled regex
 420   subject        the subject string that was matched
 421   ovector        pointer to the offsets table
 422   stringcount    the number of substrings that were captured
 423                    (i.e. the yield of the pcre_exec call, unless
 424                    that was zero, in which case it should be 1/3
 425                    of the offset table size)
 426   stringname     the name of the required substring
 427   stringptr      where to put the pointer
 428
 429 Returns:         if successful:
 430                    the length of the copied string, not including the zero
 431                    that is put on the end; can be zero
 432                  if not successful:
 433                    PCRE_ERROR_NOMEMORY (-6) couldn't get memory
 434                    PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
 435 */
 436
 437 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
 438 pcre_get_named_substring(const pcre *code, const char *subject, int *ovector,
 439   int stringcount, const char *stringname, const char **stringptr)
 440 {
 441 int n = get_first_set(code, stringname, ovector);
 442 if (n <= 0) return n;
 443 return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
 444 }
 445
 446
 447
 448
 449 /*************************************************
 450 *       Free store obtained by get_substring     *
 451 *************************************************/
 452
 453 /* This function exists for the benefit of people calling PCRE from non-C
 454 programs that can call its functions, but not free() or (pcre_free)() directly.
 455
 456 Argument:   the result of a previous pcre_get_substring()
 457 Returns:    nothing
 458 */
 459
 460 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
 461 pcre_free_substring(const char *pointer)
 462 {
 463 (pcre_free)((void *)pointer);
 464 }
 465
 466 #endif
 467
 468 /* End of pcre_get.c */