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