gdb/language.c

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