This source file includes following definitions.
- mc_search__regex_str_append_if_special
- mc_search__cond_struct_new_regex_hex_add
- mc_search__cond_struct_new_regex_accum_append
- mc_search__cond_struct_new_regex_ci_str
- mc_search__g_regex_match_full_safe
- mc_search__regex_found_cond_one
- mc_search__regex_found_cond
- mc_search_regex__get_max_num_of_replace_tokens
- mc_search_regex__get_token_by_num
- mc_search_regex__replace_handle_esc_seq
- mc_search_regex__process_replace_str
- mc_search_regex__process_append_str
- mc_search_regex__process_escape_sequence
- mc_search__cond_struct_new_init_regex
- mc_search__run_regex
- mc_search_regex_prepare_replace_str
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29 #include <config.h>
30
31 #include <stdlib.h>
32
33 #include "lib/global.h"
34 #include "lib/strutil.h"
35 #include "lib/search.h"
36 #include "lib/strescape.h"
37 #include "lib/util.h"
38
39 #include "internal.h"
40
41
42
43
44
45 #define REPLACE_PREPARE_T_NOTHING_SPECIAL -1
46 #define REPLACE_PREPARE_T_REPLACE_FLAG -2
47 #define REPLACE_PREPARE_T_ESCAPE_SEQ -3
48
49
50
51 typedef enum
52 {
53 REPLACE_T_NO_TRANSFORM = 0,
54 REPLACE_T_UPP_TRANSFORM_CHAR = 1,
55 REPLACE_T_LOW_TRANSFORM_CHAR = 2,
56 REPLACE_T_UPP_TRANSFORM = 4,
57 REPLACE_T_LOW_TRANSFORM = 8
58 } replace_transform_type_t;
59
60
61
62
63
64
65 static gboolean
66 mc_search__regex_str_append_if_special (GString * copy_to, const GString * regex_str,
67 gsize * offset)
68 {
69 const char *special_chars[] = {
70 "\\s", "\\S",
71 "\\d", "\\D",
72 "\\b", "\\B",
73 "\\w", "\\W",
74 "\\t", "\\n",
75 "\\r", "\\f",
76 "\\a", "\\e",
77 "\\x", "\\X",
78 "\\c", "\\C",
79 "\\l", "\\L",
80 "\\u", "\\U",
81 "\\E", "\\Q",
82 NULL
83 };
84
85 char *tmp_regex_str;
86 const char **spec_chr;
87
88 tmp_regex_str = &(regex_str->str[*offset]);
89
90 for (spec_chr = special_chars; *spec_chr != NULL; spec_chr++)
91 {
92 gsize spec_chr_len;
93
94 spec_chr_len = strlen (*spec_chr);
95
96 if (strncmp (tmp_regex_str, *spec_chr, spec_chr_len) == 0
97 && !strutils_is_char_escaped (regex_str->str, tmp_regex_str))
98 {
99 if (strncmp ("\\x", *spec_chr, spec_chr_len) == 0)
100 {
101 if (tmp_regex_str[spec_chr_len] != '{')
102 spec_chr_len += 2;
103 else
104 {
105 while ((spec_chr_len < regex_str->len - *offset)
106 && tmp_regex_str[spec_chr_len] != '}')
107 spec_chr_len++;
108 if (tmp_regex_str[spec_chr_len] == '}')
109 spec_chr_len++;
110 }
111 }
112 g_string_append_len (copy_to, tmp_regex_str, spec_chr_len);
113 *offset += spec_chr_len;
114 return TRUE;
115 }
116 }
117
118 return FALSE;
119 }
120
121
122
123 static void
124 mc_search__cond_struct_new_regex_hex_add (const char *charset, GString * str_to,
125 const char *one_char, gsize str_len)
126 {
127 GString *upp, *low;
128 gsize loop;
129
130 upp = mc_search__toupper_case_str (charset, one_char, str_len);
131 low = mc_search__tolower_case_str (charset, one_char, str_len);
132
133 for (loop = 0; loop < upp->len; loop++)
134 {
135 gchar tmp_str[10 + 1];
136 gint tmp_len;
137
138 if (loop >= low->len || upp->str[loop] == low->str[loop])
139 tmp_len =
140 g_snprintf (tmp_str, sizeof (tmp_str), "\\x%02X", (unsigned char) upp->str[loop]);
141 else
142 tmp_len =
143 g_snprintf (tmp_str, sizeof (tmp_str), "[\\x%02X\\x%02X]",
144 (unsigned char) upp->str[loop], (unsigned char) low->str[loop]);
145
146 g_string_append_len (str_to, tmp_str, tmp_len);
147 }
148
149 g_string_free (upp, TRUE);
150 g_string_free (low, TRUE);
151 }
152
153
154
155 static void
156 mc_search__cond_struct_new_regex_accum_append (const char *charset, GString * str_to,
157 GString * str_from)
158 {
159 GString *recoded_part;
160 gsize loop = 0;
161
162 recoded_part = g_string_sized_new (32);
163
164 while (loop < str_from->len)
165 {
166 gchar *one_char;
167 gsize one_char_len;
168 gboolean just_letters;
169
170 one_char =
171 mc_search__get_one_symbol (charset, &(str_from->str[loop]),
172 MIN (str_from->len - loop, 6), &just_letters);
173 one_char_len = strlen (one_char);
174
175 if (one_char_len == 0)
176 loop++;
177 else
178 {
179 loop += one_char_len;
180
181 if (just_letters)
182 mc_search__cond_struct_new_regex_hex_add (charset, recoded_part, one_char,
183 one_char_len);
184 else
185 g_string_append_len (recoded_part, one_char, one_char_len);
186 }
187
188 g_free (one_char);
189 }
190
191 g_string_append_len (str_to, recoded_part->str, recoded_part->len);
192 g_string_free (recoded_part, TRUE);
193 g_string_set_size (str_from, 0);
194 }
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211 static GString *
212 mc_search__cond_struct_new_regex_ci_str (const char *charset, const GString * astr)
213 {
214 GString *accumulator, *spec_char, *ret_str;
215 gsize loop;
216
217 ret_str = g_string_sized_new (64);
218 accumulator = g_string_sized_new (64);
219 spec_char = g_string_sized_new (64);
220 loop = 0;
221
222 while (loop <= astr->len)
223 {
224 if (mc_search__regex_str_append_if_special (spec_char, astr, &loop))
225 {
226 mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
227 g_string_append_len (ret_str, spec_char->str, spec_char->len);
228 g_string_set_size (spec_char, 0);
229 continue;
230 }
231
232 if (astr->str[loop] == '[' && !strutils_is_char_escaped (astr->str, &(astr->str[loop])))
233 {
234 mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
235
236 while (loop < astr->len && !(astr->str[loop] == ']'
237 && !strutils_is_char_escaped (astr->str,
238 &(astr->str[loop]))))
239 {
240 g_string_append_c (ret_str, astr->str[loop]);
241 loop++;
242 }
243
244 g_string_append_c (ret_str, astr->str[loop]);
245 loop++;
246 continue;
247 }
248
249
250
251 g_string_append_c (accumulator, astr->str[loop]);
252 loop++;
253 }
254 mc_search__cond_struct_new_regex_accum_append (charset, ret_str, accumulator);
255
256 g_string_free (accumulator, TRUE);
257 g_string_free (spec_char, TRUE);
258
259 return ret_str;
260 }
261
262
263
264 #ifdef SEARCH_TYPE_GLIB
265
266
267
268
269 static gboolean
270 mc_search__g_regex_match_full_safe (const GRegex * regex,
271 const gchar * string,
272 gssize string_len,
273 gint start_position,
274 GRegexMatchFlags match_options,
275 GMatchInfo ** match_info, GError ** error)
276 {
277 char *string_safe, *p, *end;
278 gboolean ret;
279
280 if (string_len < 0)
281 string_len = strlen (string);
282
283 if ((g_regex_get_compile_flags (regex) & G_REGEX_RAW)
284 || g_utf8_validate (string, string_len, NULL))
285 {
286 return g_regex_match_full (regex, string, string_len, start_position, match_options,
287 match_info, error);
288 }
289
290
291 p = string_safe = g_malloc (string_len + 1);
292 memcpy (string_safe, string, string_len);
293 string_safe[string_len] = '\0';
294 end = p + string_len;
295
296 while (p < end)
297 {
298 gunichar c = g_utf8_get_char_validated (p, -1);
299 if (c != (gunichar) (-1) && c != (gunichar) (-2))
300 {
301 p = g_utf8_next_char (p);
302 }
303 else
304 {
305
306
307
308 *p++ = '\0';
309 }
310 }
311
312 ret =
313 g_regex_match_full (regex, string_safe, string_len, start_position, match_options,
314 match_info, error);
315 g_free (string_safe);
316 return ret;
317 }
318 #endif
319
320
321
322 static mc_search__found_cond_t
323 mc_search__regex_found_cond_one (mc_search_t * lc_mc_search, mc_search_regex_t * regex,
324 GString * search_str)
325 {
326 #ifdef SEARCH_TYPE_GLIB
327 GError *mcerror = NULL;
328
329 if (!mc_search__g_regex_match_full_safe
330 (regex, search_str->str, search_str->len, 0, G_REGEX_MATCH_NEWLINE_ANY,
331 &lc_mc_search->regex_match_info, &mcerror))
332 {
333 g_match_info_free (lc_mc_search->regex_match_info);
334 lc_mc_search->regex_match_info = NULL;
335 if (mcerror != NULL)
336 {
337 lc_mc_search->error = MC_SEARCH_E_REGEX;
338 g_free (lc_mc_search->error_str);
339 lc_mc_search->error_str =
340 str_conv_gerror_message (mcerror, _("Regular expression error"));
341 g_error_free (mcerror);
342 return COND__FOUND_ERROR;
343 }
344 return COND__NOT_FOUND;
345 }
346 lc_mc_search->num_results = g_match_info_get_match_count (lc_mc_search->regex_match_info);
347 #else
348 lc_mc_search->num_results = pcre_exec (regex, lc_mc_search->regex_match_info,
349 search_str->str, search_str->len, 0, 0,
350 lc_mc_search->iovector, MC_SEARCH__NUM_REPLACE_ARGS);
351 if (lc_mc_search->num_results < 0)
352 {
353 return COND__NOT_FOUND;
354 }
355 #endif
356 return COND__FOUND_OK;
357
358 }
359
360
361
362 static mc_search__found_cond_t
363 mc_search__regex_found_cond (mc_search_t * lc_mc_search, GString * search_str)
364 {
365 gsize loop1;
366
367 for (loop1 = 0; loop1 < lc_mc_search->prepared.conditions->len; loop1++)
368 {
369 mc_search_cond_t *mc_search_cond;
370 mc_search__found_cond_t ret;
371
372 mc_search_cond =
373 (mc_search_cond_t *) g_ptr_array_index (lc_mc_search->prepared.conditions, loop1);
374
375 if (!mc_search_cond->regex_handle)
376 continue;
377
378 ret =
379 mc_search__regex_found_cond_one (lc_mc_search, mc_search_cond->regex_handle,
380 search_str);
381 if (ret != COND__NOT_FOUND)
382 return ret;
383 }
384 return COND__NOT_ALL_FOUND;
385 }
386
387
388
389 static int
390 mc_search_regex__get_max_num_of_replace_tokens (const gchar * str, gsize len)
391 {
392 int max_token = 0;
393 gsize loop;
394 for (loop = 0; loop < len - 1; loop++)
395 {
396 if (str[loop] == '\\' && g_ascii_isdigit (str[loop + 1]))
397 {
398 if (strutils_is_char_escaped (str, &str[loop]))
399 continue;
400 if (max_token < str[loop + 1] - '0')
401 max_token = str[loop + 1] - '0';
402 continue;
403 }
404 if (str[loop] == '$' && str[loop + 1] == '{')
405 {
406 gsize tmp_len;
407
408 if (strutils_is_char_escaped (str, &str[loop]))
409 continue;
410
411 for (tmp_len = 0;
412 loop + tmp_len + 2 < len && (str[loop + 2 + tmp_len] & (char) 0xf0) == 0x30;
413 tmp_len++);
414
415 if (str[loop + 2 + tmp_len] == '}')
416 {
417 int tmp_token;
418 char *tmp_str;
419
420 tmp_str = g_strndup (&str[loop + 2], tmp_len);
421 tmp_token = atoi (tmp_str);
422 if (max_token < tmp_token)
423 max_token = tmp_token;
424 g_free (tmp_str);
425 }
426 }
427 }
428 return max_token;
429 }
430
431
432
433 static char *
434 mc_search_regex__get_token_by_num (const mc_search_t * lc_mc_search, gsize lc_index)
435 {
436 int fnd_start = 0, fnd_end = 0;
437
438 #ifdef SEARCH_TYPE_GLIB
439 g_match_info_fetch_pos (lc_mc_search->regex_match_info, lc_index, &fnd_start, &fnd_end);
440 #else
441 fnd_start = lc_mc_search->iovector[lc_index * 2 + 0];
442 fnd_end = lc_mc_search->iovector[lc_index * 2 + 1];
443 #endif
444
445 if (fnd_end == fnd_start)
446 return g_strdup ("");
447
448 return g_strndup (lc_mc_search->regex_buffer->str + fnd_start, fnd_end - fnd_start);
449
450 }
451
452
453
454 static gboolean
455 mc_search_regex__replace_handle_esc_seq (const GString * replace_str, const gsize current_pos,
456 gsize * skip_len, int *ret)
457 {
458 char *curr_str = &(replace_str->str[current_pos]);
459 char c = curr_str[1];
460
461 if (replace_str->len > current_pos + 2)
462 {
463 if (c == '{')
464 {
465 for (*skip_len = 2;
466 current_pos + *skip_len < replace_str->len && curr_str[*skip_len] >= '0'
467 && curr_str[*skip_len] <= '7'; (*skip_len)++)
468 ;
469
470 if (current_pos + *skip_len < replace_str->len && curr_str[*skip_len] == '}')
471 {
472 (*skip_len)++;
473 *ret = REPLACE_PREPARE_T_ESCAPE_SEQ;
474 return FALSE;
475 }
476 else
477 {
478 *ret = REPLACE_PREPARE_T_NOTHING_SPECIAL;
479 return TRUE;
480 }
481 }
482
483 if (c == 'x')
484 {
485 *skip_len = 2;
486 c = curr_str[2];
487 if (c == '{')
488 {
489 for (*skip_len = 3;
490 current_pos + *skip_len < replace_str->len
491 && g_ascii_isxdigit ((guchar) curr_str[*skip_len]); (*skip_len)++)
492 ;
493
494 if (current_pos + *skip_len < replace_str->len && curr_str[*skip_len] == '}')
495 {
496 (*skip_len)++;
497 *ret = REPLACE_PREPARE_T_ESCAPE_SEQ;
498 return FALSE;
499 }
500 else
501 {
502 *ret = REPLACE_PREPARE_T_NOTHING_SPECIAL;
503 return TRUE;
504 }
505 }
506 else if (!g_ascii_isxdigit ((guchar) c))
507 {
508 *skip_len = 2;
509 *ret = REPLACE_PREPARE_T_NOTHING_SPECIAL;
510 return FALSE;
511 }
512 else
513 {
514 c = curr_str[3];
515 if (!g_ascii_isxdigit ((guchar) c))
516 *skip_len = 3;
517 else
518 *skip_len = 4;
519 *ret = REPLACE_PREPARE_T_ESCAPE_SEQ;
520 return FALSE;
521 }
522 }
523 }
524
525 if (strchr ("ntvbrfa", c) != NULL)
526 {
527 *skip_len = 2;
528 *ret = REPLACE_PREPARE_T_ESCAPE_SEQ;
529 return FALSE;
530 }
531 return TRUE;
532 }
533
534
535
536 static int
537 mc_search_regex__process_replace_str (const GString * replace_str, const gsize current_pos,
538 gsize * skip_len, replace_transform_type_t * replace_flags)
539 {
540 int ret = -1;
541 const char *curr_str = &(replace_str->str[current_pos]);
542
543 if (current_pos > replace_str->len)
544 return REPLACE_PREPARE_T_NOTHING_SPECIAL;
545
546 *skip_len = 0;
547
548 if (replace_str->len > current_pos + 2 && curr_str[0] == '$' && curr_str[1] == '{'
549 && (curr_str[2] & (char) 0xf0) == 0x30)
550 {
551 char *tmp_str;
552
553 if (strutils_is_char_escaped (replace_str->str, curr_str))
554 {
555 *skip_len = 1;
556 return REPLACE_PREPARE_T_NOTHING_SPECIAL;
557 }
558
559 for (*skip_len = 0;
560 current_pos + *skip_len + 2 < replace_str->len
561 && (curr_str[2 + *skip_len] & (char) 0xf0) == 0x30; (*skip_len)++)
562 ;
563
564 if (curr_str[2 + *skip_len] != '}')
565 return REPLACE_PREPARE_T_NOTHING_SPECIAL;
566
567 tmp_str = g_strndup (curr_str + 2, *skip_len);
568 if (tmp_str == NULL)
569 return REPLACE_PREPARE_T_NOTHING_SPECIAL;
570
571 ret = atoi (tmp_str);
572 g_free (tmp_str);
573
574 *skip_len += 3;
575 return ret;
576 }
577
578 if (curr_str[0] == '\\' && replace_str->len > current_pos + 1)
579 {
580 if (strutils_is_char_escaped (replace_str->str, curr_str))
581 {
582 *skip_len = 1;
583 return REPLACE_PREPARE_T_NOTHING_SPECIAL;
584 }
585
586 if (g_ascii_isdigit (curr_str[1]))
587 {
588 ret = g_ascii_digit_value (curr_str[1]);
589 *skip_len = 2;
590 return ret;
591 }
592
593 if (!mc_search_regex__replace_handle_esc_seq (replace_str, current_pos, skip_len, &ret))
594 return ret;
595
596 ret = REPLACE_PREPARE_T_REPLACE_FLAG;
597 *skip_len += 2;
598
599 switch (curr_str[1])
600 {
601 case 'U':
602 *replace_flags |= REPLACE_T_UPP_TRANSFORM;
603 *replace_flags &= ~REPLACE_T_LOW_TRANSFORM;
604 break;
605 case 'u':
606 *replace_flags |= REPLACE_T_UPP_TRANSFORM_CHAR;
607 break;
608 case 'L':
609 *replace_flags |= REPLACE_T_LOW_TRANSFORM;
610 *replace_flags &= ~REPLACE_T_UPP_TRANSFORM;
611 break;
612 case 'l':
613 *replace_flags |= REPLACE_T_LOW_TRANSFORM_CHAR;
614 break;
615 case 'E':
616 *replace_flags = REPLACE_T_NO_TRANSFORM;
617 break;
618 default:
619 ret = REPLACE_PREPARE_T_NOTHING_SPECIAL;
620 break;
621 }
622 }
623 return ret;
624 }
625
626
627
628 static void
629 mc_search_regex__process_append_str (GString * dest_str, const char *from, gsize len,
630 replace_transform_type_t * replace_flags)
631 {
632 gsize loop;
633 gsize char_len;
634
635 if (len == (gsize) (-1))
636 len = strlen (from);
637
638 if (*replace_flags == REPLACE_T_NO_TRANSFORM)
639 {
640 g_string_append_len (dest_str, from, len);
641 return;
642 }
643
644 for (loop = 0; loop < len; loop += char_len)
645 {
646 GString *tmp_string = NULL;
647 char *tmp_str;
648
649 tmp_str = mc_search__get_one_symbol (NULL, from + loop, len - loop, NULL);
650 char_len = strlen (tmp_str);
651
652 if ((*replace_flags & REPLACE_T_UPP_TRANSFORM_CHAR) != 0)
653 {
654 *replace_flags &= ~REPLACE_T_UPP_TRANSFORM_CHAR;
655 tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
656 g_string_append_len (dest_str, tmp_string->str, tmp_string->len);
657 g_string_free (tmp_string, TRUE);
658 }
659 else if ((*replace_flags & REPLACE_T_LOW_TRANSFORM_CHAR) != 0)
660 {
661 *replace_flags &= ~REPLACE_T_LOW_TRANSFORM_CHAR;
662 tmp_string = mc_search__tolower_case_str (NULL, tmp_str, char_len);
663 g_string_append_len (dest_str, tmp_string->str, tmp_string->len);
664 g_string_free (tmp_string, TRUE);
665 }
666 else if ((*replace_flags & REPLACE_T_UPP_TRANSFORM) != 0)
667 {
668 tmp_string = mc_search__toupper_case_str (NULL, tmp_str, char_len);
669 g_string_append_len (dest_str, tmp_string->str, tmp_string->len);
670 g_string_free (tmp_string, TRUE);
671 }
672 else if ((*replace_flags & REPLACE_T_LOW_TRANSFORM) != 0)
673 {
674 tmp_string = mc_search__tolower_case_str (NULL, tmp_str, char_len);
675 g_string_append_len (dest_str, tmp_string->str, tmp_string->len);
676 g_string_free (tmp_string, TRUE);
677 }
678
679 g_free (tmp_str);
680 }
681 }
682
683
684
685 static void
686 mc_search_regex__process_escape_sequence (GString * dest_str, const char *from, gsize len,
687 replace_transform_type_t * replace_flags,
688 gboolean is_utf8)
689 {
690 gsize i = 0;
691 unsigned int c = 0;
692 char b;
693
694 if (len == (gsize) (-1))
695 len = strlen (from);
696 if (len == 0)
697 return;
698
699 if (from[i] == '{')
700 i++;
701 if (i >= len)
702 return;
703
704 if (from[i] == 'x')
705 {
706 i++;
707 if (i < len && from[i] == '{')
708 i++;
709 for (; i < len; i++)
710 {
711 if (from[i] >= '0' && from[i] <= '9')
712 c = c * 16 + from[i] - '0';
713 else if (from[i] >= 'a' && from[i] <= 'f')
714 c = c * 16 + 10 + from[i] - 'a';
715 else if (from[i] >= 'A' && from[i] <= 'F')
716 c = c * 16 + 10 + from[i] - 'A';
717 else
718 break;
719 }
720 }
721 else if (from[i] >= '0' && from[i] <= '7')
722 for (; i < len && from[i] >= '0' && from[i] <= '7'; i++)
723 c = c * 8 + from[i] - '0';
724 else
725 {
726 switch (from[i])
727 {
728 case 'n':
729 c = '\n';
730 break;
731 case 't':
732 c = '\t';
733 break;
734 case 'v':
735 c = '\v';
736 break;
737 case 'b':
738 c = '\b';
739 break;
740 case 'r':
741 c = '\r';
742 break;
743 case 'f':
744 c = '\f';
745 break;
746 case 'a':
747 c = '\a';
748 break;
749 default:
750 mc_search_regex__process_append_str (dest_str, from, len, replace_flags);
751 return;
752 }
753 }
754
755 if (c < 0x80 || !is_utf8)
756 g_string_append_c (dest_str, (char) c);
757 else if (c < 0x800)
758 {
759 b = 0xC0 | (c >> 6);
760 g_string_append_c (dest_str, b);
761 b = 0x80 | (c & 0x3F);
762 g_string_append_c (dest_str, b);
763 }
764 else if (c < 0x10000)
765 {
766 b = 0xE0 | (c >> 12);
767 g_string_append_c (dest_str, b);
768 b = 0x80 | ((c >> 6) & 0x3F);
769 g_string_append_c (dest_str, b);
770 b = 0x80 | (c & 0x3F);
771 g_string_append_c (dest_str, b);
772 }
773 else if (c < 0x10FFFF)
774 {
775 b = 0xF0 | (c >> 16);
776 g_string_append_c (dest_str, b);
777 b = 0x80 | ((c >> 12) & 0x3F);
778 g_string_append_c (dest_str, b);
779 b = 0x80 | ((c >> 6) & 0x3F);
780 g_string_append_c (dest_str, b);
781 b = 0x80 | (c & 0x3F);
782 g_string_append_c (dest_str, b);
783 }
784 }
785
786
787
788
789
790 void
791 mc_search__cond_struct_new_init_regex (const char *charset, mc_search_t * lc_mc_search,
792 mc_search_cond_t * mc_search_cond)
793 {
794 if (lc_mc_search->whole_words && !lc_mc_search->is_entire_line)
795 {
796
797
798
799 g_string_prepend (mc_search_cond->str, "(?<![\\p{L}\\p{N}_])");
800 g_string_append (mc_search_cond->str, "(?![\\p{L}\\p{N}_])");
801 }
802
803 {
804 #ifdef SEARCH_TYPE_GLIB
805 GError *mcerror = NULL;
806 GRegexCompileFlags g_regex_options = G_REGEX_OPTIMIZE | G_REGEX_DOTALL;
807
808 if (str_isutf8 (charset) && mc_global.utf8_display)
809 {
810 if (!lc_mc_search->is_case_sensitive)
811 g_regex_options |= G_REGEX_CASELESS;
812 }
813 else
814 {
815 g_regex_options |= G_REGEX_RAW;
816
817 if (!lc_mc_search->is_case_sensitive)
818 {
819 GString *tmp;
820
821 tmp = mc_search_cond->str;
822 mc_search_cond->str = mc_search__cond_struct_new_regex_ci_str (charset, tmp);
823 g_string_free (tmp, TRUE);
824 }
825 }
826
827 mc_search_cond->regex_handle =
828 g_regex_new (mc_search_cond->str->str, g_regex_options, 0, &mcerror);
829
830 if (mcerror != NULL)
831 {
832 lc_mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
833 g_free (lc_mc_search->error_str);
834 lc_mc_search->error_str =
835 str_conv_gerror_message (mcerror, _("Regular expression error"));
836 g_error_free (mcerror);
837 return;
838 }
839 #else
840 const char *error;
841 int erroffset;
842 int pcre_options = PCRE_EXTRA | PCRE_MULTILINE;
843
844 if (str_isutf8 (charset) && mc_global.utf8_display)
845 {
846 pcre_options |= PCRE_UTF8;
847 if (!lc_mc_search->is_case_sensitive)
848 pcre_options |= PCRE_CASELESS;
849 }
850 else if (!lc_mc_search->is_case_sensitive)
851 {
852 GString *tmp;
853
854 tmp = mc_search_cond->str;
855 mc_search_cond->str = mc_search__cond_struct_new_regex_ci_str (charset, tmp);
856 g_string_free (tmp, TRUE);
857 }
858
859 mc_search_cond->regex_handle =
860 pcre_compile (mc_search_cond->str->str, pcre_options, &error, &erroffset, NULL);
861 if (mc_search_cond->regex_handle == NULL)
862 {
863 mc_search_set_error (lc_mc_search, MC_SEARCH_E_REGEX_COMPILE, "%s", error);
864 return;
865 }
866 lc_mc_search->regex_match_info = pcre_study (mc_search_cond->regex_handle, 0, &error);
867 if (lc_mc_search->regex_match_info == NULL && error != NULL)
868 {
869 mc_search_set_error (lc_mc_search, MC_SEARCH_E_REGEX_COMPILE, "%s", error);
870 MC_PTR_FREE (mc_search_cond->regex_handle);
871 return;
872 }
873 #endif
874 }
875
876 lc_mc_search->is_utf8 = str_isutf8 (charset);
877 }
878
879
880
881 gboolean
882 mc_search__run_regex (mc_search_t * lc_mc_search, const void *user_data,
883 gsize start_search, gsize end_search, gsize * found_len)
884 {
885 mc_search_cbret_t ret = MC_SEARCH_CB_NOTFOUND;
886 gsize current_pos, virtual_pos;
887 gint start_pos;
888 gint end_pos;
889
890 if (lc_mc_search->regex_buffer != NULL)
891 g_string_set_size (lc_mc_search->regex_buffer, 0);
892 else
893 lc_mc_search->regex_buffer = g_string_sized_new (64);
894
895 virtual_pos = current_pos = start_search;
896 while (virtual_pos <= end_search)
897 {
898 g_string_set_size (lc_mc_search->regex_buffer, 0);
899 lc_mc_search->start_buffer = current_pos;
900
901 if (lc_mc_search->search_fn != NULL)
902 {
903 while (TRUE)
904 {
905 int current_chr = '\n';
906
907 ret = lc_mc_search->search_fn (user_data, current_pos, ¤t_chr);
908
909 if (ret == MC_SEARCH_CB_ABORT)
910 break;
911
912 if (ret == MC_SEARCH_CB_INVALID)
913 continue;
914
915 current_pos++;
916
917 if (ret == MC_SEARCH_CB_SKIP)
918 continue;
919
920 virtual_pos++;
921
922 g_string_append_c (lc_mc_search->regex_buffer, (char) current_chr);
923
924 if ((char) current_chr == '\n' || virtual_pos > end_search)
925 break;
926 }
927 }
928 else
929 {
930
931
932
933
934 while (TRUE)
935 {
936 const char current_chr = ((const char *) user_data)[current_pos];
937
938 if (current_chr == '\0')
939 break;
940
941 current_pos++;
942
943 if (current_chr == '\n' || current_pos > end_search)
944 break;
945 }
946
947
948 g_string_append_len (lc_mc_search->regex_buffer, (const char *) user_data + virtual_pos,
949 current_pos - virtual_pos);
950 virtual_pos = current_pos;
951 }
952
953 switch (mc_search__regex_found_cond (lc_mc_search, lc_mc_search->regex_buffer))
954 {
955 case COND__FOUND_OK:
956 #ifdef SEARCH_TYPE_GLIB
957 g_match_info_fetch_pos (lc_mc_search->regex_match_info, 0, &start_pos, &end_pos);
958 #else
959 start_pos = lc_mc_search->iovector[0];
960 end_pos = lc_mc_search->iovector[1];
961 #endif
962 if (found_len != NULL)
963 *found_len = end_pos - start_pos;
964 lc_mc_search->normal_offset = lc_mc_search->start_buffer + start_pos;
965 return TRUE;
966 case COND__NOT_ALL_FOUND:
967 break;
968 default:
969 g_string_free (lc_mc_search->regex_buffer, TRUE);
970 lc_mc_search->regex_buffer = NULL;
971 return FALSE;
972 }
973
974 if ((lc_mc_search->update_fn != NULL) &&
975 ((lc_mc_search->update_fn) (user_data, current_pos) == MC_SEARCH_CB_ABORT))
976 ret = MC_SEARCH_CB_ABORT;
977
978 if (ret == MC_SEARCH_CB_ABORT || ret == MC_SEARCH_CB_NOTFOUND)
979 break;
980 }
981
982 g_string_free (lc_mc_search->regex_buffer, TRUE);
983 lc_mc_search->regex_buffer = NULL;
984
985 MC_PTR_FREE (lc_mc_search->error_str);
986 lc_mc_search->error = ret == MC_SEARCH_CB_ABORT ? MC_SEARCH_E_ABORT : MC_SEARCH_E_NOTFOUND;
987
988 return FALSE;
989 }
990
991
992
993 GString *
994 mc_search_regex_prepare_replace_str (mc_search_t * lc_mc_search, GString * replace_str)
995 {
996 GString *ret;
997
998 int num_replace_tokens;
999 gsize loop;
1000 gsize prev = 0;
1001 replace_transform_type_t replace_flags = REPLACE_T_NO_TRANSFORM;
1002
1003 num_replace_tokens =
1004 mc_search_regex__get_max_num_of_replace_tokens (replace_str->str, replace_str->len);
1005
1006 if (lc_mc_search->num_results < 0)
1007 return mc_g_string_dup (replace_str);
1008
1009 if (num_replace_tokens > lc_mc_search->num_results - 1
1010 || num_replace_tokens > MC_SEARCH__NUM_REPLACE_ARGS)
1011 {
1012 mc_search_set_error (lc_mc_search, MC_SEARCH_E_REGEX_REPLACE, "%s",
1013 _(STR_E_RPL_NOT_EQ_TO_FOUND));
1014 return NULL;
1015 }
1016
1017 ret = g_string_sized_new (64);
1018
1019 for (loop = 0; loop < replace_str->len - 1; loop++)
1020 {
1021 int lc_index;
1022 gchar *tmp_str;
1023 gsize len = 0;
1024
1025 lc_index = mc_search_regex__process_replace_str (replace_str, loop, &len, &replace_flags);
1026
1027 if (lc_index == REPLACE_PREPARE_T_NOTHING_SPECIAL)
1028 {
1029 if (len != 0)
1030 {
1031 mc_search_regex__process_append_str (ret, replace_str->str + prev, loop - prev,
1032 &replace_flags);
1033 mc_search_regex__process_append_str (ret, replace_str->str + loop + 1, len - 1,
1034 &replace_flags);
1035 prev = loop + len;
1036 loop = prev - 1;
1037 }
1038
1039 continue;
1040 }
1041
1042 if (lc_index == REPLACE_PREPARE_T_REPLACE_FLAG)
1043 {
1044 if (loop != 0)
1045 mc_search_regex__process_append_str (ret, replace_str->str + prev, loop - prev,
1046 &replace_flags);
1047 prev = loop + len;
1048 loop = prev - 1;
1049 continue;
1050 }
1051
1052
1053 if (lc_index == REPLACE_PREPARE_T_ESCAPE_SEQ)
1054 {
1055 mc_search_regex__process_append_str (ret, replace_str->str + prev, loop - prev,
1056 &replace_flags);
1057
1058 mc_search_regex__process_escape_sequence (ret, replace_str->str + loop + 1, len - 1,
1059 &replace_flags, lc_mc_search->is_utf8);
1060 prev = loop + len;
1061 loop = prev - 1;
1062 continue;
1063 }
1064
1065
1066 if (lc_index > lc_mc_search->num_results)
1067 {
1068 g_string_free (ret, TRUE);
1069 mc_search_set_error (lc_mc_search, MC_SEARCH_E_REGEX_REPLACE,
1070 _(STR_E_RPL_INVALID_TOKEN), lc_index);
1071 return NULL;
1072 }
1073
1074 tmp_str = mc_search_regex__get_token_by_num (lc_mc_search, lc_index);
1075
1076 if (loop != 0)
1077 mc_search_regex__process_append_str (ret, replace_str->str + prev, loop - prev,
1078 &replace_flags);
1079
1080 mc_search_regex__process_append_str (ret, tmp_str, -1, &replace_flags);
1081 g_free (tmp_str);
1082
1083 prev = loop + len;
1084 loop = prev - 1;
1085 }
1086
1087 mc_search_regex__process_append_str (ret, replace_str->str + prev, replace_str->len - prev,
1088 &replace_flags);
1089
1090 return ret;
1091 }