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 int unk_lang_parser (struct parser_state *);
  51
  52 static void set_range_case (void);
  53
  54 static void unk_lang_emit_char (int c, struct type *type,
  55                                 struct ui_file *stream, int quoter);
  56
  57 static void unk_lang_printchar (int c, struct type *type,
  58                                 struct ui_file *stream);
  59
  60 static void unk_lang_value_print (struct value *, struct ui_file *,
  61                                   const struct value_print_options *);
  62
  63 static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc);
  64
  65 /* The current (default at startup) state of type and range checking.
  66    (If the modes are set to "auto", though, these are changed based
  67    on the default language at startup, and then again based on the
  68    language of the first source file.  */
  69
  70 enum range_mode range_mode = range_mode_auto;
  71 enum range_check range_check = range_check_off;
  72 enum case_mode case_mode = case_mode_auto;
  73 enum case_sensitivity case_sensitivity = case_sensitive_on;
  74
  75 /* The current language and language_mode (see language.h).  */
  76
  77 const struct language_defn *current_language = nullptr;
  78 enum language_mode language_mode = language_mode_auto;
  79
  80 /* The language that the user expects to be typing in (the language
  81    of main(), or the last language we notified them about, or C).  */
  82
  83 const struct language_defn *expected_language;
  84
  85 /* Define the array containing all languages.  */
  86
  87 const struct language_defn *language_defn::languages[nr_languages];
  88
  89 /* The current values of the "set language/range/case-sensitive" enum
  90    commands.  */
  91 static const char *language;
  92 static const char *range;
  93 static const char *case_sensitive;
  94
  95 /* See language.h.  */
  96 const char lang_frame_mismatch_warn[] =
  97 N_("Warning: the current language does not match this frame.");
  98 \f
  99 /* This page contains the functions corresponding to GDB commands
 100    and their helpers.  */
 101
 102 /* Show command.  Display a warning if the language set
 103    does not match the frame.  */
 104 static void
 105 show_language_command (struct ui_file *file, int from_tty,
 106                        struct cmd_list_element *c, const char *value)
 107 {
 108   enum language flang;          /* The language of the frame.  */
 109
 110   if (language_mode == language_mode_auto)
 111     fprintf_filtered (gdb_stdout,
 112                       _("The current source language is "
 113                         "\"auto; currently %s\".\n"),
 114                       current_language->la_name);
 115   else
 116     fprintf_filtered (gdb_stdout,
 117                       _("The current source language is \"%s\".\n"),
 118                       current_language->la_name);
 119
 120   if (has_stack_frames ())
 121     {
 122       struct frame_info *frame;
 123
 124       frame = get_selected_frame (NULL);
 125       flang = get_frame_language (frame);
 126       if (flang != language_unknown
 127           && language_mode == language_mode_manual
 128           && current_language->la_language != flang)
 129         printf_filtered ("%s\n", _(lang_frame_mismatch_warn));
 130     }
 131 }
 132
 133 /* Set command.  Change the current working language.  */
 134 static void
 135 set_language_command (const char *ignore,
 136                       int from_tty, struct cmd_list_element *c)
 137 {
 138   enum language flang = language_unknown;
 139
 140   /* "local" is a synonym of "auto".  */
 141   if (strcmp (language, "local") == 0)
 142     language = "auto";
 143
 144   /* Search the list of languages for a match.  */
 145   for (const auto &lang : language_defn::languages)
 146     {
 147       if (strcmp (lang->la_name, language) == 0)
 148         {
 149           /* Found it!  Go into manual mode, and use this language.  */
 150           if (lang->la_language == language_auto)
 151             {
 152               /* Enter auto mode.  Set to the current frame's language, if
 153                  known, or fallback to the initial language.  */
 154               language_mode = language_mode_auto;
 155               try
 156                 {
 157                   struct frame_info *frame;
 158
 159                   frame = get_selected_frame (NULL);
 160                   flang = get_frame_language (frame);
 161                 }
 162               catch (const gdb_exception_error &ex)
 163                 {
 164                   flang = language_unknown;
 165                 }
 166
 167               if (flang != language_unknown)
 168                 set_language (flang);
 169               else
 170                 set_initial_language ();
 171               expected_language = current_language;
 172               return;
 173             }
 174           else
 175             {
 176               /* Enter manual mode.  Set the specified language.  */
 177               language_mode = language_mode_manual;
 178               current_language = lang;
 179               set_range_case ();
 180               expected_language = current_language;
 181               return;
 182             }
 183         }
 184     }
 185
 186   internal_error (__FILE__, __LINE__,
 187                   "Couldn't find language `%s' in known languages list.",
 188                   language);
 189 }
 190
 191 /* Show command.  Display a warning if the range setting does
 192    not match the current language.  */
 193 static void
 194 show_range_command (struct ui_file *file, int from_tty,
 195                     struct cmd_list_element *c, const char *value)
 196 {
 197   if (range_mode == range_mode_auto)
 198     {
 199       const char *tmp;
 200
 201       switch (range_check)
 202         {
 203         case range_check_on:
 204           tmp = "on";
 205           break;
 206         case range_check_off:
 207           tmp = "off";
 208           break;
 209         case range_check_warn:
 210           tmp = "warn";
 211           break;
 212         default:
 213           internal_error (__FILE__, __LINE__,
 214                           "Unrecognized range check setting.");
 215         }
 216
 217       fprintf_filtered (gdb_stdout,
 218                         _("Range checking is \"auto; currently %s\".\n"),
 219                         tmp);
 220     }
 221   else
 222     fprintf_filtered (gdb_stdout, _("Range checking is \"%s\".\n"),
 223                       value);
 224
 225   if (range_check != current_language->la_range_check)
 226     warning (_("the current range check setting "
 227                "does not match the language.\n"));
 228 }
 229
 230 /* Set command.  Change the setting for range checking.  */
 231 static void
 232 set_range_command (const char *ignore,
 233                    int from_tty, struct cmd_list_element *c)
 234 {
 235   if (strcmp (range, "on") == 0)
 236     {
 237       range_check = range_check_on;
 238       range_mode = range_mode_manual;
 239     }
 240   else if (strcmp (range, "warn") == 0)
 241     {
 242       range_check = range_check_warn;
 243       range_mode = range_mode_manual;
 244     }
 245   else if (strcmp (range, "off") == 0)
 246     {
 247       range_check = range_check_off;
 248       range_mode = range_mode_manual;
 249     }
 250   else if (strcmp (range, "auto") == 0)
 251     {
 252       range_mode = range_mode_auto;
 253       set_range_case ();
 254       return;
 255     }
 256   else
 257     {
 258       internal_error (__FILE__, __LINE__,
 259                       _("Unrecognized range check setting: \"%s\""), range);
 260     }
 261   if (range_check != current_language->la_range_check)
 262     warning (_("the current range check setting "
 263                "does not match the language.\n"));
 264 }
 265
 266 /* Show command.  Display a warning if the case sensitivity setting does
 267    not match the current language.  */
 268 static void
 269 show_case_command (struct ui_file *file, int from_tty,
 270                    struct cmd_list_element *c, const char *value)
 271 {
 272   if (case_mode == case_mode_auto)
 273     {
 274       const char *tmp = NULL;
 275
 276       switch (case_sensitivity)
 277         {
 278         case case_sensitive_on:
 279           tmp = "on";
 280           break;
 281         case case_sensitive_off:
 282           tmp = "off";
 283           break;
 284         default:
 285           internal_error (__FILE__, __LINE__,
 286                           "Unrecognized case-sensitive setting.");
 287         }
 288
 289       fprintf_filtered (gdb_stdout,
 290                         _("Case sensitivity in "
 291                           "name search is \"auto; currently %s\".\n"),
 292                         tmp);
 293     }
 294   else
 295     fprintf_filtered (gdb_stdout,
 296                       _("Case sensitivity in name search is \"%s\".\n"),
 297                       value);
 298
 299   if (case_sensitivity != current_language->la_case_sensitivity)
 300     warning (_("the current case sensitivity setting does not match "
 301                "the language.\n"));
 302 }
 303
 304 /* Set command.  Change the setting for case sensitivity.  */
 305
 306 static void
 307 set_case_command (const char *ignore, int from_tty, struct cmd_list_element *c)
 308 {
 309    if (strcmp (case_sensitive, "on") == 0)
 310      {
 311        case_sensitivity = case_sensitive_on;
 312        case_mode = case_mode_manual;
 313      }
 314    else if (strcmp (case_sensitive, "off") == 0)
 315      {
 316        case_sensitivity = case_sensitive_off;
 317        case_mode = case_mode_manual;
 318      }
 319    else if (strcmp (case_sensitive, "auto") == 0)
 320      {
 321        case_mode = case_mode_auto;
 322        set_range_case ();
 323        return;
 324      }
 325    else
 326      {
 327        internal_error (__FILE__, __LINE__,
 328                        "Unrecognized case-sensitive setting: \"%s\"",
 329                        case_sensitive);
 330      }
 331
 332    if (case_sensitivity != current_language->la_case_sensitivity)
 333      warning (_("the current case sensitivity setting does not match "
 334                 "the language.\n"));
 335 }
 336
 337 /* Set the status of range and type checking and case sensitivity based on
 338    the current modes and the current language.
 339    If SHOW is non-zero, then print out the current language,
 340    type and range checking status.  */
 341 static void
 342 set_range_case (void)
 343 {
 344   if (range_mode == range_mode_auto)
 345     range_check = current_language->la_range_check;
 346
 347   if (case_mode == case_mode_auto)
 348     case_sensitivity = current_language->la_case_sensitivity;
 349 }
 350
 351 /* Set current language to (enum language) LANG.  Returns previous
 352    language.  */
 353
 354 enum language
 355 set_language (enum language lang)
 356 {
 357   enum language prev_language;
 358
 359   prev_language = current_language->la_language;
 360   current_language = language_def (lang);
 361   set_range_case ();
 362   return prev_language;
 363 }
 364 \f
 365
 366 /* Print out the current language settings: language, range and
 367    type checking.  If QUIETLY, print only what has changed.  */
 368
 369 void
 370 language_info (int quietly)
 371 {
 372   if (quietly && expected_language == current_language)
 373     return;
 374
 375   expected_language = current_language;
 376   printf_unfiltered (_("Current language:  %s\n"), language);
 377   show_language_command (NULL, 1, NULL, NULL);
 378
 379   if (!quietly)
 380     {
 381       printf_unfiltered (_("Range checking:    %s\n"), range);
 382       show_range_command (NULL, 1, NULL, NULL);
 383       printf_unfiltered (_("Case sensitivity:  %s\n"), case_sensitive);
 384       show_case_command (NULL, 1, NULL, NULL);
 385     }
 386 }
 387 \f
 388
 389 /* Returns non-zero if the value is a pointer type.  */
 390 int
 391 pointer_type (struct type *type)
 392 {
 393   return type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type);
 394 }
 395
 396 \f
 397 /* This page contains functions that return info about
 398    (struct value) values used in GDB.  */
 399
 400 /* Returns non-zero if the value VAL represents a true value.  */
 401 int
 402 value_true (struct value *val)
 403 {
 404   /* It is possible that we should have some sort of error if a non-boolean
 405      value is used in this context.  Possibly dependent on some kind of
 406      "boolean-checking" option like range checking.  But it should probably
 407      not depend on the language except insofar as is necessary to identify
 408      a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
 409      should be an error, probably).  */
 410   return !value_logical_not (val);
 411 }
 412 \f
 413 /* This page contains functions for the printing out of
 414    error messages that occur during type- and range-
 415    checking.  */
 416
 417 /* This is called when a language fails a range-check.  The
 418    first argument should be a printf()-style format string, and the
 419    rest of the arguments should be its arguments.  If range_check is
 420    range_check_on, an error is printed;  if range_check_warn, a warning;
 421    otherwise just the message.  */
 422
 423 void
 424 range_error (const char *string,...)
 425 {
 426   va_list args;
 427
 428   va_start (args, string);
 429   switch (range_check)
 430     {
 431     case range_check_warn:
 432       vwarning (string, args);
 433       break;
 434     case range_check_on:
 435       verror (string, args);
 436       break;
 437     case range_check_off:
 438       /* FIXME: cagney/2002-01-30: Should this function print anything
 439          when range error is off?  */
 440       vfprintf_filtered (gdb_stderr, string, args);
 441       fprintf_filtered (gdb_stderr, "\n");
 442       break;
 443     default:
 444       internal_error (__FILE__, __LINE__, _("bad switch"));
 445     }
 446   va_end (args);
 447 }
 448 \f
 449
 450 /* This page contains miscellaneous functions.  */
 451
 452 /* Return the language enum for a given language string.  */
 453
 454 enum language
 455 language_enum (const char *str)
 456 {
 457   for (const auto &lang : language_defn::languages)
 458     if (strcmp (lang->la_name, str) == 0)
 459       return lang->la_language;
 460
 461   if (strcmp (str, "local") == 0)
 462     return language_auto;
 463
 464   return language_unknown;
 465 }
 466
 467 /* Return the language struct for a given language enum.  */
 468
 469 const struct language_defn *
 470 language_def (enum language lang)
 471 {
 472   const struct language_defn *l = language_defn::languages[lang];
 473   gdb_assert (l != nullptr);
 474   return l;
 475 }
 476
 477 /* Return the language as a string.  */
 478
 479 const char *
 480 language_str (enum language lang)
 481 {
 482   return language_def (lang)->la_name;
 483 }
 484
 485 \f
 486
 487 /* Build and install the "set language LANG" command.  */
 488
 489 static void
 490 add_set_language_command ()
 491 {
 492   static const char **language_names;
 493
 494   /* Build the language names array, to be used as enumeration in the
 495      "set language" enum command.  +1 for "local" and +1 for NULL
 496      termination.  */
 497   language_names = new const char *[ARRAY_SIZE (language_defn::languages) + 2];
 498
 499   /* Display "auto", "local" and "unknown" first, and then the rest,
 500      alpha sorted.  */
 501   const char **language_names_p = language_names;
 502   *language_names_p++ = language_def (language_auto)->la_name;
 503   *language_names_p++ = "local";
 504   *language_names_p++ = language_def (language_unknown)->la_name;
 505   const char **sort_begin = language_names_p;
 506   for (const auto &lang : language_defn::languages)
 507     {
 508       /* Already handled above.  */
 509       if (lang->la_language == language_auto
 510           || lang->la_language == language_unknown)
 511         continue;
 512       *language_names_p++ = lang->la_name;
 513     }
 514   *language_names_p = NULL;
 515   std::sort (sort_begin, language_names_p, compare_cstrings);
 516
 517   /* Add the filename extensions.  */
 518   for (const auto &lang : language_defn::languages)
 519     if (lang->la_filename_extensions != NULL)
 520       {
 521         for (size_t i = 0; lang->la_filename_extensions[i] != NULL; ++i)
 522           add_filename_language (lang->la_filename_extensions[i],
 523                                  lang->la_language);
 524       }
 525
 526   /* Build the "help set language" docs.  */
 527   string_file doc;
 528
 529   doc.printf (_("Set the current source language.\n"
 530                 "The currently understood settings are:\n\nlocal or "
 531                 "auto    Automatic setting based on source file"));
 532
 533   for (const auto &lang : language_defn::languages)
 534     {
 535       /* Already dealt with these above.  */
 536       if (lang->la_language == language_unknown
 537           || lang->la_language == language_auto)
 538         continue;
 539
 540       /* FIXME: i18n: for now assume that the human-readable name is
 541          just a capitalization of the internal name.  */
 542       /* Note that we add the newline at the front, so we don't wind
 543          up with a trailing newline.  */
 544       doc.printf ("\n%-16s Use the %c%s language",
 545                   lang->la_name,
 546                   /* Capitalize first letter of language name.  */
 547                   toupper (lang->la_name[0]),
 548                   lang->la_name + 1);
 549     }
 550
 551   add_setshow_enum_cmd ("language", class_support,
 552                         language_names,
 553                         &language,
 554                         doc.c_str (),
 555                         _("Show the current source language."),
 556                         NULL, set_language_command,
 557                         show_language_command,
 558                         &setlist, &showlist);
 559 }
 560
 561 /* Iterate through all registered languages looking for and calling
 562    any non-NULL struct language_defn.skip_trampoline() functions.
 563    Return the result from the first that returns non-zero, or 0 if all
 564    `fail'.  */
 565 CORE_ADDR
 566 skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
 567 {
 568   for (const auto &lang : language_defn::languages)
 569     {
 570       if (lang->skip_trampoline != NULL)
 571         {
 572           CORE_ADDR real_pc = lang->skip_trampoline (frame, pc);
 573
 574           if (real_pc)
 575             return real_pc;
 576         }
 577     }
 578
 579   return 0;
 580 }
 581
 582 /* Return demangled language symbol, or NULL.
 583    FIXME: Options are only useful for certain languages and ignored
 584    by others, so it would be better to remove them here and have a
 585    more flexible demangler for the languages that need it.
 586    FIXME: Sometimes the demangler is invoked when we don't know the
 587    language, so we can't use this everywhere.  */
 588 char *
 589 language_demangle (const struct language_defn *current_language,
 590                                 const char *mangled, int options)
 591 {
 592   if (current_language != NULL && current_language->la_demangle)
 593     return current_language->la_demangle (mangled, options);
 594   return NULL;
 595 }
 596
 597 /* See language.h.  */
 598
 599 int
 600 language_sniff_from_mangled_name (const struct language_defn *lang,
 601                                   const char *mangled, char **demangled)
 602 {
 603   gdb_assert (lang != NULL);
 604
 605   if (lang->la_sniff_from_mangled_name == NULL)
 606     {
 607       *demangled = NULL;
 608       return 0;
 609     }
 610
 611   return lang->la_sniff_from_mangled_name (mangled, demangled);
 612 }
 613
 614 /* Return class name from physname or NULL.  */
 615 char *
 616 language_class_name_from_physname (const struct language_defn *lang,
 617                                    const char *physname)
 618 {
 619   if (lang != NULL && lang->la_class_name_from_physname)
 620     return lang->la_class_name_from_physname (physname);
 621   return NULL;
 622 }
 623
 624 /* Return information about whether TYPE should be passed
 625    (and returned) by reference at the language level.  */
 626
 627 struct language_pass_by_ref_info
 628 language_pass_by_reference (struct type *type)
 629 {
 630   return current_language->la_pass_by_reference (type);
 631 }
 632
 633 /* Return a default struct that provides pass-by-reference information
 634    about the given TYPE.  Languages should update the default values
 635    as appropriate.  */
 636
 637 struct language_pass_by_ref_info
 638 default_pass_by_reference (struct type *type)
 639 {
 640   return {};
 641 }
 642
 643 /* Return the default string containing the list of characters
 644    delimiting words.  This is a reasonable default value that
 645    most languages should be able to use.  */
 646
 647 const char *
 648 default_word_break_characters (void)
 649 {
 650   return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
 651 }
 652
 653 /* See language.h.  */
 654
 655 void
 656 language_defn::print_array_index (struct type *index_type, LONGEST index,
 657                                   struct ui_file *stream,
 658                                   const value_print_options *options) const
 659 {
 660   struct value *index_value = value_from_longest (index_type, index);
 661
 662   fprintf_filtered (stream, "[");
 663   LA_VALUE_PRINT (index_value, stream, options);
 664   fprintf_filtered (stream, "] = ");
 665 }
 666
 667 /* See language.h.  */
 668
 669 bool
 670 default_symbol_name_matcher (const char *symbol_search_name,
 671                              const lookup_name_info &lookup_name,
 672                              completion_match_result *comp_match_res)
 673 {
 674   gdb::string_view name = lookup_name.name ();
 675   completion_match_for_lcd *match_for_lcd
 676     = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
 677   strncmp_iw_mode mode = (lookup_name.completion_mode ()
 678                           ? strncmp_iw_mode::NORMAL
 679                           : strncmp_iw_mode::MATCH_PARAMS);
 680
 681   if (strncmp_iw_with_mode (symbol_search_name, name.data (), name.size (),
 682                             mode, language_minimal, match_for_lcd) == 0)
 683     {
 684       if (comp_match_res != NULL)
 685         comp_match_res->set_match (symbol_search_name);
 686       return true;
 687     }
 688   else
 689     return false;
 690 }
 691
 692 /* See language.h.  */
 693
 694 bool
 695 default_is_string_type_p (struct type *type)
 696 {
 697   type = check_typedef (type);
 698   while (type->code () == TYPE_CODE_REF)
 699     {
 700       type = TYPE_TARGET_TYPE (type);
 701       type = check_typedef (type);
 702     }
 703   return (type->code ()  == TYPE_CODE_STRING);
 704 }
 705
 706 /* See language.h.  */
 707
 708 symbol_name_matcher_ftype *
 709 get_symbol_name_matcher (const language_defn *lang,
 710                          const lookup_name_info &lookup_name)
 711 {
 712   /* If currently in Ada mode, and the lookup name is wrapped in
 713      '<...>', hijack all symbol name comparisons using the Ada
 714      matcher, which handles the verbatim matching.  */
 715   if (current_language->la_language == language_ada
 716       && lookup_name.ada ().verbatim_p ())
 717     return current_language->la_get_symbol_name_matcher (lookup_name);
 718
 719   if (lang->la_get_symbol_name_matcher != nullptr)
 720     return lang->la_get_symbol_name_matcher (lookup_name);
 721   return default_symbol_name_matcher;
 722 }
 723
 724 /* Define the language that is no language.  */
 725
 726 static int
 727 unk_lang_parser (struct parser_state *ps)
 728 {
 729   return 1;
 730 }
 731
 732 static void
 733 unk_lang_emit_char (int c, struct type *type, struct ui_file *stream,
 734                     int quoter)
 735 {
 736   error (_("internal error - unimplemented "
 737            "function unk_lang_emit_char called."));
 738 }
 739
 740 static void
 741 unk_lang_printchar (int c, struct type *type, struct ui_file *stream)
 742 {
 743   error (_("internal error - unimplemented "
 744            "function unk_lang_printchar called."));
 745 }
 746
 747 static void
 748 unk_lang_printstr (struct ui_file *stream, struct type *type,
 749                    const gdb_byte *string, unsigned int length,
 750                    const char *encoding, int force_ellipses,
 751                    const struct value_print_options *options)
 752 {
 753   error (_("internal error - unimplemented "
 754            "function unk_lang_printstr called."));
 755 }
 756
 757 static void
 758 unk_lang_print_type (struct type *type, const char *varstring,
 759                      struct ui_file *stream, int show, int level,
 760                      const struct type_print_options *flags)
 761 {
 762   error (_("internal error - unimplemented "
 763            "function unk_lang_print_type called."));
 764 }
 765
 766 static void
 767 unk_lang_value_print_inner (struct value *val,
 768                             struct ui_file *stream, int recurse,
 769                             const struct value_print_options *options)
 770 {
 771   error (_("internal error - unimplemented "
 772            "function unk_lang_value_print_inner called."));
 773 }
 774
 775 static void
 776 unk_lang_value_print (struct value *val, struct ui_file *stream,
 777                       const struct value_print_options *options)
 778 {
 779   error (_("internal error - unimplemented "
 780            "function unk_lang_value_print called."));
 781 }
 782
 783 static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc)
 784 {
 785   return 0;
 786 }
 787
 788 /* Unknown languages just use the cplus demangler.  */
 789 static char *unk_lang_demangle (const char *mangled, int options)
 790 {
 791   return gdb_demangle (mangled, options);
 792 }
 793
 794 static char *unk_lang_class_name (const char *mangled)
 795 {
 796   return NULL;
 797 }
 798
 799 static const struct op_print unk_op_print_tab[] =
 800 {
 801   {NULL, OP_NULL, PREC_NULL, 0}
 802 };
 803
 804 static void
 805 unknown_language_arch_info (struct gdbarch *gdbarch,
 806                             struct language_arch_info *lai)
 807 {
 808   lai->string_char_type = builtin_type (gdbarch)->builtin_char;
 809   lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
 810   lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
 811                                                        struct type *);
 812 }
 813
 814 /* Constant data that describes the unknown language.  */
 815
 816 extern const struct language_data unknown_language_data =
 817 {
 818   "unknown",
 819   "Unknown",
 820   language_unknown,
 821   range_check_off,
 822   case_sensitive_on,
 823   array_row_major,
 824   macro_expansion_no,
 825   NULL,
 826   &exp_descriptor_standard,
 827   unk_lang_parser,
 828   null_post_parser,
 829   unk_lang_printchar,           /* Print character constant */
 830   unk_lang_printstr,
 831   unk_lang_emit_char,
 832   unk_lang_print_type,          /* Print a type using appropriate syntax */
 833   default_print_typedef,        /* Print a typedef using appropriate syntax */
 834   unk_lang_value_print_inner,   /* la_value_print_inner */
 835   unk_lang_value_print,         /* Print a top-level value */
 836   unk_lang_trampoline,          /* Language specific skip_trampoline */
 837   "this",                       /* name_of_this */
 838   true,                         /* store_sym_names_in_linkage_form_p */
 839   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 840   basic_lookup_transparent_type,/* lookup_transparent_type */
 841   unk_lang_demangle,            /* Language specific symbol demangler */
 842   NULL,
 843   unk_lang_class_name,          /* Language specific
 844                                    class_name_from_physname */
 845   unk_op_print_tab,             /* expression operators for printing */
 846   1,                            /* c-style arrays */
 847   0,                            /* String lower bound */
 848   default_word_break_characters,
 849   default_collect_symbol_completion_matches,
 850   unknown_language_arch_info,   /* la_language_arch_info.  */
 851   default_pass_by_reference,
 852   c_watch_location_expression,
 853   NULL,                         /* la_get_symbol_name_matcher */
 854   iterate_over_symbols,
 855   default_search_name_hash,
 856   &default_varobj_ops,
 857   NULL,
 858   NULL,
 859   default_is_string_type_p,
 860   "{...}"                       /* la_struct_too_deep_ellipsis */
 861 };
 862
 863 /* Class representing the unknown language.  */
 864
 865 class unknown_language : public language_defn
 866 {
 867 public:
 868   unknown_language ()
 869     : language_defn (language_unknown, unknown_language_data)
 870   { /* Nothing.  */ }
 871 };
 872
 873 /* Single instance of the unknown language class.  */
 874
 875 static unknown_language unknown_language_defn;
 876
 877 /* Constant data for the fake "auto" language.  */
 878
 879 extern const struct language_data auto_language_data =
 880 {
 881   "auto",
 882   "Auto",
 883   language_auto,
 884   range_check_off,
 885   case_sensitive_on,
 886   array_row_major,
 887   macro_expansion_no,
 888   NULL,
 889   &exp_descriptor_standard,
 890   unk_lang_parser,
 891   null_post_parser,
 892   unk_lang_printchar,           /* Print character constant */
 893   unk_lang_printstr,
 894   unk_lang_emit_char,
 895   unk_lang_print_type,          /* Print a type using appropriate syntax */
 896   default_print_typedef,        /* Print a typedef using appropriate syntax */
 897   unk_lang_value_print_inner,   /* la_value_print_inner */
 898   unk_lang_value_print,         /* Print a top-level value */
 899   unk_lang_trampoline,          /* Language specific skip_trampoline */
 900   "this",                       /* name_of_this */
 901   false,                        /* store_sym_names_in_linkage_form_p */
 902   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 903   basic_lookup_transparent_type,/* lookup_transparent_type */
 904   unk_lang_demangle,            /* Language specific symbol demangler */
 905   NULL,
 906   unk_lang_class_name,          /* Language specific
 907                                    class_name_from_physname */
 908   unk_op_print_tab,             /* expression operators for printing */
 909   1,                            /* c-style arrays */
 910   0,                            /* String lower bound */
 911   default_word_break_characters,
 912   default_collect_symbol_completion_matches,
 913   unknown_language_arch_info,   /* la_language_arch_info.  */
 914   default_pass_by_reference,
 915   c_watch_location_expression,
 916   NULL,                         /* la_get_symbol_name_matcher */
 917   iterate_over_symbols,
 918   default_search_name_hash,
 919   &default_varobj_ops,
 920   NULL,
 921   NULL,
 922   default_is_string_type_p,
 923   "{...}"                       /* la_struct_too_deep_ellipsis */
 924 };
 925
 926 /* Class representing the fake "auto" language.  */
 927
 928 class auto_language : public language_defn
 929 {
 930 public:
 931   auto_language ()
 932     : language_defn (language_auto, auto_language_data)
 933   { /* Nothing.  */ }
 934 };
 935
 936 /* Single instance of the fake "auto" language.  */
 937
 938 static auto_language auto_language_defn;
 939
 940 \f
 941 /* Per-architecture language information.  */
 942
 943 static struct gdbarch_data *language_gdbarch_data;
 944
 945 struct language_gdbarch
 946 {
 947   /* A vector of per-language per-architecture info.  Indexed by "enum
 948      language".  */
 949   struct language_arch_info arch_info[nr_languages];
 950 };
 951
 952 static void *
 953 language_gdbarch_post_init (struct gdbarch *gdbarch)
 954 {
 955   struct language_gdbarch *l;
 956
 957   l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
 958   for (const auto &lang : language_defn::languages)
 959     if (lang != NULL && lang->la_language_arch_info != NULL)
 960       {
 961         lang->la_language_arch_info (gdbarch,
 962                                      l->arch_info + lang->la_language);
 963       }
 964
 965   return l;
 966 }
 967
 968 struct type *
 969 language_string_char_type (const struct language_defn *la,
 970                            struct gdbarch *gdbarch)
 971 {
 972   struct language_gdbarch *ld
 973     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
 974
 975   return ld->arch_info[la->la_language].string_char_type;
 976 }
 977
 978 struct type *
 979 language_bool_type (const struct language_defn *la,
 980                     struct gdbarch *gdbarch)
 981 {
 982   struct language_gdbarch *ld
 983     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
 984
 985   if (ld->arch_info[la->la_language].bool_type_symbol)
 986     {
 987       struct symbol *sym;
 988
 989       sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
 990                            NULL, VAR_DOMAIN, NULL).symbol;
 991       if (sym)
 992         {
 993           struct type *type = SYMBOL_TYPE (sym);
 994
 995           if (type && type->code () == TYPE_CODE_BOOL)
 996             return type;
 997         }
 998     }
 999
