gdb/language.c

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