gdb/language.c

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