contrib/gdb-6/gdb/language.c

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