gdb/language.c

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