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