X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ff-typeprint.c;h=31b96a371f1bf3648fab02aed1ea57d6245e637e;hb=9c12d5d39ad5729160e34c306ae56e0bb66e6b52;hp=12b2865ee70355ca09b902640b255bc45cd3e29d;hpb=30727aa6d12fb866494020c0b62ab265a2bdcdfe;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/f-typeprint.c b/gdb/f-typeprint.c index 12b2865ee7..31b96a371f 100644 --- a/gdb/f-typeprint.c +++ b/gdb/f-typeprint.c @@ -1,5 +1,8 @@ /* Support for printing Fortran types for GDB, the GNU debugger. - Copyright 1986, 1988, 1989, 1991, 1993, 1994 Free Software Foundation, Inc. + + Copyright (C) 1986, 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1998, + 2000, 2001, 2002, 2003, 2006 Free Software Foundation, Inc. + Contributed by Motorola. Adapted from the C version by Farooq Butt (fmbutt@engage.sps.mot.com). @@ -17,11 +20,11 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" -#include "obstack.h" +#include "gdb_obstack.h" #include "bfd.h" #include "symtab.h" #include "gdbtypes.h" @@ -29,44 +32,34 @@ #include "value.h" #include "gdbcore.h" #include "target.h" -#include "command.h" -#include "gdbcmd.h" -#include "language.h" -#include "demangle.h" #include "f-lang.h" -#include "typeprint.h" -#include "frame.h" /* ??? */ #include "gdb_string.h" #include #if 0 /* Currently unused */ -static void f_type_print_args PARAMS ((struct type *, GDB_FILE *)); +static void f_type_print_args (struct type *, struct ui_file *); #endif -static void print_equivalent_f77_float_type PARAMS ((struct type *, - GDB_FILE *)); +static void print_equivalent_f77_float_type (int level, struct type *, + struct ui_file *); -static void f_type_print_varspec_suffix PARAMS ((struct type *, GDB_FILE *, - int, int, int)); +static void f_type_print_varspec_suffix (struct type *, struct ui_file *, + int, int, int); -void f_type_print_varspec_prefix PARAMS ((struct type *, GDB_FILE *, - int, int)); +void f_type_print_varspec_prefix (struct type *, struct ui_file *, + int, int); -void f_type_print_base PARAMS ((struct type *, GDB_FILE *, int, int)); +void f_type_print_base (struct type *, struct ui_file *, int, int); /* LEVEL is the depth to indent lines by. */ void -f_print_type (type, varstring, stream, show, level) - struct type *type; - char *varstring; - GDB_FILE *stream; - int show; - int level; +f_print_type (struct type *type, char *varstring, struct ui_file *stream, + int show, int level) { - register enum type_code code; + enum type_code code; int demangled_args; f_type_print_base (type, stream, show, level); @@ -103,11 +96,8 @@ f_print_type (type, varstring, stream, show, level) SHOW is always zero on recursive calls. */ void -f_type_print_varspec_prefix (type, stream, show, passed_a_ptr) - struct type *type; - GDB_FILE *stream; - int show; - int passed_a_ptr; +f_type_print_varspec_prefix (struct type *type, struct ui_file *stream, + int show, int passed_a_ptr) { if (type == 0) return; @@ -158,55 +148,13 @@ f_type_print_varspec_prefix (type, stream, show, passed_a_ptr) } } -#if 0 /* Currently unused */ - -static void -f_type_print_args (type, stream) - struct type *type; - GDB_FILE *stream; -{ - int i; - struct type **args; - - fprintf_filtered (stream, "("); - args = TYPE_ARG_TYPES (type); - if (args != NULL) - { - if (args[1] == NULL) - { - fprintf_filtered (stream, "..."); - } - else - { - for (i = 1; args[i] != NULL && args[i]->code != TYPE_CODE_VOID; i++) - { - f_print_type (args[i], "", stream, -1, 0); - if (args[i + 1] == NULL) - fprintf_filtered (stream, "..."); - else if (args[i + 1]->code != TYPE_CODE_VOID) - { - fprintf_filtered (stream, ","); - wrap_here (" "); - } - } - } - } - fprintf_filtered (stream, ")"); -} - -#endif /* 0 */ - /* Print any array sizes, function arguments or close parentheses needed after the variable name (to describe its type). Args work like c_type_print_varspec_prefix. */ static void -f_type_print_varspec_suffix (type, stream, show, passed_a_ptr, demangled_args) - struct type *type; - GDB_FILE *stream; - int show; - int passed_a_ptr; - int demangled_args; +f_type_print_varspec_suffix (struct type *type, struct ui_file *stream, + int show, int passed_a_ptr, int demangled_args) { int upper_bound, lower_bound; int lower_bound_was_default = 0; @@ -312,15 +260,14 @@ f_type_print_varspec_suffix (type, stream, show, passed_a_ptr, demangled_args) } static void -print_equivalent_f77_float_type (type, stream) - struct type *type; - GDB_FILE *stream; +print_equivalent_f77_float_type (int level, struct type *type, + struct ui_file *stream) { /* Override type name "float" and make it the appropriate real. XLC stupidly outputs -12 as a type for real when it really should be outputting -18 */ - fprintf_filtered (stream, "real*%d", TYPE_LENGTH (type)); + fprintfi_filtered (level, stream, "real*%d", TYPE_LENGTH (type)); } /* Print the name of the type (or the ultimate pointer target, @@ -337,15 +284,14 @@ print_equivalent_f77_float_type (type, stream) We increase it for some recursive calls. */ void -f_type_print_base (type, stream, show, level) - struct type *type; - GDB_FILE *stream; - int show; - int level; +f_type_print_base (struct type *type, struct ui_file *stream, int show, + int level) { int retcode; int upper_bound; + int index; + QUIT; wrap_here (" "); @@ -361,7 +307,7 @@ f_type_print_base (type, stream, show, level) if ((show <= 0) && (TYPE_NAME (type) != NULL)) { if (TYPE_CODE (type) == TYPE_CODE_FLT) - print_equivalent_f77_float_type (type, stream); + print_equivalent_f77_float_type (level, type, stream); else fputs_filtered (TYPE_NAME (type), stream); return; @@ -386,26 +332,31 @@ f_type_print_base (type, stream, show, level) f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level); break; + case TYPE_CODE_REF: + fprintf_filtered (stream, "REF TO -> ( "); + f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level); + break; + case TYPE_CODE_VOID: - fprintf_filtered (stream, "VOID"); + fprintfi_filtered (level, stream, "VOID"); break; case TYPE_CODE_UNDEF: - fprintf_filtered (stream, "struct "); + fprintfi_filtered (level, stream, "struct "); break; case TYPE_CODE_ERROR: - fprintf_filtered (stream, ""); + fprintfi_filtered (level, stream, ""); break; case TYPE_CODE_RANGE: /* This should not occur */ - fprintf_filtered (stream, ""); + fprintfi_filtered (level, stream, ""); break; case TYPE_CODE_CHAR: /* Override name "char" and make it "character" */ - fprintf_filtered (stream, "character"); + fprintfi_filtered (level, stream, "character"); break; case TYPE_CODE_INT: @@ -413,25 +364,25 @@ f_type_print_base (type, stream, show, level) through as TYPE_CODE_INT since dbxstclass.h is so C-oriented, we must change these to "character" from "char". */ - if (STREQ (TYPE_NAME (type), "char")) - fprintf_filtered (stream, "character"); + if (strcmp (TYPE_NAME (type), "char") == 0) + fprintfi_filtered (level, stream, "character"); else goto default_case; break; case TYPE_CODE_COMPLEX: - fprintf_filtered (stream, "complex*%d", TYPE_LENGTH (type)); + fprintfi_filtered (level, stream, "complex*%d", TYPE_LENGTH (type)); break; case TYPE_CODE_FLT: - print_equivalent_f77_float_type (type, stream); + print_equivalent_f77_float_type (level, type, stream); break; case TYPE_CODE_STRING: /* Strings may have dynamic upperbounds (lengths) like arrays. */ if (TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED) - fprintf_filtered (stream, "character*(*)"); + fprintfi_filtered (level, stream, "character*(*)"); else { retcode = f77_get_dynamic_upperbound (type, &upper_bound); @@ -443,6 +394,21 @@ f_type_print_base (type, stream, show, level) } break; + case TYPE_CODE_STRUCT: + fprintfi_filtered (level, stream, "Type "); + fputs_filtered (TYPE_TAG_NAME (type), stream); + fputs_filtered ("\n", stream); + for (index = 0; index < TYPE_NFIELDS (type); index++) + { + f_print_type (TYPE_FIELD_TYPE (type, index), "", stream, show, level + 4); + fputs_filtered (" :: ", stream); + fputs_filtered (TYPE_FIELD_NAME (type, index), stream); + fputs_filtered ("\n", stream); + } + fprintfi_filtered (level, stream, "End Type "); + fputs_filtered (TYPE_TAG_NAME (type), stream); + break; + default_case: default: /* Handle types not explicitly handled by the other cases, @@ -450,9 +416,9 @@ f_type_print_base (type, stream, show, level) the type name is, as recorded in the type itself. If there is no type name, then complain. */ if (TYPE_NAME (type) != NULL) - fputs_filtered (TYPE_NAME (type), stream); + fprintfi_filtered (level, stream, "%s", TYPE_NAME (type)); else - error ("Invalid type code (%d) in symbol table.", TYPE_CODE (type)); + error (_("Invalid type code (%d) in symbol table."), TYPE_CODE (type)); break; } }