pcre2.h File Reference

PCRE2 compilation and match helpers. More...

Go to the source code of this file.

Macros
#define	PCRE2_CODE_UNIT_WIDTH   8

Functions
pcre2_code *	asciichat_pcre2_compile (const char *pattern, uint32_t flags)
char *	asciichat_pcre2_extract_named_group (pcre2_code *regex, pcre2_match_data *match_data, const char *group_name, const char *subject)
	Extract named substring from PCRE2 match data.
char *	asciichat_pcre2_extract_group (pcre2_match_data *match_data, int group_num, const char *subject)
	Extract numbered capture group as allocated string.
const char *	asciichat_pcre2_extract_group_ptr (pcre2_match_data *match_data, int group_num, const char *subject, size_t *out_len)
	Extract numbered capture group as pointer into subject (non-allocating).
bool	asciichat_pcre2_extract_group_ulong (pcre2_match_data *match_data, int group_num, const char *subject, unsigned long *out_value)
	Extract numbered capture group and convert to unsigned long.
int	asciichat_pcre2_match (const pcre2_code *code, PCRE2_SPTR subject, PCRE2_SIZE length, PCRE2_SIZE startoffset, uint32_t options, pcre2_match_data *match_data, pcre2_match_context *context)

Detailed Description

PCRE2 compilation and match helpers.

Compiled patterns are owned and freed by their callers.

Definition in file pcre2.h.

Macro Definition Documentation

PCRE2_CODE_UNIT_WIDTH

#define PCRE2_CODE_UNIT_WIDTH   8

Definition at line 11 of file pcre2.h.

Function Documentation

asciichat_pcre2_compile()

pcre2_code * asciichat_pcre2_compile	(	const char *	pattern,
		uint32_t	flags )

Compile a pattern owned by the caller, who must call pcre2_code_free().

Definition at line 16 of file pcre2.c.

                                                                         {
  int error;
  PCRE2_SIZE offset;
  return pcre2_compile((PCRE2_SPTR)pattern, PCRE2_ZERO_TERMINATED, flags, &error, &offset, NULL);
}

Referenced by grep_init(), log_search_enter_mode(), log_search_exit_mode(), and log_search_init().

asciichat_pcre2_extract_group()

char * asciichat_pcre2_extract_group	(	pcre2_match_data *	match_data,
		int	group_num,
		const char *	subject )

Extract numbered capture group as allocated string.

Extracts a numbered capture group from match data and returns an allocated string. The caller is responsible for freeing the returned string with SAFE_FREE().

Parameters

match_data	Match data from pcre2_match() or pcre2_jit_match()
group_num	Capture group number (1-based, 0 = entire match)
subject	Original subject string that was matched

Returns

Allocated string containing the matched substring, or NULL if group not matched

Example:

char *foundation = asciichat_pcre2_extract_group(match_data, 1, line);
if (foundation) {
  // Use foundation...
  SAFE_FREE(foundation);
}

Definition at line 73 of file pcre2.c.

                                                                                                      {
  if (!match_data || !subject || group_num < 0) {
    return NULL;
  }
 
  /* Get ovector (output vector with match offsets) */
  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
  PCRE2_SIZE start = ovector[2 * group_num];
  PCRE2_SIZE end = ovector[2 * group_num + 1];
 
  if (start == PCRE2_UNSET || end == PCRE2_UNSET) {
    return NULL; /* Group not matched */
  }
 
  /* Allocate and copy substring */
  size_t len = end - start;
  char *result = SAFE_MALLOC(len + 1, char *);
  if (!result) {
    log_error("failed to allocate %zu bytes", len + 1);
    return NULL;
  }
 
  memcpy(result, subject + start, len);
  result[len] = '\0';
 
  return result;
}

References log_error, and SAFE_MALLOC.

asciichat_pcre2_extract_group_ptr()

const char * asciichat_pcre2_extract_group_ptr	(	pcre2_match_data *	match_data,
		int	group_num,
		const char *	subject,
		size_t *	out_len )

Extract numbered capture group as pointer into subject (non-allocating).

Returns a pointer to the matched substring within the original subject string. No memory allocation occurs - the returned pointer is only valid as long as the subject string remains valid.

Parameters

match_data	Match data from pcre2_match() or pcre2_jit_match()
group_num	Capture group number (1-based, 0 = entire match)
subject	Original subject string that was matched
out_len	Output parameter for substring length

Returns

Pointer to matched substring within subject, or NULL if group not matched

Example:

size_t len;
const char *video_id = asciichat_pcre2_extract_group_ptr(match_data, 1, url, &len);
if (video_id) {
  printf("Video ID: %.*s\n", (int)len, video_id);
}

Definition at line 104 of file pcre2.c.

                                                               {
  if (!match_data || !subject || !out_len || group_num < 0) {
    return NULL;
  }
 
  /* Get ovector (output vector with match offsets) */
  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
  PCRE2_SIZE start = ovector[2 * group_num];
  PCRE2_SIZE end = ovector[2 * group_num + 1];
 
  if (start == PCRE2_UNSET || end == PCRE2_UNSET) {
    return NULL; /* Group not matched */
  }
 
  *out_len = end - start;
  return subject + start;
}

Referenced by stun_servers_parse().

asciichat_pcre2_extract_group_ulong()

bool asciichat_pcre2_extract_group_ulong	(	pcre2_match_data *	match_data,
		int	group_num,
		const char *	subject,
		unsigned long *	out_value )

Extract numbered capture group and convert to unsigned long.

