Regular Expressions

Defines
#define	switch_regex_safe_free(re)
Typedefs
typedef real_pcre	switch_regex_t
Functions
switch_regex_t *	switch_regex_compile (const char *pattern, int options, const char **errorptr, int *erroroffset, const unsigned char *tables)
int	switch_regex_copy_substring (const char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, int size)
void	switch_regex_free (void *data)
int	switch_regex_perform (const char *field, const char *expression, switch_regex_t **new_re, int *ovector, uint32_t olen)
void	switch_perform_substitution (switch_regex_t *re, int match_count, const char *data, const char *field_data, char *substituted, switch_size_t len, int *ovector)
switch_status_t	switch_regex_match (const char *target, const char *expression)
	Function to evaluate an expression against a string.
switch_status_t	switch_regex_match_partial (const char *target, const char *expression, int *partial_match)
	Function to evaluate an expression against a string.
void	switch_capture_regex (switch_regex_t *re, int match_count, const char *field_data, int *ovector, const char *var, switch_cap_callback_t callback, void *user_data)
void	switch_regex_set_var_callback (const char *var, const char *val, void *user_data)
void	switch_regex_set_event_header_callback (const char *var, const char *val, void *user_data)

---

Define Documentation

#define switch_regex_safe_free

(

re

)

Value:

if (re) {\
                                switch_regex_free(re);\
                                re = NULL;\
                        }

Definition at line 79 of file switch_regex.h.

Referenced by switch_ivr_check_presence_mapping(), switch_ivr_menu_execute(), switch_ivr_phrase_macro_event(), switch_regex_perform(), and switch_str_time().

---

Typedef Documentation

typedef struct real_pcre switch_regex_t

Definition at line 43 of file switch_regex.h.

---

Function Documentation

void switch_capture_regex	(	switch_regex_t *	re,
		int	match_count,
		const char *	field_data,
		int *	ovector,
		const char *	var,
		switch_cap_callback_t	callback,
		void *	user_data
	)

Definition at line 173 of file switch_regex.c.

{


        const char *replace;
        int i;

        for (i = 0; i < match_count; i++) {
                if (pcre_get_substring(field_data, ovector, match_count, i, &replace) > 0) {
                        callback(var, replace, user_data);
                        pcre_free_substring(replace);
                }
        }
}

void switch_perform_substitution	(	switch_regex_t *	re,
		int	match_count,
		const char *	data,
		const char *	field_data,
		char *	substituted,
		switch_size_t	len,
		int *	ovector
	)

Definition at line 128 of file switch_regex.c.

Referenced by switch_ivr_menu_execute(), and switch_ivr_phrase_macro_event().

{
        char index[10] = "";
        const char *replace = NULL;
        switch_size_t x, y = 0, z = 0;
        int num = 0;

        for (x = 0; x < (len - 1) && x < strlen(data);) {
                if (data[x] == '$') {
                        x++;

                        if (!(data[x] > 47 && data[x] < 58)) {
                                substituted[y++] = data[x - 1];
                                continue;
                        }

                        while (data[x] > 47 && data[x] < 58) {
                                index[z++] = data[x];
                                x++;
                        }
                        index[z++] = '\0';
                        z = 0;
                        num = atoi(index);

                        if (num < 0 || num > 256) {
                                num = -1;
                        }

                        if (pcre_get_substring(field_data, ovector, match_count, num, &replace) > 0) {
                                switch_size_t r;
                                for (r = 0; r < strlen(replace); r++) {
                                        substituted[y++] = replace[r];
                                }
                                pcre_free_substring(replace);
                        }
                } else {
                        substituted[y++] = data[x];
                        x++;
                }
        }
        substituted[y++] = '\0';
}

switch_regex_t* switch_regex_compile	(	const char *	pattern,
		int	options,
		const char **	errorptr,
		int *	erroroffset,
		const unsigned char *	tables
	)

Definition at line 36 of file switch_regex.c.

{

        return pcre_compile(pattern, options, errorptr, erroroffset, tables);

}

int switch_regex_copy_substring	(	const char *	subject,
		int *	ovector,
		int	stringcount,
		int	stringnumber,
		char *	buffer,
		int	size
	)

Definition at line 44 of file switch_regex.c.

Referenced by switch_str_time().

{
        return pcre_copy_substring(subject, ovector, stringcount, stringnumber, buffer, size);
}

void switch_regex_free

(

void *

data

)

Definition at line 49 of file switch_regex.c.

{
        pcre_free(data);

}

switch_status_t switch_regex_match	(	const char *	target,
		const char *	expression
	)

Function to evaluate an expression against a string.

Parameters:

	target	The string to find a match in
	expression	The regular expression to run against the string

Returns:

Boolean if a match was found or not

Definition at line 246 of file switch_regex.c.

References switch_regex_match_partial().

Referenced by switch_ivr_dmachine_check_match(), and switch_play_and_get_digits().

{
        int partial = 0;
        return switch_regex_match_partial(target, expression, &partial);
}

switch_status_t switch_regex_match_partial	(	const char *	target,
		const char *	expression,
		int *	partial_match
	)

Function to evaluate an expression against a string.

Parameters:

	target	The string to find a match in
	expression	The regular expression to run against the string
	partial	If non-zero returns SUCCESS if the target is a partial match, on successful return, this is set to non-zero if the match was partial and zero if it was a full match

