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