gdb/language.c

   1 /* Multiple source language support for GDB.
   2
   3    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
   4    2001, 2002, 2003, 2004, 2005 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 2 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, write to the Free Software
  23    Foundation, Inc., 59 Temple Place - Suite 330,
  24    Boston, MA 02111-1307, USA.  */
  25
  26 /* This file contains functions that return things that are specific
  27    to languages.  Each function should examine current_language if necessary,
  28    and return the appropriate result. */
  29
  30 /* FIXME:  Most of these would be better organized as macros which
  31    return data out of a "language-specific" struct pointer that is set
  32    whenever the working language changes.  That would be a lot faster.  */
  33
  34 #include "defs.h"
  35 #include <ctype.h>
  36 #include "gdb_string.h"
  37
  38 #include "symtab.h"
  39 #include "gdbtypes.h"
  40 #include "value.h"
  41 #include "gdbcmd.h"
  42 #include "expression.h"
  43 #include "language.h"
  44 #include "target.h"
  45 #include "parser-defs.h"
  46 #include "jv-lang.h"
  47 #include "demangle.h"
  48
  49 extern void _initialize_language (void);
  50
  51 static void set_case_str (void);
  52
  53 static void set_range_str (void);
  54
  55 static void set_type_str (void);
  56
  57 static void set_lang_str (void);
  58
  59 static void unk_lang_error (char *);
  60
  61 static int unk_lang_parser (void);
  62
  63 static void show_check (char *, int);
  64
  65 static void set_check (char *, int);
  66
  67 static void set_type_range_case (void);
  68
  69 static void unk_lang_emit_char (int c, struct ui_file *stream, int quoter);
  70
  71 static void unk_lang_printchar (int c, struct ui_file *stream);
  72
  73 static struct type *unk_lang_create_fundamental_type (struct objfile *, int);
  74
  75 static void unk_lang_print_type (struct type *, char *, struct ui_file *,
  76                                  int, int);
  77
  78 static int unk_lang_value_print (struct value *, struct ui_file *, int, enum val_prettyprint);
  79
  80 static CORE_ADDR unk_lang_trampoline (CORE_ADDR pc);
  81
  82 /* Forward declaration */
  83 extern const struct language_defn unknown_language_defn;
  84
  85 /* The current (default at startup) state of type and range checking.
  86    (If the modes are set to "auto", though, these are changed based
  87    on the default language at startup, and then again based on the
  88    language of the first source file.  */
  89
  90 enum range_mode range_mode = range_mode_auto;
  91 enum range_check range_check = range_check_off;
  92 enum type_mode type_mode = type_mode_auto;
  93 enum type_check type_check = type_check_off;
  94 enum case_mode case_mode = case_mode_auto;
  95 enum case_sensitivity case_sensitivity = case_sensitive_on;
  96
  97 /* The current language and language_mode (see language.h) */
  98
  99 const struct language_defn *current_language = &unknown_language_defn;
 100 enum language_mode language_mode = language_mode_auto;
 101
 102 /* The language that the user expects to be typing in (the language
 103    of main(), or the last language we notified them about, or C).  */
 104
 105 const struct language_defn *expected_language;
 106
 107 /* The list of supported languages.  The list itself is malloc'd.  */
 108
 109 static const struct language_defn **languages;
 110 static unsigned languages_size;
 111 static unsigned languages_allocsize;
 112 #define DEFAULT_ALLOCSIZE 4
 113
 114 /* The "set language/type/range" commands all put stuff in these
 115    buffers.  This is to make them work as set/show commands.  The
 116    user's string is copied here, then the set_* commands look at
 117    them and update them to something that looks nice when it is
 118    printed out. */
 119
 120 static char *language;
 121 static char *type;
 122 static char *range;
 123 static char *case_sensitive;
 124
 125 /* Warning issued when current_language and the language of the current
 126    frame do not match. */
 127 char lang_frame_mismatch_warn[] =
 128 "Warning: the current language does not match this frame.";
 129 \f
 130 /* This page contains the functions corresponding to GDB commands
 131    and their helpers. */
 132
 133 /* Show command.  Display a warning if the language set
 134    does not match the frame. */
 135 static void
 136 show_language_command (struct ui_file *file, int from_tty,
 137                        struct cmd_list_element *c, const char *value)
 138 {
 139   enum language flang;          /* The language of the current frame */
 140
 141   deprecated_show_value_hack (file, from_tty, c, value);
 142   flang = get_frame_language ();
 143   if (flang != language_unknown &&
 144       language_mode == language_mode_manual &&
 145       current_language->la_language != flang)
 146     printf_filtered ("%s\n", lang_frame_mismatch_warn);
 147 }
 148
 149 /* Set command.  Change the current working language. */
 150 static void
 151 set_language_command (char *ignore, int from_tty, struct cmd_list_element *c)
 152 {
 153   int i;
 154   enum language flang;
 155   char *err_lang;
 156
 157   if (!language || !language[0])
 158     {
 159       printf_unfiltered (_("\
 160 The currently understood settings are:\n\n\
 161 local or auto    Automatic setting based on source file\n"));
 162
 163       for (i = 0; i < languages_size; ++i)
 164         {
 165           /* Already dealt with these above.  */
 166           if (languages[i]->la_language == language_unknown
 167               || languages[i]->la_language == language_auto)
 168             continue;
 169
 170           /* FIXME: i18n: for now assume that the human-readable name
 171              is just a capitalization of the internal name.  */
 172           printf_unfiltered ("%-16s Use the %c%s language\n",
 173                              languages[i]->la_name,
 174           /* Capitalize first letter of language
 175              name.  */
 176                              toupper (languages[i]->la_name[0]),
 177                              languages[i]->la_name + 1);
 178         }
 179       /* Restore the silly string. */
 180       set_language (current_language->la_language);
 181       return;
 182     }
 183
 184   /* Search the list of languages for a match.  */
 185   for (i = 0; i < languages_size; i++)
 186     {
 187       if (strcmp (languages[i]->la_name, language) == 0)
 188         {
 189           /* Found it!  Go into manual mode, and use this language.  */
 190           if (languages[i]->la_language == language_auto)
 191             {
 192               /* Enter auto mode.  Set to the current frame's language, if known.  */
 193               language_mode = language_mode_auto;
 194               flang = get_frame_language ();
 195               if (flang != language_unknown)
 196                 set_language (flang);
 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       if (current_language->la_language==language_cplus)
 809         {sym = lookup_symbol ("bool", NULL, VAR_DOMAIN, NULL, NULL);}
 810       else
 811         {sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL, NULL);}
 812       if (sym)
 813         {
 814           type = SYMBOL_TYPE (sym);
 815           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
 816             return type;
 817         }
 818       return builtin_type_bool;
 819     case language_java:
 820       sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL, NULL);
 821       if (sym)
 822         {
 823           type = SYMBOL_TYPE (sym);
 824           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
 825             return type;
 826         }
 827       return java_boolean_type;
 828     default:
 829       return builtin_type_int;
 830     }
 831 }
 832 \f
 833 /* This page contains functions that return info about
 834    (struct value) values used in GDB. */
 835
 836 /* Returns non-zero if the value VAL represents a true value. */
 837 int
 838 value_true (struct value *val)
 839 {
 840   /* It is possible that we should have some sort of error if a non-boolean
 841      value is used in this context.  Possibly dependent on some kind of
 842      "boolean-checking" option like range checking.  But it should probably
 843      not depend on the language except insofar as is necessary to identify
 844      a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
 845      should be an error, probably).  */
 846   return !value_logical_not (val);
 847 }
 848 \f
 849 /* This page contains functions for the printing out of
 850    error messages that occur during type- and range-
 851    checking. */
 852
 853 /* These are called when a language fails a type- or range-check.  The
 854    first argument should be a printf()-style format string, and the
 855    rest of the arguments should be its arguments.  If
 856    [type|range]_check is [type|range]_check_on, an error is printed;
 857    if [type|range]_check_warn, a warning; otherwise just the
 858    message. */
 859
 860 void
 861 type_error (const char *string,...)
 862 {
 863   va_list args;
 864   va_start (args, string);
 865
 866   switch (type_check)
 867     {
 868     case type_check_warn:
 869       vwarning (string, args);
 870       break;
 871     case type_check_on:
 872       verror (string, args);
 873       break;
 874     case type_check_off:
 875       /* FIXME: cagney/2002-01-30: Should this function print anything
 876          when type error is off?  */
 877       vfprintf_filtered (gdb_stderr, string, args);
 878       fprintf_filtered (gdb_stderr, "\n");
 879       break;
 880     default:
 881       internal_error (__FILE__, __LINE__, _("bad switch"));
 882     }
 883   va_end (args);
 884 }
 885
 886 void
 887 range_error (const char *string,...)
 888 {
 889   va_list args;
 890   va_start (args, string);
 891
 892   switch (range_check)
 893     {
 894     case range_check_warn:
 895       vwarning (string, args);
 896       break;
 897     case range_check_on:
 898       verror (string, args);
 899       break;
 900     case range_check_off:
 901       /* FIXME: cagney/2002-01-30: Should this function print anything
 902          when range error is off?  */
 903       vfprintf_filtered (gdb_stderr, string, args);
 904       fprintf_filtered (gdb_stderr, "\n");
 905       break;
 906     default:
 907       internal_error (__FILE__, __LINE__, _("bad switch"));
 908     }
 909   va_end (args);
 910 }
 911 \f
 912
 913 /* This page contains miscellaneous functions */
 914
 915 /* Return the language enum for a given language string. */
 916
 917 enum language
 918 language_enum (char *str)
 919 {
 920   int i;
 921
 922   for (i = 0; i < languages_size; i++)
 923     if (strcmp (languages[i]->la_name, str) == 0)
 924       return languages[i]->la_language;
 925
 926   return language_unknown;
 927 }
 928
 929 /* Return the language struct for a given language enum. */
 930
 931 const struct language_defn *
 932 language_def (enum language lang)
 933 {
 934   int i;
 935
 936   for (i = 0; i < languages_size; i++)
 937     {
 938       if (languages[i]->la_language == lang)
 939         {
 940           return languages[i];
 941         }
 942     }
 943   return NULL;
 944 }
 945
 946 /* Return the language as a string */
 947 char *
 948 language_str (enum language lang)
 949 {
 950   int i;
 951
 952   for (i = 0; i < languages_size; i++)
 953     {
 954       if (languages[i]->la_language == lang)
 955         {
 956           return languages[i]->la_name;
 957         }
 958     }
 959   return "Unknown";
 960 }
 961
 962 static void
 963 set_check (char *ignore, int from_tty)
 964 {
 965   printf_unfiltered (
 966      "\"set check\" must be followed by the name of a check subcommand.\n");
 967   help_list (setchecklist, "set check ", -1, gdb_stdout);
 968 }
 969
 970 static void
 971 show_check (char *ignore, int from_tty)
 972 {
 973   cmd_show_list (showchecklist, from_tty, "");
 974 }
 975 \f
 976 /* Add a language to the set of known languages.  */
 977
 978 void
 979 add_language (const struct language_defn *lang)
 980 {
 981   if (lang->la_magic != LANG_MAGIC)
 982     {
 983       fprintf_unfiltered (gdb_stderr, "Magic number of %s language struct wrong\n",
 984                           lang->la_name);
 985       internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 986     }
 987
 988   if (!languages)
 989     {
 990       languages_allocsize = DEFAULT_ALLOCSIZE;
 991       languages = (const struct language_defn **) xmalloc
 992         (languages_allocsize * sizeof (*languages));
 993     }
 994   if (languages_size >= languages_allocsize)
 995     {
 996       languages_allocsize *= 2;
 997       languages = (const struct language_defn **) xrealloc ((char *) languages,
 998                                  languages_allocsize * sizeof (*languages));
 999     }
1000   languages[languages_size++] = lang;
1001 }
1002
1003 /* Iterate through all registered languages looking for and calling
1004    any non-NULL struct language_defn.skip_trampoline() functions.
1005    Return the result from the first that returns non-zero, or 0 if all
1006    `fail'.  */
1007 CORE_ADDR
1008 skip_language_trampoline (CORE_ADDR pc)
1009 {
1010   int i;
1011
1012   for (i = 0; i < languages_size; i++)
1013     {
1014       if (languages[i]->skip_trampoline)
1015         {
1016           CORE_ADDR real_pc = (languages[i]->skip_trampoline) (pc);
1017           if (real_pc)
1018             return real_pc;
1019         }
1020     }
1021
1022   return 0;
1023 }
1024
1025 /* Return demangled language symbol, or NULL.
1026    FIXME: Options are only useful for certain languages and ignored
1027    by others, so it would be better to remove them here and have a
1028    more flexible demangler for the languages that need it.
1029    FIXME: Sometimes the demangler is invoked when we don't know the
1030    language, so we can't use this everywhere.  */
1031 char *
1032 language_demangle (const struct language_defn *current_language,
1033                                 const char *mangled, int options)
1034 {
1035   if (current_language != NULL && current_language->la_demangle)
1036     return current_language->la_demangle (mangled, options);
1037   return NULL;
1038 }
1039
1040 /* Return class name from physname or NULL.  */
1041 char *
1042 language_class_name_from_physname (const struct language_defn *current_language,
1043                                    const char *physname)
1044 {
1045   if (current_language != NULL && current_language->la_class_name_from_physname)
1046     return current_language->la_class_name_from_physname (physname);
1047   return NULL;
1048 }
1049
1050 /* Return the default string containing the list of characters
1051    delimiting words.  This is a reasonable default value that
1052    most languages should be able to use.  */
1053
1054 char *
1055 default_word_break_characters (void)
1056 {
1057   return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1058 }
1059
1060 /* Define the language that is no language.  */
1061
1062 static int
1063 unk_lang_parser (void)
1064 {
1065   return 1;
1066 }
1067
1068 static void
1069 unk_lang_error (char *msg)
1070 {
1071   error (_("Attempted to parse an expression with unknown language"));
1072 }
1073
1074 static void
1075 unk_lang_emit_char (int c, struct ui_file *stream, int quoter)
1076 {
1077   error (_("internal error - unimplemented function unk_lang_emit_char called."));
1078 }
1079
1080 static void
1081 unk_lang_printchar (int c, struct ui_file *stream)
1082 {
1083   error (_("internal error - unimplemented function unk_lang_printchar called."));
1084 }
1085
1086 static void
1087 unk_lang_printstr (struct ui_file *stream, const gdb_byte *string,
1088                    unsigned int length, int width, int force_ellipses)
1089 {
1090   error (_("internal error - unimplemented function unk_lang_printstr called."));
1091 }
1092
1093 static struct type *
1094 unk_lang_create_fundamental_type (struct objfile *objfile, int typeid)
1095 {
1096   error (_("internal error - unimplemented function unk_lang_create_fundamental_type called."));
1097 }
1098
1099 static void
1100 unk_lang_print_type (struct type *type, char *varstring, struct ui_file *stream,
1101                      int show, int level)
1102 {
1103   error (_("internal error - unimplemented function unk_lang_print_type called."));
1104 }
1105
1106 static int
1107 unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
1108                     int embedded_offset, CORE_ADDR address,
1109                     struct ui_file *stream, int format,
1110                     int deref_ref, int recurse, enum val_prettyprint pretty)
1111 {
1112   error (_("internal error - unimplemented function unk_lang_val_print called."));
1113 }
1114
1115 static int
1116 unk_lang_value_print (struct value *val, struct ui_file *stream, int format,
1117                       enum val_prettyprint pretty)
1118 {
1119   error (_("internal error - unimplemented function unk_lang_value_print called."));
1120 }
1121
1122 static CORE_ADDR unk_lang_trampoline (CORE_ADDR pc)
1123 {
1124   return 0;
1125 }
1126
1127 /* Unknown languages just use the cplus demangler.  */
1128 static char *unk_lang_demangle (const char *mangled, int options)
1129 {
1130   return cplus_demangle (mangled, options);
1131 }
1132
1133 static char *unk_lang_class_name (const char *mangled)
1134 {
1135   return NULL;
1136 }
1137
1138 static const struct op_print unk_op_print_tab[] =
1139 {
1140   {NULL, OP_NULL, PREC_NULL, 0}
1141 };
1142
1143 static void
1144 unknown_language_arch_info (struct gdbarch *gdbarch,
1145                             struct language_arch_info *lai)
1146 {
1147   lai->string_char_type = builtin_type (gdbarch)->builtin_char;
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   NULL,
1157   range_check_off,
1158   type_check_off,
1159   array_row_major,
1160   case_sensitive_on,
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_create_fundamental_type,
1169   unk_lang_print_type,          /* Print a type 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   value_of_this,                /* value_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   NULL,
1182   default_word_break_characters,
1183   unknown_language_arch_info,   /* la_language_arch_info.  */
1184   LANG_MAGIC
1185 };
1186
1187 /* These two structs define fake entries for the "local" and "auto" options. */
1188 const struct language_defn auto_language_defn =
1189 {
1190   "auto",
1191   language_auto,
1192   NULL,
1193   range_check_off,
1194   type_check_off,
1195   array_row_major,
1196   case_sensitive_on,
1197   &exp_descriptor_standard,
1198   unk_lang_parser,
1199   unk_lang_error,
1200   null_post_parser,
1201   unk_lang_printchar,           /* Print character constant */
1202   unk_lang_printstr,
1203   unk_lang_emit_char,
1204   unk_lang_create_fundamental_type,
1205   unk_lang_print_type,          /* Print a type using appropriate syntax */
1206   unk_lang_val_print,           /* Print a value using appropriate syntax */
1207   unk_lang_value_print,         /* Print a top-level value */
1208   unk_lang_trampoline,          /* Language specific skip_trampoline */
1209   value_of_this,                /* value_of_this */
1210   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1211   basic_lookup_transparent_type,/* lookup_transparent_type */
1212   unk_lang_demangle,            /* Language specific symbol demangler */
1213   unk_lang_class_name,          /* Language specific class_name_from_physname */
1214   unk_op_print_tab,             /* expression operators for printing */
1215   1,                            /* c-style arrays */
1216   0,                            /* String lower bound */
1217   NULL,
1218   default_word_break_characters,
1219   unknown_language_arch_info,   /* la_language_arch_info.  */
1220   LANG_MAGIC
1221 };
1222
1223 const struct language_defn local_language_defn =
1224 {
1225   "local",
1226   language_auto,
1227   NULL,
1228   range_check_off,
1229   type_check_off,
1230   case_sensitive_on,
1231   array_row_major,
1232   &exp_descriptor_standard,
1233   unk_lang_parser,
1234   unk_lang_error,
1235   null_post_parser,
1236   unk_lang_printchar,           /* Print character constant */
1237   unk_lang_printstr,
1238   unk_lang_emit_char,
1239   unk_lang_create_fundamental_type,
1240   unk_lang_print_type,          /* Print a type using appropriate syntax */
1241   unk_lang_val_print,           /* Print a value using appropriate syntax */
1242   unk_lang_value_print,         /* Print a top-level value */
1243   unk_lang_trampoline,          /* Language specific skip_trampoline */
1244   value_of_this,                /* value_of_this */
1245   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1246   basic_lookup_transparent_type,/* lookup_transparent_type */
1247   unk_lang_demangle,            /* Language specific symbol demangler */
1248   unk_lang_class_name,          /* Language specific class_name_from_physname */
1249   unk_op_print_tab,             /* expression operators for printing */
1250   1,                            /* c-style arrays */
1251   0,                            /* String lower bound */
1252   NULL,
1253   default_word_break_characters,
1254   unknown_language_arch_info,   /* la_language_arch_info.  */
1255   LANG_MAGIC
1256 };
1257 \f
1258 /* Per-architecture language information.  */
1259
1260 static struct gdbarch_data *language_gdbarch_data;
1261
1262 struct language_gdbarch
1263 {
1264   /* A vector of per-language per-architecture info.  Indexed by "enum
1265      language".  */
1266   struct language_arch_info arch_info[nr_languages];
1267 };
1268
1269 static void *
1270 language_gdbarch_post_init (struct gdbarch *gdbarch)
1271 {
1272   struct language_gdbarch *l;
1273   int i;
1274
1275   l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
1276   for (i = 0; i < languages_size; i++)
1277     {
1278       if (languages[i] != NULL
1279           && languages[i]->la_language_arch_info != NULL)
1280         languages[i]->la_language_arch_info
1281           (gdbarch, l->arch_info + languages[i]->la_language);
1282     }
1283   return l;
1284 }
1285
1286 struct type *
1287 language_string_char_type (const struct language_defn *la,
1288                            struct gdbarch *gdbarch)
1289 {
1290   struct language_gdbarch *ld = gdbarch_data (gdbarch,
1291                                               language_gdbarch_data);
1292   if (ld->arch_info[la->la_language].string_char_type != NULL)
1293     return ld->arch_info[la->la_language].string_char_type;
1294   else
1295     return (*la->string_char_type);
1296 }
1297
1298 struct type *
1299 language_lookup_primitive_type_by_name (const struct language_defn *la,
1300                                         struct gdbarch *gdbarch,
1301                                         const char *name)
1302 {
1303   struct language_gdbarch *ld = gdbarch_data (gdbarch,
1304                                               language_gdbarch_data);
1305   if (ld->arch_info[la->la_language].primitive_type_vector != NULL)
1306     {
1307       struct type *const *p;
1308       for (p = ld->arch_info[la->la_language].primitive_type_vector;
1309            (*p) != NULL;
1310            p++)
1311         {
1312           if (strcmp (TYPE_NAME (*p), name) == 0)
1313             return (*p);
1314         }
1315     }
1316   else
1317     {
1318       struct type **const *p;
1319       for (p = current_language->la_builtin_type_vector; *p != NULL; p++)
1320         {
1321           if (strcmp (TYPE_NAME (**p), name) == 0)
1322             return (**p);
1323         }
1324     }
1325   return (NULL);
1326 }
1327
1328 /* Initialize the language routines */
1329
1330 void
1331 _initialize_language (void)
1332 {
1333   struct cmd_list_element *set, *show;
1334
1335   language_gdbarch_data
1336     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1337
1338   /* GDB commands for language specific stuff */
1339
1340   /* FIXME: cagney/2005-02-20: This should be implemented using an
1341      enum.  */
1342   add_setshow_string_noescape_cmd ("language", class_support, &language, _("\
1343 Set the current source language."), _("\
1344 Show the current source language."), NULL,
1345                                    set_language_command,
1346                                    show_language_command,
1347                                    &setlist, &showlist);
1348
1349   add_prefix_cmd ("check", no_class, set_check,
1350                   _("Set the status of the type/range checker."),
1351                   &setchecklist, "set check ", 0, &setlist);
1352   add_alias_cmd ("c", "check", no_class, 1, &setlist);
1353   add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1354
1355   add_prefix_cmd ("check", no_class, show_check,
1356                   _("Show the status of the type/range checker."),
1357                   &showchecklist, "show check ", 0, &showlist);
1358   add_alias_cmd ("c", "check", no_class, 1, &showlist);
1359   add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1360
1361   /* FIXME: cagney/2005-02-20: This should be implemented using an
1362      enum.  */
1363   add_setshow_string_noescape_cmd ("type", class_support, &type, _("\
1364 Set type checking.  (on/warn/off/auto)"), _("\
1365 Show type checking.  (on/warn/off/auto)"), NULL,
1366                                    set_type_command,
1367                                    show_type_command,
1368                                    &setchecklist, &showchecklist);
1369
1370   /* FIXME: cagney/2005-02-20: This should be implemented using an
1371      enum.  */
1372   add_setshow_string_noescape_cmd ("range", class_support, &range, _("\
1373 Set range checking.  (on/warn/off/auto)"), _("\
1374 Show range checking.  (on/warn/off/auto)"), NULL,
1375                                    set_range_command,
1376                                    show_range_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 ("case-sensitive", class_support,
1382                                    &case_sensitive, _("\
1383 Set case sensitivity in name search.  (on/off/auto)"), _("\
1384 Show case sensitivity in name search.  (on/off/auto)"), _("\
1385 For Fortran the default is off; for other languages the default is on."),
1386                                    set_case_command,
1387                                    show_case_command,
1388                                    &setlist, &showlist);
1389
1390   add_language (&unknown_language_defn);
1391   add_language (&local_language_defn);
1392   add_language (&auto_language_defn);
1393
1394   language = savestring ("auto", strlen ("auto"));
1395   type = savestring ("auto", strlen ("auto"));
1396   range = savestring ("auto", strlen ("auto"));
1397   case_sensitive = savestring ("auto",strlen ("auto"));
1398
1399   /* Have the above take effect */
1400   set_language (language_auto);
1401 }