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