1 /* Multiple source language support for GDB. 2 3 Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 4 2002, 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. 5 6 Contributed by the Department of Computer Science at the State University 7 of New York at Buffalo. 8 9 This file is part of GDB. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 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 #include "demangle.h" 46 #include "symfile.h" 47 48 extern void _initialize_language (void); 49 50 static void unk_lang_error (char *); 51 52 static int unk_lang_parser (void); 53 54 static void show_check (char *, int); 55 56 static void set_check (char *, int); 57 58 static void set_type_range_case (void); 59 60 static void unk_lang_emit_char (int c, struct type *type, 61 struct ui_file *stream, int quoter); 62 63 static void unk_lang_printchar (int c, struct type *type, 64 struct ui_file *stream); 65 66 static void unk_lang_print_type (struct type *, char *, struct ui_file *, 67 int, int); 68 69 static int unk_lang_value_print (struct value *, struct ui_file *, 70 const struct value_print_options *); 71 72 static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc); 73 74 /* Forward declaration */ 75 extern const struct language_defn unknown_language_defn; 76 77 /* The current (default at startup) state of type and range checking. 78 (If the modes are set to "auto", though, these are changed based 79 on the default language at startup, and then again based on the 80 language of the first source file. */ 81 82 enum range_mode range_mode = range_mode_auto; 83 enum range_check range_check = range_check_off; 84 enum type_mode type_mode = type_mode_auto; 85 enum type_check type_check = type_check_off; 86 enum case_mode case_mode = case_mode_auto; 87 enum case_sensitivity case_sensitivity = case_sensitive_on; 88 89 /* The current language and language_mode (see language.h) */ 90 91 const struct language_defn *current_language = &unknown_language_defn; 92 enum language_mode language_mode = language_mode_auto; 93 94 /* The language that the user expects to be typing in (the language 95 of main(), or the last language we notified them about, or C). */ 96 97 const struct language_defn *expected_language; 98 99 /* The list of supported languages. The list itself is malloc'd. */ 100 101 static const struct language_defn **languages; 102 static unsigned languages_size; 103 static unsigned languages_allocsize; 104 #define DEFAULT_ALLOCSIZE 4 105 106 /* The current values of the "set language/type/range" enum 107 commands. */ 108 static const char *language; 109 static const char *type; 110 static const char *range; 111 static const char *case_sensitive; 112 113 /* Warning issued when current_language and the language of the current 114 frame do not match. */ 115 char lang_frame_mismatch_warn[] = 116 "Warning: the current language does not match this frame."; 117 118 /* This page contains the functions corresponding to GDB commands 119 and their helpers. */ 120 121 /* Show command. Display a warning if the language set 122 does not match the frame. */ 123 static void 124 show_language_command (struct ui_file *file, int from_tty, 125 struct cmd_list_element *c, const char *value) 126 { 127 enum language flang; /* The language of the current frame */ 128 129 if (language_mode == language_mode_auto) 130 fprintf_filtered (gdb_stdout, 131 _("The current source language is " 132 "\"auto; currently %s\".\n"), 133 current_language->la_name); 134 else 135 fprintf_filtered (gdb_stdout, _("The current source language is \"%s\".\n"), 136 current_language->la_name); 137 138 flang = get_frame_language (); 139 if (flang != language_unknown && 140 language_mode == language_mode_manual && 141 current_language->la_language != flang) 142 printf_filtered ("%s\n", lang_frame_mismatch_warn); 143 } 144 145 /* Set command. Change the current working language. */ 146 static void 147 set_language_command (char *ignore, int from_tty, struct cmd_list_element *c) 148 { 149 int i; 150 enum language flang; 151 152 /* Search the list of languages for a match. */ 153 for (i = 0; i < languages_size; i++) 154 { 155 if (strcmp (languages[i]->la_name, language) == 0) 156 { 157 /* Found it! Go into manual mode, and use this language. */ 158 if (languages[i]->la_language == language_auto) 159 { 160 /* Enter auto mode. Set to the current frame's language, if 161 known, or fallback to the initial language. */ 162 language_mode = language_mode_auto; 163 flang = get_frame_language (); 164 if (flang != language_unknown) 165 set_language (flang); 166 else 167 set_initial_language (); 168 expected_language = current_language; 169 return; 170 } 171 else 172 { 173 /* Enter manual mode. Set the specified language. */ 174 language_mode = language_mode_manual; 175 current_language = languages[i]; 176 set_type_range_case (); 177 expected_language = current_language; 178 return; 179 } 180 } 181 } 182 183 internal_error (__FILE__, __LINE__, 184 "Couldn't find language `%s' in known languages list.", 185 language); 186 } 187 188 /* Show command. Display a warning if the type setting does 189 not match the current language. */ 190 static void 191 show_type_command (struct ui_file *file, int from_tty, 192 struct cmd_list_element *c, const char *value) 193 { 194 if (type_mode == type_mode_auto) 195 { 196 char *tmp = NULL; 197 198 switch (type_check) 199 { 200 case type_check_on: 201 tmp = "on"; 202 break; 203 case type_check_off: 204 tmp = "off"; 205 break; 206 case type_check_warn: 207 tmp = "warn"; 208 break; 209 default: 210 internal_error (__FILE__, __LINE__, 211 "Unrecognized type check setting."); 212 } 213 214 fprintf_filtered (gdb_stdout, 215 _("Type checking is \"auto; currently %s\".\n"), 216 tmp); 217 } 218 else 219 fprintf_filtered (gdb_stdout, _("Type checking is \"%s\".\n"), 220 value); 221 222 if (type_check != current_language->la_type_check) 223 warning (_("the current type check setting" 224 " does not match the language.\n")); 225 } 226 227 /* Set command. Change the setting for type checking. */ 228 static void 229 set_type_command (char *ignore, int from_tty, struct cmd_list_element *c) 230 { 231 if (strcmp (type, "on") == 0) 232 { 233 type_check = type_check_on; 234 type_mode = type_mode_manual; 235 } 236 else if (strcmp (type, "warn") == 0) 237 { 238 type_check = type_check_warn; 239 type_mode = type_mode_manual; 240 } 241 else if (strcmp (type, "off") == 0) 242 { 243 type_check = type_check_off; 244 type_mode = type_mode_manual; 245 } 246 else if (strcmp (type, "auto") == 0) 247 { 248 type_mode = type_mode_auto; 249 set_type_range_case (); 250 return; 251 } 252 else 253 internal_error (__FILE__, __LINE__, 254 _("Unrecognized type check setting: \"%s\""), type); 255 256 if (type_check != current_language->la_type_check) 257 warning (_("the current type check setting" 258 " does not match the language.\n")); 259 } 260 261 /* Show command. Display a warning if the range setting does 262 not match the current language. */ 263 static void 264 show_range_command (struct ui_file *file, int from_tty, 265 struct cmd_list_element *c, const char *value) 266 { 267 if (range_mode == range_mode_auto) 268 { 269 char *tmp; 270 271 switch (range_check) 272 { 273 case range_check_on: 274 tmp = "on"; 275 break; 276 case range_check_off: 277 tmp = "off"; 278 break; 279 case range_check_warn: 280 tmp = "warn"; 281 break; 282 default: 283 internal_error (__FILE__, __LINE__, 284 "Unrecognized range check setting."); 285 } 286 287 fprintf_filtered (gdb_stdout, 288 _("Range checking is \"auto; currently %s\".\n"), 289 tmp); 290 } 291 else 292 fprintf_filtered (gdb_stdout, _("Range checking is \"%s\".\n"), 293 value); 294 295 if (range_check != current_language->la_range_check) 296 warning (_("the current range check setting " 297 "does not match the language.\n")); 298 } 299 300 /* Set command. Change the setting for range checking. */ 301 static void 302 set_range_command (char *ignore, int from_tty, struct cmd_list_element *c) 303 { 304 if (strcmp (range, "on") == 0) 305 { 306 range_check = range_check_on; 307 range_mode = range_mode_manual; 308 } 309 else if (strcmp (range, "warn") == 0) 310 { 311 range_check = range_check_warn; 312 range_mode = range_mode_manual; 313 } 314 else if (strcmp (range, "off") == 0) 315 { 316 range_check = range_check_off; 317 range_mode = range_mode_manual; 318 } 319 else if (strcmp (range, "auto") == 0) 320 { 321 range_mode = range_mode_auto; 322 set_type_range_case (); 323 return; 324 } 325 else 326 { 327 internal_error (__FILE__, __LINE__, 328 _("Unrecognized range check setting: \"%s\""), range); 329 } 330 if (range_check != current_language->la_range_check) 331 warning (_("the current range check setting " 332 "does not match the language.\n")); 333 } 334 335 /* Show command. Display a warning if the case sensitivity setting does 336 not match the current language. */ 337 static void 338 show_case_command (struct ui_file *file, int from_tty, 339 struct cmd_list_element *c, const char *value) 340 { 341 if (case_mode == case_mode_auto) 342 { 343 char *tmp = NULL; 344 345 switch (case_sensitivity) 346 { 347 case case_sensitive_on: 348 tmp = "on"; 349 break; 350 case case_sensitive_off: 351 tmp = "off"; 352 break; 353 default: 354 internal_error (__FILE__, __LINE__, 355 "Unrecognized case-sensitive setting."); 356 } 357 358 fprintf_filtered (gdb_stdout, 359 _("Case sensitivity in " 360 "name search is \"auto; currently %s\".\n"), 361 tmp); 362 } 363 else 364 fprintf_filtered (gdb_stdout, _("Case sensitivity in name search is \"%s\".\n"), 365 value); 366 367 if (case_sensitivity != current_language->la_case_sensitivity) 368 warning (_("the current case sensitivity setting does not match " 369 "the language.\n")); 370 } 371 372 /* Set command. Change the setting for case sensitivity. */ 373 374 static void 375 set_case_command (char *ignore, int from_tty, struct cmd_list_element *c) 376 { 377 if (strcmp (case_sensitive, "on") == 0) 378 { 379 case_sensitivity = case_sensitive_on; 380 case_mode = case_mode_manual; 381 } 382 else if (strcmp (case_sensitive, "off") == 0) 383 { 384 case_sensitivity = case_sensitive_off; 385 case_mode = case_mode_manual; 386 } 387 else if (strcmp (case_sensitive, "auto") == 0) 388 { 389 case_mode = case_mode_auto; 390 set_type_range_case (); 391 return; 392 } 393 else 394 { 395 internal_error (__FILE__, __LINE__, 396 "Unrecognized case-sensitive setting: \"%s\"", 397 case_sensitive); 398 } 399 400 if (case_sensitivity != current_language->la_case_sensitivity) 401 warning (_("the current case sensitivity setting does not match " 402 "the language.\n")); 403 } 404 405 /* Set the status of range and type checking and case sensitivity based on 406 the current modes and the current language. 407 If SHOW is non-zero, then print out the current language, 408 type and range checking status. */ 409 static void 410 set_type_range_case (void) 411 { 412 if (range_mode == range_mode_auto) 413 range_check = current_language->la_range_check; 414 415 if (type_mode == type_mode_auto) 416 type_check = current_language->la_type_check; 417 418 if (case_mode == case_mode_auto) 419 case_sensitivity = current_language->la_case_sensitivity; 420 } 421 422 /* Set current language to (enum language) LANG. Returns previous language. */ 423 424 enum language 425 set_language (enum language lang) 426 { 427 int i; 428 enum language prev_language; 429 430 prev_language = current_language->la_language; 431 432 for (i = 0; i < languages_size; i++) 433 { 434 if (languages[i]->la_language == lang) 435 { 436 current_language = languages[i]; 437 set_type_range_case (); 438 break; 439 } 440 } 441 442 return prev_language; 443 } 444 445 446 /* Print out the current language settings: language, range and 447 type checking. If QUIETLY, print only what has changed. */ 448 449 void 450 language_info (int quietly) 451 { 452 if (quietly && expected_language == current_language) 453 return; 454 455 expected_language = current_language; 456 printf_unfiltered (_("Current language: %s\n"), language); 457 show_language_command (NULL, 1, NULL, NULL); 458 459 if (!quietly) 460 { 461 printf_unfiltered (_("Type checking: %s\n"), type); 462 show_type_command (NULL, 1, NULL, NULL); 463 printf_unfiltered (_("Range checking: %s\n"), range); 464 show_range_command (NULL, 1, NULL, NULL); 465 printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive); 466 show_case_command (NULL, 1, NULL, NULL); 467 } 468 } 469 470 /* Return the result of a binary operation. */ 471 472 #if 0 /* Currently unused */ 473 474 struct type * 475 binop_result_type (struct value *v1, struct value *v2) 476 { 477 int size, uns; 478 struct type *t1 = check_typedef (VALUE_TYPE (v1)); 479 struct type *t2 = check_typedef (VALUE_TYPE (v2)); 480 481 int l1 = TYPE_LENGTH (t1); 482 int l2 = TYPE_LENGTH (t2); 483 484 switch (current_language->la_language) 485 { 486 case language_c: 487 case language_cplus: 488 case language_objc: 489 if (TYPE_CODE (t1) == TYPE_CODE_FLT) 490 return TYPE_CODE (t2) == TYPE_CODE_FLT && l2 > l1 ? 491 VALUE_TYPE (v2) : VALUE_TYPE (v1); 492 else if (TYPE_CODE (t2) == TYPE_CODE_FLT) 493 return TYPE_CODE (t1) == TYPE_CODE_FLT && l1 > l2 ? 494 VALUE_TYPE (v1) : VALUE_TYPE (v2); 495 else if (TYPE_UNSIGNED (t1) && l1 > l2) 496 return VALUE_TYPE (v1); 497 else if (TYPE_UNSIGNED (t2) && l2 > l1) 498 return VALUE_TYPE (v2); 499 else /* Both are signed. Result is the longer type */ 500 return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2); 501 break; 502 case language_m2: 503 /* If we are doing type-checking, l1 should equal l2, so this is 504 not needed. */ 505 return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2); 506 break; 507 } 508 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); 509 return (struct type *) 0; /* For lint */ 510 } 511 512 #endif /* 0 */ 513 #if 0 514 /* This page contains functions that are used in type/range checking. 515 They all return zero if the type/range check fails. 516 517 It is hoped that these will make extending GDB to parse different 518 languages a little easier. These are primarily used in eval.c when 519 evaluating expressions and making sure that their types are correct. 520 Instead of having a mess of conjucted/disjuncted expressions in an "if", 521 the ideas of type can be wrapped up in the following functions. 522 523 Note that some of them are not currently dependent upon which language 524 is currently being parsed. For example, floats are the same in 525 C and Modula-2 (ie. the only floating point type has TYPE_CODE of 526 TYPE_CODE_FLT), while booleans are different. */ 527 528 /* Returns non-zero if its argument is a simple type. This is the same for 529 both Modula-2 and for C. In the C case, TYPE_CODE_CHAR will never occur, 530 and thus will never cause the failure of the test. */ 531 int 532 simple_type (struct type *type) 533 { 534 CHECK_TYPEDEF (type); 535 switch (TYPE_CODE (type)) 536 { 537 case TYPE_CODE_INT: 538 case TYPE_CODE_CHAR: 539 case TYPE_CODE_ENUM: 540 case TYPE_CODE_FLT: 541 case TYPE_CODE_RANGE: 542 case TYPE_CODE_BOOL: 543 return 1; 544 545 default: 546 return 0; 547 } 548 } 549 550 /* Returns non-zero if its argument is of an ordered type. 551 An ordered type is one in which the elements can be tested for the 552 properties of "greater than", "less than", etc, or for which the 553 operations "increment" or "decrement" make sense. */ 554 int 555 ordered_type (struct type *type) 556 { 557 CHECK_TYPEDEF (type); 558 switch (TYPE_CODE (type)) 559 { 560 case TYPE_CODE_INT: 561 case TYPE_CODE_CHAR: 562 case TYPE_CODE_ENUM: 563 case TYPE_CODE_FLT: 564 case TYPE_CODE_RANGE: 565 return 1; 566 567 default: 568 return 0; 569 } 570 } 571 572 /* Returns non-zero if the two types are the same */ 573 int 574 same_type (struct type *arg1, struct type *arg2) 575 { 576 CHECK_TYPEDEF (type); 577 if (structured_type (arg1) ? !structured_type (arg2) : structured_type (arg2)) 578 /* One is structured and one isn't */ 579 return 0; 580 else if (structured_type (arg1) && structured_type (arg2)) 581 return arg1 == arg2; 582 else if (numeric_type (arg1) && numeric_type (arg2)) 583 return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) && 584 (TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2)) 585 ? 1 : 0; 586 else 587 return arg1 == arg2; 588 } 589 590 /* Returns non-zero if the type is integral */ 591 int 592 integral_type (struct type *type) 593 { 594 CHECK_TYPEDEF (type); 595 switch (current_language->la_language) 596 { 597 case language_c: 598 case language_cplus: 599 case language_objc: 600 return (TYPE_CODE (type) != TYPE_CODE_INT) && 601 (TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1; 602 case language_m2: 603 case language_pascal: 604 return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1; 605 default: 606 error (_("Language not supported.")); 607 } 608 } 609 610 /* Returns non-zero if the value is numeric */ 611 int 612 numeric_type (struct type *type) 613 { 614 CHECK_TYPEDEF (type); 615 switch (TYPE_CODE (type)) 616 { 617 case TYPE_CODE_INT: 618 case TYPE_CODE_FLT: 619 return 1; 620 621 default: 622 return 0; 623 } 624 } 625 626 /* Returns non-zero if the value is a character type */ 627 int 628 character_type (struct type *type) 629 { 630 CHECK_TYPEDEF (type); 631 switch (current_language->la_language) 632 { 633 case language_m2: 634 case language_pascal: 635 return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1; 636 637 case language_c: 638 case language_cplus: 639 case language_objc: 640 return (TYPE_CODE (type) == TYPE_CODE_INT) && 641 TYPE_LENGTH (type) == sizeof (char) 642 ? 1 : 0; 643 default: 644 return (0); 645 } 646 } 647 648 /* Returns non-zero if the value is a string type */ 649 int 650 string_type (struct type *type) 651 { 652 CHECK_TYPEDEF (type); 653 switch (current_language->la_language) 654 { 655 case language_m2: 656 case language_pascal: 657 return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1; 658 659 case language_c: 660 case language_cplus: 661 case language_objc: 662 /* C does not have distinct string type. */ 663 return (0); 664 default: 665 return (0); 666 } 667 } 668 669 /* Returns non-zero if the value is a boolean type */ 670 int 671 boolean_type (struct type *type) 672 { 673 CHECK_TYPEDEF (type); 674 if (TYPE_CODE (type) == TYPE_CODE_BOOL) 675 return 1; 676 switch (current_language->la_language) 677 { 678 case language_c: 679 case language_cplus: 680 case language_objc: 681 /* Might be more cleanly handled by having a 682 TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such 683 languages, or a TYPE_CODE_INT_OR_BOOL for C. */ 684 if (TYPE_CODE (type) == TYPE_CODE_INT) 685 return 1; 686 default: 687 break; 688 } 689 return 0; 690 } 691 692 /* Returns non-zero if the value is a floating-point type */ 693 int 694 float_type (struct type *type) 695 { 696 CHECK_TYPEDEF (type); 697 return TYPE_CODE (type) == TYPE_CODE_FLT; 698 } 699 700 /* Returns non-zero if the value is a pointer type */ 701 int 702 pointer_type (struct type *type) 703 { 704 return TYPE_CODE (type) == TYPE_CODE_PTR || 705 TYPE_CODE (type) == TYPE_CODE_REF; 706 } 707 708 /* Returns non-zero if the value is a structured type */ 709 int 710 structured_type (struct type *type) 711 { 712 CHECK_TYPEDEF (type); 713 switch (current_language->la_language) 714 { 715 case language_c: 716 case language_cplus: 717 case language_objc: 718 return (TYPE_CODE (type) == TYPE_CODE_STRUCT) || 719 (TYPE_CODE (type) == TYPE_CODE_UNION) || 720 (TYPE_CODE (type) == TYPE_CODE_ARRAY); 721 case language_pascal: 722 return (TYPE_CODE(type) == TYPE_CODE_STRUCT) || 723 (TYPE_CODE(type) == TYPE_CODE_UNION) || 724 (TYPE_CODE(type) == TYPE_CODE_SET) || 725 (TYPE_CODE(type) == TYPE_CODE_ARRAY); 726 case language_m2: 727 return (TYPE_CODE (type) == TYPE_CODE_STRUCT) || 728 (TYPE_CODE (type) == TYPE_CODE_SET) || 729 (TYPE_CODE (type) == TYPE_CODE_ARRAY); 730 default: 731 return (0); 732 } 733 } 734 #endif 735 736 /* This page contains functions that return info about 737 (struct value) values used in GDB. */ 738 739 /* Returns non-zero if the value VAL represents a true value. */ 740 int 741 value_true (struct value *val) 742 { 743 /* It is possible that we should have some sort of error if a non-boolean 744 value is used in this context. Possibly dependent on some kind of 745 "boolean-checking" option like range checking. But it should probably 746 not depend on the language except insofar as is necessary to identify 747 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean 748 should be an error, probably). */ 749 return !value_logical_not (val); 750 } 751 752 /* This page contains functions for the printing out of 753 error messages that occur during type- and range- 754 checking. */ 755 756 /* These are called when a language fails a type- or range-check. The 757 first argument should be a printf()-style format string, and the 758 rest of the arguments should be its arguments. If 759 [type|range]_check is [type|range]_check_on, an error is printed; 760 if [type|range]_check_warn, a warning; otherwise just the 761 message. */ 762 763 void 764 type_error (const char *string,...) 765 { 766 va_list args; 767 va_start (args, string); 768 769 switch (type_check) 770 { 771 case type_check_warn: 772 vwarning (string, args); 773 break; 774 case type_check_on: 775 verror (string, args); 776 break; 777 case type_check_off: 778 /* FIXME: cagney/2002-01-30: Should this function print anything 779 when type error is off? */ 780 vfprintf_filtered (gdb_stderr, string, args); 781 fprintf_filtered (gdb_stderr, "\n"); 782 break; 783 default: 784 internal_error (__FILE__, __LINE__, _("bad switch")); 785 } 786 va_end (args); 787 } 788 789 void 790 range_error (const char *string,...) 791 { 792 va_list args; 793 va_start (args, string); 794 795 switch (range_check) 796 { 797 case range_check_warn: 798 vwarning (string, args); 799 break; 800 case range_check_on: 801 verror (string, args); 802 break; 803 case range_check_off: 804 /* FIXME: cagney/2002-01-30: Should this function print anything 805 when range error is off? */ 806 vfprintf_filtered (gdb_stderr, string, args); 807 fprintf_filtered (gdb_stderr, "\n"); 808 break; 809 default: 810 internal_error (__FILE__, __LINE__, _("bad switch")); 811 } 812 va_end (args); 813 } 814 815 816 /* This page contains miscellaneous functions */ 817 818 /* Return the language enum for a given language string. */ 819 820 enum language 821 language_enum (char *str) 822 { 823 int i; 824 825 for (i = 0; i < languages_size; i++) 826 if (strcmp (languages[i]->la_name, str) == 0) 827 return languages[i]->la_language; 828 829 return language_unknown; 830 } 831 832 /* Return the language struct for a given language enum. */ 833 834 const struct language_defn * 835 language_def (enum language lang) 836 { 837 int i; 838 839 for (i = 0; i < languages_size; i++) 840 { 841 if (languages[i]->la_language == lang) 842 { 843 return languages[i]; 844 } 845 } 846 return NULL; 847 } 848 849 /* Return the language as a string */ 850 char * 851 language_str (enum language lang) 852 { 853 int i; 854 855 for (i = 0; i < languages_size; i++) 856 { 857 if (languages[i]->la_language == lang) 858 { 859 return languages[i]->la_name; 860 } 861 } 862 return "Unknown"; 863 } 864 865 static void 866 set_check (char *ignore, int from_tty) 867 { 868 printf_unfiltered ( 869 "\"set check\" must be followed by the name of a check subcommand.\n"); 870 help_list (setchecklist, "set check ", -1, gdb_stdout); 871 } 872 873 static void 874 show_check (char *ignore, int from_tty) 875 { 876 cmd_show_list (showchecklist, from_tty, ""); 877 } 878 879 /* Add a language to the set of known languages. */ 880 881 void 882 add_language (const struct language_defn *lang) 883 { 884 /* For the "set language" command. */ 885 static char **language_names = NULL; 886 /* For the "help set language" command. */ 887 char *language_set_doc = NULL; 888 889 int i; 890 struct ui_file *tmp_stream; 891 892 if (lang->la_magic != LANG_MAGIC) 893 { 894 fprintf_unfiltered (gdb_stderr, "Magic number of %s language struct wrong\n", 895 lang->la_name); 896 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); 897 } 898 899 if (!languages) 900 { 901 languages_allocsize = DEFAULT_ALLOCSIZE; 902 languages = (const struct language_defn **) xmalloc 903 (languages_allocsize * sizeof (*languages)); 904 } 905 if (languages_size >= languages_allocsize) 906 { 907 languages_allocsize *= 2; 908 languages = (const struct language_defn **) xrealloc ((char *) languages, 909 languages_allocsize * sizeof (*languages)); 910 } 911 languages[languages_size++] = lang; 912 913 /* Build the language names array, to be used as enumeration in the 914 set language" enum command. */ 915 language_names = xrealloc (language_names, 916 (languages_size + 1) * sizeof (const char *)); 917 for (i = 0; i < languages_size; ++i) 918 language_names[i] = languages[i]->la_name; 919 language_names[i] = NULL; 920 921 /* Build the "help set language" docs. */ 922 tmp_stream = mem_fileopen (); 923 924 fprintf_unfiltered (tmp_stream, _("\ 925 Set the current source language.\n\ 926 The currently understood settings are:\n\n\ 927 local or auto Automatic setting based on source file\n")); 928 929 for (i = 0; i < languages_size; ++i) 930 { 931 /* Already dealt with these above. */ 932 if (languages[i]->la_language == language_unknown 933 || languages[i]->la_language == language_auto) 934 continue; 935 936 /* FIXME: i18n: for now assume that the human-readable name 937 is just a capitalization of the internal name. */ 938 fprintf_unfiltered (tmp_stream, "%-16s Use the %c%s language\n", 939 languages[i]->la_name, 940 /* Capitalize first letter of language 941 name. */ 942 toupper (languages[i]->la_name[0]), 943 languages[i]->la_name + 1); 944 } 945 946 language_set_doc = ui_file_xstrdup (tmp_stream, NULL); 947 ui_file_delete (tmp_stream); 948 949 add_setshow_enum_cmd ("language", class_support, 950 (const char **) language_names, 951 &language, 952 language_set_doc, _("\ 953 Show the current source language."), NULL, 954 set_language_command, 955 show_language_command, 956 &setlist, &showlist); 957 958 xfree (language_set_doc); 959 } 960 961 /* Iterate through all registered languages looking for and calling 962 any non-NULL struct language_defn.skip_trampoline() functions. 963 Return the result from the first that returns non-zero, or 0 if all 964 `fail'. */ 965 CORE_ADDR 966 skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc) 967 { 968 int i; 969 970 for (i = 0; i < languages_size; i++) 971 { 972 if (languages[i]->skip_trampoline) 973 { 974 CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc); 975 if (real_pc) 976 return real_pc; 977 } 978 } 979 980 return 0; 981 } 982 983 /* Return demangled language symbol, or NULL. 984 FIXME: Options are only useful for certain languages and ignored 985 by others, so it would be better to remove them here and have a 986 more flexible demangler for the languages that need it. 987 FIXME: Sometimes the demangler is invoked when we don't know the 988 language, so we can't use this everywhere. */ 989 char * 990 language_demangle (const struct language_defn *current_language, 991 const char *mangled, int options) 992 { 993 if (current_language != NULL && current_language->la_demangle) 994 return current_language->la_demangle (mangled, options); 995 return NULL; 996 } 997 998 /* Return class name from physname or NULL. */ 999 char * 1000 language_class_name_from_physname (const struct language_defn *current_language, 1001 const char *physname) 1002 { 1003 if (current_language != NULL && current_language->la_class_name_from_physname) 1004 return current_language->la_class_name_from_physname (physname); 1005 return NULL; 1006 } 1007 1008 /* Return non-zero if TYPE should be passed (and returned) by 1009 reference at the language level. */ 1010 int 1011 language_pass_by_reference (struct type *type) 1012 { 1013 return current_language->la_pass_by_reference (type); 1014 } 1015 1016 /* Return zero; by default, types are passed by value at the language 1017 level. The target ABI may pass or return some structs by reference 1018 independent of this. */ 1019 int 1020 default_pass_by_reference (struct type *type) 1021 { 1022 return 0; 1023 } 1024 1025 /* Return the default string containing the list of characters 1026 delimiting words. This is a reasonable default value that 1027 most languages should be able to use. */ 1028 1029 char * 1030 default_word_break_characters (void) 1031 { 1032 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-"; 1033 } 1034 1035 /* Print the index of array elements using the C99 syntax. */ 1036 1037 void 1038 default_print_array_index (struct value *index_value, struct ui_file *stream, 1039 const struct value_print_options *options) 1040 { 1041 fprintf_filtered (stream, "["); 1042 LA_VALUE_PRINT (index_value, stream, options); 1043 fprintf_filtered (stream, "] = "); 1044 } 1045 1046 void 1047 default_get_string (struct value *value, gdb_byte **buffer, int *length, 1048 const char **charset) 1049 { 1050 error (_("Getting a string is unsupported in this language.")); 1051 } 1052 1053 /* Define the language that is no language. */ 1054 1055 static int 1056 unk_lang_parser (void) 1057 { 1058 return 1; 1059 } 1060 1061 static void 1062 unk_lang_error (char *msg) 1063 { 1064 error (_("Attempted to parse an expression with unknown language")); 1065 } 1066 1067 static void 1068 unk_lang_emit_char (int c, struct type *type, struct ui_file *stream, 1069 int quoter) 1070 { 1071 error (_("internal error - unimplemented function unk_lang_emit_char called.")); 1072 } 1073 1074 static void 1075 unk_lang_printchar (int c, struct type *type, struct ui_file *stream) 1076 { 1077 error (_("internal error - unimplemented function unk_lang_printchar called.")); 1078 } 1079 1080 static void 1081 unk_lang_printstr (struct ui_file *stream, struct type *type, 1082 const gdb_byte *string, unsigned int length, 1083 int force_ellipses, 1084 const struct value_print_options *options) 1085 { 1086 error (_("internal error - unimplemented function unk_lang_printstr called.")); 1087 } 1088 1089 static void 1090 unk_lang_print_type (struct type *type, char *varstring, struct ui_file *stream, 1091 int show, int level) 1092 { 1093 error (_("internal error - unimplemented function unk_lang_print_type called.")); 1094 } 1095 1096 static int 1097 unk_lang_val_print (struct type *type, const gdb_byte *valaddr, 1098 int embedded_offset, CORE_ADDR address, 1099 struct ui_file *stream, int recurse, 1100 const struct value_print_options *options) 1101 { 1102 error (_("internal error - unimplemented function unk_lang_val_print called.")); 1103 } 1104 1105 static int 1106 unk_lang_value_print (struct value *val, struct ui_file *stream, 1107 const struct value_print_options *options) 1108 { 1109 error (_("internal error - unimplemented function unk_lang_value_print called.")); 1110 } 1111 1112 static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc) 1113 { 1114 return 0; 1115 } 1116 1117 /* Unknown languages just use the cplus demangler. */ 1118 static char *unk_lang_demangle (const char *mangled, int options) 1119 { 1120 return cplus_demangle (mangled, options); 1121 } 1122 1123 static char *unk_lang_class_name (const char *mangled) 1124 { 1125 return NULL; 1126 } 1127 1128 static const struct op_print unk_op_print_tab[] = 1129 { 1130 {NULL, OP_NULL, PREC_NULL, 0} 1131 }; 1132 1133 static void 1134 unknown_language_arch_info (struct gdbarch *gdbarch, 1135 struct language_arch_info *lai) 1136 { 1137 lai->string_char_type = builtin_type (gdbarch)->builtin_char; 1138 lai->bool_type_default = builtin_type (gdbarch)->builtin_int; 1139 lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1, 1140 struct type *); 1141 } 1142 1143 const struct language_defn unknown_language_defn = 1144 { 1145 "unknown", 1146 language_unknown, 1147 range_check_off, 1148 type_check_off, 1149 case_sensitive_on, 1150 array_row_major, 1151 macro_expansion_no, 1152 &exp_descriptor_standard, 1153 unk_lang_parser, 1154 unk_lang_error, 1155 null_post_parser, 1156 unk_lang_printchar, /* Print character constant */ 1157 unk_lang_printstr, 1158 unk_lang_emit_char, 1159 unk_lang_print_type, /* Print a type using appropriate syntax */ 1160 default_print_typedef, /* Print a typedef using appropriate syntax */ 1161 unk_lang_val_print, /* Print a value using appropriate syntax */ 1162 unk_lang_value_print, /* Print a top-level value */ 1163 unk_lang_trampoline, /* Language specific skip_trampoline */ 1164 "this", /* name_of_this */ 1165 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 1166 basic_lookup_transparent_type,/* lookup_transparent_type */ 1167 unk_lang_demangle, /* Language specific symbol demangler */ 1168 unk_lang_class_name, /* Language specific class_name_from_physname */ 1169 unk_op_print_tab, /* expression operators for printing */ 1170 1, /* c-style arrays */ 1171 0, /* String lower bound */ 1172 default_word_break_characters, 1173 default_make_symbol_completion_list, 1174 unknown_language_arch_info, /* la_language_arch_info. */ 1175 default_print_array_index, 1176 default_pass_by_reference, 1177 default_get_string, 1178 LANG_MAGIC 1179 }; 1180 1181 /* These two structs define fake entries for the "local" and "auto" options. */ 1182 const struct language_defn auto_language_defn = 1183 { 1184 "auto", 1185 language_auto, 1186 range_check_off, 1187 type_check_off, 1188 case_sensitive_on, 1189 array_row_major, 1190 macro_expansion_no, 1191 &exp_descriptor_standard, 1192 unk_lang_parser, 1193 unk_lang_error, 1194 null_post_parser, 1195 unk_lang_printchar, /* Print character constant */ 1196 unk_lang_printstr, 1197 unk_lang_emit_char, 1198 unk_lang_print_type, /* Print a type using appropriate syntax */ 1199 default_print_typedef, /* Print a typedef using appropriate syntax */ 1200 unk_lang_val_print, /* Print a value using appropriate syntax */ 1201 unk_lang_value_print, /* Print a top-level value */ 1202 unk_lang_trampoline, /* Language specific skip_trampoline */ 1203 "this", /* name_of_this */ 1204 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 1205 basic_lookup_transparent_type,/* lookup_transparent_type */ 1206 unk_lang_demangle, /* Language specific symbol demangler */ 1207 unk_lang_class_name, /* Language specific class_name_from_physname */ 1208 unk_op_print_tab, /* expression operators for printing */ 1209 1, /* c-style arrays */ 1210 0, /* String lower bound */ 1211 default_word_break_characters, 1212 default_make_symbol_completion_list, 1213 unknown_language_arch_info, /* la_language_arch_info. */ 1214 default_print_array_index, 1215 default_pass_by_reference, 1216 default_get_string, 1217 LANG_MAGIC 1218 }; 1219 1220 const struct language_defn local_language_defn = 1221 { 1222 "local", 1223 language_auto, 1224 range_check_off, 1225 type_check_off, 1226 case_sensitive_on, 1227 array_row_major, 1228 macro_expansion_no, 1229 &exp_descriptor_standard, 1230 unk_lang_parser, 1231 unk_lang_error, 1232 null_post_parser, 1233 unk_lang_printchar, /* Print character constant */ 1234 unk_lang_printstr, 1235 unk_lang_emit_char, 1236 unk_lang_print_type, /* Print a type using appropriate syntax */ 1237 default_print_typedef, /* Print a typedef using appropriate syntax */ 1238 unk_lang_val_print, /* Print a value using appropriate syntax */ 1239 unk_lang_value_print, /* Print a top-level value */ 1240 unk_lang_trampoline, /* Language specific skip_trampoline */ 1241 "this", /* name_of_this */ 1242 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 1243 basic_lookup_transparent_type,/* lookup_transparent_type */ 1244 unk_lang_demangle, /* Language specific symbol demangler */ 1245 unk_lang_class_name, /* Language specific class_name_from_physname */ 1246 unk_op_print_tab, /* expression operators for printing */ 1247 1, /* c-style arrays */ 1248 0, /* String lower bound */ 1249 default_word_break_characters, 1250 default_make_symbol_completion_list, 1251 unknown_language_arch_info, /* la_language_arch_info. */ 1252 default_print_array_index, 1253 default_pass_by_reference, 1254 default_get_string, 1255 LANG_MAGIC 1256 }; 1257 1258 /* Per-architecture language information. */ 1259 1260 static struct gdbarch_data *language_gdbarch_data; 1261 1262 struct language_gdbarch 1263 { 1264 /* A vector of per-language per-architecture info. Indexed by "enum 1265 language". */ 1266 struct language_arch_info arch_info[nr_languages]; 1267 }; 1268 1269 static void * 1270 language_gdbarch_post_init (struct gdbarch *gdbarch) 1271 { 1272 struct language_gdbarch *l; 1273 int i; 1274 1275 l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch); 1276 for (i = 0; i < languages_size; i++) 1277 { 1278 if (languages[i] != NULL 1279 && languages[i]->la_language_arch_info != NULL) 1280 languages[i]->la_language_arch_info 1281 (gdbarch, l->arch_info + languages[i]->la_language); 1282 } 1283 return l; 1284 } 1285 1286 struct type * 1287 language_string_char_type (const struct language_defn *la, 1288 struct gdbarch *gdbarch) 1289 { 1290 struct language_gdbarch *ld = gdbarch_data (gdbarch, 1291 language_gdbarch_data); 1292 return ld->arch_info[la->la_language].string_char_type; 1293 } 1294 1295 struct type * 1296 language_bool_type (const struct language_defn *la, 1297 struct gdbarch *gdbarch) 1298 { 1299 struct language_gdbarch *ld = gdbarch_data (gdbarch, 1300 language_gdbarch_data); 1301 1302 if (ld->arch_info[la->la_language].bool_type_symbol) 1303 { 1304 struct symbol *sym; 1305 sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol, 1306 NULL, VAR_DOMAIN, NULL); 1307 if (sym) 1308 { 1309 struct type *type = SYMBOL_TYPE (sym); 1310 if (type && TYPE_CODE (type) == TYPE_CODE_BOOL) 1311 return type; 1312 } 1313 } 1314 1315 return ld->arch_info[la->la_language].bool_type_default; 1316 } 1317 1318 struct type * 1319 language_lookup_primitive_type_by_name (const struct language_defn *la, 1320 struct gdbarch *gdbarch, 1321 const char *name) 1322 { 1323 struct language_gdbarch *ld = gdbarch_data (gdbarch, 1324 language_gdbarch_data); 1325 struct type *const *p; 1326 for (p = ld->arch_info[la->la_language].primitive_type_vector; 1327 (*p) != NULL; 1328 p++) 1329 { 1330 if (strcmp (TYPE_NAME (*p), name) == 0) 1331 return (*p); 1332 } 1333 return (NULL); 1334 } 1335 1336 /* Initialize the language routines */ 1337 1338 void 1339 _initialize_language (void) 1340 { 1341 static const char *type_or_range_names[] 1342 = { "on", "off", "warn", "auto", NULL }; 1343 1344 static const char *case_sensitive_names[] 1345 = { "on", "off", "auto", NULL }; 1346 1347 language_gdbarch_data 1348 = gdbarch_data_register_post_init (language_gdbarch_post_init); 1349 1350 /* GDB commands for language specific stuff */ 1351 1352 add_prefix_cmd ("check", no_class, set_check, 1353 _("Set the status of the type/range checker."), 1354 &setchecklist, "set check ", 0, &setlist); 1355 add_alias_cmd ("c", "check", no_class, 1, &setlist); 1356 add_alias_cmd ("ch", "check", no_class, 1, &setlist); 1357 1358 add_prefix_cmd ("check", no_class, show_check, 1359 _("Show the status of the type/range checker."), 1360 &showchecklist, "show check ", 0, &showlist); 1361 add_alias_cmd ("c", "check", no_class, 1, &showlist); 1362 add_alias_cmd ("ch", "check", no_class, 1, &showlist); 1363 1364 add_setshow_enum_cmd ("type", class_support, type_or_range_names, &type, _("\ 1365 Set type checking. (on/warn/off/auto)"), _("\ 1366 Show type checking. (on/warn/off/auto)"), NULL, 1367 set_type_command, 1368 show_type_command, 1369 &setchecklist, &showchecklist); 1370 1371 add_setshow_enum_cmd ("range", class_support, type_or_range_names, 1372 &range, _("\ 1373 Set range checking. (on/warn/off/auto)"), _("\ 1374 Show range checking. (on/warn/off/auto)"), NULL, 1375 set_range_command, 1376 show_range_command, 1377 &setchecklist, &showchecklist); 1378 1379 add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names, 1380 &case_sensitive, _("\ 1381 Set case sensitivity in name search. (on/off/auto)"), _("\ 1382 Show case sensitivity in name search. (on/off/auto)"), _("\ 1383 For Fortran the default is off; for other languages the default is on."), 1384 set_case_command, 1385 show_case_command, 1386 &setlist, &showlist); 1387 1388 add_language (&auto_language_defn); 1389 add_language (&local_language_defn); 1390 add_language (&unknown_language_defn); 1391 1392 language = xstrdup ("auto"); 1393 type = xstrdup ("auto"); 1394 range = xstrdup ("auto"); 1395 case_sensitive = xstrdup ("auto"); 1396 1397 /* Have the above take effect */ 1398 set_language (language_auto); 1399 } 1400