gdb/language.c

   1 /* Multiple source language support for GDB.
   2
   3    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
   4    2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
   5    Free Software Foundation, Inc.
   6
   7    Contributed by the Department of Computer Science at the State University
   8    of New York at Buffalo.
   9
  10    This file is part of GDB.
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  24
  25 /* This file contains functions that return things that are specific
  26    to languages.  Each function should examine current_language if necessary,
  27    and return the appropriate result. */
  28
  29 /* FIXME:  Most of these would be better organized as macros which
  30    return data out of a "language-specific" struct pointer that is set
  31    whenever the working language changes.  That would be a lot faster.  */
  32
  33 #include "defs.h"
  34 #include <ctype.h>
  35 #include "gdb_string.h"
  36
  37 #include "symtab.h"
  38 #include "gdbtypes.h"
  39 #include "value.h"
  40 #include "gdbcmd.h"
  41 #include "expression.h"
  42 #include "language.h"
  43 #include "target.h"
  44 #include "parser-defs.h"
  45 #include "jv-lang.h"
  46 #include "demangle.h"
  47 #include "symfile.h"
  48
  49 extern void _initialize_language (void);
  50
  51 static void unk_lang_error (char *);
  52
  53 static int unk_lang_parser (void);
  54
  55 static void show_check (char *, int);
  56
  57 static void set_check (char *, int);
  58
  59 static void set_type_range_case (void);
  60
  61 static void unk_lang_emit_char (int c, struct type *type,
  62                                 struct ui_file *stream, int quoter);
  63
  64 static void unk_lang_printchar (int c, struct type *type,
  65                                 struct ui_file *stream);
  66
  67 static void unk_lang_print_type (struct type *, char *, struct ui_file *,
  68                                  int, int);
  69
  70 static int unk_lang_value_print (struct value *, struct ui_file *,
  71                                  const struct value_print_options *);
  72
  73 static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc);
  74
  75 /* Forward declaration */
  76 extern const struct language_defn unknown_language_defn;
  77
  78 /* The current (default at startup) state of type and range checking.
  79    (If the modes are set to "auto", though, these are changed based
  80    on the default language at startup, and then again based on the
  81    language of the first source file.  */
  82
  83 enum range_mode range_mode = range_mode_auto;
  84 enum range_check range_check = range_check_off;
  85 enum type_mode type_mode = type_mode_auto;
  86 enum type_check type_check = type_check_off;
  87 enum case_mode case_mode = case_mode_auto;
  88 enum case_sensitivity case_sensitivity = case_sensitive_on;
  89
  90 /* The current language and language_mode (see language.h) */
  91
  92 const struct language_defn *current_language = &unknown_language_defn;
  93 enum language_mode language_mode = language_mode_auto;
  94
  95 /* The language that the user expects to be typing in (the language
  96    of main(), or the last language we notified them about, or C).  */
  97
  98 const struct language_defn *expected_language;
  99
 100 /* The list of supported languages.  The list itself is malloc'd.  */
 101
 102 static const struct language_defn **languages;
 103 static unsigned languages_size;
 104 static unsigned languages_allocsize;
 105 #define DEFAULT_ALLOCSIZE 4
 106
 107 /* The current values of the "set language/type/range" enum
 108    commands.  */
 109 static const char *language;
 110 static const char *type;
 111 static const char *range;
 112 static const char *case_sensitive;
 113
 114 /* Warning issued when current_language and the language of the current
 115    frame do not match. */
 116 char lang_frame_mismatch_warn[] =
 117 "Warning: the current language does not match this frame.";
 118 \f
 119 /* This page contains the functions corresponding to GDB commands
 120    and their helpers. */
 121
 122 /* Show command.  Display a warning if the language set
 123    does not match the frame. */
 124 static void
 125 show_language_command (struct ui_file *file, int from_tty,
 126                        struct cmd_list_element *c, const char *value)
 127 {
 128   enum language flang;          /* The language of the current frame */
 129
 130   if (language_mode == language_mode_auto)
 131     fprintf_filtered (gdb_stdout,
 132                       _("The current source language is "
 133                         "\"auto; currently %s\".\n"),
 134                       current_language->la_name);
 135   else
 136     fprintf_filtered (gdb_stdout, _("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, _("Case sensitivity in name search is \"%s\".\n"),
 366                       value);
 367
 368   if (case_sensitivity != current_language->la_case_sensitivity)
 369     warning (_("the current case sensitivity setting does not match "
 370                "the language.\n"));
 371 }
 372
 373 /* Set command.  Change the setting for case sensitivity.  */
 374
 375 static void
 376 set_case_command (char *ignore, int from_tty, struct cmd_list_element *c)
 377 {
 378    if (strcmp (case_sensitive, "on") == 0)
 379      {
 380        case_sensitivity = case_sensitive_on;
 381        case_mode = case_mode_manual;
 382      }
 383    else if (strcmp (case_sensitive, "off") == 0)
 384      {
 385        case_sensitivity = case_sensitive_off;
 386        case_mode = case_mode_manual;
 387      }
 388    else if (strcmp (case_sensitive, "auto") == 0)
 389      {
 390        case_mode = case_mode_auto;
 391        set_type_range_case ();
 392        return;
 393      }
 394    else
 395      {
 396        internal_error (__FILE__, __LINE__,
 397                        "Unrecognized case-sensitive setting: \"%s\"",
 398                        case_sensitive);
 399      }
 400
 401    if (case_sensitivity != current_language->la_case_sensitivity)
 402      warning (_("the current case sensitivity setting does not match "
 403                 "the language.\n"));
 404 }
 405
 406 /* Set the status of range and type checking and case sensitivity based on
 407    the current modes and the current language.
 408    If SHOW is non-zero, then print out the current language,
 409    type and range checking status. */
 410 static void
 411 set_type_range_case (void)
 412 {
 413   if (range_mode == range_mode_auto)
 414     range_check = current_language->la_range_check;
 415
 416   if (type_mode == type_mode_auto)
 417     type_check = current_language->la_type_check;
 418
 419   if (case_mode == case_mode_auto)
 420     case_sensitivity = current_language->la_case_sensitivity;
 421 }
 422
 423 /* Set current language to (enum language) LANG.  Returns previous language. */
 424
 425 enum language
 426 set_language (enum language lang)
 427 {
 428   int i;
 429   enum language prev_language;
 430
 431   prev_language = current_language->la_language;
 432
 433   for (i = 0; i < languages_size; i++)
 434     {
 435       if (languages[i]->la_language == lang)
 436         {
 437           current_language = languages[i];
 438           set_type_range_case ();
 439           break;
 440         }
 441     }
 442
 443   return prev_language;
 444 }
 445 \f
 446
 447 /* Print out the current language settings: language, range and
 448    type checking.  If QUIETLY, print only what has changed.  */
 449
 450 void
 451 language_info (int quietly)
 452 {
 453   if (quietly && expected_language == current_language)
 454     return;
 455
 456   expected_language = current_language;
 457   printf_unfiltered (_("Current language:  %s\n"), language);
 458   show_language_command (NULL, 1, NULL, NULL);
 459
 460   if (!quietly)
 461     {
 462       printf_unfiltered (_("Type checking:     %s\n"), type);
 463       show_type_command (NULL, 1, NULL, NULL);
 464       printf_unfiltered (_("Range checking:    %s\n"), range);
 465       show_range_command (NULL, 1, NULL, NULL);
 466       printf_unfiltered (_("Case sensitivity:  %s\n"), case_sensitive);
 467       show_case_command (NULL, 1, NULL, NULL);
 468     }
 469 }
 470 \f
 471 /* Return the result of a binary operation. */
 472
 473 #if 0                           /* Currently unused */
 474
 475 struct type *
 476 binop_result_type (struct value *v1, struct value *v2)
 477 {
 478   int size, uns;
 479   struct type *t1 = check_typedef (VALUE_TYPE (v1));
 480   struct type *t2 = check_typedef (VALUE_TYPE (v2));
 481
 482   int l1 = TYPE_LENGTH (t1);
 483   int l2 = TYPE_LENGTH (t2);
 484
 485   switch (current_language->la_language)
 486     {
 487     case language_c:
 488     case language_cplus:
 489     case language_d:
 490     case language_objc:
 491       if (TYPE_CODE (t1) == TYPE_CODE_FLT)
 492         return TYPE_CODE (t2) == TYPE_CODE_FLT && l2 > l1 ?
 493           VALUE_TYPE (v2) : VALUE_TYPE (v1);
 494       else if (TYPE_CODE (t2) == TYPE_CODE_FLT)
 495         return TYPE_CODE (t1) == TYPE_CODE_FLT && l1 > l2 ?
 496           VALUE_TYPE (v1) : VALUE_TYPE (v2);
 497       else if (TYPE_UNSIGNED (t1) && l1 > l2)
 498         return VALUE_TYPE (v1);
 499       else if (TYPE_UNSIGNED (t2) && l2 > l1)
 500         return VALUE_TYPE (v2);
 501       else                      /* Both are signed.  Result is the longer type */
 502         return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
 503       break;
 504     case language_m2:
 505       /* If we are doing type-checking, l1 should equal l2, so this is
 506          not needed. */
 507       return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
 508       break;
 509     }
 510   internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 511   return (struct type *) 0;     /* For lint */
 512 }
 513
 514 #endif /* 0 */
 515 #if 0
 516 /* This page contains functions that are used in type/range checking.
 517    They all return zero if the type/range check fails.
 518
 519    It is hoped that these will make extending GDB to parse different
 520    languages a little easier.  These are primarily used in eval.c when
 521    evaluating expressions and making sure that their types are correct.
 522    Instead of having a mess of conjucted/disjuncted expressions in an "if",
 523    the ideas of type can be wrapped up in the following functions.
 524
 525    Note that some of them are not currently dependent upon which language
 526    is currently being parsed.  For example, floats are the same in
 527    C and Modula-2 (ie. the only floating point type has TYPE_CODE of
 528    TYPE_CODE_FLT), while booleans are different. */
 529
 530 /* Returns non-zero if its argument is a simple type.  This is the same for
 531    both Modula-2 and for C.  In the C case, TYPE_CODE_CHAR will never occur,
 532    and thus will never cause the failure of the test. */
 533 int
 534 simple_type (struct type *type)
 535 {
 536   CHECK_TYPEDEF (type);
 537   switch (TYPE_CODE (type))
 538     {
 539     case TYPE_CODE_INT:
 540     case TYPE_CODE_CHAR:
 541     case TYPE_CODE_ENUM:
 542     case TYPE_CODE_FLT:
 543     case TYPE_CODE_RANGE:
 544     case TYPE_CODE_BOOL:
 545       return 1;
 546
 547     default:
 548       return 0;
 549     }
 550 }
 551
 552 /* Returns non-zero if its argument is of an ordered type.
 553    An ordered type is one in which the elements can be tested for the
 554    properties of "greater than", "less than", etc, or for which the
 555    operations "increment" or "decrement" make sense. */
 556 int
 557 ordered_type (struct type *type)
 558 {
 559   CHECK_TYPEDEF (type);
 560   switch (TYPE_CODE (type))
 561     {
 562     case TYPE_CODE_INT:
 563     case TYPE_CODE_CHAR:
 564     case TYPE_CODE_ENUM:
 565     case TYPE_CODE_FLT:
 566     case TYPE_CODE_RANGE:
 567       return 1;
 568
 569     default:
 570       return 0;
 571     }
 572 }
 573
 574 /* Returns non-zero if the two types are the same */
 575 int
 576 same_type (struct type *arg1, struct type *arg2)
 577 {
 578   CHECK_TYPEDEF (type);
 579   if (structured_type (arg1) ? !structured_type (arg2) : structured_type (arg2))
 580     /* One is structured and one isn't */
 581     return 0;
 582   else if (structured_type (arg1) && structured_type (arg2))
 583     return arg1 == arg2;
 584   else if (numeric_type (arg1) && numeric_type (arg2))
 585     return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) &&
 586       (TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2))
 587       ? 1 : 0;
 588   else
 589     return arg1 == arg2;
 590 }
 591
 592 /* Returns non-zero if the type is integral */
 593 int
 594 integral_type (struct type *type)
 595 {
 596   CHECK_TYPEDEF (type);
 597   switch (current_language->la_language)
 598     {
 599     case language_c:
 600     case language_cplus:
 601     case language_d:
 602     case language_objc:
 603       return (TYPE_CODE (type) != TYPE_CODE_INT) &&
 604         (TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1;
 605     case language_m2:
 606     case language_pascal:
 607       return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1;
 608     default:
 609       error (_("Language not supported."));
 610     }
 611 }
 612
 613 /* Returns non-zero if the value is numeric */
 614 int
 615 numeric_type (struct type *type)
 616 {
 617   CHECK_TYPEDEF (type);
 618   switch (TYPE_CODE (type))
 619     {
 620     case TYPE_CODE_INT:
 621     case TYPE_CODE_FLT:
 622       return 1;
 623
 624     default:
 625       return 0;
 626     }
 627 }
 628
 629 /* Returns non-zero if the value is a character type */
 630 int
 631 character_type (struct type *type)
 632 {
 633   CHECK_TYPEDEF (type);
 634   switch (current_language->la_language)
 635     {
 636     case language_m2:
 637     case language_pascal:
 638       return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1;
 639
 640     case language_c:
 641     case language_cplus:
 642     case language_d:
 643     case language_objc:
 644       return (TYPE_CODE (type) == TYPE_CODE_INT) &&
 645         TYPE_LENGTH (type) == sizeof (char)
 646       ? 1 : 0;
 647     default:
 648       return (0);
 649     }
 650 }
 651
 652 /* Returns non-zero if the value is a string type */
 653 int
 654 string_type (struct type *type)
 655 {
 656   CHECK_TYPEDEF (type);
 657   switch (current_language->la_language)
 658     {
 659     case language_m2:
 660     case language_pascal:
 661       return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1;
 662
 663     case language_c:
 664     case language_cplus:
 665     case language_d:
 666     case language_objc:
 667       /* C does not have distinct string type. */
 668       return (0);
 669     default:
 670       return (0);
 671     }
 672 }
 673
 674 /* Returns non-zero if the value is a boolean type */
 675 int
 676 boolean_type (struct type *type)
 677 {
 678   CHECK_TYPEDEF (type);
 679   if (TYPE_CODE (type) == TYPE_CODE_BOOL)
 680     return 1;
 681   switch (current_language->la_language)
 682     {
 683     case language_c:
 684     case language_cplus:
 685     case language_d:
 686     case language_objc:
 687       /* Might be more cleanly handled by having a
 688          TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such
 689          languages, or a TYPE_CODE_INT_OR_BOOL for C.  */
 690       if (TYPE_CODE (type) == TYPE_CODE_INT)
 691         return 1;
 692     default:
 693       break;
 694     }
 695   return 0;
 696 }
 697
 698 /* Returns non-zero if the value is a floating-point type */
 699 int
 700 float_type (struct type *type)
 701 {
 702   CHECK_TYPEDEF (type);
 703   return TYPE_CODE (type) == TYPE_CODE_FLT;
 704 }
 705 #endif
 706
 707 /* Returns non-zero if the value is a pointer type */
 708 int
 709 pointer_type (struct type *type)
 710 {
 711   return TYPE_CODE (type) == TYPE_CODE_PTR ||
 712     TYPE_CODE (type) == TYPE_CODE_REF;
 713 }
 714
 715 #if 0
 716 /* Returns non-zero if the value is a structured type */
 717 int
 718 structured_type (struct type *type)
 719 {
 720   CHECK_TYPEDEF (type);
 721   switch (current_language->la_language)
 722     {
 723     case language_c:
 724     case language_cplus:
 725     case language_d:
 726     case language_objc:
 727       return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
 728         (TYPE_CODE (type) == TYPE_CODE_UNION) ||
 729         (TYPE_CODE (type) == TYPE_CODE_ARRAY);
 730    case language_pascal:
 731       return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
 732          (TYPE_CODE(type) == TYPE_CODE_UNION) ||
 733          (TYPE_CODE(type) == TYPE_CODE_SET) ||
 734             (TYPE_CODE(type) == TYPE_CODE_ARRAY);
 735     case language_m2:
 736       return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
 737         (TYPE_CODE (type) == TYPE_CODE_SET) ||
 738         (TYPE_CODE (type) == TYPE_CODE_ARRAY);
 739     default:
 740       return (0);
 741     }
 742 }
 743 #endif
 744 \f
 745 /* This page contains functions that return info about
 746    (struct value) values used in GDB. */
 747
 748 /* Returns non-zero if the value VAL represents a true value. */
 749 int
 750 value_true (struct value *val)
 751 {
 752   /* It is possible that we should have some sort of error if a non-boolean
 753      value is used in this context.  Possibly dependent on some kind of
 754      "boolean-checking" option like range checking.  But it should probably
 755      not depend on the language except insofar as is necessary to identify
 756      a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
 757      should be an error, probably).  */
 758   return !value_logical_not (val);
 759 }
 760 \f
 761 /* This page contains functions for the printing out of
 762    error messages that occur during type- and range-
 763    checking. */
 764
 765 /* These are called when a language fails a type- or range-check.  The
 766    first argument should be a printf()-style format string, and the
 767    rest of the arguments should be its arguments.  If
 768    [type|range]_check is [type|range]_check_on, an error is printed;
 769    if [type|range]_check_warn, a warning; otherwise just the
 770    message. */
 771
 772 void
 773 type_error (const char *string,...)
 774 {
 775   va_list args;
 776   va_start (args, string);
 777
 778   switch (type_check)
 779     {
 780     case type_check_warn:
 781       vwarning (string, args);
 782       break;
 783     case type_check_on:
 784       verror (string, args);
 785       break;
 786     case type_check_off:
 787       /* FIXME: cagney/2002-01-30: Should this function print anything
 788          when type error is off?  */
 789       vfprintf_filtered (gdb_stderr, string, args);
 790       fprintf_filtered (gdb_stderr, "\n");
 791       break;
 792     default:
 793       internal_error (__FILE__, __LINE__, _("bad switch"));
 794     }
 795   va_end (args);
 796 }
 797
 798 void
 799 range_error (const char *string,...)
 800 {
 801   va_list args;
 802   va_start (args, string);
 803
 804   switch (range_check)
 805     {
 806     case range_check_warn:
 807       vwarning (string, args);
 808       break;
 809     case range_check_on:
 810       verror (string, args);
 811       break;
 812     case range_check_off:
 813       /* FIXME: cagney/2002-01-30: Should this function print anything
 814          when range error is off?  */
 815       vfprintf_filtered (gdb_stderr, string, args);
 816       fprintf_filtered (gdb_stderr, "\n");
 817       break;
 818     default:
 819       internal_error (__FILE__, __LINE__, _("bad switch"));
 820     }
 821   va_end (args);
 822 }
 823 \f
 824
 825 /* This page contains miscellaneous functions */
 826
 827 /* Return the language enum for a given language string. */
 828
 829 enum language
 830 language_enum (char *str)
 831 {
 832   int i;
 833
 834   for (i = 0; i < languages_size; i++)
 835     if (strcmp (languages[i]->la_name, str) == 0)
 836       return languages[i]->la_language;
 837
 838   return language_unknown;
 839 }
 840
 841 /* Return the language struct for a given language enum. */
 842
 843 const struct language_defn *
 844 language_def (enum language lang)
 845 {
 846   int i;
 847
 848   for (i = 0; i < languages_size; i++)
 849     {
 850       if (languages[i]->la_language == lang)
 851         {
 852           return languages[i];
 853         }
 854     }
 855   return NULL;
 856 }
 857
 858 /* Return the language as a string */
 859 char *
 860 language_str (enum language lang)
 861 {
 862   int i;
 863
 864   for (i = 0; i < languages_size; i++)
 865     {
 866       if (languages[i]->la_language == lang)
 867         {
 868           return languages[i]->la_name;
 869         }
 870     }
 871   return "Unknown";
 872 }
 873
 874 static void
 875 set_check (char *ignore, int from_tty)
 876 {
 877   printf_unfiltered (
 878      "\"set check\" must be followed by the name of a check subcommand.\n");
 879   help_list (setchecklist, "set check ", -1, gdb_stdout);
 880 }
 881
 882 static void
 883 show_check (char *ignore, int from_tty)
 884 {
 885   cmd_show_list (showchecklist, from_tty, "");
 886 }
 887 \f
 888 /* Add a language to the set of known languages.  */
 889
 890 void
 891 add_language (const struct language_defn *lang)
 892 {
 893   /* For the "set language" command.  */
 894   static char **language_names = NULL;
 895   /* For the "help set language" command.  */
 896   char *language_set_doc = NULL;
 897
 898   int i;
 899   struct ui_file *tmp_stream;
 900
 901   if (lang->la_magic != LANG_MAGIC)
 902     {
 903       fprintf_unfiltered (gdb_stderr, "Magic number of %s language struct wrong\n",
 904                           lang->la_name);
 905       internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 906     }
 907
 908   if (!languages)
 909     {
 910       languages_allocsize = DEFAULT_ALLOCSIZE;
 911       languages = (const struct language_defn **) xmalloc
 912         (languages_allocsize * sizeof (*languages));
 913     }
 914   if (languages_size >= languages_allocsize)
 915     {
 916       languages_allocsize *= 2;
 917       languages = (const struct language_defn **) xrealloc ((char *) languages,
 918                                  languages_allocsize * sizeof (*languages));
 919     }
 920   languages[languages_size++] = lang;
 921
 922   /* Build the language names array, to be used as enumeration in the
 923      set language" enum command.  */
 924   language_names = xrealloc (language_names,
 925                              (languages_size + 1) * sizeof (const char *));
 926   for (i = 0; i < languages_size; ++i)
 927     language_names[i] = languages[i]->la_name;
 928   language_names[i] = NULL;
 929
 930   /* Build the "help set language" docs.  */
 931   tmp_stream = mem_fileopen ();
 932
 933   fprintf_unfiltered (tmp_stream, _("\
 934 Set the current source language.\n\
 935 The currently understood settings are:\n\n\
 936 local or auto    Automatic setting based on source file\n"));
 937
 938   for (i = 0; i < languages_size; ++i)
 939     {
 940       /* Already dealt with these above.  */
 941       if (languages[i]->la_language == language_unknown
 942           || languages[i]->la_language == language_auto)
 943         continue;
 944
 945       /* FIXME: i18n: for now assume that the human-readable name
 946          is just a capitalization of the internal name.  */
 947       fprintf_unfiltered (tmp_stream, "%-16s Use the %c%s language\n",
 948                           languages[i]->la_name,
 949                           /* Capitalize first letter of language
 950                              name.  */
 951                           toupper (languages[i]->la_name[0]),
 952                           languages[i]->la_name + 1);
 953     }
 954
 955   language_set_doc = ui_file_xstrdup (tmp_stream, NULL);
 956   ui_file_delete (tmp_stream);
 957
 958   add_setshow_enum_cmd ("language", class_support,
 959                         (const char **) language_names,
 960                         &language,
 961                         language_set_doc, _("\
 962 Show the current source language."), NULL,
 963                         set_language_command,
 964                         show_language_command,
 965                         &setlist, &showlist);
 966
 967   xfree (language_set_doc);
 968 }
 969
 970 /* Iterate through all registered languages looking for and calling
 971    any non-NULL struct language_defn.skip_trampoline() functions.
 972    Return the result from the first that returns non-zero, or 0 if all
 973    `fail'.  */
 974 CORE_ADDR
 975 skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
 976 {
 977   int i;
 978
 979   for (i = 0; i < languages_size; i++)
 980     {
 981       if (languages[i]->skip_trampoline)
 982         {
 983           CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc);
 984           if (real_pc)
 985             return real_pc;
 986         }
 987     }
 988
 989   return 0;
 990 }
 991
 992 /* Return demangled language symbol, or NULL.
 993    FIXME: Options are only useful for certain languages and ignored
 994    by others, so it would be better to remove them here and have a
 995    more flexible demangler for the languages that need it.
 996    FIXME: Sometimes the demangler is invoked when we don't know the
 997    language, so we can't use this everywhere.  */
 998 char *
 999 language_demangle (const struct language_defn *current_language,
1000                                 const char *mangled, int options)
1001 {
1002   if (current_language != NULL && current_language->la_demangle)
1003     return current_language->la_demangle (mangled, options);
1004   return NULL;
1005 }
1006
1007 /* Return class name from physname or NULL.  */
1008 char *
1009 language_class_name_from_physname (const struct language_defn *current_language,
1010                                    const char *physname)
1011 {
1012   if (current_language != NULL && current_language->la_class_name_from_physname)
1013     return current_language->la_class_name_from_physname (physname);
1014   return NULL;
1015 }
1016
1017 /* Return non-zero if TYPE should be passed (and returned) by
1018    reference at the language level.  */
1019 int
1020 language_pass_by_reference (struct type *type)
1021 {
1022   return current_language->la_pass_by_reference (type);
1023 }
1024
1025 /* Return zero; by default, types are passed by value at the language
1026    level.  The target ABI may pass or return some structs by reference
1027    independent of this.  */
1028 int
1029 default_pass_by_reference (struct type *type)
1030 {
1031   return 0;
1032 }
1033
1034 /* Return the default string containing the list of characters
1035    delimiting words.  This is a reasonable default value that
1036    most languages should be able to use.  */
1037
1038 char *
1039 default_word_break_characters (void)
1040 {
1041   return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1042 }
1043
1044 /* Print the index of array elements using the C99 syntax.  */
1045
1046 void
1047 default_print_array_index (struct value *index_value, struct ui_file *stream,
1048                            const struct value_print_options *options)
1049 {
1050   fprintf_filtered (stream, "[");
1051   LA_VALUE_PRINT (index_value, stream, options);
1052   fprintf_filtered (stream, "] = ");
1053 }
1054
1055 void
1056 default_get_string (struct value *value, gdb_byte **buffer, int *length,
1057                     struct type **char_type, const char **charset)
1058 {
1059   error (_("Getting a string is unsupported in this language."));
1060 }
1061
1062 /* Define the language that is no language.  */
1063
1064 static int
1065 unk_lang_parser (void)
1066 {
1067   return 1;
1068 }
1069
1070 static void
1071 unk_lang_error (char *msg)
1072 {
1073   error (_("Attempted to parse an expression with unknown language"));
1074 }
1075
1076 static void
1077 unk_lang_emit_char (int c, struct type *type, struct ui_file *stream,
1078                     int quoter)
1079 {
1080   error (_("internal error - unimplemented function unk_lang_emit_char called."));
1081 }
1082
1083 static void
1084 unk_lang_printchar (int c, struct type *type, struct ui_file *stream)
1085 {
1086   error (_("internal error - unimplemented function unk_lang_printchar called."));
1087 }
1088
1089 static void
1090 unk_lang_printstr (struct ui_file *stream, struct type *type,
1091                    const gdb_byte *string, unsigned int length,
1092                    const char *encoding, int force_ellipses,
1093                    const struct value_print_options *options)
1094 {
1095   error (_("internal error - unimplemented function unk_lang_printstr called."));
1096 }
1097
1098 static void
1099 unk_lang_print_type (struct type *type, char *varstring, struct ui_file *stream,
1100                      int show, int level)
1101 {
1102   error (_("internal error - unimplemented function unk_lang_print_type called."));
1103 }
1104
1105 static int
1106 unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
1107                     int embedded_offset, CORE_ADDR address,
1108                     struct ui_file *stream, int recurse,
1109                     const struct value_print_options *options)
1110 {
1111   error (_("internal error - unimplemented function unk_lang_val_print called."));
1112 }
1113
1114 static int
1115 unk_lang_value_print (struct value *val, struct ui_file *stream,
1116                       const struct value_print_options *options)
1117 {
1118   error (_("internal error - unimplemented function unk_lang_value_print called."));
1119 }
1120
1121 static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc)
1122 {
1123   return 0;
1124 }
1125
1126 /* Unknown languages just use the cplus demangler.  */
1127 static char *unk_lang_demangle (const char *mangled, int options)
1128 {
1129   return cplus_demangle (mangled, options);
1130 }
1131
1132 static char *unk_lang_class_name (const char *mangled)
1133 {
1134   return NULL;
1135 }
1136
1137 static const struct op_print unk_op_print_tab[] =
1138 {
1139   {NULL, OP_NULL, PREC_NULL, 0}
1140 };
1141
1142 static void
1143 unknown_language_arch_info (struct gdbarch *gdbarch,
1144                             struct language_arch_info *lai)
1145 {
1146   lai->string_char_type = builtin_type (gdbarch)->builtin_char;
1147   lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
1148   lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
1149                                                        struct type *);
1150 }
1151
1152 const struct language_defn unknown_language_defn =
1153 {
1154   "unknown",
1155   language_unknown,
1156   range_check_off,
1157   type_check_off,
1158   case_sensitive_on,
1159   array_row_major,
1160   macro_expansion_no,
1161   &exp_descriptor_standard,
1162   unk_lang_parser,
1163   unk_lang_error,
1164   null_post_parser,
1165   unk_lang_printchar,           /* Print character constant */
1166   unk_lang_printstr,
1167   unk_lang_emit_char,
1168   unk_lang_print_type,          /* Print a type using appropriate syntax */
1169   default_print_typedef,        /* Print a typedef using appropriate syntax */
1170   unk_lang_val_print,           /* Print a value using appropriate syntax */
1171   unk_lang_value_print,         /* Print a top-level value */
1172   unk_lang_trampoline,          /* Language specific skip_trampoline */
1173   "this",                       /* name_of_this */
1174   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1175   basic_lookup_transparent_type,/* lookup_transparent_type */
1176   unk_lang_demangle,            /* Language specific symbol demangler */
1177   unk_lang_class_name,          /* Language specific class_name_from_physname */
1178   unk_op_print_tab,             /* expression operators for printing */
1179   1,                            /* c-style arrays */
1180   0,                            /* String lower bound */
1181   default_word_break_characters,
1182   default_make_symbol_completion_list,
1183   unknown_language_arch_info,   /* la_language_arch_info.  */
1184   default_print_array_index,
1185   default_pass_by_reference,
1186   default_get_string,
1187   LANG_MAGIC
1188 };
1189
1190 /* These two structs define fake entries for the "local" and "auto" options. */
1191 const struct language_defn auto_language_defn =
1192 {
1193   "auto",
1194   language_auto,
1195   range_check_off,
1196   type_check_off,
1197   case_sensitive_on,
1198   array_row_major,
1199   macro_expansion_no,
1200   &exp_descriptor_standard,
1201   unk_lang_parser,
1202   unk_lang_error,
1203   null_post_parser,
1204   unk_lang_printchar,           /* Print character constant */
1205   unk_lang_printstr,
1206   unk_lang_emit_char,
1207   unk_lang_print_type,          /* Print a type using appropriate syntax */
1208   default_print_typedef,        /* Print a typedef using appropriate syntax */
1209   unk_lang_val_print,           /* Print a value using appropriate syntax */
1210   unk_lang_value_print,         /* Print a top-level value */
1211   unk_lang_trampoline,          /* Language specific skip_trampoline */
1212   "this",                       /* name_of_this */
1213   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1214   basic_lookup_transparent_type,/* lookup_transparent_type */
1215   unk_lang_demangle,            /* Language specific symbol demangler */
1216   unk_lang_class_name,          /* Language specific class_name_from_physname */
1217   unk_op_print_tab,             /* expression operators for printing */
1218   1,                            /* c-style arrays */
1219   0,                            /* String lower bound */
1220   default_word_break_characters,
1221   default_make_symbol_completion_list,
1222   unknown_language_arch_info,   /* la_language_arch_info.  */
1223   default_print_array_index,
1224   default_pass_by_reference,
1225   default_get_string,
1226   LANG_MAGIC
1227 };
1228
1229 const struct language_defn local_language_defn =
1230 {
1231   "local",
1232   language_auto,
1233   range_check_off,
1234   type_check_off,
1235   case_sensitive_on,
1236   array_row_major,
1237   macro_expansion_no,
1238   &exp_descriptor_standard,
1239   unk_lang_parser,
1240   unk_lang_error,
1241   null_post_parser,
1242   unk_lang_printchar,           /* Print character constant */
1243   unk_lang_printstr,
1244   unk_lang_emit_char,
1245   unk_lang_print_type,          /* Print a type using appropriate syntax */
1246   default_print_typedef,        /* Print a typedef using appropriate syntax */
1247   unk_lang_val_print,           /* Print a value using appropriate syntax */
1248   unk_lang_value_print,         /* Print a top-level value */
1249   unk_lang_trampoline,          /* Language specific skip_trampoline */
1250   "this",                       /* name_of_this */
1251   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1252   basic_lookup_transparent_type,/* lookup_transparent_type */
1253   unk_lang_demangle,            /* Language specific symbol demangler */
1254   unk_lang_class_name,          /* Language specific class_name_from_physname */
1255   unk_op_print_tab,             /* expression operators for printing */
1256   1,                            /* c-style arrays */
1257   0,                            /* String lower bound */
1258   default_word_break_characters,
1259   default_make_symbol_completion_list,
1260   unknown_language_arch_info,   /* la_language_arch_info.  */
1261   default_print_array_index,
1262   default_pass_by_reference,
1263   default_get_string,
1264   LANG_MAGIC
1265 };
1266 \f
1267 /* Per-architecture language information.  */
1268
1269 static struct gdbarch_data *language_gdbarch_data;
1270
1271 struct language_gdbarch
1272 {
1273   /* A vector of per-language per-architecture info.  Indexed by "enum
1274      language".  */
1275   struct language_arch_info arch_info[nr_languages];
1276 };
1277
1278 static void *
1279 language_gdbarch_post_init (struct gdbarch *gdbarch)
1280 {
1281   struct language_gdbarch *l;
1282   int i;
1283
1284   l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
1285   for (i = 0; i < languages_size; i++)
1286     {
1287       if (languages[i] != NULL
1288           && languages[i]->la_language_arch_info != NULL)
1289         languages[i]->la_language_arch_info
1290           (gdbarch, l->arch_info + languages[i]->la_language);
1291     }
1292   return l;
1293 }
1294
1295 struct type *
1296 language_string_char_type (const struct language_defn *la,
1297                            struct gdbarch *gdbarch)
1298 {
1299   struct language_gdbarch *ld = gdbarch_data (gdbarch,
1300                                               language_gdbarch_data);
1301   return ld->arch_info[la->la_language].string_char_type;
1302 }
1303
1304 struct type *
1305 language_bool_type (const struct language_defn *la,
1306                     struct gdbarch *gdbarch)
1307 {
1308   struct language_gdbarch *ld = gdbarch_data (gdbarch,
1309                                               language_gdbarch_data);
1310
1311   if (ld->arch_info[la->la_language].bool_type_symbol)
1312     {
1313       struct symbol *sym;
1314       sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
1315                            NULL, VAR_DOMAIN, NULL);
1316       if (sym)
1317         {
1318           struct type *type = SYMBOL_TYPE (sym);
1319           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
1320             return type;
1321         }
1322     }
1323
1324   return ld->arch_info[la->la_language].bool_type_default;
1325 }
1326
1327 struct type *
1328 language_lookup_primitive_type_by_name (const struct language_defn *la,
1329                                         struct gdbarch *gdbarch,
1330                                         const char *name)
1331 {
1332   struct language_gdbarch *ld = gdbarch_data (gdbarch,
1333                                               language_gdbarch_data);
1334   struct type *const *p;
1335   for (p = ld->arch_info[la->la_language].primitive_type_vector;
1336        (*p) != NULL;
1337        p++)
1338     {
1339       if (strcmp (TYPE_NAME (*p), name) == 0)
1340         return (*p);
1341     }
1342   return (NULL);
1343 }
1344
1345 /* Initialize the language routines */
1346
1347 void
1348 _initialize_language (void)
1349 {
1350   static const char *type_or_range_names[]
1351     = { "on", "off", "warn", "auto", NULL };
1352
1353   static const char *case_sensitive_names[]
1354     = { "on", "off", "auto", NULL };
1355
1356   language_gdbarch_data
1357     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1358
1359   /* GDB commands for language specific stuff */
1360
1361   add_prefix_cmd ("check", no_class, set_check,
1362                   _("Set the status of the type/range checker."),
1363                   &setchecklist, "set check ", 0, &setlist);
1364   add_alias_cmd ("c", "check", no_class, 1, &setlist);
1365   add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1366
1367   add_prefix_cmd ("check", no_class, show_check,
1368                   _("Show the status of the type/range checker."),
1369                   &showchecklist, "show check ", 0, &showlist);
1370   add_alias_cmd ("c", "check", no_class, 1, &showlist);
1371   add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1372
1373   add_setshow_enum_cmd ("type", class_support, type_or_range_names, &type, _("\
1374 Set type checking.  (on/warn/off/auto)"), _("\
1375 Show type checking.  (on/warn/off/auto)"), NULL,
1376                         set_type_command,
1377                         show_type_command,
1378                         &setchecklist, &showchecklist);
1379
1380   add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1381                         &range, _("\
1382 Set range checking.  (on/warn/off/auto)"), _("\
1383 Show range checking.  (on/warn/off/auto)"), NULL,
1384                         set_range_command,
1385                         show_range_command,
1386                         &setchecklist, &showchecklist);
1387
1388   add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1389                         &case_sensitive, _("\
1390 Set case sensitivity in name search.  (on/off/auto)"), _("\
1391 Show case sensitivity in name search.  (on/off/auto)"), _("\
1392 For Fortran the default is off; for other languages the default is on."),
1393                         set_case_command,
1394                         show_case_command,
1395                         &setlist, &showlist);
1396
1397   add_language (&auto_language_defn);
1398   add_language (&local_language_defn);
1399   add_language (&unknown_language_defn);
1400
1401   language = xstrdup ("auto");
1402   type = xstrdup ("auto");
1403   range = xstrdup ("auto");
1404   case_sensitive = xstrdup ("auto");
1405
1406   /* Have the above take effect */
1407   set_language (language_auto);
1408 }