/* Source-language-related definitions for GDB.
- Copyright (C) 1991-2014 Free Software Foundation, Inc.
+ Copyright (C) 1991-2016 Free Software Foundation, Inc.
Contributed by the Department of Computer Science at the State University
of New York at Buffalo.
expressions, regardless of whether the program being debugged
actually defines such a type. */
struct type **primitive_type_vector;
+
+ /* Symbol wrappers around primitive_type_vector, so that the symbol lookup
+ machinery can return them. */
+ struct symbol **primitive_type_symbols;
+
/* Type of elements of strings. */
struct type *string_char_type;
/* Style of macro expansion, if any, supported by this language. */
enum macro_expansion la_macro_expansion;
+ /* A NULL-terminated array of file extensions for this language.
+ The extension must include the ".", like ".c". If this
+ language doesn't need to provide any filename extensions, this
+ may be NULL. */
+
+ const char *const *la_filename_extensions;
+
/* Definitions related to expression printing, prefixifying, and
dumping. */
TYPE is the type of the sub-object to be printed.
- CONTENTS holds the bits of the value. This holds the entire
- enclosing object.
-
EMBEDDED_OFFSET is the offset into the outermost object of the
sub-object represented by TYPE. This is the object which this
call should print. Note that the enclosing type is not
printing. */
void (*la_val_print) (struct type *type,
- const gdb_byte *contents,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
- const struct value *val,
+ struct value *val,
const struct value_print_options *options);
/* Print a top-level value using syntax appropriate for this language. */
void (*la_value_print) (struct value *, struct ui_file *,
const struct value_print_options *);
- /* Given a symbol VAR, and a stack frame id FRAME, read the value
- of the variable an return (pointer to a) struct value containing
- the value.
+ /* Given a symbol VAR, the corresponding block VAR_BLOCK (if any) and a
+ stack frame id FRAME, read the value of the variable and return (pointer
+ to a) struct value containing the value.
+
+ VAR_BLOCK is needed if there's a possibility for VAR to be outside
+ FRAME. This is what happens if FRAME correspond to a nested function
+ and VAR is defined in the outer function. If callers know that VAR is
+ located in FRAME or is global/static, NULL can be passed as VAR_BLOCK.
Throw an error if the variable cannot be found. */
struct value *(*la_read_var_value) (struct symbol *var,
+ const struct block *var_block,
struct frame_info *frame);
/* PC is possibly an unknown languages trampoline.
the part of symbol lookup where C looks up static and global
variables. */
- struct symbol *(*la_lookup_symbol_nonlocal) (const struct language_defn *,
- const char *,
- const struct block *,
- const domain_enum);
+ struct block_symbol (*la_lookup_symbol_nonlocal)
+ (const struct language_defn *,
+ const char *,
+ const struct block *,
+ const domain_enum);
/* Find the definition of the type with the given name. */
struct type *(*la_lookup_transparent_type) (const char *);
/* Return demangled language symbol, or NULL. */
char *(*la_demangle) (const char *mangled, int options);
+ /* Demangle a symbol according to this language's rules. Unlike
+ la_demangle, this does not take any options.
+
+ *DEMANGLED will be set by this function.
+
+ If this function returns 0, then *DEMANGLED must always be set
+ to NULL.
+
+ If this function returns 1, the implementation may set this to
+ a xmalloc'd string holding the demangled form. However, it is
+ not required to. The string, if any, is owned by the caller.
+
+ The resulting string should be of the form that will be
+ installed into a symbol. */
+ int (*la_sniff_from_mangled_name) (const char *mangled, char **demangled);
+
/* Return class name of a mangled method name or NULL. */
char *(*la_class_name_from_physname) (const char *physname);
If 'la_get_gcc_context' is not defined, then this method is
ignored.
- This takes the user-supplied text and returns a newly malloc'd
- bit of code to compile. The caller owns the result.
+ This takes the user-supplied text and returns a new bit of code
+ to compile.
INST is the compiler instance being used.
INPUT is the user's input text.
parsed.
EXPR_PC is the PC at which the expression is being parsed. */
- char *(*la_compute_program) (struct compile_instance *inst,
- const char *input,
- struct gdbarch *gdbarch,
- const struct block *expr_block,
- CORE_ADDR expr_pc);
+ std::string (*la_compute_program) (struct compile_instance *inst,
+ const char *input,
+ struct gdbarch *gdbarch,
+ const struct block *expr_block,
+ CORE_ADDR expr_pc);
/* Add fields above this point, so the magic number is always last. */
/* Magic number for compat checking. */
struct type *language_string_char_type (const struct language_defn *l,
struct gdbarch *gdbarch);
+/* Look up type NAME in language L, and return its definition for architecture
+ GDBARCH. Returns NULL if not found. */
+
struct type *language_lookup_primitive_type (const struct language_defn *l,
struct gdbarch *gdbarch,
const char *name);
+/* Wrapper around language_lookup_primitive_type to return the
+ corresponding symbol. */
+
+struct symbol *
+ language_lookup_primitive_type_as_symbol (const struct language_defn *l,
+ struct gdbarch *gdbarch,
+ const char *name);
+
\f
/* These macros define the behaviour of the expression
evaluator. */
#define LA_PRINT_TYPEDEF(type,new_symbol,stream) \
(current_language->la_print_typedef(type,new_symbol,stream))
-#define LA_VAL_PRINT(type,valaddr,offset,addr,stream,val,recurse,options) \
- (current_language->la_val_print(type,valaddr,offset,addr,stream, \
- val,recurse,options))
#define LA_VALUE_PRINT(val,stream,options) \
(current_language->la_value_print(val,stream,options))
extern void add_language (const struct language_defn *);
-extern enum language get_frame_language (void); /* In stack.c */
-
/* Check for a language-specific trampoline. */
extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc);
extern char *language_demangle (const struct language_defn *current_language,
const char *mangled, int options);
+/* A wrapper for la_sniff_from_mangled_name. The arguments and result
+ are as for the method. */
+
+extern int language_sniff_from_mangled_name (const struct language_defn *lang,
+ const char *mangled,
+ char **demangled);
+
/* Return class name from physname, or NULL. */
extern char *language_class_name_from_physname (const struct language_defn *,
const char *physname);
projects / deliverable / binutils-gdb.git / blobdiff