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    case BINOP_MOD:
 846       if (!integral_type(t1) || !integral_type(t2))
 847          type_op_error ("Arguments to %s must be of integral type.",op);
 848       break;
 849
 850    case BINOP_LESS:
 851    case BINOP_GTR:
 852    case BINOP_LEQ:
 853    case BINOP_GEQ:
 854       if (!ordered_type(t1) || !ordered_type(t2))
 855          type_op_error ("Arguments to %s must be of ordered type.",op);
 856       else if (!same_type(t1,t2))
 857          type_op_error ("Arguments to %s must be of the same type.",op);
 858       break;
 859
 860    case BINOP_ASSIGN:
 861       if (pointer_type(t1) && !integral_type(t2))
 862          type_op_error ("A pointer can only be assigned an integer.",op);
 863       else if (pointer_type(t1) && integral_type(t2))
 864       {
 865          warning ("combining integer and pointer.");
 866          break;
 867       }
 868       else if (!simple_type(t1) || !simple_type(t2))
 869          type_op_error ("Arguments to %s must be of simple type.",op);
 870       else if (!same_type(t1,t2))
 871          type_op_error ("Arguments to %s must be of the same type.",op);
 872       break;
 873
 874    /* Unary checks -- arg2 is null */
 875
 876    case UNOP_LOGICAL_NOT:
 877       if (!boolean_type(t1))
 878          type_op_error ("Argument to %s must be of boolean type.",op);
 879       break;
 880
 881    case UNOP_PLUS:
 882    case UNOP_NEG:
 883       if (!numeric_type(t1))
 884          type_op_error ("Argument to %s must be of numeric type.",op);
 885       break;
 886
 887    case UNOP_IND:
 888       if (integral_type(t1))
 889       {
 890          warning ("combining pointer and integer.\n");
 891          break;
 892       }
 893       else if (!pointer_type(t1))
 894          type_op_error ("Argument to %s must be a pointer.",op);
 895       break;
 896
 897    case UNOP_PREINCREMENT:
 898    case UNOP_POSTINCREMENT:
 899    case UNOP_PREDECREMENT:
 900    case UNOP_POSTDECREMENT:
 901       if (!ordered_type(t1))
 902          type_op_error ("Argument to %s must be of an ordered type.",op);
 903       break;
 904
 905    default:
 906       /* Ok.  The following operators have different meanings in
 907          different languages. */
 908       switch(current_language->la_language)
 909       {
 910 #ifdef _LANG_c
 911       case language_c:
 912       case language_cplus:
 913          switch(op)
 914          {
 915          case BINOP_DIV:
 916             if (!numeric_type(t1) || !numeric_type(t2))
 917                type_op_error ("Arguments to %s must be numbers.",op);
 918             break;
 919          }
 920          break;
 921 #endif
 922
 923 #ifdef _LANG_m2
 924       case language_m2:
 925          switch(op)
 926          {
 927          case BINOP_DIV:
 928             if (!float_type(t1) || !float_type(t2))
 929                type_op_error ("Arguments to %s must be floating point numbers.",op);
 930             break;
 931          case BINOP_INTDIV:
 932             if (!integral_type(t1) || !integral_type(t2))
 933                type_op_error ("Arguments to %s must be of integral type.",op);
 934             break;
 935          }
 936 #endif
 937
 938 /* start-sanitize-chill */
 939 #ifdef _LANG_chill
 940        case language_chill:
 941          error ("Missing Chill support in function binop_type_check.");/*FIXME*/
 942 #endif
 943 /* end-sanitize-chill */
 944
 945       }
 946    }
 947 }
 948
 949 #endif  /* 0 */
 950
 951 \f
 952 /* This page contains functions for the printing out of
 953    error messages that occur during type- and range-
 954    checking. */
 955
 956 /* Prints the format string FMT with the operator as a string
 957    corresponding to the opcode OP.  If FATAL is non-zero, then
 958    this is an error and error () is called.  Otherwise, it is
 959    a warning and printf() is called. */
 960 void
 961 op_error (fmt,op,fatal)
 962    char *fmt;
 963    enum exp_opcode op;
 964    int fatal;
 965 {
 966    if (fatal)
 967       error (fmt,op_string(op));
 968    else
 969    {
 970       warning (fmt,op_string(op));
 971    }
 972 }
 973
 974 /* These are called when a language fails a type- or range-check.
 975    The first argument should be a printf()-style format string, and
 976    the rest of the arguments should be its arguments.  If
 977    [type|range]_check is [type|range]_check_on, then return_to_top_level()
 978    is called in the style of error ().  Otherwise, the message is prefixed
 979    by the value of warning_pre_print and we do not return to the top level. */
 980
 981 void
 982 type_error (va_alist)
 983      va_dcl
 984 {
 985    va_list args;
 986    char *string;
 987
 988    if (type_check==type_check_warn)
 989       fprintf(stderr,warning_pre_print);
 990    else
 991       target_terminal_ours();
 992
 993    va_start (args);
 994    string = va_arg (args, char *);
 995    vfprintf (stderr, string, args);
 996    fprintf (stderr, "\n");
 997    va_end (args);
 998    if (type_check==type_check_on)
 999       return_to_top_level();
1000 }
1001
1002 void
1003 range_error (va_alist)
1004      va_dcl
1005 {
1006    va_list args;
1007    char *string;
1008
1009    if (range_check==range_check_warn)
1010       fprintf(stderr,warning_pre_print);
1011    else
1012       target_terminal_ours();
1013
1014    va_start (args);
1015    string = va_arg (args, char *);
1016    vfprintf (stderr, string, args);
1017    fprintf (stderr, "\n");
1018    va_end (args);
1019    if (range_check==range_check_on)
1020       return_to_top_level();
1021 }
1022
1023 \f
1024 /* This page contains miscellaneous functions */
1025
1026 /* Return the language struct for a given language enum. */
1027
1028 const struct language_defn *
1029 language_def(lang)
1030    enum language lang;
1031 {
1032   int i;
1033
1034   for (i = 0; i < languages_size; i++) {
1035     if (languages[i]->la_language == lang) {
1036       return languages[i];
1037     }
1038   }
1039   return NULL;
1040 }
1041
1042 /* Return the language as a string */
1043 char *
1044 language_str(lang)
1045    enum language lang;
1046 {
1047   int i;
1048
1049   for (i = 0; i < languages_size; i++) {
1050     if (languages[i]->la_language == lang) {
1051       return languages[i]->la_name;
1052     }
1053   }
1054   return "Unknown";
1055 }
1056
1057 static void
1058 set_check (ignore, from_tty)
1059    char *ignore;
1060    int from_tty;
1061 {
1062    printf(
1063 "\"set check\" must be followed by the name of a check subcommand.\n");
1064    help_list(setchecklist, "set check ", -1, stdout);
1065 }
1066
1067 static void
1068 show_check (ignore, from_tty)
1069    char *ignore;
1070    int from_tty;
1071 {
1072    cmd_show_list(showchecklist, from_tty, "");
1073 }
1074 \f
1075 /* Add a language to the set of known languages.  */
1076
1077 void
1078 add_language (lang)
1079      const struct language_defn *lang;
1080 {
1081   if (lang->la_magic != LANG_MAGIC)
1082     {
1083       fprintf(stderr, "Magic number of %s language struct wrong\n",
1084         lang->la_name);
1085       abort();
1086     }
1087
1088   if (!languages)
1089     {
1090       languages_allocsize = DEFAULT_ALLOCSIZE;
1091       languages = (const struct language_defn **) xmalloc
1092         (languages_allocsize * sizeof (*languages));
1093     }
1094   if (languages_size >= languages_allocsize)
1095     {
1096       languages_allocsize *= 2;
1097       languages = (const struct language_defn **) xrealloc ((char *) languages,
1098         languages_allocsize * sizeof (*languages));
1099     }
1100   languages[languages_size++] = lang;
1101 }
1102
1103 /* Define the language that is no language.  */
1104
1105 static int
1106 unk_lang_parser ()
1107 {
1108   return 1;
1109 }
1110
1111 static void
1112 unk_lang_error (msg)
1113      char *msg;
1114 {
1115   error ("Attempted to parse an expression with unknown language");
1116 }
1117
1118 static void
1119 unk_lang_printchar (c, stream)
1120      register int c;
1121      FILE *stream;
1122 {
1123   error ("internal error - unimplemented function unk_lang_printchar called.");
1124 }
1125
1126 static void
1127 unk_lang_printstr (stream, string, length, force_ellipses)
1128      FILE *stream;
1129      char *string;
1130      unsigned int length;
1131      int force_ellipses;
1132 {
1133   error ("internal error - unimplemented function unk_lang_printstr called.");
1134 }
1135
1136 static struct type *
1137 unk_lang_create_fundamental_type (objfile, typeid)
1138      struct objfile *objfile;
1139      int typeid;
1140 {
1141   error ("internal error - unimplemented function unk_lang_create_fundamental_type called.");
1142 }
1143
1144 void
1145 unk_lang_print_type (type, varstring, stream, show, level)
1146      struct type *type;
1147      char *varstring;
1148      FILE *stream;
1149      int show;
1150      int level;
1151 {
1152   error ("internal error - unimplemented function unk_lang_print_type called.");
1153 }
1154
1155 int
1156 unk_lang_val_print (type, valaddr, address, stream, format, deref_ref,
1157                     recurse, pretty)
1158      struct type *type;
1159      char *valaddr;
1160      CORE_ADDR address;
1161      FILE *stream;
1162      int format;
1163      int deref_ref;
1164      int recurse;
1165      enum val_prettyprint pretty;
1166 {
1167   error ("internal error - unimplemented function unk_lang_val_print called.");
1168 }
1169
1170 static struct type ** const (unknown_builtin_types[]) = { 0 };
1171 static const struct op_print unk_op_print_tab[] = {
1172     {NULL, 0, 0, 0}
1173 };
1174
1175 const struct language_defn unknown_language_defn = {
1176   "unknown",
1177   language_unknown,
1178   &unknown_builtin_types[0],
1179   range_check_off,
1180   type_check_off,
1181   unk_lang_parser,
1182   unk_lang_error,
1183   unk_lang_printchar,           /* Print character constant */
1184   unk_lang_printstr,
1185   unk_lang_create_fundamental_type,
1186   unk_lang_print_type,          /* Print a type using appropriate syntax */
1187   unk_lang_val_print,           /* Print a value using appropriate syntax */
1188   &builtin_type_error,          /* longest signed   integral type */
1189   &builtin_type_error,          /* longest unsigned integral type */
1190   &builtin_type_error,          /* longest floating point type */
1191   {"",      "",    "",   ""},   /* Binary format info */
1192   {"0%o",   "0",   "o",  ""},   /* Octal format info */
1193   {"%d",    "",    "d",  ""},   /* Decimal format info */
1194   {"0x%x",  "0x",  "x",  ""},   /* Hex format info */
1195   unk_op_print_tab,             /* expression operators for printing */
1196   LANG_MAGIC
1197 };
1198
1199 /* These two structs define fake entries for the "local" and "auto" options. */
1200 const struct language_defn auto_language_defn = {
1201   "auto",
1202   language_auto,
1203   &unknown_builtin_types[0],
1204   range_check_off,
1205   type_check_off,
1206   unk_lang_parser,
1207   unk_lang_error,
1208   unk_lang_printchar,           /* Print character constant */
1209   unk_lang_printstr,
1210   unk_lang_create_fundamental_type,
1211   unk_lang_print_type,          /* Print a type using appropriate syntax */
1212   unk_lang_val_print,           /* Print a value using appropriate syntax */
1213   &builtin_type_error,          /* longest signed   integral type */
1214   &builtin_type_error,          /* longest unsigned integral type */
1215   &builtin_type_error,          /* longest floating point type */
1216   {"",      "",    "",   ""},   /* Binary format info */
1217   {"0%o",   "0",   "o",  ""},   /* Octal format info */
1218   {"%d",    "",    "d",  ""},   /* Decimal format info */
1219   {"0x%x",  "0x",  "x",  ""},   /* Hex format info */
1220   unk_op_print_tab,             /* expression operators for printing */
1221   LANG_MAGIC
1222 };
1223
1224 const struct language_defn local_language_defn = {
1225   "local",
1226   language_auto,
1227   &unknown_builtin_types[0],
1228   range_check_off,
1229   type_check_off,
1230   unk_lang_parser,
1231   unk_lang_error,
1232   unk_lang_printchar,           /* Print character constant */
1233   unk_lang_printstr,
1234   unk_lang_create_fundamental_type,
1235   unk_lang_print_type,          /* Print a type using appropriate syntax */
1236   unk_lang_val_print,           /* Print a value using appropriate syntax */
1237   &builtin_type_error,          /* longest signed   integral type */
1238   &builtin_type_error,          /* longest unsigned integral type */
1239   &builtin_type_error,          /* longest floating point type */
1240   {"",      "",    "",   ""},   /* Binary format info */
1241   {"0%o",   "0",   "o",  ""},   /* Octal format info */
1242   {"%d",    "",    "d",  ""},   /* Decimal format info */
1243   {"0x%x",  "0x",  "x",  ""},   /* Hex format info */
1244   unk_op_print_tab,             /* expression operators for printing */
1245   LANG_MAGIC
1246 };
1247 \f
1248 /* Initialize the language routines */
1249
1250 void
1251 _initialize_language()
1252 {
1253    struct cmd_list_element *set, *show;
1254
1255    /* GDB commands for language specific stuff */
1256
1257    set = add_set_cmd ("language", class_support, var_string_noescape,
1258                       (char *)&language,
1259                       "Set the current source language.",
1260                       &setlist);
1261    show = add_show_from_set (set, &showlist);
1262    set->function.cfunc = set_language_command;
1263    show->function.cfunc = show_language_command;
1264
1265    add_prefix_cmd ("check", no_class, set_check,
1266                    "Set the status of the type/range checker",
1267                    &setchecklist, "set check ", 0, &setlist);
1268    add_alias_cmd ("c", "check", no_class, 1, &setlist);
1269    add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1270
1271    add_prefix_cmd ("check", no_class, show_check,
1272                    "Show the status of the type/range checker",
1273                    &showchecklist, "show check ", 0, &showlist);
1274    add_alias_cmd ("c", "check", no_class, 1, &showlist);
1275    add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1276
1277    set = add_set_cmd ("type", class_support, var_string_noescape,
1278                       (char *)&type,
1279                       "Set type checking.  (on/warn/off/auto)",
1280                       &setchecklist);
1281    show = add_show_from_set (set, &showchecklist);
1282    set->function.cfunc = set_type_command;
1283    show->function.cfunc = show_type_command;
1284
1285    set = add_set_cmd ("range", class_support, var_string_noescape,
1286                       (char *)&range,
1287                       "Set range checking.  (on/warn/off/auto)",
1288                       &setchecklist);
1289    show = add_show_from_set (set, &showchecklist);
1290    set->function.cfunc = set_range_command;
1291    show->function.cfunc = show_range_command;
1292
1293    add_language (&unknown_language_defn);
1294    add_language (&local_language_defn);
1295    add_language (&auto_language_defn);
1296
1297    language = savestring ("auto",strlen("auto"));
1298    range = savestring ("auto",strlen("auto"));
1299    type = savestring ("auto",strlen("auto"));
1300
1301    /* Have the above take effect */
1302
1303    set_language_command (language, 0);
1304    set_type_command (NULL, 0);
1305    set_range_command (NULL, 0);
1306 }