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