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::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 /* Parent class for both the "auto" and "unknown" languages.  These two
 786    pseudo-languages are very similar so merging their implementations like
 787    this makes sense.  */
 788
 789 class auto_or_unknown_language : public language_defn
 790 {
 791 public:
 792   auto_or_unknown_language (enum language lang)
 793     : language_defn (lang)
 794   { /* Nothing.  */ }
 795
 796   /* See language.h.  */
 797   void language_arch_info (struct gdbarch *gdbarch,
 798                            struct language_arch_info *lai) const override
 799   {
 800     lai->string_char_type = builtin_type (gdbarch)->builtin_char;
 801     lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
 802     lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
 803                                                        struct type *);
 804   }
 805
 806   /* See language.h.  */
 807
 808   void print_type (struct type *type, const char *varstring,
 809                    struct ui_file *stream, int show, int level,
 810                    const struct type_print_options *flags) const override
 811   {
 812     error (_("type printing not implemented for language \"%s\""),
 813            natural_name ());
 814   }
 815
 816   /* See language.h.  */
 817
 818   char *demangle_symbol (const char *mangled, int options) const override
 819   {
 820     /* The auto language just uses the C++ demangler.  */
 821     return gdb_demangle (mangled, options);
 822   }
 823
 824   /* See language.h.  */
 825
 826   void value_print (struct value *val, struct ui_file *stream,
 827                     const struct value_print_options *options) const override
 828   {
 829     error (_("value printing not implemented for language \"%s\""),
 830            natural_name ());
 831   }
 832
 833   /* See language.h.  */
 834
 835   void value_print_inner
 836         (struct value *val, struct ui_file *stream, int recurse,
 837          const struct value_print_options *options) const override
 838   {
 839     error (_("inner value printing not implemented for language \"%s\""),
 840            natural_name ());
 841   }
 842
 843   /* See language.h.  */
 844
 845   int parser (struct parser_state *ps) const override
 846   {
 847     /* No parsing is done, just claim success.  */
 848     return 1;
 849   }
 850
 851   /* See language.h.  */
 852
 853   void emitchar (int ch, struct type *chtype,
 854                  struct ui_file *stream, int quoter) const override
 855   {
 856     error (_("emit character not implemented for language \"%s\""),
 857            natural_name ());
 858   }
 859
 860   /* See language.h.  */
 861
 862   void printchar (int ch, struct type *chtype,
 863                   struct ui_file *stream) const override
 864   {
 865     error (_("print character not implemented for language \"%s\""),
 866            natural_name ());
 867   }
 868
 869   /* See language.h.  */
 870
 871   void printstr (struct ui_file *stream, struct type *elttype,
 872                  const gdb_byte *string, unsigned int length,
 873                  const char *encoding, int force_ellipses,
 874                  const struct value_print_options *options) const override
 875   {
 876     error (_("print string not implemented for language \"%s\""),
 877            natural_name ());
 878   }
 879
 880   /* See language.h.  */
 881
 882   void print_typedef (struct type *type, struct symbol *new_symbol,
 883                       struct ui_file *stream) const override
 884   {
 885     error (_("print typedef not implemented for language \"%s\""),
 886            natural_name ());
 887   }
 888
 889   /* See language.h.  */
 890
 891   bool is_string_type_p (struct type *type) const override
 892   {
 893     type = check_typedef (type);
 894     while (type->code () == TYPE_CODE_REF)
 895       {
 896         type = TYPE_TARGET_TYPE (type);
 897         type = check_typedef (type);
 898       }
 899     return (type->code () == TYPE_CODE_STRING);
 900   }
 901
 902   /* See language.h.  */
 903
 904   const char *name_of_this () const override
 905   { return "this"; }
 906
 907   /* See language.h.  */
 908
 909   const struct op_print *opcode_print_table () const override
 910   {
 911     static const struct op_print unk_op_print_tab[] =
 912       {
 913         {NULL, OP_NULL, PREC_NULL, 0}
 914       };
 915
 916     return unk_op_print_tab;
 917   }
 918 };
 919
 920 /* Class representing the fake "auto" language.  */
 921
 922 class auto_language : public auto_or_unknown_language
 923 {
 924 public:
 925   auto_language ()
 926     : auto_or_unknown_language (language_auto)
 927   { /* Nothing.  */ }
 928
 929   /* See language.h.  */
 930
 931   const char *name () const override
 932   { return "auto"; }
 933
 934   /* See language.h.  */
 935
 936   const char *natural_name () const override
 937   { return "Auto"; }
 938 };
 939
 940 /* Single instance of the fake "auto" language.  */
 941
 942 static auto_language auto_language_defn;
 943
 944 /* Class representing the unknown language.  */
 945
 946 class unknown_language : public auto_or_unknown_language
 947 {
 948 public:
 949   unknown_language ()
 950     : auto_or_unknown_language (language_unknown)
 951   { /* Nothing.  */ }
 952
 953   /* See language.h.  */
 954
 955   const char *name () const override
 956   { return "unknown"; }
 957
 958   /* See language.h.  */
 959
 960   const char *natural_name () const override
 961   { return "Unknown"; }
 962
 963   /* See language.h.  */
 964
 965   bool store_sym_names_in_linkage_form_p () const override
 966   { return true; }
 967 };
 968
 969 /* Single instance of the unknown language class.  */
 970
 971 static unknown_language unknown_language_defn;
 972
 973 \f
 974 /* Per-architecture language information.  */
 975
 976 static struct gdbarch_data *language_gdbarch_data;
 977
 978 struct language_gdbarch
 979 {
 980   /* A vector of per-language per-architecture info.  Indexed by "enum
 981      language".  */
 982   struct language_arch_info arch_info[nr_languages];
 983 };
 984
 985 static void *
 986 language_gdbarch_post_init (struct gdbarch *gdbarch)
 987 {
 988   struct language_gdbarch *l;
 989
 990   l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
 991   for (const auto &lang : language_defn::languages)
 992     {
 993       gdb_assert (lang != nullptr);
 994       lang->language_arch_info (gdbarch,
 995                                 l->arch_info + lang->la_language);
 996     }
 997
 998   return l;
 999 }
