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;
}
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);
}
/**
* 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);
}
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;
}
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;
}
