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 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 /* Splitting strings into words. */ 173 extern const char *default_word_break_characters (void); 174 175 /* Structure tying together assorted information about a language. 176 177 As we move over from the old structure based languages to a class 178 hierarchy of languages this structure will continue to contain a 179 mixture of both data and function pointers. 180 181 Once the class hierarchy of languages in place the first task is to 182 remove the function pointers from this structure and convert them into 183 member functions on the different language classes. 184 185 The current plan it to keep the constant data that describes a language 186 in this structure, and have each language pass in an instance of this 187 structure at construction time. */ 188 189 struct language_data 190 { 191 /* Name of the language. */ 192 193 const char *la_name; 194 195 /* Natural or official name of the language. */ 196 197 const char *la_natural_name; 198 199 /* its symtab language-enum (defs.h). */ 200 201 enum language la_language; 202 203 /* Default range checking. */ 204 205 enum range_check la_range_check; 206 207 /* Default case sensitivity. */ 208 enum case_sensitivity la_case_sensitivity; 209 210 /* Multi-dimensional array ordering. */ 211 enum array_ordering la_array_ordering; 212 213 /* Style of macro expansion, if any, supported by this language. */ 214 enum macro_expansion la_macro_expansion; 215 216 /* A NULL-terminated array of file extensions for this language. 217 The extension must include the ".", like ".c". If this 218 language doesn't need to provide any filename extensions, this 219 may be NULL. */ 220 221 const char *const *la_filename_extensions; 222 223 /* Definitions related to expression printing, prefixifying, and 224 dumping. */ 225 226 const struct exp_descriptor *la_exp_desc; 227 228 /* Now come some hooks for lookup_symbol. */ 229 230 /* If this is non-NULL, specifies the name that of the implicit 231 local variable that refers to the current object instance. */ 232 233 const char *la_name_of_this; 234 235 /* True if the symbols names should be stored in GDB's data structures 236 for minimal/partial/full symbols using their linkage (aka mangled) 237 form; false if the symbol names should be demangled first. 238 239 Most languages implement symbol lookup by comparing the demangled 240 names, in which case it is advantageous to store that information 241 already demangled, and so would set this field to false. 242 243 On the other hand, some languages have opted for doing symbol 244 lookups by comparing mangled names instead, for reasons usually 245 specific to the language. Those languages should set this field 246 to true. 247 248 And finally, other languages such as C or Asm do not have 249 the concept of mangled vs demangled name, so those languages 250 should set this field to true as well, to prevent any accidental 251 demangling through an unrelated language's demangler. */ 252 253 const bool la_store_sym_names_in_linkage_form_p; 254 255 /* Table for printing expressions. */ 256 257 const struct op_print *la_op_print_tab; 258 259 /* Zero if the language has first-class arrays. True if there are no 260 array values, and array objects decay to pointers, as in C. */ 261 262 char c_style_arrays; 263 264 /* Index to use for extracting the first element of a string. */ 265 char string_lower_bound; 266 267 /* Various operations on varobj. */ 268 const struct lang_varobj_ops *la_varobj_ops; 269 270 /* This string is used by the 'set print max-depth' setting. When GDB 271 replaces a struct or union (during value printing) that is "too 272 deep" this string is displayed instead. */ 273 const char *la_struct_too_deep_ellipsis; 274 275 }; 276 277 /* Base class from which all other language classes derive. */ 278 279 struct language_defn : language_data 280 { 281 language_defn (enum language lang, const language_data &init_data) 282 : language_data (init_data) 283 { 284 /* We should only ever create one instance of each language. */ 285 gdb_assert (languages[lang] == nullptr); 286 languages[lang] = this; 287 } 288 289 /* Print the index of an element of an array. This default 290 implementation prints using C99 syntax. */ 291 292 virtual void print_array_index (struct type *index_type, 293 LONGEST index_value, 294 struct ui_file *stream, 295 const value_print_options *options) const; 296 297 /* Given a symbol VAR, the corresponding block VAR_BLOCK (if any) and a 298 stack frame id FRAME, read the value of the variable and return (pointer 299 to a) struct value containing the value. 300 301 VAR_BLOCK is needed if there's a possibility for VAR to be outside 302 FRAME. This is what happens if FRAME correspond to a nested function 303 and VAR is defined in the outer function. If callers know that VAR is 304 located in FRAME or is global/static, NULL can be passed as VAR_BLOCK. 305 306 Throw an error if the variable cannot be found. */ 307 308 virtual struct value *read_var_value (struct symbol *var, 309 const struct block *var_block, 310 struct frame_info *frame) const; 311 312 /* Return information about whether TYPE should be passed 313 (and returned) by reference at the language level. The default 314 implementation returns a LANGUAGE_PASS_BY_REF_INFO initialised in its 315 default state. */ 316 317 virtual struct language_pass_by_ref_info pass_by_reference_info 318 (struct type *type) const 319 { 320 return {}; 321 } 322 323 /* The per-architecture (OS/ABI) language information. */ 324 325 virtual void language_arch_info (struct gdbarch *, 326 struct language_arch_info *) const = 0; 327 328 /* Find the definition of the type with the given name. */ 329 330 virtual struct type *lookup_transparent_type (const char *name) const 331 { 332 return basic_lookup_transparent_type (name); 333 } 334 335 /* Find all symbols in the current program space matching NAME in 336 DOMAIN, according to this language's rules. 337 338 The search is done in BLOCK only. 339 The caller is responsible for iterating up through superblocks 340 if desired. 341 342 For each one, call CALLBACK with the symbol. If CALLBACK 343 returns false, the iteration ends at that point. 344 345 This field may not be NULL. If the language does not need any 346 special processing here, 'iterate_over_symbols' should be 347 used as the definition. */ 348 virtual bool iterate_over_symbols 349 (const struct block *block, const lookup_name_info &name, 350 domain_enum domain, 351 gdb::function_view<symbol_found_callback_ftype> callback) const 352 { 353 return ::iterate_over_symbols (block, name, domain, callback); 354 } 355 356 /* Return a pointer to the function that should be used to match a 357 symbol name against LOOKUP_NAME, according to this language's 358 rules. The matching algorithm depends on LOOKUP_NAME. For 359 example, on Ada, the matching algorithm depends on the symbol 360 name (wild/full/verbatim matching), and on whether we're doing 361 a normal lookup or a completion match lookup. 362 363 As Ada wants to capture symbol matching for all languages in some 364 cases, then this method is a non-overridable interface. Languages 365 should override GET_SYMBOL_NAME_MATCHER_INNER if they need to. */ 366 367 symbol_name_matcher_ftype *get_symbol_name_matcher 368 (const lookup_name_info &lookup_name) const; 369 370 /* If this language allows compilation from the gdb command line, then 371 this method will return an instance of struct gcc_context appropriate 372 to the language. If compilation for this language is generally 373 supported, but something goes wrong then an exception is thrown. The 374 returned compiler instance is owned by its caller and must be 375 deallocated by the caller. If compilation is not supported for this 376 language then this method returns NULL. */ 377 378 virtual compile_instance *get_compile_instance () const 379 { 380 return nullptr; 381 } 382 383 /* This method must be overridden if 'get_compile_instance' is 384 overridden. 385 386 This takes the user-supplied text and returns a new bit of code 387 to compile. 388 389 INST is the compiler instance being used. 390 INPUT is the user's input text. 391 GDBARCH is the architecture to use. 392 EXPR_BLOCK is the block in which the expression is being 393 parsed. 394 EXPR_PC is the PC at which the expression is being parsed. */ 395 396 virtual std::string compute_program (compile_instance *inst, 397 const char *input, 398 struct gdbarch *gdbarch, 399 const struct block *expr_block, 400 CORE_ADDR expr_pc) const 401 { 402 gdb_assert_not_reached ("language_defn::compute_program"); 403 } 404 405 /* Hash the given symbol search name. */ 406 virtual unsigned int search_name_hash (const char *name) const; 407 408 /* Demangle a symbol according to this language's rules. Unlike 409 la_demangle, this does not take any options. 410 411 *DEMANGLED will be set by this function. 412 413 If this function returns false, then *DEMANGLED must always be set 414 to NULL. 415 416 If this function returns true, the implementation may set this to 417 a xmalloc'd string holding the demangled form. However, it is 418 not required to. The string, if any, is owned by the caller. 419 420 The resulting string should be of the form that will be 421 installed into a symbol. */ 422 virtual bool sniff_from_mangled_name (const char *mangled, 423 char **demangled) const 424 { 425 *demangled = nullptr; 426 return false; 427 } 428 429 /* Return demangled language symbol version of MANGLED, or NULL. */ 430 virtual char *demangle (const char *mangled, int options) const 431 { 432 return nullptr; 433 } 434 435 /* Print a type using syntax appropriate for this language. */ 436 437 virtual void print_type (struct type *, const char *, struct ui_file *, int, 438 int, const struct type_print_options *) const = 0; 439 440 /* PC is possibly an unknown languages trampoline. 441 If that PC falls in a trampoline belonging to this language, return 442 the address of the first pc in the real function, or 0 if it isn't a 443 language tramp for this language. */ 444 virtual CORE_ADDR skip_trampoline (struct frame_info *fi, CORE_ADDR pc) const 445 { 446 return (CORE_ADDR) 0; 447 } 448 449 /* Return class name of a mangled method name or NULL. */ 450 virtual char *class_name_from_physname (const char *physname) const 451 { 452 return nullptr; 453 } 454 455 /* The list of characters forming word boundaries. */ 456 virtual const char *word_break_characters (void) const 457 { 458 return default_word_break_characters (); 459 } 460 461 /* Add to the completion tracker all symbols which are possible 462 completions for TEXT. WORD is the entire command on which the 463 completion is being made. If CODE is TYPE_CODE_UNDEF, then all 464 symbols should be examined; otherwise, only STRUCT_DOMAIN symbols 465 whose type has a code of CODE should be matched. */ 466 467 virtual void collect_symbol_completion_matches 468 (completion_tracker &tracker, 469 complete_symbol_mode mode, 470 symbol_name_match_type name_match_type, 471 const char *text, 472 const char *word, 473 enum type_code code) const 474 { 475 return default_collect_symbol_completion_matches_break_on 476 (tracker, mode, name_match_type, text, word, "", code); 477 } 478 479 /* This is a function that lookup_symbol will call when it gets to 480 the part of symbol lookup where C looks up static and global 481 variables. This default implements the basic C lookup rules. */ 482 483 virtual struct block_symbol lookup_symbol_nonlocal 484 (const char *name, 485 const struct block *block, 486 const domain_enum domain) const; 487 488 /* Return an expression that can be used for a location 489 watchpoint. TYPE is a pointer type that points to the memory 490 to watch, and ADDR is the address of the watched memory. */ 491 virtual gdb::unique_xmalloc_ptr<char> watch_location_expression 492 (struct type *type, CORE_ADDR addr) const; 493 494 /* List of all known languages. */ 495 static const struct language_defn *languages[nr_languages]; 496 497 /* Print a top-level value using syntax appropriate for this language. */ 498 virtual void value_print (struct value *val, struct ui_file *stream, 499 const struct value_print_options *options) const; 500 501 /* Print a value using syntax appropriate for this language. RECURSE is 502 the recursion depth. It is zero-based. */ 503 virtual void value_print_inner 504 (struct value *val, struct ui_file *stream, int recurse, 505 const struct value_print_options *options) const; 506 507 /* Parser function. */ 508 509 virtual int parser (struct parser_state *ps) const; 510 511 /* Given an expression *EXPP created by prefixifying the result of 512 la_parser, perform any remaining processing necessary to complete its 513 translation. *EXPP may change; la_post_parser is responsible for 514 releasing its previous contents, if necessary. If VOID_CONTEXT_P, 515 then no value is expected from the expression. If COMPLETING is 516 non-zero, then the expression has been parsed for completion, not 517 evaluation. */ 518 519 virtual void post_parser (expression_up *expp, int void_context_p, 520 int completing, 521 innermost_block_tracker *tracker) const 522 { 523 /* By default the post-parser does nothing. */ 524 } 525 526 /* Print the character CH (of type CHTYPE) on STREAM as part of the 527 contents of a literal string whose delimiter is QUOTER. */ 528 529 virtual void emitchar (int ch, struct type *chtype, 530 struct ui_file *stream, int quoter) const; 531 532 virtual void printchar (int ch, struct type *chtype, 533 struct ui_file * stream) const; 534 535 /* Print the character string STRING, printing at most LENGTH characters. 536 Printing stops early if the number hits print_max; repeat counts 537 are printed as appropriate. Print ellipses at the end if we 538 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES. */ 539 540 virtual void printstr (struct ui_file *stream, struct type *elttype, 541 const gdb_byte *string, unsigned int length, 542 const char *encoding, int force_ellipses, 543 const struct value_print_options *options) const; 544 545 546 /* Print a typedef using syntax appropriate for this language. 547 TYPE is the underlying type. NEW_SYMBOL is the symbol naming 548 the type. STREAM is the output stream on which to print. */ 549 550 virtual void print_typedef (struct type *type, struct symbol *new_symbol, 551 struct ui_file *stream) const; 552 553 /* Return true if TYPE is a string type. */ 554 virtual bool is_string_type_p (struct type *type) const; 555 556 protected: 557 558 /* This is the overridable part of the GET_SYMBOL_NAME_MATCHER method. 559 See that method for a description of the arguments. */ 560 561 virtual symbol_name_matcher_ftype *get_symbol_name_matcher_inner 562 (const lookup_name_info &lookup_name) const; 563 }; 564 565 /* Pointer to the language_defn for our current language. This pointer 566 always points to *some* valid struct; it can be used without checking 567 it for validity. 568 569 The current language affects expression parsing and evaluation 570 (FIXME: it might be cleaner to make the evaluation-related stuff 571 separate exp_opcodes for each different set of semantics. We 572 should at least think this through more clearly with respect to 573 what happens if the language is changed between parsing and 574 evaluation) and printing of things like types and arrays. It does 575 *not* affect symbol-reading-- each source file in a symbol-file has 576 its own language and we should keep track of that regardless of the 577 language when symbols are read. If we want some manual setting for 578 the language of symbol files (e.g. detecting when ".c" files are 579 C++), it should be a separate setting from the current_language. */ 580 581 extern const struct language_defn *current_language; 582 583 /* Pointer to the language_defn expected by the user, e.g. the language 584 of main(), or the language we last mentioned in a message, or C. */ 585 586 extern const struct language_defn *expected_language; 587 588 /* Warning issued when current_language and the language of the current 589 frame do not match. */ 590 591 extern const char lang_frame_mismatch_warn[]; 592 593 /* language_mode == 594 language_mode_auto: current_language automatically set upon selection 595 of scope (e.g. stack frame) 596 language_mode_manual: current_language set only by user. */ 597 598 extern enum language_mode 599 { 600 language_mode_auto, language_mode_manual 601 } 602 language_mode; 603 604 struct type *language_bool_type (const struct language_defn *l, 605 struct gdbarch *gdbarch); 606 607 struct type *language_string_char_type (const struct language_defn *l, 608 struct gdbarch *gdbarch); 609 610 /* Look up type NAME in language L, and return its definition for architecture 611 GDBARCH. Returns NULL if not found. */ 612 613 struct type *language_lookup_primitive_type (const struct language_defn *l, 614 struct gdbarch *gdbarch, 615 const char *name); 616 617 /* Wrapper around language_lookup_primitive_type to return the 618 corresponding symbol. */ 619 620 struct symbol * 621 language_lookup_primitive_type_as_symbol (const struct language_defn *l, 622 struct gdbarch *gdbarch, 623 const char *name); 624 625 626 /* These macros define the behaviour of the expression 627 evaluator. */ 628 629 /* Should we range check values against the domain of their type? */ 630 #define RANGE_CHECK (range_check != range_check_off) 631 632 /* "cast" really means conversion. */ 633 /* FIXME -- should be a setting in language_defn. */ 634 #define CAST_IS_CONVERSION(LANG) ((LANG)->la_language == language_c || \ 635 (LANG)->la_language == language_cplus || \ 636 (LANG)->la_language == language_objc) 637 638 extern void language_info (int); 639 640 extern enum language set_language (enum language); 641 642 643 /* This page contains functions that return things that are 644 specific to languages. Each of these functions is based on 645 the current setting of working_lang, which the user sets 646 with the "set language" command. */ 647 648 #define LA_PRINT_TYPE(type,varstring,stream,show,level,flags) \ 649 (current_language->print_type(type,varstring,stream,show,level,flags)) 650 651 #define LA_PRINT_TYPEDEF(type,new_symbol,stream) \ 652 (current_language->print_typedef (type,new_symbol,stream)) 653 654 #define LA_VALUE_PRINT(val,stream,options) \ 655 (current_language->value_print (val,stream,options)) 656 657 #define LA_PRINT_CHAR(ch, type, stream) \ 658 (current_language->printchar (ch, type, stream)) 659 #define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options) \ 660 (current_language->printstr (stream, elttype, string, length, \ 661 encoding, force_ellipses,options)) 662 #define LA_EMIT_CHAR(ch, type, stream, quoter) \ 663 (current_language->emitchar (ch, type, stream, quoter)) 664 665 #define LA_PRINT_ARRAY_INDEX(index_type, index_value, stream, options) \ 666 (current_language->print_array_index(index_type, index_value, stream, \ 667 options)) 668 669 #define LA_ITERATE_OVER_SYMBOLS(BLOCK, NAME, DOMAIN, CALLBACK) \ 670 (current_language->iterate_over_symbols (BLOCK, NAME, DOMAIN, CALLBACK)) 671 672 /* Test a character to decide whether it can be printed in literal form 673 or needs to be printed in another representation. For example, 674 in C the literal form of the character with octal value 141 is 'a' 675 and the "other representation" is '\141'. The "other representation" 676 is program language dependent. */ 677 678 #define PRINT_LITERAL_FORM(c) \ 679 ((c) >= 0x20 \ 680 && ((c) < 0x7F || (c) >= 0xA0) \ 681 && (!sevenbit_strings || (c) < 0x80)) 682 683 /* Type predicates */ 684 685 extern int pointer_type (struct type *); 686 687 /* Error messages */ 688 689 extern void range_error (const char *, ...) ATTRIBUTE_PRINTF (1, 2); 690 691 /* Data: Does this value represent "truth" to the current language? */ 692 693 extern int value_true (struct value *); 694 695 /* Misc: The string representing a particular enum language. */ 696 697 extern enum language language_enum (const char *str); 698 699 extern const struct language_defn *language_def (enum language); 700 701 extern const char *language_str (enum language); 702 703 /* Check for a language-specific trampoline. */ 704 705 extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc); 706 707 /* Return demangled language symbol, or NULL. */ 708 extern char *language_demangle (const struct language_defn *current_language, 709 const char *mangled, int options); 710 711 /* Return information about whether TYPE should be passed 712 (and returned) by reference at the language level. */ 713 struct language_pass_by_ref_info language_pass_by_reference (struct type *type); 714 715 void c_get_string (struct value *value, 716 gdb::unique_xmalloc_ptr<gdb_byte> *buffer, 717 int *length, struct type **char_type, 718 const char **charset); 719 720 /* Get LANG's symbol_name_matcher method for LOOKUP_NAME. Returns 721 default_symbol_name_matcher if not set. LANG is used as a hint; 722 the function may ignore it depending on the current language and 723 LOOKUP_NAME. Specifically, if the current language is Ada, this 724 may return an Ada matcher regardless of LANG. */ 725 symbol_name_matcher_ftype *get_symbol_name_matcher 726 (const language_defn *lang, const lookup_name_info &lookup_name); 727 728 /* Save the current language and restore it upon destruction. */ 729 730 class scoped_restore_current_language 731 { 732 public: 733 734 explicit scoped_restore_current_language () 735 : m_lang (current_language->la_language) 736 { 737 } 738 739 ~scoped_restore_current_language () 740 { 741 set_language (m_lang); 742 } 743 744 scoped_restore_current_language (const scoped_restore_current_language &) 745 = delete; 746 scoped_restore_current_language &operator= 747 (const scoped_restore_current_language &) = delete; 748 749 private: 750 751 enum language m_lang; 752 }; 753 754 /* If language_mode is language_mode_auto, 755 then switch current language to the language of SYM 756 and restore current language upon destruction. 757 758 Else do nothing. */ 759 760 class scoped_switch_to_sym_language_if_auto 761 { 762 public: 763 764 explicit scoped_switch_to_sym_language_if_auto (const struct symbol *sym) 765 { 766 if (language_mode == language_mode_auto) 767 { 768 m_lang = current_language->la_language; 769 m_switched = true; 770 set_language (sym->language ()); 771 } 772 else 773 { 774 m_switched = false; 775 /* Assign to m_lang to silence a GCC warning. See 776 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80635. */ 777 m_lang = language_unknown; 778 } 779 } 780 781 ~scoped_switch_to_sym_language_if_auto () 782 { 783 if (m_switched) 784 set_language (m_lang); 785 } 786 787 DISABLE_COPY_AND_ASSIGN (scoped_switch_to_sym_language_if_auto); 788 789 private: 790 bool m_switched; 791 enum language m_lang; 792 }; 793 794 #endif /* defined (LANGUAGE_H) */ 795