Returns:

Boolean if a match was found or not

Definition at line 190 of file switch_regex.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_regex_match().

{
        const char *error = NULL;       /* Used to hold any errors                                           */
        int error_offset = 0;           /* Holds the offset of an error                                      */
        pcre *pcre_prepared = NULL;     /* Holds the compiled regex                                          */
        int match_count = 0;            /* Number of times the regex was matched                             */
        int offset_vectors[255];        /* not used, but has to exist or pcre won't even try to find a match */
        int pcre_flags = 0;

        /* Compile the expression */
        pcre_prepared = pcre_compile(expression, 0, &error, &error_offset, NULL);

        /* See if there was an error in the expression */
        if (error != NULL) {
                /* Clean up after ourselves */
                if (pcre_prepared) {
                        pcre_free(pcre_prepared);
                        pcre_prepared = NULL;
                }
                /* Note our error */
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                  "Regular Expression Error expression[%s] error[%s] location[%d]\n", expression, error, error_offset);

                /* We definitely didn't match anything */
                return SWITCH_STATUS_FALSE;
        }

        if (*partial) {
                pcre_flags = PCRE_PARTIAL;
        }

        /* So far so good, run the regex */
        match_count =
                pcre_exec(pcre_prepared, NULL, target, (int) strlen(target), 0, pcre_flags, offset_vectors, sizeof(offset_vectors) / sizeof(offset_vectors[0]));

        /* Clean up */
        if (pcre_prepared) {
                pcre_free(pcre_prepared);
                pcre_prepared = NULL;
        }

        /* switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "number of matches: %d\n", match_count); */

        /* Was it a match made in heaven? */
        if (match_count > 0) {
                *partial = 0;
                return SWITCH_STATUS_SUCCESS;
        } else if (match_count == PCRE_ERROR_PARTIAL || match_count == PCRE_ERROR_BADPARTIAL) {
                /* yes it is already set, but the code is clearer this way */
                *partial = 1;
                return SWITCH_STATUS_SUCCESS;
        } else {
                return SWITCH_STATUS_FALSE;
        }
}

int switch_regex_perform	(	const char *	field,
		const char *	expression,
		switch_regex_t **	new_re,
		int *	ovector,
		uint32_t	olen
	)

Definition at line 55 of file switch_regex.c.

References switch_ast2regex(), SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), switch_regex_safe_free, and switch_safe_free.

Referenced by switch_ivr_check_presence_mapping(), switch_ivr_menu_execute(), switch_ivr_phrase_macro_event(), and switch_str_time().

{
        const char *error = NULL;
        int erroffset = 0;
        pcre *re = NULL;
        int match_count = 0;
        char *tmp = NULL;
        uint32_t flags = 0;
        char abuf[256] = "";

        if (!(field && expression)) {
                return 0;
        }

        if (*expression == '_') {
                if (switch_ast2regex(expression + 1, abuf, sizeof(abuf))) {
                        expression = abuf;
                }
        }

        if (*expression == '/') {
                char *opts = NULL;
                tmp = strdup(expression + 1);
                assert(tmp);
                if ((opts = strrchr(tmp, '/'))) {
                        *opts++ = '\0';
                } else {
                        goto end;
                }
                expression = tmp;
                if (opts) {
                        if (strchr(opts, 'i')) {
                                flags |= PCRE_CASELESS;
                        }
                        if (strchr(opts, 's')) {
                                flags |= PCRE_DOTALL;
                        }
                }
        }

        re = pcre_compile(expression,   /* the pattern */
                                          flags,        /* default options */
                                          &error,       /* for error message */
                                          &erroffset,   /* for error offset */
                                          NULL);        /* use default character tables */
        if (error) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "COMPILE ERROR: %d [%s][%s]\n", erroffset, error, expression);
                switch_regex_safe_free(re);
                goto end;
        }

        match_count = pcre_exec(re,     /* result of pcre_compile() */
                                                        NULL,   /* we didn't study the pattern */
                                                        field,  /* the subject string */
                                                        (int) strlen(field),    /* the length of the subject string */
                                                        0,      /* start at offset 0 in the subject */
                                                        0,      /* default options */
                                                        ovector,        /* vector of integers for substring information */
                                                        olen);  /* number of elements (NOT size in bytes) */


        if (match_count <= 0) {
                switch_regex_safe_free(re);
                match_count = 0;
        }

        *new_re = (switch_regex_t *) re;

  end:
        switch_safe_free(tmp);
        return match_count;
}

void switch_regex_set_event_header_callback	(	const char *	var,
		const char *	val,
		void *	user_data
	)

Definition at line 259 of file switch_regex.c.

References switch_event_add_header_string(), and SWITCH_STACK_BOTTOM.

{

        switch_event_t *event = (switch_event_t *) user_data;
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, var, val);
}

void switch_regex_set_var_callback	(	const char *	var,
		const char *	val,
		void *	user_data
	)

Definition at line 252 of file switch_regex.c.

References switch_channel_add_variable_var_check(), switch_core_session_get_channel(), SWITCH_FALSE, and SWITCH_STACK_PUSH.

{
        switch_core_session_t *session = (switch_core_session_t *) user_data;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_channel_add_variable_var_check(channel, var, val, SWITCH_FALSE, SWITCH_STACK_PUSH);
}

---