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