lib/search/lib.c

   1 /*
   2    Search text engine.
   3    Common share code for module.
   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 #include <sys/types.h>
  32
  33 #include "../src/global.h"
  34 #include "../src/search/search.h"
  35 #include "../src/search/internal.h"
  36 #include "../src/strutil.h"
  37 #include "../src/charsets.h"
  38
  39 /*** global variables ****************************************************************************/
  40
  41 const char * STR_E_NOTFOUND = N_(" Search string not found ");
  42 const char * STR_E_UNKNOWN_TYPE = N_(" Not implemented yet ");
  43 const char * STR_E_RPL_NOT_EQ_TO_FOUND = N_(" Num of replace tokens not equal to num of found tokens ");
  44 const char * STR_E_RPL_INVALID_TOKEN = N_(" Invalid token number %d ");
  45
  46 /*** file scope macro definitions ****************************************************************/
  47
  48 /*** file scope type declarations ****************************************************************/
  49
  50 /*** file scope variables ************************************************************************/
  51
  52 /*** file scope functions ************************************************************************/
  53
  54 /*** public functions ****************************************************************************/
  55
  56 gchar *
  57 mc_search__recode_str (const char *str, gsize str_len,
  58                        const char *charset_from, const char *charset_to, gsize * bytes_written)
  59 {
  60     gchar *ret;
  61     gsize bytes_read;
  62     GIConv conv;
  63
  64     if (charset_from == NULL || charset_to == NULL  || !strcmp (charset_to, charset_from)) {
  65         *bytes_written = str_len;
  66         return g_strndup (str, str_len);
  67     }
  68
  69     conv = g_iconv_open (charset_to, charset_from);
  70     if (conv == INVALID_CONV) {
  71         *bytes_written = str_len;
  72         return g_strndup (str, str_len);
  73     }
  74
  75     ret = g_convert_with_iconv (str, str_len, conv, &bytes_read, bytes_written, NULL);
  76     g_iconv_close (conv);
  77
  78     if (ret == NULL) {
  79         *bytes_written = str_len;
  80         return g_strndup (str, str_len);
  81     }
  82
  83     return ret;
  84 }
  85
  86 /* --------------------------------------------------------------------------------------------- */
  87
  88 gchar *
  89 mc_search__get_one_symbol (const char *charset, const char *str, gsize str_len,
  90                            gboolean * just_letters)
  91 {
  92
  93     gchar *converted_str, *next_char;
  94
  95     gsize tmp_len;
  96 #ifdef HAVE_CHARSET
  97     gsize converted_str_len;
  98     gchar *converted_str2;
  99
 100     if (charset == NULL)
 101         charset = cp_source;
 102
 103     converted_str = mc_search__recode_str (str, str_len, charset, cp_display, &converted_str_len);
 104 #else
 105     (void) charset;
 106
 107     converted_str = g_strndup (str, str_len);
 108 #endif
 109
 110     next_char = (char *) str_cget_next_char (converted_str);
 111
 112     tmp_len = next_char - converted_str;
 113
 114     converted_str[tmp_len] = '\0';
 115
 116 #ifdef HAVE_CHARSET
 117     converted_str2 =
 118         mc_search__recode_str (converted_str, tmp_len, cp_display, charset, &converted_str_len);
 119 #endif
 120     if (just_letters) {
 121         if (str_isalnum (converted_str) && !str_isdigit (converted_str))
 122             *just_letters = TRUE;
 123         else
 124             *just_letters = FALSE;
 125     }
 126 #ifdef HAVE_CHARSET
 127     g_free (converted_str);
 128     return converted_str2;
 129 #else
 130     return converted_str;
 131 #endif
 132 }
 133
 134 /* --------------------------------------------------------------------------------------------- */
 135 int
 136 mc_search__get_char (mc_search_t * lc_mc_search, const void *user_data, gsize current_pos)
 137 {
 138     char *data;
 139     if (lc_mc_search->search_fn)
 140         return (lc_mc_search->search_fn) (user_data, current_pos);
 141
 142     data = (char *) user_data;
 143     return (int) (unsigned char) data[current_pos];
 144 }
 145
 146 /* --------------------------------------------------------------------------------------------- */
 147
 148
 149 GString *
 150 mc_search__tolower_case_str (const char *charset, const char *str, gsize str_len)
 151 {
 152     GString *ret;
 153 #ifdef HAVE_CHARSET
 154     gchar *converted_str, *tmp_str1, *tmp_str2, *tmp_str3;
 155     gsize converted_str_len;
 156     gsize tmp_len;
 157
 158     if (charset == NULL)
 159         charset = cp_source;
 160
 161     tmp_str2 = converted_str =
 162         mc_search__recode_str (str, str_len, charset, cp_display, &converted_str_len);
 163
 164     tmp_len = converted_str_len + 1;
 165
 166     tmp_str3 = tmp_str1 = g_strdup (converted_str);
 167
 168     while (str_tolower (tmp_str1, &tmp_str2, &tmp_len))
 169         tmp_str1 += str_length_char (tmp_str1);
 170
 171     g_free (tmp_str3);
 172     tmp_str2 =
 173         mc_search__recode_str (converted_str, converted_str_len, cp_display, charset, &tmp_len);
 174     g_free (converted_str);
 175
 176     ret = g_string_new_len (tmp_str2, tmp_len);
 177     g_free (tmp_str2);
 178     return ret;
 179 #else
 180     const gchar *tmp_str1 = str;
 181     gchar *converted_str, *tmp_str2;
 182     gsize converted_str_len = str_len + 1;
 183
 184     (void) charset;
 185
 186     tmp_str2 = converted_str = g_strndup (str, str_len);
 187
 188     while (str_tolower (tmp_str1, &tmp_str2, &converted_str_len))
 189         tmp_str1 += str_length_char (tmp_str1);
 190
 191     ret = g_string_new_len (converted_str, str_len);
 192     g_free (converted_str);
 193     return ret;
 194 #endif
 195 }
 196
 197 /* --------------------------------------------------------------------------------------------- */
 198
 199 GString *
 200 mc_search__toupper_case_str (const char *charset, const char *str, gsize str_len)
 201 {
 202     GString *ret;
 203 #ifdef HAVE_CHARSET
 204     gchar *converted_str, *tmp_str1, *tmp_str2, *tmp_str3;
 205     gsize converted_str_len;
 206     gsize tmp_len;
 207
 208     if (charset == NULL)
 209         charset = cp_source;
 210
 211     tmp_str2 = converted_str =
 212         mc_search__recode_str (str, str_len, charset, cp_display, &converted_str_len);
 213
 214     tmp_len = converted_str_len + 1;
 215
 216     tmp_str3 = tmp_str1 = g_strdup (converted_str);
 217
 218     while (str_toupper (tmp_str1, &tmp_str2, &tmp_len))
 219         tmp_str1 += str_length_char (tmp_str1);
 220
 221     g_free (tmp_str3);
 222
 223     tmp_str2 =
 224         mc_search__recode_str (converted_str, converted_str_len, cp_display, charset, &tmp_len);
 225     g_free (converted_str);
 226
 227     ret = g_string_new_len (tmp_str2, tmp_len);
 228     g_free (tmp_str2);
 229     return ret;
 230 #else
 231
 232     const gchar *tmp_str1 = str;
 233     gchar *converted_str, *tmp_str2;
 234     gsize converted_str_len = str_len + 1;
 235
 236     (void) charset;
 237
 238     tmp_str2 = converted_str = g_strndup (str, str_len);
 239
 240     while (str_toupper (tmp_str1, &tmp_str2, &converted_str_len))
 241         tmp_str1 += str_length_char (tmp_str1);
 242
 243     ret = g_string_new_len (converted_str, str_len);
 244     g_free (converted_str);
 245     return ret;
 246 #endif
 247 }
 248
 249 /* --------------------------------------------------------------------------------------------- */
 250
 251 gchar **
 252 mc_search_get_types_strings_array (size_t *num)
 253 {
 254     gchar **ret;
 255     int lc_index;
 256     size_t n;
 257
 258     const mc_search_type_str_t *type_str;
 259     const mc_search_type_str_t *types_str = mc_search_types_list_get (&n);
 260
 261     ret = g_try_new0 (char *, n + 1);
 262     if (ret == NULL)
 263         return NULL;
 264
 265     for (lc_index = 0, type_str = types_str;
 266             type_str->str != NULL;
 267             type_str++, lc_index++)
 268         ret[lc_index] = g_strdup (type_str->str);
 269
 270     /* don't count last NULL item */
 271     if (num != NULL)
 272         *num = (size_t) lc_index;
 273
 274     return ret;
 275 }
 276
 277 /* --------------------------------------------------------------------------------------------- */