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 (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   LA_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::printchar (int ch, struct type *chtype,
 682                           struct ui_file * stream) const
 683 {
 684   c_printchar (ch, chtype, stream);
 685 }
 686
 687 /* See language.h.  */
 688
 689 void
 690 language_defn::printstr (struct ui_file *stream, struct type *elttype,
 691                          const gdb_byte *string, unsigned int length,
 692                          const char *encoding, int force_ellipses,
 693                          const struct value_print_options *options) const
 694 {
 695   c_printstr (stream, elttype, string, length, encoding, force_ellipses,
 696               options);
 697 }
 698
 699 /* See language.h.  */
 700
 701 void
 702 language_defn::print_typedef (struct type *type, struct symbol *new_symbol,
 703                               struct ui_file *stream) const
 704 {
 705   c_print_typedef (type, new_symbol, stream);
 706 }
 707
 708 /* See language.h.  */
 709
 710 bool
 711 language_defn::is_string_type_p (struct type *type) const
 712 {
 713   return c_is_string_type_p (type);
 714 }
 715
 716 /* The default implementation of the get_symbol_name_matcher_inner method
 717    from the language_defn class.  Matches with strncmp_iw.  */
 718
 719 static bool
 720 default_symbol_name_matcher (const char *symbol_search_name,
 721                              const lookup_name_info &lookup_name,
 722                              completion_match_result *comp_match_res)
 723 {
 724   gdb::string_view name = lookup_name.name ();
 725   completion_match_for_lcd *match_for_lcd
 726     = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
 727   strncmp_iw_mode mode = (lookup_name.completion_mode ()
 728                           ? strncmp_iw_mode::NORMAL
 729                           : strncmp_iw_mode::MATCH_PARAMS);
 730
 731   if (strncmp_iw_with_mode (symbol_search_name, name.data (), name.size (),
 732                             mode, language_minimal, match_for_lcd) == 0)
 733     {
 734       if (comp_match_res != NULL)
 735         comp_match_res->set_match (symbol_search_name);
 736       return true;
 737     }
 738   else
 739     return false;
 740 }
 741
 742 /* See language.h.  */
 743
 744 symbol_name_matcher_ftype *
 745 language_defn::get_symbol_name_matcher
 746         (const lookup_name_info &lookup_name) const
 747 {
 748   /* If currently in Ada mode, and the lookup name is wrapped in
 749      '<...>', hijack all symbol name comparisons using the Ada
 750      matcher, which handles the verbatim matching.  */
 751   if (current_language->la_language == language_ada
 752       && lookup_name.ada ().verbatim_p ())
 753     return current_language->get_symbol_name_matcher_inner (lookup_name);
 754
 755   return this->get_symbol_name_matcher_inner (lookup_name);
 756 }
 757
 758 /* See language.h.  */
 759
 760 symbol_name_matcher_ftype *
 761 language_defn::get_symbol_name_matcher_inner
 762         (const lookup_name_info &lookup_name) const
 763 {
 764   return default_symbol_name_matcher;
 765 }
 766
 767 /* See language.h.  */
 768
 769 const struct lang_varobj_ops *
 770 language_defn::varobj_ops () const
 771 {
 772   /* The ops for the C language are suitable for the vast majority of the
 773      supported languages.  */
 774   return &c_varobj_ops;
 775 }
 776
 777 /* See language.h.  */
 778
 779 const struct exp_descriptor *
 780 language_defn::expression_ops () const
 781 {
 782   return &exp_descriptor_standard;
 783 }
 784
 785 /* Return true if TYPE is a string type, otherwise return false.  This
 786    default implementation only detects TYPE_CODE_STRING.  */
 787
 788 static bool
 789 default_is_string_type_p (struct type *type)
 790 {
 791   type = check_typedef (type);
 792   while (type->code () == TYPE_CODE_REF)
 793     {
 794       type = TYPE_TARGET_TYPE (type);
 795       type = check_typedef (type);
 796     }
 797   return (type->code ()  == TYPE_CODE_STRING);
 798 }
 799
 800 static const struct op_print unk_op_print_tab[] =
 801 {
 802   {NULL, OP_NULL, PREC_NULL, 0}
 803 };
 804
 805 static void
 806 unknown_language_arch_info (struct gdbarch *gdbarch,
 807                             struct language_arch_info *lai)
 808 {
 809   lai->string_char_type = builtin_type (gdbarch)->builtin_char;
 810   lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
 811   lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
 812                                                        struct type *);
 813 }
 814
 815 /* Constant data that describes the unknown language.  */
 816
 817 extern const struct language_data unknown_language_data =
 818 {
 819   unk_op_print_tab,             /* expression operators for printing */
 820 };
 821
 822 /* Class representing the unknown language.  */
 823
 824 class unknown_language : public language_defn
 825 {
 826 public:
 827   unknown_language ()
 828     : language_defn (language_unknown, unknown_language_data)
 829   { /* Nothing.  */ }
 830
 831   /* See language.h.  */
 832
 833   const char *name () const override
 834   { return "unknown"; }
 835
 836   /* See language.h.  */
 837
 838   const char *natural_name () const override
 839   { return "Unknown"; }
 840
 841   /* See language.h.  */
 842   void language_arch_info (struct gdbarch *gdbarch,
 843                            struct language_arch_info *lai) const override
 844   {
 845     unknown_language_arch_info (gdbarch, lai);
 846   }
 847
 848   /* See language.h.  */
 849
 850   void print_type (struct type *type, const char *varstring,
 851                    struct ui_file *stream, int show, int level,
 852                    const struct type_print_options *flags) const override
 853   {
 854     error (_("unimplemented unknown_language::print_type called"));
 855   }
 856
 857   /* See language.h.  */
 858
 859   char *demangle (const char *mangled, int options) const override
 860   {
 861     /* The unknown language just uses the C++ demangler.  */
 862     return gdb_demangle (mangled, options);
 863   }
 864
 865   /* See language.h.  */
 866
 867   void value_print (struct value *val, struct ui_file *stream,
 868                     const struct value_print_options *options) const override
 869   {
 870     error (_("unimplemented unknown_language::value_print called"));
 871   }
 872
 873   /* See language.h.  */
 874
 875   void value_print_inner
 876         (struct value *val, struct ui_file *stream, int recurse,
 877          const struct value_print_options *options) const override
 878   {
 879     error (_("unimplemented unknown_language::value_print_inner called"));
 880   }
 881
 882   /* See language.h.  */
 883
 884   int parser (struct parser_state *ps) const override
 885   {
 886     /* No parsing is done, just claim success.  */
 887     return 1;
 888   }
 889
 890   /* See language.h.  */
 891
 892   void emitchar (int ch, struct type *chtype,
 893                  struct ui_file *stream, int quoter) const override
 894   {
 895     error (_("unimplemented unknown_language::emitchar called"));
 896   }
 897
 898   /* See language.h.  */
 899
 900   void printchar (int ch, struct type *chtype,
 901                   struct ui_file *stream) const override
 902   {
 903     error (_("unimplemented unknown_language::printchar called"));
 904   }
 905
 906   /* See language.h.  */
 907
 908   void printstr (struct ui_file *stream, struct type *elttype,
 909                  const gdb_byte *string, unsigned int length,
 910                  const char *encoding, int force_ellipses,
 911                  const struct value_print_options *options) const override
 912   {
 913     error (_("unimplemented unknown_language::printstr called"));
 914   }
 915
 916   /* See language.h.  */
 917
 918   void print_typedef (struct type *type, struct symbol *new_symbol,
 919                       struct ui_file *stream) const override
 920   {
 921     error (_("unimplemented unknown_language::print_typedef called"));
 922   }
 923
 924   /* See language.h.  */
 925
 926   bool is_string_type_p (struct type *type) const override
 927   {
 928     return default_is_string_type_p (type);
 929   }
 930
 931   /* See language.h.  */
 932
 933   const char *name_of_this () const override
 934   { return "this"; }
 935
 936   /* See language.h.  */
 937
 938   bool store_sym_names_in_linkage_form_p () const override
 939   { return true; }
 940 };
 941
 942 /* Single instance of the unknown language class.  */
 943
 944 static unknown_language unknown_language_defn;
 945
 946 /* Constant data for the fake "auto" language.  */
 947
 948 extern const struct language_data auto_language_data =
 949 {
 950   unk_op_print_tab,             /* expression operators for printing */
 951 };
 952
 953 /* Class representing the fake "auto" language.  */
 954
 955 class auto_language : public language_defn
 956 {
 957 public:
 958   auto_language ()
 959     : language_defn (language_auto, auto_language_data)
 960   { /* Nothing.  */ }
 961
 962   /* See language.h.  */
 963
 964   const char *name () const override
 965   { return "auto"; }
 966
 967   /* See language.h.  */
 968
 969   const char *natural_name () const override
 970   { return "Auto"; }
 971
 972   /* See language.h.  */
 973   void language_arch_info (struct gdbarch *gdbarch,
 974                            struct language_arch_info *lai) const override
 975   {
 976     unknown_language_arch_info (gdbarch, lai);
 977   }
 978
 979   /* See language.h.  */
 980
 981   void print_type (struct type *type, const char *varstring,
 982                    struct ui_file *stream, int show, int level,
 983                    const struct type_print_options *flags) const override
 984   {
 985     error (_("unimplemented auto_language::print_type called"));
 986   }
 987
 988   /* See language.h.  */
 989
 990   char *demangle (const char *mangled, int options) const override
 991   {
 992     /* The auto language just uses the C++ demangler.  */
 993     return gdb_demangle (mangled, options);
 994   }
 995
 996   /* See language.h.  */
 997
 998   void value_print (struct value *val, struct ui_file *stream,
 999                     const struct value_print_options *options) const override
1000   {
1001     error (_("unimplemented auto_language::value_print called"));
1002   }
1003
1004   /* See language.h.  */
1005
1006   void value_print_inner
1007         (struct value *val, struct ui_file *stream, int recurse,
1008          const struct value_print_options *options) const override
1009   {
1010     error (_("unimplemented auto_language::value_print_inner called"));
1011   }
1012
1013   /* See language.h.  */
1014
1015   int parser (struct parser_state *ps) const override
1016   {
1017     /* No parsing is done, just claim success.  */
1018     return 1;
1019   }
1020
1021   /* See language.h.  */
1022
1023   void emitchar (int ch, struct type *chtype,
1024                  struct ui_file *stream, int quoter) const override
1025   {
1026     error (_("unimplemented auto_language::emitchar called"));
1027   }
1028
1029   /* See language.h.  */
1030
1031   void printchar (int ch, struct type *chtype,
1032                   struct ui_file *stream) const override
1033   {
1034     error (_("unimplemented auto_language::printchar called"));
1035   }
1036
1037   /* See language.h.  */
1038
1039   void printstr (struct ui_file *stream, struct type *elttype,
1040                  const gdb_byte *string, unsigned int length,
1041                  const char *encoding, int force_ellipses,
1042                  const struct value_print_options *options) const override
1043   {
1044     error (_("unimplemented auto_language::printstr called"));
1045   }
1046
1047   /* See language.h.  */
1048
1049   void print_typedef (struct type *type, struct symbol *new_symbol,
1050                       struct ui_file *stream) const override
1051   {
1052     error (_("unimplemented auto_language::print_typedef called"));
1053   }
1054
1055   /* See language.h.  */
1056
1057   bool is_string_type_p (struct type *type) const override
1058   {
1059     return default_is_string_type_p (type);
1060   }
1061
1062   /* See language.h.  */
1063
1064   const char *name_of_this () const override
1065   { return "this"; }
1066 };
1067
1068 /* Single instance of the fake "auto" language.  */
1069
1070 static auto_language auto_language_defn;
1071
1072 \f
1073 /* Per-architecture language information.  */
1074
1075 static struct gdbarch_data *language_gdbarch_data;
1076
1077 struct language_gdbarch
1078 {
1079   /* A vector of per-language per-architecture info.  Indexed by "enum
1080      language".  */
1081   struct language_arch_info arch_info[nr_languages];
1082 };
1083
1084 static void *
1085 language_gdbarch_post_init (struct gdbarch *gdbarch)
1086 {
1087   struct language_gdbarch *l;
1088
1089   l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
1090   for (const auto &lang : language_defn::languages)
1091     {
1092       gdb_assert (lang != nullptr);
1093       lang->language_arch_info (gdbarch,
1094                                 l->arch_info + lang->la_language);
1095     }
1096
1097   return l;
1098 }
1099
1100 struct type *
1101 language_string_char_type (const struct language_defn *la,
1102                            struct gdbarch *gdbarch)
1103 {
1104   struct language_gdbarch *ld
1105     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1106
1107   return ld->arch_info[la->la_language].string_char_type;
1108 }
1109
1110 struct type *
1111 language_bool_type (const struct language_defn *la,
1112                     struct gdbarch *gdbarch)
1113 {
1114   struct language_gdbarch *ld
1115     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1116
1117   if (ld->arch_info[la->la_language].bool_type_symbol)
1118     {
1119       struct symbol *sym;
1120
1121       sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
1122                            NULL, VAR_DOMAIN, NULL).symbol;
1123       if (sym)
1124         {
1125           struct type *type = SYMBOL_TYPE (sym);
1126
1127           if (type && type->code () == TYPE_CODE_BOOL)
1128             return type;
1129         }
1130     }
1131
1132   return ld->arch_info[la->la_language].bool_type_default;
1133 }
1134
1135 /* Helper function for primitive type lookup.  */
1136
1137 static struct type **
1138 language_lookup_primitive_type_1 (const struct language_arch_info *lai,
1139                                   const char *name)
1140 {
1141   struct type **p;
1142
1143   for (p = lai->primitive_type_vector; (*p) != NULL; p++)
1144     {
1145       if (strcmp ((*p)->name (), name) == 0)
1146         return p;
1147     }
1148   return NULL;
1149 }
1150
1151 /* See language.h.  */
1152
1153 struct type *
1154 language_lookup_primitive_type (const struct language_defn *la,
1155                                 struct gdbarch *gdbarch,
1156                                 const char *name)
1157 {
1158   struct language_gdbarch *ld =
1159     (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1160   struct type **typep;
1161
1162   typep = language_lookup_primitive_type_1 (&ld->arch_info[la->la_language],
1163                                             name);
1164   if (typep == NULL)
1165     return NULL;
1166   return *typep;
1167 }
1168
1169 /* Helper function for type lookup as a symbol.
1170    Create the symbol corresponding to type TYPE in language LANG.  */
1171
1172 static struct symbol *
1173 language_alloc_type_symbol (enum language lang, struct type *type)
1174 {
1175   struct symbol *symbol;
1176   struct gdbarch *gdbarch;
1177
1178   gdb_assert (!TYPE_OBJFILE_OWNED (type));
1179
1180   gdbarch = TYPE_OWNER (type).gdbarch;
1181   symbol = new (gdbarch_obstack (gdbarch)) struct symbol ();
1182
1183   symbol->m_name = type->name ();
1184   symbol->set_language (lang, nullptr);
1185   symbol->owner.arch = gdbarch;
1186   SYMBOL_OBJFILE_OWNED (symbol) = 0;
1187   SYMBOL_SECTION (symbol) = 0;
1188   SYMBOL_TYPE (symbol) = type;
1189   SYMBOL_DOMAIN (symbol) = VAR_DOMAIN;
1190   SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF;
1191
1192   return symbol;
1193 }
1194
1195 /* Initialize the primitive type symbols of language LD.
1196    The primitive type vector must have already been initialized.  */
1197
1198 static void
1199 language_init_primitive_type_symbols (struct language_arch_info *lai,
1200                                       const struct language_defn *la,
1201                                       struct gdbarch *gdbarch)
1202 {
1203   int n;
1204
1205   gdb_assert (lai->primitive_type_vector != NULL);
1206
1207   for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
1208     continue;
1209
1210   lai->primitive_type_symbols
1211     = GDBARCH_OBSTACK_CALLOC (gdbarch, n + 1, struct symbol *);
1212
1213   for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
1214     {
1215       lai->primitive_type_symbols[n]
1216         = language_alloc_type_symbol (la->la_language,
1217                                       lai->primitive_type_vector[n]);
1218     }
1219
1220   /* Note: The result of symbol lookup is normally a symbol *and* the block
1221      it was found in.  Builtin types don't live in blocks.  We *could* give
1222      them one, but there is no current need so to keep things simple symbol
1223      lookup is extended to allow for BLOCK_FOUND to be NULL.  */
1224 }
1225
1226 /* See language.h.  */
1227
1228 struct symbol *
1229 language_lookup_primitive_type_as_symbol (const struct language_defn *la,
1230                                           struct gdbarch *gdbarch,
1231                                           const char *name)
1232 {
1233   struct language_gdbarch *ld
1234     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1235   struct language_arch_info *lai = &ld->arch_info[la->la_language];
1236   struct type **typep;
1237   struct symbol *sym;
1238
1239   if (symbol_lookup_debug)
1240     {
1241       fprintf_unfiltered (gdb_stdlog,
1242                           "language_lookup_primitive_type_as_symbol"
1243                           " (%s, %s, %s)",
1244                           la->name (), host_address_to_string (gdbarch), name);
1245     }
1246
1247   typep = language_lookup_primitive_type_1 (lai, name);
1248   if (typep == NULL)
1249     {
1250       if (symbol_lookup_debug)
1251         fprintf_unfiltered (gdb_stdlog, " = NULL\n");
1252       return NULL;
1253     }
1254
1255   /* The set of symbols is lazily initialized.  */
1256   if (lai->primitive_type_symbols == NULL)
1257     language_init_primitive_type_symbols (lai, la, gdbarch);
1258
1259   sym = lai->primitive_type_symbols[typep - lai->primitive_type_vector];
1260
1261   if (symbol_lookup_debug)
1262     fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym));
1263   return sym;
1264 }
1265
1266 /* Initialize the language routines.  */
1267
1268 void _initialize_language ();
1269 void
1270 _initialize_language ()
1271 {
1272   static const char *const type_or_range_names[]
1273     = { "on", "off", "warn", "auto", NULL };
1274
1275   static const char *const case_sensitive_names[]
1276     = { "on", "off", "auto", NULL };
1277
1278   language_gdbarch_data
1279     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1280
1281   /* GDB commands for language specific stuff.  */
1282
1283   add_basic_prefix_cmd ("check", no_class,
1284                         _("Set the status of the type/range checker."),
1285                         &setchecklist, "set check ", 0, &setlist);
1286   add_alias_cmd ("c", "check", no_class, 1, &setlist);
1287   add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1288
1289   add_show_prefix_cmd ("check", no_class,
1290                        _("Show the status of the type/range checker."),
1291                        &showchecklist, "show check ", 0, &showlist);
1292   add_alias_cmd ("c", "check", no_class, 1, &showlist);
1293   add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1294
1295   add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1296                         &range,
1297                         _("Set range checking (on/warn/off/auto)."),
1298                         _("Show range checking (on/warn/off/auto)."),
1299                         NULL, set_range_command,
1300                         show_range_command,
1301                         &setchecklist, &showchecklist);
1302
1303   add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1304                         &case_sensitive, _("\
1305 Set case sensitivity in name search (on/off/auto)."), _("\
1306 Show case sensitivity in name search (on/off/auto)."), _("\
1307 For Fortran the default is off; for other languages the default is on."),
1308                         set_case_command,
1309                         show_case_command,
1310                         &setlist, &showlist);
1311
1312   /* In order to call SET_LANGUAGE (below) we need to make sure that
1313      CURRENT_LANGUAGE is not NULL.  So first set the language to unknown,
1314      then we can change the language to 'auto'.  */
1315   current_language = language_def (language_unknown);
1316
1317   add_set_language_command ();
1318
1319   language = "auto";
1320   range = "auto";
1321   case_sensitive = "auto";
1322
1323   /* Have the above take effect.  */
1324   set_language (language_auto);
1325 }