mc/src/search/regex.c

698 lines
23 KiB
C
Raw Normal View History

/*
Search text engine.
Regex search
Copyright (C) 2009 The Free Software Foundation, Inc.
Written by:
Slava Zanko <slavazanko@gmail.com>, 2009.
This file is part of the Midnight Commander.
The Midnight Commander is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The Midnight Commander is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA.
*/
#include <config.h>
#include "../src/global.h"
#include "../src/search/search.h"
#include "../src/search/internal.h"
#include "../src/strutil.h"
#include "../src/strescape.h"
#include "../src/charsets.h"
/*** global variables ****************************************************************************/
/*** file scope macro definitions ****************************************************************/
/*** file scope type declarations ****************************************************************/
typedef enum {
REPLACE_T_NO_TRANSFORM = 0,
REPLACE_T_UPP_TRANSFORM_CHAR = 1,
REPLACE_T_LOW_TRANSFORM_CHAR = 2,
REPLACE_T_UPP_TRANSFORM = 4,
REPLACE_T_LOW_TRANSFORM = 8
} replace_transform_type_t;
/*** file scope variables ************************************************************************/
/*** file scope functions ************************************************************************/
static gboolean
mc_search__regex_str_append_if_special (GString * copy_to, GString * regex_str, gsize * offset)
{
char *tmp_regex_str;
gsize spec_chr_len;
char **spec_chr;
char *special_chars[] = {
"\\s", "\\S",
"\\d", "\\D",
"\\B", "\\B",
"\\w", "\\W",
"\\t", "\\n",
"\\r", "\\f",
"\\a", "\\e",
"\\x", "\\X",
"\\c", "\\C",
"\\l", "\\L",
"\\u", "\\U",
"\\E", "\\Q",
NULL
};
spec_chr = special_chars;
tmp_regex_str = &(regex_str->str[*offset]);
while (*spec_chr) {
spec_chr_len = strlen (*spec_chr);
if (!strncmp (tmp_regex_str, *spec_chr, spec_chr_len)) {
if (!strutils_is_char_escaped (regex_str->str, tmp_regex_str)) {
if (!strncmp ("\\x", *spec_chr, spec_chr_len)) {
if (*(tmp_regex_str + spec_chr_len) == '{') {
while ((spec_chr_len < regex_str->len - *offset)
&& *(tmp_regex_str + spec_chr_len) != '}')
spec_chr_len++;
if (*(tmp_regex_str + spec_chr_len) == '}')
spec_chr_len++;
} else
spec_chr_len += 2;
}
g_string_append_len (copy_to, tmp_regex_str, spec_chr_len);
*offset += spec_chr_len;
return TRUE;
}
}
spec_chr++;
}
return FALSE;
}
/* --------------------------------------------------------------------------------------------- */
static void
mc_search__cond_struct_new_regex_hex_add (const char *charset, GString * str_to,
const char *one_char, gsize str_len)
{
GString *upp, *low;
gchar *tmp_str;
gsize loop;
upp = mc_search__toupper_case_str (charset, one_char, str_len);
low = mc_search__tolower_case_str (charset, one_char, str_len);
for (loop = 0; loop < upp->len; loop++) {
if (loop < low->len) {
if (upp->str[loop] == low->str[loop])
tmp_str = g_strdup_printf ("\\x%02X", (unsigned char) upp->str[loop]);
else
tmp_str =
g_strdup_printf ("[\\x%02X\\x%02X]", (unsigned char) upp->str[loop],
(unsigned char) low->str[loop]);
} else {
tmp_str = g_strdup_printf ("\\x%02X", (unsigned char) upp->str[loop]);
}
g_string_append (str_to, tmp_str);
g_free (tmp_str);
}
g_string_free (upp, TRUE);
g_string_free (low, TRUE);
}
/* --------------------------------------------------------------------------------------------- */
static void
mc_search__cond_struct_new_regex_accum_append (const char *charset, GString * str_to,
GString * str_from)
{
GString *recoded_part;
gchar *one_char;
gsize loop;
gboolean just_letters;
loop = 0;
recoded_part = g_string_new ("");
while (loop < str_from->len) {
one_char =
mc_search__get_one_symbol (charset, &(str_from->str[loop]),
(str_from->len - loop > 6) ? 6 : str_from->len - loop,
&just_letters);
if (!strlen (one_char)) {
loop++;
continue;
}
if (just_letters) {
mc_search__cond_struct_new_regex_hex_add (charset, recoded_part, one_char,
strlen (one_char));
} else {
g_string_append (recoded_part, one_char);
}
loop += strlen (one_char);
if (!strlen (one_char))
loop++;
g_free (one_char);
}
g_string_append (str_to, recoded_part->str);
g_string_free (recoded_part, TRUE);
g_string_set_size (str_from, 0);
}
/* --------------------------------------------------------------------------------------------- */
static GString *
mc_search__cond_struct_new_regex_ci_str (const char *charset, const char *str, gsize str_len)
{
GString *accumulator, *spec_char, *ret_str;
gsize loop;
GString *tmp;
tmp = g_string_new_len (str, str_len);
ret_str = g_string_new ("");
accumulator = g_string_new ("");
spec_char = g_string_new ("");
loop = 0;
while (loop <= str_len) {
if (mc_search__regex_str_append_if_special (spec_char, tmp, &loop)) {
mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
g_string_append_len (ret_str, spec_char->str, spec_char->len);
g_string_set_size (spec_char, 0);
continue;
}
if (tmp->str[loop] == '[' && !strutils_is_char_escaped (tmp->str, &(tmp->str[loop]))) {
mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
while (loop < str_len && !(tmp->str[loop] == ']'
&& !strutils_is_char_escaped (tmp->str,
&(tmp->str[loop])))) {
g_string_append_c (ret_str, tmp->str[loop]);
loop++;
}
g_string_append_c (ret_str, tmp->str[loop]);
loop++;
continue;
}
/*
TODO: handle [ and ]
*/
g_string_append_c (accumulator, tmp->str[loop]);
loop++;
}
mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
g_string_free (accumulator, TRUE);
g_string_free (spec_char, TRUE);
g_string_free (tmp, TRUE);
return ret_str;
}
/* --------------------------------------------------------------------------------------------- */
static mc_search__found_cond_t
mc_search__regex_found_cond_one (mc_search_t * mc_search, mc_search_regex_t * regex,
2009-04-27 10:34:10 +04:00
GString * search_str)
{
#if GLIB_CHECK_VERSION (2, 14, 0)
GError *error = NULL;
if (!g_regex_match_full
(regex, search_str->str, -1, 0, 0, &mc_search->regex_match_info, &error)) {
g_match_info_free (mc_search->regex_match_info);
mc_search->regex_match_info = NULL;
if (error) {
mc_search->error = MC_SEARCH_E_REGEX;
mc_search->error_str = str_conv_gerror_message (error, _(" Regular expression error "));
g_error_free (error);
return COND__FOUND_ERROR;
}
return COND__NOT_FOUND;
}
mc_search->num_rezults = g_match_info_get_match_count (mc_search->regex_match_info);
#else
#if HAVE_LIBPCRE
mc_search->num_rezults = pcre_exec (regex, mc_search->regex_match_info,
search_str->str, search_str->len, 0, 0, mc_search->iovector,
MC_SEARCH__PCRE_MAX_MATCHES);
if (mc_search->num_rezults < 0) {
return COND__NOT_FOUND;
}
#else /* HAVE_LIBPCRE */
if (regexec (regex, search_str->str, MC_SEARCH__NUM_REPL_ARGS, mc_search->regex_match_info, 0))
return COND__NOT_FOUND;
for (mc_search->num_rezults = 0; mc_search->num_rezults < MC_SEARCH__NUM_REPL_ARGS;
mc_search->num_rezults++) {
if (mc_search->regex_match_info[mc_search->num_rezults].rm_eo == 0)
break;
}
#endif /* HAVE_LIBPCRE */
#endif /* GLIB_CHECK_VERSION (2, 14, 0) */
return COND__FOUND_OK;
}
/* --------------------------------------------------------------------------------------------- */
static mc_search__found_cond_t
mc_search__regex_found_cond (mc_search_t * mc_search, GString * search_str)
{
gsize loop1;
mc_search_cond_t *mc_search_cond;
mc_search__found_cond_t ret;
for (loop1 = 0; loop1 < mc_search->conditions->len; loop1++) {
mc_search_cond = (mc_search_cond_t *) g_ptr_array_index (mc_search->conditions, loop1);
if (!mc_search_cond->regex_handle)
continue;
ret = mc_search__regex_found_cond_one (mc_search, mc_search_cond->regex_handle, search_str);
if (ret != COND__NOT_FOUND)
return ret;
}
return COND__NOT_ALL_FOUND;
}
/* --------------------------------------------------------------------------------------------- */
static int
mc_search_regex__get_max_num_of_replace_tokens (const gchar * str, gsize len)
{
int max_token = 0;
gsize loop;
for (loop = 0; loop < len - 1; loop++) {
if (str[loop] == '\\' && (str[loop + 1] & (char) 0xf0) == 0x30 /* 0-9 */ ) {
if (strutils_is_char_escaped (str, &str[loop]))
continue;
if (max_token < str[loop + 1] - '0')
max_token = str[loop + 1] - '0';
continue;
}
if (str[loop] == '$' && str[loop + 1] == '{') {
gsize tmp_len;
char *tmp_str;
int tmp_token;
if (strutils_is_char_escaped (str, &str[loop]))
continue;
for (tmp_len = 0;
loop + tmp_len + 2 < len && (str[loop + 2 + tmp_len] & (char) 0xf0) == 0x30;
tmp_len++);
if (str[loop + 2 + tmp_len] == '}') {
tmp_str = g_strndup (&str[loop + 2], tmp_len);
tmp_token = atoi (tmp_str);
if (max_token < tmp_token)
max_token = tmp_token;
g_free (tmp_str);
}
}
}
return max_token;
}
/* --------------------------------------------------------------------------------------------- */
static char *
mc_search_regex__get_token_by_num (const mc_search_t * mc_search, gsize index)
{
int fnd_start, fnd_end;
#if GLIB_CHECK_VERSION (2, 14, 0)
g_match_info_fetch_pos (mc_search->regex_match_info, index, &fnd_start, &fnd_end);
#else /* GLIB_CHECK_VERSION (2, 14, 0) */
#if HAVE_LIBPCRE
fnd_start = mc_search->iovector[index * 2 + 0];
fnd_end = mc_search->iovector[index * 2 + 1];
#else /* HAVE_LIBPCRE */
fnd_start = mc_search->regex_match_info[index].rm_so;
fnd_end = mc_search->regex_match_info[index].rm_eo;
#endif /* HAVE_LIBPCRE */
#endif /* GLIB_CHECK_VERSION (2, 14, 0) */
if (fnd_end - fnd_start == 0)
return NULL;
return g_strndup (mc_search->regex_buffer->str + fnd_start, fnd_end - fnd_start);
}
/* --------------------------------------------------------------------------------------------- */
static int
mc_search_regex__process_replace_str (const GString * replace_str, const gsize current_pos,
gsize * skip_len, replace_transform_type_t * replace_flags)
{
int ret = -1;
char *tmp_str;
const char *curr_str = &(replace_str->str[current_pos]);
if (current_pos > replace_str->len)
return -1;
*skip_len = 0;
if (*curr_str == '$' && *(curr_str + 1) == '{' && (*(curr_str + 2) & (char) 0xf0) == 0x30) {
if (strutils_is_char_escaped (replace_str->str, curr_str))
return -1;
for (*skip_len = 0;
current_pos + *skip_len + 2 < replace_str->len
&& (*(curr_str + 2 + *skip_len) & (char) 0xf0) == 0x30; (*skip_len)++);
if (*(curr_str + 2 + *skip_len) != '}')
return -1;
tmp_str = g_strndup (curr_str + 2, *skip_len);
if (tmp_str == NULL)
return -1;
ret = atoi (tmp_str);
g_free (tmp_str);
*skip_len += 3; /* ${} */
return ret;
}
if (*curr_str == '\\') {
if (strutils_is_char_escaped (replace_str->str, curr_str))
return -1;
if ((*(curr_str + 1) & (char) 0xf0) == 0x30) {
ret = *(curr_str + 1) - '0';
*skip_len = 2; /* \\ and one digit */
return ret;
}
ret = -2;
*skip_len += 2;
switch (*(curr_str + 1)) {
case 'U':
*replace_flags |= REPLACE_T_UPP_TRANSFORM;
*replace_flags &= ~REPLACE_T_LOW_TRANSFORM;
break;
case 'u':
*replace_flags |= REPLACE_T_UPP_TRANSFORM_CHAR;
break;
case 'L':
*replace_flags |= REPLACE_T_LOW_TRANSFORM;
*replace_flags &= ~REPLACE_T_UPP_TRANSFORM;
break;
case 'l':
*replace_flags |= REPLACE_T_LOW_TRANSFORM_CHAR;
break;
case 'E':
*replace_flags = REPLACE_T_NO_TRANSFORM;
break;
default:
ret = -1;
break;
}
}
return ret;
}
static void
mc_search_regex__process_append_str (GString * dest_str, const char *from, gsize len,
replace_transform_type_t * replace_flags)
{
gsize loop = 0;
gsize char_len;
char *tmp_str;
GString *tmp_string;
if (len == -1)
len = strlen (from);
if (*replace_flags == REPLACE_T_NO_TRANSFORM) {
g_string_append_len (dest_str, from, len);
return;
}
while (loop < len) {
tmp_str = mc_search__get_one_symbol (NULL, from + loop, len - loop, NULL);
char_len = strlen (tmp_str);
if (*replace_flags & REPLACE_T_UPP_TRANSFORM_CHAR) {
*replace_flags &= !REPLACE_T_UPP_TRANSFORM_CHAR;
tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
g_string_append (dest_str, tmp_string->str);
g_string_free (tmp_string, TRUE);
} else if (*replace_flags & REPLACE_T_LOW_TRANSFORM_CHAR) {
*replace_flags &= !REPLACE_T_LOW_TRANSFORM_CHAR;
tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
g_string_append (dest_str, tmp_string->str);
g_string_free (tmp_string, TRUE);
} else if (*replace_flags & REPLACE_T_UPP_TRANSFORM) {
tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
g_string_append (dest_str, tmp_string->str);
g_string_free (tmp_string, TRUE);
} else if (*replace_flags & REPLACE_T_LOW_TRANSFORM) {
tmp_string = mc_search__tolower_case_str (NULL, tmp_str, char_len);
g_string_append (dest_str, tmp_string->str);
g_string_free (tmp_string, TRUE);
} else {
g_string_append (dest_str, tmp_str);
}
g_free (tmp_str);
loop += char_len;
}
}
/*** public functions ****************************************************************************/
void
mc_search__cond_struct_new_init_regex (const char *charset, mc_search_t * mc_search,
mc_search_cond_t * mc_search_cond)
{
GString *tmp = NULL;
#if GLIB_CHECK_VERSION (2, 14, 0)
GError *error = NULL;
#else
const char *error;
int erroffset;
#endif
if (!mc_search->is_case_sentitive) {
tmp = g_string_new_len (mc_search_cond->str->str, mc_search_cond->str->len);
g_string_free (mc_search_cond->str, TRUE);
mc_search_cond->str = mc_search__cond_struct_new_regex_ci_str (charset, tmp->str, tmp->len);
g_string_free (tmp, TRUE);
}
#if GLIB_CHECK_VERSION (2, 14, 0)
mc_search_cond->regex_handle =
g_regex_new (mc_search_cond->str->str, G_REGEX_OPTIMIZE | G_REGEX_RAW, 0, &error);
if (error != NULL) {
mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
mc_search->error_str = str_conv_gerror_message (error, _(" Regular expression error "));
g_error_free (error);
return;
}
#else /* GLIB_CHECK_VERSION (2, 14, 0) */
#if HAVE_LIBPCRE
mc_search_cond->regex_handle =
pcre_compile (mc_search_cond->str->str, PCRE_EXTRA, &error, &erroffset, NULL);
if (mc_search_cond->regex_handle == NULL) {
mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
mc_search->error_str = g_strdup (error);
return;
}
mc_search->regex_match_info = pcre_study (mc_search_cond->regex_handle, 0, &error);
if (mc_search->regex_match_info == NULL) {
if (error) {
mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
mc_search->error_str = g_strdup (error);
free (mc_search_cond->regex_handle);
mc_search_cond->regex_handle = NULL;
return;
}
}
#else /* HAVE_LIBPCRE */
mc_search_cond->regex_handle = g_malloc0 (sizeof (regex_t));
erroffset = regcomp (mc_search_cond->regex_handle, mc_search_cond->str->str, REG_EXTENDED);
if (erroffset) {
size_t err_len = regerror (erroffset, mc_search_cond->regex_handle, NULL, 0);
error = g_malloc (err_len + 1);
regerror (erroffset, mc_search_cond->regex_handle, error, err_len);
mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
mc_search->error_str = error;
regfree (mc_search_cond->regex_handle);
mc_search_cond->regex_handle = NULL;
return;
}
mc_search->regex_match_info = g_new0 (mc_search_matchinfo_t, MC_SEARCH__NUM_REPL_ARGS);
#endif /* HAVE_LIBPCRE */
#endif /* GLIB_CHECK_VERSION (2, 14, 0) */
}
/* --------------------------------------------------------------------------------------------- */
gboolean
mc_search__run_regex (mc_search_t * mc_search, const void *user_data,
gsize start_search, gsize end_search, gsize * found_len)
{
gsize current_pos, start_buffer;
int current_chr = 0;
gint start_pos;
gint end_pos;
if (mc_search->regex_buffer != NULL)
g_string_free (mc_search->regex_buffer, TRUE);
mc_search->regex_buffer = g_string_new ("");
current_pos = start_search;
while (current_pos <= end_search) {
g_string_set_size (mc_search->regex_buffer, 0);
start_buffer = current_pos;
while (1) {
current_chr = mc_search__get_char (mc_search, user_data, current_pos);
if (current_chr == -1)
break;
g_string_append_c (mc_search->regex_buffer, (char) current_chr);
current_pos++;
if (current_chr == 0 || (char) current_chr == '\n')
break;
if (current_pos > end_search)
break;
}
if (current_chr == -1)
break;
switch (mc_search__regex_found_cond (mc_search, mc_search->regex_buffer)) {
case COND__FOUND_OK:
#if GLIB_CHECK_VERSION (2, 14, 0)
g_match_info_fetch_pos (mc_search->regex_match_info, 0, &start_pos, &end_pos);
#else /* GLIB_CHECK_VERSION (2, 14, 0) */
#if HAVE_LIBPCRE
start_pos = mc_search->iovector[0];
end_pos = mc_search->iovector[1];
#else /* HAVE_LIBPCRE */
start_pos = mc_search->regex_match_info[0].rm_so;
end_pos = mc_search->regex_match_info[0].rm_eo;
#endif /* HAVE_LIBPCRE */
#endif /* GLIB_CHECK_VERSION (2, 14, 0) */
if (found_len)
*found_len = end_pos - start_pos;
mc_search->normal_offset = start_buffer + start_pos;
return TRUE;
break;
case COND__NOT_ALL_FOUND:
break;
default:
g_string_free (mc_search->regex_buffer, TRUE);
mc_search->regex_buffer = NULL;
return FALSE;
break;
}
}
g_string_free (mc_search->regex_buffer, TRUE);
mc_search->regex_buffer = NULL;
mc_search->error = MC_SEARCH_E_NOTFOUND;
mc_search->error_str = g_strdup (_(STR_E_NOTFOUND));
return FALSE;
}
/* --------------------------------------------------------------------------------------------- */
GString *
mc_search_regex_prepare_replace_str (mc_search_t * mc_search, GString * replace_str)
{
GString *ret;
gchar *tmp_str;
int num_replace_tokens, index;
gsize loop;
gsize len;
gchar *prev_str;
replace_transform_type_t replace_flags = REPLACE_T_NO_TRANSFORM;
num_replace_tokens =
mc_search_regex__get_max_num_of_replace_tokens (replace_str->str, replace_str->len);
if (mc_search->num_rezults < 0)
return g_string_new_len (replace_str->str, replace_str->len);
if (num_replace_tokens > mc_search->num_rezults - 1
|| num_replace_tokens > MC_SEARCH__NUM_REPLACE_ARGS) {
mc_search->error = MC_SEARCH_E_REGEX_REPLACE;
mc_search->error_str = g_strdup (STR_E_RPL_NOT_EQ_TO_FOUND);
return NULL;
}
ret = g_string_new ("");
prev_str = replace_str->str;
for (loop = 0; loop < replace_str->len - 1; loop++) {
index = mc_search_regex__process_replace_str (replace_str, loop, &len, &replace_flags);
if (index == -1)
continue;
if (index == -2) {
if (loop)
mc_search_regex__process_append_str (ret, prev_str,
replace_str->str - prev_str + loop,
&replace_flags);
prev_str = replace_str->str + loop + len;
loop += len - 1;
continue;
}
if (index > mc_search->num_rezults) {
g_string_free (ret, TRUE);
mc_search->error = MC_SEARCH_E_REGEX_REPLACE;
mc_search->error_str = g_strdup_printf (STR_E_RPL_INVALID_TOKEN, index);
return NULL;
}
tmp_str = mc_search_regex__get_token_by_num (mc_search, index);
if (tmp_str == NULL)
continue;
if (loop)
mc_search_regex__process_append_str (ret, prev_str, replace_str->str - prev_str + loop,
&replace_flags);
prev_str = replace_str->str + loop + len;
mc_search_regex__process_append_str (ret, tmp_str, -1, &replace_flags);
g_free (tmp_str);
loop += len - 1;
}
mc_search_regex__process_append_str (ret, prev_str,
replace_str->str - prev_str + replace_str->len,
&replace_flags);
return ret;
}