diff options
Diffstat (limited to 'lib/search/regex.c')
| -rw-r--r-- | lib/search/regex.c | 1121 |
1 files changed, 1121 insertions, 0 deletions
diff --git a/lib/search/regex.c b/lib/search/regex.c new file mode 100644 index 0000000..d24cf48 --- /dev/null +++ b/lib/search/regex.c @@ -0,0 +1,1121 @@ +/* + Search text engine. + Regex search + + Copyright (C) 2009-2023 + Free Software Foundation, Inc. + + Written by: + Slava Zanko <slavazanko@gmail.com>, 2009, 2010, 2011, 2013 + Vitaliy Filippov <vitalif@yourcmc.ru>, 2011 + Andrew Borodin <aborodin@vmail.ru>, 2013-2015 + + 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 3 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, see <http://www.gnu.org/licenses/>. + */ + +#include <config.h> + +#include <stdlib.h> + +#include "lib/global.h" +#include "lib/strutil.h" +#include "lib/search.h" +#include "lib/strescape.h" +#include "lib/util.h" /* MC_PTR_FREE */ + +#include "internal.h" + +/*** global variables ****************************************************************************/ + +/*** file scope macro definitions ****************************************************************/ + +#define REPLACE_PREPARE_T_NOTHING_SPECIAL -1 +#define REPLACE_PREPARE_T_REPLACE_FLAG -2 +#define REPLACE_PREPARE_T_ESCAPE_SEQ -3 + +/*** 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; + +/*** forward declarations (file scope functions) *************************************************/ + +/*** file scope variables ************************************************************************/ + +/* --------------------------------------------------------------------------------------------- */ +/*** file scope functions ************************************************************************/ +/* --------------------------------------------------------------------------------------------- */ + +static gboolean +mc_search__regex_str_append_if_special (GString * copy_to, const GString * regex_str, + gsize * offset) +{ + const 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 + }; + + char *tmp_regex_str; + const char **spec_chr; + + tmp_regex_str = &(regex_str->str[*offset]); + + for (spec_chr = special_chars; *spec_chr != NULL; spec_chr++) + { + gsize spec_chr_len; + + spec_chr_len = strlen (*spec_chr); + + if (strncmp (tmp_regex_str, *spec_chr, spec_chr_len) == 0 + && !strutils_is_char_escaped (regex_str->str, tmp_regex_str)) + { + if (strncmp ("\\x", *spec_chr, spec_chr_len) == 0) + { + if (tmp_regex_str[spec_chr_len] != '{') + spec_chr_len += 2; + else + { + 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++; + } + } + g_string_append_len (copy_to, tmp_regex_str, spec_chr_len); + *offset += spec_chr_len; + return TRUE; + } + } + + return FALSE; +} + +/* --------------------------------------------------------------------------------------------- */ + +static void +mc_search__cond_struct_new_regex_hex_add (const char *charset, GString * str_to, + const GString * one_char) +{ + GString *upp, *low; + gsize loop; + + upp = mc_search__toupper_case_str (charset, one_char); + low = mc_search__tolower_case_str (charset, one_char); + + for (loop = 0; loop < upp->len; loop++) + { + gchar tmp_str[10 + 1]; /* longest content is "[\\x%02X\\x%02X]" */ + gint tmp_len; + + if (loop >= low->len || upp->str[loop] == low->str[loop]) + tmp_len = + g_snprintf (tmp_str, sizeof (tmp_str), "\\x%02X", (unsigned char) upp->str[loop]); + else + tmp_len = + g_snprintf (tmp_str, sizeof (tmp_str), "[\\x%02X\\x%02X]", + (unsigned char) upp->str[loop], (unsigned char) low->str[loop]); + + g_string_append_len (str_to, tmp_str, tmp_len); + } + + 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; + gsize loop = 0; + + recoded_part = g_string_sized_new (32); + + while (loop < str_from->len) + { + GString *one_char; + gboolean just_letters; + + one_char = + mc_search__get_one_symbol (charset, str_from->str + loop, + MIN (str_from->len - loop, 6), &just_letters); + + if (one_char->len == 0) + loop++; + else + { + loop += one_char->len; + + if (just_letters) + mc_search__cond_struct_new_regex_hex_add (charset, recoded_part, one_char); + else + g_string_append_len (recoded_part, one_char->str, one_char->len); + } + + g_string_free (one_char, TRUE); + } + + g_string_append_len (str_to, recoded_part->str, recoded_part->len); + g_string_free (recoded_part, TRUE); + g_string_set_size (str_from, 0); +} + +/* --------------------------------------------------------------------------------------------- */ + +/** + * Creates a case-insensitive version of a regex pattern. + * + * For example (assuming ASCII charset): given "\\bHello!\\xAB", returns + * "\\b[Hh][Ee][Ll][Ll][Oo]!\\xAB" (this example is for easier reading; in + * reality hex codes are used instead of letters). + * + * This function knows not to ruin special regex symbols. + * + * This function is used when working with non-UTF-8 charsets: GLib's + * regex engine doesn't understand such charsets and therefore can't do + * this job itself. + */ +static GString * +mc_search__cond_struct_new_regex_ci_str (const char *charset, const GString * astr) +{ + GString *accumulator, *spec_char, *ret_str; + gsize loop; + + ret_str = g_string_sized_new (64); + accumulator = g_string_sized_new (64); + spec_char = g_string_sized_new (64); + loop = 0; + + while (loop < astr->len) + { + if (mc_search__regex_str_append_if_special (spec_char, astr, &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 (astr->str[loop] == '[' && !strutils_is_char_escaped (astr->str, &(astr->str[loop]))) + { + mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator); + + while (loop < astr->len && !(astr->str[loop] == ']' + && !strutils_is_char_escaped (astr->str, + &(astr->str[loop])))) + { + g_string_append_c (ret_str, astr->str[loop]); + loop++; + } + + g_string_append_c (ret_str, astr->str[loop]); + loop++; + continue; + } + /* + TODO: handle [ and ] + */ + g_string_append_c (accumulator, astr->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); + + return ret_str; +} + +/* --------------------------------------------------------------------------------------------- */ + +#ifdef SEARCH_TYPE_GLIB +/* A thin wrapper above g_regex_match_full that makes sure the string passed + * to it is valid UTF-8 (unless G_REGEX_RAW compile flag was set), as it is a + * requirement by glib and it might crash otherwise. See: mc ticket 3449. + * Be careful: there might be embedded NULs in the strings. */ +static gboolean +mc_search__g_regex_match_full_safe (const GRegex * regex, + const gchar * string, + gssize string_len, + gint start_position, + GRegexMatchFlags match_options, + GMatchInfo ** match_info, GError ** error) +{ + char *string_safe, *p, *end; + gboolean ret; + + if (string_len < 0) + string_len = strlen (string); + + if ((g_regex_get_compile_flags (regex) & G_REGEX_RAW) + || g_utf8_validate (string, string_len, NULL)) + { + return g_regex_match_full (regex, string, string_len, start_position, match_options, + match_info, error); + } + + /* Correctly handle embedded NULs while copying */ + p = string_safe = g_malloc (string_len + 1); + memcpy (string_safe, string, string_len); + string_safe[string_len] = '\0'; + end = p + string_len; + + while (p < end) + { + gunichar c = g_utf8_get_char_validated (p, -1); + if (c != (gunichar) (-1) && c != (gunichar) (-2)) + { + p = g_utf8_next_char (p); + } + else + { + /* U+FFFD would be the proper choice, but then we'd have to + maintain mapping between old and new offsets. + So rather do a byte by byte replacement. */ + *p++ = '\0'; + } + } + + ret = + g_regex_match_full (regex, string_safe, string_len, start_position, match_options, + match_info, error); + g_free (string_safe); + return ret; +} +#endif /* SEARCH_TYPE_GLIB */ + +/* --------------------------------------------------------------------------------------------- */ + +static mc_search__found_cond_t +mc_search__regex_found_cond_one (mc_search_t * lc_mc_search, mc_search_regex_t * regex, + GString * search_str) +{ +#ifdef SEARCH_TYPE_GLIB + GError *mcerror = NULL; + + if (!mc_search__g_regex_match_full_safe + (regex, search_str->str, search_str->len, 0, G_REGEX_MATCH_NEWLINE_ANY, + &lc_mc_search->regex_match_info, &mcerror)) + { + g_match_info_free (lc_mc_search->regex_match_info); + lc_mc_search->regex_match_info = NULL; + if (mcerror != NULL) + { + lc_mc_search->error = MC_SEARCH_E_REGEX; + g_free (lc_mc_search->error_str); + lc_mc_search->error_str = + str_conv_gerror_message (mcerror, _("Regular expression error")); + g_error_free (mcerror); + return COND__FOUND_ERROR; + } + return COND__NOT_FOUND; + } + lc_mc_search->num_results = g_match_info_get_match_count (lc_mc_search->regex_match_info); +#else /* SEARCH_TYPE_GLIB */ + + lc_mc_search->num_results = +#ifdef HAVE_PCRE2 + pcre2_match (regex, (unsigned char *) search_str->str, search_str->len, 0, 0, + lc_mc_search->regex_match_info, NULL); +#else + pcre_exec (regex, lc_mc_search->regex_match_info, search_str->str, search_str->len, 0, 0, + lc_mc_search->iovector, MC_SEARCH__NUM_REPLACE_ARGS); +#endif + if (lc_mc_search->num_results < 0) + { + return COND__NOT_FOUND; + } +#endif /* SEARCH_TYPE_GLIB */ + return COND__FOUND_OK; + +} + +/* --------------------------------------------------------------------------------------------- */ + +static mc_search__found_cond_t +mc_search__regex_found_cond (mc_search_t * lc_mc_search, GString * search_str) +{ + gsize loop1; + + for (loop1 = 0; loop1 < lc_mc_search->prepared.conditions->len; loop1++) + { + mc_search_cond_t *mc_search_cond; + mc_search__found_cond_t ret; + + mc_search_cond = + (mc_search_cond_t *) g_ptr_array_index (lc_mc_search->prepared.conditions, loop1); + + if (!mc_search_cond->regex_handle) + continue; + + ret = + mc_search__regex_found_cond_one (lc_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] == '\\' && g_ascii_isdigit (str[loop + 1])) + { + 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; + + 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] == '}') + { + int tmp_token; + char *tmp_str; + + 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 * lc_mc_search, gsize lc_index) +{ + int fnd_start = 0, fnd_end = 0; + +#ifdef SEARCH_TYPE_GLIB + g_match_info_fetch_pos (lc_mc_search->regex_match_info, lc_index, &fnd_start, &fnd_end); +#else /* SEARCH_TYPE_GLIB */ + fnd_start = lc_mc_search->iovector[lc_index * 2 + 0]; + fnd_end = lc_mc_search->iovector[lc_index * 2 + 1]; +#endif /* SEARCH_TYPE_GLIB */ + + if (fnd_end == fnd_start) + return g_strdup (""); + + return g_strndup (lc_mc_search->regex_buffer->str + fnd_start, fnd_end - fnd_start); + +} + +/* --------------------------------------------------------------------------------------------- */ + +static gboolean +mc_search_regex__replace_handle_esc_seq (const GString * replace_str, const gsize current_pos, + gsize * skip_len, int *ret) +{ + char *curr_str = &(replace_str->str[current_pos]); + char c = curr_str[1]; + + if (replace_str->len > current_pos + 2) + { + if (c == '{') + { + for (*skip_len = 2; /* \{ */ + current_pos + *skip_len < replace_str->len && curr_str[*skip_len] >= '0' + && curr_str[*skip_len] <= '7'; (*skip_len)++) + ; + + if (current_pos + *skip_len < replace_str->len && curr_str[*skip_len] == '}') + { + (*skip_len)++; + *ret = REPLACE_PREPARE_T_ESCAPE_SEQ; + return FALSE; + } + else + { + *ret = REPLACE_PREPARE_T_NOTHING_SPECIAL; + return TRUE; + } + } + + if (c == 'x') + { + *skip_len = 2; /* \x */ + c = curr_str[2]; + if (c == '{') + { + for (*skip_len = 3; /* \x{ */ + current_pos + *skip_len < replace_str->len + && g_ascii_isxdigit ((guchar) curr_str[*skip_len]); (*skip_len)++) + ; + + if (current_pos + *skip_len < replace_str->len && curr_str[*skip_len] == '}') + { + (*skip_len)++; + *ret = REPLACE_PREPARE_T_ESCAPE_SEQ; + return FALSE; + } + else + { + *ret = REPLACE_PREPARE_T_NOTHING_SPECIAL; + return TRUE; + } + } + else if (!g_ascii_isxdigit ((guchar) c)) + { + *skip_len = 2; /* \x without number behind */ + *ret = REPLACE_PREPARE_T_NOTHING_SPECIAL; + return FALSE; + } + else + { + c = curr_str[3]; + if (!g_ascii_isxdigit ((guchar) c)) + *skip_len = 3; /* \xH */ + else + *skip_len = 4; /* \xHH */ + *ret = REPLACE_PREPARE_T_ESCAPE_SEQ; + return FALSE; + } + } + } + + if (strchr ("ntvbrfa", c) != NULL) + { + *skip_len = 2; + *ret = REPLACE_PREPARE_T_ESCAPE_SEQ; + return FALSE; + } + return TRUE; +} + +/* --------------------------------------------------------------------------------------------- */ + +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; + const char *curr_str = &(replace_str->str[current_pos]); + + if (current_pos > replace_str->len) + return REPLACE_PREPARE_T_NOTHING_SPECIAL; + + *skip_len = 0; + + if (replace_str->len > current_pos + 2 && curr_str[0] == '$' && curr_str[1] == '{' + && (curr_str[2] & (char) 0xf0) == 0x30) + { + char *tmp_str; + + if (strutils_is_char_escaped (replace_str->str, curr_str)) + { + *skip_len = 1; + return REPLACE_PREPARE_T_NOTHING_SPECIAL; + } + + 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 REPLACE_PREPARE_T_NOTHING_SPECIAL; + + tmp_str = g_strndup (curr_str + 2, *skip_len); + if (tmp_str == NULL) + return REPLACE_PREPARE_T_NOTHING_SPECIAL; + + ret = atoi (tmp_str); + g_free (tmp_str); + + *skip_len += 3; /* ${} */ + return ret; /* capture buffer index >= 0 */ + } + + if (curr_str[0] == '\\' && replace_str->len > current_pos + 1) + { + if (strutils_is_char_escaped (replace_str->str, curr_str)) + { + *skip_len = 1; + return REPLACE_PREPARE_T_NOTHING_SPECIAL; + } + + if (g_ascii_isdigit (curr_str[1])) + { + ret = g_ascii_digit_value (curr_str[1]); /* capture buffer index >= 0 */ + *skip_len = 2; /* \\ and one digit */ + return ret; + } + + if (!mc_search_regex__replace_handle_esc_seq (replace_str, current_pos, skip_len, &ret)) + return ret; + + ret = REPLACE_PREPARE_T_REPLACE_FLAG; + *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 = REPLACE_PREPARE_T_NOTHING_SPECIAL; + 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; + gsize char_len; + + if (len == (gsize) (-1)) + len = strlen (from); + + if (*replace_flags == REPLACE_T_NO_TRANSFORM) + { + g_string_append_len (dest_str, from, len); + return; + } + + for (loop = 0; loop < len; loop += char_len) + { + GString *tmp_string = NULL; + GString *s; + + s = mc_search__get_one_symbol (NULL, from + loop, len - loop, NULL); + char_len = s->len; + + if ((*replace_flags & REPLACE_T_UPP_TRANSFORM_CHAR) != 0) + { + *replace_flags &= ~REPLACE_T_UPP_TRANSFORM_CHAR; + tmp_string = mc_search__toupper_case_str (NULL, s); + g_string_append_len (dest_str, tmp_string->str, tmp_string->len); + } + else if ((*replace_flags & REPLACE_T_LOW_TRANSFORM_CHAR) != 0) + { + *replace_flags &= ~REPLACE_T_LOW_TRANSFORM_CHAR; + tmp_string = mc_search__tolower_case_str (NULL, s); + g_string_append_len (dest_str, tmp_string->str, tmp_string->len); + } + else if ((*replace_flags & REPLACE_T_UPP_TRANSFORM) != 0) + { + tmp_string = mc_search__toupper_case_str (NULL, s); + g_string_append_len (dest_str, tmp_string->str, tmp_string->len); + } + else if ((*replace_flags & REPLACE_T_LOW_TRANSFORM) != 0) + { + tmp_string = mc_search__tolower_case_str (NULL, s); + g_string_append_len (dest_str, tmp_string->str, tmp_string->len); + } + + g_string_free (s, TRUE); + if (tmp_string != NULL) + g_string_free (tmp_string, TRUE); + } +} + +/* --------------------------------------------------------------------------------------------- */ + +static void +mc_search_regex__process_escape_sequence (GString * dest_str, const char *from, gsize len, + replace_transform_type_t * replace_flags, + gboolean is_utf8) +{ + gsize i = 0; + unsigned int c = 0; + char b; + + if (len == (gsize) (-1)) + len = strlen (from); + if (len == 0) + return; + + if (from[i] == '{') + i++; + if (i >= len) + return; + + if (from[i] == 'x') + { + i++; + if (i < len && from[i] == '{') + i++; + for (; i < len; i++) + { + if (from[i] >= '0' && from[i] <= '9') + c = c * 16 + from[i] - '0'; + else if (from[i] >= 'a' && from[i] <= 'f') + c = c * 16 + 10 + from[i] - 'a'; + else if (from[i] >= 'A' && from[i] <= 'F') + c = c * 16 + 10 + from[i] - 'A'; + else + break; + } + } + else if (from[i] >= '0' && from[i] <= '7') + for (; i < len && from[i] >= '0' && from[i] <= '7'; i++) + c = c * 8 + from[i] - '0'; + else + { + switch (from[i]) + { + case 'n': + c = '\n'; + break; + case 't': + c = '\t'; + break; + case 'v': + c = '\v'; + break; + case 'b': + c = '\b'; + break; + case 'r': + c = '\r'; + break; + case 'f': + c = '\f'; + break; + case 'a': + c = '\a'; + break; + default: + mc_search_regex__process_append_str (dest_str, from, len, replace_flags); + return; + } + } + + if (c < 0x80 || !is_utf8) + g_string_append_c (dest_str, (char) c); + else if (c < 0x800) + { + b = 0xC0 | (c >> 6); + g_string_append_c (dest_str, b); + b = 0x80 | (c & 0x3F); + g_string_append_c (dest_str, b); + } + else if (c < 0x10000) + { + b = 0xE0 | (c >> 12); + g_string_append_c (dest_str, b); + b = 0x80 | ((c >> 6) & 0x3F); + g_string_append_c (dest_str, b); + b = 0x80 | (c & 0x3F); + g_string_append_c (dest_str, b); + } + else if (c < 0x10FFFF) + { + b = 0xF0 | (c >> 16); + g_string_append_c (dest_str, b); + b = 0x80 | ((c >> 12) & 0x3F); + g_string_append_c (dest_str, b); + b = 0x80 | ((c >> 6) & 0x3F); + g_string_append_c (dest_str, b); + b = 0x80 | (c & 0x3F); + g_string_append_c (dest_str, b); + } +} + +/* --------------------------------------------------------------------------------------------- */ +/*** public functions ****************************************************************************/ +/* --------------------------------------------------------------------------------------------- */ + +void +mc_search__cond_struct_new_init_regex (const char *charset, mc_search_t * lc_mc_search, + mc_search_cond_t * mc_search_cond) +{ + if (lc_mc_search->whole_words && !lc_mc_search->is_entire_line) + { + /* NOTE: \b as word boundary doesn't allow search + * whole words with non-ASCII symbols. + * Update: Is it still true nowadays? Probably not. #2396, #3524 */ + g_string_prepend (mc_search_cond->str, "(?<![\\p{L}\\p{N}_])"); + g_string_append (mc_search_cond->str, "(?![\\p{L}\\p{N}_])"); + } + + { +#ifdef SEARCH_TYPE_GLIB + GError *mcerror = NULL; + GRegexCompileFlags g_regex_options = G_REGEX_OPTIMIZE | G_REGEX_DOTALL; + + if (str_isutf8 (charset) && mc_global.utf8_display) + { + if (!lc_mc_search->is_case_sensitive) + g_regex_options |= G_REGEX_CASELESS; + } + else + { + g_regex_options |= G_REGEX_RAW; + + if (!lc_mc_search->is_case_sensitive) + { + GString *tmp; + + tmp = mc_search_cond->str; + mc_search_cond->str = mc_search__cond_struct_new_regex_ci_str (charset, tmp); + g_string_free (tmp, TRUE); + } + } + + mc_search_cond->regex_handle = + g_regex_new (mc_search_cond->str->str, g_regex_options, 0, &mcerror); + + if (mcerror != NULL) + { + lc_mc_search->error = MC_SEARCH_E_REGEX_COMPILE; + g_free (lc_mc_search->error_str); + lc_mc_search->error_str = + str_conv_gerror_message (mcerror, _("Regular expression error")); + g_error_free (mcerror); + return; + } +#else /* SEARCH_TYPE_GLIB */ + +#ifdef HAVE_PCRE2 + int errcode; + char error[BUF_SMALL]; + size_t erroffset; + int pcre_options = PCRE2_MULTILINE; +#else + const char *error; + int erroffset; + int pcre_options = PCRE_EXTRA | PCRE_MULTILINE; +#endif + + if (str_isutf8 (charset) && mc_global.utf8_display) + { +#ifdef HAVE_PCRE2 + pcre_options |= PCRE2_UTF; + if (!lc_mc_search->is_case_sensitive) + pcre_options |= PCRE2_CASELESS; +#else + pcre_options |= PCRE_UTF8; + if (!lc_mc_search->is_case_sensitive) + pcre_options |= PCRE_CASELESS; +#endif + } + else if (!lc_mc_search->is_case_sensitive) + { + GString *tmp; + + tmp = mc_search_cond->str; + mc_search_cond->str = mc_search__cond_struct_new_regex_ci_str (charset, tmp); + g_string_free (tmp, TRUE); + } + + mc_search_cond->regex_handle = +#ifdef HAVE_PCRE2 + pcre2_compile ((unsigned char *) mc_search_cond->str->str, PCRE2_ZERO_TERMINATED, + pcre_options, &errcode, &erroffset, NULL); +#else + pcre_compile (mc_search_cond->str->str, pcre_options, &error, &erroffset, NULL); +#endif + if (mc_search_cond->regex_handle == NULL) + { +#ifdef HAVE_PCRE2 + pcre2_get_error_message (errcode, (unsigned char *) error, sizeof (error)); +#endif + mc_search_set_error (lc_mc_search, MC_SEARCH_E_REGEX_COMPILE, "%s", error); + return; + } +#ifdef HAVE_PCRE2 + if (pcre2_jit_compile (mc_search_cond->regex_handle, PCRE2_JIT_COMPLETE) && *error != '\0') +#else + lc_mc_search->regex_match_info = pcre_study (mc_search_cond->regex_handle, 0, &error); + if (lc_mc_search->regex_match_info == NULL && error != NULL) +#endif + { + mc_search_set_error (lc_mc_search, MC_SEARCH_E_REGEX_COMPILE, "%s", error); + MC_PTR_FREE (mc_search_cond->regex_handle); + return; + } +#endif /* SEARCH_TYPE_GLIB */ + } + + lc_mc_search->is_utf8 = str_isutf8 (charset); +} + +/* --------------------------------------------------------------------------------------------- */ + +gboolean +mc_search__run_regex (mc_search_t * lc_mc_search, const void *user_data, + gsize start_search, gsize end_search, gsize * found_len) +{ + mc_search_cbret_t ret = MC_SEARCH_CB_NOTFOUND; + gsize current_pos, virtual_pos; + gint start_pos; + gint end_pos; + + if (lc_mc_search->regex_buffer != NULL) + g_string_set_size (lc_mc_search->regex_buffer, 0); + else + lc_mc_search->regex_buffer = g_string_sized_new (64); + + virtual_pos = current_pos = start_search; + while (virtual_pos <= end_search) + { + g_string_set_size (lc_mc_search->regex_buffer, 0); + lc_mc_search->start_buffer = current_pos; + + if (lc_mc_search->search_fn != NULL) + { + while (TRUE) + { + int current_chr = '\n'; /* stop search symbol */ + + ret = lc_mc_search->search_fn (user_data, current_pos, ¤t_chr); + + if (ret == MC_SEARCH_CB_ABORT) + break; + + if (ret == MC_SEARCH_CB_INVALID) + continue; + + current_pos++; + + if (ret == MC_SEARCH_CB_SKIP) + continue; + + virtual_pos++; + + g_string_append_c (lc_mc_search->regex_buffer, (char) current_chr); + + if ((char) current_chr == '\n' || virtual_pos > end_search) + break; + } + } + else + { + /* optimization for standard case (for search from file manager) + * where there is no MC_SEARCH_CB_INVALID or MC_SEARCH_CB_SKIP + * return codes, so we can copy line at regex buffer all at once + */ + while (TRUE) + { + const char current_chr = ((const char *) user_data)[current_pos]; + + if (current_chr == '\0') + break; + + current_pos++; + + if (current_chr == '\n' || current_pos > end_search) + break; + } + + /* use virtual_pos as index of start of current chunk */ + g_string_append_len (lc_mc_search->regex_buffer, (const char *) user_data + virtual_pos, + current_pos - virtual_pos); + virtual_pos = current_pos; + } + + switch (mc_search__regex_found_cond (lc_mc_search, lc_mc_search->regex_buffer)) + { + case COND__FOUND_OK: +#ifdef SEARCH_TYPE_GLIB + g_match_info_fetch_pos (lc_mc_search->regex_match_info, 0, &start_pos, &end_pos); +#else /* SEARCH_TYPE_GLIB */ + start_pos = lc_mc_search->iovector[0]; + end_pos = lc_mc_search->iovector[1]; +#endif /* SEARCH_TYPE_GLIB */ + if (found_len != NULL) + *found_len = end_pos - start_pos; + lc_mc_search->normal_offset = lc_mc_search->start_buffer + start_pos; + return TRUE; + case COND__NOT_ALL_FOUND: + break; + default: + g_string_free (lc_mc_search->regex_buffer, TRUE); + lc_mc_search->regex_buffer = NULL; + return FALSE; + } + + if ((lc_mc_search->update_fn != NULL) && + ((lc_mc_search->update_fn) (user_data, current_pos) == MC_SEARCH_CB_ABORT)) + ret = MC_SEARCH_CB_ABORT; + + if (ret == MC_SEARCH_CB_ABORT || ret == MC_SEARCH_CB_NOTFOUND) + break; + } + + g_string_free (lc_mc_search->regex_buffer, TRUE); + lc_mc_search->regex_buffer = NULL; + + MC_PTR_FREE (lc_mc_search->error_str); + lc_mc_search->error = ret == MC_SEARCH_CB_ABORT ? MC_SEARCH_E_ABORT : MC_SEARCH_E_NOTFOUND; + + return FALSE; +} + +/* --------------------------------------------------------------------------------------------- */ + +GString * +mc_search_regex_prepare_replace_str (mc_search_t * lc_mc_search, GString * replace_str) +{ + GString *ret; + + int num_replace_tokens; + gsize loop; + gsize prev = 0; + 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 (lc_mc_search->num_results < 0) + return mc_g_string_dup (replace_str); + + if (num_replace_tokens > lc_mc_search->num_results - 1 + || num_replace_tokens > MC_SEARCH__NUM_REPLACE_ARGS) + { + mc_search_set_error (lc_mc_search, MC_SEARCH_E_REGEX_REPLACE, "%s", + _(STR_E_RPL_NOT_EQ_TO_FOUND)); + return NULL; + } + + ret = g_string_sized_new (64); + + for (loop = 0; loop < replace_str->len - 1; loop++) + { + int lc_index; + gchar *tmp_str; + gsize len = 0; + + lc_index = mc_search_regex__process_replace_str (replace_str, loop, &len, &replace_flags); + + if (lc_index == REPLACE_PREPARE_T_NOTHING_SPECIAL) + { + if (len != 0) + { + mc_search_regex__process_append_str (ret, replace_str->str + prev, loop - prev, + &replace_flags); + mc_search_regex__process_append_str (ret, replace_str->str + loop + 1, len - 1, + &replace_flags); + prev = loop + len; + loop = prev - 1; /* prepare to loop++ */ + } + + continue; + } + + if (lc_index == REPLACE_PREPARE_T_REPLACE_FLAG) + { + if (loop != 0) + mc_search_regex__process_append_str (ret, replace_str->str + prev, loop - prev, + &replace_flags); + prev = loop + len; + loop = prev - 1; /* prepare to loop++ */ + continue; + } + + /* escape sequence */ + if (lc_index == REPLACE_PREPARE_T_ESCAPE_SEQ) + { + mc_search_regex__process_append_str (ret, replace_str->str + prev, loop - prev, + &replace_flags); + /* call process_escape_sequence without starting '\\' */ + mc_search_regex__process_escape_sequence (ret, replace_str->str + loop + 1, len - 1, + &replace_flags, lc_mc_search->is_utf8); + prev = loop + len; + loop = prev - 1; /* prepare to loop++ */ + continue; + } + + /* invalid capture buffer number */ + if (lc_index > lc_mc_search->num_results) + { + g_string_free (ret, TRUE); + mc_search_set_error (lc_mc_search, MC_SEARCH_E_REGEX_REPLACE, + _(STR_E_RPL_INVALID_TOKEN), lc_index); + return NULL; + } + + tmp_str = mc_search_regex__get_token_by_num (lc_mc_search, lc_index); + + if (loop != 0) + mc_search_regex__process_append_str (ret, replace_str->str + prev, loop - prev, + &replace_flags); + + mc_search_regex__process_append_str (ret, tmp_str, -1, &replace_flags); + g_free (tmp_str); + + prev = loop + len; + loop = prev - 1; /* prepare to loop++ */ + } + + mc_search_regex__process_append_str (ret, replace_str->str + prev, replace_str->len - prev, + &replace_flags); + + return ret; +} |