gdb/language.c

   1 /* Multiple source language support for GDB.
   2
   3    Copyright (C) 1991-2016 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
  47 extern void _initialize_language (void);
  48
  49 static void unk_lang_error (char *);
  50
  51 static int unk_lang_parser (struct parser_state *);
  52
  53 static void show_check (char *, int);
  54
  55 static void set_check (char *, int);
  56
  57 static void set_range_case (void);
  58
  59 static void unk_lang_emit_char (int c, struct type *type,
  60                                 struct ui_file *stream, int quoter);
  61
  62 static void unk_lang_printchar (int c, struct type *type,
  63                                 struct ui_file *stream);
  64
  65 static void unk_lang_value_print (struct value *, struct ui_file *,
  66                                   const struct value_print_options *);
  67
  68 static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc);
  69
  70 /* Forward declaration */
  71 extern const struct language_defn unknown_language_defn;
  72
  73 /* The current (default at startup) state of type and range checking.
  74    (If the modes are set to "auto", though, these are changed based
  75    on the default language at startup, and then again based on the
  76    language of the first source file.  */
  77
  78 enum range_mode range_mode = range_mode_auto;
  79 enum range_check range_check = range_check_off;
  80 enum case_mode case_mode = case_mode_auto;
  81 enum case_sensitivity case_sensitivity = case_sensitive_on;
  82
  83 /* The current language and language_mode (see language.h).  */
  84
  85 const struct language_defn *current_language = &unknown_language_defn;
  86 enum language_mode language_mode = language_mode_auto;
  87
  88 /* The language that the user expects to be typing in (the language
  89    of main(), or the last language we notified them about, or C).  */
  90
  91 const struct language_defn *expected_language;
  92
  93 /* The list of supported languages.  The list itself is malloc'd.  */
  94
  95 static const struct language_defn **languages;
  96 static unsigned languages_size;
  97 static unsigned languages_allocsize;
  98 #define DEFAULT_ALLOCSIZE 4
  99
 100 /* The current values of the "set language/type/range" enum
 101    commands.  */
 102 static const char *language;
 103 static const char *type;
 104 static const char *range;
 105 static const char *case_sensitive;
 106
 107 /* Warning issued when current_language and the language of the current
 108    frame do not match.  */
 109 char lang_frame_mismatch_warn[] =
 110 "Warning: the current language does not match this frame.";
 111 \f
 112 /* This page contains the functions corresponding to GDB commands
 113    and their helpers.  */
 114
 115 /* Show command.  Display a warning if the language set
 116    does not match the frame.  */
 117 static void
 118 show_language_command (struct ui_file *file, int from_tty,
 119                        struct cmd_list_element *c, const char *value)
 120 {
 121   enum language flang;          /* The language of the frame.  */
 122
 123   if (language_mode == language_mode_auto)
 124     fprintf_filtered (gdb_stdout,
 125                       _("The current source language is "
 126                         "\"auto; currently %s\".\n"),
 127                       current_language->la_name);
 128   else
 129     fprintf_filtered (gdb_stdout,
 130                       _("The current source language is \"%s\".\n"),
 131                       current_language->la_name);
 132
 133   if (has_stack_frames ())
 134     {
 135       struct frame_info *frame;
 136
 137       frame = get_selected_frame (NULL);
 138       flang = get_frame_language (frame);
 139       if (flang != language_unknown
 140           && language_mode == language_mode_manual
 141           && current_language->la_language != flang)
 142         printf_filtered ("%s\n", lang_frame_mismatch_warn);
 143     }
 144 }
 145
 146 /* Set command.  Change the current working language.  */
 147 static void
 148 set_language_command (char *ignore, int from_tty, struct cmd_list_element *c)
 149 {
 150   int i;
 151   enum language flang = language_unknown;
 152
 153   /* Search the list of languages for a match.  */
 154   for (i = 0; i < languages_size; i++)
 155     {
 156       if (strcmp (languages[i]->la_name, language) == 0)
 157         {
 158           /* Found it!  Go into manual mode, and use this language.  */
 159           if (languages[i]->la_language == language_auto)
 160             {
 161               /* Enter auto mode.  Set to the current frame's language, if
 162                  known, or fallback to the initial language.  */
 163               language_mode = language_mode_auto;
 164               TRY
 165                 {
 166                   struct frame_info *frame;
 167
 168                   frame = get_selected_frame (NULL);
 169                   flang = get_frame_language (frame);
 170                 }
 171               CATCH (ex, RETURN_MASK_ERROR)
 172                 {
 173                   flang = language_unknown;
 174                 }
 175               END_CATCH
 176
 177               if (flang != language_unknown)
 178                 set_language (flang);
 179               else
 180                 set_initial_language ();
 181               expected_language = current_language;
 182               return;
 183             }
 184           else
 185             {
 186               /* Enter manual mode.  Set the specified language.  */
 187               language_mode = language_mode_manual;
 188               current_language = languages[i];
 189               set_range_case ();
 190               expected_language = current_language;
 191               return;
 192             }
 193         }
 194     }
 195
 196   internal_error (__FILE__, __LINE__,
 197                   "Couldn't find language `%s' in known languages list.",
 198                   language);
 199 }
 200
 201 /* Show command.  Display a warning if the range setting does
 202    not match the current language.  */
 203 static void
 204 show_range_command (struct ui_file *file, int from_tty,
 205                     struct cmd_list_element *c, const char *value)
 206 {
 207   if (range_mode == range_mode_auto)
 208     {
 209       char *tmp;
 210
 211       switch (range_check)
 212         {
 213         case range_check_on:
 214           tmp = "on";
 215           break;
 216         case range_check_off:
 217           tmp = "off";
 218           break;
 219         case range_check_warn:
 220           tmp = "warn";
 221           break;
 222         default:
 223           internal_error (__FILE__, __LINE__,
 224                           "Unrecognized range check setting.");
 225         }
 226
 227       fprintf_filtered (gdb_stdout,
 228                         _("Range checking is \"auto; currently %s\".\n"),
 229                         tmp);
 230     }
 231   else
 232     fprintf_filtered (gdb_stdout, _("Range checking is \"%s\".\n"),
 233                       value);
 234
 235   if (range_check != current_language->la_range_check)
 236     warning (_("the current range check setting "
 237                "does not match the language.\n"));
 238 }
 239
 240 /* Set command.  Change the setting for range checking.  */
 241 static void
 242 set_range_command (char *ignore, int from_tty, struct cmd_list_element *c)
 243 {
 244   if (strcmp (range, "on") == 0)
 245     {
 246       range_check = range_check_on;
 247       range_mode = range_mode_manual;
 248     }
 249   else if (strcmp (range, "warn") == 0)
 250     {
 251       range_check = range_check_warn;
 252       range_mode = range_mode_manual;
 253     }
 254   else if (strcmp (range, "off") == 0)
 255     {
 256       range_check = range_check_off;
 257       range_mode = range_mode_manual;
 258     }
 259   else if (strcmp (range, "auto") == 0)
 260     {
 261       range_mode = range_mode_auto;
 262       set_range_case ();
 263       return;
 264     }
 265   else
 266     {
 267       internal_error (__FILE__, __LINE__,
 268                       _("Unrecognized range check setting: \"%s\""), range);
 269     }
 270   if (range_check != current_language->la_range_check)
 271     warning (_("the current range check setting "
 272                "does not match the language.\n"));
 273 }
 274
 275 /* Show command.  Display a warning if the case sensitivity setting does
 276    not match the current language.  */
 277 static void
 278 show_case_command (struct ui_file *file, int from_tty,
 279                    struct cmd_list_element *c, const char *value)
 280 {
 281   if (case_mode == case_mode_auto)
 282     {
 283       char *tmp = NULL;
 284
 285       switch (case_sensitivity)
 286         {
 287         case case_sensitive_on:
 288           tmp = "on";
 289           break;
 290         case case_sensitive_off:
 291           tmp = "off";
 292           break;
 293         default:
 294           internal_error (__FILE__, __LINE__,
 295                           "Unrecognized case-sensitive setting.");
 296         }
 297
 298       fprintf_filtered (gdb_stdout,
 299                         _("Case sensitivity in "
 300                           "name search is \"auto; currently %s\".\n"),
 301                         tmp);
 302     }
 303   else
 304     fprintf_filtered (gdb_stdout,
 305                       _("Case sensitivity in name search is \"%s\".\n"),
 306                       value);
 307
 308   if (case_sensitivity != current_language->la_case_sensitivity)
 309     warning (_("the current case sensitivity setting does not match "
 310                "the language.\n"));
 311 }
 312
 313 /* Set command.  Change the setting for case sensitivity.  */
 314
 315 static void
 316 set_case_command (char *ignore, int from_tty, struct cmd_list_element *c)
 317 {
 318    if (strcmp (case_sensitive, "on") == 0)
 319      {
 320        case_sensitivity = case_sensitive_on;
 321        case_mode = case_mode_manual;
 322      }
 323    else if (strcmp (case_sensitive, "off") == 0)
 324      {
 325        case_sensitivity = case_sensitive_off;
 326        case_mode = case_mode_manual;
 327      }
 328    else if (strcmp (case_sensitive, "auto") == 0)
 329      {
 330        case_mode = case_mode_auto;
 331        set_range_case ();
 332        return;
 333      }
 334    else
 335      {
 336        internal_error (__FILE__, __LINE__,
 337                        "Unrecognized case-sensitive setting: \"%s\"",
 338                        case_sensitive);
 339      }
 340
 341    if (case_sensitivity != current_language->la_case_sensitivity)
 342      warning (_("the current case sensitivity setting does not match "
 343                 "the language.\n"));
 344 }
 345
 346 /* Set the status of range and type checking and case sensitivity based on
 347    the current modes and the current language.
 348    If SHOW is non-zero, then print out the current language,
 349    type and range checking status.  */
 350 static void
 351 set_range_case (void)
 352 {
 353   if (range_mode == range_mode_auto)
 354     range_check = current_language->la_range_check;
 355
 356   if (case_mode == case_mode_auto)
 357     case_sensitivity = current_language->la_case_sensitivity;
 358 }
 359
 360 /* Set current language to (enum language) LANG.  Returns previous
 361    language.  */
 362
 363 enum language
 364 set_language (enum language lang)
 365 {
 366   int i;
 367   enum language prev_language;
 368
 369   prev_language = current_language->la_language;
 370
 371   for (i = 0; i < languages_size; i++)
 372     {
 373       if (languages[i]->la_language == lang)
 374         {
 375           current_language = languages[i];
 376           set_range_case ();
 377           break;
 378         }
 379     }
 380
 381   return prev_language;
 382 }
 383 \f
 384
 385 /* Print out the current language settings: language, range and
 386    type checking.  If QUIETLY, print only what has changed.  */
 387
 388 void
 389 language_info (int quietly)
 390 {
 391   if (quietly && expected_language == current_language)
 392     return;
 393
 394   expected_language = current_language;
 395   printf_unfiltered (_("Current language:  %s\n"), language);
 396   show_language_command (NULL, 1, NULL, NULL);
 397
 398   if (!quietly)
 399     {
 400       printf_unfiltered (_("Range checking:    %s\n"), range);
 401       show_range_command (NULL, 1, NULL, NULL);
 402       printf_unfiltered (_("Case sensitivity:  %s\n"), case_sensitive);
 403       show_case_command (NULL, 1, NULL, NULL);
 404     }
 405 }
 406 \f
 407
 408 /* Returns non-zero if the value is a pointer type.  */
 409 int
 410 pointer_type (struct type *type)
 411 {
 412   return TYPE_CODE (type) == TYPE_CODE_PTR ||
 413     TYPE_CODE (type) == TYPE_CODE_REF;
 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 (char *str)
 476 {
 477   int i;
 478
 479   for (i = 0; i < languages_size; i++)
 480     if (strcmp (languages[i]->la_name, str) == 0)
 481       return languages[i]->la_language;
 482
 483   return language_unknown;
 484 }
 485
 486 /* Return the language struct for a given language enum.  */
 487
 488 const struct language_defn *
 489 language_def (enum language lang)
 490 {
 491   int i;
 492
 493   for (i = 0; i < languages_size; i++)
 494     {
 495       if (languages[i]->la_language == lang)
 496         {
 497           return languages[i];
 498         }
 499     }
 500   return NULL;
 501 }
 502
 503 /* Return the language as a string.  */
 504 const char *
 505 language_str (enum language lang)
 506 {
 507   int i;
 508
 509   for (i = 0; i < languages_size; i++)
 510     {
 511       if (languages[i]->la_language == lang)
 512         {
 513           return languages[i]->la_name;
 514         }
 515     }
 516   return "Unknown";
 517 }
 518
 519 static void
 520 set_check (char *ignore, int from_tty)
 521 {
 522   printf_unfiltered (
 523      "\"set check\" must be followed by the name of a check subcommand.\n");
 524   help_list (setchecklist, "set check ", all_commands, gdb_stdout);
 525 }
 526
 527 static void
 528 show_check (char *ignore, int from_tty)
 529 {
 530   cmd_show_list (showchecklist, from_tty, "");
 531 }
 532 \f
 533 /* Add a language to the set of known languages.  */
 534
 535 void
 536 add_language (const struct language_defn *lang)
 537 {
 538   /* For the "set language" command.  */
 539   static const char **language_names = NULL;
 540   /* For the "help set language" command.  */
 541   char *language_set_doc = NULL;
 542
 543   int i;
 544   struct ui_file *tmp_stream;
 545
 546   if (lang->la_magic != LANG_MAGIC)
 547     {
 548       fprintf_unfiltered (gdb_stderr,
 549                           "Magic number of %s language struct wrong\n",
 550                           lang->la_name);
 551       internal_error (__FILE__, __LINE__,
 552                       _("failed internal consistency check"));
 553     }
 554
 555   if (!languages)
 556     {
 557       languages_allocsize = DEFAULT_ALLOCSIZE;
 558       languages = XNEWVEC (const struct language_defn *, languages_allocsize);
 559     }
 560   if (languages_size >= languages_allocsize)
 561     {
 562       languages_allocsize *= 2;
 563       languages = (const struct language_defn **) xrealloc ((char *) languages,
 564                                  languages_allocsize * sizeof (*languages));
 565     }
 566   languages[languages_size++] = lang;
 567
 568   /* Build the language names array, to be used as enumeration in the
 569      set language" enum command.  */
 570   language_names = XRESIZEVEC (const char *, language_names,
 571                                languages_size + 1);
 572
 573   for (i = 0; i < languages_size; ++i)
 574     language_names[i] = languages[i]->la_name;
 575   language_names[i] = NULL;
 576
 577   /* Add the filename extensions.  */
 578   if (lang->la_filename_extensions != NULL)
 579     {
 580       int i;
 581
 582       for (i = 0; lang->la_filename_extensions[i] != NULL; ++i)
 583         add_filename_language (lang->la_filename_extensions[i],
 584                                lang->la_language);
 585     }
 586
 587   /* Build the "help set language" docs.  */
 588   tmp_stream = mem_fileopen ();
 589
 590   fprintf_unfiltered (tmp_stream,
 591                       _("Set the current source language.\n"
 592                         "The currently understood settings are:\n\nlocal or "
 593                         "auto    Automatic setting based on source file\n"));
 594
 595   for (i = 0; i < languages_size; ++i)
 596     {
 597       /* Already dealt with these above.  */
 598       if (languages[i]->la_language == language_unknown
 599           || languages[i]->la_language == language_auto)
 600         continue;
 601
 602       /* FIXME: i18n: for now assume that the human-readable name
 603          is just a capitalization of the internal name.  */
 604       fprintf_unfiltered (tmp_stream, "%-16s Use the %c%s language\n",
 605                           languages[i]->la_name,
 606                           /* Capitalize first letter of language
 607                              name.  */
 608                           toupper (languages[i]->la_name[0]),
 609                           languages[i]->la_name + 1);
 610     }
 611
 612   language_set_doc = ui_file_xstrdup (tmp_stream, NULL);
 613   ui_file_delete (tmp_stream);
 614
 615   add_setshow_enum_cmd ("language", class_support,
 616                         (const char **) language_names,
 617                         &language,
 618                         language_set_doc,
 619                         _("Show the current source language."),
 620                         NULL, set_language_command,
 621                         show_language_command,
 622                         &setlist, &showlist);
 623
 624   xfree (language_set_doc);
 625 }
 626
 627 /* Iterate through all registered languages looking for and calling
 628    any non-NULL struct language_defn.skip_trampoline() functions.
 629    Return the result from the first that returns non-zero, or 0 if all
 630    `fail'.  */
 631 CORE_ADDR
 632 skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
 633 {
 634   int i;
 635
 636   for (i = 0; i < languages_size; i++)
 637     {
 638       if (languages[i]->skip_trampoline)
 639         {
 640           CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc);
 641
 642           if (real_pc)
 643             return real_pc;
 644         }
 645     }
 646
 647   return 0;
 648 }
 649
 650 /* Return demangled language symbol, or NULL.
 651    FIXME: Options are only useful for certain languages and ignored
 652    by others, so it would be better to remove them here and have a
 653    more flexible demangler for the languages that need it.
 654    FIXME: Sometimes the demangler is invoked when we don't know the
 655    language, so we can't use this everywhere.  */
 656 char *
 657 language_demangle (const struct language_defn *current_language,
 658                                 const char *mangled, int options)
 659 {
 660   if (current_language != NULL && current_language->la_demangle)
 661     return current_language->la_demangle (mangled, options);
 662   return NULL;
 663 }
 664
 665 /* See langauge.h.  */
 666
 667 int
 668 language_sniff_from_mangled_name (const struct language_defn *lang,
 669                                   const char *mangled, char **demangled)
 670 {
 671   gdb_assert (lang != NULL);
 672
 673   if (lang->la_sniff_from_mangled_name == NULL)
 674     {
 675       *demangled = NULL;
 676       return 0;
 677     }
 678
 679   return lang->la_sniff_from_mangled_name (mangled, demangled);
 680 }
 681
 682 /* Return class name from physname or NULL.  */
 683 char *
 684 language_class_name_from_physname (const struct language_defn *lang,
 685                                    const char *physname)
 686 {
 687   if (lang != NULL && lang->la_class_name_from_physname)
 688     return lang->la_class_name_from_physname (physname);
 689   return NULL;
 690 }
 691
 692 /* Return non-zero if TYPE should be passed (and returned) by
 693    reference at the language level.  */
 694 int
 695 language_pass_by_reference (struct type *type)
 696 {
 697   return current_language->la_pass_by_reference (type);
 698 }
 699
 700 /* Return zero; by default, types are passed by value at the language
 701    level.  The target ABI may pass or return some structs by reference
 702    independent of this.  */
 703 int
 704 default_pass_by_reference (struct type *type)
 705 {
 706   return 0;
 707 }
 708
 709 /* Return the default string containing the list of characters
 710    delimiting words.  This is a reasonable default value that
 711    most languages should be able to use.  */
 712
 713 char *
 714 default_word_break_characters (void)
 715 {
 716   return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
 717 }
 718
 719 /* Print the index of array elements using the C99 syntax.  */
 720
 721 void
 722 default_print_array_index (struct value *index_value, struct ui_file *stream,
 723                            const struct value_print_options *options)
 724 {
 725   fprintf_filtered (stream, "[");
 726   LA_VALUE_PRINT (index_value, stream, options);
 727   fprintf_filtered (stream, "] = ");
 728 }
 729
 730 void
 731 default_get_string (struct value *value, gdb_byte **buffer, int *length,
 732                     struct type **char_type, const char **charset)
 733 {
 734   error (_("Getting a string is unsupported in this language."));
 735 }
 736
 737 /* Define the language that is no language.  */
 738
 739 static int
 740 unk_lang_parser (struct parser_state *ps)
 741 {
 742   return 1;
 743 }
 744
 745 static void
 746 unk_lang_error (char *msg)
 747 {
 748   error (_("Attempted to parse an expression with unknown language"));
 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, const gdb_byte *valaddr,
 787                     int embedded_offset, CORE_ADDR address,
 788                     struct ui_file *stream, int recurse,
 789                     const 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   unk_lang_error,
 848   null_post_parser,
 849   unk_lang_printchar,           /* Print character constant */
 850   unk_lang_printstr,
 851   unk_lang_emit_char,
 852   unk_lang_print_type,          /* Print a type using appropriate syntax */
 853   default_print_typedef,        /* Print a typedef using appropriate syntax */
 854   unk_lang_val_print,           /* Print a value using appropriate syntax */
 855   unk_lang_value_print,         /* Print a top-level value */
 856   default_read_var_value,       /* la_read_var_value */
 857   unk_lang_trampoline,          /* Language specific skip_trampoline */
 858   "this",                       /* name_of_this */
 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_make_symbol_completion_list,
 870   unknown_language_arch_info,   /* la_language_arch_info.  */
 871   default_print_array_index,
 872   default_pass_by_reference,
 873   default_get_string,
 874   NULL,                         /* la_get_symbol_name_cmp */
 875   iterate_over_symbols,
 876   &default_varobj_ops,
 877   NULL,
 878   NULL,
 879   LANG_MAGIC
 880 };
 881
 882 /* These two structs define fake entries for the "local" and "auto"
 883    options.  */
 884 const struct language_defn auto_language_defn =
 885 {
 886   "auto",
 887   "Auto",
 888   language_auto,
 889   range_check_off,
 890   case_sensitive_on,
 891   array_row_major,
 892   macro_expansion_no,
 893   NULL,
 894   &exp_descriptor_standard,
 895   unk_lang_parser,
 896   unk_lang_error,
 897   null_post_parser,
 898   unk_lang_printchar,           /* Print character constant */
 899   unk_lang_printstr,
 900   unk_lang_emit_char,
 901   unk_lang_print_type,          /* Print a type using appropriate syntax */
 902   default_print_typedef,        /* Print a typedef using appropriate syntax */
 903   unk_lang_val_print,           /* Print a value using appropriate syntax */
 904   unk_lang_value_print,         /* Print a top-level value */
 905   default_read_var_value,       /* la_read_var_value */
 906   unk_lang_trampoline,          /* Language specific skip_trampoline */
 907   "this",                       /* name_of_this */
 908   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 909   basic_lookup_transparent_type,/* lookup_transparent_type */
 910   unk_lang_demangle,            /* Language specific symbol demangler */
 911   NULL,
 912   unk_lang_class_name,          /* Language specific
 913                                    class_name_from_physname */
 914   unk_op_print_tab,             /* expression operators for printing */
 915   1,                            /* c-style arrays */
 916   0,                            /* String lower bound */
 917   default_word_break_characters,
 918   default_make_symbol_completion_list,
 919   unknown_language_arch_info,   /* la_language_arch_info.  */
 920   default_print_array_index,
 921   default_pass_by_reference,
 922   default_get_string,
 923   NULL,                         /* la_get_symbol_name_cmp */
 924   iterate_over_symbols,
 925   &default_varobj_ops,
 926   NULL,
 927   NULL,
 928   LANG_MAGIC
 929 };
 930
 931 const struct language_defn local_language_defn =
 932 {
 933   "local",
 934   "Local",
 935   language_auto,
 936   range_check_off,
 937   case_sensitive_on,
 938   array_row_major,
 939   macro_expansion_no,
 940   NULL,
 941   &exp_descriptor_standard,
 942   unk_lang_parser,
 943   unk_lang_error,
 944   null_post_parser,
 945   unk_lang_printchar,           /* Print character constant */
 946   unk_lang_printstr,
 947   unk_lang_emit_char,
 948   unk_lang_print_type,          /* Print a type using appropriate syntax */
 949   default_print_typedef,        /* Print a typedef using appropriate syntax */
 950   unk_lang_val_print,           /* Print a value using appropriate syntax */
 951   unk_lang_value_print,         /* Print a top-level value */
 952   default_read_var_value,       /* la_read_var_value */
 953   unk_lang_trampoline,          /* Language specific skip_trampoline */
 954   "this",                       /* name_of_this */
 955   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 956   basic_lookup_transparent_type,/* lookup_transparent_type */
 957   unk_lang_demangle,            /* Language specific symbol demangler */
 958   NULL,
 959   unk_lang_class_name,          /* Language specific
 960                                    class_name_from_physname */
 961   unk_op_print_tab,             /* expression operators for printing */
 962   1,                            /* c-style arrays */
 963   0,                            /* String lower bound */
 964   default_word_break_characters,
 965   default_make_symbol_completion_list,
 966   unknown_language_arch_info,   /* la_language_arch_info.  */
 967   default_print_array_index,
 968   default_pass_by_reference,
 969   default_get_string,
 970   NULL,                         /* la_get_symbol_name_cmp */
 971   iterate_over_symbols,
 972   &default_varobj_ops,
 973   NULL,
 974   NULL,
 975   LANG_MAGIC
 976 };
 977 \f
 978 /* Per-architecture language information.  */
 979
 980 static struct gdbarch_data *language_gdbarch_data;
 981
 982 struct language_gdbarch
 983 {
 984   /* A vector of per-language per-architecture info.  Indexed by "enum
 985      language".  */
 986   struct language_arch_info arch_info[nr_languages];
 987 };
 988
 989 static void *
 990 language_gdbarch_post_init (struct gdbarch *gdbarch)
 991 {
 992   struct language_gdbarch *l;
 993   int i;
 994
 995   l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
 996   for (i = 0; i < languages_size; i++)
 997     {
 998       if (languages[i] != NULL
 999           && languages[i]->la_language_arch_info != NULL)
1000         languages[i]->la_language_arch_info
1001           (gdbarch, l->arch_info + languages[i]->la_language);
1002     }
1003   return l;
1004 }
1005
1006 struct type *
1007 language_string_char_type (const struct language_defn *la,
1008                            struct gdbarch *gdbarch)
1009 {
1010   struct language_gdbarch *ld
1011     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1012
1013   return ld->arch_info[la->la_language].string_char_type;
1014 }
1015
1016 struct type *
1017 language_bool_type (const struct language_defn *la,
1018                     struct gdbarch *gdbarch)
1019 {
1020   struct language_gdbarch *ld
1021     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1022
1023   if (ld->arch_info[la->la_language].bool_type_symbol)
1024     {
1025       struct symbol *sym;
1026
1027       sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
1028                            NULL, VAR_DOMAIN, NULL).symbol;
1029       if (sym)
1030         {
1031           struct type *type = SYMBOL_TYPE (sym);
1032
1033           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
1034             return type;
1035         }
1036     }
1037
1038   return ld->arch_info[la->la_language].bool_type_default;
1039 }
1040
1041 /* Helper function for primitive type lookup.  */
1042
1043 static struct type **
1044 language_lookup_primitive_type_1 (const struct language_arch_info *lai,
1045                                   const char *name)
1046 {
1047   struct type **p;
1048
1049   for (p = lai->primitive_type_vector; (*p) != NULL; p++)
1050     {
1051       if (strcmp (TYPE_NAME (*p), name) == 0)
1052         return p;
1053     }
1054   return NULL;
1055 }
1056
1057 /* See language.h.  */
1058
1059 struct type *
1060 language_lookup_primitive_type (const struct language_defn *la,
1061                                 struct gdbarch *gdbarch,
1062                                 const char *name)
1063 {
1064   struct language_gdbarch *ld =
1065     (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1066   struct type **typep;
1067
1068   typep = language_lookup_primitive_type_1 (&ld->arch_info[la->la_language],
1069                                             name);
1070   if (typep == NULL)
1071     return NULL;
1072   return *typep;
1073 }
1074
1075 /* Helper function for type lookup as a symbol.
1076    Create the symbol corresponding to type TYPE in language LANG.  */
1077
1078 static struct symbol *
1079 language_alloc_type_symbol (enum language lang, struct type *type)
1080 {
1081   struct symbol *symbol;
1082   struct gdbarch *gdbarch;
1083
1084   gdb_assert (!TYPE_OBJFILE_OWNED (type));
1085
1086   gdbarch = TYPE_OWNER (type).gdbarch;
1087   symbol = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct symbol);
1088
1089   symbol->ginfo.name = TYPE_NAME (type);
1090   symbol->ginfo.language = lang;
1091   symbol->owner.arch = gdbarch;
1092   SYMBOL_OBJFILE_OWNED (symbol) = 0;
1093   SYMBOL_TYPE (symbol) = type;
1094   SYMBOL_DOMAIN (symbol) = VAR_DOMAIN;
1095   SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF;
1096
1097   return symbol;
1098 }
1099
1100 /* Initialize the primitive type symbols of language LD.
1101    The primitive type vector must have already been initialized.  */
1102
1103 static void
1104 language_init_primitive_type_symbols (struct language_arch_info *lai,
1105                                       const struct language_defn *la,
1106                                       struct gdbarch *gdbarch)
1107 {
1108   int n;
1109
1110   gdb_assert (lai->primitive_type_vector != NULL);
1111
1112   for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
1113     continue;
1114
1115   lai->primitive_type_symbols
1116     = GDBARCH_OBSTACK_CALLOC (gdbarch, n + 1, struct symbol *);
1117
1118   for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
1119     {
1120       lai->primitive_type_symbols[n]
1121         = language_alloc_type_symbol (la->la_language,
1122                                       lai->primitive_type_vector[n]);
1123     }
1124
1125   /* Note: The result of symbol lookup is normally a symbol *and* the block
1126      it was found in.  Builtin types don't live in blocks.  We *could* give
1127      them one, but there is no current need so to keep things simple symbol
1128      lookup is extended to allow for BLOCK_FOUND to be NULL.  */
1129 }
1130
1131 /* See language.h.  */
1132
1133 struct symbol *
1134 language_lookup_primitive_type_as_symbol (const struct language_defn *la,
1135                                           struct gdbarch *gdbarch,
1136                                           const char *name)
1137 {
1138   struct language_gdbarch *ld
1139     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1140   struct language_arch_info *lai = &ld->arch_info[la->la_language];
1141   struct type **typep;
1142   struct symbol *sym;
1143
1144   if (symbol_lookup_debug)
1145     {
1146       fprintf_unfiltered (gdb_stdlog,
1147                           "language_lookup_primitive_type_as_symbol"
1148                           " (%s, %s, %s)",
1149                           la->la_name, host_address_to_string (gdbarch), name);
1150     }
1151
1152   typep = language_lookup_primitive_type_1 (lai, name);
1153   if (typep == NULL)
1154     {
1155       if (symbol_lookup_debug)
1156         fprintf_unfiltered (gdb_stdlog, " = NULL\n");
1157       return NULL;
1158     }
1159
1160   /* The set of symbols is lazily initialized.  */
1161   if (lai->primitive_type_symbols == NULL)
1162     language_init_primitive_type_symbols (lai, la, gdbarch);
1163
1164   sym = lai->primitive_type_symbols[typep - lai->primitive_type_vector];
1165
1166   if (symbol_lookup_debug)
1167     fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym));
1168   return sym;
1169 }
1170
1171 /* Initialize the language routines.  */
1172
1173 void
1174 _initialize_language (void)
1175 {
1176   static const char *const type_or_range_names[]
1177     = { "on", "off", "warn", "auto", NULL };
1178
1179   static const char *const case_sensitive_names[]
1180     = { "on", "off", "auto", NULL };
1181
1182   language_gdbarch_data
1183     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1184
1185   /* GDB commands for language specific stuff.  */
1186
1187   add_prefix_cmd ("check", no_class, set_check,
1188                   _("Set the status of the type/range checker."),
1189                   &setchecklist, "set check ", 0, &setlist);
1190   add_alias_cmd ("c", "check", no_class, 1, &setlist);
1191   add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1192
1193   add_prefix_cmd ("check", no_class, show_check,
1194                   _("Show the status of the type/range checker."),
1195                   &showchecklist, "show check ", 0, &showlist);
1196   add_alias_cmd ("c", "check", no_class, 1, &showlist);
1197   add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1198
1199   add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1200                         &range,
1201                         _("Set range checking.  (on/warn/off/auto)"),
1202                         _("Show range checking.  (on/warn/off/auto)"),
1203                         NULL, set_range_command,
1204                         show_range_command,
1205                         &setchecklist, &showchecklist);
1206
1207   add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1208                         &case_sensitive, _("\
1209 Set case sensitivity in name search.  (on/off/auto)"), _("\
1210 Show case sensitivity in name search.  (on/off/auto)"), _("\
1211 For Fortran the default is off; for other languages the default is on."),
1212                         set_case_command,
1213                         show_case_command,
1214                         &setlist, &showlist);
1215
1216   add_language (&auto_language_defn);
1217   add_language (&local_language_defn);
1218   add_language (&unknown_language_defn);
1219
1220   language = xstrdup ("auto");
1221   type = xstrdup ("auto");
1222   range = xstrdup ("auto");
1223   case_sensitive = xstrdup ("auto");
1224
1225   /* Have the above take effect.  */
1226   set_language (language_auto);
1227 }