X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fp-typeprint.c;h=a3c2ef897d664658103e737e6f0026969138c376;hb=9324bfeab9b819042ddbab4ce8918ee533db651a;hp=794d09c759c339a92ec8fedd8c94a85fa43464e2;hpb=b4aa388a2099d88f1d521a79bdfabb0501a03f1a;p=binutils-gdb.git diff --git a/gdb/p-typeprint.c b/gdb/p-typeprint.c index 794d09c759c..a3c2ef897d6 100644 --- a/gdb/p-typeprint.c +++ b/gdb/p-typeprint.c @@ -1,5 +1,5 @@ /* Support for printing Pascal types for GDB, the GNU debugger. - Copyright (C) 2000-2002, 2006-2012 Free Software Foundation, Inc. + Copyright (C) 2000-2023 Free Software Foundation, Inc. This file is part of GDB. @@ -19,7 +19,7 @@ /* This file is derived from p-typeprint.c */ #include "defs.h" -#include "gdb_obstack.h" +#include "gdbsupport/gdb_obstack.h" #include "bfd.h" /* Binary File Description */ #include "symtab.h" #include "gdbtypes.h" @@ -31,143 +31,112 @@ #include "p-lang.h" #include "typeprint.h" #include "gdb-demangle.h" -#include "gdb_string.h" -#include #include +#include "cli/cli-style.h" -static void pascal_type_print_varspec_suffix (struct type *, struct ui_file *, - int, int, int); - -static void pascal_type_print_derivation_info (struct ui_file *, - struct type *); - -void pascal_type_print_varspec_prefix (struct type *, struct ui_file *, - int, int); - - -/* LEVEL is the depth to indent lines by. */ +/* See language.h. */ void -pascal_print_type (struct type *type, const char *varstring, - struct ui_file *stream, int show, int level) +pascal_language::print_type (struct type *type, const char *varstring, + struct ui_file *stream, int show, int level, + const struct type_print_options *flags) const { enum type_code code; int demangled_args; - code = TYPE_CODE (type); + code = type->code (); if (show > 0) - CHECK_TYPEDEF (type); + type = check_typedef (type); if ((code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)) { - pascal_type_print_varspec_prefix (type, stream, show, 0); + type_print_varspec_prefix (type, stream, show, 0, flags); } /* first the name */ - fputs_filtered (varstring, stream); + gdb_puts (varstring, stream); if ((varstring != NULL && *varstring != '\0') && !(code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)) { - fputs_filtered (" : ", stream); + gdb_puts (" : ", stream); } if (!(code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)) { - pascal_type_print_varspec_prefix (type, stream, show, 0); + type_print_varspec_prefix (type, stream, show, 0, flags); } - pascal_type_print_base (type, stream, show, level); + type_print_base (type, stream, show, level, flags); /* For demangled function names, we have the arglist as part of the name, so don't print an additional pair of ()'s. */ demangled_args = varstring ? strchr (varstring, '(') != NULL : 0; - pascal_type_print_varspec_suffix (type, stream, show, 0, demangled_args); + type_print_varspec_suffix (type, stream, show, 0, demangled_args, + flags); } -/* Print a typedef using Pascal syntax. TYPE is the underlying type. - NEW_SYMBOL is the symbol naming the type. STREAM is the stream on - which to print. */ +/* See language.h. */ void -pascal_print_typedef (struct type *type, struct symbol *new_symbol, - struct ui_file *stream) +pascal_language::print_typedef (struct type *type, struct symbol *new_symbol, + struct ui_file *stream) const { - CHECK_TYPEDEF (type); - fprintf_filtered (stream, "type "); - fprintf_filtered (stream, "%s = ", SYMBOL_PRINT_NAME (new_symbol)); + type = check_typedef (type); + gdb_printf (stream, "type "); + gdb_printf (stream, "%s = ", new_symbol->print_name ()); type_print (type, "", stream, 0); - fprintf_filtered (stream, ";\n"); + gdb_printf (stream, ";"); } -/* If TYPE is a derived type, then print out derivation information. - Print only the actual base classes of this type, not the base classes - of the base classes. I.e. for the derivation hierarchy: - - class A { int a; }; - class B : public A {int b; }; - class C : public B {int c; }; - - Print the type of class C as: - - class C : public B { - int c; - } - - Not as the following (like gdb used to), which is not legal C++ syntax for - derived types and may be confused with the multiple inheritance form: - - class C : public B : public A { - int c; - } +/* See p-lang.h. */ - In general, gdb should try to print the types as closely as possible to - the form that they appear in the source code. */ - -static void -pascal_type_print_derivation_info (struct ui_file *stream, struct type *type) +void +pascal_language::type_print_derivation_info (struct ui_file *stream, + struct type *type) const { const char *name; int i; for (i = 0; i < TYPE_N_BASECLASSES (type); i++) { - fputs_filtered (i == 0 ? ": " : ", ", stream); - fprintf_filtered (stream, "%s%s ", - BASETYPE_VIA_PUBLIC (type, i) ? "public" : "private", - BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : ""); - name = type_name_no_tag (TYPE_BASECLASS (type, i)); - fprintf_filtered (stream, "%s", name ? name : "(null)"); + gdb_puts (i == 0 ? ": " : ", ", stream); + gdb_printf (stream, "%s%s ", + BASETYPE_VIA_PUBLIC (type, i) ? "public" : "private", + BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : ""); + name = TYPE_BASECLASS (type, i)->name (); + gdb_printf (stream, "%s", name ? name : "(null)"); } if (i > 0) { - fputs_filtered (" ", stream); + gdb_puts (" ", stream); } } -/* Print the Pascal method arguments ARGS to the file STREAM. */ +/* See p-lang.h. */ void -pascal_type_print_method_args (const char *physname, const char *methodname, - struct ui_file *stream) +pascal_language::type_print_method_args (const char *physname, + const char *methodname, + struct ui_file *stream) const { - int is_constructor = (strncmp (physname, "__ct__", 6) == 0); - int is_destructor = (strncmp (physname, "__dt__", 6) == 0); + int is_constructor = (startswith (physname, "__ct__")); + int is_destructor = (startswith (physname, "__dt__")); if (is_constructor || is_destructor) { physname += 6; } - fputs_filtered (methodname, stream); + gdb_puts (methodname, stream); if (physname && (*physname != 0)) { - fputs_filtered (" (", stream); + gdb_puts (" (", stream); /* We must demangle this. */ while (isdigit (physname[0])) { @@ -183,260 +152,216 @@ pascal_type_print_method_args (const char *physname, const char *methodname, physname += len; for (j = 0; j < i; ++j) - fputc_filtered (physname[j], stream); + gdb_putc (physname[j], stream); physname += i; if (physname[0] != 0) { - fputs_filtered (", ", stream); + gdb_puts (", ", stream); } } - fputs_filtered (")", stream); + gdb_puts (")", stream); } } -/* Print any asterisks or open-parentheses needed before the - variable name (to describe its type). - - On outermost call, pass 0 for PASSED_A_PTR. - On outermost call, SHOW > 0 means should ignore - any typename for TYPE and show its details. - SHOW is always zero on recursive calls. */ +/* See p-lang.h. */ void -pascal_type_print_varspec_prefix (struct type *type, struct ui_file *stream, - int show, int passed_a_ptr) +pascal_language::type_print_varspec_prefix (struct type *type, + struct ui_file *stream, + int show, int passed_a_ptr, + const struct type_print_options *flags) const { if (type == 0) return; - if (TYPE_NAME (type) && show <= 0) + if (type->name () && show <= 0) return; QUIT; - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_PTR: - fprintf_filtered (stream, "^"); - pascal_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1); + gdb_printf (stream, "^"); + type_print_varspec_prefix (type->target_type (), stream, 0, 1, + flags); break; /* Pointer should be handled normally in pascal. */ case TYPE_CODE_METHOD: if (passed_a_ptr) - fprintf_filtered (stream, "("); - if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID) + gdb_printf (stream, "("); + if (type->target_type () != NULL + && type->target_type ()->code () != TYPE_CODE_VOID) { - fprintf_filtered (stream, "function "); + gdb_printf (stream, "function "); } else { - fprintf_filtered (stream, "procedure "); + gdb_printf (stream, "procedure "); } if (passed_a_ptr) { - fprintf_filtered (stream, " "); - pascal_type_print_base (TYPE_DOMAIN_TYPE (type), - stream, 0, passed_a_ptr); - fprintf_filtered (stream, "::"); + gdb_printf (stream, " "); + type_print_base (TYPE_SELF_TYPE (type), + stream, 0, passed_a_ptr, flags); + gdb_printf (stream, "::"); } break; case TYPE_CODE_REF: - pascal_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1); - fprintf_filtered (stream, "&"); + type_print_varspec_prefix (type->target_type (), stream, 0, 1, + flags); + gdb_printf (stream, "&"); break; case TYPE_CODE_FUNC: if (passed_a_ptr) - fprintf_filtered (stream, "("); + gdb_printf (stream, "("); - if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID) + if (type->target_type () != NULL + && type->target_type ()->code () != TYPE_CODE_VOID) { - fprintf_filtered (stream, "function "); + gdb_printf (stream, "function "); } else { - fprintf_filtered (stream, "procedure "); + gdb_printf (stream, "procedure "); } break; case TYPE_CODE_ARRAY: if (passed_a_ptr) - fprintf_filtered (stream, "("); - fprintf_filtered (stream, "array "); - if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0 - && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type)) - fprintf_filtered (stream, "[%s..%s] ", - plongest (TYPE_ARRAY_LOWER_BOUND_VALUE (type)), - plongest (TYPE_ARRAY_UPPER_BOUND_VALUE (type))); - fprintf_filtered (stream, "of "); - break; - - case TYPE_CODE_UNDEF: - case TYPE_CODE_STRUCT: - case TYPE_CODE_UNION: - case TYPE_CODE_ENUM: - case TYPE_CODE_INT: - case TYPE_CODE_FLT: - case TYPE_CODE_VOID: - case TYPE_CODE_ERROR: - case TYPE_CODE_CHAR: - case TYPE_CODE_BOOL: - case TYPE_CODE_SET: - case TYPE_CODE_RANGE: - case TYPE_CODE_STRING: - case TYPE_CODE_COMPLEX: - case TYPE_CODE_TYPEDEF: - /* These types need no prefix. They are listed here so that - gcc -Wall will reveal any types that haven't been handled. */ - break; - default: - error (_("type not handled in pascal_type_print_varspec_prefix()")); + gdb_printf (stream, "("); + gdb_printf (stream, "array "); + if (type->target_type ()->length () > 0 + && type->bounds ()->high.is_constant ()) + gdb_printf (stream, "[%s..%s] ", + plongest (type->bounds ()->low.const_val ()), + plongest (type->bounds ()->high.const_val ())); + gdb_printf (stream, "of "); break; } } -static void -pascal_print_func_args (struct type *type, struct ui_file *stream) +/* See p-lang.h. */ + +void +pascal_language::print_func_args (struct type *type, struct ui_file *stream, + const struct type_print_options *flags) const { - int i, len = TYPE_NFIELDS (type); + int i, len = type->num_fields (); if (len) { - fprintf_filtered (stream, "("); + gdb_printf (stream, "("); } for (i = 0; i < len; i++) { if (i > 0) { - fputs_filtered (", ", stream); - wrap_here (" "); + gdb_puts (", ", stream); + stream->wrap_here (4); } /* Can we find if it is a var parameter ?? - if ( TYPE_FIELD(type, i) == ) - { - fprintf_filtered (stream, "var "); - } */ - pascal_print_type (TYPE_FIELD_TYPE (type, i), "" /* TYPE_FIELD_NAME - seems invalid! */ - ,stream, -1, 0); + if ( TYPE_FIELD(type, i) == ) + { + gdb_printf (stream, "var "); + } */ + print_type (type->field (i).type (), "" /* TYPE_FIELD_NAME + seems invalid! */ + ,stream, -1, 0, flags); } if (len) { - fprintf_filtered (stream, ")"); + gdb_printf (stream, ")"); + } +} + +/* See p-lang.h. */ + +void +pascal_language::type_print_func_varspec_suffix (struct type *type, + struct ui_file *stream, + int show, int passed_a_ptr, + int demangled_args, + const struct type_print_options *flags) const +{ + if (type->target_type () == NULL + || type->target_type ()->code () != TYPE_CODE_VOID) + { + gdb_printf (stream, " : "); + type_print_varspec_prefix (type->target_type (), + stream, 0, 0, flags); + + if (type->target_type () == NULL) + type_print_unknown_return_type (stream); + else + type_print_base (type->target_type (), stream, show, 0, + flags); + + type_print_varspec_suffix (type->target_type (), stream, 0, + passed_a_ptr, 0, flags); } } -/* Print any array sizes, function arguments or close parentheses - needed after the variable name (to describe its type). - Args work like pascal_type_print_varspec_prefix. */ +/* See p-lang.h. */ -static void -pascal_type_print_varspec_suffix (struct type *type, struct ui_file *stream, - int show, int passed_a_ptr, - int demangled_args) +void +pascal_language::type_print_varspec_suffix (struct type *type, + struct ui_file *stream, + int show, int passed_a_ptr, + int demangled_args, + const struct type_print_options *flags) const { if (type == 0) return; - if (TYPE_NAME (type) && show <= 0) + if (type->name () && show <= 0) return; QUIT; - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_ARRAY: if (passed_a_ptr) - fprintf_filtered (stream, ")"); + gdb_printf (stream, ")"); break; case TYPE_CODE_METHOD: if (passed_a_ptr) - fprintf_filtered (stream, ")"); - pascal_type_print_method_args ("", - "", - stream); - if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID) - { - fprintf_filtered (stream, " : "); - pascal_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), - stream, 0, 0); - pascal_type_print_base (TYPE_TARGET_TYPE (type), stream, show, 0); - pascal_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, - passed_a_ptr, 0); - } + gdb_printf (stream, ")"); + type_print_method_args ("", "", stream); + type_print_func_varspec_suffix (type, stream, show, + passed_a_ptr, 0, flags); break; case TYPE_CODE_PTR: case TYPE_CODE_REF: - pascal_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), - stream, 0, 1, 0); + type_print_varspec_suffix (type->target_type (), + stream, 0, 1, 0, flags); break; case TYPE_CODE_FUNC: if (passed_a_ptr) - fprintf_filtered (stream, ")"); + gdb_printf (stream, ")"); if (!demangled_args) - pascal_print_func_args (type, stream); - if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID) - { - fprintf_filtered (stream, " : "); - pascal_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), - stream, 0, 0); - pascal_type_print_base (TYPE_TARGET_TYPE (type), stream, show, 0); - pascal_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, - passed_a_ptr, 0); - } - break; - - case TYPE_CODE_UNDEF: - case TYPE_CODE_STRUCT: - case TYPE_CODE_UNION: - case TYPE_CODE_ENUM: - case TYPE_CODE_INT: - case TYPE_CODE_FLT: - case TYPE_CODE_VOID: - case TYPE_CODE_ERROR: - case TYPE_CODE_CHAR: - case TYPE_CODE_BOOL: - case TYPE_CODE_SET: - case TYPE_CODE_RANGE: - case TYPE_CODE_STRING: - case TYPE_CODE_COMPLEX: - case TYPE_CODE_TYPEDEF: - /* These types do not need a suffix. They are listed so that - gcc -Wall will report types that may not have been considered. */ - break; - default: - error (_("type not handled in pascal_type_print_varspec_suffix()")); + print_func_args (type, stream, flags); + type_print_func_varspec_suffix (type, stream, show, + passed_a_ptr, 0, flags); break; } } -/* Print the name of the type (or the ultimate pointer target, - function value or array element), or the description of a - structure or union. - - SHOW positive means print details about the type (e.g. enum values), - and print structure elements passing SHOW - 1 for show. - SHOW negative means just print the type name or struct tag if there is one. - If there is no name, print something sensible but concise like - "struct {...}". - SHOW zero means just print the type name or struct tag if there is one. - If there is no name, print something sensible but not as concise like - "struct {int x; int y;}". - - LEVEL is the number of spaces to indent by. - We increase it for some recursive calls. */ +/* See p-lang.h. */ void -pascal_type_print_base (struct type *type, struct ui_file *stream, int show, - int level) +pascal_language::type_print_base (struct type *type, struct ui_file *stream, int show, + int level, const struct type_print_options *flags) const { int i; int len; @@ -448,102 +373,94 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, section_type; QUIT; - wrap_here (" "); + stream->wrap_here (4); if (type == NULL) { - fputs_filtered ("", stream); + fputs_styled ("", metadata_style.style (), stream); return; } /* void pointer */ - if ((TYPE_CODE (type) == TYPE_CODE_PTR) - && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)) + if ((type->code () == TYPE_CODE_PTR) + && (type->target_type ()->code () == TYPE_CODE_VOID)) { - fputs_filtered (TYPE_NAME (type) ? TYPE_NAME (type) : "pointer", - stream); + gdb_puts (type->name () ? type->name () : "pointer", + stream); return; } /* When SHOW is zero or less, and there is a valid type name, then always just print the type name directly from the type. */ if (show <= 0 - && TYPE_NAME (type) != NULL) + && type->name () != NULL) { - fputs_filtered (TYPE_NAME (type), stream); + gdb_puts (type->name (), stream); return; } - CHECK_TYPEDEF (type); + type = check_typedef (type); - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_TYPEDEF: case TYPE_CODE_PTR: case TYPE_CODE_REF: - /* case TYPE_CODE_FUNC: - case TYPE_CODE_METHOD: */ - pascal_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level); + type_print_base (type->target_type (), stream, show, level, + flags); break; case TYPE_CODE_ARRAY: - /* pascal_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), - stream, 0, 0); - pascal_type_print_base (TYPE_TARGET_TYPE (type), - stream, show, level); - pascal_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), - stream, 0, 0, 0); */ - pascal_print_type (TYPE_TARGET_TYPE (type), NULL, stream, 0, 0); + print_type (type->target_type (), NULL, stream, 0, 0, flags); break; case TYPE_CODE_FUNC: case TYPE_CODE_METHOD: - /* - pascal_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level); - only after args !! */ break; case TYPE_CODE_STRUCT: - if (TYPE_TAG_NAME (type) != NULL) + if (type->name () != NULL) { - fputs_filtered (TYPE_TAG_NAME (type), stream); - fputs_filtered (" = ", stream); + gdb_puts (type->name (), stream); + gdb_puts (" = ", stream); } if (HAVE_CPLUS_STRUCT (type)) { - fprintf_filtered (stream, "class "); + gdb_printf (stream, "class "); } else { - fprintf_filtered (stream, "record "); + gdb_printf (stream, "record "); } goto struct_union; case TYPE_CODE_UNION: - if (TYPE_TAG_NAME (type) != NULL) + if (type->name () != NULL) { - fputs_filtered (TYPE_TAG_NAME (type), stream); - fputs_filtered (" = ", stream); + gdb_puts (type->name (), stream); + gdb_puts (" = ", stream); } - fprintf_filtered (stream, "case of "); + gdb_printf (stream, "case of "); struct_union: - wrap_here (" "); + stream->wrap_here (4); if (show < 0) { /* If we just printed a tag name, no need to print anything else. */ - if (TYPE_TAG_NAME (type) == NULL) - fprintf_filtered (stream, "{...}"); + if (type->name () == NULL) + gdb_printf (stream, "{...}"); } - else if (show > 0 || TYPE_TAG_NAME (type) == NULL) + else if (show > 0 || type->name () == NULL) { - pascal_type_print_derivation_info (stream, type); + type_print_derivation_info (stream, type); - fprintf_filtered (stream, "\n"); - if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0)) + gdb_printf (stream, "\n"); + if ((type->num_fields () == 0) && (TYPE_NFN_FIELDS (type) == 0)) { - if (TYPE_STUB (type)) - fprintfi_filtered (level + 4, stream, "\n"); + if (type->is_stub ()) + gdb_printf (stream, "%*s\n", + level + 4, ""); else - fprintfi_filtered (level + 4, stream, "\n"); + gdb_printf (stream, "%*s\n", + level + 4, ""); } /* Start off with no specific section type, so we can print @@ -555,17 +472,17 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, /* If there is a base class for this type, do not print the field that it occupies. */ - len = TYPE_NFIELDS (type); + len = type->num_fields (); for (i = TYPE_N_BASECLASSES (type); i < len; i++) { QUIT; /* Don't print out virtual function table. */ - if ((strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0) - && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5])) + if ((startswith (type->field (i).name (), "_vptr")) + && is_cplus_marker ((type->field (i).name ())[5])) continue; /* If this is a pascal object or class we can print the - various section labels. */ + various section labels. */ if (HAVE_CPLUS_STRUCT (type)) { @@ -574,8 +491,8 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, if (section_type != s_protected) { section_type = s_protected; - fprintfi_filtered (level + 2, stream, - "protected\n"); + gdb_printf (stream, "%*sprotected\n", + level + 2, ""); } } else if (TYPE_FIELD_PRIVATE (type, i)) @@ -583,7 +500,8 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, if (section_type != s_private) { section_type = s_private; - fprintfi_filtered (level + 2, stream, "private\n"); + gdb_printf (stream, "%*sprivate\n", + level + 2, ""); } } else @@ -591,18 +509,19 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, if (section_type != s_public) { section_type = s_public; - fprintfi_filtered (level + 2, stream, "public\n"); + gdb_printf (stream, "%*spublic\n", + level + 2, ""); } } } - print_spaces_filtered (level + 4, stream); - if (field_is_static (&TYPE_FIELD (type, i))) - fprintf_filtered (stream, "static "); - pascal_print_type (TYPE_FIELD_TYPE (type, i), - TYPE_FIELD_NAME (type, i), - stream, show - 1, level + 4); - if (!field_is_static (&TYPE_FIELD (type, i)) + print_spaces (level + 4, stream); + if (type->field (i).is_static ()) + gdb_printf (stream, "static "); + print_type (type->field (i).type (), + type->field (i).name (), + stream, show - 1, level + 4, flags); + if (!type->field (i).is_static () && TYPE_FIELD_PACKED (type, i)) { /* It is a bitfield. This code does not attempt @@ -610,16 +529,16 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, unnamed fields. This would lead to misleading results if the compiler does not put out fields for such things (I don't know what it does). */ - fprintf_filtered (stream, " : %d", - TYPE_FIELD_BITSIZE (type, i)); + gdb_printf (stream, " : %d", + TYPE_FIELD_BITSIZE (type, i)); } - fprintf_filtered (stream, ";\n"); + gdb_printf (stream, ";\n"); } /* If there are both fields and methods, put a space between. */ len = TYPE_NFN_FIELDS (type); if (len && section_type != s_none) - fprintf_filtered (stream, "\n"); + gdb_printf (stream, "\n"); /* Object pascal: print out the methods. */ @@ -630,14 +549,14 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i); /* this is GNU C++ specific - how can we know constructor/destructor? - It might work for GNU pascal. */ + how can we know constructor/destructor? + It might work for GNU pascal. */ for (j = 0; j < len2; j++) { const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); - int is_constructor = (strncmp (physname, "__ct__", 6) == 0); - int is_destructor = (strncmp (physname, "__dt__", 6) == 0); + int is_constructor = (startswith (physname, "__ct__")); + int is_destructor = (startswith (physname, "__dt__")); QUIT; if (TYPE_FN_FIELD_PROTECTED (f, j)) @@ -645,8 +564,8 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, if (section_type != s_protected) { section_type = s_protected; - fprintfi_filtered (level + 2, stream, - "protected\n"); + gdb_printf (stream, "%*sprotected\n", + level + 2, ""); } } else if (TYPE_FN_FIELD_PRIVATE (f, j)) @@ -654,7 +573,8 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, if (section_type != s_private) { section_type = s_private; - fprintfi_filtered (level + 2, stream, "private\n"); + gdb_printf (stream, "%*sprivate\n", + level + 2, ""); } } else @@ -662,153 +582,153 @@ pascal_type_print_base (struct type *type, struct ui_file *stream, int show, if (section_type != s_public) { section_type = s_public; - fprintfi_filtered (level + 2, stream, "public\n"); + gdb_printf (stream, "%*spublic\n", + level + 2, ""); } } - print_spaces_filtered (level + 4, stream); + print_spaces (level + 4, stream); if (TYPE_FN_FIELD_STATIC_P (f, j)) - fprintf_filtered (stream, "static "); - if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0) + gdb_printf (stream, "static "); + if (TYPE_FN_FIELD_TYPE (f, j)->target_type () == 0) { /* Keep GDB from crashing here. */ - fprintf_filtered (stream, " %s;\n", - TYPE_FN_FIELD_PHYSNAME (f, j)); + gdb_printf (stream, " %s;\n", + TYPE_FN_FIELD_PHYSNAME (f, j)); break; } if (is_constructor) { - fprintf_filtered (stream, "constructor "); + gdb_printf (stream, "constructor "); } else if (is_destructor) { - fprintf_filtered (stream, "destructor "); + gdb_printf (stream, "destructor "); } - else if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) != 0 - && TYPE_CODE (TYPE_TARGET_TYPE ( - TYPE_FN_FIELD_TYPE (f, j))) != TYPE_CODE_VOID) + else if (TYPE_FN_FIELD_TYPE (f, j)->target_type () != 0 + && (TYPE_FN_FIELD_TYPE(f, j)->target_type ()->code () + != TYPE_CODE_VOID)) { - fprintf_filtered (stream, "function "); + gdb_printf (stream, "function "); } else { - fprintf_filtered (stream, "procedure "); + gdb_printf (stream, "procedure "); } /* This does not work, no idea why !! */ - pascal_type_print_method_args (physname, - method_name, - stream); + type_print_method_args (physname, method_name, stream); - if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) != 0 - && TYPE_CODE (TYPE_TARGET_TYPE ( - TYPE_FN_FIELD_TYPE (f, j))) != TYPE_CODE_VOID) + if (TYPE_FN_FIELD_TYPE (f, j)->target_type () != 0 + && (TYPE_FN_FIELD_TYPE(f, j)->target_type ()->code () + != TYPE_CODE_VOID)) { - fputs_filtered (" : ", stream); - type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)), + gdb_puts (" : ", stream); + type_print (TYPE_FN_FIELD_TYPE (f, j)->target_type (), "", stream, -1); } if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) - fprintf_filtered (stream, "; virtual"); + gdb_printf (stream, "; virtual"); - fprintf_filtered (stream, ";\n"); + gdb_printf (stream, ";\n"); } } - fprintfi_filtered (level, stream, "end"); + gdb_printf (stream, "%*send", level, ""); } break; case TYPE_CODE_ENUM: - if (TYPE_TAG_NAME (type) != NULL) + if (type->name () != NULL) { - fputs_filtered (TYPE_TAG_NAME (type), stream); + gdb_puts (type->name (), stream); if (show > 0) - fputs_filtered (" ", stream); + gdb_puts (" ", stream); } /* enum is just defined by - type enume_name = (enum_member1,enum_member2,...) */ - fprintf_filtered (stream, " = "); - wrap_here (" "); + type enume_name = (enum_member1,enum_member2,...) */ + gdb_printf (stream, " = "); + stream->wrap_here (4); if (show < 0) { /* If we just printed a tag name, no need to print anything else. */ - if (TYPE_TAG_NAME (type) == NULL) - fprintf_filtered (stream, "(...)"); + if (type->name () == NULL) + gdb_printf (stream, "(...)"); } - else if (show > 0 || TYPE_TAG_NAME (type) == NULL) + else if (show > 0 || type->name () == NULL) { - fprintf_filtered (stream, "("); - len = TYPE_NFIELDS (type); + gdb_printf (stream, "("); + len = type->num_fields (); lastval = 0; for (i = 0; i < len; i++) { QUIT; if (i) - fprintf_filtered (stream, ", "); - wrap_here (" "); - fputs_filtered (TYPE_FIELD_NAME (type, i), stream); - if (lastval != TYPE_FIELD_ENUMVAL (type, i)) + gdb_printf (stream, ", "); + stream->wrap_here (4); + gdb_puts (type->field (i).name (), stream); + if (lastval != type->field (i).loc_enumval ()) { - fprintf_filtered (stream, - " := %s", - plongest (TYPE_FIELD_ENUMVAL (type, i))); - lastval = TYPE_FIELD_ENUMVAL (type, i); + gdb_printf (stream, + " := %s", + plongest (type->field (i).loc_enumval ())); + lastval = type->field (i).loc_enumval (); } lastval++; } - fprintf_filtered (stream, ")"); + gdb_printf (stream, ")"); } break; case TYPE_CODE_VOID: - fprintf_filtered (stream, "void"); + gdb_printf (stream, "void"); break; case TYPE_CODE_UNDEF: - fprintf_filtered (stream, "record "); + gdb_printf (stream, "record "); break; case TYPE_CODE_ERROR: - fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type)); + gdb_printf (stream, "%s", TYPE_ERROR_NAME (type)); break; /* this probably does not work for enums. */ case TYPE_CODE_RANGE: { - struct type *target = TYPE_TARGET_TYPE (type); + struct type *target = type->target_type (); - print_type_scalar (target, TYPE_LOW_BOUND (type), stream); - fputs_filtered ("..", stream); - print_type_scalar (target, TYPE_HIGH_BOUND (type), stream); + print_type_scalar (target, type->bounds ()->low.const_val (), stream); + gdb_puts ("..", stream); + print_type_scalar (target, type->bounds ()->high.const_val (), stream); } break; case TYPE_CODE_SET: - fputs_filtered ("set of ", stream); - pascal_print_type (TYPE_INDEX_TYPE (type), "", stream, - show - 1, level); + gdb_puts ("set of ", stream); + print_type (type->index_type (), "", stream, + show - 1, level, flags); break; case TYPE_CODE_STRING: - fputs_filtered ("String", stream); + gdb_puts ("String", stream); break; default: /* Handle types not explicitly handled by the other cases, - such as fundamental types. For these, just print whatever - the type name is, as recorded in the type itself. If there - is no type name, then complain. */ - if (TYPE_NAME (type) != NULL) + such as fundamental types. For these, just print whatever + the type name is, as recorded in the type itself. If there + is no type name, then complain. */ + if (type->name () != NULL) { - fputs_filtered (TYPE_NAME (type), stream); + gdb_puts (type->name (), stream); } else { /* At least for dump_symtab, it is important that this not be an error (). */ - fprintf_filtered (stream, "", - TYPE_CODE (type)); + fprintf_styled (stream, metadata_style.style (), + "", + type->code ()); } break; }