]> Git Repo - binutils.git/blob - gdb/language.h
Update copyright year range in all GDB files.
[binutils.git] / gdb / language.h
1 /* Source-language-related definitions for GDB.
2
3    Copyright (C) 1991-2020 Free Software Foundation, Inc.
4
5    Contributed by the Department of Computer Science at the State University
6    of New York at Buffalo.
7
8    This file is part of GDB.
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23 #if !defined (LANGUAGE_H)
24 #define LANGUAGE_H 1
25
26 #include "symtab.h"
27 #include "gdbsupport/function-view.h"
28 #include "expression.h"
29
30 /* Forward decls for prototypes.  */
31 struct value;
32 struct objfile;
33 struct frame_info;
34 struct ui_file;
35 struct value_print_options;
36 struct type_print_options;
37 struct lang_varobj_ops;
38 struct parser_state;
39 class compile_instance;
40 struct completion_match_for_lcd;
41 class innermost_block_tracker;
42
43 #define MAX_FORTRAN_DIMS  7     /* Maximum number of F77 array dims.  */
44
45 /* range_mode ==
46    range_mode_auto:   range_check set automatically to default of language.
47    range_mode_manual: range_check set manually by user.  */
48
49 extern enum range_mode
50   {
51     range_mode_auto, range_mode_manual
52   }
53 range_mode;
54
55 /* range_check ==
56    range_check_on:    Ranges are checked in GDB expressions, producing errors.
57    range_check_warn:  Ranges are checked, producing warnings.
58    range_check_off:   Ranges are not checked in GDB expressions.  */
59
60 extern enum range_check
61   {
62     range_check_off, range_check_warn, range_check_on
63   }
64 range_check;
65
66 /* case_mode ==
67    case_mode_auto:   case_sensitivity set upon selection of scope.
68    case_mode_manual: case_sensitivity set only by user.  */
69
70 extern enum case_mode
71   {
72     case_mode_auto, case_mode_manual
73   }
74 case_mode;
75
76 /* array_ordering ==
77    array_row_major:     Arrays are in row major order.
78    array_column_major:  Arrays are in column major order.  */
79
80 extern enum array_ordering
81   {
82     array_row_major, array_column_major
83   } 
84 array_ordering;
85
86
87 /* case_sensitivity ==
88    case_sensitive_on:   Case sensitivity in name matching is used.
89    case_sensitive_off:  Case sensitivity in name matching is not used.  */
90
91 extern enum case_sensitivity
92   {
93     case_sensitive_on, case_sensitive_off
94   }
95 case_sensitivity;
96
97
98 /* macro_expansion ==
99    macro_expansion_no:  No macro expansion is available.
100    macro_expansion_c:   C-like macro expansion is available.  */
101
102 enum macro_expansion
103   {
104     macro_expansion_no, macro_expansion_c
105   };
106
107 \f
108 /* Per architecture (OS/ABI) language information.  */
109
110 struct language_arch_info
111 {
112   /* Its primitive types.  This is a vector ended by a NULL pointer.
113      These types can be specified by name in parsing types in
114      expressions, regardless of whether the program being debugged
115      actually defines such a type.  */
116   struct type **primitive_type_vector;
117
118   /* Symbol wrappers around primitive_type_vector, so that the symbol lookup
119      machinery can return them.  */
120   struct symbol **primitive_type_symbols;
121
122   /* Type of elements of strings.  */
123   struct type *string_char_type;
124
125   /* Symbol name of type to use as boolean type, if defined.  */
126   const char *bool_type_symbol;
127   /* Otherwise, this is the default boolean builtin type.  */
128   struct type *bool_type_default;
129 };
130
131 /* In a language (particularly C++) a function argument of an aggregate
132    type (i.e.  class/struct/union) may be implicitly passed by reference
133    even though it is declared a call-by-value argument in the source.
134    The struct below puts together necessary information for GDB to be
135    able to detect and carry out pass-by-reference semantics for a
136    particular type.  This type is referred as T in the inlined comments
137    below.
138
139    The default values of the fields are chosen to give correct semantics
140    for primitive types and for simple aggregate types, such as
141
142    class T {
143      int x;
144    };  */
145
146 struct language_pass_by_ref_info
147 {
148   /* True if an argument of type T can be passed to a function by value
149      (i.e.  not through an implicit reference).  False, otherwise.  */
150   bool trivially_copyable = true;
151
152   /* True if a copy of a value of type T can be initialized by
153      memcpy'ing the value bit-by-bit.  False, otherwise.
154      E.g.  If T has a user-defined copy ctor, this should be false.  */
155   bool trivially_copy_constructible = true;
156
157   /* True if a value of type T can be destructed simply by reclaiming
158      the memory area occupied by the value.  False, otherwise.
159      E.g.  If T has a user-defined destructor, this should be false.  */
160   bool trivially_destructible = true;
161
162   /* True if it is allowed to create a copy of a value of type T.
163      False, otherwise.
164      E.g.  If T has a deleted copy ctor, this should be false.  */
165   bool copy_constructible = true;
166
167   /* True if a value of type T can be destructed.  False, otherwise.
168      E.g.  If T has a deleted destructor, this should be false.  */
169   bool destructible = true;
170 };
171
172 /* Structure tying together assorted information about a language.  */
173
174 struct language_defn
175   {
176     /* Name of the language.  */
177
178     const char *la_name;
179
180     /* Natural or official name of the language.  */
181
182     const char *la_natural_name;
183
184     /* its symtab language-enum (defs.h).  */
185
186     enum language la_language;
187
188     /* Default range checking.  */
189
190     enum range_check la_range_check;
191
192     /* Default case sensitivity.  */
193     enum case_sensitivity la_case_sensitivity;
194
195     /* Multi-dimensional array ordering.  */
196     enum array_ordering la_array_ordering;
197
198     /* Style of macro expansion, if any, supported by this language.  */
199     enum macro_expansion la_macro_expansion;
200
201     /* A NULL-terminated array of file extensions for this language.
202        The extension must include the ".", like ".c".  If this
203        language doesn't need to provide any filename extensions, this
204        may be NULL.  */
205
206     const char *const *la_filename_extensions;
207
208     /* Definitions related to expression printing, prefixifying, and
209        dumping.  */
210
211     const struct exp_descriptor *la_exp_desc;
212
213     /* Parser function.  */
214
215     int (*la_parser) (struct parser_state *);
216
217     /* Given an expression *EXPP created by prefixifying the result of
218        la_parser, perform any remaining processing necessary to complete
219        its translation.  *EXPP may change; la_post_parser is responsible 
220        for releasing its previous contents, if necessary.  If 
221        VOID_CONTEXT_P, then no value is expected from the expression.
222        If COMPLETING is non-zero, then the expression has been parsed
223        for completion, not evaluation.  */
224
225     void (*la_post_parser) (expression_up *expp, int void_context_p,
226                             int completing, innermost_block_tracker *tracker);
227
228     void (*la_printchar) (int ch, struct type *chtype,
229                           struct ui_file * stream);
230
231     void (*la_printstr) (struct ui_file * stream, struct type *elttype,
232                          const gdb_byte *string, unsigned int length,
233                          const char *encoding, int force_ellipses,
234                          const struct value_print_options *);
235
236     void (*la_emitchar) (int ch, struct type *chtype,
237                          struct ui_file * stream, int quoter);
238
239     /* Print a type using syntax appropriate for this language.  */
240
241     void (*la_print_type) (struct type *, const char *, struct ui_file *, int,
242                            int, const struct type_print_options *);
243
244     /* Print a typedef using syntax appropriate for this language.
245        TYPE is the underlying type.  NEW_SYMBOL is the symbol naming
246        the type.  STREAM is the output stream on which to print.  */
247
248     void (*la_print_typedef) (struct type *type, struct symbol *new_symbol,
249                               struct ui_file *stream);
250
251     /* Print a value using syntax appropriate for this language.
252        
253        TYPE is the type of the sub-object to be printed.
254
255        EMBEDDED_OFFSET is the offset into the outermost object of the
256        sub-object represented by TYPE.  This is the object which this
257        call should print.  Note that the enclosing type is not
258        available.
259
260        ADDRESS is the address in the inferior of the enclosing object.
261
262        STREAM is the stream on which the value is to be printed.
263
264        RECURSE is the recursion depth.  It is zero-based.
265
266        OPTIONS are the formatting options to be used when
267        printing.  */
268
269     void (*la_val_print) (struct type *type,
270                           int embedded_offset, CORE_ADDR address,
271                           struct ui_file *stream, int recurse,
272                           struct value *val,
273                           const struct value_print_options *options);
274
275     /* Print a top-level value using syntax appropriate for this language.  */
276
277     void (*la_value_print) (struct value *, struct ui_file *,
278                             const struct value_print_options *);
279
280     /* Given a symbol VAR, the corresponding block VAR_BLOCK (if any) and a
281        stack frame id FRAME, read the value of the variable and return (pointer
282        to a) struct value containing the value.
283
284        VAR_BLOCK is needed if there's a possibility for VAR to be outside
285        FRAME.  This is what happens if FRAME correspond to a nested function
286        and VAR is defined in the outer function.  If callers know that VAR is
287        located in FRAME or is global/static, NULL can be passed as VAR_BLOCK.
288
289        Throw an error if the variable cannot be found.  */
290
291     struct value *(*la_read_var_value) (struct symbol *var,
292                                         const struct block *var_block,
293                                         struct frame_info *frame);
294
295     /* PC is possibly an unknown languages trampoline.
296        If that PC falls in a trampoline belonging to this language,
297        return the address of the first pc in the real function, or 0
298        if it isn't a language tramp for this language.  */
299     CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
300
301     /* Now come some hooks for lookup_symbol.  */
302
303     /* If this is non-NULL, specifies the name that of the implicit
304        local variable that refers to the current object instance.  */
305
306     const char *la_name_of_this;
307
308     /* True if the symbols names should be stored in GDB's data structures
309        for minimal/partial/full symbols using their linkage (aka mangled)
310        form; false if the symbol names should be demangled first.
311
312        Most languages implement symbol lookup by comparing the demangled
313        names, in which case it is advantageous to store that information
314        already demangled, and so would set this field to false.
315
316        On the other hand, some languages have opted for doing symbol
317        lookups by comparing mangled names instead, for reasons usually
318        specific to the language.  Those languages should set this field
319        to true.
320
321        And finally, other languages such as C or Asm do not have
322        the concept of mangled vs demangled name, so those languages
323        should set this field to true as well, to prevent any accidental
324        demangling through an unrelated language's demangler.  */
325
326     const bool la_store_sym_names_in_linkage_form_p;
327
328     /* This is a function that lookup_symbol will call when it gets to
329        the part of symbol lookup where C looks up static and global
330        variables.  */
331
332     struct block_symbol (*la_lookup_symbol_nonlocal)
333       (const struct language_defn *,
334        const char *,
335        const struct block *,
336        const domain_enum);
337
338     /* Find the definition of the type with the given name.  */
339     struct type *(*la_lookup_transparent_type) (const char *);
340
341     /* Return demangled language symbol, or NULL.  */
342     char *(*la_demangle) (const char *mangled, int options);
343
344     /* Demangle a symbol according to this language's rules.  Unlike
345        la_demangle, this does not take any options.
346
347        *DEMANGLED will be set by this function.
348        
349        If this function returns 0, then *DEMANGLED must always be set
350        to NULL.
351
352        If this function returns 1, the implementation may set this to
353        a xmalloc'd string holding the demangled form.  However, it is
354        not required to.  The string, if any, is owned by the caller.
355
356        The resulting string should be of the form that will be
357        installed into a symbol.  */
358     int (*la_sniff_from_mangled_name) (const char *mangled, char **demangled);
359
360     /* Return class name of a mangled method name or NULL.  */
361     char *(*la_class_name_from_physname) (const char *physname);
362
363     /* Table for printing expressions.  */
364
365     const struct op_print *la_op_print_tab;
366
367     /* Zero if the language has first-class arrays.  True if there are no
368        array values, and array objects decay to pointers, as in C.  */
369
370     char c_style_arrays;
371
372     /* Index to use for extracting the first element of a string.  */
373     char string_lower_bound;
374
375     /* The list of characters forming word boundaries.  */
376     const char *(*la_word_break_characters) (void);
377
378     /* Add to the completion tracker all symbols which are possible
379        completions for TEXT.  WORD is the entire command on which the
380        completion is being made.  If CODE is TYPE_CODE_UNDEF, then all
381        symbols should be examined; otherwise, only STRUCT_DOMAIN
382        symbols whose type has a code of CODE should be matched.  */
383     void (*la_collect_symbol_completion_matches)
384       (completion_tracker &tracker,
385        complete_symbol_mode mode,
386        symbol_name_match_type match_type,
387        const char *text,
388        const char *word,
389        enum type_code code);
390
391     /* The per-architecture (OS/ABI) language information.  */
392     void (*la_language_arch_info) (struct gdbarch *,
393                                    struct language_arch_info *);
394
395     /* Print the index of an element of an array.  */
396     void (*la_print_array_index) (struct value *index_value,
397                                   struct ui_file *stream,
398                                   const struct value_print_options *options);
399
400     /* Return information about whether TYPE should be passed
401        (and returned) by reference at the language level.  */
402     struct language_pass_by_ref_info (*la_pass_by_reference)
403       (struct type *type);
404
405     /* Return an expression that can be used for a location
406        watchpoint.  TYPE is a pointer type that points to the memory
407        to watch, and ADDR is the address of the watched memory.  */
408     gdb::unique_xmalloc_ptr<char> (*la_watch_location_expression)
409          (struct type *type, CORE_ADDR addr);
410
411     /* Return a pointer to the function that should be used to match a
412        symbol name against LOOKUP_NAME, according to this language's
413        rules.  The matching algorithm depends on LOOKUP_NAME.  For
414        example, on Ada, the matching algorithm depends on the symbol
415        name (wild/full/verbatim matching), and on whether we're doing
416        a normal lookup or a completion match lookup.
417
418        This field may be NULL, in which case
419        default_symbol_name_matcher is used to perform the
420        matching.  */
421     symbol_name_matcher_ftype *(*la_get_symbol_name_matcher)
422       (const lookup_name_info &);
423
424     /* Find all symbols in the current program space matching NAME in
425        DOMAIN, according to this language's rules.
426
427        The search is done in BLOCK only.
428        The caller is responsible for iterating up through superblocks
429        if desired.
430
431        For each one, call CALLBACK with the symbol.  If CALLBACK
432        returns false, the iteration ends at that point.
433
434        This field may not be NULL.  If the language does not need any
435        special processing here, 'iterate_over_symbols' should be
436        used as the definition.  */
437     bool (*la_iterate_over_symbols)
438       (const struct block *block, const lookup_name_info &name,
439        domain_enum domain,
440        gdb::function_view<symbol_found_callback_ftype> callback);
441
442     /* Hash the given symbol search name.  Use
443        default_search_name_hash if no special treatment is
444        required.  */
445     unsigned int (*la_search_name_hash) (const char *name);
446
447     /* Various operations on varobj.  */
448     const struct lang_varobj_ops *la_varobj_ops;
449
450     /* If this language allows compilation from the gdb command line,
451        this method should be non-NULL.  When called it should return
452        an instance of struct gcc_context appropriate to the language.
453        When defined this method must never return NULL; instead it
454        should throw an exception on failure.  The returned compiler
455        instance is owned by its caller and must be deallocated by
456        calling its 'destroy' method.  */
457
458     compile_instance *(*la_get_compile_instance) (void);
459
460     /* This method must be defined if 'la_get_gcc_context' is defined.
461        If 'la_get_gcc_context' is not defined, then this method is
462        ignored.
463
464        This takes the user-supplied text and returns a new bit of code
465        to compile.
466
467        INST is the compiler instance being used.
468        INPUT is the user's input text.
469        GDBARCH is the architecture to use.
470        EXPR_BLOCK is the block in which the expression is being
471        parsed.
472        EXPR_PC is the PC at which the expression is being parsed.  */
473
474     std::string (*la_compute_program) (compile_instance *inst,
475                                        const char *input,
476                                        struct gdbarch *gdbarch,
477                                        const struct block *expr_block,
478                                        CORE_ADDR expr_pc);
479
480     /* Return true if TYPE is a string type.  */
481     bool (*la_is_string_type_p) (struct type *type);
482
483     /* This string is used by the 'set print max-depth' setting.  When GDB
484        replaces a struct or union (during value printing) that is "too
485        deep" this string is displayed instead.  */
486     const char *la_struct_too_deep_ellipsis;
487
488   };
489
490 /* Pointer to the language_defn for our current language.  This pointer
491    always points to *some* valid struct; it can be used without checking
492    it for validity.
493
494    The current language affects expression parsing and evaluation
495    (FIXME: it might be cleaner to make the evaluation-related stuff
496    separate exp_opcodes for each different set of semantics.  We
497    should at least think this through more clearly with respect to
498    what happens if the language is changed between parsing and
499    evaluation) and printing of things like types and arrays.  It does
500    *not* affect symbol-reading-- each source file in a symbol-file has
501    its own language and we should keep track of that regardless of the
502    language when symbols are read.  If we want some manual setting for
503    the language of symbol files (e.g. detecting when ".c" files are
504    C++), it should be a separate setting from the current_language.  */
505
506 extern const struct language_defn *current_language;
507
508 /* Pointer to the language_defn expected by the user, e.g. the language
509    of main(), or the language we last mentioned in a message, or C.  */
510
511 extern const struct language_defn *expected_language;
512
513 /* Warning issued when current_language and the language of the current
514    frame do not match.  */
515
516 extern const char lang_frame_mismatch_warn[];
517
518 /* language_mode == 
519    language_mode_auto:   current_language automatically set upon selection
520    of scope (e.g. stack frame)
521    language_mode_manual: current_language set only by user.  */
522
523 extern enum language_mode
524   {
525     language_mode_auto, language_mode_manual
526   }
527 language_mode;
528
529 struct type *language_bool_type (const struct language_defn *l,
530                                  struct gdbarch *gdbarch);
531
532 struct type *language_string_char_type (const struct language_defn *l,
533                                         struct gdbarch *gdbarch);
534
535 /* Look up type NAME in language L, and return its definition for architecture
536    GDBARCH.  Returns NULL if not found.  */
537
538 struct type *language_lookup_primitive_type (const struct language_defn *l,
539                                              struct gdbarch *gdbarch,
540                                              const char *name);
541
542 /* Wrapper around language_lookup_primitive_type to return the
543    corresponding symbol.  */
544
545 struct symbol *
546   language_lookup_primitive_type_as_symbol (const struct language_defn *l,
547                                             struct gdbarch *gdbarch,
548                                             const char *name);
549
550 \f
551 /* These macros define the behaviour of the expression 
552    evaluator.  */
553
554 /* Should we range check values against the domain of their type?  */
555 #define RANGE_CHECK (range_check != range_check_off)
556
557 /* "cast" really means conversion.  */
558 /* FIXME -- should be a setting in language_defn.  */
559 #define CAST_IS_CONVERSION(LANG) ((LANG)->la_language == language_c  || \
560                                   (LANG)->la_language == language_cplus || \
561                                   (LANG)->la_language == language_objc)
562
563 extern void language_info (int);
564
565 extern enum language set_language (enum language);
566 \f
567
568 /* This page contains functions that return things that are
569    specific to languages.  Each of these functions is based on
570    the current setting of working_lang, which the user sets
571    with the "set language" command.  */
572
573 #define LA_PRINT_TYPE(type,varstring,stream,show,level,flags)           \
574   (current_language->la_print_type(type,varstring,stream,show,level,flags))
575
576 #define LA_PRINT_TYPEDEF(type,new_symbol,stream) \
577   (current_language->la_print_typedef(type,new_symbol,stream))
578
579 #define LA_VALUE_PRINT(val,stream,options) \
580   (current_language->la_value_print(val,stream,options))
581
582 #define LA_PRINT_CHAR(ch, type, stream) \
583   (current_language->la_printchar(ch, type, stream))
584 #define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options) \
585   (current_language->la_printstr(stream, elttype, string, length, \
586                                  encoding, force_ellipses,options))
587 #define LA_EMIT_CHAR(ch, type, stream, quoter) \
588   (current_language->la_emitchar(ch, type, stream, quoter))
589
590 #define LA_PRINT_ARRAY_INDEX(index_value, stream, options) \
591   (current_language->la_print_array_index(index_value, stream, options))
592
593 #define LA_ITERATE_OVER_SYMBOLS(BLOCK, NAME, DOMAIN, CALLBACK) \
594   (current_language->la_iterate_over_symbols (BLOCK, NAME, DOMAIN, CALLBACK))
595
596 /* Test a character to decide whether it can be printed in literal form
597    or needs to be printed in another representation.  For example,
598    in C the literal form of the character with octal value 141 is 'a'
599    and the "other representation" is '\141'.  The "other representation"
600    is program language dependent.  */
601
602 #define PRINT_LITERAL_FORM(c)           \
603   ((c) >= 0x20                          \
604    && ((c) < 0x7F || (c) >= 0xA0)       \
605    && (!sevenbit_strings || (c) < 0x80))
606
607 /* Type predicates */
608
609 extern int pointer_type (struct type *);
610
611 /* Return true if TYPE is a string type, otherwise return false.  This
612    default implementation only detects TYPE_CODE_STRING.  */
613 extern bool default_is_string_type_p (struct type *type);
614
615 /* Error messages */
616
617 extern void range_error (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
618
619 /* Data:  Does this value represent "truth" to the current language?  */
620
621 extern int value_true (struct value *);
622
623 /* Misc:  The string representing a particular enum language.  */
624
625 extern enum language language_enum (const char *str);
626
627 extern const struct language_defn *language_def (enum language);
628
629 extern const char *language_str (enum language);
630
631 /* Check for a language-specific trampoline.  */
632
633 extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc);
634
635 /* Return demangled language symbol, or NULL.  */
636 extern char *language_demangle (const struct language_defn *current_language, 
637                                 const char *mangled, int options);
638
639 /* A wrapper for la_sniff_from_mangled_name.  The arguments and result
640    are as for the method.  */
641
642 extern int language_sniff_from_mangled_name (const struct language_defn *lang,
643                                              const char *mangled,
644                                              char **demangled);
645
646 /* Return class name from physname, or NULL.  */
647 extern char *language_class_name_from_physname (const struct language_defn *,
648                                                 const char *physname);
649
650 /* Splitting strings into words.  */
651 extern const char *default_word_break_characters (void);
652
653 /* Print the index of an array element using the C99 syntax.  */
654 extern void default_print_array_index (struct value *index_value,
655                                        struct ui_file *stream,
656                                        const struct value_print_options *options);
657
658 /* Return information about whether TYPE should be passed
659    (and returned) by reference at the language level.  */
660 struct language_pass_by_ref_info language_pass_by_reference (struct type *type);
661
662 /* Return a default struct that provides pass-by-reference information
663    about the given TYPE.  Languages should update the default values
664    as appropriate.  */
665 struct language_pass_by_ref_info default_pass_by_reference (struct type *type);
666
667 /* The default implementation of la_print_typedef.  */
668 void default_print_typedef (struct type *type, struct symbol *new_symbol,
669                             struct ui_file *stream);
670
671 /* Default name hashing function.  */
672
673 /* Produce an unsigned hash value from SEARCH_NAME that is consistent
674    with strcmp_iw, strcmp, and, at least on Ada symbols, wild_match.
675    That is, two identifiers equivalent according to any of those three
676    comparison operators hash to the same value.  */
677 extern unsigned int default_search_name_hash (const char *search_name);
678
679 void c_get_string (struct value *value,
680                    gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
681                    int *length, struct type **char_type,
682                    const char **charset);
683
684 /* The default implementation of la_symbol_name_matcher.  Matches with
685    strncmp_iw.  */
686 extern bool default_symbol_name_matcher
687   (const char *symbol_search_name,
688    const lookup_name_info &lookup_name,
689    completion_match_result *comp_match_res);
690
691 /* Get LANG's symbol_name_matcher method for LOOKUP_NAME.  Returns
692    default_symbol_name_matcher if not set.  LANG is used as a hint;
693    the function may ignore it depending on the current language and
694    LOOKUP_NAME.  Specifically, if the current language is Ada, this
695    may return an Ada matcher regardless of LANG.  */
696 symbol_name_matcher_ftype *get_symbol_name_matcher
697   (const language_defn *lang, const lookup_name_info &lookup_name);
698
699 /* The languages supported by GDB.  */
700
701 extern const struct language_defn auto_language_defn;
702 extern const struct language_defn unknown_language_defn;
703 extern const struct language_defn minimal_language_defn;
704
705 extern const struct language_defn ada_language_defn;
706 extern const struct language_defn asm_language_defn;
707 extern const struct language_defn c_language_defn;
708 extern const struct language_defn cplus_language_defn;
709 extern const struct language_defn d_language_defn;
710 extern const struct language_defn f_language_defn;
711 extern const struct language_defn go_language_defn;
712 extern const struct language_defn m2_language_defn;
713 extern const struct language_defn objc_language_defn;
714 extern const struct language_defn opencl_language_defn;
715 extern const struct language_defn pascal_language_defn;
716 extern const struct language_defn rust_language_defn;
717
718 /* Save the current language and restore it upon destruction.  */
719
720 class scoped_restore_current_language
721 {
722 public:
723
724   explicit scoped_restore_current_language ()
725     : m_lang (current_language->la_language)
726   {
727   }
728
729   ~scoped_restore_current_language ()
730   {
731     set_language (m_lang);
732   }
733
734   scoped_restore_current_language (const scoped_restore_current_language &)
735       = delete;
736   scoped_restore_current_language &operator=
737       (const scoped_restore_current_language &) = delete;
738
739 private:
740
741   enum language m_lang;
742 };
743
744 /* If language_mode is language_mode_auto,
745    then switch current language to the language of SYM
746    and restore current language upon destruction.
747
748    Else do nothing.  */
749
750 class scoped_switch_to_sym_language_if_auto
751 {
752 public:
753
754   explicit scoped_switch_to_sym_language_if_auto (const struct symbol *sym)
755   {
756     if (language_mode == language_mode_auto)
757       {
758         m_lang = current_language->la_language;
759         m_switched = true;
760         set_language (sym->language ());
761       }
762     else
763       {
764         m_switched = false;
765         /* Assign to m_lang to silence a GCC warning.  See
766            https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80635.  */
767         m_lang = language_unknown;
768       }
769   }
770
771   ~scoped_switch_to_sym_language_if_auto ()
772   {
773     if (m_switched)
774       set_language (m_lang);
775   }
776
777   DISABLE_COPY_AND_ASSIGN (scoped_switch_to_sym_language_if_auto);
778
779 private:
780   bool m_switched;
781   enum language m_lang;
782 };
783
784 #endif /* defined (LANGUAGE_H) */
This page took 0.067634 seconds and 4 git commands to generate.