gdb/language.c

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