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