gdb/language.c

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