gchar* Inkscape::IO::locale_to_utf8_fallback( const gchar *opsysstring, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error ) { gchar *result = NULL; if ( opsysstring ) { gchar *newFileName = g_locale_to_utf8( opsysstring, len, bytes_read, bytes_written, error ); if ( newFileName ) { if ( !g_utf8_validate(newFileName, -1, NULL) ) { g_warning( "input filename did not yield UTF-8" ); g_free( newFileName ); } else { result = newFileName; } newFileName = 0; } else if ( g_utf8_validate(opsysstring, -1, NULL) ) { // This *might* be a case that we want // g_warning( "input failed filename->utf8, fell back to original" ); // TODO handle cases when len >= 0 result = g_strdup( opsysstring ); } else { gchar const *charset = 0; g_get_charset(&charset); g_warning( "input filename conversion failed for file with locale charset '%s'", charset ); } } return result; }
int get_stamp_str (char *fmt, time_t tim, char **ret) { char *loc = NULL; char dest[128]; gsize len; /* strftime wants the format string in LOCALE! */ if (!prefs.utf8_locale) { const gchar *charset; g_get_charset (&charset); loc = g_convert_with_fallback (fmt, -1, charset, "UTF-8", "?", 0, 0, 0); if (loc) fmt = loc; } len = strftime_validated (dest, sizeof (dest), fmt, localtime (&tim)); if (len) { if (prefs.utf8_locale) *ret = g_strdup (dest); else *ret = g_locale_to_utf8 (dest, len, 0, &len, 0); } if (loc) g_free (loc); return len; }
GSList * _gedit_utils_encoding_strv_to_list (const gchar * const *enc_str) { GSList *res = NULL; gchar **p; for (p = (gchar **)enc_str; p != NULL && *p != NULL; p++) { const gchar *charset = *p; const GtkSourceEncoding *enc; if (g_str_equal (charset, "CURRENT")) { g_get_charset (&charset); } g_return_val_if_fail (charset != NULL, NULL); enc = gtk_source_encoding_get_from_charset (charset); if (enc != NULL && !data_exists (res, (gpointer)enc)) { res = g_slist_prepend (res, (gpointer)enc); } } return g_slist_reverse (res); }
/* schreibt eine UTF-8 Zeichenkette auf die Standardausgabe */ gint printf_utf8(const gchar *format, ...) { gchar *str_utf8, *str_locale; const char *locale_charset; va_list ap; gsize len_utf8, len_locale; gint retval; va_start(ap, format); str_utf8 = g_strdup_vprintf(format, ap); va_end(ap); len_utf8 = (gsize) strlen(str_utf8); if (!g_get_charset(&locale_charset)) { str_locale = g_convert_with_fallback(str_utf8, (gssize) len_utf8, locale_charset, "UTF-8", "_", NULL, &len_locale, NULL); g_free(str_utf8); } else { str_locale = str_utf8; str_utf8 = NULL; len_locale = len_utf8; } if (str_locale == NULL) return -1; retval = (gint) fwrite(str_locale, sizeof(gchar), len_locale, stdout); g_free(str_locale); return retval; }
/** Parse a given file into XML, handling old broken files correctly. * @param filename The name of the file to read. * @returns An XML document parsed from the file. * @see xmlParseFile() in the XML2 library for details on the return value. */ xmlDocPtr xmlDiaParseFile(const char *filename) { G_CONST_RETURN char *local_charset = NULL; if ( !g_get_charset(&local_charset) && local_charset) { /* we're not in an UTF-8 environment. */ const gchar *fname = xml_file_check_encoding(filename,local_charset); if (fname != filename) { /* We've got a corrected file to parse. */ xmlDocPtr ret = xmlDoParseFile(fname); unlink(fname); /* printf("has read %s instead of %s\n",fname,filename); */ g_free((void *)fname); return ret; } else { /* the XML file is good. libxml is "old enough" to handle it correctly. */ return xmlDoParseFile(filename); } } else { return xmlDoParseFile(filename); } }
/* Must free the returned string yourself */ gchar *charset_track_charset_from_utf8 (Track *s, const gchar *str) { gchar *charset; const gchar *locale_charset; gchar *result; ExtraTrackData *etd; g_return_val_if_fail (s, NULL); g_return_val_if_fail (s->userdata, NULL); if (str == NULL) return NULL; /* sanity */ etd = s->userdata; if (etd->charset && strlen (etd->charset)) charset = g_strdup(etd->charset); else charset = prefs_get_string("charset"); if (!charset || !strlen (charset)) { /* use standard locale charset */ g_free(charset); g_get_charset (&locale_charset); charset = g_strdup(locale_charset); } result = charset_to_charset ("UTF-8", charset, str); g_free(charset); return result; }
void CoreManager::InputInit() { // init libtermkey TERMKEY_CHECK_VERSION; if (!(tk = termkey_new(STDIN_FILENO, TERMKEY_FLAG_NOTERMIOS))) { g_critical(_("Libtermkey initialization failed.")); exit(1); } utf8 = g_get_charset(NULL); io_input_channel = g_io_channel_unix_new(STDIN_FILENO); // set channel encoding to NULL so it can be unbuffered g_io_channel_set_encoding(io_input_channel, NULL, NULL); g_io_channel_set_buffered(io_input_channel, FALSE); g_io_channel_set_close_on_unref(io_input_channel, TRUE); io_input_channel_id = g_io_add_watch_full(io_input_channel, G_PRIORITY_HIGH, static_cast<GIOCondition>(G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_PRI), io_input_, this, NULL); g_io_add_watch_full(io_input_channel, G_PRIORITY_HIGH, G_IO_NVAL, io_input_error_, this, NULL); g_io_channel_unref(io_input_channel); // screen resizing if (!pipe(pipefd)) { pipe_valid = true; resize_channel = g_io_channel_unix_new(pipefd[0]); g_io_channel_set_encoding(resize_channel, NULL, NULL); g_io_channel_set_buffered(resize_channel, FALSE); g_io_channel_set_close_on_unref(resize_channel, TRUE); resize_channel_id = g_io_add_watch_full(resize_channel, G_PRIORITY_HIGH, G_IO_IN, resize_input_, this, NULL); } }
static gchar * str_to_utf8 (const gchar *text) { static const gchar *encodings_to_try[2]; static gint n_encodings_to_try = 0; gchar *utf8_text = NULL; gint i; if (n_encodings_to_try == 0) { const gchar *charset; gboolean charset_is_utf8; charset_is_utf8 = g_get_charset (&charset); if (!charset_is_utf8) { encodings_to_try[n_encodings_to_try++] = charset; } if (g_ascii_strcasecmp (charset, "ISO-8859-1") != 0) { encodings_to_try[n_encodings_to_try++] = "ISO-8859-1"; } } for (i = 0; i < n_encodings_to_try; i++) { utf8_text = g_convert (text, -1, "UTF-8", encodings_to_try[i], NULL, NULL, NULL); if (utf8_text) break; } return utf8_text; }
/* Must free the returned string yourself */ gchar *charset_to_utf8 (const gchar *str) { gchar *charset; /* From prefs */ const gchar *locale_charset; /* Used if prefs doesn't have a charset */ gchar *result; if (str == NULL) return NULL; /* sanity */ charset = charset_check_auto (str); if (charset) { g_free(auto_charset); auto_charset = g_strdup(charset); } else { charset = prefs_get_string("charset"); if (!charset || !strlen (charset)) { /* use standard locale charset */ g_free(charset); g_get_charset (&locale_charset); charset = g_strdup(locale_charset); } } result = charset_to_charset (charset, "UTF-8", str); g_free(charset); return result; }
/* Use this function to process a line for the first time, it will convert the * string to UTF-8. */ static void process_line (LatexilaPostProcessor *pp, gchar *line) { gchar *utf8_line = NULL; /* locale is not UTF-8 */ if (!g_get_charset (NULL)) { utf8_line = g_locale_to_utf8 (line, -1, NULL, NULL, NULL); } else if (g_utf8_validate (line, -1, NULL)) { utf8_line = line; line = NULL; } /* The LaTeX output can be in ISO-8859-1, with accents in a filename for * instance. */ if (utf8_line == NULL) utf8_line = g_convert (line, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL); if (utf8_line != NULL) latexila_post_processor_process_line (pp, utf8_line); else g_warning ("Failed to convert subprocess output to UTF-8: %s", line); g_free (line); }
/*! * \brief Parse a given file into XML, handling old broken files correctly. * @param filename The name of the file to read. * @returns An XML document parsed from the file. * @see xmlParseFile() in the XML2 library for details on the return value. * @param ctx The context in which this function is called * \ingroup DiagramXmlIo */ static xmlDocPtr xmlDiaParseFile(const char *filename, DiaContext *ctx) { const char *local_charset = NULL; xmlErrorPtr error_xml = NULL; xmlDocPtr ret = NULL; if ( !g_get_charset(&local_charset) && local_charset) { /* we're not in an UTF-8 environment. */ const gchar *fname = xml_file_check_encoding(filename,local_charset, ctx); if (fname != filename) { /* We've got a corrected file to parse. */ xmlDocPtr ret = xmlDoParseFile(fname, &error_xml); unlink(fname); /* printf("has read %s instead of %s\n",fname,filename); */ g_free((void *)fname); } else { /* the XML file is good. libxml is "old enough" to handle it correctly. */ ret = xmlDoParseFile(filename, &error_xml); } } else { ret = xmlDoParseFile(filename, &error_xml); } if (error_xml) dia_context_add_message (ctx, error_xml->message); return ret; }
const PlumaEncoding * pluma_encoding_get_current (void) { static gboolean initialized = FALSE; static const PlumaEncoding *locale_encoding = NULL; const gchar *locale_charset; pluma_encoding_lazy_init (); if (initialized != FALSE) return locale_encoding; if (g_get_charset (&locale_charset) == FALSE) { g_return_val_if_fail (locale_charset != NULL, &utf8_encoding); locale_encoding = pluma_encoding_get_from_charset (locale_charset); } else { locale_encoding = &utf8_encoding; } if (locale_encoding == NULL) { locale_encoding = &unknown_encoding; } g_return_val_if_fail (locale_encoding != NULL, NULL); initialized = TRUE; return locale_encoding; }
/* * Conversion with UTF-8 for Ogg Vorbis and FLAC tags (current_charset <===> UTF-8) */ gchar *convert_to_utf8 (const gchar *string) { gchar *output; GError *error = NULL; g_return_val_if_fail (string != NULL, NULL); output = g_locale_to_utf8(string, -1, NULL, NULL, &error); if (output == NULL) { const gchar *usercharset; gchar *escaped_str = g_strescape(string, NULL); g_get_charset(&usercharset); Log_Print(LOG_ERROR,"convert_to_utf8(): Failed conversion from charset '%s'. " "String '%s'. Errcode %d (%s).", usercharset, escaped_str, error->code, error->message); g_free(escaped_str); if (g_utf8_validate(string, -1, NULL)) Log_Print(LOG_ERROR,"convert_to_utf8(): String was valid UTF-8."); else Log_Print(LOG_ERROR,"convert_to_utf8(): String was INVALID UTF-8."); g_error_free(error); return g_strdup(string); } return output; }
/** * gtk_content_formats_add_text_targets: * @list: a #GdkContentFormats * * Appends the text targets supported by #GtkSelectionData to * the target list. All targets are added with the same @info. **/ GdkContentFormats * gtk_content_formats_add_text_targets (GdkContentFormats *list) { GdkContentFormatsBuilder *builder; g_return_val_if_fail (list != NULL, NULL); init_atoms (); builder = gdk_content_formats_builder_new (); gdk_content_formats_builder_add_formats (builder, list); gdk_content_formats_unref (list); /* Keep in sync with gtk_selection_data_targets_include_text() */ gdk_content_formats_builder_add_mime_type (builder, utf8_atom); gdk_content_formats_builder_add_mime_type (builder, ctext_atom); gdk_content_formats_builder_add_mime_type (builder, text_atom); gdk_content_formats_builder_add_mime_type (builder, g_intern_static_string ("STRING")); gdk_content_formats_builder_add_mime_type (builder, text_plain_utf8_atom); if (!g_get_charset (NULL)) gdk_content_formats_builder_add_mime_type (builder, text_plain_locale_atom); gdk_content_formats_builder_add_mime_type (builder, text_plain_atom); return gdk_content_formats_builder_free_to_formats (builder); }
static void test_non_utf8_import (NMVpnPluginUiInterface *plugin, const char *dir) { NMConnection *connection; NMSettingConnection *s_con; NMSettingVPN *s_vpn; const char *expected_id = "Att äta en ko"; const char *charset = NULL; /* Change charset to ISO-8859-15 to match iso885915.pcf */ g_get_charset (&charset); setlocale (LC_ALL, "de_DE@euro"); connection = get_basic_connection ("non-utf8-import", plugin, dir, "iso885915.pcf"); setlocale (LC_ALL, charset); ASSERT (connection != NULL, "non-utf8-import", "failed to import connection"); /* Connection setting */ s_con = nm_connection_get_setting_connection (connection); ASSERT (s_con != NULL, "non-utf8-import", "missing 'connection' setting"); ASSERT (strcmp (nm_setting_connection_get_id (s_con), expected_id) == 0, "non-utf8-import", "unexpected connection ID"); ASSERT (nm_setting_connection_get_uuid (s_con) == NULL, "non-utf8-import", "unexpected valid UUID"); /* VPN setting */ s_vpn = nm_connection_get_setting_vpn (connection); ASSERT (s_vpn != NULL, "non-utf8-import", "missing 'vpn' setting"); g_object_unref (connection); }
const gchar *get_default_charset(void) { const gchar *charset; g_get_charset(&charset); return charset; }
gchar * gdk_wcstombs (const GdkWChar *src) { const gchar *charset; g_get_charset (&charset); return g_convert ((char *) src, -1, charset, "UCS-4LE", NULL, NULL, NULL); }
void netinfo_text_buffer_insert (Netinfo * netinfo) { gchar *dir = g_get_current_dir (); gint child_pid, pout; GIOChannel *channel; const gchar *charset; GIOStatus status; GError *err = NULL; g_return_if_fail (netinfo != NULL); g_return_if_fail (netinfo->command_line != NULL); if (g_spawn_async_with_pipes (dir, netinfo->command_line, NULL, G_SPAWN_FILE_AND_ARGV_ZERO | G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, &child_pid, NULL, &pout, NULL, &err)) { netinfo->child_pid = child_pid; netinfo->pipe_out = pout; fcntl (pout, F_SETFL, O_NONBLOCK); fcntl (pout, F_SETFL, O_NONBLOCK); netinfo->command_output = NULL; g_child_watch_add (child_pid, netinfo_reap_child, netinfo); g_get_charset(&charset); channel = g_io_channel_unix_new (pout); status = g_io_channel_set_encoding(channel, charset, &err); if (G_IO_STATUS_NORMAL == status) { g_io_add_watch (channel, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, netinfo_io_text_buffer_dialog, netinfo); g_io_channel_unref (channel); } else { g_warning ("Error: %s\n", err->message); g_error_free (err); } } else { gint len = strlen (err->message); if (netinfo->process_line != NULL) { (netinfo->process_line) ((gpointer) netinfo, err->message, len, NULL); } netinfo_toggle_state (netinfo, ACTIVE, NULL); g_warning ("Error: %s\n", err->message); g_error_free (err); } g_free (dir); }
static gboolean recode_get_charset(const char **charset) { *charset = settings_get_str("term_charset"); if (**charset) /* we use the same test as in src/fe-text/term.c:123 */ return (g_strcasecmp(*charset, "utf-8") == 0); return g_get_charset(charset); }
static void GtkErrorLog (const char *format, ...) { GtkWidget *dialog, *label; va_list args; char buf[256]; if (dialog_connecting != NULL) { gtk_widget_destroy (dialog_connecting); dialog_connecting = NULL; } va_start (args, format); vsnprintf (buf, 255, format, args); va_end (args); if (g_utf8_validate (buf, strlen (buf), NULL)) { label = gtk_label_new (buf); } else { const gchar *charset; gchar *utf8; (void) g_get_charset (&charset); utf8 = g_convert_with_fallback (buf, strlen (buf), "UTF-8", charset, NULL, NULL, NULL, NULL); if (utf8) { label = gtk_label_new (utf8); g_free (utf8); } else { label = gtk_label_new (buf); g_warning ("Message Output is not in UTF-8" "nor in locale charset.\n"); } } dialog = gtk_dialog_new_with_buttons ("Error", NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); label = gtk_label_new (buf); gtk_widget_show (label); gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label); gtk_widget_show (dialog); switch (gtk_dialog_run (GTK_DIALOG (dialog))) { case GTK_RESPONSE_ACCEPT: break; default: break; } gtk_widget_destroy (dialog); }
static char const * get_locale_encoding_name(GOCharmapSel *cs) { char const *locale_encoding; char const *name; g_get_charset(&locale_encoding); name = go_charmap_sel_get_encoding_name(cs, locale_encoding); return name ? name : locale_encoding; }
static const gchar *GetLocaleCodeset(void) { #ifdef HAVE_GLIB2 const gchar *codeset; g_get_charset(&codeset); return FixedCodeset(codeset); #else return "ISO-8859-1"; #endif }
gboolean mu_util_locale_is_utf8 (void) { const gchar *dummy; static int is_utf8 = -1; if (G_UNLIKELY(is_utf8 == -1)) is_utf8 = g_get_charset(&dummy) ? 1 : 0; return is_utf8 ? TRUE : FALSE; }
static const char * _fr_process_get_charset (FrProcess *process) { const char *charset = NULL; if (process->priv->current_charset >= 0) charset = try_charsets[process->priv->current_charset]; else if (g_get_charset (&charset)) charset = NULL; return charset; }
GstTagList * gst_rm_utils_read_tags (const guint8 * data, guint datalen, GstRmUtilsStringReadFunc read_string_func) { const gchar *gst_tags[] = { GST_TAG_TITLE, GST_TAG_ARTIST, GST_TAG_COPYRIGHT, GST_TAG_COMMENT }; GstTagList *tags; guint i; g_assert (read_string_func != NULL); GST_DEBUG ("File Content : (CONT) len = %d", datalen); tags = gst_tag_list_new (); for (i = 0; i < G_N_ELEMENTS (gst_tags); ++i) { gchar *str = NULL; guint total_length = 0; str = read_string_func (data, datalen, &total_length); data += total_length; datalen -= total_length; if (str != NULL && !g_utf8_validate (str, -1, NULL)) { const gchar *encoding; gchar *tmp; encoding = g_getenv ("GST_TAG_ENCODING"); if (encoding == NULL || *encoding == '\0') { if (g_get_charset (&encoding)) encoding = "ISO-8859-15"; } GST_DEBUG ("converting tag from %s to UTF-8", encoding); tmp = g_convert_with_fallback (str, -1, "UTF-8", encoding, "*", NULL, NULL, NULL); g_free (str); str = tmp; } GST_DEBUG ("%s = %s", gst_tags[i], GST_STR_NULL (str)); if (str != NULL && *str != '\0') { gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, gst_tags[i], str, NULL); } g_free (str); } if (gst_structure_n_fields ((GstStructure *) tags) > 0) return tags; gst_tag_list_free (tags); return NULL; }
static gchar * get_string_from_guessed_encoding (const gchar *str, gsize str_len, gsize *utf8_len) { const gchar *current = NULL; /* If we have embedded NULs try UTF-16 directly */ if (memchr (str, '\0', str_len)) current = "UTF-16"; /* If locale charset is UTF-8, try with windows-1252. * NOTE: g_get_charset() returns TRUE if locale charset is UTF-8 */ else if (g_get_charset (¤t)) current = "windows-1252"; while (current) { gchar *utf8_str; gsize bytes_read = 0; gsize bytes_written = 0; utf8_str = g_convert (str, str_len, "UTF-8", current, &bytes_read, &bytes_written, NULL); if (utf8_str && str_len == bytes_read) { g_debug ("Converted %" G_GSIZE_FORMAT " bytes in '%s' codeset " "to %" G_GSIZE_FORMAT " bytes in UTF-8", bytes_read, current, bytes_written); *utf8_len = bytes_written; return utf8_str; } g_free (utf8_str); g_debug ("Text not in '%s' encoding", current); if (!strcmp (current, "windows-1252") || !strcmp (current, "UTF-16")) /* If we tried windows-1252 or UTF-16, don't try anything else */ current = NULL; else /* If we tried a locale encoding and didn't work, retry with * windows-1252 */ current = "windows-1252"; } return NULL; }
bool log_init(bool verbose, bool use_stdout, GError **error_r) { const struct config_param *param; g_get_charset(&log_charset); if (verbose) log_threshold = G_LOG_LEVEL_DEBUG; else if ((param = config_get_param(CONF_LOG_LEVEL)) != NULL) log_threshold = parse_log_level(param->value, param->line); if (use_stdout) { log_init_stdout(); return true; } else { param = config_get_param(CONF_LOG_FILE); if (param == NULL) { #ifdef HAVE_SYSLOG /* no configuration: default to syslog (if available) */ log_init_syslog(); return true; #else g_set_error(error_r, log_quark(), 0, "config parameter \"%s\" not found", CONF_LOG_FILE); return false; #endif #ifdef HAVE_SYSLOG } else if (strcmp(param->value, "syslog") == 0) { log_init_syslog(); return true; #endif } else { GError *error = NULL; char *path = config_dup_path(CONF_LOG_FILE, &error); if (path == NULL) { assert(error != NULL); g_propagate_error(error_r, error); return false; } bool success = log_init_file(path, param->line, error_r); g_free(path); return success; } } }
/* {{{ proto array Glib::getCharset() Obtains the character set for the current locale. Returns an array, the first element of which is a boolean indicating if the current charset is UTF-8. The remaining element is the charset. */ PHP_METHOD(Glib, getCharset) { gboolean status; const gchar *charset; if (zend_parse_parameters_none() == FAILURE) { return; } status = g_get_charset(&charset); array_init(return_value); add_next_index_bool(return_value, status); add_next_index_string(return_value, (char *)charset, 1); }
const gchar* get_codeset(void) { const char *codeset = NULL; gboolean ret; ret = g_get_charset(&codeset); if(!ret && codeset == NULL){ codeset = setlocale(LC_CTYPE, NULL); if (codeset != NULL) { codeset = strchr(codeset, '.'); if (codeset != NULL) ++codeset; } } return codeset; }
const char * terminal_encoding_get_charset (TerminalEncoding *encoding) { g_return_val_if_fail (encoding != NULL, NULL); if (strcmp (encoding->id, "current") == 0) { const char *charset; g_get_charset (&charset); return charset; } return encoding->id; }