/* Search text engine. Regex search Copyright (C) 2009-2024 Free Software Foundation, Inc. Written by: Slava Zanko , 2009, 2010, 2011, 2013 Vitaliy Filippov , 2011 Andrew Borodin , 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 . */ #include #include #include "lib/global.h" #include "lib/strutil.h" #include "lib/search.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 && !str_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] == '[' && !str_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] == ']' && !str_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 (str_is_char_escaped (str, &str[loop])) continue; if (max_token < str[loop + 1] - '0') max_token = str[loop + 1] - '0'; } else if (str[loop] == '$' && str[loop + 1] == '{') { gsize tmp_len; if (str_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 (str_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 (str_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, "(?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; }