1000
1001 struct type *
1002 language_string_char_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
1008   return ld->arch_info[la->la_language].string_char_type;
1009 }
1010
1011 struct type *
1012 language_bool_type (const struct language_defn *la,
1013                     struct gdbarch *gdbarch)
1014 {
1015   struct language_gdbarch *ld
1016     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1017
1018   if (ld->arch_info[la->la_language].bool_type_symbol)
1019     {
1020       struct symbol *sym;
1021
1022       sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
1023                            NULL, VAR_DOMAIN, NULL).symbol;
1024       if (sym)
1025         {
1026           struct type *type = SYMBOL_TYPE (sym);
1027
1028           if (type && type->code () == TYPE_CODE_BOOL)
1029             return type;
1030         }
1031     }
1032
1033   return ld->arch_info[la->la_language].bool_type_default;
1034 }
1035
1036 /* Helper function for primitive type lookup.  */
1037
1038 static struct type **
1039 language_lookup_primitive_type_1 (const struct language_arch_info *lai,
1040                                   const char *name)
1041 {
1042   struct type **p;
1043
1044   for (p = lai->primitive_type_vector; (*p) != NULL; p++)
1045     {
1046       if (strcmp ((*p)->name (), name) == 0)
1047         return p;
1048     }
1049   return NULL;
1050 }
1051
1052 /* See language.h.  */
1053
1054 struct type *
1055 language_lookup_primitive_type (const struct language_defn *la,
1056                                 struct gdbarch *gdbarch,
1057                                 const char *name)
1058 {
1059   struct language_gdbarch *ld =
1060     (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1061   struct type **typep;
1062
1063   typep = language_lookup_primitive_type_1 (&ld->arch_info[la->la_language],
1064                                             name);
1065   if (typep == NULL)
1066     return NULL;
1067   return *typep;
1068 }
1069
1070 /* Helper function for type lookup as a symbol.
1071    Create the symbol corresponding to type TYPE in language LANG.  */
1072
1073 static struct symbol *
1074 language_alloc_type_symbol (enum language lang, struct type *type)
1075 {
1076   struct symbol *symbol;
1077   struct gdbarch *gdbarch;
1078
1079   gdb_assert (!TYPE_OBJFILE_OWNED (type));
1080
1081   gdbarch = TYPE_OWNER (type).gdbarch;
1082   symbol = new (gdbarch_obstack (gdbarch)) struct symbol ();
1083
1084   symbol->m_name = type->name ();
1085   symbol->set_language (lang, nullptr);
1086   symbol->owner.arch = gdbarch;
1087   SYMBOL_OBJFILE_OWNED (symbol) = 0;
1088   SYMBOL_SECTION (symbol) = 0;
1089   SYMBOL_TYPE (symbol) = type;
1090   SYMBOL_DOMAIN (symbol) = VAR_DOMAIN;
1091   SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF;
1092
1093   return symbol;
1094 }
1095
1096 /* Initialize the primitive type symbols of language LD.
1097    The primitive type vector must have already been initialized.  */
1098
1099 static void
1100 language_init_primitive_type_symbols (struct language_arch_info *lai,
1101                                       const struct language_defn *la,
1102                                       struct gdbarch *gdbarch)
1103 {
1104   int n;
1105
1106   gdb_assert (lai->primitive_type_vector != NULL);
1107
1108   for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
1109     continue;
1110
1111   lai->primitive_type_symbols
1112     = GDBARCH_OBSTACK_CALLOC (gdbarch, n + 1, struct symbol *);
1113
1114   for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
1115     {
1116       lai->primitive_type_symbols[n]
1117         = language_alloc_type_symbol (la->la_language,
1118                                       lai->primitive_type_vector[n]);
1119     }
1120
1121   /* Note: The result of symbol lookup is normally a symbol *and* the block
1122      it was found in.  Builtin types don't live in blocks.  We *could* give
1123      them one, but there is no current need so to keep things simple symbol
1124      lookup is extended to allow for BLOCK_FOUND to be NULL.  */
1125 }
1126
1127 /* See language.h.  */
1128
1129 struct symbol *
1130 language_lookup_primitive_type_as_symbol (const struct language_defn *la,
1131                                           struct gdbarch *gdbarch,
1132                                           const char *name)
1133 {
1134   struct language_gdbarch *ld
1135     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1136   struct language_arch_info *lai = &ld->arch_info[la->la_language];
1137   struct type **typep;
1138   struct symbol *sym;
1139
1140   if (symbol_lookup_debug)
1141     {
1142       fprintf_unfiltered (gdb_stdlog,
1143                           "language_lookup_primitive_type_as_symbol"
1144                           " (%s, %s, %s)",
1145                           la->name (), host_address_to_string (gdbarch), name);
1146     }
1147
1148   typep = language_lookup_primitive_type_1 (lai, name);
1149   if (typep == NULL)
1150     {
1151       if (symbol_lookup_debug)
1152         fprintf_unfiltered (gdb_stdlog, " = NULL\n");
1153       return NULL;
1154     }
1155
1156   /* The set of symbols is lazily initialized.  */
1157   if (lai->primitive_type_symbols == NULL)
1158     language_init_primitive_type_symbols (lai, la, gdbarch);
1159
1160   sym = lai->primitive_type_symbols[typep - lai->primitive_type_vector];
1161
1162   if (symbol_lookup_debug)
1163     fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym));
1164   return sym;
1165 }
1166
1167 /* Initialize the language routines.  */
1168
1169 void _initialize_language ();
1170 void
1171 _initialize_language ()
1172 {
1173   static const char *const type_or_range_names[]
1174     = { "on", "off", "warn", "auto", NULL };
1175
1176   static const char *const case_sensitive_names[]
1177     = { "on", "off", "auto", NULL };
1178
1179   language_gdbarch_data
1180     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1181
1182   /* GDB commands for language specific stuff.  */
1183
1184   add_basic_prefix_cmd ("check", no_class,
1185                         _("Set the status of the type/range checker."),
1186                         &setchecklist, "set check ", 0, &setlist);
1187   add_alias_cmd ("c", "check", no_class, 1, &setlist);
1188   add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1189
1190   add_show_prefix_cmd ("check", no_class,
1191                        _("Show the status of the type/range checker."),
1192                        &showchecklist, "show check ", 0, &showlist);
1193   add_alias_cmd ("c", "check", no_class, 1, &showlist);
1194   add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1195
1196   add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1197                         &range,
1198                         _("Set range checking (on/warn/off/auto)."),
1199                         _("Show range checking (on/warn/off/auto)."),
1200                         NULL, set_range_command,
1201                         show_range_command,
1202                         &setchecklist, &showchecklist);
1203
1204   add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1205                         &case_sensitive, _("\
1206 Set case sensitivity in name search (on/off/auto)."), _("\
1207 Show case sensitivity in name search (on/off/auto)."), _("\
1208 For Fortran the default is off; for other languages the default is on."),
1209                         set_case_command,
1210                         show_case_command,
1211                         &setlist, &showlist);
1212
1213   /* In order to call SET_LANGUAGE (below) we need to make sure that
1214      CURRENT_LANGUAGE is not NULL.  So first set the language to unknown,
1215      then we can change the language to 'auto'.  */
1216   current_language = language_def (language_unknown);
1217
1218   add_set_language_command ();
1219
1220   language = "auto";
1221   range = "auto";
1222   case_sensitive = "auto";
1223
1224   /* Have the above take effect.  */
1225   set_language (language_auto);
1226 }