gdb/language.c

   1 /* Multiple source language support for GDB.
   2
   3    Copyright (C) 1991-2022 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 /* This file contains functions that return things that are specific
  24    to languages.  Each function should examine current_language if necessary,
  25    and return the appropriate result.  */
  26
  27 /* FIXME:  Most of these would be better organized as macros which
  28    return data out of a "language-specific" struct pointer that is set
  29    whenever the working language changes.  That would be a lot faster.  */
  30
  31 #include "defs.h"
  32 #include <ctype.h>
  33 #include "symtab.h"
  34 #include "gdbtypes.h"
  35 #include "value.h"
  36 #include "gdbcmd.h"
  37 #include "expression.h"
  38 #include "language.h"
  39 #include "varobj.h"
  40 #include "target.h"
  41 #include "parser-defs.h"
  42 #include "demangle.h"
  43 #include "symfile.h"
  44 #include "cp-support.h"
  45 #include "frame.h"
  46 #include "c-lang.h"
  47 #include <algorithm>
  48 #include "gdbarch.h"
  49 #include "compile/compile-internal.h"
  50
  51 static void set_range_case (void);
  52
  53 /* range_mode ==
  54    range_mode_auto:   range_check set automatically to default of language.
  55    range_mode_manual: range_check set manually by user.  */
  56
  57 enum range_mode
  58   {
  59     range_mode_auto, range_mode_manual
  60   };
  61
  62 /* case_mode ==
  63    case_mode_auto:   case_sensitivity set upon selection of scope.
  64    case_mode_manual: case_sensitivity set only by user.  */
  65
  66 enum case_mode
  67   {
  68     case_mode_auto, case_mode_manual
  69   };
  70
  71 /* The current (default at startup) state of type and range checking.
  72    (If the modes are set to "auto", though, these are changed based
  73    on the default language at startup, and then again based on the
  74    language of the first source file.  */
  75
  76 static enum range_mode range_mode = range_mode_auto;
  77 enum range_check range_check = range_check_off;
  78 static enum case_mode case_mode = case_mode_auto;
  79 enum case_sensitivity case_sensitivity = case_sensitive_on;
  80
  81 /* The current language and language_mode (see language.h).  */
  82
  83 const struct language_defn *current_language = nullptr;
  84 enum language_mode language_mode = language_mode_auto;
  85
  86 /* The language that the user expects to be typing in (the language
  87    of main(), or the last language we notified them about, or C).  */
  88
  89 const struct language_defn *expected_language;
  90
  91 /* Define the array containing all languages.  */
  92
  93 const struct language_defn *language_defn::languages[nr_languages];
  94
  95 /* The current values of the "set language/range/case-sensitive" enum
  96    commands.  */
  97 static const char *language;
  98 static const char *range;
  99 static const char *case_sensitive;
 100
 101 /* See language.h.  */
 102 const char lang_frame_mismatch_warn[] =
 103 N_("Warning: the current language does not match this frame.");
 104 \f
 105 /* This page contains the functions corresponding to GDB commands
 106    and their helpers.  */
 107
 108 /* Show command.  Display a warning if the language set
 109    does not match the frame.  */
 110 static void
 111 show_language_command (struct ui_file *file, int from_tty,
 112                        struct cmd_list_element *c, const char *value)
 113 {
 114   enum language flang;          /* The language of the frame.  */
 115
 116   if (language_mode == language_mode_auto)
 117     fprintf_filtered (gdb_stdout,
 118                       _("The current source language is "
 119                         "\"auto; currently %s\".\n"),
 120                       current_language->name ());
 121   else
 122     fprintf_filtered (gdb_stdout,
 123                       _("The current source language is \"%s\".\n"),
 124                       current_language->name ());
 125
 126   if (has_stack_frames ())
 127     {
 128       struct frame_info *frame;
 129
 130       frame = get_selected_frame (NULL);
 131       flang = get_frame_language (frame);
 132       if (flang != language_unknown
 133           && language_mode == language_mode_manual
 134           && current_language->la_language != flang)
 135         printf_filtered ("%s\n", _(lang_frame_mismatch_warn));
 136     }
 137 }
 138
 139 /* Set command.  Change the current working language.  */
 140 static void
 141 set_language_command (const char *ignore,
 142                       int from_tty, struct cmd_list_element *c)
 143 {
 144   enum language flang = language_unknown;
 145
 146   /* "local" is a synonym of "auto".  */
 147   if (strcmp (language, "local") == 0)
 148     language = "auto";
 149
 150   /* Search the list of languages for a match.  */
 151   for (const auto &lang : language_defn::languages)
 152     {
 153       if (strcmp (lang->name (), language) == 0)
 154         {
 155           /* Found it!  Go into manual mode, and use this language.  */
 156           if (lang->la_language == language_auto)
 157             {
 158               /* Enter auto mode.  Set to the current frame's language, if
 159                  known, or fallback to the initial language.  */
 160               language_mode = language_mode_auto;
 161               try
 162                 {
 163                   struct frame_info *frame;
 164
 165                   frame = get_selected_frame (NULL);
 166                   flang = get_frame_language (frame);
 167                 }
 168               catch (const gdb_exception_error &ex)
 169                 {
 170                   flang = language_unknown;
 171                 }
 172
 173               if (flang != language_unknown)
 174                 set_language (flang);
 175               else
 176                 set_initial_language ();
 177               expected_language = current_language;
 178               return;
 179             }
 180           else
 181             {
 182               /* Enter manual mode.  Set the specified language.  */
 183               language_mode = language_mode_manual;
 184               current_language = lang;
 185               set_range_case ();
 186               expected_language = current_language;
 187               return;
 188             }
 189         }
 190     }
 191
 192   internal_error (__FILE__, __LINE__,
 193                   "Couldn't find language `%s' in known languages list.",
 194                   language);
 195 }
 196
 197 /* Show command.  Display a warning if the range setting does
 198    not match the current language.  */
 199 static void
 200 show_range_command (struct ui_file *file, int from_tty,
 201                     struct cmd_list_element *c, const char *value)
 202 {
 203   if (range_mode == range_mode_auto)
 204     {
 205       const char *tmp;
 206
 207       switch (range_check)
 208         {
 209         case range_check_on:
 210           tmp = "on";
 211           break;
 212         case range_check_off:
 213           tmp = "off";
 214           break;
 215         case range_check_warn:
 216           tmp = "warn";
 217           break;
 218         default:
 219           internal_error (__FILE__, __LINE__,
 220                           "Unrecognized range check setting.");
 221         }
 222
 223       fprintf_filtered (gdb_stdout,
 224                         _("Range checking is \"auto; currently %s\".\n"),
 225                         tmp);
 226     }
 227   else
 228     fprintf_filtered (gdb_stdout, _("Range checking is \"%s\".\n"),
 229                       value);
 230
 231   if (range_check == range_check_warn
 232       || ((range_check == range_check_on)
 233           != current_language->range_checking_on_by_default ()))
 234     warning (_("the current range check setting "
 235                "does not match the language.\n"));
 236 }
 237
 238 /* Set command.  Change the setting for range checking.  */
 239 static void
 240 set_range_command (const char *ignore,
 241                    int from_tty, struct cmd_list_element *c)
 242 {
 243   if (strcmp (range, "on") == 0)
 244     {
 245       range_check = range_check_on;
 246       range_mode = range_mode_manual;
 247     }
 248   else if (strcmp (range, "warn") == 0)
 249     {
 250       range_check = range_check_warn;
 251       range_mode = range_mode_manual;
 252     }
 253   else if (strcmp (range, "off") == 0)
 254     {
 255       range_check = range_check_off;
 256       range_mode = range_mode_manual;
 257     }
 258   else if (strcmp (range, "auto") == 0)
 259     {
 260       range_mode = range_mode_auto;
 261       set_range_case ();
 262       return;
 263     }
 264   else
 265     {
 266       internal_error (__FILE__, __LINE__,
 267                       _("Unrecognized range check setting: \"%s\""), range);
 268     }
 269   if (range_check == range_check_warn
 270       || ((range_check == range_check_on)
 271           != current_language->range_checking_on_by_default ()))
 272     warning (_("the current range check setting "
 273                "does not match the language.\n"));
 274 }
 275
 276 /* Show command.  Display a warning if the case sensitivity setting does
 277    not match the current language.  */
 278 static void
 279 show_case_command (struct ui_file *file, int from_tty,
 280                    struct cmd_list_element *c, const char *value)
 281 {
 282   if (case_mode == case_mode_auto)
 283     {
 284       const char *tmp = NULL;
 285
 286       switch (case_sensitivity)
 287         {
 288         case case_sensitive_on:
 289           tmp = "on";
 290           break;
 291         case case_sensitive_off:
 292           tmp = "off";
 293           break;
 294         default:
 295           internal_error (__FILE__, __LINE__,
 296                           "Unrecognized case-sensitive setting.");
 297         }
 298
 299       fprintf_filtered (gdb_stdout,
 300                         _("Case sensitivity in "
 301                           "name search is \"auto; currently %s\".\n"),
 302                         tmp);
 303     }
 304   else
 305     fprintf_filtered (gdb_stdout,
 306                       _("Case sensitivity in name search is \"%s\".\n"),
 307                       value);
 308
 309   if (case_sensitivity != current_language->case_sensitivity ())
 310     warning (_("the current case sensitivity setting does not match "
 311                "the language.\n"));
 312 }
 313
 314 /* Set command.  Change the setting for case sensitivity.  */
 315
 316 static void
 317 set_case_command (const char *ignore, int from_tty, struct cmd_list_element *c)
 318 {
 319    if (strcmp (case_sensitive, "on") == 0)
 320      {
 321        case_sensitivity = case_sensitive_on;
 322        case_mode = case_mode_manual;
 323      }
 324    else if (strcmp (case_sensitive, "off") == 0)
 325      {
 326        case_sensitivity = case_sensitive_off;
 327        case_mode = case_mode_manual;
 328      }
 329    else if (strcmp (case_sensitive, "auto") == 0)
 330      {
 331        case_mode = case_mode_auto;
 332        set_range_case ();
 333        return;
 334      }
 335    else
 336      {
 337        internal_error (__FILE__, __LINE__,
 338                        "Unrecognized case-sensitive setting: \"%s\"",
 339                        case_sensitive);
 340      }
 341
 342    if (case_sensitivity != current_language->case_sensitivity ())
 343      warning (_("the current case sensitivity setting does not match "
 344                 "the language.\n"));
 345 }
 346
 347 /* Set the status of range and type checking and case sensitivity based on
 348    the current modes and the current language.
 349    If SHOW is non-zero, then print out the current language,
 350    type and range checking status.  */
 351 static void
 352 set_range_case (void)
 353 {
 354   if (range_mode == range_mode_auto)
 355     range_check = (current_language->range_checking_on_by_default ()
 356                    ? range_check_on : range_check_off);
 357
 358   if (case_mode == case_mode_auto)
 359     case_sensitivity = current_language->case_sensitivity ();
 360 }
 361
 362 /* Set current language to (enum language) LANG.  Returns previous
 363    language.  */
 364
 365 enum language
 366 set_language (enum language lang)
 367 {
 368   enum language prev_language;
 369
 370   prev_language = current_language->la_language;
 371   current_language = language_def (lang);
 372   set_range_case ();
 373   return prev_language;
 374 }
 375 \f
 376
 377 /* See language.h.  */
 378
 379 void
 380 language_info ()
 381 {
 382   if (expected_language == current_language)
 383     return;
 384
 385   expected_language = current_language;
 386   printf_unfiltered (_("Current language:  %s\n"), language);
 387   show_language_command (NULL, 1, NULL, NULL);
 388 }
 389 \f
 390
 391 /* Returns non-zero if the value is a pointer type.  */
 392 int
 393 pointer_type (struct type *type)
 394 {
 395   return type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type);
 396 }
 397
 398 \f
 399 /* This page contains functions that return info about
 400    (struct value) values used in GDB.  */
 401
 402 /* Returns non-zero if the value VAL represents a true value.  */
 403 int
 404 value_true (struct value *val)
 405 {
 406   /* It is possible that we should have some sort of error if a non-boolean
 407      value is used in this context.  Possibly dependent on some kind of
 408      "boolean-checking" option like range checking.  But it should probably
 409      not depend on the language except insofar as is necessary to identify
 410      a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
 411      should be an error, probably).  */
 412   return !value_logical_not (val);
 413 }
 414 \f
 415 /* This page contains functions for the printing out of
 416    error messages that occur during type- and range-
 417    checking.  */
 418
 419 /* This is called when a language fails a range-check.  The
 420    first argument should be a printf()-style format string, and the
 421    rest of the arguments should be its arguments.  If range_check is
 422    range_check_on, an error is printed;  if range_check_warn, a warning;
 423    otherwise just the message.  */
 424
 425 void
 426 range_error (const char *string,...)
 427 {
 428   va_list args;
 429
 430   va_start (args, string);
 431   switch (range_check)
 432     {
 433     case range_check_warn:
 434       vwarning (string, args);
 435       break;
 436     case range_check_on:
 437       verror (string, args);
 438       break;
 439     case range_check_off:
 440       /* FIXME: cagney/2002-01-30: Should this function print anything
 441          when range error is off?  */
 442       vfprintf_filtered (gdb_stderr, string, args);
 443       fprintf_filtered (gdb_stderr, "\n");
 444       break;
 445     default:
 446       internal_error (__FILE__, __LINE__, _("bad switch"));
 447     }
 448   va_end (args);
 449 }
 450 \f
 451
 452 /* This page contains miscellaneous functions.  */
 453
 454 /* Return the language enum for a given language string.  */
 455
 456 enum language
 457 language_enum (const char *str)
 458 {
 459   for (const auto &lang : language_defn::languages)
 460     if (strcmp (lang->name (), str) == 0)
 461       return lang->la_language;
 462
 463   if (strcmp (str, "local") == 0)
 464     return language_auto;
 465
 466   return language_unknown;
 467 }
 468
 469 /* Return the language struct for a given language enum.  */
 470
 471 const struct language_defn *
 472 language_def (enum language lang)
 473 {
 474   const struct language_defn *l = language_defn::languages[lang];
 475   gdb_assert (l != nullptr);
 476   return l;
 477 }
 478
 479 /* Return the language as a string.  */
 480
 481 const char *
 482 language_str (enum language lang)
 483 {
 484   return language_def (lang)->name ();
 485 }
 486
 487 \f
 488
 489 /* Build and install the "set language LANG" command.  */
 490
 491 static void
 492 add_set_language_command ()
 493 {
 494   static const char **language_names;
 495
 496   /* Build the language names array, to be used as enumeration in the
 497      "set language" enum command.  +1 for "local" and +1 for NULL
 498      termination.  */
 499   language_names = new const char *[ARRAY_SIZE (language_defn::languages) + 2];
 500
 501   /* Display "auto", "local" and "unknown" first, and then the rest,
 502      alpha sorted.  */
 503   const char **language_names_p = language_names;
 504   *language_names_p++ = language_def (language_auto)->name ();
 505   *language_names_p++ = "local";
 506   *language_names_p++ = language_def (language_unknown)->name ();
 507   const char **sort_begin = language_names_p;
 508   for (const auto &lang : language_defn::languages)
 509     {
 510       /* Already handled above.  */
 511       if (lang->la_language == language_auto
 512           || lang->la_language == language_unknown)
 513         continue;
 514       *language_names_p++ = lang->name ();
 515     }
 516   *language_names_p = NULL;
 517   std::sort (sort_begin, language_names_p, compare_cstrings);
 518
 519   /* Add the filename extensions.  */
 520   for (const auto &lang : language_defn::languages)
 521     for (const char * const &ext : lang->filename_extensions ())
 522       add_filename_language (ext, lang->la_language);
 523
 524   /* Build the "help set language" docs.  */
 525   string_file doc;
 526
 527   doc.printf (_("Set the current source language.\n"
 528                 "The currently understood settings are:\n\nlocal or "
 529                 "auto    Automatic setting based on source file"));
 530
 531   for (const auto &lang : language_defn::languages)
 532     {
 533       /* Already dealt with these above.  */
 534       if (lang->la_language == language_unknown
 535           || lang->la_language == language_auto)
 536         continue;
 537
 538       /* Note that we add the newline at the front, so we don't wind
 539          up with a trailing newline.  */
 540       doc.printf ("\n%-16s Use the %s language",
 541                   lang->name (),
 542                   lang->natural_name ());
 543     }
 544
 545   add_setshow_enum_cmd ("language", class_support,
 546                         language_names,
 547                         &language,
 548                         doc.c_str (),
 549                         _("Show the current source language."),
 550                         NULL, set_language_command,
 551                         show_language_command,
 552                         &setlist, &showlist);
 553 }
 554
 555 /* Iterate through all registered languages looking for and calling
 556    any non-NULL struct language_defn.skip_trampoline() functions.
 557    Return the result from the first that returns non-zero, or 0 if all
 558    `fail'.  */
 559 CORE_ADDR
 560 skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
 561 {
 562   for (const auto &lang : language_defn::languages)
 563     {
 564       CORE_ADDR real_pc = lang->skip_trampoline (frame, pc);
 565
 566       if (real_pc != 0)
 567         return real_pc;
 568     }
 569
 570   return 0;
 571 }
 572
 573 /* Return demangled language symbol, or NULL.
 574    FIXME: Options are only useful for certain languages and ignored
 575    by others, so it would be better to remove them here and have a
 576    more flexible demangler for the languages that need it.
 577    FIXME: Sometimes the demangler is invoked when we don't know the
 578    language, so we can't use this everywhere.  */
 579 char *
 580 language_demangle (const struct language_defn *current_language,
 581                                 const char *mangled, int options)
 582 {
 583   if (current_language != NULL)
 584     return current_language->demangle_symbol (mangled, options);
 585   return NULL;
 586 }
 587
 588 /* Return information about whether TYPE should be passed
 589    (and returned) by reference at the language level.  */
 590
 591 struct language_pass_by_ref_info
 592 language_pass_by_reference (struct type *type)
 593 {
 594   return current_language->pass_by_reference_info (type);
 595 }
 596
 597 /* Return the default string containing the list of characters
 598    delimiting words.  This is a reasonable default value that
 599    most languages should be able to use.  */
 600
 601 const char *
 602 default_word_break_characters (void)
 603 {
 604   return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
 605 }
 606
 607 /* See language.h.  */
 608
 609 void
 610 language_defn::print_array_index (struct type *index_type, LONGEST index,
 611                                   struct ui_file *stream,
 612                                   const value_print_options *options) const
 613 {
 614   struct value *index_value = value_from_longest (index_type, index);
 615
 616   fprintf_filtered (stream, "[");
 617   value_print (index_value, stream, options);
 618   fprintf_filtered (stream, "] = ");
 619 }
 620
 621 /* See language.h.  */
 622
 623 gdb::unique_xmalloc_ptr<char>
 624 language_defn::watch_location_expression (struct type *type,
 625                                           CORE_ADDR addr) const
 626 {
 627   /* Generates an expression that assumes a C like syntax is valid.  */
 628   type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
 629   std::string name = type_to_string (type);
 630   return gdb::unique_xmalloc_ptr<char>
 631     (xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr)));
 632 }
 633
 634 /* See language.h.  */
 635
 636 void
 637 language_defn::value_print (struct value *val, struct ui_file *stream,
 638                const struct value_print_options *options) const
 639 {
 640   return c_value_print (val, stream, options);
 641 }
 642
 643 /* See language.h.  */
 644
 645 int
 646 language_defn::parser (struct parser_state *ps) const
 647 {
 648   return c_parse (ps);
 649 }
 650
 651 /* See language.h.  */
 652
 653 void
 654 language_defn::value_print_inner
 655         (struct value *val, struct ui_file *stream, int recurse,
 656          const struct value_print_options *options) const
 657 {
 658   return c_value_print_inner (val, stream, recurse, options);
 659 }
 660
 661 /* See language.h.  */
 662
 663 void
 664 language_defn::emitchar (int ch, struct type *chtype,
 665                          struct ui_file * stream, int quoter) const
 666 {
 667   c_emit_char (ch, chtype, stream, quoter);
 668 }
 669
 670 /* See language.h.  */
 671
 672 void
 673 language_defn::printstr (struct ui_file *stream, struct type *elttype,
 674                          const gdb_byte *string, unsigned int length,
 675                          const char *encoding, int force_ellipses,
 676                          const struct value_print_options *options) const
 677 {
 678   c_printstr (stream, elttype, string, length, encoding, force_ellipses,
 679               options);
 680 }
 681
 682 /* See language.h.  */
 683
 684 void
 685 language_defn::print_typedef (struct type *type, struct symbol *new_symbol,
 686                               struct ui_file *stream) const
 687 {
 688   c_print_typedef (type, new_symbol, stream);
 689 }
 690
 691 /* See language.h.  */
 692
 693 bool
 694 language_defn::is_string_type_p (struct type *type) const
 695 {
 696   return c_is_string_type_p (type);
 697 }
 698
 699 /* See language.h.  */
 700
 701 std::unique_ptr<compile_instance>
 702 language_defn::get_compile_instance () const
 703 {
 704   return {};
 705 }
 706
 707 /* The default implementation of the get_symbol_name_matcher_inner method
 708    from the language_defn class.  Matches with strncmp_iw.  */
 709
 710 static bool
 711 default_symbol_name_matcher (const char *symbol_search_name,
 712                              const lookup_name_info &lookup_name,
 713                              completion_match_result *comp_match_res)
 714 {
 715   gdb::string_view name = lookup_name.name ();
 716   completion_match_for_lcd *match_for_lcd
 717     = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
 718   strncmp_iw_mode mode = (lookup_name.completion_mode ()
 719                           ? strncmp_iw_mode::NORMAL
 720                           : strncmp_iw_mode::MATCH_PARAMS);
 721
 722   if (strncmp_iw_with_mode (symbol_search_name, name.data (), name.size (),
 723                             mode, language_minimal, match_for_lcd) == 0)
 724     {
 725       if (comp_match_res != NULL)
 726         comp_match_res->set_match (symbol_search_name);
 727       return true;
 728     }
 729   else
 730     return false;
 731 }
 732
 733 /* See language.h.  */
 734
 735 symbol_name_matcher_ftype *
 736 language_defn::get_symbol_name_matcher
 737         (const lookup_name_info &lookup_name) const
 738 {
 739   /* If currently in Ada mode, and the lookup name is wrapped in
 740      '<...>', hijack all symbol name comparisons using the Ada
 741      matcher, which handles the verbatim matching.  */
 742   if (current_language->la_language == language_ada
 743       && lookup_name.ada ().verbatim_p ())
 744     return current_language->get_symbol_name_matcher_inner (lookup_name);
 745
 746   return this->get_symbol_name_matcher_inner (lookup_name);
 747 }
 748
 749 /* See language.h.  */
 750
 751 symbol_name_matcher_ftype *
 752 language_defn::get_symbol_name_matcher_inner
 753         (const lookup_name_info &lookup_name) const
 754 {
 755   return default_symbol_name_matcher;
 756 }
 757
 758 /* See language.h.  */
 759
 760 const struct lang_varobj_ops *
 761 language_defn::varobj_ops () const
 762 {
 763   /* The ops for the C language are suitable for the vast majority of the
 764      supported languages.  */
 765   return &c_varobj_ops;
 766 }
 767
 768 /* Parent class for both the "auto" and "unknown" languages.  These two
 769    pseudo-languages are very similar so merging their implementations like
 770    this makes sense.  */
 771
 772 class auto_or_unknown_language : public language_defn
 773 {
 774 public:
 775   auto_or_unknown_language (enum language lang)
 776     : language_defn (lang)
 777   { /* Nothing.  */ }
 778
 779   /* See language.h.  */
 780   void language_arch_info (struct gdbarch *gdbarch,
 781                            struct language_arch_info *lai) const override
 782   {
 783     lai->set_string_char_type (builtin_type (gdbarch)->builtin_char);
 784     lai->set_bool_type (builtin_type (gdbarch)->builtin_int);
 785   }
 786
 787   /* See language.h.  */
 788
 789   void print_type (struct type *type, const char *varstring,
 790                    struct ui_file *stream, int show, int level,
 791                    const struct type_print_options *flags) const override
 792   {
 793     error (_("type printing not implemented for language \"%s\""),
 794            natural_name ());
 795   }
 796
 797   /* See language.h.  */
 798
 799   char *demangle_symbol (const char *mangled, int options) const override
 800   {
 801     /* The auto language just uses the C++ demangler.  */
 802     return gdb_demangle (mangled, options);
 803   }
 804
 805   /* See language.h.  */
 806
 807   void value_print (struct value *val, struct ui_file *stream,
 808                     const struct value_print_options *options) const override
 809   {
 810     error (_("value printing not implemented for language \"%s\""),
 811            natural_name ());
 812   }
 813
 814   /* See language.h.  */
 815
 816   void value_print_inner
 817         (struct value *val, struct ui_file *stream, int recurse,
 818          const struct value_print_options *options) const override
 819   {
 820     error (_("inner value printing not implemented for language \"%s\""),
 821            natural_name ());
 822   }
 823
 824   /* See language.h.  */
 825
 826   int parser (struct parser_state *ps) const override
 827   {
 828     error (_("expression parsing not implemented for language \"%s\""),
 829            natural_name ());
 830   }
 831
 832   /* See language.h.  */
 833
 834   void emitchar (int ch, struct type *chtype,
 835                  struct ui_file *stream, int quoter) const override
 836   {
 837     error (_("emit character not implemented for language \"%s\""),
 838            natural_name ());
 839   }
 840
 841   /* See language.h.  */
 842
 843   void printchar (int ch, struct type *chtype,
 844                   struct ui_file *stream) const override
 845   {
 846     error (_("print character not implemented for language \"%s\""),
 847            natural_name ());
 848   }
 849
 850   /* See language.h.  */
 851
 852   void printstr (struct ui_file *stream, struct type *elttype,
 853                  const gdb_byte *string, unsigned int length,
 854                  const char *encoding, int force_ellipses,
 855                  const struct value_print_options *options) const override
 856   {
 857     error (_("print string not implemented for language \"%s\""),
 858            natural_name ());
 859   }
 860
 861   /* See language.h.  */
 862
 863   void print_typedef (struct type *type, struct symbol *new_symbol,
 864                       struct ui_file *stream) const override
 865   {
 866     error (_("print typedef not implemented for language \"%s\""),
 867            natural_name ());
 868   }
 869
 870   /* See language.h.  */
 871
 872   bool is_string_type_p (struct type *type) const override
 873   {
 874     type = check_typedef (type);
 875     while (type->code () == TYPE_CODE_REF)
 876       {
 877         type = TYPE_TARGET_TYPE (type);
 878         type = check_typedef (type);
 879       }
 880     return (type->code () == TYPE_CODE_STRING);
 881   }
 882
 883   /* See language.h.  */
 884
 885   const char *name_of_this () const override
 886   { return "this"; }
 887 };
 888
 889 /* Class representing the fake "auto" language.  */
 890
 891 class auto_language : public auto_or_unknown_language
 892 {
 893 public:
 894   auto_language ()
 895     : auto_or_unknown_language (language_auto)
 896   { /* Nothing.  */ }
 897
 898   /* See language.h.  */
 899
 900   const char *name () const override
 901   { return "auto"; }
 902
 903   /* See language.h.  */
 904
 905   const char *natural_name () const override
 906   { return "Auto"; }
 907 };
 908
 909 /* Single instance of the fake "auto" language.  */
 910
 911 static auto_language auto_language_defn;
 912
 913 /* Class representing the unknown language.  */
 914
 915 class unknown_language : public auto_or_unknown_language
 916 {
 917 public:
 918   unknown_language ()
 919     : auto_or_unknown_language (language_unknown)
 920   { /* Nothing.  */ }
 921
 922   /* See language.h.  */
 923
 924   const char *name () const override
 925   { return "unknown"; }
 926
 927   /* See language.h.  */
 928
 929   const char *natural_name () const override
 930   { return "Unknown"; }
 931
 932   /* See language.h.  */
 933
 934   bool store_sym_names_in_linkage_form_p () const override
 935   { return true; }
 936 };
 937
 938 /* Single instance of the unknown language class.  */
 939
 940 static unknown_language unknown_language_defn;
 941
 942 \f
 943 /* Per-architecture language information.  */
 944
 945 static struct gdbarch_data *language_gdbarch_data;
 946
 947 struct language_gdbarch
 948 {
 949   /* A vector of per-language per-architecture info.  Indexed by "enum
 950      language".  */
 951   struct language_arch_info arch_info[nr_languages];
 952 };
 953
 954 static void *
 955 language_gdbarch_post_init (struct gdbarch *gdbarch)
 956 {
 957   struct language_gdbarch *l
 958     = obstack_new<struct language_gdbarch> (gdbarch_obstack (gdbarch));
 959   for (const auto &lang : language_defn::languages)
 960     {
 961       gdb_assert (lang != nullptr);
 962       lang->language_arch_info (gdbarch, &l->arch_info[lang->la_language]);
 963     }
 964
 965   return l;
 966 }
 967
 968 /* See language.h.  */
 969
 970 struct type *
 971 language_string_char_type (const struct language_defn *la,
 972                            struct gdbarch *gdbarch)
 973 {
 974   struct language_gdbarch *ld
 975     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
 976   return ld->arch_info[la->la_language].string_char_type ();
 977 }
 978
 979 /* See language.h.  */
 980
 981 struct type *
 982 language_bool_type (const struct language_defn *la,
 983                     struct gdbarch *gdbarch)
 984 {
 985   struct language_gdbarch *ld
 986     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
 987   return ld->arch_info[la->la_language].bool_type ();
 988 }
 989
 990 /* See language.h.  */
 991
 992 struct type *
 993 language_arch_info::bool_type () const
 994 {
 995   if (m_bool_type_name != nullptr)
 996     {
 997       struct symbol *sym;
 998
 999       sym = lookup_symbol (m_bool_type_name, NULL, VAR_DOMAIN, NULL).symbol;
1000       if (sym != nullptr)
1001         {
1002           struct type *type = SYMBOL_TYPE (sym);
1003           if (type != nullptr && type->code () == TYPE_CODE_BOOL)
1004             return type;
1005         }
1006     }
1007
1008   return m_bool_type_default;
1009 }
1010
1011 /* See language.h.  */
1012
1013 struct symbol *
1014 language_arch_info::type_and_symbol::alloc_type_symbol
1015         (enum language lang, struct type *type)
1016 {
1017   struct symbol *symbol;
1018   struct gdbarch *gdbarch;
1019   gdb_assert (!type->is_objfile_owned ());
1020   gdbarch = type->arch_owner ();
1021   symbol = new (gdbarch_obstack (gdbarch)) struct symbol ();
1022   symbol->m_name = type->name ();
1023   symbol->set_language (lang, nullptr);
1024   symbol->owner.arch = gdbarch;
1025   SYMBOL_OBJFILE_OWNED (symbol) = 0;
1026   symbol->set_section_index (0);
1027   SYMBOL_TYPE (symbol) = type;
1028   SYMBOL_DOMAIN (symbol) = VAR_DOMAIN;
1029   SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF;
1030   return symbol;
1031 }
1032
1033 /* See language.h.  */
1034
1035 language_arch_info::type_and_symbol *
1036 language_arch_info::lookup_primitive_type_and_symbol (const char *name)
1037 {
1038   for (struct type_and_symbol &tas : primitive_types_and_symbols)
1039     {
1040       if (strcmp (tas.type ()->name (), name) == 0)
1041         return &tas;
1042     }
1043
1044   return nullptr;
1045 }
1046
1047 /* See language.h.  */
1048
1049 struct type *
1050 language_arch_info::lookup_primitive_type (const char *name)
1051 {
1052   type_and_symbol *tas = lookup_primitive_type_and_symbol (name);
1053   if (tas != nullptr)
1054     return tas->type ();
1055   return nullptr;
1056 }
1057
1058 /* See language.h.  */
1059
1060 struct type *
1061 language_arch_info::lookup_primitive_type
1062   (gdb::function_view<bool (struct type *)> filter)
1063 {
1064   for (struct type_and_symbol &tas : primitive_types_and_symbols)
1065     {
1066       if (filter (tas.type ()))
1067         return tas.type ();
1068     }
1069
1070   return nullptr;
1071 }
1072
1073 /* See language.h.  */
1074
1075 struct symbol *
1076 language_arch_info::lookup_primitive_type_as_symbol (const char *name,
1077                                                      enum language lang)
1078 {
1079   type_and_symbol *tas = lookup_primitive_type_and_symbol (name);
1080   if (tas != nullptr)
1081     return tas->symbol (lang);
1082   return nullptr;
1083 }
1084
1085 /* Helper for the language_lookup_primitive_type overloads to forward
1086    to the corresponding language's lookup_primitive_type overload.  */
1087
1088 template<typename T>
1089 static struct type *
1090 language_lookup_primitive_type_1 (const struct language_defn *la,
1091                                   struct gdbarch *gdbarch,
1092                                   T arg)
1093 {
1094   struct language_gdbarch *ld =
1095     (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1096   return ld->arch_info[la->la_language].lookup_primitive_type (arg);
1097 }
1098
1099 /* See language.h.  */
1100
1101 struct type *
1102 language_lookup_primitive_type (const struct language_defn *la,
1103                                 struct gdbarch *gdbarch,
1104                                 const char *name)
1105 {
1106   return language_lookup_primitive_type_1 (la, gdbarch, name);
1107 }
1108
1109 /* See language.h.  */
1110
1111 struct type *
1112 language_lookup_primitive_type (const struct language_defn *la,
1113                                 struct gdbarch *gdbarch,
1114                                 gdb::function_view<bool (struct type *)> filter)
1115 {
1116   return language_lookup_primitive_type_1 (la, gdbarch, filter);
1117 }
1118
1119 /* See language.h.  */
1120
1121 struct symbol *
1122 language_lookup_primitive_type_as_symbol (const struct language_defn *la,
1123                                           struct gdbarch *gdbarch,
1124                                           const char *name)
1125 {
1126   struct language_gdbarch *ld
1127     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1128   struct language_arch_info *lai = &ld->arch_info[la->la_language];
1129
1130   if (symbol_lookup_debug)
1131     fprintf_unfiltered (gdb_stdlog,
1132                         "language_lookup_primitive_type_as_symbol"
1133                         " (%s, %s, %s)",
1134                         la->name (), host_address_to_string (gdbarch), name);
1135
1136   struct symbol *sym
1137     = lai->lookup_primitive_type_as_symbol (name, la->la_language);
1138
1139   if (symbol_lookup_debug)
1140     fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym));
1141
1142   /* Note: The result of symbol lookup is normally a symbol *and* the block
1143      it was found in.  Builtin types don't live in blocks.  We *could* give
1144      them one, but there is no current need so to keep things simple symbol
1145      lookup is extended to allow for BLOCK_FOUND to be NULL.  */
1146
1147   return sym;
1148 }
1149
1150 /* Initialize the language routines.  */
1151
1152 void _initialize_language ();
1153 void
1154 _initialize_language ()
1155 {
1156   static const char *const type_or_range_names[]
1157     = { "on", "off", "warn", "auto", NULL };
1158
1159   static const char *const case_sensitive_names[]
1160     = { "on", "off", "auto", NULL };
1161
1162   language_gdbarch_data
1163     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1164
1165   /* GDB commands for language specific stuff.  */
1166
1167   cmd_list_element *set_check_cmd
1168     = add_basic_prefix_cmd ("check", no_class,
1169                             _("Set the status of the type/range checker."),
1170                             &setchecklist, 0, &setlist);
1171   add_alias_cmd ("c", set_check_cmd, no_class, 1, &setlist);
1172   add_alias_cmd ("ch", set_check_cmd, no_class, 1, &setlist);
1173
1174   cmd_list_element *show_check_cmd
1175     = add_show_prefix_cmd ("check", no_class,
1176                          _("Show the status of the type/range checker."),
1177                          &showchecklist, 0, &showlist);
1178   add_alias_cmd ("c", show_check_cmd, no_class, 1, &showlist);
1179   add_alias_cmd ("ch", show_check_cmd, no_class, 1, &showlist);
1180
1181   add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1182                         &range,
1183                         _("Set range checking (on/warn/off/auto)."),
1184                         _("Show range checking (on/warn/off/auto)."),
1185                         NULL, set_range_command,
1186                         show_range_command,
1187                         &setchecklist, &showchecklist);
1188
1189   add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1190                         &case_sensitive, _("\
1191 Set case sensitivity in name search (on/off/auto)."), _("\
1192 Show case sensitivity in name search (on/off/auto)."), _("\
1193 For Fortran the default is off; for other languages the default is on."),
1194                         set_case_command,
1195                         show_case_command,
1196                         &setlist, &showlist);
1197
1198   /* In order to call SET_LANGUAGE (below) we need to make sure that
1199      CURRENT_LANGUAGE is not NULL.  So first set the language to unknown,
1200      then we can change the language to 'auto'.  */
1201   current_language = language_def (language_unknown);
1202
1203   add_set_language_command ();
1204
1205   language = "auto";
1206   range = "auto";
1207   case_sensitive = "auto";
1208
1209   /* Have the above take effect.  */
1210   set_language (language_auto);
1211 }