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       if (TYPE_CODE (t1) == TYPE_CODE_FLT)
 553         return TYPE_CODE (t2) == TYPE_CODE_FLT && l2 > l1 ?
 554           VALUE_TYPE (v2) : VALUE_TYPE (v1);
 555       else if (TYPE_CODE (t2) == TYPE_CODE_FLT)
 556         return TYPE_CODE (t1) == TYPE_CODE_FLT && l1 > l2 ?
 557           VALUE_TYPE (v1) : VALUE_TYPE (v2);
 558       else if (TYPE_UNSIGNED (t1) && l1 > l2)
 559         return VALUE_TYPE (v1);
 560       else if (TYPE_UNSIGNED (t2) && l2 > l1)
 561         return VALUE_TYPE (v2);
 562       else                      /* Both are signed.  Result is the longer type */
 563         return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
 564       break;
 565     case language_m2:
 566       /* If we are doing type-checking, l1 should equal l2, so this is
 567          not needed. */
 568       return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
 569       break;
 570       /* OBSOLETE case language_chill: */
 571       /* OBSOLETE    error ("Missing Chill support in function binop_result_check.");  */       /*FIXME */
 572     }
 573   internal_error (__FILE__, __LINE__, "failed internal consistency check");
 574   return (struct type *) 0;     /* For lint */
 575 }
 576
 577 #endif /* 0 */
 578 \f
 579
 580 /* This page contains functions that return format strings for
 581    printf for printing out numbers in different formats */
 582
 583 /* Returns the appropriate printf format for hexadecimal
 584    numbers. */
 585 char *
 586 local_hex_format_custom (char *pre)
 587 {
 588   static char form[50];
 589
 590   strcpy (form, local_hex_format_prefix ());
 591   strcat (form, "%");
 592   strcat (form, pre);
 593   strcat (form, local_hex_format_specifier ());
 594   strcat (form, local_hex_format_suffix ());
 595   return form;
 596 }
 597
 598 /* Converts a LONGEST to custom hexadecimal and stores it in a static
 599    string.  Returns a pointer to this string. */
 600 char *
 601 local_hex_string (LONGEST num)
 602 {
 603   return local_hex_string_custom (num, "l");
 604 }
 605
 606 /* Converts a LONGEST number to custom hexadecimal and stores it in a static
 607    string.  Returns a pointer to this string. Note that the width parameter
 608    should end with "l", e.g. "08l" as with calls to local_hex_string_custom */
 609
 610 char *
 611 local_hex_string_custom (LONGEST num, char *width)
 612 {
 613 #define RESULT_BUF_LEN 50
 614   static char res2[RESULT_BUF_LEN];
 615   char format[RESULT_BUF_LEN];
 616   int field_width;
 617   int num_len;
 618   int num_pad_chars;
 619   char *pad_char;               /* string with one character */
 620   int pad_on_left;
 621   char *parse_ptr;
 622   char temp_nbr_buf[RESULT_BUF_LEN];
 623
 624   /* Use phex_nz to print the number into a string, then
 625      build the result string from local_hex_format_prefix, padding and
 626      the hex representation as indicated by "width".  */
 627   strcpy (temp_nbr_buf, phex_nz (num, sizeof (num)));
 628   /* parse width */
 629   parse_ptr = width;
 630   pad_on_left = 1;
 631   pad_char = " ";
 632   if (*parse_ptr == '-')
 633     {
 634       parse_ptr++;
 635       pad_on_left = 0;
 636     }
 637   if (*parse_ptr == '0')
 638     {
 639       parse_ptr++;
 640       if (pad_on_left)
 641         pad_char = "0";         /* If padding is on the right, it is blank */
 642     }
 643   field_width = atoi (parse_ptr);
 644   num_len = strlen (temp_nbr_buf);
 645   num_pad_chars = field_width - strlen (temp_nbr_buf);  /* possibly negative */
 646
 647   if (strlen (local_hex_format_prefix ()) + num_len + num_pad_chars
 648       >= RESULT_BUF_LEN)                /* paranoia */
 649     internal_error (__FILE__, __LINE__,
 650                     "local_hex_string_custom: insufficient space to store result");
 651
 652   strcpy (res2, local_hex_format_prefix ());
 653   if (pad_on_left)
 654     {
 655       while (num_pad_chars > 0)
 656         {
 657           strcat (res2, pad_char);
 658           num_pad_chars--;
 659         }
 660     }
 661   strcat (res2, temp_nbr_buf);
 662   if (!pad_on_left)
 663     {
 664       while (num_pad_chars > 0)
 665         {
 666           strcat (res2, pad_char);
 667           num_pad_chars--;
 668         }
 669     }
 670   return res2;
 671
 672 }                               /* local_hex_string_custom */
 673
 674 /* Returns the appropriate printf format for octal
 675    numbers. */
 676 char *
 677 local_octal_format_custom (char *pre)
 678 {
 679   static char form[50];
 680
 681   strcpy (form, local_octal_format_prefix ());
 682   strcat (form, "%");
 683   strcat (form, pre);
 684   strcat (form, local_octal_format_specifier ());
 685   strcat (form, local_octal_format_suffix ());
 686   return form;
 687 }
 688
 689 /* Returns the appropriate printf format for decimal numbers. */
 690 char *
 691 local_decimal_format_custom (char *pre)
 692 {
 693   static char form[50];
 694
 695   strcpy (form, local_decimal_format_prefix ());
 696   strcat (form, "%");
 697   strcat (form, pre);
 698   strcat (form, local_decimal_format_specifier ());
 699   strcat (form, local_decimal_format_suffix ());
 700   return form;
 701 }
 702 \f
 703 #if 0
 704 /* This page contains functions that are used in type/range checking.
 705    They all return zero if the type/range check fails.
 706
 707    It is hoped that these will make extending GDB to parse different
 708    languages a little easier.  These are primarily used in eval.c when
 709    evaluating expressions and making sure that their types are correct.
 710    Instead of having a mess of conjucted/disjuncted expressions in an "if",
 711    the ideas of type can be wrapped up in the following functions.
 712
 713    Note that some of them are not currently dependent upon which language
 714    is currently being parsed.  For example, floats are the same in
 715    C and Modula-2 (ie. the only floating point type has TYPE_CODE of
 716    TYPE_CODE_FLT), while booleans are different. */
 717
 718 /* Returns non-zero if its argument is a simple type.  This is the same for
 719    both Modula-2 and for C.  In the C case, TYPE_CODE_CHAR will never occur,
 720    and thus will never cause the failure of the test. */
 721 int
 722 simple_type (struct type *type)
 723 {
 724   CHECK_TYPEDEF (type);
 725   switch (TYPE_CODE (type))
 726     {
 727     case TYPE_CODE_INT:
 728     case TYPE_CODE_CHAR:
 729     case TYPE_CODE_ENUM:
 730     case TYPE_CODE_FLT:
 731     case TYPE_CODE_RANGE:
 732     case TYPE_CODE_BOOL:
 733       return 1;
 734
 735     default:
 736       return 0;
 737     }
 738 }
 739
 740 /* Returns non-zero if its argument is of an ordered type.
 741    An ordered type is one in which the elements can be tested for the
 742    properties of "greater than", "less than", etc, or for which the
 743    operations "increment" or "decrement" make sense. */
 744 int
 745 ordered_type (struct type *type)
 746 {
 747   CHECK_TYPEDEF (type);
 748   switch (TYPE_CODE (type))
 749     {
 750     case TYPE_CODE_INT:
 751     case TYPE_CODE_CHAR:
 752     case TYPE_CODE_ENUM:
 753     case TYPE_CODE_FLT:
 754     case TYPE_CODE_RANGE:
 755       return 1;
 756
 757     default:
 758       return 0;
 759     }
 760 }
 761
 762 /* Returns non-zero if the two types are the same */
 763 int
 764 same_type (struct type *arg1, struct type *arg2)
 765 {
 766   CHECK_TYPEDEF (type);
 767   if (structured_type (arg1) ? !structured_type (arg2) : structured_type (arg2))
 768     /* One is structured and one isn't */
 769     return 0;
 770   else if (structured_type (arg1) && structured_type (arg2))
 771     return arg1 == arg2;
 772   else if (numeric_type (arg1) && numeric_type (arg2))
 773     return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) &&
 774       (TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2))
 775       ? 1 : 0;
 776   else
 777     return arg1 == arg2;
 778 }
 779
 780 /* Returns non-zero if the type is integral */
 781 int
 782 integral_type (struct type *type)
 783 {
 784   CHECK_TYPEDEF (type);
 785   switch (current_language->la_language)
 786     {
 787     case language_c:
 788     case language_cplus:
 789       return (TYPE_CODE (type) != TYPE_CODE_INT) &&
 790         (TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1;
 791     case language_m2:
 792     case language_pascal:
 793       return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1;
 794       /* OBSOLETE case language_chill: */
 795       /* OBSOLETE   error ("Missing Chill support in function integral_type."); *//*FIXME */
 796     default:
 797       error ("Language not supported.");
 798     }
 799 }
 800
 801 /* Returns non-zero if the value is numeric */
 802 int
 803 numeric_type (struct type *type)
 804 {
 805   CHECK_TYPEDEF (type);
 806   switch (TYPE_CODE (type))
 807     {
 808     case TYPE_CODE_INT:
 809     case TYPE_CODE_FLT:
 810       return 1;
 811
 812     default:
 813       return 0;
 814     }
 815 }
 816
 817 /* Returns non-zero if the value is a character type */
 818 int
 819 character_type (struct type *type)
 820 {
 821   CHECK_TYPEDEF (type);
 822   switch (current_language->la_language)
 823     {
 824       /* OBSOLETE case language_chill: */
 825     case language_m2:
 826     case language_pascal:
 827       return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1;
 828
 829     case language_c:
 830     case language_cplus:
 831       return (TYPE_CODE (type) == TYPE_CODE_INT) &&
 832         TYPE_LENGTH (type) == sizeof (char)
 833       ? 1 : 0;
 834     default:
 835       return (0);
 836     }
 837 }
 838
 839 /* Returns non-zero if the value is a string type */
 840 int
 841 string_type (struct type *type)
 842 {
 843   CHECK_TYPEDEF (type);
 844   switch (current_language->la_language)
 845     {
 846       /* OBSOLETE case language_chill: */
 847     case language_m2:
 848     case language_pascal:
 849       return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1;
 850
 851     case language_c:
 852     case language_cplus:
 853       /* C does not have distinct string type. */
 854       return (0);
 855     default:
 856       return (0);
 857     }
 858 }
 859
 860 /* Returns non-zero if the value is a boolean type */
 861 int
 862 boolean_type (struct type *type)
 863 {
 864   CHECK_TYPEDEF (type);
 865   if (TYPE_CODE (type) == TYPE_CODE_BOOL)
 866     return 1;
 867   switch (current_language->la_language)
 868     {
 869     case language_c:
 870     case language_cplus:
 871       /* Might be more cleanly handled by having a
 872          TYPE_CODE_INT_NOT_BOOL for (OBSOLETE) CHILL and such
 873          languages, or a TYPE_CODE_INT_OR_BOOL for C.  */
 874       if (TYPE_CODE (type) == TYPE_CODE_INT)
 875         return 1;
 876     default:
 877       break;
 878     }
 879   return 0;
 880 }
 881
 882 /* Returns non-zero if the value is a floating-point type */
 883 int
 884 float_type (struct type *type)
 885 {
 886   CHECK_TYPEDEF (type);
 887   return TYPE_CODE (type) == TYPE_CODE_FLT;
 888 }
 889
 890 /* Returns non-zero if the value is a pointer type */
 891 int
 892 pointer_type (struct type *type)
 893 {
 894   return TYPE_CODE (type) == TYPE_CODE_PTR ||
 895     TYPE_CODE (type) == TYPE_CODE_REF;
 896 }
 897
 898 /* Returns non-zero if the value is a structured type */
 899 int
 900 structured_type (struct type *type)
 901 {
 902   CHECK_TYPEDEF (type);
 903   switch (current_language->la_language)
 904     {
 905     case language_c:
 906     case language_cplus:
 907       return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
 908         (TYPE_CODE (type) == TYPE_CODE_UNION) ||
 909         (TYPE_CODE (type) == TYPE_CODE_ARRAY);
 910    case language_pascal:
 911       return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
 912          (TYPE_CODE(type) == TYPE_CODE_UNION) ||
 913          (TYPE_CODE(type) == TYPE_CODE_SET) ||
 914             (TYPE_CODE(type) == TYPE_CODE_ARRAY);
 915     case language_m2:
 916       return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
 917         (TYPE_CODE (type) == TYPE_CODE_SET) ||
 918         (TYPE_CODE (type) == TYPE_CODE_ARRAY);
 919       /* OBSOLETE case language_chill: */
 920       /* OBSOLETE     error ("Missing Chill support in function structured_type.");     *//*FIXME */
 921     default:
 922       return (0);
 923     }
 924 }
 925 #endif
 926 \f
 927 struct type *
 928 lang_bool_type (void)
 929 {
 930   struct symbol *sym;
 931   struct type *type;
 932   switch (current_language->la_language)
 933     {
 934 #if 0
 935       /* OBSOLETE case language_chill: */
 936       /* OBSOLETE    return builtin_type_chill_bool; */
 937 #endif
 938     case language_fortran:
 939       sym = lookup_symbol ("logical", NULL, VAR_NAMESPACE, NULL, NULL);
 940       if (sym)
 941         {
 942           type = SYMBOL_TYPE (sym);
 943           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
 944             return type;
 945         }
 946       return builtin_type_f_logical_s2;
 947     case language_cplus:
 948     case language_pascal:
 949       if (current_language->la_language==language_cplus)
 950         {sym = lookup_symbol ("bool", NULL, VAR_NAMESPACE, NULL, NULL);}
 951       else
 952         {sym = lookup_symbol ("boolean", NULL, VAR_NAMESPACE, NULL, NULL);}
 953       if (sym)
 954         {
 955           type = SYMBOL_TYPE (sym);
 956           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
 957             return type;
 958         }
 959       return builtin_type_bool;
 960     case language_java:
 961       sym = lookup_symbol ("boolean", NULL, VAR_NAMESPACE, NULL, NULL);
 962       if (sym)
 963         {
 964           type = SYMBOL_TYPE (sym);
 965           if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
 966             return type;
 967         }
 968       return java_boolean_type;
 969     default:
 970       return builtin_type_int;
 971     }
 972 }
 973 \f
 974 /* This page contains functions that return info about
 975    (struct value) values used in GDB. */
 976
 977 /* Returns non-zero if the value VAL represents a true value. */
 978 int
 979 value_true (struct value *val)
 980 {
 981   /* It is possible that we should have some sort of error if a non-boolean
 982      value is used in this context.  Possibly dependent on some kind of
 983      "boolean-checking" option like range checking.  But it should probably
 984      not depend on the language except insofar as is necessary to identify
 985      a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
 986      should be an error, probably).  */
 987   return !value_logical_not (val);
 988 }
 989 \f
 990 /* Returns non-zero if the operator OP is defined on
 991    the values ARG1 and ARG2. */
 992
 993 #if 0                           /* Currently unused */
 994
 995 void
 996 binop_type_check (struct value *arg1, struct value *arg2, int op)
 997 {
 998   struct type *t1, *t2;
 999
1000   /* If we're not checking types, always return success. */
1001   if (!STRICT_TYPE)
1002     return;
1003
1004   t1 = VALUE_TYPE (arg1);
1005   if (arg2 != NULL)
1006     t2 = VALUE_TYPE (arg2);
1007   else
1008     t2 = NULL;
1009
1010   switch (op)
1011     {
1012     case BINOP_ADD:
1013     case BINOP_SUB:
1014       if ((numeric_type (t1) && pointer_type (t2)) ||
1015           (pointer_type (t1) && numeric_type (t2)))
1016         {
1017           warning ("combining pointer and integer.\n");
1018           break;
1019         }
1020     case BINOP_MUL:
1021     case BINOP_LSH:
1022     case BINOP_RSH:
1023       if (!numeric_type (t1) || !numeric_type (t2))
1024         type_op_error ("Arguments to %s must be numbers.", op);
1025       else if (!same_type (t1, t2))
1026         type_op_error ("Arguments to %s must be of the same type.", op);
1027       break;
1028
1029     case BINOP_LOGICAL_AND:
1030     case BINOP_LOGICAL_OR:
1031       if (!boolean_type (t1) || !boolean_type (t2))
1032         type_op_error ("Arguments to %s must be of boolean type.", op);
1033       break;
1034
1035     case BINOP_EQUAL:
1036       if ((pointer_type (t1) && !(pointer_type (t2) || integral_type (t2))) ||
1037           (pointer_type (t2) && !(pointer_type (t1) || integral_type (t1))))
1038         type_op_error ("A pointer can only be compared to an integer or pointer.", op);
1039       else if ((pointer_type (t1) && integral_type (t2)) ||
1040                (integral_type (t1) && pointer_type (t2)))
1041         {
1042           warning ("combining integer and pointer.\n");
1043           break;
1044         }
1045       else if (!simple_type (t1) || !simple_type (t2))
1046         type_op_error ("Arguments to %s must be of simple type.", op);
1047       else if (!same_type (t1, t2))
1048         type_op_error ("Arguments to %s must be of the same type.", op);
1049       break;
1050
1051     case BINOP_REM:
1052     case BINOP_MOD:
1053       if (!integral_type (t1) || !integral_type (t2))
1054         type_op_error ("Arguments to %s must be of integral type.", op);
1055       break;
1056
1057     case BINOP_LESS:
1058     case BINOP_GTR:
1059     case BINOP_LEQ:
1060     case BINOP_GEQ:
1061       if (!ordered_type (t1) || !ordered_type (t2))
1062         type_op_error ("Arguments to %s must be of ordered type.", op);
1063       else if (!same_type (t1, t2))
1064         type_op_error ("Arguments to %s must be of the same type.", op);
1065       break;
1066
1067     case BINOP_ASSIGN:
1068       if (pointer_type (t1) && !integral_type (t2))
1069         type_op_error ("A pointer can only be assigned an integer.", op);
1070       else if (pointer_type (t1) && integral_type (t2))
1071         {
1072           warning ("combining integer and pointer.");
1073           break;
1074         }
1075       else if (!simple_type (t1) || !simple_type (t2))
1076         type_op_error ("Arguments to %s must be of simple type.", op);
1077       else if (!same_type (t1, t2))
1078         type_op_error ("Arguments to %s must be of the same type.", op);
1079       break;
1080
1081     case BINOP_CONCAT:
1082       /* FIXME:  Needs to handle bitstrings as well. */
1083       if (!(string_type (t1) || character_type (t1) || integral_type (t1))
1084         || !(string_type (t2) || character_type (t2) || integral_type (t2)))
1085         type_op_error ("Arguments to %s must be strings or characters.", op);
1086       break;
1087
1088       /* Unary checks -- arg2 is null */
1089
1090     case UNOP_LOGICAL_NOT:
1091       if (!boolean_type (t1))
1092         type_op_error ("Argument to %s must be of boolean type.", op);
1093       break;
1094
1095     case UNOP_PLUS:
1096     case UNOP_NEG:
1097       if (!numeric_type (t1))
1098         type_op_error ("Argument to %s must be of numeric type.", op);
1099       break;
1100
1101     case UNOP_IND:
1102       if (integral_type (t1))
1103         {
1104           warning ("combining pointer and integer.\n");
1105           break;
1106         }
1107       else if (!pointer_type (t1))
1108         type_op_error ("Argument to %s must be a pointer.", op);
1109       break;
1110
1111     case UNOP_PREINCREMENT:
1112     case UNOP_POSTINCREMENT:
1113     case UNOP_PREDECREMENT:
1114     case UNOP_POSTDECREMENT:
1115       if (!ordered_type (t1))
1116         type_op_error ("Argument to %s must be of an ordered type.", op);
1117       break;
1118
1119     default:
1120       /* Ok.  The following operators have different meanings in
1121          different languages. */
1122       switch (current_language->la_language)
1123         {
1124 #ifdef _LANG_c
1125         case language_c:
1126         case language_cplus:
1127           switch (op)
1128             {
1129             case BINOP_DIV:
1130               if (!numeric_type (t1) || !numeric_type (t2))
1131                 type_op_error ("Arguments to %s must be numbers.", op);
1132               break;
1133             }
1134           break;
1135 #endif
1136
1137 #ifdef _LANG_m2
1138         case language_m2:
1139           switch (op)
1140             {
1141             case BINOP_DIV:
1142               if (!float_type (t1) || !float_type (t2))
1143                 type_op_error ("Arguments to %s must be floating point numbers.", op);
1144               break;
1145             case BINOP_INTDIV:
1146               if (!integral_type (t1) || !integral_type (t2))
1147                 type_op_error ("Arguments to %s must be of integral type.", op);
1148               break;
1149             }
1150 #endif
1151
1152 #ifdef _LANG_pascal
1153       case language_pascal:
1154          switch(op)
1155          {
1156          case BINOP_DIV:
1157             if (!float_type(t1) && !float_type(t2))
1158                type_op_error ("Arguments to %s must be floating point numbers.",op);
1159             break;
1160          case BINOP_INTDIV:
1161             if (!integral_type(t1) || !integral_type(t2))
1162                type_op_error ("Arguments to %s must be of integral type.",op);
1163             break;
1164          }
1165 #endif
1166
1167 #ifdef _LANG_chill /* OBSOLETE */
1168          /* OBSOLETE case language_chill: */
1169          /* OBSOLETE   error ("Missing Chill support in function binop_type_check.");   *//*FIXME */
1170 #endif
1171
1172         }
1173     }
1174 }
1175
1176 #endif /* 0 */
1177 \f
1178
1179 /* This page contains functions for the printing out of
1180    error messages that occur during type- and range-
1181    checking. */
1182
1183 /* Prints the format string FMT with the operator as a string
1184    corresponding to the opcode OP.  If FATAL is non-zero, then
1185    this is an error and error () is called.  Otherwise, it is
1186    a warning and printf() is called. */
1187 void
1188 op_error (char *fmt, enum exp_opcode op, int fatal)
1189 {
1190   if (fatal)
1191     error (fmt, op_string (op));
1192   else
1193     {
1194       warning (fmt, op_string (op));
1195     }
1196 }
1197
1198 /* These are called when a language fails a type- or range-check.  The
1199    first argument should be a printf()-style format string, and the
1200    rest of the arguments should be its arguments.  If
1201    [type|range]_check is [type|range]_check_on, an error is printed;
1202    if [type|range]_check_warn, a warning; otherwise just the
1203    message. */
1204
1205 void
1206 type_error (const char *string,...)
1207 {
1208   va_list args;
1209   va_start (args, string);
1210
1211   switch (type_check)
1212     {
1213     case type_check_warn:
1214       vwarning (string, args);
1215       break;
1216     case type_check_on:
1217       verror (string, args);
1218       break;
1219     case type_check_off:
1220       /* FIXME: cagney/2002-01-30: Should this function print anything
1221          when type error is off?  */
1222       vfprintf_filtered (gdb_stderr, string, args);
1223       fprintf_filtered (gdb_stderr, "\n");
1224       break;
1225     default:
1226       internal_error (__FILE__, __LINE__, "bad switch");
1227     }
1228   va_end (args);
1229 }
1230
1231 void
1232 range_error (const char *string,...)
1233 {
1234   va_list args;
1235   va_start (args, string);
1236
1237   switch (range_check)
1238     {
1239     case range_check_warn:
1240       vwarning (string, args);
1241       break;
1242     case range_check_on:
1243       verror (string, args);
1244       break;
1245     case range_check_off:
1246       /* FIXME: cagney/2002-01-30: Should this function print anything
1247          when range error is off?  */
1248       vfprintf_filtered (gdb_stderr, string, args);
1249       fprintf_filtered (gdb_stderr, "\n");
1250       break;
1251     default:
1252       internal_error (__FILE__, __LINE__, "bad switch");
1253     }
1254   va_end (args);
1255 }
1256 \f
1257
1258 /* This page contains miscellaneous functions */
1259
1260 /* Return the language enum for a given language string. */
1261
1262 enum language
1263 language_enum (char *str)
1264 {
1265   int i;
1266
1267   for (i = 0; i < languages_size; i++)
1268     if (STREQ (languages[i]->la_name, str))
1269       return languages[i]->la_language;
1270
1271   return language_unknown;
1272 }
1273
1274 /* Return the language struct for a given language enum. */
1275
1276 const struct language_defn *
1277 language_def (enum language lang)
1278 {
1279   int i;
1280
1281   for (i = 0; i < languages_size; i++)
1282     {
1283       if (languages[i]->la_language == lang)
1284         {
1285           return languages[i];
1286         }
1287     }
1288   return NULL;
1289 }
1290
1291 /* Return the language as a string */
1292 char *
1293 language_str (enum language lang)
1294 {
1295   int i;
1296
1297   for (i = 0; i < languages_size; i++)
1298     {
1299       if (languages[i]->la_language == lang)
1300         {
1301           return languages[i]->la_name;
1302         }
1303     }
1304   return "Unknown";
1305 }
1306
1307 static void
1308 set_check (char *ignore, int from_tty)
1309 {
1310   printf_unfiltered (
1311      "\"set check\" must be followed by the name of a check subcommand.\n");
1312   help_list (setchecklist, "set check ", -1, gdb_stdout);
1313 }
1314
1315 static void
1316 show_check (char *ignore, int from_tty)
1317 {
1318   cmd_show_list (showchecklist, from_tty, "");
1319 }
1320 \f
1321 /* Add a language to the set of known languages.  */
1322
1323 void
1324 add_language (const struct language_defn *lang)
1325 {
1326   if (lang->la_magic != LANG_MAGIC)
1327     {
1328       fprintf_unfiltered (gdb_stderr, "Magic number of %s language struct wrong\n",
1329                           lang->la_name);
1330       internal_error (__FILE__, __LINE__, "failed internal consistency check");
1331     }
1332
1333   if (!languages)
1334     {
1335       languages_allocsize = DEFAULT_ALLOCSIZE;
1336       languages = (const struct language_defn **) xmalloc
1337         (languages_allocsize * sizeof (*languages));
1338     }
1339   if (languages_size >= languages_allocsize)
1340     {
1341       languages_allocsize *= 2;
1342       languages = (const struct language_defn **) xrealloc ((char *) languages,
1343                                  languages_allocsize * sizeof (*languages));
1344     }
1345   languages[languages_size++] = lang;
1346 }
1347
1348 /* Define the language that is no language.  */
1349
1350 static int
1351 unk_lang_parser (void)
1352 {
1353   return 1;
1354 }
1355
1356 static void
1357 unk_lang_error (char *msg)
1358 {
1359   error ("Attempted to parse an expression with unknown language");
1360 }
1361
1362 static void
1363 unk_lang_emit_char (register int c, struct ui_file *stream, int quoter)
1364 {
1365   error ("internal error - unimplemented function unk_lang_emit_char called.");
1366 }
1367
1368 static void
1369 unk_lang_printchar (register int c, struct ui_file *stream)
1370 {
1371   error ("internal error - unimplemented function unk_lang_printchar called.");
1372 }
1373
1374 static void
1375 unk_lang_printstr (struct ui_file *stream, char *string, unsigned int length,
1376                    int width, int force_ellipses)
1377 {
1378   error ("internal error - unimplemented function unk_lang_printstr called.");
1379 }
1380
1381 static struct type *
1382 unk_lang_create_fundamental_type (struct objfile *objfile, int typeid)
1383 {
1384   error ("internal error - unimplemented function unk_lang_create_fundamental_type called.");
1385 }
1386
1387 static void
1388 unk_lang_print_type (struct type *type, char *varstring, struct ui_file *stream,
1389                      int show, int level)
1390 {
1391   error ("internal error - unimplemented function unk_lang_print_type called.");
1392 }
1393
1394 static int
1395 unk_lang_val_print (struct type *type, char *valaddr, int embedded_offset,
1396                     CORE_ADDR address, struct ui_file *stream, int format,
1397                     int deref_ref, int recurse, enum val_prettyprint pretty)
1398 {
1399   error ("internal error - unimplemented function unk_lang_val_print called.");
1400 }
1401
1402 static int
1403 unk_lang_value_print (struct value *val, struct ui_file *stream, int format,
1404                       enum val_prettyprint pretty)
1405 {
1406   error ("internal error - unimplemented function unk_lang_value_print called.");
1407 }
1408
1409 static struct type **const (unknown_builtin_types[]) =
1410 {
1411   0
1412 };
1413 static const struct op_print unk_op_print_tab[] =
1414 {
1415   {NULL, OP_NULL, PREC_NULL, 0}
1416 };
1417
1418 const struct language_defn unknown_language_defn =
1419 {
1420   "unknown",
1421   language_unknown,
1422   &unknown_builtin_types[0],
1423   range_check_off,
1424   type_check_off,
1425   case_sensitive_on,
1426   unk_lang_parser,
1427   unk_lang_error,
1428   evaluate_subexp_standard,
1429   unk_lang_printchar,           /* Print character constant */
1430   unk_lang_printstr,
1431   unk_lang_emit_char,
1432   unk_lang_create_fundamental_type,
1433   unk_lang_print_type,          /* Print a type using appropriate syntax */
1434   unk_lang_val_print,           /* Print a value using appropriate syntax */
1435   unk_lang_value_print,         /* Print a top-level value */
1436   {"", "", "", ""},             /* Binary format info */
1437   {"0%lo", "0", "o", ""},       /* Octal format info */
1438   {"%ld", "", "d", ""},         /* Decimal format info */
1439   {"0x%lx", "0x", "x", ""},     /* Hex format info */
1440   unk_op_print_tab,             /* expression operators for printing */
1441   1,                            /* c-style arrays */
1442   0,                            /* String lower bound */
1443   &builtin_type_char,           /* Type of string elements */
1444   LANG_MAGIC
1445 };
1446
1447 /* These two structs define fake entries for the "local" and "auto" options. */
1448 const struct language_defn auto_language_defn =
1449 {
1450   "auto",
1451   language_auto,
1452   &unknown_builtin_types[0],
1453   range_check_off,
1454   type_check_off,
1455   case_sensitive_on,
1456   unk_lang_parser,
1457   unk_lang_error,
1458   evaluate_subexp_standard,
1459   unk_lang_printchar,           /* Print character constant */
1460   unk_lang_printstr,
1461   unk_lang_emit_char,
1462   unk_lang_create_fundamental_type,
1463   unk_lang_print_type,          /* Print a type using appropriate syntax */
1464   unk_lang_val_print,           /* Print a value using appropriate syntax */
1465   unk_lang_value_print,         /* Print a top-level value */
1466   {"", "", "", ""},             /* Binary format info */
1467   {"0%lo", "0", "o", ""},       /* Octal format info */
1468   {"%ld", "", "d", ""},         /* Decimal format info */
1469   {"0x%lx", "0x", "x", ""},     /* Hex format info */
1470   unk_op_print_tab,             /* expression operators for printing */
1471   1,                            /* c-style arrays */
1472   0,                            /* String lower bound */
1473   &builtin_type_char,           /* Type of string elements */
1474   LANG_MAGIC
1475 };
1476
1477 const struct language_defn local_language_defn =
1478 {
1479   "local",
1480   language_auto,
1481   &unknown_builtin_types[0],
1482   range_check_off,
1483   type_check_off,
1484   case_sensitive_on,
1485   unk_lang_parser,
1486   unk_lang_error,
1487   evaluate_subexp_standard,
1488   unk_lang_printchar,           /* Print character constant */
1489   unk_lang_printstr,
1490   unk_lang_emit_char,
1491   unk_lang_create_fundamental_type,
1492   unk_lang_print_type,          /* Print a type using appropriate syntax */
1493   unk_lang_val_print,           /* Print a value using appropriate syntax */
1494   unk_lang_value_print,         /* Print a top-level value */
1495   {"", "", "", ""},             /* Binary format info */
1496   {"0%lo", "0", "o", ""},       /* Octal format info */
1497   {"%ld", "", "d", ""},         /* Decimal format info */
1498   {"0x%lx", "0x", "x", ""},     /* Hex format info */
1499   unk_op_print_tab,             /* expression operators for printing */
1500   1,                            /* c-style arrays */
1501   0,                            /* String lower bound */
1502   &builtin_type_char,           /* Type of string elements */
1503   LANG_MAGIC
1504 };
1505 \f
1506 /* Initialize the language routines */
1507
1508 void
1509 _initialize_language (void)
1510 {
1511   struct cmd_list_element *set, *show;
1512
1513   /* GDB commands for language specific stuff */
1514
1515   set = add_set_cmd ("language", class_support, var_string_noescape,
1516                      (char *) &language,
1517                      "Set the current source language.",
1518                      &setlist);
1519   show = add_show_from_set (set, &showlist);
1520   set_cmd_cfunc (set, set_language_command);
1521   set_cmd_cfunc (show, show_language_command);
1522
1523   add_prefix_cmd ("check", no_class, set_check,
1524                   "Set the status of the type/range checker.",
1525                   &setchecklist, "set check ", 0, &setlist);
1526   add_alias_cmd ("c", "check", no_class, 1, &setlist);
1527   add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1528
1529   add_prefix_cmd ("check", no_class, show_check,
1530                   "Show the status of the type/range checker.",
1531                   &showchecklist, "show check ", 0, &showlist);
1532   add_alias_cmd ("c", "check", no_class, 1, &showlist);
1533   add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1534
1535   set = add_set_cmd ("type", class_support, var_string_noescape,
1536                      (char *) &type,
1537                      "Set type checking.  (on/warn/off/auto)",
1538                      &setchecklist);
1539   show = add_show_from_set (set, &showchecklist);
1540   set_cmd_cfunc (set, set_type_command);
1541   set_cmd_cfunc (show, show_type_command);
1542
1543   set = add_set_cmd ("range", class_support, var_string_noescape,
1544                      (char *) &range,
1545                      "Set range checking.  (on/warn/off/auto)",
1546                      &setchecklist);
1547   show = add_show_from_set (set, &showchecklist);
1548   set_cmd_cfunc (set, set_range_command);
1549   set_cmd_cfunc (show, show_range_command);
1550
1551   set = add_set_cmd ("case-sensitive", class_support, var_string_noescape,
1552                      (char *) &case_sensitive,
1553                      "Set case sensitivity in name search.  (on/off/auto)\n\
1554 For Fortran the default is off; for other languages the default is on.",
1555                      &setlist);
1556   show = add_show_from_set (set, &showlist);
1557   set_cmd_cfunc (set, set_case_command);
1558   set_cmd_cfunc (show, show_case_command);
1559
1560   add_language (&unknown_language_defn);
1561   add_language (&local_language_defn);
1562   add_language (&auto_language_defn);
1563
1564   language = savestring ("auto", strlen ("auto"));
1565   type = savestring ("auto", strlen ("auto"));
1566   range = savestring ("auto", strlen ("auto"));
1567   case_sensitive = savestring ("auto",strlen ("auto"));
1568
1569   /* Have the above take effect */
1570   set_language (language_auto);
1571 }