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