Extracts a numbered capture group and converts it to an unsigned long integer. Handles extraction and parsing in one step.

Parameters

match_data	Match data from pcre2_match() or pcre2_jit_match()
group_num	Capture group number (1-based, 0 = entire match)
subject	Original subject string that was matched
out_value	Output parameter for parsed integer value

Returns

true if extraction and parsing succeeded, false otherwise

Example:

unsigned long component_id;
if (asciichat_pcre2_extract_group_ulong(match_data, 2, line, &component_id)) {
  candidate->component_id = (uint32_t)component_id;
}

Definition at line 126 of file pcre2.c.

                                                                   {
  if (!match_data || !subject || !out_value || group_num < 0) {
    return false;
  }
 
  /* Get ovector (output vector with match offsets) */
  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
  PCRE2_SIZE start = ovector[2 * group_num];
  PCRE2_SIZE end = ovector[2 * group_num + 1];
 
  if (start == PCRE2_UNSET || end == PCRE2_UNSET) {
    return false; /* Group not matched */
  }
 
  /* Extract substring into temporary buffer */
  size_t len = end - start;
  if (len == 0 || len > 63) { /* Sanity check for reasonable number length */
    return false;
  }
 
  char temp[UTIL_PCRE2_TEMP_BUFFER_SIZE];
  memcpy(temp, subject + start, len);
  temp[len] = '\0';
 
  /* Parse as unsigned long */
  char *endptr;
  errno = 0;
  unsigned long value = strtoul(temp, &endptr, 10);
 
  if (errno != 0 || endptr == temp || *endptr != '\0') {
    return false; /* Parse failed */
  }
 
  *out_value = value;
  return true;
}

References errno, and UTIL_PCRE2_TEMP_BUFFER_SIZE.

asciichat_pcre2_extract_named_group()

char * asciichat_pcre2_extract_named_group	(	pcre2_code *	regex,
		pcre2_match_data *	match_data,
		const char *	group_name,
		const char *	subject )

Extract named substring from PCRE2 match data.

Extracts a named capture group from match data and returns an allocated string. The caller is responsible for freeing the returned string with SAFE_FREE().

Parameters

regex	Compiled PCRE2 regex with named groups
match_data	Match data from pcre2_match() or pcre2_jit_match()
group_name	Name of the capture group to extract
subject	Original subject string that was matched

Returns

Allocated string containing the matched substring, or NULL if group not matched

Example:

pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(regex, NULL);
int rc = pcre2_jit_match(regex, (PCRE2_SPTR)subject, strlen(subject), 0, 0, match_data, NULL);
if (rc >= 0) {
  char *value = asciichat_pcre2_extract_named_group(regex, match_data, "fieldname", subject);
  if (value) {
    // Use value...
    SAFE_FREE(value);
  }
}
pcre2_match_data_free(match_data);

Extracts a named capture group from match data and returns an allocated string. The caller is responsible for freeing the returned string with SAFE_FREE().

Parameters

regex	Compiled PCRE2 regex with named groups
match_data	Match data from pcre2_match() or pcre2_jit_match()
group_name	Name of the capture group to extract
subject	Original subject string that was matched

Returns

Allocated string containing the matched substring, or NULL if group not matched

Definition at line 34 of file pcre2.c.

                                                               {
  if (!regex || !match_data || !group_name || !subject) {
    log_error("invalid parameters");
    return NULL;
  }
 
  /* Get group number from name */
  int group_number = pcre2_substring_number_from_name(regex, (PCRE2_SPTR)group_name);
  if (group_number < 0) {
    return NULL; /* Group doesn't exist */
  }
 
  /* Get ovector (output vector with match offsets) */
  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
  PCRE2_SIZE start = ovector[2 * group_number];
  PCRE2_SIZE end = ovector[2 * group_number + 1];
 
  if (start == PCRE2_UNSET || end == PCRE2_UNSET) {
    return NULL; /* Group not matched */
  }
 
  /* Allocate and copy substring */
  size_t len = end - start;
  char *result = SAFE_MALLOC(len + 1, char *);
  if (!result) {
    log_error("failed to allocate %zu bytes", len + 1);
    return NULL;
  }
 
  memcpy(result, subject + start, len);
  result[len] = '\0';
 
  return result;
}

References log_error, and SAFE_MALLOC.

Referenced by crypto_regex_extract_gpg_keygrip(), crypto_regex_extract_pem_base64(), crypto_regex_match_known_hosts(), crypto_regex_match_public_key(), and url_parse().

asciichat_pcre2_match()

int asciichat_pcre2_match	(	const pcre2_code *	code,
		PCRE2_SPTR	subject,
		PCRE2_SIZE	length,
		PCRE2_SIZE	startoffset,
		uint32_t	options,
		pcre2_match_data *	match_data,
		pcre2_match_context *	context )

Match with the JIT fast path, using the interpreter when JIT is unavailable. Returns the native PCRE2 capture count or negative PCRE2 error code.

Definition at line 164 of file pcre2.c.

                                                                                                        {
  int result = pcre2_jit_match(code, subject, length, startoffset, options, match_data, context);
  if (result == PCRE2_ERROR_JIT_BADOPTION || result == PCRE2_ERROR_JIT_STACKLIMIT)
    return pcre2_match(code, subject, length, startoffset, options | PCRE2_NO_JIT, match_data, context);
  return result;
}

Referenced by grep_highlight_colored(), grep_should_output(), stun_servers_parse(), and url_parse().