gdb/language.c

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