gdb/language.c

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