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