lib/search/lib.c

   1 /*
   2    Search text engine.
   3    Common share code for module.
   4
   5    Copyright (C) 2009-2016
   6    Free Software Foundation, Inc.
   7
   8    Written by:
   9    Slava Zanko <slavazanko@gmail.com>, 2009, 2011
  10    Andrew Borodin <aborodin@vmail.ru>, 2013
  11
  12    This file is part of the Midnight Commander.
  13
  14    The Midnight Commander is free software: you can redistribute it
  15    and/or modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation, either version 3 of the License,
  17    or (at your option) any later version.
  18
  19    The Midnight Commander is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26  */
  27
  28 #include <config.h>
  29
  30 #include <stdlib.h>
  31 #include <sys/types.h>
  32
  33 #include "lib/global.h"
  34 #include "lib/strutil.h"
  35 #include "lib/search.h"
  36 #ifdef HAVE_CHARSET
  37 #include "lib/charsets.h"
  38 #endif
  39
  40 #include "internal.h"
  41
  42 /*** global variables ****************************************************************************/
  43
  44 const char *STR_E_NOTFOUND = N_("Search string not found");
  45 const char *STR_E_UNKNOWN_TYPE = N_("Not implemented yet");
  46 const char *STR_E_RPL_NOT_EQ_TO_FOUND =
  47 N_("Num of replace tokens not equal to num of found tokens");
  48 const char *STR_E_RPL_INVALID_TOKEN = N_("Invalid token number %d");
  49
  50 /*** file scope macro definitions ****************************************************************/
  51
  52 /*** file scope type declarations ****************************************************************/
  53
  54 /*** file scope variables ************************************************************************/
  55
  56 /*** file scope functions ************************************************************************/
  57
  58 /*** public functions ****************************************************************************/
  59
  60 gchar *
  61 mc_search__recode_str (const char *str, gsize str_len,
  62                        const char *charset_from, const char *charset_to, gsize * bytes_written)
  63 {
  64     gchar *ret;
  65     gsize bytes_read;
  66     GIConv conv;
  67
  68     if (charset_from == NULL || charset_to == NULL
  69         || g_ascii_strcasecmp (charset_to, charset_from) == 0)
  70     {
  71         *bytes_written = str_len;
  72         return g_strndup (str, str_len);
  73     }
  74
  75     conv = g_iconv_open (charset_to, charset_from);
  76     if (conv == INVALID_CONV)
  77     {
  78         *bytes_written = str_len;
  79         return g_strndup (str, str_len);
  80     }
  81
  82     ret = g_convert_with_iconv (str, str_len, conv, &bytes_read, bytes_written, NULL);
  83     g_iconv_close (conv);
  84
  85     if (ret == NULL)
  86     {
  87         *bytes_written = str_len;
  88         return g_strndup (str, str_len);
  89     }
  90
  91     return ret;
  92 }
  93
  94 /* --------------------------------------------------------------------------------------------- */
  95
  96 gchar *
  97 mc_search__get_one_symbol (const char *charset, const char *str, gsize str_len,
  98                            gboolean * just_letters)
  99 {
 100     gchar *converted_str, *next_char;
 101
 102     gsize tmp_len;
 103 #ifdef HAVE_CHARSET
 104     gsize converted_str_len;
 105     gchar *converted_str2;
 106
 107     if (charset == NULL)
 108         charset = cp_source;
 109
 110     converted_str = mc_search__recode_str (str, str_len, charset, cp_display, &converted_str_len);
 111 #else
 112     (void) charset;
 113
 114     converted_str = g_strndup (str, str_len);
 115 #endif
 116
 117     next_char = (char *) str_cget_next_char (converted_str);
 118
 119     tmp_len = next_char - converted_str;
 120
 121     converted_str[tmp_len] = '\0';
 122
 123 #ifdef HAVE_CHARSET
 124     converted_str2 =
 125         mc_search__recode_str (converted_str, tmp_len, cp_display, charset, &converted_str_len);
 126 #endif
 127     if (just_letters)
 128     {
 129         if (str_isalnum (converted_str) && !str_isdigit (converted_str))
 130             *just_letters = TRUE;
 131         else
 132             *just_letters = FALSE;
 133     }
 134 #ifdef HAVE_CHARSET
 135     g_free (converted_str);
 136     return converted_str2;
 137 #else
 138     return converted_str;
 139 #endif
 140 }
 141
 142 /* --------------------------------------------------------------------------------------------- */
 143
 144 GString *
 145 mc_search__tolower_case_str (const char *charset, const char *str, gsize str_len)
 146 {
 147     GString *ret;
 148 #ifdef HAVE_CHARSET
 149     gchar *converted_str, *tmp_str1, *tmp_str2, *tmp_str3;
 150     gsize converted_str_len;
 151     gsize tmp_len;
 152
 153     if (charset == NULL)
 154         charset = cp_source;
 155
 156     tmp_str2 = converted_str =
 157         mc_search__recode_str (str, str_len, charset, cp_display, &converted_str_len);
 158
 159     tmp_len = converted_str_len + 1;
 160
 161     tmp_str3 = tmp_str1 = g_strdup (converted_str);
 162
 163     while (str_tolower (tmp_str1, &tmp_str2, &tmp_len))
 164         tmp_str1 += str_length_char (tmp_str1);
 165
 166     g_free (tmp_str3);
 167     tmp_str2 =
 168         mc_search__recode_str (converted_str, converted_str_len, cp_display, charset, &tmp_len);
 169     g_free (converted_str);
 170
 171     ret = g_string_new_len (tmp_str2, tmp_len);
 172     g_free (tmp_str2);
 173     return ret;
 174 #else
 175     const gchar *tmp_str1 = str;
 176     gchar *converted_str, *tmp_str2;
 177     gsize converted_str_len = str_len + 1;
 178
 179     (void) charset;
 180
 181     tmp_str2 = converted_str = g_strndup (str, str_len);
 182
 183     while (str_tolower (tmp_str1, &tmp_str2, &converted_str_len))
 184         tmp_str1 += str_length_char (tmp_str1);
 185
 186     ret = g_string_new_len (converted_str, str_len);
 187     g_free (converted_str);
 188     return ret;
 189 #endif
 190 }
 191
 192 /* --------------------------------------------------------------------------------------------- */
 193
 194 GString *
 195 mc_search__toupper_case_str (const char *charset, const char *str, gsize str_len)
 196 {
 197     GString *ret;
 198 #ifdef HAVE_CHARSET
 199     gchar *converted_str, *tmp_str1, *tmp_str2, *tmp_str3;
 200     gsize converted_str_len;
 201     gsize tmp_len;
 202
 203     if (charset == NULL)
 204         charset = cp_source;
 205
 206     tmp_str2 = converted_str =
 207         mc_search__recode_str (str, str_len, charset, cp_display, &converted_str_len);
 208
 209     tmp_len = converted_str_len + 1;
 210
 211     tmp_str3 = tmp_str1 = g_strdup (converted_str);
 212
 213     while (str_toupper (tmp_str1, &tmp_str2, &tmp_len))
 214         tmp_str1 += str_length_char (tmp_str1);
 215
 216     g_free (tmp_str3);
 217
 218     tmp_str2 =
 219         mc_search__recode_str (converted_str, converted_str_len, cp_display, charset, &tmp_len);
 220     g_free (converted_str);
 221
 222     ret = g_string_new_len (tmp_str2, tmp_len);
 223     g_free (tmp_str2);
 224     return ret;
 225 #else
 226
 227     const gchar *tmp_str1 = str;
 228     gchar *converted_str, *tmp_str2;
 229     gsize converted_str_len = str_len + 1;
 230
 231     (void) charset;
 232
 233     tmp_str2 = converted_str = g_strndup (str, str_len);
 234
 235     while (str_toupper (tmp_str1, &tmp_str2, &converted_str_len))
 236         tmp_str1 += str_length_char (tmp_str1);
 237
 238     ret = g_string_new_len (converted_str, str_len);
 239     g_free (converted_str);
 240     return ret;
 241 #endif
 242 }
 243
 244 /* --------------------------------------------------------------------------------------------- */
 245
 246 gchar **
 247 mc_search_get_types_strings_array (size_t * num)
 248 {
 249     gchar **ret;
 250     int lc_index;
 251     size_t n;
 252
 253     const mc_search_type_str_t *type_str;
 254     const mc_search_type_str_t *types_str = mc_search_types_list_get (&n);
 255
 256     ret = g_try_new0 (char *, n + 1);
 257     if (ret == NULL)
 258         return NULL;
 259
 260     for (lc_index = 0, type_str = types_str; type_str->str != NULL; type_str++, lc_index++)
 261         ret[lc_index] = g_strdup (type_str->str);
 262
 263     /* don't count last NULL item */
 264     if (num != NULL)
 265         *num = (size_t) lc_index;
 266
 267     return ret;
 268 }
 269
 270 /* --------------------------------------------------------------------------------------------- */