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