lib/search/regex.c

   1 /*
   2    Search text engine.
   3    Regex search
   4
   5    Copyright (C) 2009 The Free Software Foundation, Inc.
   6
   7    Written by:
   8    Slava Zanko <slavazanko@gmail.com>, 2009.
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software; you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation; either version 2 of the
  15    License, or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be
  18    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  19    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program; if not, write to the Free Software
  24    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  25    MA 02110-1301, USA.
  26  */
  27
  28 #include <config.h>
  29
  30 #include <stdlib.h>
  31
  32 #include "lib/global.h"
  33 #include "lib/strutil.h"
  34 #include "lib/search.h"
  35 #include "lib/strescape.h"
  36
  37 #include "src/charsets.h"
  38
  39 #include "internal.h"
  40
  41 /*** global variables ****************************************************************************/
  42
  43 /*** file scope macro definitions ****************************************************************/
  44
  45 /*** file scope type declarations ****************************************************************/
  46
  47 typedef enum
  48 {
  49     REPLACE_T_NO_TRANSFORM = 0,
  50     REPLACE_T_UPP_TRANSFORM_CHAR = 1,
  51     REPLACE_T_LOW_TRANSFORM_CHAR = 2,
  52     REPLACE_T_UPP_TRANSFORM = 4,
  53     REPLACE_T_LOW_TRANSFORM = 8
  54 } replace_transform_type_t;
  55
  56 /*** file scope variables ************************************************************************/
  57
  58 /*** file scope functions ************************************************************************/
  59
  60 static gboolean
  61 mc_search__regex_str_append_if_special (GString * copy_to, const GString * regex_str, gsize * offset)
  62 {
  63     char *tmp_regex_str;
  64     gsize spec_chr_len;
  65     const char **spec_chr;
  66     const char *special_chars[] = {
  67         "\\s", "\\S",
  68         "\\d", "\\D",
  69         "\\b", "\\B",
  70         "\\w", "\\W",
  71         "\\t", "\\n",
  72         "\\r", "\\f",
  73         "\\a", "\\e",
  74         "\\x", "\\X",
  75         "\\c", "\\C",
  76         "\\l", "\\L",
  77         "\\u", "\\U",
  78         "\\E", "\\Q",
  79         NULL
  80     };
  81     spec_chr = special_chars;
  82
  83     tmp_regex_str = &(regex_str->str[*offset]);
  84
  85     while (*spec_chr)
  86     {
  87         spec_chr_len = strlen (*spec_chr);
  88         if (!strncmp (tmp_regex_str, *spec_chr, spec_chr_len))
  89         {
  90             if (!strutils_is_char_escaped (regex_str->str, tmp_regex_str))
  91             {
  92                 if (!strncmp ("\\x", *spec_chr, spec_chr_len))
  93                 {
  94                     if (*(tmp_regex_str + spec_chr_len) == '{')
  95                     {
  96                         while ((spec_chr_len < regex_str->len - *offset)
  97                                && *(tmp_regex_str + spec_chr_len) != '}')
  98                             spec_chr_len++;
  99                         if (*(tmp_regex_str + spec_chr_len) == '}')
 100                             spec_chr_len++;
 101                     }
 102                     else
 103                         spec_chr_len += 2;
 104                 }
 105                 g_string_append_len (copy_to, tmp_regex_str, spec_chr_len);
 106                 *offset += spec_chr_len;
 107                 return TRUE;
 108             }
 109         }
 110         spec_chr++;
 111     }
 112     return FALSE;
 113
 114 }
 115
 116 /* --------------------------------------------------------------------------------------------- */
 117 static void
 118 mc_search__cond_struct_new_regex_hex_add (const char *charset, GString * str_to,
 119                                           const char *one_char, gsize str_len)
 120 {
 121     GString *upp, *low;
 122     gchar *tmp_str;
 123     gsize loop;
 124
 125     upp = mc_search__toupper_case_str (charset, one_char, str_len);
 126     low = mc_search__tolower_case_str (charset, one_char, str_len);
 127
 128     for (loop = 0; loop < upp->len; loop++)
 129     {
 130
 131         if (loop < low->len)
 132         {
 133             if (upp->str[loop] == low->str[loop])
 134                 tmp_str = g_strdup_printf ("\\x%02X", (unsigned char) upp->str[loop]);
 135             else
 136                 tmp_str =
 137                     g_strdup_printf ("[\\x%02X\\x%02X]", (unsigned char) upp->str[loop],
 138                                      (unsigned char) low->str[loop]);
 139         }
 140         else
 141         {
 142             tmp_str = g_strdup_printf ("\\x%02X", (unsigned char) upp->str[loop]);
 143         }
 144         g_string_append (str_to, tmp_str);
 145         g_free (tmp_str);
 146     }
 147     g_string_free (upp, TRUE);
 148     g_string_free (low, TRUE);
 149 }
 150
 151 /* --------------------------------------------------------------------------------------------- */
 152
 153 static void
 154 mc_search__cond_struct_new_regex_accum_append (const char *charset, GString * str_to,
 155                                                GString * str_from)
 156 {
 157     GString *recoded_part;
 158     gsize loop = 0;
 159
 160     recoded_part = g_string_sized_new (32);
 161
 162     while (loop < str_from->len)
 163     {
 164         gchar *one_char;
 165         gsize one_char_len;
 166         gboolean just_letters;
 167
 168         one_char =
 169             mc_search__get_one_symbol (charset, &(str_from->str[loop]),
 170                                        min (str_from->len - loop, 6), &just_letters);
 171         one_char_len = strlen (one_char);
 172
 173         if (one_char_len == 0)
 174             loop++;
 175         else
 176         {
 177             loop += one_char_len;
 178
 179             if (just_letters)
 180                 mc_search__cond_struct_new_regex_hex_add (charset, recoded_part, one_char,
 181                                                           one_char_len);
 182             else
 183                 g_string_append_len (recoded_part, one_char, one_char_len);
 184         }
 185
 186         g_free (one_char);
 187     }
 188
 189     g_string_append (str_to, recoded_part->str);
 190     g_string_free (recoded_part, TRUE);
 191     g_string_set_size (str_from, 0);
 192 }
 193
 194 /* --------------------------------------------------------------------------------------------- */
 195
 196 static GString *
 197 mc_search__cond_struct_new_regex_ci_str (const char *charset, const char *str, gsize str_len)
 198 {
 199     GString *accumulator, *spec_char, *ret_str;
 200     gsize loop;
 201     GString *tmp;
 202     tmp = g_string_new_len (str, str_len);
 203
 204
 205     ret_str = g_string_new ("");
 206     accumulator = g_string_new ("");
 207     spec_char = g_string_new ("");
 208     loop = 0;
 209
 210     while (loop <= str_len)
 211     {
 212         if (mc_search__regex_str_append_if_special (spec_char, tmp, &loop))
 213         {
 214             mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
 215             g_string_append_len (ret_str, spec_char->str, spec_char->len);
 216             g_string_set_size (spec_char, 0);
 217             continue;
 218         }
 219
 220         if (tmp->str[loop] == '[' && !strutils_is_char_escaped (tmp->str, &(tmp->str[loop])))
 221         {
 222             mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
 223
 224             while (loop < str_len && !(tmp->str[loop] == ']'
 225                                        && !strutils_is_char_escaped (tmp->str, &(tmp->str[loop]))))
 226             {
 227                 g_string_append_c (ret_str, tmp->str[loop]);
 228                 loop++;
 229
 230             }
 231             g_string_append_c (ret_str, tmp->str[loop]);
 232             loop++;
 233             continue;
 234         }
 235         /*
 236            TODO: handle [ and ]
 237          */
 238         g_string_append_c (accumulator, tmp->str[loop]);
 239         loop++;
 240     }
 241     mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
 242
 243     g_string_free (accumulator, TRUE);
 244     g_string_free (spec_char, TRUE);
 245     g_string_free (tmp, TRUE);
 246     return ret_str;
 247 }
 248
 249 /* --------------------------------------------------------------------------------------------- */
 250
 251 static mc_search__found_cond_t
 252 mc_search__regex_found_cond_one (mc_search_t * lc_mc_search, mc_search_regex_t * regex,
 253                                  GString * search_str)
 254 {
 255 #ifdef SEARCH_TYPE_GLIB
 256     GError *error = NULL;
 257
 258     if (!g_regex_match_full
 259         (regex, search_str->str, -1, 0, G_REGEX_MATCH_NEWLINE_ANY, &lc_mc_search->regex_match_info,
 260          &error))
 261     {
 262         g_match_info_free (lc_mc_search->regex_match_info);
 263         lc_mc_search->regex_match_info = NULL;
 264         if (error)
 265         {
 266             lc_mc_search->error = MC_SEARCH_E_REGEX;
 267             lc_mc_search->error_str =
 268                 str_conv_gerror_message (error, _("Regular expression error"));
 269             g_error_free (error);
 270             return COND__FOUND_ERROR;
 271         }
 272         return COND__NOT_FOUND;
 273     }
 274     lc_mc_search->num_results = g_match_info_get_match_count (lc_mc_search->regex_match_info);
 275 #else /* SEARCH_TYPE_GLIB */
 276     lc_mc_search->num_results = pcre_exec (regex, lc_mc_search->regex_match_info,
 277                                            search_str->str, search_str->len - 1, 0, 0,
 278                                            lc_mc_search->iovector, MC_SEARCH__NUM_REPLACE_ARGS);
 279     if (lc_mc_search->num_results < 0)
 280     {
 281         return COND__NOT_FOUND;
 282     }
 283 #endif /* SEARCH_TYPE_GLIB */
 284     return COND__FOUND_OK;
 285
 286 }
 287
 288 /* --------------------------------------------------------------------------------------------- */
 289
 290 static mc_search__found_cond_t
 291 mc_search__regex_found_cond (mc_search_t * lc_mc_search, GString * search_str)
 292 {
 293     gsize loop1;
 294     mc_search_cond_t *mc_search_cond;
 295     mc_search__found_cond_t ret;
 296
 297     for (loop1 = 0; loop1 < lc_mc_search->conditions->len; loop1++)
 298     {
 299         mc_search_cond = (mc_search_cond_t *) g_ptr_array_index (lc_mc_search->conditions, loop1);
 300
 301         if (!mc_search_cond->regex_handle)
 302             continue;
 303
 304         ret =
 305             mc_search__regex_found_cond_one (lc_mc_search, mc_search_cond->regex_handle,
 306                                              search_str);
 307
 308         if (ret != COND__NOT_FOUND)
 309             return ret;
 310     }
 311     return COND__NOT_ALL_FOUND;
 312 }
 313
 314 /* --------------------------------------------------------------------------------------------- */
 315
 316 static int
 317 mc_search_regex__get_max_num_of_replace_tokens (const gchar * str, gsize len)
 318 {
 319     int max_token = 0;
 320     gsize loop;
 321     for (loop = 0; loop < len - 1; loop++)
 322     {
 323         if (str[loop] == '\\' && g_ascii_isdigit(str[loop + 1]) )
 324         {
 325             if (strutils_is_char_escaped (str, &str[loop]))
 326                 continue;
 327             if (max_token < str[loop + 1] - '0')
 328                 max_token = str[loop + 1] - '0';
 329             continue;
 330         }
 331         if (str[loop] == '$' && str[loop + 1] == '{')
 332         {
 333             gsize tmp_len;
 334             char *tmp_str;
 335             int tmp_token;
 336             if (strutils_is_char_escaped (str, &str[loop]))
 337                 continue;
 338
 339             for (tmp_len = 0;
 340                  loop + tmp_len + 2 < len && (str[loop + 2 + tmp_len] & (char) 0xf0) == 0x30;
 341                  tmp_len++);
 342             if (str[loop + 2 + tmp_len] == '}')
 343             {
 344                 tmp_str = g_strndup (&str[loop + 2], tmp_len);
 345                 tmp_token = atoi (tmp_str);
 346                 if (max_token < tmp_token)
 347                     max_token = tmp_token;
 348                 g_free (tmp_str);
 349             }
 350         }
 351     }
 352     return max_token;
 353 }
 354
 355 /* --------------------------------------------------------------------------------------------- */
 356
 357 static char *
 358 mc_search_regex__get_token_by_num (const mc_search_t * lc_mc_search, gsize lc_index)
 359 {
 360     int fnd_start = 0, fnd_end = 0;
 361
 362 #ifdef SEARCH_TYPE_GLIB
 363     g_match_info_fetch_pos (lc_mc_search->regex_match_info, lc_index, &fnd_start, &fnd_end);
 364 #else /* SEARCH_TYPE_GLIB */
 365     fnd_start = lc_mc_search->iovector[lc_index * 2 + 0];
 366     fnd_end = lc_mc_search->iovector[lc_index * 2 + 1];
 367 #endif /* SEARCH_TYPE_GLIB */
 368
 369     if (fnd_end - fnd_start == 0)
 370         return NULL;
 371
 372     return g_strndup (lc_mc_search->regex_buffer->str + fnd_start, fnd_end - fnd_start);
 373
 374 }
 375
 376 /* --------------------------------------------------------------------------------------------- */
 377 static int
 378 mc_search_regex__process_replace_str (const GString * replace_str, const gsize current_pos,
 379                                       gsize * skip_len, replace_transform_type_t * replace_flags)
 380 {
 381     int ret = -1;
 382     char *tmp_str;
 383     const char *curr_str = &(replace_str->str[current_pos]);
 384
 385     if (current_pos > replace_str->len)
 386         return -1;
 387
 388     *skip_len = 0;
 389
 390     if (*curr_str == '$' && *(curr_str + 1) == '{' && (*(curr_str + 2) & (char) 0xf0) == 0x30)
 391     {
 392         if (strutils_is_char_escaped (replace_str->str, curr_str))
 393         {
 394             *skip_len = 1;
 395             return -1;
 396         }
 397
 398         for (*skip_len = 0;
 399              current_pos + *skip_len + 2 < replace_str->len
 400              && (*(curr_str + 2 + *skip_len) & (char) 0xf0) == 0x30; (*skip_len)++);
 401
 402         if (*(curr_str + 2 + *skip_len) != '}')
 403             return -1;
 404
 405         tmp_str = g_strndup (curr_str + 2, *skip_len);
 406         if (tmp_str == NULL)
 407             return -1;
 408
 409         ret = atoi (tmp_str);
 410         g_free (tmp_str);
 411
 412         *skip_len += 3;         /* ${} */
 413         return ret;
 414     }
 415
 416     if (*curr_str == '\\')
 417     {
 418         if (strutils_is_char_escaped (replace_str->str, curr_str))
 419         {
 420             *skip_len = 1;
 421             return -1;
 422         }
 423
 424         if ( g_ascii_isdigit(*(curr_str + 1)))
 425         {
 426             ret = g_ascii_digit_value (*(curr_str + 1));
 427             *skip_len = 2;      /* \\ and one digit */
 428             return ret;
 429         }
 430         ret = -2;
 431         *skip_len += 2;
 432         switch (*(curr_str + 1))
 433         {
 434         case 'U':
 435             *replace_flags |= REPLACE_T_UPP_TRANSFORM;
 436             *replace_flags &= ~REPLACE_T_LOW_TRANSFORM;
 437             break;
 438         case 'u':
 439             *replace_flags |= REPLACE_T_UPP_TRANSFORM_CHAR;
 440             break;
 441         case 'L':
 442             *replace_flags |= REPLACE_T_LOW_TRANSFORM;
 443             *replace_flags &= ~REPLACE_T_UPP_TRANSFORM;
 444             break;
 445         case 'l':
 446             *replace_flags |= REPLACE_T_LOW_TRANSFORM_CHAR;
 447             break;
 448         case 'E':
 449             *replace_flags = REPLACE_T_NO_TRANSFORM;
 450             break;
 451         default:
 452             ret = -1;
 453             break;
 454         }
 455     }
 456     return ret;
 457 }
 458 static void
 459 mc_search_regex__process_append_str (GString * dest_str, const char *from, gsize len,
 460                                      replace_transform_type_t * replace_flags)
 461 {
 462     gsize loop = 0;
 463     gsize char_len;
 464     char *tmp_str;
 465     GString *tmp_string;
 466
 467     if (len == (gsize) - 1)
 468         len = strlen (from);
 469
 470     if (*replace_flags == REPLACE_T_NO_TRANSFORM)
 471     {
 472         g_string_append_len (dest_str, from, len);
 473         return;
 474     }
 475     while (loop < len)
 476     {
 477         tmp_str = mc_search__get_one_symbol (NULL, from + loop, len - loop, NULL);
 478         char_len = strlen (tmp_str);
 479         if (*replace_flags & REPLACE_T_UPP_TRANSFORM_CHAR)
 480         {
 481             *replace_flags &= ~REPLACE_T_UPP_TRANSFORM_CHAR;
 482             tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
 483             g_string_append (dest_str, tmp_string->str);
 484             g_string_free (tmp_string, TRUE);
 485
 486         }
 487         else if (*replace_flags & REPLACE_T_LOW_TRANSFORM_CHAR)
 488         {
 489             *replace_flags &= ~REPLACE_T_LOW_TRANSFORM_CHAR;
 490             tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
 491             g_string_append (dest_str, tmp_string->str);
 492             g_string_free (tmp_string, TRUE);
 493
 494         }
 495         else if (*replace_flags & REPLACE_T_UPP_TRANSFORM)
 496         {
 497             tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
 498             g_string_append (dest_str, tmp_string->str);
 499             g_string_free (tmp_string, TRUE);
 500
 501         }
 502         else if (*replace_flags & REPLACE_T_LOW_TRANSFORM)
 503         {
 504             tmp_string = mc_search__tolower_case_str (NULL, tmp_str, char_len);
 505             g_string_append (dest_str, tmp_string->str);
 506             g_string_free (tmp_string, TRUE);
 507
 508         }
 509         else
 510         {
 511             g_string_append (dest_str, tmp_str);
 512         }
 513         g_free (tmp_str);
 514         loop += char_len;
 515     }
 516
 517 }
 518
 519 /*** public functions ****************************************************************************/
 520
 521 void
 522 mc_search__cond_struct_new_init_regex (const char *charset, mc_search_t * lc_mc_search,
 523                                        mc_search_cond_t * mc_search_cond)
 524 {
 525     GString *tmp = NULL;
 526 #ifdef SEARCH_TYPE_GLIB
 527     GError *error = NULL;
 528 #else /* SEARCH_TYPE_GLIB */
 529     const char *error;
 530     int erroffset;
 531 #endif /* SEARCH_TYPE_GLIB */
 532
 533     if (!lc_mc_search->is_case_sensitive)
 534     {
 535         tmp = g_string_new_len (mc_search_cond->str->str, mc_search_cond->str->len);
 536         g_string_free (mc_search_cond->str, TRUE);
 537         mc_search_cond->str = mc_search__cond_struct_new_regex_ci_str (charset, tmp->str, tmp->len);
 538         g_string_free (tmp, TRUE);
 539     }
 540 #ifdef SEARCH_TYPE_GLIB
 541     mc_search_cond->regex_handle =
 542         g_regex_new (mc_search_cond->str->str, G_REGEX_OPTIMIZE | G_REGEX_RAW | G_REGEX_DOTALL, 0,
 543                      &error);
 544
 545     if (error != NULL)
 546     {
 547         lc_mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
 548         lc_mc_search->error_str = str_conv_gerror_message (error, _("Regular expression error"));
 549         g_error_free (error);
 550         return;
 551     }
 552 #else /* SEARCH_TYPE_GLIB */
 553     mc_search_cond->regex_handle =
 554         pcre_compile (mc_search_cond->str->str, PCRE_EXTRA, &error, &erroffset, NULL);
 555     if (mc_search_cond->regex_handle == NULL)
 556     {
 557         lc_mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
 558         lc_mc_search->error_str = g_strdup (error);
 559         return;
 560     }
 561     lc_mc_search->regex_match_info = pcre_study (mc_search_cond->regex_handle, 0, &error);
 562     if (lc_mc_search->regex_match_info == NULL)
 563     {
 564         if (error)
 565         {
 566             lc_mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
 567             lc_mc_search->error_str = g_strdup (error);
 568             g_free (mc_search_cond->regex_handle);
 569             mc_search_cond->regex_handle = NULL;
 570             return;
 571         }
 572     }
 573 #endif /* SEARCH_TYPE_GLIB */
 574 }
 575
 576 /* --------------------------------------------------------------------------------------------- */
 577
 578 gboolean
 579 mc_search__run_regex (mc_search_t * lc_mc_search, const void *user_data,
 580                       gsize start_search, gsize end_search, gsize * found_len)
 581 {
 582     gsize current_pos, virtual_pos;
 583     int current_chr = 0;
 584     gint start_pos;
 585     gint end_pos;
 586
 587     if (lc_mc_search->regex_buffer != NULL)
 588         g_string_free (lc_mc_search->regex_buffer, TRUE);
 589
 590     lc_mc_search->regex_buffer = g_string_new ("");
 591
 592     virtual_pos = current_pos = start_search;
 593     while (virtual_pos <= end_search)
 594     {
 595         g_string_set_size (lc_mc_search->regex_buffer, 0);
 596         lc_mc_search->start_buffer = current_pos;
 597
 598         while (1)
 599         {
 600             current_chr = mc_search__get_char (lc_mc_search, user_data, current_pos);
 601             if (current_chr == MC_SEARCH_CB_ABORT)
 602                 break;
 603
 604             current_pos++;
 605
 606             if (current_chr == MC_SEARCH_CB_SKIP)
 607                 continue;
 608
 609             virtual_pos++;
 610
 611             g_string_append_c (lc_mc_search->regex_buffer, (char) current_chr);
 612
 613
 614             if (current_chr == 0 || (char) current_chr == '\n')
 615                 break;
 616
 617             if (virtual_pos > end_search)
 618                 break;
 619
 620         }
 621         switch (mc_search__regex_found_cond (lc_mc_search, lc_mc_search->regex_buffer))
 622         {
 623         case COND__FOUND_OK:
 624 #ifdef SEARCH_TYPE_GLIB
 625             if (lc_mc_search->whole_words)
 626             {
 627                 g_match_info_fetch_pos (lc_mc_search->regex_match_info, 2, &start_pos, &end_pos);
 628             }
 629             else
 630             {
 631                 g_match_info_fetch_pos (lc_mc_search->regex_match_info, 0, &start_pos, &end_pos);
 632             }
 633 #else /* SEARCH_TYPE_GLIB */
 634             if (lc_mc_search->whole_words)
 635             {
 636                 start_pos = lc_mc_search->iovector[4];
 637                 end_pos = lc_mc_search->iovector[5];
 638             }
 639             else
 640             {
 641                 start_pos = lc_mc_search->iovector[0];
 642                 end_pos = lc_mc_search->iovector[1];
 643             }
 644 #endif /* SEARCH_TYPE_GLIB */
 645             if (found_len)
 646                 *found_len = end_pos - start_pos;
 647             lc_mc_search->normal_offset = lc_mc_search->start_buffer + start_pos;
 648             return TRUE;
 649         case COND__NOT_ALL_FOUND:
 650             break;
 651         default:
 652             g_string_free (lc_mc_search->regex_buffer, TRUE);
 653             lc_mc_search->regex_buffer = NULL;
 654             return FALSE;
 655         }
 656         if ((lc_mc_search->update_fn != NULL) &&
 657             ((lc_mc_search->update_fn) (user_data, current_pos) == MC_SEARCH_CB_ABORT))
 658             current_chr = MC_SEARCH_CB_ABORT;
 659
 660         if (current_chr == MC_SEARCH_CB_ABORT)
 661             break;
 662     }
 663     g_string_free (lc_mc_search->regex_buffer, TRUE);
 664     lc_mc_search->regex_buffer = NULL;
 665     lc_mc_search->error = MC_SEARCH_E_NOTFOUND;
 666
 667     if (current_chr != MC_SEARCH_CB_ABORT)
 668         lc_mc_search->error_str = g_strdup (_(STR_E_NOTFOUND));
 669     else
 670         lc_mc_search->error_str = NULL;
 671
 672     return FALSE;
 673 }
 674
 675 /* --------------------------------------------------------------------------------------------- */
 676 GString *
 677 mc_search_regex_prepare_replace_str (mc_search_t * lc_mc_search, GString * replace_str)
 678 {
 679     GString *ret;
 680     gchar *tmp_str;
 681
 682     int num_replace_tokens, lc_index;
 683     gsize loop;
 684     gsize len = 0;
 685     gchar *prev_str;
 686     replace_transform_type_t replace_flags = REPLACE_T_NO_TRANSFORM;
 687
 688     num_replace_tokens =
 689         mc_search_regex__get_max_num_of_replace_tokens (replace_str->str, replace_str->len);
 690
 691     if (lc_mc_search->num_results < 0)
 692         return g_string_new_len (replace_str->str, replace_str->len);
 693
 694     if (num_replace_tokens > lc_mc_search->num_results - 1
 695         || num_replace_tokens > MC_SEARCH__NUM_REPLACE_ARGS)
 696     {
 697         lc_mc_search->error = MC_SEARCH_E_REGEX_REPLACE;
 698         lc_mc_search->error_str = g_strdup (_(STR_E_RPL_NOT_EQ_TO_FOUND));
 699         return NULL;
 700     }
 701
 702     ret = g_string_new ("");
 703     prev_str = replace_str->str;
 704     for (loop = 0; loop < replace_str->len - 1; loop++)
 705     {
 706         lc_index = mc_search_regex__process_replace_str (replace_str, loop, &len, &replace_flags);
 707
 708         if (lc_index == -1)
 709         {
 710             if (len != 0)
 711             {
 712                 mc_search_regex__process_append_str (ret, prev_str,
 713                                                      replace_str->str - prev_str + loop,
 714                                                      &replace_flags);
 715                 mc_search_regex__process_append_str (ret, replace_str->str + loop + 1, len - 1,
 716                                                      &replace_flags);
 717                 prev_str = replace_str->str + loop + len;
 718                 loop += len - 1;
 719             }
 720             continue;
 721         }
 722
 723         if (lc_index == -2)
 724         {
 725             if (loop)
 726                 mc_search_regex__process_append_str (ret, prev_str,
 727                                                      replace_str->str - prev_str + loop,
 728                                                      &replace_flags);
 729             prev_str = replace_str->str + loop + len;
 730             loop += len - 1;
 731             continue;
 732         }
 733
 734         if (lc_index > lc_mc_search->num_results)
 735         {
 736             g_string_free (ret, TRUE);
 737             lc_mc_search->error = MC_SEARCH_E_REGEX_REPLACE;
 738             lc_mc_search->error_str = g_strdup_printf (_(STR_E_RPL_INVALID_TOKEN), lc_index);
 739             return NULL;
 740         }
 741
 742         tmp_str = mc_search_regex__get_token_by_num (lc_mc_search, lc_index);
 743         if (tmp_str == NULL)
 744             continue;
 745
 746         if (loop)
 747             mc_search_regex__process_append_str (ret, prev_str, replace_str->str - prev_str + loop,
 748                                                  &replace_flags);
 749         prev_str = replace_str->str + loop + len;
 750
 751         mc_search_regex__process_append_str (ret, tmp_str, -1, &replace_flags);
 752         g_free (tmp_str);
 753         loop += len - 1;
 754     }
 755     mc_search_regex__process_append_str (ret, prev_str,
 756                                          replace_str->str - prev_str + replace_str->len,
 757                                          &replace_flags);
 758
 759     return ret;
 760 }