char *
mc_tty_normalize_from_utf8 (const char *str)
{
GIConv conv;
GString *buffer;
const char *_system_codepage = str_detect_termencoding ();
if (str_isutf8 (_system_codepage))
return g_strdup (str);
conv = g_iconv_open (_system_codepage, "UTF-8");
if (conv == INVALID_CONV)
return g_strdup (str);
buffer = g_string_new ("");
if (str_convert (conv, str, buffer) == ESTR_FAILURE)
{
g_string_free (buffer, TRUE);
str_close_conv (conv);
return g_strdup (str);
}
str_close_conv (conv);
return g_string_free (buffer, FALSE);
}
static void
translate_file (char *filedata)
{
GIConv conv;
GString *translated_data;
/* initial allocation for largest whole help file */
translated_data = g_string_sized_new (32 * 1024);
conv = str_crt_conv_from ("UTF-8");
if (conv == INVALID_CONV)
g_string_free (translated_data, TRUE);
else
{
g_free (fdata);
if (str_convert (conv, filedata, translated_data) != ESTR_FAILURE)
fdata = g_string_free (translated_data, FALSE);
else
{
fdata = NULL;
g_string_free (translated_data, TRUE);
}
str_close_conv (conv);
}
}
static gchar *
str_8bit_conv_gerror_message (GError * mcerror, const char *def_msg)
{
GIConv conv;
gchar *ret;
/* glib messages are in UTF-8 charset */
conv = str_crt_conv_from ("UTF-8");
if (conv == INVALID_CONV)
ret = g_strdup (def_msg != NULL ? def_msg : "");
else
{
GString *buf;
buf = g_string_new ("");
if (str_convert (conv, mcerror->message, buf) != ESTR_FAILURE)
ret = g_string_free (buf, FALSE);
else
{
ret = g_strdup (def_msg != NULL ? def_msg : "");
g_string_free (buf, TRUE);
}
str_close_conv (conv);
}
return ret;
}
void
mcview_set_codeset (mcview_t * view)
{
#ifdef HAVE_CHARSET
const char *cp_id = NULL;
view->utf8 = TRUE;
cp_id =
get_codepage_id (mc_global.source_codepage >=
0 ? mc_global.source_codepage : mc_global.display_codepage);
if (cp_id != NULL)
{
GIConv conv;
conv = str_crt_conv_from (cp_id);
if (conv != INVALID_CONV)
{
if (view->converter != str_cnv_from_term)
str_close_conv (view->converter);
view->converter = conv;
}
view->utf8 = (gboolean) str_isutf8 (cp_id);
}
#else
(void) view;
#endif
}
unsigned char
convert_from_utf_to_current (const char *str)
{
unsigned char buf_ch[6 + 1];
unsigned char ch = '.';
GIConv conv;
const char *cp_to;
if (!str)
return '.';
cp_to = get_codepage_id (source_codepage);
conv = str_crt_conv_to (cp_to);
if (conv != INVALID_CONV)
{
switch (str_translate_char (conv, str, -1, (char *) buf_ch, sizeof (buf_ch)))
{
case ESTR_SUCCESS:
ch = buf_ch[0];
break;
case ESTR_PROBLEM:
case ESTR_FAILURE:
ch = '.';
break;
}
str_close_conv (conv);
}
return ch;
}
void
mcview_done (mcview_t * view)
{
/* Save current file position */
if (mcview_remember_file_position && view->filename_vpath != NULL)
{
save_file_position (view->filename_vpath, -1, 0,
view->hex_mode ? view->hex_cursor : view->dpy_start,
view->saved_bookmarks);
view->saved_bookmarks = NULL;
}
/* Write back the global viewer mode */
mcview_default_hex_mode = view->hex_mode;
mcview_default_nroff_flag = view->text_nroff_mode;
mcview_default_magic_flag = view->magic_mode;
mcview_global_wrap_mode = view->text_wrap_mode;
/* Free memory used by the viewer */
/* view->widget needs no destructor */
vfs_path_free (view->filename_vpath);
view->filename_vpath = NULL;
vfs_path_free (view->workdir_vpath);
view->workdir_vpath = NULL;
MC_PTR_FREE (view->command);
mcview_close_datasource (view);
/* the growing buffer is freed with the datasource */
coord_cache_free (view->coord_cache), view->coord_cache = NULL;
if (view->converter == INVALID_CONV)
view->converter = str_cnv_from_term;
if (view->converter != str_cnv_from_term)
{
str_close_conv (view->converter);
view->converter = str_cnv_from_term;
}
mc_search_free (view->search);
view->search = NULL;
g_free (view->last_search_string);
view->last_search_string = NULL;
mcview_nroff_seq_free (&view->search_nroff_seq);
mcview_hexedit_free_change_list (view);
if (mc_global.mc_run_mode == MC_RUN_VIEWER && view->dir != NULL)
{
/* mcviewer is the owner of file list */
dir_list_clean (view->dir);
g_free (view->dir->list);
g_free (view->dir_idx);
g_free (view->dir);
}
view->dir = NULL;
}
static gchar *
mc_config_normalize_before_save (const gchar * value)
{
GIConv conv;
GString *buffer;
gboolean ok;
if (mc_global.utf8_display)
return g_strdup (value);
conv = str_crt_conv_to ("UTF-8");
if (conv == INVALID_CONV)
return g_strdup (value);
buffer = g_string_new ("");
ok = (str_convert (conv, value, buffer) != ESTR_FAILURE);
str_close_conv (conv);
if (!ok)
{
g_string_free (buffer, TRUE);
return g_strdup (value);
}
return g_string_free (buffer, FALSE);
}
static gchar *
mc_config_normalize_before_save(const gchar * value)
{
GIConv conv;
GString *buffer;
if (utf8_display)
{
buffer = g_string_new(value);
}
else
{
conv = str_crt_conv_to ("UTF-8");
if (conv == INVALID_CONV)
return;
buffer = g_string_new ("");
if (str_convert (conv, value, buffer) == ESTR_FAILURE)
{
g_string_free(buffer, TRUE);
buffer = g_string_new(value);
}
str_close_conv (conv);
}
return g_string_free(buffer, FALSE);
}
/**
* Load history form the mc_config
*/
GList *
history_load (struct mc_config_t * cfg, const char *name)
{
size_t i;
GList *hist = NULL;
char **keys;
size_t keys_num = 0;
GIConv conv = INVALID_CONV;
GString *buffer;
if (name == NULL || *name == '\0')
return NULL;
/* get number of keys */
keys = mc_config_get_keys (cfg, name, &keys_num);
g_strfreev (keys);
/* create charset conversion handler to convert strings
from utf-8 to system codepage */
if (!mc_global.utf8_display)
conv = str_crt_conv_from ("UTF-8");
buffer = g_string_sized_new (64);
for (i = 0; i < keys_num; i++)
{
char key[BUF_TINY];
char *this_entry;
g_snprintf (key, sizeof (key), "%lu", (unsigned long) i);
this_entry = mc_config_get_string_raw (cfg, name, key, "");
if (this_entry == NULL)
continue;
if (conv == INVALID_CONV)
hist = list_append_unique (hist, this_entry);
else
{
g_string_set_size (buffer, 0);
if (str_convert (conv, this_entry, buffer) == ESTR_FAILURE)
hist = list_append_unique (hist, this_entry);
else
{
hist = list_append_unique (hist, g_strdup (buffer->str));
g_free (this_entry);
}
}
}
g_string_free (buffer, TRUE);
if (conv != INVALID_CONV)
str_close_conv (conv);
/* return pointer to the last entry in the list */
return g_list_last (hist);
}
/**
* Save history to the mc_config, but don't save config to file
*/
void
history_save (struct mc_config_t *cfg, const char *name, GList * h)
{
GIConv conv = INVALID_CONV;
GString *buffer;
int i;
if (name == NULL || *name == '\0' || h == NULL)
return;
/* go to end of list */
h = g_list_last (h);
/* go back 60 places */
for (i = 0; (i < num_history_items_recorded - 1) && (h->prev != NULL); i++)
h = g_list_previous (h);
if (name != NULL)
mc_config_del_group (cfg, name);
/* create charset conversion handler to convert strings
from system codepage to UTF-8 */
if (!mc_global.utf8_display)
conv = str_crt_conv_to ("UTF-8");
buffer = g_string_sized_new (64);
/* dump history into profile */
for (i = 0; h != NULL; h = g_list_next (h))
{
char key[BUF_TINY];
char *text = (char *) h->data;
/* We shouldn't have null entries, but let's be sure */
if (text == NULL)
continue;
g_snprintf (key, sizeof (key), "%d", i++);
if (conv == INVALID_CONV)
mc_config_set_string_raw (cfg, name, key, text);
else
{
g_string_set_size (buffer, 0);
if (str_convert (conv, text, buffer) == ESTR_FAILURE)
mc_config_set_string_raw (cfg, name, key, text);
else
mc_config_set_string_raw (cfg, name, key, buffer->str);
}
}
g_string_free (buffer, TRUE);
if (conv != INVALID_CONV)
str_close_conv (conv);
}
char *
get_random_hint (int force)
{
char *data, *result = NULL, *eol;
int len;
int start;
static int last_sec;
static struct timeval tv;
GIConv conv;
GString *buffer;
/* Do not change hints more often than one minute */
gettimeofday (&tv, NULL);
if (!force && !(tv.tv_sec > last_sec + 60))
return g_strdup ("");
last_sec = tv.tv_sec;
data = load_mc_home_file (mc_global.share_data_dir, MC_HINT, NULL);
if (data == NULL)
return NULL;
/* get a random entry */
srand (tv.tv_sec);
len = strlen (data);
start = rand () % len;
for (; start != 0; start--)
if (data[start] == '\n')
{
start++;
break;
}
eol = strchr (data + start, '\n');
if (eol != NULL)
*eol = '\0';
/* hint files are stored in utf-8 */
/* try convert hint file from utf-8 to terminal encoding */
conv = str_crt_conv_from ("UTF-8");
if (conv != INVALID_CONV)
{
buffer = g_string_new ("");
if (str_convert (conv, &data[start], buffer) != ESTR_FAILURE)
result = g_strdup (buffer->str);
g_string_free (buffer, TRUE);
str_close_conv (conv);
}
g_free (data);
return result;
}
gchar *
mc_config_get_string (mc_config_t * mc_config, const gchar * group,
const gchar * param, const gchar * def)
{
GIConv conv;
GString *buffer;
gchar *ret;
estr_t conv_res;
if (!mc_config || !group || !param)
return g_strdup (def);
if (!mc_config_has_param (mc_config, group, param))
{
if (def != NULL)
mc_config_set_string (mc_config, group, param, def);
return g_strdup (def);
}
ret = g_key_file_get_string (mc_config->handle, group, param, NULL);
if (ret == NULL)
ret = g_strdup (def);
if (mc_global.utf8_display)
return ret;
conv = str_crt_conv_from ("UTF-8");
if (conv == INVALID_CONV)
return ret;
buffer = g_string_new ("");
conv_res = str_convert (conv, ret, buffer);
str_close_conv (conv);
if (conv_res == ESTR_FAILURE)
{
g_string_free (buffer, TRUE);
return ret;
}
g_free (ret);
return g_string_free (buffer, FALSE);
}
GString *
str_nconvert_to_input (char *str, int len)
{
GString *buff;
GIConv conv;
if (!str)
return g_string_new ("");
if (cp_display == cp_source)
return g_string_new (str);
conv = str_crt_conv_to (cp_source);
buff = g_string_new ("");
str_nconvert (conv, str, len, buff);
str_close_conv (conv);
return buff;
}
int
convert_from_8bit_to_utf_c2 (const char input_char)
{
unsigned char str[2];
unsigned char buf_ch[6 + 1];
int ch = '.';
int res = 0;
GIConv conv;
const char *cp_from;
str[0] = (unsigned char) input_char;
str[1] = '\0';
cp_from = get_codepage_id (source_codepage);
conv = str_crt_conv_to (cp_from);
if (conv != INVALID_CONV)
{
switch (str_translate_char (conv, (char *) str, -1, (char *) buf_ch, sizeof (buf_ch)))
{
case ESTR_SUCCESS:
res = g_utf8_get_char_validated ((char *) buf_ch, -1);
if (res < 0)
{
ch = buf_ch[0];
}
else
{
ch = res;
}
break;
case ESTR_PROBLEM:
case ESTR_FAILURE:
ch = '.';
break;
}
str_close_conv (conv);
}
return ch;
}
char *
get_random_hint (int force)
{
char *data, *result = NULL, *eop;
int len;
int start;
static int last_sec;
static struct timeval tv;
GIConv conv;
/* Do not change hints more often than one minute */
gettimeofday (&tv, NULL);
if (!force && !(tv.tv_sec > last_sec + 60))
return g_strdup ("");
last_sec = tv.tv_sec;
data = load_mc_home_file (mc_global.share_data_dir, MC_HINT, NULL);
if (data == NULL)
return NULL;
/* get a random entry */
srand (tv.tv_sec);
len = strlen (data);
start = rand () % (len - 1);
/* Search the start of paragraph */
for (; start != 0; start--)
if (data[start] == '\n' && data[start + 1] == '\n')
{
start += 2;
break;
}
/* Search the end of paragraph */
for (eop = data + start; *eop != '\0'; eop++)
{
if (*eop == '\n' && *(eop + 1) == '\n')
{
*eop = '\0';
break;
}
if (*eop == '\n')
*eop = ' ';
}
/* hint files are stored in utf-8 */
/* try convert hint file from utf-8 to terminal encoding */
conv = str_crt_conv_from ("UTF-8");
if (conv != INVALID_CONV)
{
GString *buffer;
buffer = g_string_new ("");
if (str_convert (conv, &data[start], buffer) != ESTR_FAILURE)
result = g_string_free (buffer, FALSE);
else
g_string_free (buffer, TRUE);
str_close_conv (conv);
}
else
result = g_strdup (&data[start]);
g_free (data);
return result;
}
static estr_t
_vfs_translate_path (const char *path, int size, GIConv defcnv, GString * buffer)
{
estr_t state = ESTR_SUCCESS;
#ifdef HAVE_CHARSET
const char *semi;
const char *slash;
if (size == 0)
return ESTR_SUCCESS;
size = (size > 0) ? size : (signed int) strlen (path);
/* try found /#enc: */
semi = g_strrstr_len (path, size, VFS_ENCODING_PREFIX);
if (semi != NULL && (semi == path || *(semi - 1) == PATH_SEP))
{
char encoding[16];
GIConv coder = INVALID_CONV;
int ms;
/* first must be translated part before #enc: */
ms = semi - path;
state = _vfs_translate_path (path, ms, defcnv, buffer);
if (state != ESTR_SUCCESS)
return state;
/* now can be translated part after #enc: */
semi += strlen (VFS_ENCODING_PREFIX); /* skip "#enc:" */
slash = strchr (semi, PATH_SEP);
/* ignore slashes after size; */
if (slash - path >= size)
slash = NULL;
ms = (slash != NULL) ? slash - semi : (int) strlen (semi);
ms = min ((unsigned int) ms, sizeof (encoding) - 1);
/* limit encoding size (ms) to path size (size) */
if (semi + ms > path + size)
ms = path + size - semi;
memcpy (encoding, semi, ms);
encoding[ms] = '\0';
if (is_supported_encoding (encoding))
coder = str_crt_conv_to (encoding);
if (coder != INVALID_CONV)
{
if (slash != NULL)
state = str_vfs_convert_to (coder, slash + 1, path + size - slash - 1, buffer);
str_close_conv (coder);
return state;
}
errno = EINVAL;
state = ESTR_FAILURE;
}
else
{
/* path can be translated whole at once */
state = str_vfs_convert_to (defcnv, path, size, buffer);
}
#else
(void) size;
(void) defcnv;
g_string_assign (buffer, path);
#endif /* HAVE_CHARSET */
return state;
}
