gdb/language.c

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