/* C language support routines for GDB, the GNU debugger.
- Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000
- Free Software Foundation, Inc.
+
+ Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002,
+ 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GDB.
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 "symtab.h"
#include "language.h"
#include "c-lang.h"
#include "valprint.h"
+#include "macroscope.h"
+#include "gdb_assert.h"
+#include "charset.h"
+#include "gdb_string.h"
+#include "demangle.h"
+#include "cp-support.h"
extern void _initialize_c_language (void);
static void c_emit_char (int c, struct ui_file * stream, int quoter);
characters and strings is language specific. */
static void
-c_emit_char (register int c, struct ui_file *stream, int quoter)
+c_emit_char (int c, struct ui_file *stream, int quoter)
{
+ const char *escape;
+ int host_char;
+
c &= 0xFF; /* Avoid sign bit follies */
- if (PRINT_LITERAL_FORM (c))
+ escape = c_target_char_has_backslash_escape (c);
+ if (escape)
{
- if (c == '\\' || c == quoter)
- {
- fputs_filtered ("\\", stream);
- }
- fprintf_filtered (stream, "%c", c);
+ if (quoter == '"' && strcmp (escape, "0") == 0)
+ /* Print nulls embedded in double quoted strings as \000 to
+ prevent ambiguity. */
+ fprintf_filtered (stream, "\\000");
+ else
+ fprintf_filtered (stream, "\\%s", escape);
}
- else
+ else if (target_char_to_host (c, &host_char)
+ && host_char_print_literally (host_char))
{
- 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 '\033':
- fputs_filtered ("\\e", stream);
- break;
- case '\007':
- fputs_filtered ("\\a", stream);
- break;
- default:
- fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
- break;
- }
+ if (host_char == '\\' || host_char == quoter)
+ fputs_filtered ("\\", stream);
+ fprintf_filtered (stream, "%c", host_char);
}
+ else
+ fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
}
void
printing LENGTH characters, or if FORCE_ELLIPSES. */
void
-c_printstr (struct ui_file *stream, char *string, unsigned int length,
- int width, int force_ellipses)
+c_printstr (struct ui_file *stream, const gdb_byte *string,
+ unsigned int length, int width, int force_ellipses)
{
- register unsigned int i;
+ 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')
+ && (extract_unsigned_integer (string + (length - 1) * width, width)
+ == '\0'))
length--;
if (length == 0)
in_quotes = 0;
}
LA_PRINT_CHAR (current_char, stream);
- fprintf_filtered (stream, " <repeats %u times>", reps);
+ fprintf_filtered (stream, _(" <repeats %u times>"), reps);
i = rep1 - 1;
things_printed += repeat_count_threshold;
need_comma = 1;
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
+ starts taking its 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;
+ struct type *type = NULL;
switch (typeid)
{
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);
+ warning (_("internal error: no C/C++ fundamental type %d"), typeid);
break;
case FT_VOID:
type = init_type (TYPE_CODE_VOID,
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,
- 0, "char", objfile);
- TYPE_FLAGS (type) |= TYPE_FLAG_NOSIGN;
+ TYPE_FLAG_NOSIGN, "char", objfile);
break;
case FT_SIGNED_CHAR:
type = init_type (TYPE_CODE_INT,
TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
0, "long double", objfile);
break;
+ case FT_COMPLEX:
+ type = init_type (TYPE_CODE_FLT,
+ 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
+ 0, "complex float", objfile);
+ TYPE_TARGET_TYPE (type)
+ = init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
+ 0, "float", objfile);
+ break;
+ case FT_DBL_PREC_COMPLEX:
+ type = init_type (TYPE_CODE_FLT,
+ 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+ 0, "complex double", objfile);
+ TYPE_TARGET_TYPE (type)
+ = init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+ 0, "double", objfile);
+ break;
+ case FT_EXT_PREC_COMPLEX:
+ type = init_type (TYPE_CODE_FLT,
+ 2 * TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
+ 0, "complex long double", objfile);
+ TYPE_TARGET_TYPE (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);
}
\f
+/* Preprocessing and parsing C and C++ expressions. */
+
+
+/* When we find that lexptr (the global var defined in parse.c) is
+ pointing at a macro invocation, we expand the invocation, and call
+ scan_macro_expansion to save the old lexptr here and point lexptr
+ into the expanded text. When we reach the end of that, we call
+ end_macro_expansion to pop back to the value we saved here. The
+ macro expansion code promises to return only fully-expanded text,
+ so we don't need to "push" more than one level.
+
+ This is disgusting, of course. It would be cleaner to do all macro
+ expansion beforehand, and then hand that to lexptr. But we don't
+ really know where the expression ends. Remember, in a command like
+
+ (gdb) break *ADDRESS if CONDITION
+
+ we evaluate ADDRESS in the scope of the current frame, but we
+ evaluate CONDITION in the scope of the breakpoint's location. So
+ it's simply wrong to try to macro-expand the whole thing at once. */
+static char *macro_original_text;
+static char *macro_expanded_text;
+
+
+void
+scan_macro_expansion (char *expansion)
+{
+ /* We'd better not be trying to push the stack twice. */
+ gdb_assert (! macro_original_text);
+ gdb_assert (! macro_expanded_text);
+
+ /* Save the old lexptr value, so we can return to it when we're done
+ parsing the expanded text. */
+ macro_original_text = lexptr;
+ lexptr = expansion;
+
+ /* Save the expanded text, so we can free it when we're finished. */
+ macro_expanded_text = expansion;
+}
+
+
+int
+scanning_macro_expansion (void)
+{
+ return macro_original_text != 0;
+}
+
+
+void
+finished_macro_expansion (void)
+{
+ /* There'd better be something to pop back to, and we better have
+ saved a pointer to the start of the expanded text. */
+ gdb_assert (macro_original_text);
+ gdb_assert (macro_expanded_text);
+
+ /* Pop back to the original text. */
+ lexptr = macro_original_text;
+ macro_original_text = 0;
+
+ /* Free the expanded text. */
+ xfree (macro_expanded_text);
+ macro_expanded_text = 0;
+}
+
+
+static void
+scan_macro_cleanup (void *dummy)
+{
+ if (macro_original_text)
+ finished_macro_expansion ();
+}
+
+
+/* We set these global variables before calling c_parse, to tell it
+ how it to find macro definitions for the expression at hand. */
+macro_lookup_ftype *expression_macro_lookup_func;
+void *expression_macro_lookup_baton;
+
+static struct macro_definition *
+null_macro_lookup (const char *name, void *baton)
+{
+ return 0;
+}
+
+
+static int
+c_preprocess_and_parse (void)
+{
+ /* Set up a lookup function for the macro expander. */
+ struct macro_scope *scope = 0;
+ struct cleanup *back_to = make_cleanup (free_current_contents, &scope);
+
+ if (expression_context_block)
+ scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
+ else
+ scope = default_macro_scope ();
+
+ if (scope)
+ {
+ expression_macro_lookup_func = standard_macro_lookup;
+ expression_macro_lookup_baton = (void *) scope;
+ }
+ else
+ {
+ expression_macro_lookup_func = null_macro_lookup;
+ expression_macro_lookup_baton = 0;
+ }
+
+ gdb_assert (! macro_original_text);
+ make_cleanup (scan_macro_cleanup, 0);
+
+ {
+ int result = c_parse ();
+ do_cleanups (back_to);
+ return result;
+ }
+}
+
+
+\f
/* Table mapping opcodes into strings for printing operators
and precedences of the operators. */
{NULL, 0, 0, 0}
};
\f
-struct type **CONST_PTR (c_builtin_types[]) =
+enum c_primitive_types {
+ c_primitive_type_int,
+ c_primitive_type_long,
+ c_primitive_type_short,
+ c_primitive_type_char,
+ c_primitive_type_float,
+ c_primitive_type_double,
+ c_primitive_type_void,
+ c_primitive_type_long_long,
+ c_primitive_type_signed_char,
+ c_primitive_type_unsigned_char,
+ c_primitive_type_unsigned_short,
+ c_primitive_type_unsigned_int,
+ c_primitive_type_unsigned_long,
+ c_primitive_type_unsigned_long_long,
+ c_primitive_type_long_double,
+ c_primitive_type_complex,
+ c_primitive_type_double_complex,
+ nr_c_primitive_types
+};
+
+void
+c_language_arch_info (struct gdbarch *gdbarch,
+ struct language_arch_info *lai)
{
- &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 builtin_type *builtin = builtin_type (gdbarch);
+ lai->string_char_type = builtin->builtin_char;
+ lai->primitive_type_vector
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
+ struct type *);
+ lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
+ lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
+ lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
+ lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
+ lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
+ lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
+ lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
+ lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
+ lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
+ lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
+ lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
+ lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
+ lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
+ lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
+ lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
+ lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
+ lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
};
const struct language_defn c_language_defn =
{
"c", /* Language name */
language_c,
- c_builtin_types,
+ NULL,
range_check_off,
type_check_off,
case_sensitive_on,
- c_parse,
+ array_row_major,
+ &exp_descriptor_standard,
+ c_preprocess_and_parse,
c_error,
- evaluate_subexp_standard,
+ null_post_parser,
c_printchar, /* Print a character constant */
c_printstr, /* Function to print string constant */
c_emit_char, /* Print a single char */
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 */
+ NULL, /* Language specific skip_trampoline */
+ NULL, /* value_of_this */
+ basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
+ basic_lookup_transparent_type,/* lookup_transparent_type */
+ NULL, /* Language specific symbol demangler */
+ NULL, /* Language specific class_name_from_physname */
c_op_print_tab, /* expression operators for printing */
1, /* c-style arrays */
0, /* String lower bound */
- &builtin_type_char, /* Type of string elements */
+ NULL,
+ default_word_break_characters,
+ c_language_arch_info,
+ default_print_array_index,
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
+ &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 =
range_check_off,
type_check_off,
case_sensitive_on,
- c_parse,
+ array_row_major,
+ &exp_descriptor_standard,
+ c_preprocess_and_parse,
c_error,
- evaluate_subexp_standard,
+ null_post_parser,
c_printchar, /* Print a character constant */
c_printstr, /* Function to print string constant */
c_emit_char, /* Print a single char */
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 */
+ NULL, /* Language specific skip_trampoline */
+ value_of_this, /* value_of_this */
+ cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
+ cp_lookup_transparent_type, /* lookup_transparent_type */
+ cplus_demangle, /* Language specific symbol demangler */
+ cp_class_name_from_physname, /* Language specific class_name_from_physname */
c_op_print_tab, /* expression operators for printing */
1, /* c-style arrays */
0, /* String lower bound */
&builtin_type_char, /* Type of string elements */
+ default_word_break_characters,
+ NULL, /* FIXME: la_language_arch_info. */
+ default_print_array_index,
LANG_MAGIC
};
{
"asm", /* Language name */
language_asm,
- c_builtin_types,
+ NULL,
range_check_off,
type_check_off,
case_sensitive_on,
- c_parse,
+ array_row_major,
+ &exp_descriptor_standard,
+ c_preprocess_and_parse,
c_error,
- evaluate_subexp_standard,
+ null_post_parser,
c_printchar, /* Print a character constant */
c_printstr, /* Function to print string constant */
c_emit_char, /* Print a single char */
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 */
+ NULL, /* Language specific skip_trampoline */
+ NULL, /* value_of_this */
+ basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
+ basic_lookup_transparent_type,/* lookup_transparent_type */
+ NULL, /* Language specific symbol demangler */
+ NULL, /* Language specific class_name_from_physname */
c_op_print_tab, /* expression operators for printing */
1, /* c-style arrays */
0, /* String lower bound */
- &builtin_type_char, /* Type of string elements */
+ NULL,
+ default_word_break_characters,
+ c_language_arch_info, /* FIXME: la_language_arch_info. */
+ default_print_array_index,
+ LANG_MAGIC
+};
+
+/* The following language_defn does not represent a real language.
+ It just provides a minimal support a-la-C that should allow users
+ to do some simple operations when debugging applications that use
+ a language currently not supported by GDB. */
+
+const struct language_defn minimal_language_defn =
+{
+ "minimal", /* Language name */
+ language_minimal,
+ NULL,
+ range_check_off,
+ type_check_off,
+ case_sensitive_on,
+ array_row_major,
+ &exp_descriptor_standard,
+ c_preprocess_and_parse,
+ c_error,
+ null_post_parser,
+ 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 */
+ NULL, /* Language specific skip_trampoline */
+ NULL, /* value_of_this */
+ basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
+ basic_lookup_transparent_type,/* lookup_transparent_type */
+ NULL, /* Language specific symbol demangler */
+ NULL, /* Language specific class_name_from_physname */
+ c_op_print_tab, /* expression operators for printing */
+ 1, /* c-style arrays */
+ 0, /* String lower bound */
+ NULL,
+ default_word_break_characters,
+ c_language_arch_info,
+ default_print_array_index,
LANG_MAGIC
};
add_language (&c_language_defn);
add_language (&cplus_language_defn);
add_language (&asm_language_defn);
+ add_language (&minimal_language_defn);
}