| /* C language support routines for GDB, the GNU debugger. |
| Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002 |
| Free Software Foundation, Inc. |
| |
| This file is part of GDB. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| 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. */ |
| |
| #include "defs.h" |
| #include "symtab.h" |
| #include "gdbtypes.h" |
| #include "expression.h" |
| #include "parser-defs.h" |
| #include "language.h" |
| #include "c-lang.h" |
| #include "valprint.h" |
| |
| extern void _initialize_c_language (void); |
| static void c_emit_char (int c, struct ui_file * stream, int quoter); |
| |
| /* Print the character C on STREAM as part of the contents of a literal |
| string whose delimiter is QUOTER. Note that that format for printing |
| characters and strings is language specific. */ |
| |
| static void |
| c_emit_char (register int c, struct ui_file *stream, int quoter) |
| { |
| c &= 0xFF; /* Avoid sign bit follies */ |
| |
| if (PRINT_LITERAL_FORM (c)) |
| { |
| if (c == '\\' || c == quoter) |
| { |
| fputs_filtered ("\\", stream); |
| } |
| fprintf_filtered (stream, "%c", c); |
| } |
| else |
| { |
| switch (c) |
| { |
| case '\n': |
| fputs_filtered ("\\n", stream); |
| break; |
| case '\b': |
| fputs_filtered ("\\b", stream); |
| break; |
| case '\t': |
| fputs_filtered ("\\t", stream); |
| break; |
| case '\f': |
| fputs_filtered ("\\f", stream); |
| break; |
| case '\r': |
| fputs_filtered ("\\r", stream); |
| break; |
| case '\013': |
| fputs_filtered ("\\v", stream); |
| break; |
| case '\033': |
| fputs_filtered ("\\e", stream); |
| break; |
| case '\007': |
| fputs_filtered ("\\a", stream); |
| break; |
| case '\0': |
| fputs_filtered ("\\0", stream); |
| break; |
| default: |
| fprintf_filtered (stream, "\\%.3o", (unsigned int) c); |
| break; |
| } |
| } |
| } |
| |
| void |
| c_printchar (int c, struct ui_file *stream) |
| { |
| fputc_filtered ('\'', stream); |
| LA_EMIT_CHAR (c, stream, '\''); |
| fputc_filtered ('\'', stream); |
| } |
| |
| /* Print the character string STRING, printing at most LENGTH characters. |
| LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes |
| long. Printing stops early if the number hits print_max; repeat counts are |
| printed as appropriate. Print ellipses at the end if we had to stop before |
| printing LENGTH characters, or if FORCE_ELLIPSES. */ |
| |
| void |
| c_printstr (struct ui_file *stream, char *string, unsigned int length, |
| int width, int force_ellipses) |
| { |
| register unsigned int i; |
| unsigned int things_printed = 0; |
| int in_quotes = 0; |
| int need_comma = 0; |
| extern int inspect_it; |
| |
| /* If the string was not truncated due to `set print elements', and |
| the last byte of it is a null, we don't print that, in traditional C |
| style. */ |
| if (!force_ellipses |
| && length > 0 |
| && (extract_unsigned_integer (string + (length - 1) * width, width) |
| == '\0')) |
| length--; |
| |
| if (length == 0) |
| { |
| fputs_filtered ("\"\"", stream); |
| return; |
| } |
| |
| for (i = 0; i < length && things_printed < print_max; ++i) |
| { |
| /* Position of the character we are examining |
| to see whether it is repeated. */ |
| unsigned int rep1; |
| /* Number of repetitions we have detected so far. */ |
| unsigned int reps; |
| unsigned long current_char; |
| |
| QUIT; |
| |
| if (need_comma) |
| { |
| fputs_filtered (", ", stream); |
| need_comma = 0; |
| } |
| |
| current_char = extract_unsigned_integer (string + i * width, width); |
| |
| rep1 = i + 1; |
| reps = 1; |
| while (rep1 < length |
| && extract_unsigned_integer (string + rep1 * width, width) |
| == current_char) |
| { |
| ++rep1; |
| ++reps; |
| } |
| |
| if (reps > repeat_count_threshold) |
| { |
| if (in_quotes) |
| { |
| if (inspect_it) |
| fputs_filtered ("\\\", ", stream); |
| else |
| fputs_filtered ("\", ", stream); |
| in_quotes = 0; |
| } |
| LA_PRINT_CHAR (current_char, stream); |
| fprintf_filtered (stream, " <repeats %u times>", reps); |
| i = rep1 - 1; |
| things_printed += repeat_count_threshold; |
| need_comma = 1; |
| } |
| else |
| { |
| if (!in_quotes) |
| { |
| if (inspect_it) |
| fputs_filtered ("\\\"", stream); |
| else |
| fputs_filtered ("\"", stream); |
| in_quotes = 1; |
| } |
| LA_EMIT_CHAR (current_char, stream, '"'); |
| ++things_printed; |
| } |
| } |
| |
| /* Terminate the quotes if necessary. */ |
| if (in_quotes) |
| { |
| if (inspect_it) |
| fputs_filtered ("\\\"", stream); |
| else |
| fputs_filtered ("\"", stream); |
| } |
| |
| if (force_ellipses || i < length) |
| fputs_filtered ("...", stream); |
| } |
| |
| /* Create a fundamental C type using default reasonable for the current |
| target machine. |
| |
| Some object/debugging file formats (DWARF version 1, COFF, etc) do not |
| define fundamental types such as "int" or "double". Others (stabs or |
| DWARF version 2, etc) do define fundamental types. For the formats which |
| don't provide fundamental types, gdb can create such types using this |
| function. |
| |
| FIXME: Some compilers distinguish explicitly signed integral types |
| (signed short, signed int, signed long) from "regular" integral types |
| (short, int, long) in the debugging information. There is some dis- |
| agreement as to how useful this feature is. In particular, gcc does |
| not support this. Also, only some debugging formats allow the |
| distinction to be passed on to a debugger. For now, we always just |
| use "short", "int", or "long" as the type name, for both the implicit |
| and explicitly signed types. This also makes life easier for the |
| gdb test suite since we don't have to account for the differences |
| in output depending upon what the compiler and debugging format |
| support. We will probably have to re-examine the issue when gdb |
| starts taking it's fundamental type information directly from the |
| debugging information supplied by the compiler. fnf@cygnus.com */ |
| |
| struct type * |
| c_create_fundamental_type (struct objfile *objfile, int typeid) |
| { |
| register struct type *type = NULL; |
| |
| switch (typeid) |
| { |
| default: |
| /* FIXME: For now, if we are asked to produce a type not in this |
| language, create the equivalent of a C integer type with the |
| name "<?type?>". When all the dust settles from the type |
| reconstruction work, this should probably become an error. */ |
| type = init_type (TYPE_CODE_INT, |
| TARGET_INT_BIT / TARGET_CHAR_BIT, |
| 0, "<?type?>", objfile); |
| warning ("internal error: no C/C++ fundamental type %d", typeid); |
| break; |
| case FT_VOID: |
| type = init_type (TYPE_CODE_VOID, |
| TARGET_CHAR_BIT / TARGET_CHAR_BIT, |
| 0, "void", objfile); |
| break; |
| case FT_BOOLEAN: |
| type = init_type (TYPE_CODE_BOOL, |
| TARGET_CHAR_BIT / TARGET_CHAR_BIT, |
| 0, "bool", objfile); |
| break; |
| case FT_CHAR: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_CHAR_BIT / TARGET_CHAR_BIT, |
| TYPE_FLAG_NOSIGN, "char", objfile); |
| break; |
| case FT_SIGNED_CHAR: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_CHAR_BIT / TARGET_CHAR_BIT, |
| 0, "signed char", objfile); |
| break; |
| case FT_UNSIGNED_CHAR: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_CHAR_BIT / TARGET_CHAR_BIT, |
| TYPE_FLAG_UNSIGNED, "unsigned char", objfile); |
| break; |
| case FT_SHORT: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_SHORT_BIT / TARGET_CHAR_BIT, |
| 0, "short", objfile); |
| break; |
| case FT_SIGNED_SHORT: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_SHORT_BIT / TARGET_CHAR_BIT, |
| 0, "short", objfile); /* FIXME-fnf */ |
| break; |
| case FT_UNSIGNED_SHORT: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_SHORT_BIT / TARGET_CHAR_BIT, |
| TYPE_FLAG_UNSIGNED, "unsigned short", objfile); |
| break; |
| case FT_INTEGER: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_INT_BIT / TARGET_CHAR_BIT, |
| 0, "int", objfile); |
| break; |
| case FT_SIGNED_INTEGER: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_INT_BIT / TARGET_CHAR_BIT, |
| 0, "int", objfile); /* FIXME -fnf */ |
| break; |
| case FT_UNSIGNED_INTEGER: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_INT_BIT / TARGET_CHAR_BIT, |
| TYPE_FLAG_UNSIGNED, "unsigned int", objfile); |
| break; |
| case FT_LONG: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_LONG_BIT / TARGET_CHAR_BIT, |
| 0, "long", objfile); |
| break; |
| case FT_SIGNED_LONG: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_LONG_BIT / TARGET_CHAR_BIT, |
| 0, "long", objfile); /* FIXME -fnf */ |
| break; |
| case FT_UNSIGNED_LONG: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_LONG_BIT / TARGET_CHAR_BIT, |
| TYPE_FLAG_UNSIGNED, "unsigned long", objfile); |
| break; |
| case FT_LONG_LONG: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, |
| 0, "long long", objfile); |
| break; |
| case FT_SIGNED_LONG_LONG: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, |
| 0, "signed long long", objfile); |
| break; |
| case FT_UNSIGNED_LONG_LONG: |
| type = init_type (TYPE_CODE_INT, |
| TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, |
| TYPE_FLAG_UNSIGNED, "unsigned long long", objfile); |
| break; |
| case FT_FLOAT: |
| type = init_type (TYPE_CODE_FLT, |
| TARGET_FLOAT_BIT / TARGET_CHAR_BIT, |
| 0, "float", objfile); |
| break; |
| case FT_DBL_PREC_FLOAT: |
| type = init_type (TYPE_CODE_FLT, |
| TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, |
| 0, "double", objfile); |
| break; |
| case FT_EXT_PREC_FLOAT: |
| type = init_type (TYPE_CODE_FLT, |
| TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, |
| 0, "long double", objfile); |
| break; |
| case FT_TEMPLATE_ARG: |
| type = init_type (TYPE_CODE_TEMPLATE_ARG, |
| 0, |
| 0, "<template arg>", objfile); |
| break; |
| } |
| return (type); |
| } |
| |
| |
| /* Table mapping opcodes into strings for printing operators |
| and precedences of the operators. */ |
| |
| const struct op_print c_op_print_tab[] = |
| { |
| {",", BINOP_COMMA, PREC_COMMA, 0}, |
| {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, |
| {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, |
| {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, |
| {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0}, |
| {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0}, |
| {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0}, |
| {"==", BINOP_EQUAL, PREC_EQUAL, 0}, |
| {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, |
| {"<=", BINOP_LEQ, PREC_ORDER, 0}, |
| {">=", BINOP_GEQ, PREC_ORDER, 0}, |
| {">", BINOP_GTR, PREC_ORDER, 0}, |
| {"<", BINOP_LESS, PREC_ORDER, 0}, |
| {">>", BINOP_RSH, PREC_SHIFT, 0}, |
| {"<<", BINOP_LSH, PREC_SHIFT, 0}, |
| {"+", BINOP_ADD, PREC_ADD, 0}, |
| {"-", BINOP_SUB, PREC_ADD, 0}, |
| {"*", BINOP_MUL, PREC_MUL, 0}, |
| {"/", BINOP_DIV, PREC_MUL, 0}, |
| {"%", BINOP_REM, PREC_MUL, 0}, |
| {"@", BINOP_REPEAT, PREC_REPEAT, 0}, |
| {"-", UNOP_NEG, PREC_PREFIX, 0}, |
| {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, |
| {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0}, |
| {"*", UNOP_IND, PREC_PREFIX, 0}, |
| {"&", UNOP_ADDR, PREC_PREFIX, 0}, |
| {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, |
| {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, |
| {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, |
| {NULL, 0, 0, 0} |
| }; |
| |
| struct type **const (c_builtin_types[]) = |
| { |
| &builtin_type_int, |
| &builtin_type_long, |
| &builtin_type_short, |
| &builtin_type_char, |
| &builtin_type_float, |
| &builtin_type_double, |
| &builtin_type_void, |
| &builtin_type_long_long, |
| &builtin_type_signed_char, |
| &builtin_type_unsigned_char, |
| &builtin_type_unsigned_short, |
| &builtin_type_unsigned_int, |
| &builtin_type_unsigned_long, |
| &builtin_type_unsigned_long_long, |
| &builtin_type_long_double, |
| &builtin_type_complex, |
| &builtin_type_double_complex, |
| 0 |
| }; |
| |
| const struct language_defn c_language_defn = |
| { |
| "c", /* Language name */ |
| language_c, |
| c_builtin_types, |
| range_check_off, |
| type_check_off, |
| case_sensitive_on, |
| c_parse, |
| c_error, |
| evaluate_subexp_standard, |
| c_printchar, /* Print a character constant */ |
| c_printstr, /* Function to print string constant */ |
| c_emit_char, /* Print a single char */ |
| c_create_fundamental_type, /* Create fundamental type in this language */ |
| c_print_type, /* Print a type using appropriate syntax */ |
| c_val_print, /* Print a value using appropriate syntax */ |
| c_value_print, /* Print a top-level value */ |
| {"", "", "", ""}, /* Binary format info */ |
| {"0%lo", "0", "o", ""}, /* Octal format info */ |
| {"%ld", "", "d", ""}, /* Decimal format info */ |
| {"0x%lx", "0x", "x", ""}, /* Hex format info */ |
| c_op_print_tab, /* expression operators for printing */ |
| 1, /* c-style arrays */ |
| 0, /* String lower bound */ |
| &builtin_type_char, /* Type of string elements */ |
| LANG_MAGIC |
| }; |
| |
| struct type **const (cplus_builtin_types[]) = |
| { |
| &builtin_type_int, |
| &builtin_type_long, |
| &builtin_type_short, |
| &builtin_type_char, |
| &builtin_type_float, |
| &builtin_type_double, |
| &builtin_type_void, |
| &builtin_type_long_long, |
| &builtin_type_signed_char, |
| &builtin_type_unsigned_char, |
| &builtin_type_unsigned_short, |
| &builtin_type_unsigned_int, |
| &builtin_type_unsigned_long, |
| &builtin_type_unsigned_long_long, |
| &builtin_type_long_double, |
| &builtin_type_complex, |
| &builtin_type_double_complex, |
| &builtin_type_bool, |
| 0 |
| }; |
| |
| const struct language_defn cplus_language_defn = |
| { |
| "c++", /* Language name */ |
| language_cplus, |
| cplus_builtin_types, |
| range_check_off, |
| type_check_off, |
| case_sensitive_on, |
| c_parse, |
| c_error, |
| evaluate_subexp_standard, |
| c_printchar, /* Print a character constant */ |
| c_printstr, /* Function to print string constant */ |
| c_emit_char, /* Print a single char */ |
| c_create_fundamental_type, /* Create fundamental type in this language */ |
| c_print_type, /* Print a type using appropriate syntax */ |
| c_val_print, /* Print a value using appropriate syntax */ |
| c_value_print, /* Print a top-level value */ |
| {"", "", "", ""}, /* Binary format info */ |
| {"0%lo", "0", "o", ""}, /* Octal format info */ |
| {"%ld", "", "d", ""}, /* Decimal format info */ |
| {"0x%lx", "0x", "x", ""}, /* Hex format info */ |
| c_op_print_tab, /* expression operators for printing */ |
| 1, /* c-style arrays */ |
| 0, /* String lower bound */ |
| &builtin_type_char, /* Type of string elements */ |
| LANG_MAGIC |
| }; |
| |
| const struct language_defn asm_language_defn = |
| { |
| "asm", /* Language name */ |
| language_asm, |
| c_builtin_types, |
| range_check_off, |
| type_check_off, |
| case_sensitive_on, |
| c_parse, |
| c_error, |
| evaluate_subexp_standard, |
| c_printchar, /* Print a character constant */ |
| c_printstr, /* Function to print string constant */ |
| c_emit_char, /* Print a single char */ |
| c_create_fundamental_type, /* Create fundamental type in this language */ |
| c_print_type, /* Print a type using appropriate syntax */ |
| c_val_print, /* Print a value using appropriate syntax */ |
| c_value_print, /* Print a top-level value */ |
| {"", "", "", ""}, /* Binary format info */ |
| {"0%lo", "0", "o", ""}, /* Octal format info */ |
| {"%ld", "", "d", ""}, /* Decimal format info */ |
| {"0x%lx", "0x", "x", ""}, /* Hex format info */ |
| c_op_print_tab, /* expression operators for printing */ |
| 1, /* c-style arrays */ |
| 0, /* String lower bound */ |
| &builtin_type_char, /* Type of string elements */ |
| LANG_MAGIC |
| }; |
| |
| void |
| _initialize_c_language (void) |
| { |
| add_language (&c_language_defn); |
| add_language (&cplus_language_defn); |
| add_language (&asm_language_defn); |
| } |