1000   return ld->arch_info[la->la_language].bool_type_default;
1001 }
1002
1003 /* Helper function for primitive type lookup.  */
1004
1005 static struct type **
1006 language_lookup_primitive_type_1 (const struct language_arch_info *lai,
1007                                   const char *name)
1008 {
1009   struct type **p;
1010
1011   for (p = lai->primitive_type_vector; (*p) != NULL; p++)
1012     {
1013       if (strcmp ((*p)->name (), name) == 0)
1014         return p;
1015     }
1016   return NULL;
1017 }
1018
1019 /* See language.h.  */
1020
1021 struct type *
1022 language_lookup_primitive_type (const struct language_defn *la,
1023                                 struct gdbarch *gdbarch,
1024                                 const char *name)
1025 {
1026   struct language_gdbarch *ld =
1027     (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1028   struct type **typep;
1029
1030   typep = language_lookup_primitive_type_1 (&ld->arch_info[la->la_language],
1031                                             name);
1032   if (typep == NULL)
1033     return NULL;
1034   return *typep;
1035 }
1036
1037 /* Helper function for type lookup as a symbol.
1038    Create the symbol corresponding to type TYPE in language LANG.  */
1039
1040 static struct symbol *
1041 language_alloc_type_symbol (enum language lang, struct type *type)
1042 {
1043   struct symbol *symbol;
1044   struct gdbarch *gdbarch;
1045
1046   gdb_assert (!TYPE_OBJFILE_OWNED (type));
1047
1048   gdbarch = TYPE_OWNER (type).gdbarch;
1049   symbol = new (gdbarch_obstack (gdbarch)) struct symbol ();
1050
1051   symbol->m_name = type->name ();
1052   symbol->set_language (lang, nullptr);
1053   symbol->owner.arch = gdbarch;
1054   SYMBOL_OBJFILE_OWNED (symbol) = 0;
1055   SYMBOL_SECTION (symbol) = 0;
1056   SYMBOL_TYPE (symbol) = type;
1057   SYMBOL_DOMAIN (symbol) = VAR_DOMAIN;
1058   SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF;
1059
1060   return symbol;
1061 }
1062
1063 /* Initialize the primitive type symbols of language LD.
1064    The primitive type vector must have already been initialized.  */
1065
1066 static void
1067 language_init_primitive_type_symbols (struct language_arch_info *lai,
1068                                       const struct language_defn *la,
1069                                       struct gdbarch *gdbarch)
1070 {
1071   int n;
1072
1073   gdb_assert (lai->primitive_type_vector != NULL);
1074
1075   for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
1076     continue;
1077
1078   lai->primitive_type_symbols
1079     = GDBARCH_OBSTACK_CALLOC (gdbarch, n + 1, struct symbol *);
1080
1081   for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
1082     {
1083       lai->primitive_type_symbols[n]
1084         = language_alloc_type_symbol (la->la_language,
1085                                       lai->primitive_type_vector[n]);
1086     }
1087
1088   /* Note: The result of symbol lookup is normally a symbol *and* the block
1089      it was found in.  Builtin types don't live in blocks.  We *could* give
1090      them one, but there is no current need so to keep things simple symbol
1091      lookup is extended to allow for BLOCK_FOUND to be NULL.  */
1092 }
1093
1094 /* See language.h.  */
1095
1096 struct symbol *
1097 language_lookup_primitive_type_as_symbol (const struct language_defn *la,
1098                                           struct gdbarch *gdbarch,
1099                                           const char *name)
1100 {
1101   struct language_gdbarch *ld
1102     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1103   struct language_arch_info *lai = &ld->arch_info[la->la_language];
1104   struct type **typep;
1105   struct symbol *sym;
1106
1107   if (symbol_lookup_debug)
1108     {
1109       fprintf_unfiltered (gdb_stdlog,
1110                           "language_lookup_primitive_type_as_symbol"
1111                           " (%s, %s, %s)",
1112                           la->la_name, host_address_to_string (gdbarch), name);
1113     }
1114
1115   typep = language_lookup_primitive_type_1 (lai, name);
1116   if (typep == NULL)
1117     {
1118       if (symbol_lookup_debug)
1119         fprintf_unfiltered (gdb_stdlog, " = NULL\n");
1120       return NULL;
1121     }
1122
1123   /* The set of symbols is lazily initialized.  */
1124   if (lai->primitive_type_symbols == NULL)
1125     language_init_primitive_type_symbols (lai, la, gdbarch);
1126
1127   sym = lai->primitive_type_symbols[typep - lai->primitive_type_vector];
1128
1129   if (symbol_lookup_debug)
1130     fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym));
1131   return sym;
1132 }
1133
1134 /* Initialize the language routines.  */
1135
1136 void _initialize_language ();
1137 void
1138 _initialize_language ()
1139 {
1140   static const char *const type_or_range_names[]
1141     = { "on", "off", "warn", "auto", NULL };
1142
1143   static const char *const case_sensitive_names[]
1144     = { "on", "off", "auto", NULL };
1145
1146   language_gdbarch_data
1147     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1148
1149   /* GDB commands for language specific stuff.  */
1150
1151   add_basic_prefix_cmd ("check", no_class,
1152                         _("Set the status of the type/range checker."),
1153                         &setchecklist, "set check ", 0, &setlist);
1154   add_alias_cmd ("c", "check", no_class, 1, &setlist);
1155   add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1156
1157   add_show_prefix_cmd ("check", no_class,
1158                        _("Show the status of the type/range checker."),
1159                        &showchecklist, "show check ", 0, &showlist);
1160   add_alias_cmd ("c", "check", no_class, 1, &showlist);
1161   add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1162
1163   add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1164                         &range,
1165                         _("Set range checking (on/warn/off/auto)."),
1166                         _("Show range checking (on/warn/off/auto)."),
1167                         NULL, set_range_command,
1168                         show_range_command,
1169                         &setchecklist, &showchecklist);
1170
1171   add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1172                         &case_sensitive, _("\
1173 Set case sensitivity in name search (on/off/auto)."), _("\
1174 Show case sensitivity in name search (on/off/auto)."), _("\
1175 For Fortran the default is off; for other languages the default is on."),
1176                         set_case_command,
1177                         show_case_command,
1178                         &setlist, &showlist);
1179
1180   /* In order to call SET_LANGUAGE (below) we need to make sure that
1181      CURRENT_LANGUAGE is not NULL.  So first set the language to unknown,
1182      then we can change the language to 'auto'.  */
1183   current_language = language_def (language_unknown);
1184
1185   add_set_language_command ();
1186
1187   language = "auto";
1188   range = "auto";
1189   case_sensitive = "auto";
1190
1191   /* Have the above take effect.  */
1192   set_language (language_auto);
1193 }