static void validate (struct gdbarch *gdbarch) { iconv_t desc; const char *host_cset = host_charset (); const char *target_cset = target_charset (gdbarch); const char *target_wide_cset = target_wide_charset_name; if (!strcmp (target_wide_cset, "auto")) target_wide_cset = gdbarch_auto_wide_charset (gdbarch); desc = iconv_open (target_wide_cset, host_cset); if (desc == (iconv_t) -1) error (_("Cannot convert between character sets `%s' and `%s'"), target_wide_cset, host_cset); iconv_close (desc); desc = iconv_open (target_cset, host_cset); if (desc == (iconv_t) -1) error (_("Cannot convert between character sets `%s' and `%s'"), target_cset, host_cset); iconv_close (desc); /* Clear the cache. */ be_le_arch = NULL; }
static const char * charset_for_string_type (enum c_string_type str_type, struct gdbarch *gdbarch) { switch (str_type & ~C_CHAR) { case C_STRING: return target_charset (gdbarch); case C_WIDE_STRING: return target_wide_charset (gdbarch); case C_STRING_16: /* FIXME: UTF-16 is not always correct. */ if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) return "UTF-16BE"; else return "UTF-16LE"; case C_STRING_32: /* FIXME: UTF-32 is not always correct. */ if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) return "UTF-32BE"; else return "UTF-32LE"; } internal_error (__FILE__, __LINE__, _("unhandled c_string_type")); }
char * gdbscm_scm_to_target_string_unsafe (SCM string, size_t *lenp, struct gdbarch *gdbarch) { return scm_to_stringn (string, lenp, target_charset (gdbarch), SCM_FAILED_CONVERSION_ERROR); }
/* Converts a target string of LENGTH bytes in the target's charset to a Python Unicode string. If LENGTH is -1, convert until a null byte is found. Returns NULL on error, with a python exception set. */ PyObject * target_string_to_unicode (const gdb_byte *str, int length) { if (length == -1) length = strlen (str); return PyUnicode_Decode (str, length, target_charset (), NULL); }
static SCM gdbscm_arch_charset (SCM self) { arch_smob *a_smob =arscm_get_arch_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME); struct gdbarch *gdbarch = a_smob->gdbarch; return gdbscm_scm_from_c_string (target_charset (gdbarch)); }
/* sfunc for the 'show charset' command. */ static void show_charset (char *arg, int from_tty) { if (current_host_charset == current_target_charset) { printf_filtered ("The current host and target character set is `%s'.\n", host_charset ()); } else { printf_filtered ("The current host character set is `%s'.\n", host_charset ()); printf_filtered ("The current target character set is `%s'.\n", target_charset ()); } }
static const char * java_get_encoding (struct type *type) { struct gdbarch *arch = get_type_arch (type); const char *encoding; if (type == builtin_java_type (arch)->builtin_char) { if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG) encoding = "UTF-16BE"; else encoding = "UTF-16LE"; } else encoding = target_charset (arch); return encoding; }
static const char * f_get_encoding (struct type *type) { const char *encoding; switch (TYPE_LENGTH (type)) { case 1: encoding = target_charset (get_type_arch (type)); break; case 4: if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_BIG) encoding = "UTF-32BE"; else encoding = "UTF-32LE"; break; default: error (_("unrecognized character type")); } return encoding; }
static enum string_repr_result ppscm_print_string_repr (SCM printer, enum display_hint hint, struct ui_file *stream, int recurse, const struct value_print_options *options, struct gdbarch *gdbarch, const struct language_defn *language) { struct value *replacement = NULL; SCM str_scm; enum string_repr_result result = STRING_REPR_ERROR; str_scm = ppscm_pretty_print_one_value (printer, &replacement, gdbarch, language); if (gdbscm_is_false (str_scm)) { result = STRING_REPR_NONE; } else if (scm_is_eq (str_scm, SCM_BOOL_T)) { struct value_print_options opts = *options; gdb_assert (replacement != NULL); opts.addressprint = 0; common_val_print (replacement, stream, recurse, &opts, language); result = STRING_REPR_OK; } else if (scm_is_string (str_scm)) { struct cleanup *cleanup; size_t length; char *string = gdbscm_scm_to_string (str_scm, &length, target_charset (gdbarch), 0 /*!strict*/, NULL); cleanup = make_cleanup (xfree, string); if (hint == HINT_STRING) { struct type *type = builtin_type (gdbarch)->builtin_char; LA_PRINT_STRING (stream, type, (gdb_byte *) string, length, NULL, 0, options); } else { /* Alas scm_to_stringn doesn't nul-terminate the string if we ask for the length. */ size_t i; for (i = 0; i < length; ++i) { if (string[i] == '\0') fputs_filtered ("\\000", stream); else fputc_filtered (string[i], stream); } } result = STRING_REPR_OK; do_cleanups (cleanup); } else if (lsscm_is_lazy_string (str_scm)) { struct value_print_options local_opts = *options; local_opts.addressprint = 0; lsscm_val_print_lazy_string (str_scm, stream, &local_opts); result = STRING_REPR_OK; } else { gdb_assert (gdbscm_is_exception (str_scm)); ppscm_print_exception_unless_memory_error (str_scm, stream); result = STRING_REPR_ERROR; } return result; }
/* Returns a PyObject with the contents of the given unicode string object converted to the target's charset. If an error occurs during the conversion, NULL will be returned and a python exception will be set. */ static PyObject * unicode_to_target_python_string (PyObject *unicode_str) { return unicode_to_encoded_python_string (unicode_str, target_charset (python_gdbarch)); }
/* Returns a newly allocated string with the contents of the given unicode string object converted to the target's charset. If an error occurs during the conversion, NULL will be returned and a python exception will be set. */ gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str) { return unicode_to_encoded_string (unicode_str, target_charset (python_gdbarch)); }
/* Returns a newly allocated string with the contents of the given unicode string object converted to the target's charset. If an error occurs during the conversion, NULL will be returned and a python exception will be set. The caller is responsible for xfree'ing the string. */ char * unicode_to_target_string (PyObject *unicode_str) { return unicode_to_encoded_string (unicode_str, target_charset ()); }