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 Free Software 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 set_case_str (void);
  51
  52 static void set_range_str (void);
  53
  54 static void set_type_str (void);
  55
  56 static void set_lang_str (void);
  57
  58 static void unk_lang_error (char *);
  59
  60 static int unk_lang_parser (void);
  61
  62 static void show_check (char *, int);
  63
  64 static void set_check (char *, int);
  65
  66 static void set_type_range_case (void);
  67
  68 static void unk_lang_emit_char (int c, struct ui_file *stream, int quoter);
  69
  70 static void unk_lang_printchar (int c, struct ui_file *stream);
  71
  72 static void unk_lang_print_type (struct type *, char *, struct ui_file *,
  73                                  int, int);
  74
  75 static int unk_lang_value_print (struct value *, struct ui_file *, int, enum val_prettyprint);
  76
  77 static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc);
  78
  79 /* Forward declaration */
  80 extern const struct language_defn unknown_language_defn;
  81
  82 /* The current (default at startup) state of type and range checking.
  83    (If the modes are set to "auto", though, these are changed based
  84    on the default language at startup, and then again based on the
  85    language of the first source file.  */
  86
  87 enum range_mode range_mode = range_mode_auto;
  88 enum range_check range_check = range_check_off;
  89 enum type_mode type_mode = type_mode_auto;
  90 enum type_check type_check = type_check_off;
  91 enum case_mode case_mode = case_mode_auto;
  92 enum case_sensitivity case_sensitivity = case_sensitive_on;
  93
  94 /* The current language and language_mode (see language.h) */
  95
  96 const struct language_defn *current_language = &unknown_language_defn;
  97 enum language_mode language_mode = language_mode_auto;
  98
  99 /* The language that the user expects to be typing in (the language
 100    of main(), or the last language we notified them about, or C).  */
 101
 102 const struct language_defn *expected_language;
 103
 104 /* The list of supported languages.  The list itself is malloc'd.  */
 105
 106 static const struct language_defn **languages;
 107 static unsigned languages_size;
 108 static unsigned languages_allocsize;
 109 #define DEFAULT_ALLOCSIZE 4
 110
 111 /* The "set language/type/range" commands all put stuff in these
 112    buffers.  This is to make them work as set/show commands.  The
 113    user's string is copied here, then the set_* commands look at
 114    them and update them to something that looks nice when it is
 115    printed out. */
 116
 117 static char *language;
 118 static char *type;
 119 static char *range;
 120 static char *case_sensitive;
 121
 122 /* Warning issued when current_language and the language of the current
 123    frame do not match. */
 124 char lang_frame_mismatch_warn[] =
 125 "Warning: the current language does not match this frame.";
 126 \f
 127 /* This page contains the functions corresponding to GDB commands
 128    and their helpers. */
 129
 130 /* Show command.  Display a warning if the language set
 131    does not match the frame. */
 132 static void
 133 show_language_command (struct ui_file *file, int from_tty,
 134                        struct cmd_list_element *c, const char *value)
 135 {
 136   enum language flang;          /* The language of the current frame */
 137
 138   deprecated_show_value_hack (file, from_tty, c, value);
 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   char *err_lang;
 153
 154   if (!language || !language[0])
 155     {
 156       printf_unfiltered (_("\
 157 The currently understood settings are:\n\n\
 158 local or auto    Automatic setting based on source file\n"));
 159
 160       for (i = 0; i < languages_size; ++i)
 161         {
 162           /* Already dealt with these above.  */
 163           if (languages[i]->la_language == language_unknown
 164               || languages[i]->la_language == language_auto)
 165             continue;
 166
 167           /* FIXME: i18n: for now assume that the human-readable name
 168              is just a capitalization of the internal name.  */
 169           printf_unfiltered ("%-16s Use the %c%s language\n",
 170                              languages[i]->la_name,
 171           /* Capitalize first letter of language
 172              name.  */
 173                              toupper (languages[i]->la_name[0]),
 174                              languages[i]->la_name + 1);
 175         }
 176       /* Restore the silly string. */
 177       set_language (current_language->la_language);
 178       return;
 179     }
 180
 181   /* Search the list of languages for a match.  */
 182   for (i = 0; i < languages_size; i++)
 183     {
 184       if (strcmp (languages[i]->la_name, language) == 0)
 185         {
 186           /* Found it!  Go into manual mode, and use this language.  */
 187           if (languages[i]->la_language == language_auto)
 188             {
 189               /* Enter auto mode.  Set to the current frame's language, if
 190                  known, or fallback to the initial language.  */
 191               language_mode = language_mode_auto;
 192               flang = get_frame_language ();
 193               if (flang != language_unknown)
 194                 set_language (flang);
 195               else
 196                 set_initial_language ();
 197               expected_language = current_language;
 198               return;
 199             }
 200           else
 201             {
 202               /* Enter manual mode.  Set the specified language.  */
 203               language_mode = language_mode_manual;
 204               current_language = languages[i];
 205               set_type_range_case ();
 206               set_lang_str ();
 207               expected_language = current_language;
 208               return;
 209             }
 210         }
 211     }
 212
 213   /* Reset the language (esp. the global string "language") to the
 214      correct values. */
 215   err_lang = savestring (language, strlen (language));
 216   make_cleanup (xfree, err_lang);       /* Free it after error */
 217   set_language (current_language->la_language);
 218   error (_("Unknown language `%s'."), err_lang);
 219 }
 220
 221 /* Show command.  Display a warning if the type setting does
 222    not match the current language. */
 223 static void
 224 show_type_command (struct ui_file *file, int from_tty,
 225                    struct cmd_list_element *c, const char *value)
 226 {
 227   deprecated_show_value_hack (file, from_tty, c, value);
 228   if (type_check != current_language->la_type_check)
 229     printf_unfiltered (
 230                         "Warning: the current type check setting does not match the language.\n");
 231 }
 232
 233 /* Set command.  Change the setting for type checking. */
 234 static void
 235 set_type_command (char *ignore, int from_tty, struct cmd_list_element *c)
 236 {
 237   if (strcmp (type, "on") == 0)
 238     {
 239       type_check = type_check_on;
 240       type_mode = type_mode_manual;
 241     }
 242   else if (strcmp (type, "warn") == 0)
 243     {
 244       type_check = type_check_warn;
 245       type_mode = type_mode_manual;
 246     }
 247   else if (strcmp (type, "off") == 0)
 248     {
 249       type_check = type_check_off;
 250       type_mode = type_mode_manual;
 251     }
 252   else if (strcmp (type, "auto") == 0)
 253     {
 254       type_mode = type_mode_auto;
 255       set_type_range_case ();
 256       /* Avoid hitting the set_type_str call below.  We
 257          did it in set_type_range_case. */
 258       return;
 259     }
 260   else
 261     {
 262       warning (_("Unrecognized type check setting: \"%s\""), type);
 263     }
 264   set_type_str ();
 265   show_type_command (NULL, from_tty, NULL, NULL);
 266 }
 267
 268 /* Show command.  Display a warning if the range setting does
 269    not match the current language. */
 270 static void
 271 show_range_command (struct ui_file *file, int from_tty,
 272                     struct cmd_list_element *c, const char *value)
 273 {
 274   deprecated_show_value_hack (file, from_tty, c, value);
 275   if (range_check != current_language->la_range_check)
 276     printf_unfiltered (
 277                         "Warning: the current range check setting does not match the language.\n");
 278 }
 279
 280 /* Set command.  Change the setting for range checking. */
 281 static void
 282 set_range_command (char *ignore, int from_tty, struct cmd_list_element *c)
 283 {
 284   if (strcmp (range, "on") == 0)
 285     {
 286       range_check = range_check_on;
 287       range_mode = range_mode_manual;
 288     }
 289   else if (strcmp (range, "warn") == 0)
 290     {
 291       range_check = range_check_warn;
 292       range_mode = range_mode_manual;
 293     }
 294   else if (strcmp (range, "off") == 0)
 295     {
 296       range_check = range_check_off;
 297       range_mode = range_mode_manual;
 298     }
 299   else if (strcmp (range, "auto") == 0)
 300     {
 301       range_mode = range_mode_auto;
 302       set_type_range_case ();
 303       /* Avoid hitting the set_range_str call below.  We
 304          did it in set_type_range_case. */
 305       return;
 306     }
 307   else
 308     {
 309       warning (_("Unrecognized range check setting: \"%s\""), range);
 310     }
 311   set_range_str ();
 312   show_range_command (NULL, from_tty, NULL, NULL);
 313 }
 314
 315 /* Show command.  Display a warning if the case sensitivity setting does
 316    not match the current language. */
 317 static void
 318 show_case_command (struct ui_file *file, int from_tty,
 319                    struct cmd_list_element *c, const char *value)
 320 {
 321   deprecated_show_value_hack (file, from_tty, c, value);
 322   if (case_sensitivity != current_language->la_case_sensitivity)
 323     printf_unfiltered(
 324 "Warning: the current case sensitivity setting does not match the language.\n");
 325 }
 326
 327 /* Set command.  Change the setting for case sensitivity.  */
 328
 329 static void
 330 set_case_command (char *ignore, int from_tty, struct cmd_list_element *c)
 331 {
 332    if (strcmp (case_sensitive, "on") == 0)
 333      {
 334        case_sensitivity = case_sensitive_on;
 335        case_mode = case_mode_manual;
 336      }
 337    else if (strcmp (case_sensitive, "off") == 0)
 338      {
 339        case_sensitivity = case_sensitive_off;
 340        case_mode = case_mode_manual;
 341      }
 342    else if (strcmp (case_sensitive, "auto") == 0)
 343      {
 344        case_mode = case_mode_auto;
 345        set_type_range_case ();
 346        /* Avoid hitting the set_case_str call below.  We did it in
 347           set_type_range_case.  */
 348        return;
 349      }
 350    else
 351      {
 352        warning (_("Unrecognized case-sensitive setting: \"%s\""),
 353                 case_sensitive);
 354      }
 355    set_case_str();
 356    show_case_command (NULL, from_tty, NULL, NULL);
 357 }
 358
 359 /* Set the status of range and type checking and case sensitivity based on
 360    the current modes and the current language.
 361    If SHOW is non-zero, then print out the current language,
 362    type and range checking status. */
 363 static void
 364 set_type_range_case (void)
 365 {
 366
 367   if (range_mode == range_mode_auto)
 368     range_check = current_language->la_range_check;
 369
 370   if (type_mode == type_mode_auto)
 371     type_check = current_language->la_type_check;
 372
 373   if (case_mode == case_mode_auto)
 374     case_sensitivity = current_language->la_case_sensitivity;
 375
 376   set_type_str ();
 377   set_range_str ();
 378   set_case_str ();
 379 }
 380
 381 /* Set current language to (enum language) LANG.  Returns previous language. */
 382
 383 enum language
 384 set_language (enum language lang)
 385 {
 386   int i;
 387   enum language prev_language;
 388
 389   prev_language = current_language->la_language;
 390
 391   for (i = 0; i < languages_size; i++)
 392     {
 393       if (languages[i]->la_language == lang)
 394         {
 395           current_language = languages[i];
 396           set_type_range_case ();
 397           set_lang_str ();
 398           break;
 399         }
 400     }
 401
 402   return prev_language;
 403 }
 404 \f
 405 /* This page contains functions that update the global vars
 406    language, type and range. */
 407 static void
 408 set_lang_str (void)
 409 {
 410   char *prefix = "";
 411
 412   if (language)
 413     xfree (language);
 414   if (language_mode == language_mode_auto)
 415     prefix = "auto; currently ";
 416
 417   language = concat (prefix, current_language->la_name, (char *)NULL);
 418 }
 419
 420 static void
 421 set_type_str (void)
 422 {
 423   char *tmp = NULL, *prefix = "";
 424
 425   if (type)
 426     xfree (type);
 427   if (type_mode == type_mode_auto)
 428     prefix = "auto; currently ";
 429
 430   switch (type_check)
 431     {
 432     case type_check_on:
 433       tmp = "on";
 434       break;
 435     case type_check_off:
 436       tmp = "off";
 437       break;
 438     case type_check_warn:
 439       tmp = "warn";
 440       break;
 441     default:
 442       error (_("Unrecognized type check setting."));
 443     }
 444
 445   type = concat (prefix, tmp, (char *)NULL);
 446 }
 447
 448 static void
 449 set_range_str (void)
 450 {
 451   char *tmp, *pref = "";
 452
 453   if (range_mode == range_mode_auto)
 454     pref = "auto; currently ";
 455
 456   switch (range_check)
 457     {
 458     case range_check_on:
 459       tmp = "on";
 460       break;
 461     case range_check_off:
 462       tmp = "off";
 463       break;
 464     case range_check_warn:
 465       tmp = "warn";
 466       break;
 467     default:
 468       error (_("Unrecognized range check setting."));
 469     }
 470
 471   if (range)
 472     xfree (range);
 473   range = concat (pref, tmp, (char *)NULL);
 474 }
 475
 476 static void
 477 set_case_str (void)
 478 {
 479    char *tmp = NULL, *prefix = "";
 480
 481    if (case_mode==case_mode_auto)
 482       prefix = "auto; currently ";
 483
 484    switch (case_sensitivity)
 485    {
 486    case case_sensitive_on:
 487      tmp = "on";
 488      break;
 489    case case_sensitive_off:
 490      tmp = "off";
 491      break;
 492    default:
 493      error (_("Unrecognized case-sensitive setting."));
 494    }
 495
 496    xfree (case_sensitive);
 497    case_sensitive = concat (prefix, tmp, (char *)NULL);
 498 }
 499
 500 /* Print out the current language settings: language, range and
 501    type checking.  If QUIETLY, print only what has changed.  */
 502
 503 void
 504 language_info (int quietly)
 505 {
 506   if (quietly && expected_language == current_language)
 507     return;
 508
 509   expected_language = current_language;
 510   printf_unfiltered (_("Current language:  %s\n"), language);
 511   show_language_command (NULL, 1, NULL, NULL);
 512
 513   if (!quietly)
 514     {
 515       printf_unfiltered (_("Type checking:     %s\n"), type);
 516       show_type_command (NULL, 1, NULL, NULL);
 517       printf_unfiltered (_("Range checking:    %s\n"), range);
 518       show_range_command (NULL, 1, NULL, NULL);
 519       printf_unfiltered (_("Case sensitivity:  %s\n"), case_sensitive);
 520       show_case_command (NULL, 1, NULL, NULL);
 521     }
 522 }
 523 \f
 524 /* Return the result of a binary operation. */
 525
 526 #if 0                           /* Currently unused */
 527
 528 struct type *
 529 binop_result_type (struct value *v1, struct value *v2)
 530 {
 531   int size, uns;
 532   struct type *t1 = check_typedef (VALUE_TYPE (v1));
 533   struct type *t2 = check_typedef (VALUE_TYPE (v2));
 534
 535   int l1 = TYPE_LENGTH (t1);
 536   int l2 = TYPE_LENGTH (t2);
 537
 538   switch (current_language->la_language)
 539     {
 540     case language_c:
 541     case language_cplus:
 542     case language_objc:
 543       if (TYPE_CODE (t1) == TYPE_CODE_FLT)
 544         return TYPE_CODE (t2) == TYPE_CODE_FLT && l2 > l1 ?
 545           VALUE_TYPE (v2) : VALUE_TYPE (v1);
 546       else if (TYPE_CODE (t2) == TYPE_CODE_FLT)
 547         return TYPE_CODE (t1) == TYPE_CODE_FLT && l1 > l2 ?
 548           VALUE_TYPE (v1) : VALUE_TYPE (v2);
 549       else if (TYPE_UNSIGNED (t1) && l1 > l2)
 550         return VALUE_TYPE (v1);
 551       else if (TYPE_UNSIGNED (t2) && l2 > l1)
 552         return VALUE_TYPE (v2);
 553       else                      /* Both are signed.  Result is the longer type */
 554         return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
 555       break;
 556     case language_m2:
 557       /* If we are doing type-checking, l1 should equal l2, so this is
 558          not needed. */
 559       return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
 560       break;
 561     }
 562   internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 563   return (struct type *) 0;     /* For lint */
 564 }
 565
 566 #endif /* 0 */
 567 #if 0
 568 /* This page contains functions that are used in type/range checking.
 569    They all return zero if the type/range check fails.
 570
 571    It is hoped that these will make extending GDB to parse different
 572    languages a little easier.  These are primarily used in eval.c when
 573    evaluating expressions and making sure that their types are correct.
 574    Instead of having a mess of conjucted/disjuncted expressions in an "if",
 575    the ideas of type can be wrapped up in the following functions.
 576
 577    Note that some of them are not currently dependent upon which language
 578    is currently being parsed.  For example, floats are the same in
 579    C and Modula-2 (ie. the only floating point type has TYPE_CODE of
 580    TYPE_CODE_FLT), while booleans are different. */
 581
 582 /* Returns non-zero if its argument is a simple type.  This is the same for
 583    both Modula-2 and for C.  In the C case, TYPE_CODE_CHAR will never occur,
 584    and thus will never cause the failure of the test. */
 585 int
 586 simple_type (struct type *type)
 587 {
 588   CHECK_TYPEDEF (type);
 589   switch (TYPE_CODE (type))
 590     {
 591     case TYPE_CODE_INT:
 592     case TYPE_CODE_CHAR:
 593     case TYPE_CODE_ENUM:
 594     case TYPE_CODE_FLT:
 595     case TYPE_CODE_RANGE:
 596     case TYPE_CODE_BOOL:
 597       return 1;
 598
 599     default:
 600       return 0;
 601     }
 602 }
 603
 604 /* Returns non-zero if its argument is of an ordered type.
 605    An ordered type is one in which the elements can be tested for the
 606    properties of "greater than", "less than", etc, or for which the
 607    operations "increment" or "decrement" make sense. */
 608 int
 609 ordered_type (struct type *type)
 610 {
 611   CHECK_TYPEDEF (type);
 612   switch (TYPE_CODE (type))
 613     {
 614     case TYPE_CODE_INT:
 615     case TYPE_CODE_CHAR:
 616     case TYPE_CODE_ENUM:
 617     case TYPE_CODE_FLT:
 618     case TYPE_CODE_RANGE:
 619       return 1;
 620
 621     default:
 622       return 0;
 623     }
 624 }
 625
 626 /* Returns non-zero if the two types are the same */
 627 int
 628 same_type (struct type *arg1, struct type *arg2)
 629 {
 630   CHECK_TYPEDEF (type);
 631   if (structured_type (arg1) ? !structured_type (arg2) : structured_type (arg2))
 632     /* One is structured and one isn't */
 633     return 0;
 634   else if (structured_type (arg1) && structured_type (arg2))
 635     return arg1 == arg2;
 636   else if (numeric_type (arg1) && numeric_type (arg2))
 637     return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) &&
 638       (TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2))
 639       ? 1 : 0;
 640   else
 641     return arg1 == arg2;
 642 }
 643
 644 /* Returns non-zero if the type is integral */
 645 int
 646 integral_type (struct type *type)
 647 {
 648   CHECK_TYPEDEF (type);
 649   switch (current_language->la_language)
 650     {
 651     case language_c:
 652     case language_cplus:
 653     case language_objc:
 654       return (TYPE_CODE (type) != TYPE_CODE_INT) &&
 655         (TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1;
 656     case language_m2:
 657     case language_pascal:
 658       return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1;
 659     default:
 660       error (_("Language not supported."));
 661     }
 662 }
 663
 664 /* Returns non-zero if the value is numeric */
 665 int
 666 numeric_type (struct type *type)
 667 {
 668   CHECK_TYPEDEF (type);
 669   switch (TYPE_CODE (type))
 670     {
 671     case TYPE_CODE_INT:
 672     case TYPE_CODE_FLT:
 673       return 1;
 674
 675     default:
 676       return 0;
 677     }
 678 }
 679
 680 /* Returns non-zero if the value is a character type */
 681 int
 682 character_type (struct type *type)
 683 {
 684   CHECK_TYPEDEF (type);
 685   switch (current_language->la_language)
 686     {
 687     case language_m2:
 688     case language_pascal:
 689       return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1;
 690
 691     case language_c:
 692     case language_cplus:
 693     case language_objc:
 694       return (TYPE_CODE (type) == TYPE_CODE_INT) &&
 695         TYPE_LENGTH (type) == sizeof (char)
 696       ? 1 : 0;
 697     default:
 698       return (0);
 699     }
 700 }
 701
 702 /* Returns non-zero if the value is a string type */
 703 int
 704 string_type (struct type *type)
 705 {
 706   CHECK_TYPEDEF (type);
 707   switch (current_language->la_language)
 708     {
 709     case language_m2:
 710     case language_pascal:
 711       return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1;
 712
 713     case language_c:
 714     case language_cplus:
 715     case language_objc:
 716       /* C does not have distinct string type. */
 717       return (0);
 718     default:
 719       return (0);
 720     }
 721 }
 722
 723 /* Returns non-zero if the value is a boolean type */
 724 int
 725 boolean_type (struct type *type)
 726 {
 727   CHECK_TYPEDEF (type);
 728   if (TYPE_CODE (type) == TYPE_CODE_BOOL)
 729     return 1;
 730   switch (current_language->la_language)
 731     {
 732     case language_c:
 733     case language_cplus:
 734     case language_objc:
 735       /* Might be more cleanly handled by having a
 736          TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such
 737          languages, or a TYPE_CODE_INT_OR_BOOL for C.  */
 738       if (TYPE_CODE (type) == TYPE_CODE_INT)
 739         return 1;
 740     default:
 741       break;
 742     }
 743   return 0;
 744 }
 745
 746 /* Returns non-zero if the value is a floating-point type */
 747 int
 748 float_type (struct type *type)
 749 {
 750   CHECK_TYPEDEF (type);
 751   return TYPE_CODE (type) == TYPE_CODE_FLT;
 752 }
 753
 754 /* Returns non-zero if the value is a pointer type */
 755 int
 756 pointer_type (struct type *type)
 757 {
 758   return TYPE_CODE (type) == TYPE_CODE_PTR ||
 759     TYPE_CODE (type) == TYPE_CODE_REF;
 760 }
 761
 762 /* Returns non-zero if the value is a structured type */
 763 int
 764 structured_type (struct type *type)
 765 {
 766   CHECK_TYPEDEF (type);
 767   switch (current_language->la_language)
 768     {
 769     case language_c:
 770     case language_cplus:
 771     case language_objc:
 772       return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
 773         (TYPE_CODE (type) == TYPE_CODE_UNION) ||
 774         (TYPE_CODE (type) == TYPE_CODE_ARRAY);
 775    case language_pascal:
 776       return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
 777          (TYPE_CODE(type) == TYPE_CODE_UNION) ||
 778          (TYPE_CODE(type) == TYPE_CODE_SET) ||
 779             (TYPE_CODE(type) == TYPE_CODE_ARRAY);
 780     case language_m2:
 781       return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
 782         (TYPE_CODE (type) == TYPE_CODE_SET) ||
 783         (TYPE_CODE (type) == TYPE_CODE_ARRAY);
 784     default:
 785       return (0);
 786     }
 787 }
 788 #endif
 789 \f
 790 struct type *
 791 lang_bool_type (void)
 792 {
 793   struct symbol *sym;
 794   struct type *type;
 795   switch (current_language->la_language)
 796     {
 797     case language_fortran:
 798       sym = lookup_symbol ("logical", NULL, VAR_DOMAIN, NULL, NULL);
 799       if (sym)
 800         {
 801           type = SYMBOL_TYPE (sym);
 802           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
 803             return type;
 804         }
 805       return builtin_type_f_logical_s2;
 806     case language_cplus:
 807     case language_pascal:
 808     case language_ada:
 809       if (current_language->la_language==language_cplus)
 810         {sym = lookup_symbol ("bool", NULL, VAR_DOMAIN, NULL, NULL);}
 811       else
 812         {sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL, NULL);}
 813       if (sym)
 814         {
 815           type = SYMBOL_TYPE (sym);
 816           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
 817             return type;
 818         }
 819       return builtin_type_bool;
 820     case language_java:
 821       sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL, NULL);
 822       if (sym)
 823         {
 824           type = SYMBOL_TYPE (sym);
 825           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
 826             return type;
 827         }
 828       return java_boolean_type;
 829
 830     default:
 831       return builtin_type_int;
 832     }
 833 }
 834 \f
 835 /* This page contains functions that return info about
 836    (struct value) values used in GDB. */
 837
 838 /* Returns non-zero if the value VAL represents a true value. */
 839 int
 840 value_true (struct value *val)
 841 {
 842   /* It is possible that we should have some sort of error if a non-boolean
 843      value is used in this context.  Possibly dependent on some kind of
 844      "boolean-checking" option like range checking.  But it should probably
 845      not depend on the language except insofar as is necessary to identify
 846      a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
 847      should be an error, probably).  */
 848   return !value_logical_not (val);
 849 }
 850 \f
 851 /* This page contains functions for the printing out of
 852    error messages that occur during type- and range-
 853    checking. */
 854
 855 /* These are called when a language fails a type- or range-check.  The
 856    first argument should be a printf()-style format string, and the
 857    rest of the arguments should be its arguments.  If
 858    [type|range]_check is [type|range]_check_on, an error is printed;
 859    if [type|range]_check_warn, a warning; otherwise just the
 860    message. */
 861
 862 void
 863 type_error (const char *string,...)
 864 {
 865   va_list args;
 866   va_start (args, string);
 867
 868   switch (type_check)
 869     {
 870     case type_check_warn:
 871       vwarning (string, args);
 872       break;
 873     case type_check_on:
 874       verror (string, args);
 875       break;
 876     case type_check_off:
 877       /* FIXME: cagney/2002-01-30: Should this function print anything
 878          when type error is off?  */
 879       vfprintf_filtered (gdb_stderr, string, args);
 880       fprintf_filtered (gdb_stderr, "\n");
 881       break;
 882     default:
 883       internal_error (__FILE__, __LINE__, _("bad switch"));
 884     }
 885   va_end (args);
 886 }
 887
 888 void
 889 range_error (const char *string,...)
 890 {
 891   va_list args;
 892   va_start (args, string);
 893
 894   switch (range_check)
 895     {
 896     case range_check_warn:
 897       vwarning (string, args);
 898       break;
 899     case range_check_on:
 900       verror (string, args);
 901       break;
 902     case range_check_off:
 903       /* FIXME: cagney/2002-01-30: Should this function print anything
 904          when range error is off?  */
 905       vfprintf_filtered (gdb_stderr, string, args);
 906       fprintf_filtered (gdb_stderr, "\n");
 907       break;
 908     default:
 909       internal_error (__FILE__, __LINE__, _("bad switch"));
 910     }
 911   va_end (args);
 912 }
 913 \f
 914
 915 /* This page contains miscellaneous functions */
 916
 917 /* Return the language enum for a given language string. */
 918
 919 enum language
 920 language_enum (char *str)
 921 {
 922   int i;
 923
 924   for (i = 0; i < languages_size; i++)
 925     if (strcmp (languages[i]->la_name, str) == 0)
 926       return languages[i]->la_language;
 927
 928   return language_unknown;
 929 }
 930
 931 /* Return the language struct for a given language enum. */
 932
 933 const struct language_defn *
 934 language_def (enum language lang)
 935 {
 936   int i;
 937
 938   for (i = 0; i < languages_size; i++)
 939     {
 940       if (languages[i]->la_language == lang)
 941         {
 942           return languages[i];
 943         }
 944     }
 945   return NULL;
 946 }
 947
 948 /* Return the language as a string */
 949 char *
 950 language_str (enum language lang)
 951 {
 952   int i;
 953
 954   for (i = 0; i < languages_size; i++)
 955     {
 956       if (languages[i]->la_language == lang)
 957         {
 958           return languages[i]->la_name;
 959         }
 960     }
 961   return "Unknown";
 962 }
 963
 964 static void
 965 set_check (char *ignore, int from_tty)
 966 {
 967   printf_unfiltered (
 968      "\"set check\" must be followed by the name of a check subcommand.\n");
 969   help_list (setchecklist, "set check ", -1, gdb_stdout);
 970 }
 971
 972 static void
 973 show_check (char *ignore, int from_tty)
 974 {
 975   cmd_show_list (showchecklist, from_tty, "");
 976 }
 977 \f
 978 /* Add a language to the set of known languages.  */
 979
 980 void
 981 add_language (const struct language_defn *lang)
 982 {
 983   if (lang->la_magic != LANG_MAGIC)
 984     {
 985       fprintf_unfiltered (gdb_stderr, "Magic number of %s language struct wrong\n",
 986                           lang->la_name);
 987       internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 988     }
 989
 990   if (!languages)
 991     {
 992       languages_allocsize = DEFAULT_ALLOCSIZE;
 993       languages = (const struct language_defn **) xmalloc
 994         (languages_allocsize * sizeof (*languages));
 995     }
 996   if (languages_size >= languages_allocsize)
 997     {
 998       languages_allocsize *= 2;
 999       languages = (const struct language_defn **) xrealloc ((char *) languages,
1000                                  languages_allocsize * sizeof (*languages));
1001     }
1002   languages[languages_size++] = lang;
1003 }
1004
1005 /* Iterate through all registered languages looking for and calling
1006    any non-NULL struct language_defn.skip_trampoline() functions.
1007    Return the result from the first that returns non-zero, or 0 if all
1008    `fail'.  */
1009 CORE_ADDR
1010 skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
1011 {
1012   int i;
1013
1014   for (i = 0; i < languages_size; i++)
1015     {
1016       if (languages[i]->skip_trampoline)
1017         {
1018           CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc);
1019           if (real_pc)
1020             return real_pc;
1021         }
1022     }
1023
1024   return 0;
1025 }
1026
1027 /* Return demangled language symbol, or NULL.
1028    FIXME: Options are only useful for certain languages and ignored
1029    by others, so it would be better to remove them here and have a
1030    more flexible demangler for the languages that need it.
1031    FIXME: Sometimes the demangler is invoked when we don't know the
1032    language, so we can't use this everywhere.  */
1033 char *
1034 language_demangle (const struct language_defn *current_language,
1035                                 const char *mangled, int options)
1036 {
1037   if (current_language != NULL && current_language->la_demangle)
1038     return current_language->la_demangle (mangled, options);
1039   return NULL;
1040 }
1041
1042 /* Return class name from physname or NULL.  */
1043 char *
1044 language_class_name_from_physname (const struct language_defn *current_language,
1045                                    const char *physname)
1046 {
1047   if (current_language != NULL && current_language->la_class_name_from_physname)
1048     return current_language->la_class_name_from_physname (physname);
1049   return NULL;
1050 }
1051
1052 /* Return non-zero if TYPE should be passed (and returned) by
1053    reference at the language level.  */
1054 int
1055 language_pass_by_reference (struct type *type)
1056 {
1057   return current_language->la_pass_by_reference (type);
1058 }
1059
1060 /* Return zero; by default, types are passed by value at the language
1061    level.  The target ABI may pass or return some structs by reference
1062    independent of this.  */
1063 int
1064 default_pass_by_reference (struct type *type)
1065 {
1066   return 0;
1067 }
1068
1069 /* Return the default string containing the list of characters
1070    delimiting words.  This is a reasonable default value that
1071    most languages should be able to use.  */
1072
1073 char *
1074 default_word_break_characters (void)
1075 {
1076   return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1077 }
1078
1079 /* Print the index of array elements using the C99 syntax.  */
1080
1081 void
1082 default_print_array_index (struct value *index_value, struct ui_file *stream,
1083                            int format, enum val_prettyprint pretty)
1084 {
1085   fprintf_filtered (stream, "[");
1086   LA_VALUE_PRINT (index_value, stream, format, pretty);
1087   fprintf_filtered (stream, "] = ");
1088 }
1089
1090 /* Define the language that is no language.  */
1091
1092 static int
1093 unk_lang_parser (void)
1094 {
1095   return 1;
1096 }
1097
1098 static void
1099 unk_lang_error (char *msg)
1100 {
1101   error (_("Attempted to parse an expression with unknown language"));
1102 }
1103
1104 static void
1105 unk_lang_emit_char (int c, struct ui_file *stream, int quoter)
1106 {
1107   error (_("internal error - unimplemented function unk_lang_emit_char called."));
1108 }
1109
1110 static void
1111 unk_lang_printchar (int c, struct ui_file *stream)
1112 {
1113   error (_("internal error - unimplemented function unk_lang_printchar called."));
1114 }
1115
1116 static void
1117 unk_lang_printstr (struct ui_file *stream, const gdb_byte *string,
1118                    unsigned int length, int width, int force_ellipses)
1119 {
1120   error (_("internal error - unimplemented function unk_lang_printstr called."));
1121 }
1122
1123 static void
1124 unk_lang_print_type (struct type *type, char *varstring, struct ui_file *stream,
1125                      int show, int level)
1126 {
1127   error (_("internal error - unimplemented function unk_lang_print_type called."));
1128 }
1129
1130 static int
1131 unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
1132                     int embedded_offset, CORE_ADDR address,
1133                     struct ui_file *stream, int format,
1134                     int deref_ref, int recurse, enum val_prettyprint pretty)
1135 {
1136   error (_("internal error - unimplemented function unk_lang_val_print called."));
1137 }
1138
1139 static int
1140 unk_lang_value_print (struct value *val, struct ui_file *stream, int format,
1141                       enum val_prettyprint pretty)
1142 {
1143   error (_("internal error - unimplemented function unk_lang_value_print called."));
1144 }
1145
1146 static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc)
1147 {
1148   return 0;
1149 }
1150
1151 /* Unknown languages just use the cplus demangler.  */
1152 static char *unk_lang_demangle (const char *mangled, int options)
1153 {
1154   return cplus_demangle (mangled, options);
1155 }
1156
1157 static char *unk_lang_class_name (const char *mangled)
1158 {
1159   return NULL;
1160 }
1161
1162 static const struct op_print unk_op_print_tab[] =
1163 {
1164   {NULL, OP_NULL, PREC_NULL, 0}
1165 };
1166
1167 static void
1168 unknown_language_arch_info (struct gdbarch *gdbarch,
1169                             struct language_arch_info *lai)
1170 {
1171   lai->string_char_type = builtin_type (gdbarch)->builtin_char;
1172   lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
1173                                                        struct type *);
1174 }
1175
1176 const struct language_defn unknown_language_defn =
1177 {
1178   "unknown",
1179   language_unknown,
1180   range_check_off,
1181   type_check_off,
1182   array_row_major,
1183   case_sensitive_on,
1184   &exp_descriptor_standard,
1185   unk_lang_parser,
1186   unk_lang_error,
1187   null_post_parser,
1188   unk_lang_printchar,           /* Print character constant */
1189   unk_lang_printstr,
1190   unk_lang_emit_char,
1191   unk_lang_print_type,          /* Print a type using appropriate syntax */
1192   unk_lang_val_print,           /* Print a value using appropriate syntax */
1193   unk_lang_value_print,         /* Print a top-level value */
1194   unk_lang_trampoline,          /* Language specific skip_trampoline */
1195   value_of_this,                /* value_of_this */
1196   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1197   basic_lookup_transparent_type,/* lookup_transparent_type */
1198   unk_lang_demangle,            /* Language specific symbol demangler */
1199   unk_lang_class_name,          /* Language specific class_name_from_physname */
1200   unk_op_print_tab,             /* expression operators for printing */
1201   1,                            /* c-style arrays */
1202   0,                            /* String lower bound */
1203   default_word_break_characters,
1204   default_make_symbol_completion_list,
1205   unknown_language_arch_info,   /* la_language_arch_info.  */
1206   default_print_array_index,
1207   default_pass_by_reference,
1208   LANG_MAGIC
1209 };
1210
1211 /* These two structs define fake entries for the "local" and "auto" options. */
1212 const struct language_defn auto_language_defn =
1213 {
1214   "auto",
1215   language_auto,
1216   range_check_off,
1217   type_check_off,
1218   array_row_major,
1219   case_sensitive_on,
1220   &exp_descriptor_standard,
1221   unk_lang_parser,
1222   unk_lang_error,
1223   null_post_parser,
1224   unk_lang_printchar,           /* Print character constant */
1225   unk_lang_printstr,
1226   unk_lang_emit_char,
1227   unk_lang_print_type,          /* Print a type using appropriate syntax */
1228   unk_lang_val_print,           /* Print a value using appropriate syntax */
1229   unk_lang_value_print,         /* Print a top-level value */
1230   unk_lang_trampoline,          /* Language specific skip_trampoline */
1231   value_of_this,                /* value_of_this */
1232   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1233   basic_lookup_transparent_type,/* lookup_transparent_type */
1234   unk_lang_demangle,            /* Language specific symbol demangler */
1235   unk_lang_class_name,          /* Language specific class_name_from_physname */
1236   unk_op_print_tab,             /* expression operators for printing */
1237   1,                            /* c-style arrays */
1238   0,                            /* String lower bound */
1239   default_word_break_characters,
1240   default_make_symbol_completion_list,
1241   unknown_language_arch_info,   /* la_language_arch_info.  */
1242   default_print_array_index,
1243   default_pass_by_reference,
1244   LANG_MAGIC
1245 };
1246
1247 const struct language_defn local_language_defn =
1248 {
1249   "local",
1250   language_auto,
1251   range_check_off,
1252   type_check_off,
1253   case_sensitive_on,
1254   array_row_major,
1255   &exp_descriptor_standard,
1256   unk_lang_parser,
1257   unk_lang_error,
1258   null_post_parser,
1259   unk_lang_printchar,           /* Print character constant */
1260   unk_lang_printstr,
1261   unk_lang_emit_char,
1262   unk_lang_print_type,          /* Print a type using appropriate syntax */
1263   unk_lang_val_print,           /* Print a value using appropriate syntax */
1264   unk_lang_value_print,         /* Print a top-level value */
1265   unk_lang_trampoline,          /* Language specific skip_trampoline */
1266   value_of_this,                /* value_of_this */
1267   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1268   basic_lookup_transparent_type,/* lookup_transparent_type */
1269   unk_lang_demangle,            /* Language specific symbol demangler */
1270   unk_lang_class_name,          /* Language specific class_name_from_physname */
1271   unk_op_print_tab,             /* expression operators for printing */
1272   1,                            /* c-style arrays */
1273   0,                            /* String lower bound */
1274   default_word_break_characters,
1275   default_make_symbol_completion_list,
1276   unknown_language_arch_info,   /* la_language_arch_info.  */
1277   default_print_array_index,
1278   default_pass_by_reference,
1279   LANG_MAGIC
1280 };
1281 \f
1282 /* Per-architecture language information.  */
1283
1284 static struct gdbarch_data *language_gdbarch_data;
1285
1286 struct language_gdbarch
1287 {
1288   /* A vector of per-language per-architecture info.  Indexed by "enum
1289      language".  */
1290   struct language_arch_info arch_info[nr_languages];
1291 };
1292
1293 static void *
1294 language_gdbarch_post_init (struct gdbarch *gdbarch)
1295 {
1296   struct language_gdbarch *l;
1297   int i;
1298
1299   l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
1300   for (i = 0; i < languages_size; i++)
1301     {
1302       if (languages[i] != NULL
1303           && languages[i]->la_language_arch_info != NULL)
1304         languages[i]->la_language_arch_info
1305           (gdbarch, l->arch_info + languages[i]->la_language);
1306     }
1307   return l;
1308 }
1309
1310 struct type *
1311 language_string_char_type (const struct language_defn *la,
1312                            struct gdbarch *gdbarch)
1313 {
1314   struct language_gdbarch *ld = gdbarch_data (gdbarch,
1315                                               language_gdbarch_data);
1316   return ld->arch_info[la->la_language].string_char_type;
1317 }
1318
1319 struct type *
1320 language_lookup_primitive_type_by_name (const struct language_defn *la,
1321                                         struct gdbarch *gdbarch,
1322                                         const char *name)
1323 {
1324   struct language_gdbarch *ld = gdbarch_data (gdbarch,
1325                                               language_gdbarch_data);
1326   struct type *const *p;
1327   for (p = ld->arch_info[la->la_language].primitive_type_vector;
1328        (*p) != NULL;
1329        p++)
1330     {
1331       if (strcmp (TYPE_NAME (*p), name) == 0)
1332         return (*p);
1333     }
1334   return (NULL);
1335 }
1336
1337 /* Initialize the language routines */
1338
1339 void
1340 _initialize_language (void)
1341 {
1342   struct cmd_list_element *set, *show;
1343
1344   language_gdbarch_data
1345     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1346
1347   /* GDB commands for language specific stuff */
1348
1349   /* FIXME: cagney/2005-02-20: This should be implemented using an
1350      enum.  */
1351   add_setshow_string_noescape_cmd ("language", class_support, &language, _("\
1352 Set the current source language."), _("\
1353 Show the current source language."), NULL,
1354                                    set_language_command,
1355                                    show_language_command,
1356                                    &setlist, &showlist);
1357
1358   add_prefix_cmd ("check", no_class, set_check,
1359                   _("Set the status of the type/range checker."),
1360                   &setchecklist, "set check ", 0, &setlist);
1361   add_alias_cmd ("c", "check", no_class, 1, &setlist);
1362   add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1363
1364   add_prefix_cmd ("check", no_class, show_check,
1365                   _("Show the status of the type/range checker."),
1366                   &showchecklist, "show check ", 0, &showlist);
1367   add_alias_cmd ("c", "check", no_class, 1, &showlist);
1368   add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1369
1370   /* FIXME: cagney/2005-02-20: This should be implemented using an
1371      enum.  */
1372   add_setshow_string_noescape_cmd ("type", class_support, &type, _("\
1373 Set type checking.  (on/warn/off/auto)"), _("\
1374 Show type checking.  (on/warn/off/auto)"), NULL,
1375                                    set_type_command,
1376                                    show_type_command,
1377                                    &setchecklist, &showchecklist);
1378
1379   /* FIXME: cagney/2005-02-20: This should be implemented using an
1380      enum.  */
1381   add_setshow_string_noescape_cmd ("range", class_support, &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   /* FIXME: cagney/2005-02-20: This should be implemented using an
1389      enum.  */
1390   add_setshow_string_noescape_cmd ("case-sensitive", class_support,
1391                                    &case_sensitive, _("\
1392 Set case sensitivity in name search.  (on/off/auto)"), _("\
1393 Show case sensitivity in name search.  (on/off/auto)"), _("\
1394 For Fortran the default is off; for other languages the default is on."),
1395                                    set_case_command,
1396                                    show_case_command,
1397                                    &setlist, &showlist);
1398
1399   add_language (&unknown_language_defn);
1400   add_language (&local_language_defn);
1401   add_language (&auto_language_defn);
1402
1403   language = savestring ("auto", strlen ("auto"));
1404   type = savestring ("auto", strlen ("auto"));
1405   range = savestring ("auto", strlen ("auto"));
1406   case_sensitive = savestring ("auto",strlen ("auto"));
1407
1408   /* Have the above take effect */
1409   set_language (language_auto);
1410 }