/src/php-src/ext/pcre/pcre2lib/pcre2_context.c

Source (jump to first uncovered line)
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"



/*************************************************
*          Default malloc/free functions         *
*************************************************/

/* Ignore the "user data" argument in each case. */

static void *default_malloc(size_t size, void *data)
{
(void)data;
return malloc(size);
}


static void default_free(void *block, void *data)
{
(void)data;
free(block);
}



/*************************************************
*        Get a block and save memory control     *
*************************************************/

/* This internal function is called to get a block of memory in which the
memory control data is to be stored at the start for future use.

Arguments:
  size        amount of memory required
  memctl      pointer to a memctl block or NULL

Returns:      pointer to memory or NULL on failure
*/

extern void *
PRIV(memctl_malloc)(size_t size, pcre2_memctl *memctl)
{
pcre2_memctl *newmemctl;
void *yield = (memctl == NULL)? malloc(size) :
  memctl->malloc(size, memctl->memory_data);
if (yield == NULL) return NULL;
newmemctl = (pcre2_memctl *)yield;
if (memctl == NULL)
  {
  newmemctl->malloc = default_malloc;
  newmemctl->free = default_free;
  newmemctl->memory_data = NULL;
  }
else *newmemctl = *memctl;
return yield;
}



/*************************************************
*          Create and initialize contexts        *
*************************************************/

/* Initializing for compile and match contexts is done in separate, private
functions so that these can be called from functions such as pcre2_compile()
when an external context is not supplied. The initializing functions have an
option to set up default memory management. */

PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
pcre2_general_context_create(void *(*private_malloc)(size_t, void *),
  void (*private_free)(void *, void *), void *memory_data)
{
pcre2_general_context *gcontext;
if (private_malloc == NULL) private_malloc = default_malloc;
if (private_free == NULL) private_free = default_free;
gcontext = private_malloc(sizeof(pcre2_real_general_context), memory_data);
if (gcontext == NULL) return NULL;
gcontext->memctl.malloc = private_malloc;
gcontext->memctl.free = private_free;
gcontext->memctl.memory_data = memory_data;
return gcontext;
}


/* A default compile context is set up to save having to initialize at run time
when no context is supplied to the compile function. */

pcre2_compile_context PRIV(default_compile_context) = {
  { default_malloc, default_free, NULL },    /* Default memory handling */
  NULL,                                      /* Stack guard */
  NULL,                                      /* Stack guard data */
  PRIV(default_tables),                      /* Character tables */
  PCRE2_UNSET,                               /* Max pattern length */
  PCRE2_UNSET,                               /* Max pattern compiled length */
  BSR_DEFAULT,                               /* Backslash R default */
  NEWLINE_DEFAULT,                           /* Newline convention */
  PARENS_NEST_LIMIT,                         /* As it says */
  0,                                         /* Extra options */
  MAX_VARLOOKBEHIND,                         /* As it says */
  PCRE2_OPTIMIZATION_ALL                     /* All optimizations enabled */
  };

/* The create function copies the default into the new memory, but must
override the default memory handling functions if a gcontext was provided. */

PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
pcre2_compile_context_create(pcre2_general_context *gcontext)
{
pcre2_compile_context *ccontext = PRIV(memctl_malloc)(
  sizeof(pcre2_real_compile_context), (pcre2_memctl *)gcontext);
if (ccontext == NULL) return NULL;
*ccontext = PRIV(default_compile_context);
if (gcontext != NULL)
  *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
return ccontext;
}


/* A default match context is set up to save having to initialize at run time
when no context is supplied to a match function. */

pcre2_match_context PRIV(default_match_context) = {
  { default_malloc, default_free, NULL },
#ifdef SUPPORT_JIT
  NULL,          /* JIT callback */
  NULL,          /* JIT callback data */
#endif
  NULL,          /* Callout function */
  NULL,          /* Callout data */
  NULL,          /* Substitute callout function */
  NULL,          /* Substitute callout data */
  NULL,          /* Substitute case callout function */
  NULL,          /* Substitute case callout data */
  PCRE2_UNSET,   /* Offset limit */
  HEAP_LIMIT,
  MATCH_LIMIT,
  MATCH_LIMIT_DEPTH };

/* The create function copies the default into the new memory, but must
override the default memory handling functions if a gcontext was provided. */

PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
pcre2_match_context_create(pcre2_general_context *gcontext)
{
pcre2_match_context *mcontext = PRIV(memctl_malloc)(
  sizeof(pcre2_real_match_context), (pcre2_memctl *)gcontext);
if (mcontext == NULL) return NULL;
*mcontext = PRIV(default_match_context);
if (gcontext != NULL)
  *((pcre2_memctl *)mcontext) = *((pcre2_memctl *)gcontext);
return mcontext;
}


/* A default convert context is set up to save having to initialize at run time
when no context is supplied to the convert function. */

pcre2_convert_context PRIV(default_convert_context) = {
  { default_malloc, default_free, NULL },    /* Default memory handling */
#ifdef _WIN32
  CHAR_BACKSLASH,                            /* Default path separator */
  CHAR_GRAVE_ACCENT                          /* Default escape character */
#else  /* Not Windows */
  CHAR_SLASH,                                /* Default path separator */
  CHAR_BACKSLASH                             /* Default escape character */
#endif
  };

/* The create function copies the default into the new memory, but must
override the default memory handling functions if a gcontext was provided. */

PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
pcre2_convert_context_create(pcre2_general_context *gcontext)
{
pcre2_convert_context *ccontext = PRIV(memctl_malloc)(
  sizeof(pcre2_real_convert_context), (pcre2_memctl *)gcontext);
if (ccontext == NULL) return NULL;
*ccontext = PRIV(default_convert_context);
if (gcontext != NULL)
  *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
return ccontext;
}


/*************************************************
*              Context copy functions            *
*************************************************/

PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
pcre2_general_context_copy(pcre2_general_context *gcontext)
{
pcre2_general_context *newcontext =
  gcontext->memctl.malloc(sizeof(pcre2_real_general_context),
  gcontext->memctl.memory_data);
if (newcontext == NULL) return NULL;
memcpy(newcontext, gcontext, sizeof(pcre2_real_general_context));
return newcontext;
}


PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
pcre2_compile_context_copy(pcre2_compile_context *ccontext)
{
pcre2_compile_context *newcontext =
  ccontext->memctl.malloc(sizeof(pcre2_real_compile_context),
  ccontext->memctl.memory_data);
if (newcontext == NULL) return NULL;
memcpy(newcontext, ccontext, sizeof(pcre2_real_compile_context));
return newcontext;
}


PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
pcre2_match_context_copy(pcre2_match_context *mcontext)
{
pcre2_match_context *newcontext =
  mcontext->memctl.malloc(sizeof(pcre2_real_match_context),
  mcontext->memctl.memory_data);
if (newcontext == NULL) return NULL;
memcpy(newcontext, mcontext, sizeof(pcre2_real_match_context));
return newcontext;
}


PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
pcre2_convert_context_copy(pcre2_convert_context *ccontext)
{
pcre2_convert_context *newcontext =
  ccontext->memctl.malloc(sizeof(pcre2_real_convert_context),
  ccontext->memctl.memory_data);
if (newcontext == NULL) return NULL;
memcpy(newcontext, ccontext, sizeof(pcre2_real_convert_context));
return newcontext;
}


/*************************************************
*              Context free functions            *
*************************************************/

PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_general_context_free(pcre2_general_context *gcontext)
{
if (gcontext != NULL)
  gcontext->memctl.free(gcontext, gcontext->memctl.memory_data);
}


PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_compile_context_free(pcre2_compile_context *ccontext)
{
if (ccontext != NULL)
  ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
}


PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_match_context_free(pcre2_match_context *mcontext)
{
if (mcontext != NULL)
  mcontext->memctl.free(mcontext, mcontext->memctl.memory_data);
}


PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_convert_context_free(pcre2_convert_context *ccontext)
{
if (ccontext != NULL)
  ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
}


/*************************************************
*             Set values in contexts             *
*************************************************/

/* All these functions return 0 for success or PCRE2_ERROR_BADDATA if invalid
data is given. Only some of the functions are able to test the validity of the
data. */


