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