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