gdb/language.c

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