Ticket #1882: mc-4.7.0pre-searchPCRE-escape-sequences-and-UTF8.patch

src/search/regex.c

@@ -63 +63 @@
     const char *special_chars[] = {
         "\\s", "\\S",
         "\\d", "\\D",
-        "\\b", "\\B",
+        "\\B", "\\B",
         "\\w", "\\W",
         "\\t", "\\n",
         "\\r", "\\f",
@@ -348 +348 @@
 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; /* nothing special */
+    int ret = -1;
     char *tmp_str;
     const char *curr_str = &(replace_str->str[current_pos]);
 
@@ -360 +360 @@
     if (*curr_str == '$' && *(curr_str + 1) == '{' && (*(curr_str + 2) & (char) 0xf0) == 0x30) {
         if (strutils_is_char_escaped (replace_str->str, curr_str)) {
             *skip_len = 1;
-            return -1; /* nothing special */
+            return -1;
         }
 
         for (*skip_len = 0;
@@ -368 +368 @@
              && (*(curr_str + 2 + *skip_len) & (char) 0xf0) == 0x30; (*skip_len)++);
 
         if (*(curr_str + 2 + *skip_len) != '}')
-            return -1; /* nothing special */
+            return -1;
 
         tmp_str = g_strndup (curr_str + 2, *skip_len);
         if (tmp_str == NULL)
-            return -1; /* nothing special */
+            return -1;
 
         ret = atoi (tmp_str);
         g_free (tmp_str);
 
         *skip_len += 3;         /* ${} */
-        return ret; /* capture buffer index >= 0 */
+        return ret;
     }
 
     if (*curr_str == '\\') {
-        char next_char;
         if (strutils_is_char_escaped (replace_str->str, curr_str)) {
             *skip_len = 1;
-            return -1; /* nothing special */
+            return -1;
         }
 
-        next_char = *(curr_str + 1);
-        if ((next_char & (char) 0xf0) == 0x30) {
-            ret = next_char - '0'; /* capture buffer index >= 0 */
+        if ((*(curr_str + 1) & (char) 0xf0) == 0x30) {
+            ret = *(curr_str + 1) - '0';
             *skip_len = 2;      /* \\ and one digit */
             return ret;
         }
-
-        if (next_char == '{')
-        {
-            for (*skip_len = 2; /* \{ */
-                 current_pos + *skip_len < replace_str->len
-                 && (*(curr_str + *skip_len)) != '}'; (*skip_len)++);
-            if (current_pos + *skip_len < replace_str->len)
-                (*skip_len)++;
-            return -3; /* escape sequence */
-        }
-
-        if (next_char == 'x')
-        {
-            *skip_len = 2; /* \x */
-            next_char = *(curr_str + 2);
-            if (next_char == '{')
-            {
-                for (*skip_len = 3; /* \x{ */
-                     current_pos + *skip_len < replace_str->len
-                     && (*(curr_str + *skip_len)) != '}'; (*skip_len)++);
-                if (current_pos + *skip_len < replace_str->len)
-                    (*skip_len)++;
-                return -3; /* escape sequence */
-            }
-            else if ((next_char < '0' || next_char > '9') &&
-                (next_char < 'a' || next_char > 'f') &&
-                (next_char < 'A' || next_char > 'F'))
-            {
-                *skip_len = 2; /* \x without number behind */
-                return -1; /* nothing special */
-            }
-            else
-            {
-                next_char = *(curr_str + 3);
-                if ((next_char < '0' || next_char > '9') &&
-                    (next_char < 'a' || next_char > 'f') &&
-                    (next_char < 'A' || next_char > 'F'))
-                    *skip_len = 3; /* \xH */
-                else
-                    *skip_len = 4; /* \xHH */
-                return -3; /* escape sequence */
-            }
-        }
-
-        if (next_char == 'n' || next_char == 't' ||
-            next_char == 'v' || next_char == 'b' ||
-            next_char == 'r' || next_char == 'f' ||
-            next_char == 'a')
-        {
-            *skip_len = 2;
-            return -3; /* escape sequence */
-        }
-
-        ret = -2; /* replace flag */
+        ret = -2;
         *skip_len += 2;
-        switch (next_char) {
+        switch (*(curr_str + 1)) {
         case 'U':
             *replace_flags |= REPLACE_T_UPP_TRANSFORM;
             *replace_flags &= ~REPLACE_T_LOW_TRANSFORM;
@@ -468 +413 @@
             *replace_flags = REPLACE_T_NO_TRANSFORM;
             break;
         default:
-            ret = -1; /* nothing special */
+            ret = -1;
             break;
         }
     }
@@ -524 +469 @@
 
 }
 
-static void
-mc_search_regex__process_escape_sequence (GString * dest_str, const char *from, gsize len,
-                                          replace_transform_type_t * replace_flags)
-{
-    gsize i = 0;
-    char c = 0;
-    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] <= '9')
-        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;
-        }
-    }
-    g_string_append_len (dest_str, &c, 1);
-}
-
 /*** public functions ****************************************************************************/
 
 void
 mc_search__cond_struct_new_init_regex (const char *charset, mc_search_t * mc_search,
                                        mc_search_cond_t * mc_search_cond)
 {
-    int utf8 = 0;
+    GString *tmp = NULL;
 #ifdef SEARCH_TYPE_GLIB
     GError *error = NULL;
 #else /* SEARCH_TYPE_GLIB */
@@ -591 +483 @@
     int erroffset;
 #endif /* SEARCH_TYPE_GLIB */
 
-#ifdef SEARCH_TYPE_GLIB
     if (!mc_search->is_case_sentitive) {
-        GString *tmp = g_string_new_len (mc_search_cond->str->str, mc_search_cond->str->len);
+        tmp = g_string_new_len (mc_search_cond->str->str, mc_search_cond->str->len);
         g_string_free (mc_search_cond->str, TRUE);
         mc_search_cond->str = mc_search__cond_struct_new_regex_ci_str (charset, tmp->str, tmp->len);
         g_string_free (tmp, TRUE);
     }
+#ifdef SEARCH_TYPE_GLIB
     mc_search_cond->regex_handle =
         g_regex_new (mc_search_cond->str->str, G_REGEX_OPTIMIZE | G_REGEX_RAW | G_REGEX_DOTALL, 0,
                      &error);
@@ -609 +501 @@
         return;
     }
 #else /* SEARCH_TYPE_GLIB */
