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