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     REPLACE_T_NO_TRANSFORM = 0,
  49     REPLACE_T_UPP_TRANSFORM_CHAR = 1,
  50     REPLACE_T_LOW_TRANSFORM_CHAR = 2,
  51     REPLACE_T_UPP_TRANSFORM = 4,
  52     REPLACE_T_LOW_TRANSFORM = 8
  53 } replace_transform_type_t;
  54
  55 /*** file scope variables ************************************************************************/
  56
  57 /*** file scope functions ************************************************************************/
  58
  59 static gboolean
  60 mc_search__regex_str_append_if_special (GString * copy_to, GString * regex_str, gsize * offset)
  61 {
  62     char *tmp_regex_str;
  63     gsize spec_chr_len;
  64     const char **spec_chr;
  65     const char *special_chars[] = {
  66         "\\s", "\\S",
  67         "\\d", "\\D",
  68         "\\b", "\\B",
  69         "\\w", "\\W",
  70         "\\t", "\\n",
  71         "\\r", "\\f",
  72         "\\a", "\\e",
  73         "\\x", "\\X",
  74         "\\c", "\\C",
  75         "\\l", "\\L",
  76         "\\u", "\\U",
  77         "\\E", "\\Q",
  78         NULL
  79     };
  80     spec_chr = special_chars;
  81
  82     tmp_regex_str = &(regex_str->str[*offset]);
  83
  84     while (*spec_chr) {
  85         spec_chr_len = strlen (*spec_chr);
  86         if (!strncmp (tmp_regex_str, *spec_chr, spec_chr_len)) {
  87             if (!strutils_is_char_escaped (regex_str->str, tmp_regex_str)) {
  88                 if (!strncmp ("\\x", *spec_chr, spec_chr_len)) {
  89                     if (*(tmp_regex_str + spec_chr_len) == '{') {
  90                         while ((spec_chr_len < regex_str->len - *offset)
  91                                && *(tmp_regex_str + spec_chr_len) != '}')
  92                             spec_chr_len++;
  93                         if (*(tmp_regex_str + spec_chr_len) == '}')
  94                             spec_chr_len++;
  95                     } else
  96                         spec_chr_len += 2;
  97                 }
  98                 g_string_append_len (copy_to, tmp_regex_str, spec_chr_len);
  99                 *offset += spec_chr_len;
 100                 return TRUE;
 101             }
 102         }
 103         spec_chr++;
 104     }
 105     return FALSE;
 106
 107 }
 108
 109 /* --------------------------------------------------------------------------------------------- */
 110 static void
 111 mc_search__cond_struct_new_regex_hex_add (const char *charset, GString * str_to,
 112                                           const char *one_char, gsize str_len)
 113 {
 114     GString *upp, *low;
 115     gchar *tmp_str;
 116     gsize loop;
 117
 118     upp = mc_search__toupper_case_str (charset, one_char, str_len);
 119     low = mc_search__tolower_case_str (charset, one_char, str_len);
 120
 121     for (loop = 0; loop < upp->len; loop++) {
 122
 123         if (loop < low->len) {
 124             if (upp->str[loop] == low->str[loop])
 125                 tmp_str = g_strdup_printf ("\\x%02X", (unsigned char) upp->str[loop]);
 126             else
 127                 tmp_str =
 128                     g_strdup_printf ("[\\x%02X\\x%02X]", (unsigned char) upp->str[loop],
 129                                      (unsigned char) low->str[loop]);
 130         } else {
 131             tmp_str = g_strdup_printf ("\\x%02X", (unsigned char) upp->str[loop]);
 132         }
 133         g_string_append (str_to, tmp_str);
 134         g_free (tmp_str);
 135     }
 136     g_string_free (upp, TRUE);
 137     g_string_free (low, TRUE);
 138 }
 139
 140 /* --------------------------------------------------------------------------------------------- */
 141
 142 static void
 143 mc_search__cond_struct_new_regex_accum_append (const char *charset, GString * str_to,
 144                                                GString * str_from)
 145 {
 146     GString *recoded_part;
 147     gsize loop = 0;
 148
 149     recoded_part = g_string_sized_new (32);
 150
 151     while (loop < str_from->len) {
 152         gchar *one_char;
 153         gsize one_char_len;
 154         gboolean just_letters;
 155
 156         one_char =
 157             mc_search__get_one_symbol (charset, &(str_from->str[loop]),
 158                                        min (str_from->len - loop, 6), &just_letters);
 159         one_char_len = strlen (one_char);
 160
 161         if (one_char_len == 0)
 162             loop++;
 163         else {
 164             loop += one_char_len;
 165
 166             if (just_letters)
 167                 mc_search__cond_struct_new_regex_hex_add (charset, recoded_part, one_char,
 168                                                             one_char_len);
 169             else
 170                 g_string_append_len (recoded_part, one_char, one_char_len);
 171         }
 172
 173         g_free (one_char);
 174     }
 175
 176     g_string_append (str_to, recoded_part->str);
 177     g_string_free (recoded_part, TRUE);
 178     g_string_set_size (str_from, 0);
 179 }
 180
 181 /* --------------------------------------------------------------------------------------------- */
 182
 183 static GString *
 184 mc_search__cond_struct_new_regex_ci_str (const char *charset, const char *str, gsize str_len)
 185 {
 186     GString *accumulator, *spec_char, *ret_str;
 187     gsize loop;
 188     GString *tmp;
 189     tmp = g_string_new_len (str, str_len);
 190
 191
 192     ret_str = g_string_new ("");
 193     accumulator = g_string_new ("");
 194     spec_char = g_string_new ("");
 195     loop = 0;
 196
 197     while (loop <= str_len) {
 198         if (mc_search__regex_str_append_if_special (spec_char, tmp, &loop)) {
 199             mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
 200             g_string_append_len (ret_str, spec_char->str, spec_char->len);
 201             g_string_set_size (spec_char, 0);
 202             continue;
 203         }
 204
 205         if (tmp->str[loop] == '[' && !strutils_is_char_escaped (tmp->str, &(tmp->str[loop]))) {
 206             mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
 207
 208             while (loop < str_len && !(tmp->str[loop] == ']'
 209                                        && !strutils_is_char_escaped (tmp->str,
 210                                                                      &(tmp->str[loop])))) {
 211                 g_string_append_c (ret_str, tmp->str[loop]);
 212                 loop++;
 213
 214             }
 215             g_string_append_c (ret_str, tmp->str[loop]);
 216             loop++;
 217             continue;
 218         }
 219         /*
 220            TODO: handle [ and ]
 221          */
 222         g_string_append_c (accumulator, tmp->str[loop]);
 223         loop++;
 224     }
 225     mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
 226
 227     g_string_free (accumulator, TRUE);
 228     g_string_free (spec_char, TRUE);
 229     g_string_free (tmp, TRUE);
 230     return ret_str;
 231 }
 232
 233 /* --------------------------------------------------------------------------------------------- */
 234
 235 static mc_search__found_cond_t
 236 mc_search__regex_found_cond_one (mc_search_t * lc_mc_search, mc_search_regex_t * regex,
 237                                  GString * search_str)
 238 {
 239 #ifdef SEARCH_TYPE_GLIB
 240     GError *error = NULL;
 241
 242     if (!g_regex_match_full
 243         (regex, search_str->str, -1, 0, G_REGEX_MATCH_NEWLINE_ANY, &lc_mc_search->regex_match_info,
 244          &error)) {
 245         g_match_info_free (lc_mc_search->regex_match_info);
 246         lc_mc_search->regex_match_info = NULL;
 247         if (error) {
 248             lc_mc_search->error = MC_SEARCH_E_REGEX;
 249             lc_mc_search->error_str = str_conv_gerror_message (error, _(" Regular expression error "));
 250             g_error_free (error);
 251             return COND__FOUND_ERROR;
 252         }
 253         return COND__NOT_FOUND;
 254     }
 255     lc_mc_search->num_rezults = g_match_info_get_match_count (lc_mc_search->regex_match_info);
 256 #else /* SEARCH_TYPE_GLIB */
 257     lc_mc_search->num_rezults = pcre_exec (regex, lc_mc_search->regex_match_info,
 258                                         search_str->str, search_str->len - 1, 0, 0, lc_mc_search->iovector,
 259                                         MC_SEARCH__NUM_REPLACE_ARGS);
 260     if (lc_mc_search->num_rezults < 0) {
 261         return COND__NOT_FOUND;
 262     }
 263 #endif /* SEARCH_TYPE_GLIB */
 264     return COND__FOUND_OK;
 265
 266 }
 267
 268 /* --------------------------------------------------------------------------------------------- */
 269
 270 static mc_search__found_cond_t
 271 mc_search__regex_found_cond (mc_search_t * lc_mc_search, GString * search_str)
 272 {
 273     gsize loop1;
 274     mc_search_cond_t *mc_search_cond;
 275     mc_search__found_cond_t ret;
 276
 277     for (loop1 = 0; loop1 < lc_mc_search->conditions->len; loop1++) {
 278         mc_search_cond = (mc_search_cond_t *) g_ptr_array_index (lc_mc_search->conditions, loop1);
 279
 280         if (!mc_search_cond->regex_handle)
 281             continue;
 282
 283         ret = mc_search__regex_found_cond_one (lc_mc_search, mc_search_cond->regex_handle, search_str);
 284
 285         if (ret != COND__NOT_FOUND)
 286             return ret;
 287     }
 288     return COND__NOT_ALL_FOUND;
 289 }
 290
 291 /* --------------------------------------------------------------------------------------------- */
 292
 293 static int
 294 mc_search_regex__get_max_num_of_replace_tokens (const gchar * str, gsize len)
 295 {
 296     int max_token = 0;
 297     gsize loop;
 298     for (loop = 0; loop < len - 1; loop++) {
 299         if (str[loop] == '\\' && (str[loop + 1] & (char) 0xf0) == 0x30 /* 0-9 */ ) {
 300             if (strutils_is_char_escaped (str, &str[loop]))
 301                 continue;
 302             if (max_token < str[loop + 1] - '0')
 303                 max_token = str[loop + 1] - '0';
 304             continue;
 305         }
 306         if (str[loop] == '$' && str[loop + 1] == '{') {
 307             gsize tmp_len;
 308             char *tmp_str;
 309             int tmp_token;
 310             if (strutils_is_char_escaped (str, &str[loop]))
 311                 continue;
 312
 313             for (tmp_len = 0;
 314                  loop + tmp_len + 2 < len && (str[loop + 2 + tmp_len] & (char) 0xf0) == 0x30;
 315                  tmp_len++);
 316             if (str[loop + 2 + tmp_len] == '}') {
 317                 tmp_str = g_strndup (&str[loop + 2], tmp_len);
 318                 tmp_token = atoi (tmp_str);
 319                 if (max_token < tmp_token)
 320                     max_token = tmp_token;
 321                 g_free (tmp_str);
 322             }
 323         }
 324     }
 325     return max_token;
 326 }
 327
 328 /* --------------------------------------------------------------------------------------------- */
 329
 330 static char *
 331 mc_search_regex__get_token_by_num (const mc_search_t * lc_mc_search, gsize lc_index)
 332 {
 333     int fnd_start = 0, fnd_end = 0;
 334
 335 #ifdef SEARCH_TYPE_GLIB
 336     g_match_info_fetch_pos (lc_mc_search->regex_match_info, lc_index, &fnd_start, &fnd_end);
 337 #else /* SEARCH_TYPE_GLIB */
 338     fnd_start = lc_mc_search->iovector[lc_index * 2 + 0];
 339     fnd_end = lc_mc_search->iovector[lc_index * 2 + 1];
 340 #endif /* SEARCH_TYPE_GLIB */
 341
 342     if (fnd_end - fnd_start == 0)
 343         return NULL;
 344
 345     return g_strndup (lc_mc_search->regex_buffer->str + fnd_start, fnd_end - fnd_start);
 346
 347 }
 348
 349 /* --------------------------------------------------------------------------------------------- */
 350 static int
 351 mc_search_regex__process_replace_str (const GString * replace_str, const gsize current_pos,
 352                                       gsize * skip_len, replace_transform_type_t * replace_flags)
 353 {
 354     int ret = -1;
 355     char *tmp_str;
 356     const char *curr_str = &(replace_str->str[current_pos]);
 357
 358     if (current_pos > replace_str->len)
 359         return -1;
 360
 361     *skip_len = 0;
 362
 363     if (*curr_str == '$' && *(curr_str + 1) == '{' && (*(curr_str + 2) & (char) 0xf0) == 0x30) {
 364         if (strutils_is_char_escaped (replace_str->str, curr_str)) {
 365             *skip_len = 1;
 366             return -1;
 367         }
 368
 369         for (*skip_len = 0;
 370              current_pos + *skip_len + 2 < replace_str->len
 371              && (*(curr_str + 2 + *skip_len) & (char) 0xf0) == 0x30; (*skip_len)++);
 372
 373         if (*(curr_str + 2 + *skip_len) != '}')
 374             return -1;
 375
 376         tmp_str = g_strndup (curr_str + 2, *skip_len);
 377         if (tmp_str == NULL)
 378             return -1;
 379
 380         ret = atoi (tmp_str);
 381         g_free (tmp_str);
 382
 383         *skip_len += 3;         /* ${} */
 384         return ret;
 385     }
 386
 387     if (*curr_str == '\\') {
 388         if (strutils_is_char_escaped (replace_str->str, curr_str)) {
 389             *skip_len = 1;
 390             return -1;
 391         }
 392
 393         if ((*(curr_str + 1) & (char) 0xf0) == 0x30) {
 394             ret = *(curr_str + 1) - '0';
 395             *skip_len = 2;      /* \\ and one digit */
 396             return ret;
 397         }
 398         ret = -2;
 399         *skip_len += 2;
 400         switch (*(curr_str + 1)) {
 401         case 'U':
 402             *replace_flags |= REPLACE_T_UPP_TRANSFORM;
 403             *replace_flags &= ~REPLACE_T_LOW_TRANSFORM;
 404             break;
 405         case 'u':
 406             *replace_flags |= REPLACE_T_UPP_TRANSFORM_CHAR;
 407             break;
 408         case 'L':
 409             *replace_flags |= REPLACE_T_LOW_TRANSFORM;
 410             *replace_flags &= ~REPLACE_T_UPP_TRANSFORM;
 411             break;
 412         case 'l':
 413             *replace_flags |= REPLACE_T_LOW_TRANSFORM_CHAR;
 414             break;
 415         case 'E':
 416             *replace_flags = REPLACE_T_NO_TRANSFORM;
 417             break;
 418         default:
 419             ret = -1;
 420             break;
 421         }
 422     }
 423     return ret;
 424 }
 425 static void
 426 mc_search_regex__process_append_str (GString * dest_str, const char *from, gsize len,
 427                                      replace_transform_type_t * replace_flags)
 428 {
 429     gsize loop = 0;
 430     gsize char_len;
 431     char *tmp_str;
 432     GString *tmp_string;
 433
 434     if (len == (gsize) -1)
 435         len = strlen (from);
 436
 437     if (*replace_flags == REPLACE_T_NO_TRANSFORM) {
 438         g_string_append_len (dest_str, from, len);
 439         return;
 440     }
 441     while (loop < len) {
 442         tmp_str = mc_search__get_one_symbol (NULL, from + loop, len - loop, NULL);
 443         char_len = strlen (tmp_str);
 444         if (*replace_flags & REPLACE_T_UPP_TRANSFORM_CHAR) {
 445             *replace_flags &= !REPLACE_T_UPP_TRANSFORM_CHAR;
 446             tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
 447             g_string_append (dest_str, tmp_string->str);
 448             g_string_free (tmp_string, TRUE);
 449
 450         } else if (*replace_flags & REPLACE_T_LOW_TRANSFORM_CHAR) {
 451             *replace_flags &= !REPLACE_T_LOW_TRANSFORM_CHAR;
 452             tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
 453             g_string_append (dest_str, tmp_string->str);
 454             g_string_free (tmp_string, TRUE);
 455
 456         } else if (*replace_flags & REPLACE_T_UPP_TRANSFORM) {
 457             tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
 458             g_string_append (dest_str, tmp_string->str);
 459             g_string_free (tmp_string, TRUE);
 460
 461         } else if (*replace_flags & REPLACE_T_LOW_TRANSFORM) {
 462             tmp_string = mc_search__tolower_case_str (NULL, tmp_str, char_len);
 463             g_string_append (dest_str, tmp_string->str);
 464             g_string_free (tmp_string, TRUE);
 465
 466         } else {
 467             g_string_append (dest_str, tmp_str);
 468         }
 469         g_free (tmp_str);
 470         loop += char_len;
 471     }
 472
 473 }
 474
 475 /*** public functions ****************************************************************************/
 476
 477 void
 478 mc_search__cond_struct_new_init_regex (const char *charset, mc_search_t * lc_mc_search,
 479                                        mc_search_cond_t * mc_search_cond)
 480 {
 481     GString *tmp = NULL;
 482 #ifdef SEARCH_TYPE_GLIB
 483     GError *error = NULL;
 484 #else /* SEARCH_TYPE_GLIB */
 485     const char *error;
 486     int erroffset;
 487 #endif /* SEARCH_TYPE_GLIB */
 488
 489     if (!lc_mc_search->is_case_sentitive) {
 490         tmp = g_string_new_len (mc_search_cond->str->str, mc_search_cond->str->len);
 491         g_string_free (mc_search_cond->str, TRUE);
 492         mc_search_cond->str = mc_search__cond_struct_new_regex_ci_str (charset, tmp->str, tmp->len);
 493         g_string_free (tmp, TRUE);
 494     }
 495 #ifdef SEARCH_TYPE_GLIB
 496     mc_search_cond->regex_handle =
 497         g_regex_new (mc_search_cond->str->str, G_REGEX_OPTIMIZE | G_REGEX_RAW | G_REGEX_DOTALL, 0,
 498                      &error);
 499
 500     if (error != NULL) {
 501         lc_mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
 502         lc_mc_search->error_str = str_conv_gerror_message (error, _(" Regular expression error "));
 503         g_error_free (error);
 504         return;
 505     }
 506 #else /* SEARCH_TYPE_GLIB */
 507     mc_search_cond->regex_handle =
 508         pcre_compile (mc_search_cond->str->str, PCRE_EXTRA, &error, &erroffset, NULL);
 509     if (mc_search_cond->regex_handle == NULL) {
 510         lc_mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
 511         lc_mc_search->error_str = g_strdup (error);
 512         return;
 513     }
 514     lc_mc_search->regex_match_info = pcre_study (mc_search_cond->regex_handle, 0, &error);
 515     if (lc_mc_search->regex_match_info == NULL) {
 516         if (error) {
 517             lc_mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
 518             lc_mc_search->error_str = g_strdup (error);
 519             g_free (mc_search_cond->regex_handle);
 520             mc_search_cond->regex_handle = NULL;
 521             return;
 522         }
 523     }
 524 #endif /* SEARCH_TYPE_GLIB */
 525 }
 526
 527 /* --------------------------------------------------------------------------------------------- */
 528
 529 gboolean
 530 mc_search__run_regex (mc_search_t * lc_mc_search, const void *user_data,
 531                       gsize start_search, gsize end_search, gsize * found_len)
 532 {
 533     gsize current_pos, virtual_pos;
 534     int current_chr = 0;
 535     gint start_pos;
 536     gint end_pos;
 537
 538     if (lc_mc_search->regex_buffer != NULL)
 539         g_string_free (lc_mc_search->regex_buffer, TRUE);
 540
 541     lc_mc_search->regex_buffer = g_string_new ("");
 542
 543     virtual_pos = current_pos = start_search;
 544     while (virtual_pos <= end_search) {
 545         g_string_set_size (lc_mc_search->regex_buffer, 0);
 546         lc_mc_search->start_buffer = current_pos;
 547
 548         while (1) {
 549             current_chr = mc_search__get_char (lc_mc_search, user_data, current_pos);
 550             if (current_chr == MC_SEARCH_CB_ABORT)
 551                 break;
 552
 553             current_pos++;
 554
 555             if (current_chr == MC_SEARCH_CB_SKIP)
 556                 continue;
 557
 558             virtual_pos++;
 559
 560             g_string_append_c (lc_mc_search->regex_buffer, (char) current_chr);
 561
 562
 563             if (current_chr == 0 || (char) current_chr == '\n')
 564                 break;
 565
 566             if (virtual_pos > end_search)
 567                 break;
 568
 569         }
 570         switch (mc_search__regex_found_cond (lc_mc_search, lc_mc_search->regex_buffer)) {
 571         case COND__FOUND_OK:
 572 #ifdef SEARCH_TYPE_GLIB
 573             g_match_info_fetch_pos (lc_mc_search->regex_match_info, 0, &start_pos, &end_pos);
 574 #else /* SEARCH_TYPE_GLIB */
 575             start_pos = lc_mc_search->iovector[0];
 576             end_pos = lc_mc_search->iovector[1];
 577 #endif /* SEARCH_TYPE_GLIB */
 578             if (found_len)
 579                 *found_len = end_pos - start_pos;
 580             lc_mc_search->normal_offset = lc_mc_search->start_buffer + start_pos;
 581             return TRUE;
 582             break;
 583         case COND__NOT_ALL_FOUND:
 584             break;
 585         default:
 586             g_string_free (lc_mc_search->regex_buffer, TRUE);
 587             lc_mc_search->regex_buffer = NULL;
 588             return FALSE;
 589             break;
 590         }
 591         if (( lc_mc_search->update_fn != NULL ) &&
 592             ( (lc_mc_search->update_fn) (user_data, current_pos) == MC_SEARCH_CB_ABORT))
 593             current_chr = MC_SEARCH_CB_ABORT;
 594
 595         if (current_chr == MC_SEARCH_CB_ABORT)
 596             break;
 597     }
 598     g_string_free (lc_mc_search->regex_buffer, TRUE);
 599     lc_mc_search->regex_buffer = NULL;
 600     lc_mc_search->error = MC_SEARCH_E_NOTFOUND;
 601
 602     if (current_chr != MC_SEARCH_CB_ABORT)
 603         lc_mc_search->error_str = g_strdup (_(STR_E_NOTFOUND));
 604     else
 605         lc_mc_search->error_str = NULL;
 606
 607     return FALSE;
 608 }
 609
 610 /* --------------------------------------------------------------------------------------------- */
 611 GString *
 612 mc_search_regex_prepare_replace_str (mc_search_t * lc_mc_search, GString * replace_str)
 613 {
 614     GString *ret;
 615     gchar *tmp_str;
 616
 617     int num_replace_tokens, lc_index;
 618     gsize loop;
 619     gsize len = 0;
 620     gchar *prev_str;
 621     replace_transform_type_t replace_flags = REPLACE_T_NO_TRANSFORM;
 622
 623     num_replace_tokens =
 624         mc_search_regex__get_max_num_of_replace_tokens (replace_str->str, replace_str->len);
 625
 626     if (lc_mc_search->num_rezults < 0)
 627         return g_string_new_len (replace_str->str, replace_str->len);
 628
 629     if (num_replace_tokens > lc_mc_search->num_rezults - 1
 630         || num_replace_tokens > MC_SEARCH__NUM_REPLACE_ARGS) {
 631         lc_mc_search->error = MC_SEARCH_E_REGEX_REPLACE;
 632         lc_mc_search->error_str = g_strdup (STR_E_RPL_NOT_EQ_TO_FOUND);
 633         return NULL;
 634     }
 635
 636     ret = g_string_new ("");
 637     prev_str = replace_str->str;
 638     for (loop = 0; loop < replace_str->len - 1; loop++) {
 639         lc_index = mc_search_regex__process_replace_str (replace_str, loop, &len, &replace_flags);
 640
 641         if (lc_index == -1) {
 642             if (len != 0) {
 643                 mc_search_regex__process_append_str (ret, prev_str,
 644                                                      replace_str->str - prev_str + loop,
 645                                                      &replace_flags);
 646                 mc_search_regex__process_append_str (ret, replace_str->str + loop + 1, len - 1,
 647                                                      &replace_flags);
 648                 prev_str = replace_str->str + loop + len;
 649                 loop += len - 1;
 650             }
 651             continue;
 652         }
 653
 654         if (lc_index == -2) {
 655             if (loop)
 656                 mc_search_regex__process_append_str (ret, prev_str,
 657                                                      replace_str->str - prev_str + loop,
 658                                                      &replace_flags);
 659             prev_str = replace_str->str + loop + len;
 660             loop += len - 1;
 661             continue;
 662         }
 663
 664         if (lc_index > lc_mc_search->num_rezults) {
 665             g_string_free (ret, TRUE);
 666             lc_mc_search->error = MC_SEARCH_E_REGEX_REPLACE;
 667             lc_mc_search->error_str = g_strdup_printf (STR_E_RPL_INVALID_TOKEN, lc_index);
 668             return NULL;
 669         }
 670
 671         tmp_str = mc_search_regex__get_token_by_num (lc_mc_search, lc_index);
 672         if (tmp_str == NULL)
 673             continue;
 674
 675         if (loop)
 676             mc_search_regex__process_append_str (ret, prev_str, replace_str->str - prev_str + loop,
 677                                                  &replace_flags);
 678         prev_str = replace_str->str + loop + len;
 679
 680         mc_search_regex__process_append_str (ret, tmp_str, -1, &replace_flags);
 681         g_free (tmp_str);
 682         loop += len - 1;
 683     }
 684     mc_search_regex__process_append_str (ret, prev_str,
 685                                          replace_str->str - prev_str + replace_str->len,
 686                                          &replace_flags);
 687
 688     return ret;
 689 }