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