-    if (charset && !strncasecmp(charset, "utf-8", 6))
-        utf8 = 1;
     mc_search_cond->regex_handle =
-        pcre_compile (mc_search_cond->str->str, (!mc_search->is_case_sentitive ? PCRE_CASELESS : 0) | PCRE_MULTILINE | (utf8 ? PCRE_UTF8 : 0) | PCRE_EXTRA, &error, &erroffset, NULL);
+        pcre_compile (mc_search_cond->str->str, PCRE_EXTRA, &error, &erroffset, NULL);
     if (mc_search_cond->regex_handle == NULL) {
         mc_search->error = MC_SEARCH_E_REGEX_COMPILE;
         mc_search->error_str = g_strdup (error);
@@ -745 +635 @@
     for (loop = 0; loop < replace_str->len - 1; loop++) {
         index = mc_search_regex__process_replace_str (replace_str, loop, &len, &replace_flags);
 
-        /* nothing special */
         if (index == -1) {
             if (len != 0) {
                 mc_search_regex__process_append_str (ret, prev_str,
@@ -759 +648 @@
             continue;
         }
 
-        /* replace flag (transform) */
         if (index == -2) {
             if (loop)
                 mc_search_regex__process_append_str (ret, prev_str,
@@ -770 +658 @@
             continue;
         }
 
-        /* escape sequence */
-        if (index == -3) {
-            mc_search_regex__process_append_str (ret, prev_str,
-                                                 replace_str->str - prev_str + loop,
-                                                 &replace_flags);
-            mc_search_regex__process_escape_sequence (ret, replace_str->str - loop + 1, len - 1,
-                                                      &replace_flags);
-            prev_str = replace_str->str + loop + len;
-            loop += len - 1;
-            continue;
-        }
-
         if (index > mc_search->num_rezults) {
             g_string_free (ret, TRUE);
             mc_search->error = MC_SEARCH_E_REGEX_REPLACE;