gdb/language.c

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