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