src/external/pcre2-10.32/src/pcre2_context.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      Original API code Copyright (c) 1997-2012 University of Cambridge
  10           New API code Copyright (c) 2016-2017 University of Cambridge
  11
  12 -----------------------------------------------------------------------------
  13 Redistribution and use in source and binary forms, with or without
  14 modification, are permitted provided that the following conditions are met:
  15
  16     * Redistributions of source code must retain the above copyright notice,
  17       this list of conditions and the following disclaimer.
  18
  19     * Redistributions in binary form must reproduce the above copyright
  20       notice, this list of conditions and the following disclaimer in the
  21       documentation and/or other materials provided with the distribution.
  22
  23     * Neither the name of the University of Cambridge nor the names of its
  24       contributors may be used to endorse or promote products derived from
  25       this software without specific prior written permission.
  26
  27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37 POSSIBILITY OF SUCH DAMAGE.
  38 -----------------------------------------------------------------------------
  39 */
  40
  41
  42 #ifdef HAVE_CONFIG_H
  43 #include "config.h"
  44 #endif
  45
  46 #include "pcre2_internal.h"
  47
  48
  49
  50 /*************************************************
  51 *          Default malloc/free functions         *
  52 *************************************************/
  53
  54 /* Ignore the "user data" argument in each case. */
  55
  56 static void *default_malloc(size_t size, void *data)
  57 {
  58 (void)data;
  59 return malloc(size);
  60 }
  61
  62
  63 static void default_free(void *block, void *data)
  64 {
  65 (void)data;
  66 free(block);
  67 }
  68
  69
  70
  71 /*************************************************
  72 *        Get a block and save memory control     *
  73 *************************************************/
  74
  75 /* This internal function is called to get a block of memory in which the
  76 memory control data is to be stored at the start for future use.
  77
  78 Arguments:
  79   size        amount of memory required
  80   memctl      pointer to a memctl block or NULL
  81
  82 Returns:      pointer to memory or NULL on failure
  83 */
  84
  85 extern void *
  86 PRIV(memctl_malloc)(size_t size, pcre2_memctl *memctl)
  87 {
  88 pcre2_memctl *newmemctl;
  89 void *yield = (memctl == NULL)? malloc(size) :
  90   memctl->malloc(size, memctl->memory_data);
  91 if (yield == NULL) return NULL;
  92 newmemctl = (pcre2_memctl *)yield;
  93 if (memctl == NULL)
  94   {
  95   newmemctl->malloc = default_malloc;
  96   newmemctl->free = default_free;
  97   newmemctl->memory_data = NULL;
  98   }
  99 else *newmemctl = *memctl;
 100 return yield;
 101 }
 102
 103
 104
 105 /*************************************************
 106 *          Create and initialize contexts        *
 107 *************************************************/
 108
 109 /* Initializing for compile and match contexts is done in separate, private
 110 functions so that these can be called from functions such as pcre2_compile()
 111 when an external context is not supplied. The initializing functions have an
 112 option to set up default memory management. */
 113
 114 PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
 115 pcre2_general_context_create(void *(*private_malloc)(size_t, void *),
 116   void (*private_free)(void *, void *), void *memory_data)
 117 {
 118 pcre2_general_context *gcontext;
 119 if (private_malloc == NULL) private_malloc = default_malloc;
 120 if (private_free == NULL) private_free = default_free;
 121 gcontext = private_malloc(sizeof(pcre2_real_general_context), memory_data);
 122 if (gcontext == NULL) return NULL;
 123 gcontext->memctl.malloc = private_malloc;
 124 gcontext->memctl.free = private_free;
 125 gcontext->memctl.memory_data = memory_data;
 126 return gcontext;
 127 }
 128
 129
 130 /* A default compile context is set up to save having to initialize at run time
 131 when no context is supplied to the compile function. */
 132
 133 const pcre2_compile_context PRIV(default_compile_context) = {
 134   { default_malloc, default_free, NULL },    /* Default memory handling */
 135   NULL,                                      /* Stack guard */
 136   NULL,                                      /* Stack guard data */
 137   PRIV(default_tables),                      /* Character tables */
 138   PCRE2_UNSET,                               /* Max pattern length */
 139   BSR_DEFAULT,                               /* Backslash R default */
 140   NEWLINE_DEFAULT,                           /* Newline convention */
 141   PARENS_NEST_LIMIT,                         /* As it says */
 142   0 };                                       /* Extra options */
 143
 144 /* The create function copies the default into the new memory, but must
 145 override the default memory handling functions if a gcontext was provided. */
 146
 147 PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
 148 pcre2_compile_context_create(pcre2_general_context *gcontext)
 149 {
 150 pcre2_compile_context *ccontext = PRIV(memctl_malloc)(
 151   sizeof(pcre2_real_compile_context), (pcre2_memctl *)gcontext);
 152 if (ccontext == NULL) return NULL;
 153 *ccontext = PRIV(default_compile_context);
 154 if (gcontext != NULL)
 155   *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
 156 return ccontext;
 157 }
 158
 159
 160 /* A default match context is set up to save having to initialize at run time
 161 when no context is supplied to a match function. */
 162
 163 const pcre2_match_context PRIV(default_match_context) = {
 164   { default_malloc, default_free, NULL },
 165 #ifdef SUPPORT_JIT
 166   NULL,
 167   NULL,
 168 #endif
 169   NULL,
 170   NULL,
 171   PCRE2_UNSET,   /* Offset limit */
 172   HEAP_LIMIT,
 173   MATCH_LIMIT,
 174   MATCH_LIMIT_DEPTH };
 175
 176 /* The create function copies the default into the new memory, but must
 177 override the default memory handling functions if a gcontext was provided. */
 178
 179 PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
 180 pcre2_match_context_create(pcre2_general_context *gcontext)
 181 {
 182 pcre2_match_context *mcontext = PRIV(memctl_malloc)(
 183   sizeof(pcre2_real_match_context), (pcre2_memctl *)gcontext);
 184 if (mcontext == NULL) return NULL;
 185 *mcontext = PRIV(default_match_context);
 186 if (gcontext != NULL)
 187   *((pcre2_memctl *)mcontext) = *((pcre2_memctl *)gcontext);
 188 return mcontext;
 189 }
 190
 191
 192 /* A default convert context is set up to save having to initialize at run time
 193 when no context is supplied to the convert function. */
 194
 195 const pcre2_convert_context PRIV(default_convert_context) = {
 196   { default_malloc, default_free, NULL },    /* Default memory handling */
 197 #ifdef _WIN32
 198   CHAR_BACKSLASH,                            /* Default path separator */
 199   CHAR_GRAVE_ACCENT                          /* Default escape character */
 200 #else  /* Not Windows */
 201   CHAR_SLASH,                                /* Default path separator */
 202   CHAR_BACKSLASH                             /* Default escape character */
 203 #endif
 204   };
 205
 206 /* The create function copies the default into the new memory, but must
 207 override the default memory handling functions if a gcontext was provided. */
 208
 209 PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
 210 pcre2_convert_context_create(pcre2_general_context *gcontext)
 211 {
 212 pcre2_convert_context *ccontext = PRIV(memctl_malloc)(
 213   sizeof(pcre2_real_convert_context), (pcre2_memctl *)gcontext);
 214 if (ccontext == NULL) return NULL;
 215 *ccontext = PRIV(default_convert_context);
 216 if (gcontext != NULL)
 217   *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
 218 return ccontext;
 219 }
 220
 221
 222 /*************************************************
 223 *              Context copy functions            *
 224 *************************************************/
 225
 226 PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
 227 pcre2_general_context_copy(pcre2_general_context *gcontext)
 228 {
 229 pcre2_general_context *new =
 230   gcontext->memctl.malloc(sizeof(pcre2_real_general_context),
 231   gcontext->memctl.memory_data);
 232 if (new == NULL) return NULL;
 233 memcpy(new, gcontext, sizeof(pcre2_real_general_context));
 234 return new;
 235 }
 236
 237
 238 PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
 239 pcre2_compile_context_copy(pcre2_compile_context *ccontext)
 240 {
 241 pcre2_compile_context *new =
 242   ccontext->memctl.malloc(sizeof(pcre2_real_compile_context),
 243   ccontext->memctl.memory_data);
 244 if (new == NULL) return NULL;
 245 memcpy(new, ccontext, sizeof(pcre2_real_compile_context));
 246 return new;
 247 }
 248
 249
 250 PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
 251 pcre2_match_context_copy(pcre2_match_context *mcontext)
 252 {
 253 pcre2_match_context *new =
 254   mcontext->memctl.malloc(sizeof(pcre2_real_match_context),
 255   mcontext->memctl.memory_data);
 256 if (new == NULL) return NULL;
 257 memcpy(new, mcontext, sizeof(pcre2_real_match_context));
 258 return new;
 259 }
 260
 261
 262
 263 PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
 264 pcre2_convert_context_copy(pcre2_convert_context *ccontext)
 265 {
 266 pcre2_convert_context *new =
 267   ccontext->memctl.malloc(sizeof(pcre2_real_convert_context),
 268   ccontext->memctl.memory_data);
 269 if (new == NULL) return NULL;
 270 memcpy(new, ccontext, sizeof(pcre2_real_convert_context));
 271 return new;
 272 }
 273
 274
 275 /*************************************************
 276 *              Context free functions            *
 277 *************************************************/
 278
 279 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
 280 pcre2_general_context_free(pcre2_general_context *gcontext)
 281 {
 282 if (gcontext != NULL)
 283   gcontext->memctl.free(gcontext, gcontext->memctl.memory_data);
 284 }
 285
 286
 287 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
 288 pcre2_compile_context_free(pcre2_compile_context *ccontext)
 289 {
 290 if (ccontext != NULL)
 291   ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
 292 }
 293
 294
 295 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
 296 pcre2_match_context_free(pcre2_match_context *mcontext)
 297 {
 298 if (mcontext != NULL)
 299   mcontext->memctl.free(mcontext, mcontext->memctl.memory_data);
 300 }
 301
 302
 303 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
 304 pcre2_convert_context_free(pcre2_convert_context *ccontext)
 305 {
 306 if (ccontext != NULL)
 307   ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
 308 }
 309
 310
 311 /*************************************************
 312 *             Set values in contexts             *
 313 *************************************************/
 314
 315 /* All these functions return 0 for success or PCRE2_ERROR_BADDATA if invalid
 316 data is given. Only some of the functions are able to test the validity of the
 317 data. */
 318
 319
 320 /* ------------ Compile context ------------ */
 321
 322 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 323 pcre2_set_character_tables(pcre2_compile_context *ccontext,
 324   const unsigned char *tables)
 325 {
 326 ccontext->tables = tables;
 327 return 0;
 328 }
 329
 330 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 331 pcre2_set_bsr(pcre2_compile_context *ccontext, uint32_t value)
 332 {
 333 switch(value)
 334   {
 335   case PCRE2_BSR_ANYCRLF:
 336   case PCRE2_BSR_UNICODE:
 337   ccontext->bsr_convention = value;
 338   return 0;
 339
 340   default:
 341   return PCRE2_ERROR_BADDATA;
 342   }
 343 }
 344
 345 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 346 pcre2_set_max_pattern_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
 347 {
 348 ccontext->max_pattern_length = length;
 349 return 0;
 350 }
 351
 352 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 353 pcre2_set_newline(pcre2_compile_context *ccontext, uint32_t newline)
 354 {
 355 switch(newline)
 356   {
 357   case PCRE2_NEWLINE_CR:
 358   case PCRE2_NEWLINE_LF:
 359   case PCRE2_NEWLINE_CRLF:
 360   case PCRE2_NEWLINE_ANY:
 361   case PCRE2_NEWLINE_ANYCRLF:
 362   case PCRE2_NEWLINE_NUL:
 363   ccontext->newline_convention = newline;
 364   return 0;
 365
 366   default:
 367   return PCRE2_ERROR_BADDATA;
 368   }
 369 }
 370
 371 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 372 pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext, uint32_t limit)
 373 {
 374 ccontext->parens_nest_limit = limit;
 375 return 0;
 376 }
 377
 378 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 379 pcre2_set_compile_extra_options(pcre2_compile_context *ccontext, uint32_t options)
 380 {
 381 ccontext->extra_options = options;
 382 return 0;
 383 }
 384
 385 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 386 pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,
 387   int (*guard)(uint32_t, void *), void *user_data)
 388 {
 389 ccontext->stack_guard = guard;
 390 ccontext->stack_guard_data = user_data;
 391 return 0;
 392 }
 393
 394
 395 /* ------------ Match context ------------ */
 396
 397 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 398 pcre2_set_callout(pcre2_match_context *mcontext,
 399   int (*callout)(pcre2_callout_block *, void *), void *callout_data)
 400 {
 401 mcontext->callout = callout;
 402 mcontext->callout_data = callout_data;
 403 return 0;
 404 }
 405
 406 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 407 pcre2_set_heap_limit(pcre2_match_context *mcontext, uint32_t limit)
 408 {
 409 mcontext->heap_limit = limit;
 410 return 0;
 411 }
 412
 413 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 414 pcre2_set_match_limit(pcre2_match_context *mcontext, uint32_t limit)
 415 {
 416 mcontext->match_limit = limit;
 417 return 0;
 418 }
 419
 420 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 421 pcre2_set_depth_limit(pcre2_match_context *mcontext, uint32_t limit)
 422 {
 423 mcontext->depth_limit = limit;
 424 return 0;
 425 }
 426
 427 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 428 pcre2_set_offset_limit(pcre2_match_context *mcontext, PCRE2_SIZE limit)
 429 {
 430 mcontext->offset_limit = limit;
 431 return 0;
 432 }
 433
 434 /* This function became obsolete at release 10.30. It is kept as a synonym for
 435 backwards compatibility. */
 436
 437 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 438 pcre2_set_recursion_limit(pcre2_match_context *mcontext, uint32_t limit)
 439 {
 440 return pcre2_set_depth_limit(mcontext, limit);
 441 }
 442
 443 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 444 pcre2_set_recursion_memory_management(pcre2_match_context *mcontext,
 445   void *(*mymalloc)(size_t, void *), void (*myfree)(void *, void *),
 446   void *mydata)
 447 {
 448 (void)mcontext;
 449 (void)mymalloc;
 450 (void)myfree;
 451 (void)mydata;
 452 return 0;
 453 }
 454
 455 /* ------------ Convert context ------------ */
 456
 457 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 458 pcre2_set_glob_separator(pcre2_convert_context *ccontext, uint32_t separator)
 459 {
 460 if (separator != CHAR_SLASH && separator != CHAR_BACKSLASH &&
 461     separator != CHAR_DOT) return PCRE2_ERROR_BADDATA;
 462 ccontext->glob_separator = separator;
 463 return 0;
 464 }
 465
 466 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 467 pcre2_set_glob_escape(pcre2_convert_context *ccontext, uint32_t escape)
 468 {
 469 if (escape > 255 || (escape != 0 && !ispunct(escape)))
 470   return PCRE2_ERROR_BADDATA;
 471 ccontext->glob_escape = escape;
 472 return 0;
 473 }
 474
 475 /* End of pcre2_context.c */
 476