/* ------------ Compile context ------------ */

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_character_tables(pcre2_compile_context *ccontext,
  const uint8_t *tables)
{
ccontext->tables = tables;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_bsr(pcre2_compile_context *ccontext, uint32_t value)
{
switch(value)
  {
  case PCRE2_BSR_ANYCRLF:
  case PCRE2_BSR_UNICODE:
  ccontext->bsr_convention = value;
  return 0;

  default:
  return PCRE2_ERROR_BADDATA;
  }
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_max_pattern_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
{
ccontext->max_pattern_length = length;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_max_pattern_compiled_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
{
ccontext->max_pattern_compiled_length = length;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_newline(pcre2_compile_context *ccontext, uint32_t newline)
{
switch(newline)
  {
  case PCRE2_NEWLINE_CR:
  case PCRE2_NEWLINE_LF:
  case PCRE2_NEWLINE_CRLF:
  case PCRE2_NEWLINE_ANY:
  case PCRE2_NEWLINE_ANYCRLF:
  case PCRE2_NEWLINE_NUL:
  ccontext->newline_convention = newline;
  return 0;

  default:
  return PCRE2_ERROR_BADDATA;
  }
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_max_varlookbehind(pcre2_compile_context *ccontext, uint32_t limit)
{
ccontext->max_varlookbehind = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext, uint32_t limit)
{
ccontext->parens_nest_limit = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_compile_extra_options(pcre2_compile_context *ccontext, uint32_t options)
{
ccontext->extra_options = options;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,
  int (*guard)(uint32_t, void *), void *user_data)
{
ccontext->stack_guard = guard;
ccontext->stack_guard_data = user_data;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_optimize(pcre2_compile_context *ccontext, uint32_t directive)
{
if (ccontext == NULL)
  return PCRE2_ERROR_NULL;

switch (directive)
  {
  case PCRE2_OPTIMIZATION_NONE:
  ccontext->optimization_flags = 0;
  break;

  case PCRE2_OPTIMIZATION_FULL:
  ccontext->optimization_flags = PCRE2_OPTIMIZATION_ALL;
  break;

  default:
  if (directive >= PCRE2_AUTO_POSSESS && directive <= PCRE2_START_OPTIMIZE_OFF)
    {
    /* Even directive numbers starting from 64 switch a bit on;
     * Odd directive numbers starting from 65 switch a bit off */
    if ((directive & 1) != 0)
      ccontext->optimization_flags &= ~(1u << ((directive >> 1) - 32));
    else
      ccontext->optimization_flags |= 1u << ((directive >> 1) - 32);
    return 0;
    }
  return PCRE2_ERROR_BADOPTION;
  }

return 0;
}

/* ------------ Match context ------------ */

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_callout(pcre2_match_context *mcontext,
  int (*callout)(pcre2_callout_block *, void *), void *callout_data)
{
mcontext->callout = callout;
mcontext->callout_data = callout_data;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_substitute_callout(pcre2_match_context *mcontext,
  int (*substitute_callout)(pcre2_substitute_callout_block *, void *),
  void *substitute_callout_data)
{
mcontext->substitute_callout = substitute_callout;
mcontext->substitute_callout_data = substitute_callout_data;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_substitute_case_callout(pcre2_match_context *mcontext,
  PCRE2_SIZE (*substitute_case_callout)(PCRE2_SPTR, PCRE2_SIZE, PCRE2_UCHAR *,
                                        PCRE2_SIZE, int, void *),
  void *substitute_case_callout_data)
{
mcontext->substitute_case_callout = substitute_case_callout;
mcontext->substitute_case_callout_data = substitute_case_callout_data;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_heap_limit(pcre2_match_context *mcontext, uint32_t limit)
{
mcontext->heap_limit = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_match_limit(pcre2_match_context *mcontext, uint32_t limit)
{
mcontext->match_limit = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_depth_limit(pcre2_match_context *mcontext, uint32_t limit)
{
mcontext->depth_limit = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_offset_limit(pcre2_match_context *mcontext, PCRE2_SIZE limit)
{
mcontext->offset_limit = limit;
return 0;
}

/* These functions became obsolete at release 10.30. The first is kept as a
synonym for backwards compatibility. The second now does nothing. Exclude both
from coverage reports. */

/* LCOV_EXCL_START */

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_recursion_limit(pcre2_match_context *mcontext, uint32_t limit)
{
return pcre2_set_depth_limit(mcontext, limit);
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_recursion_memory_management(pcre2_match_context *mcontext,
  void *(*mymalloc)(size_t, void *), void (*myfree)(void *, void *),
  void *mydata)
{
(void)mcontext;
(void)mymalloc;
(void)myfree;
(void)mydata;
return 0;
}

/* LCOV_EXCL_STOP */


/* ------------ Convert context ------------ */

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_glob_separator(pcre2_convert_context *ccontext, uint32_t separator)
{
if (separator != CHAR_SLASH && separator != CHAR_BACKSLASH &&
    separator != CHAR_DOT) return PCRE2_ERROR_BADDATA;
ccontext->glob_separator = separator;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_glob_escape(pcre2_convert_context *ccontext, uint32_t escape)
{
if (escape > 255 || (escape != 0 && !ispunct(escape)))
  return PCRE2_ERROR_BADDATA;
ccontext->glob_escape = escape;
return 0;
}

/* End of pcre2_context.c */


Coverage Report

Created: 2025-06-13 06:43

Line	Count	Source (jump to first uncovered line)
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-2024 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	0	{
58	0	(void)data;
59	0	return malloc(size);
60	0	}
61
62
63		static void default_free(void block, void data)
64	0	{
65	0	(void)data;
66	0	free(block);
67	0	}
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	200	{
88	200	pcre2_memctl *newmemctl;
89	200	void *yield = (memctl == NULL)? malloc(size) :
90	200	memctl->malloc(size, memctl->memory_data);
91	200	if (yield == NULL) return NULL;
92	200	newmemctl = (pcre2_memctl *)yield;
93	200	if (memctl == NULL)
94	0	{
95	0	newmemctl->malloc = default_malloc;
96	0	newmemctl->free = default_free;
97	0	newmemctl->memory_data = NULL;
98	0	}
99	200	else newmemctl = memctl;
100	200	return yield;
101	200	}
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	300k	{
118	300k	pcre2_general_context *gcontext;
119	300k	if (private_malloc == NULL) private_malloc = default_malloc;
120	300k	if (private_free == NULL) private_free = default_free;
121	300k	gcontext = private_malloc(sizeof(pcre2_real_general_context), memory_data);
122	300k	if (gcontext == NULL) return NULL;
123	300k	gcontext->memctl.malloc = private_malloc;
124	300k	gcontext->memctl.free = private_free;
125	300k	gcontext->memctl.memory_data = memory_data;
126	300k	return gcontext;
127	300k	}
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		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		PCRE2_UNSET, /* Max pattern compiled length */
140		BSR_DEFAULT, /* Backslash R default */
141		NEWLINE_DEFAULT, /* Newline convention */
142		PARENS_NEST_LIMIT, /* As it says */
143		0, /* Extra options */
144		MAX_VARLOOKBEHIND, /* As it says */
145		PCRE2_OPTIMIZATION_ALL /* All optimizations enabled */
146		};
147
148		/* The create function copies the default into the new memory, but must
149		override the default memory handling functions if a gcontext was provided. */
150
151		PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
152		pcre2_compile_context_create(pcre2_general_context *gcontext)
153	16	{
154	16	pcre2_compile_context *ccontext = PRIV(memctl_malloc)(
155	16	sizeof(pcre2_real_compile_context), (pcre2_memctl *)gcontext);
156	16	if (ccontext == NULL) return NULL;
157	16	*ccontext = PRIV(default_compile_context);
158	16	if (gcontext != NULL)
159	16	((pcre2_memctl )ccontext) = ((pcre2_memctl )gcontext);
160	16	return ccontext;
161	16	}
162
163
164		/* A default match context is set up to save having to initialize at run time
165		when no context is supplied to a match function. */
166
167		pcre2_match_context PRIV(default_match_context) = {
168		{ default_malloc, default_free, NULL },
169		#ifdef SUPPORT_JIT
170		NULL, /* JIT callback */
171		NULL, /* JIT callback data */
172		#endif
173		NULL, /* Callout function */
174		NULL, /* Callout data */
175		NULL, /* Substitute callout function */
176		NULL, /* Substitute callout data */
177		NULL, /* Substitute case callout function */
178		NULL, /* Substitute case callout data */
179		PCRE2_UNSET, /* Offset limit */
180		HEAP_LIMIT,
181		MATCH_LIMIT,
182		MATCH_LIMIT_DEPTH };
183
184		/* The create function copies the default into the new memory, but must
185		override the default memory handling functions if a gcontext was provided. */
186
187		PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
188		pcre2_match_context_create(pcre2_general_context *gcontext)
189	16	{
190	16	pcre2_match_context *mcontext = PRIV(memctl_malloc)(
191	16	sizeof(pcre2_real_match_context), (pcre2_memctl *)gcontext);
192	16	if (mcontext == NULL) return NULL;
193	16	*mcontext = PRIV(default_match_context);
194	16	if (gcontext != NULL)
195	16	((pcre2_memctl )mcontext) = ((pcre2_memctl )gcontext);
196	16	return mcontext;
197	16	}
198
199
200		/* A default convert context is set up to save having to initialize at run time
201		when no context is supplied to the convert function. */
202
203		pcre2_convert_context PRIV(default_convert_context) = {
204		{ default_malloc, default_free, NULL }, /* Default memory handling */
205		#ifdef _WIN32
206		CHAR_BACKSLASH, /* Default path separator */
207		CHAR_GRAVE_ACCENT /* Default escape character */
208		#else /* Not Windows */
209		CHAR_SLASH, /* Default path separator */
210		CHAR_BACKSLASH /* Default escape character */
211		#endif
212		};
213
214		/* The create function copies the default into the new memory, but must
215		override the default memory handling functions if a gcontext was provided. */
216
217		PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
218		pcre2_convert_context_create(pcre2_general_context *gcontext)
219	0	{
220	0	pcre2_convert_context *ccontext = PRIV(memctl_malloc)(
221	0	sizeof(pcre2_real_convert_context), (pcre2_memctl *)gcontext);
222	0	if (ccontext == NULL) return NULL;
223	0	*ccontext = PRIV(default_convert_context);
224	0	if (gcontext != NULL)
225	0	((pcre2_memctl )ccontext) = ((pcre2_memctl )gcontext);
226	0	return ccontext;
227	0	}
228
229
230		/*************************************************
231		* Context copy functions *
232		*************************************************/
233
234		PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
235		pcre2_general_context_copy(pcre2_general_context *gcontext)
236	0	{
237	0	pcre2_general_context *newcontext =
238	0	gcontext->memctl.malloc(sizeof(pcre2_real_general_context),
239	0	gcontext->memctl.memory_data);
240	0	if (newcontext == NULL) return NULL;
241	0	memcpy(newcontext, gcontext, sizeof(pcre2_real_general_context));
242	0	return newcontext;
243	0	}
244
245
246		PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
247		pcre2_compile_context_copy(pcre2_compile_context *ccontext)
248	0	{
249	0	pcre2_compile_context *newcontext =
250	0	ccontext->memctl.malloc(sizeof(pcre2_real_compile_context),
251	0	ccontext->memctl.memory_data);
252	0	if (newcontext == NULL) return NULL;
253	0	memcpy(newcontext, ccontext, sizeof(pcre2_real_compile_context));
254	0	return newcontext;
255	0	}
256
257
258		PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
259		pcre2_match_context_copy(pcre2_match_context *mcontext)
260	0	{
261	0	pcre2_match_context *newcontext =
262	0	mcontext->memctl.malloc(sizeof(pcre2_real_match_context),
263	0	mcontext->memctl.memory_data);
264	0	if (newcontext == NULL) return NULL;
265	0	memcpy(newcontext, mcontext, sizeof(pcre2_real_match_context));
266	0	return newcontext;
267	0	}
268
269
270		PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
271		pcre2_convert_context_copy(pcre2_convert_context *ccontext)
272	0	{
273	0	pcre2_convert_context *newcontext =
274	0	ccontext->memctl.malloc(sizeof(pcre2_real_convert_context),
275	0	ccontext->memctl.memory_data);
276	0	if (newcontext == NULL) return NULL;
277	0	memcpy(newcontext, ccontext, sizeof(pcre2_real_convert_context));
278	0	return newcontext;
279	0	}
280
281
282		/*************************************************
283		* Context free functions *
284		*************************************************/
285
286		PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
287		pcre2_general_context_free(pcre2_general_context *gcontext)
288	300k	{
289	300k	if (gcontext != NULL)
290	300k	gcontext->memctl.free(gcontext, gcontext->memctl.memory_data);
291	300k	}
292
293
294		PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
295		pcre2_compile_context_free(pcre2_compile_context *ccontext)
296	0	{
297	0	if (ccontext != NULL)
298	0	ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
299	0	}
300
301
302		PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
303		pcre2_match_context_free(pcre2_match_context *mcontext)
304	0	{
305	0	if (mcontext != NULL)
306	0	mcontext->memctl.free(mcontext, mcontext->memctl.memory_data);
307	0	}
308
309
310		PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
311		pcre2_convert_context_free(pcre2_convert_context *ccontext)
312	0	{
313	0	if (ccontext != NULL)
314	0	ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
315	0	}
316
317
318		/*************************************************
319		* Set values in contexts *
320		*************************************************/
321
322		/* All these functions return 0 for success or PCRE2_ERROR_BADDATA if invalid
323		data is given. Only some of the functions are able to test the validity of the
324		data. */
325
326
327		/* ------------ Compile context ------------ */
328
329		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
330		pcre2_set_character_tables(pcre2_compile_context *ccontext,
331		const uint8_t *tables)
332	2.39k	{
333	2.39k	ccontext->tables = tables;
334	2.39k	return 0;
335	2.39k	}
336
337		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
338		pcre2_set_bsr(pcre2_compile_context *ccontext, uint32_t value)
339	0	{
340	0	switch(value)
341	0	{
342	0	case PCRE2_BSR_ANYCRLF:
343	0	case PCRE2_BSR_UNICODE:
344	0	ccontext->bsr_convention = value;
345	0	return 0;
346
347	0	default:
348	0	return PCRE2_ERROR_BADDATA;
349	0	}
350	0	}
351
352		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
353		pcre2_set_max_pattern_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
354	0	{
355	0	ccontext->max_pattern_length = length;
356	0	return 0;
357	0	}
358
359		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
360		pcre2_set_max_pattern_compiled_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
361	0	{
362	0	ccontext->max_pattern_compiled_length = length;
363	0	return 0;
364	0	}
365
366		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
367		pcre2_set_newline(pcre2_compile_context *ccontext, uint32_t newline)
368	0	{
369	0	switch(newline)
370	0	{
371	0	case PCRE2_NEWLINE_CR:
372	0	case PCRE2_NEWLINE_LF:
373	0	case PCRE2_NEWLINE_CRLF:
374	0	case PCRE2_NEWLINE_ANY:
375	0	case PCRE2_NEWLINE_ANYCRLF:
376	0	case PCRE2_NEWLINE_NUL:
377	0	ccontext->newline_convention = newline;
378	0	return 0;
379
380	0	default:
381	0	return PCRE2_ERROR_BADDATA;
382	0	}
383	0	}
384
385		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
386		pcre2_set_max_varlookbehind(pcre2_compile_context *ccontext, uint32_t limit)
387	0	{
388	0	ccontext->max_varlookbehind = limit;
389	0	return 0;
390	0	}
391
392		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
393		pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext, uint32_t limit)
394	0	{
395	0	ccontext->parens_nest_limit = limit;
396	0	return 0;
397	0	}
398
399		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
400		pcre2_set_compile_extra_options(pcre2_compile_context *ccontext, uint32_t options)
401	2.39k	{
402	2.39k	ccontext->extra_options = options;
403	2.39k	return 0;
404	2.39k	}
405
406		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
407		pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,
408		int (guard)(uint32_t, void ), void *user_data)
409	0	{
410	0	ccontext->stack_guard = guard;
411	0	ccontext->stack_guard_data = user_data;
412	0	return 0;
413	0	}
414
415		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
416		pcre2_set_optimize(pcre2_compile_context *ccontext, uint32_t directive)
417	0	{
418	0	if (ccontext == NULL)
419	0	return PCRE2_ERROR_NULL;
420
421	0	switch (directive)
422	0	{
423	0	case PCRE2_OPTIMIZATION_NONE:
424	0	ccontext->optimization_flags = 0;
425	0	break;
426
427	0	case PCRE2_OPTIMIZATION_FULL:
428	0	ccontext->optimization_flags = PCRE2_OPTIMIZATION_ALL;
429	0	break;
430
431	0	default:
432	0	if (directive >= PCRE2_AUTO_POSSESS && directive <= PCRE2_START_OPTIMIZE_OFF)
433	0	{
434		/* Even directive numbers starting from 64 switch a bit on;
435		* Odd directive numbers starting from 65 switch a bit off */
436	0	if ((directive & 1) != 0)
437	0	ccontext->optimization_flags &= ~(1u << ((directive >> 1) - 32));
438	0	else
439	0	ccontext->optimization_flags \|= 1u << ((directive >> 1) - 32);
440	0	return 0;
441	0	}
442	0	return PCRE2_ERROR_BADOPTION;
443	0	}
444
445	0	return 0;
446	0	}
447
448		/* ------------ Match context ------------ */
449
450		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
451		pcre2_set_callout(pcre2_match_context *mcontext,
452		int (callout)(pcre2_callout_block , void ), void callout_data)
453	0	{
454	0	mcontext->callout = callout;
455	0	mcontext->callout_data = callout_data;
456	0	return 0;
457	0	}
458
459		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
460		pcre2_set_substitute_callout(pcre2_match_context *mcontext,
461		int (substitute_callout)(pcre2_substitute_callout_block , void *),
462		void *substitute_callout_data)
463	0	{
464	0	mcontext->substitute_callout = substitute_callout;
465	0	mcontext->substitute_callout_data = substitute_callout_data;
466	0	return 0;
467	0	}
468
469		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
470		pcre2_set_substitute_case_callout(pcre2_match_context *mcontext,
471		PCRE2_SIZE (substitute_case_callout)(PCRE2_SPTR, PCRE2_SIZE, PCRE2_UCHAR ,
472		PCRE2_SIZE, int, void *),
473		void *substitute_case_callout_data)
474	0	{
475	0	mcontext->substitute_case_callout = substitute_case_callout;
476	0	mcontext->substitute_case_callout_data = substitute_case_callout_data;
477	0	return 0;
478	0	}
479
480		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
481		pcre2_set_heap_limit(pcre2_match_context *mcontext, uint32_t limit)
482	0	{
483	0	mcontext->heap_limit = limit;
484	0	return 0;
485	0	}
486
487		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
488		pcre2_set_match_limit(pcre2_match_context *mcontext, uint32_t limit)
489	16	{
490	16	mcontext->match_limit = limit;
491	16	return 0;
492	16	}
493
494		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
495		pcre2_set_depth_limit(pcre2_match_context *mcontext, uint32_t limit)
496	16	{
497	16	mcontext->depth_limit = limit;
498	16	return 0;
499	16	}
500
501		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
502		pcre2_set_offset_limit(pcre2_match_context *mcontext, PCRE2_SIZE limit)
503	0	{
504	0	mcontext->offset_limit = limit;
505	0	return 0;
506	0	}
507
508		/* These functions became obsolete at release 10.30. The first is kept as a
509		synonym for backwards compatibility. The second now does nothing. Exclude both
510		from coverage reports. */
511
512		/* LCOV_EXCL_START */
513
514		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
515		pcre2_set_recursion_limit(pcre2_match_context *mcontext, uint32_t limit)
516	0	{
517	0	return pcre2_set_depth_limit(mcontext, limit);
518	0	}
519
520		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
521		pcre2_set_recursion_memory_management(pcre2_match_context *mcontext,
522		void (mymalloc)(size_t, void ), void (myfree)(void , void ),
523		void *mydata)
524	0	{
525	0	(void)mcontext;
526	0	(void)mymalloc;
527	0	(void)myfree;
528	0	(void)mydata;
529	0	return 0;
530	0	}
531
532		/* LCOV_EXCL_STOP */
533
534
535		/* ------------ Convert context ------------ */
536
537		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
538		pcre2_set_glob_separator(pcre2_convert_context *ccontext, uint32_t separator)
539	0	{
540	0	if (separator != CHAR_SLASH && separator != CHAR_BACKSLASH &&
541	0	separator != CHAR_DOT) return PCRE2_ERROR_BADDATA;
542	0	ccontext->glob_separator = separator;
543	0	return 0;
544	0	}
545
546		PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
547		pcre2_set_glob_escape(pcre2_convert_context *ccontext, uint32_t escape)
548	0	{
549	0	if (escape > 255 \|\| (escape != 0 && !ispunct(escape)))
550	0	return PCRE2_ERROR_BADDATA;
551	0	ccontext->glob_escape = escape;
552	0	return 0;
553	0	}
554
555		/* End of pcre2_context.c */
556