void
c_printchar (int c, struct type *type, struct ui_file *stream)
{
enum c_string_type str_type;
str_type = classify_type (type, get_type_arch (type), NULL);
switch (str_type)
{
case C_CHAR:
break;
case C_WIDE_CHAR:
fputc_filtered ('L', stream);
break;
case C_CHAR_16:
fputc_filtered ('u', stream);
break;
case C_CHAR_32:
fputc_filtered ('U', stream);
break;
}
fputc_filtered ('\'', stream);
LA_EMIT_CHAR (c, type, stream, '\'');
fputc_filtered ('\'', stream);
}
void
c_printchar (int c, struct ui_file *stream)
{
fputc_filtered ('\'', stream);
LA_EMIT_CHAR (c, stream, '\'');
fputc_filtered ('\'', stream);
}
static void
field_separator (void)
{
cli_out_data *data = ui_out_data (uiout);
fputc_filtered (' ', data->stream);
}
static void
field_separator (void)
{
cli_out_data *data = ui_out_data (current_uiout);
struct ui_file *stream = VEC_last (ui_filep, data->streams);
fputc_filtered (' ', stream);
}
static void
field_separator (void)
{
cli_out_data *data = (cli_out_data *) ui_out_data (current_uiout);
struct ui_file *stream = data->streams.back ();
fputc_filtered (' ', stream);
}
static void
fputsn_filtered (const char *s, size_t size, struct ui_file *stream)
{
size_t i;
for (i = 0; i < size; ++i)
{
if (s[i] == '\0')
fputs_filtered ("\\000", stream);
else
fputc_filtered (s[i], stream);
}
}
void
pascal_type_print_method_args (const char *physname, const char *methodname,
struct ui_file *stream)
{
int is_constructor = (strncmp (physname, "__ct__", 6) == 0);
int is_destructor = (strncmp (physname, "__dt__", 6) == 0);
if (is_constructor || is_destructor)
{
physname += 6;
}
fputs_filtered (methodname, stream);
if (physname && (*physname != 0))
{
fputs_filtered (" (", stream);
/* We must demangle this. */
while (isdigit (physname[0]))
{
int len = 0;
int i, j;
char *argname;
while (isdigit (physname[len]))
{
len++;
}
i = strtol (physname, &argname, 0);
physname += len;
for (j = 0; j < i; ++j)
fputc_filtered (physname[i], stream);
fputs_filtered (physname, stream);
physname += i;
if (physname[0] != 0)
{
fputs_filtered (", ", stream);
}
}
fputs_filtered (")", stream);
}
}
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;
}
void
cli_ui_out::field_separator ()
{
fputc_filtered (' ', m_streams.back ());
}
