1/* C language support routines for GDB, the GNU debugger. 2 3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003, 4 2004, 2005, 2007 Free Software Foundation, Inc. 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 3 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, see <http://www.gnu.org/licenses/>. */ 20 21#include "defs.h" 22#include "symtab.h" 23#include "gdbtypes.h" 24#include "expression.h" 25#include "parser-defs.h" 26#include "language.h" 27#include "c-lang.h" 28#include "valprint.h" 29#include "macroscope.h" 30#include "gdb_assert.h" 31#include "charset.h" 32#include "gdb_string.h" 33#include "demangle.h" 34#include "cp-abi.h" 35#include "cp-support.h" 36 37extern void _initialize_c_language (void); 38static void c_emit_char (int c, struct ui_file * stream, int quoter); 39 40/* Print the character C on STREAM as part of the contents of a literal 41 string whose delimiter is QUOTER. Note that that format for printing 42 characters and strings is language specific. */ 43 44static void 45c_emit_char (int c, struct ui_file *stream, int quoter) 46{ 47 const char *escape; 48 int host_char; 49 50 c &= 0xFF; /* Avoid sign bit follies */ 51 52 escape = c_target_char_has_backslash_escape (c); 53 if (escape) 54 { 55 if (quoter == '"' && strcmp (escape, "0") == 0) 56 /* Print nulls embedded in double quoted strings as \000 to 57 prevent ambiguity. */ 58 fprintf_filtered (stream, "\\000"); 59 else 60 fprintf_filtered (stream, "\\%s", escape); 61 } 62 else if (target_char_to_host (c, &host_char) 63 && host_char_print_literally (host_char)) 64 { 65 if (host_char == '\\' || host_char == quoter) 66 fputs_filtered ("\\", stream); 67 fprintf_filtered (stream, "%c", host_char); 68 } 69 else 70 fprintf_filtered (stream, "\\%.3o", (unsigned int) c); 71} 72 73void 74c_printchar (int c, struct ui_file *stream) 75{ 76 fputc_filtered ('\'', stream); 77 LA_EMIT_CHAR (c, stream, '\''); 78 fputc_filtered ('\'', stream); 79} 80 81/* Print the character string STRING, printing at most LENGTH characters. 82 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes 83 long. Printing stops early if the number hits print_max; repeat counts are 84 printed as appropriate. Print ellipses at the end if we had to stop before 85 printing LENGTH characters, or if FORCE_ELLIPSES. */ 86 87void 88c_printstr (struct ui_file *stream, const gdb_byte *string, 89 unsigned int length, int width, int force_ellipses) 90{ 91 unsigned int i; 92 unsigned int things_printed = 0; 93 int in_quotes = 0; 94 int need_comma = 0; 95 96 /* If the string was not truncated due to `set print elements', and 97 the last byte of it is a null, we don't print that, in traditional C 98 style. */ 99 if (!force_ellipses 100 && length > 0 101 && (extract_unsigned_integer (string + (length - 1) * width, width) 102 == '\0')) 103 length--; 104 105 if (length == 0) 106 { 107 fputs_filtered ("\"\"", stream); 108 return; 109 } 110 111 for (i = 0; i < length && things_printed < print_max; ++i) 112 { 113 /* Position of the character we are examining 114 to see whether it is repeated. */ 115 unsigned int rep1; 116 /* Number of repetitions we have detected so far. */ 117 unsigned int reps; 118 unsigned long current_char; 119 120 QUIT; 121 122 if (need_comma) 123 { 124 fputs_filtered (", ", stream); 125 need_comma = 0; 126 } 127 128 current_char = extract_unsigned_integer (string + i * width, width); 129 130 rep1 = i + 1; 131 reps = 1; 132 while (rep1 < length 133 && extract_unsigned_integer (string + rep1 * width, width) 134 == current_char) 135 { 136 ++rep1; 137 ++reps; 138 } 139 140 if (reps > repeat_count_threshold) 141 { 142 if (in_quotes) 143 { 144 if (inspect_it) 145 fputs_filtered ("\\\", ", stream); 146 else 147 fputs_filtered ("\", ", stream); 148 in_quotes = 0; 149 } 150 LA_PRINT_CHAR (current_char, stream); 151 fprintf_filtered (stream, _(" <repeats %u times>"), reps); 152 i = rep1 - 1; 153 things_printed += repeat_count_threshold; 154 need_comma = 1; 155 } 156 else 157 { 158 if (!in_quotes) 159 { 160 if (inspect_it) 161 fputs_filtered ("\\\"", stream); 162 else 163 fputs_filtered ("\"", stream); 164 in_quotes = 1; 165 } 166 LA_EMIT_CHAR (current_char, stream, '"'); 167 ++things_printed; 168 } 169 } 170 171 /* Terminate the quotes if necessary. */ 172 if (in_quotes) 173 { 174 if (inspect_it) 175 fputs_filtered ("\\\"", stream); 176 else 177 fputs_filtered ("\"", stream); 178 } 179 180 if (force_ellipses || i < length) 181 fputs_filtered ("...", stream); 182} 183 184/* Create a fundamental C type using default reasonable for the current 185 target machine. 186 187 Some object/debugging file formats (DWARF version 1, COFF, etc) do not 188 define fundamental types such as "int" or "double". Others (stabs or 189 DWARF version 2, etc) do define fundamental types. For the formats which 190 don't provide fundamental types, gdb can create such types using this 191 function. 192 193 FIXME: Some compilers distinguish explicitly signed integral types 194 (signed short, signed int, signed long) from "regular" integral types 195 (short, int, long) in the debugging information. There is some dis- 196 agreement as to how useful this feature is. In particular, gcc does 197 not support this. Also, only some debugging formats allow the 198 distinction to be passed on to a debugger. For now, we always just 199 use "short", "int", or "long" as the type name, for both the implicit 200 and explicitly signed types. This also makes life easier for the 201 gdb test suite since we don't have to account for the differences 202 in output depending upon what the compiler and debugging format 203 support. We will probably have to re-examine the issue when gdb 204 starts taking its fundamental type information directly from the 205 debugging information supplied by the compiler. fnf@cygnus.com */ 206 207struct type * 208c_create_fundamental_type (struct objfile *objfile, int typeid) 209{ 210 struct type *type = NULL; 211 212 switch (typeid) 213 { 214 default: 215 /* FIXME: For now, if we are asked to produce a type not in this 216 language, create the equivalent of a C integer type with the 217 name "<?type?>". When all the dust settles from the type 218 reconstruction work, this should probably become an error. */ 219 type = init_type (TYPE_CODE_INT, 220 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, 221 0, "<?type?>", objfile); 222 warning (_("internal error: no C/C++ fundamental type %d"), typeid); 223 break; 224 case FT_VOID: 225 type = init_type (TYPE_CODE_VOID, 226 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 227 0, "void", objfile); 228 break; 229 case FT_BOOLEAN: 230 type = init_type (TYPE_CODE_BOOL, 231 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 232 0, "bool", objfile); 233 break; 234 case FT_CHAR: 235 type = init_type (TYPE_CODE_INT, 236 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 237 TYPE_FLAG_NOSIGN, "char", objfile); 238 break; 239 case FT_SIGNED_CHAR: 240 type = init_type (TYPE_CODE_INT, 241 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 242 0, "signed char", objfile); 243 break; 244 case FT_UNSIGNED_CHAR: 245 type = init_type (TYPE_CODE_INT, 246 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 247 TYPE_FLAG_UNSIGNED, "unsigned char", objfile); 248 break; 249 case FT_SHORT: 250 type = init_type (TYPE_CODE_INT, 251 gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT, 252 0, "short", objfile); 253 break; 254 case FT_SIGNED_SHORT: 255 type = init_type (TYPE_CODE_INT, 256 gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT, 257 0, "short", objfile); /* FIXME-fnf */ 258 break; 259 case FT_UNSIGNED_SHORT: 260 type = init_type (TYPE_CODE_INT, 261 gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT, 262 TYPE_FLAG_UNSIGNED, "unsigned short", objfile); 263 break; 264 case FT_INTEGER: 265 type = init_type (TYPE_CODE_INT, 266 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, 267 0, "int", objfile); 268 break; 269 case FT_SIGNED_INTEGER: 270 type = init_type (TYPE_CODE_INT, 271 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, 272 0, "int", objfile); /* FIXME -fnf */ 273 break; 274 case FT_UNSIGNED_INTEGER: 275 type = init_type (TYPE_CODE_INT, 276 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, 277 TYPE_FLAG_UNSIGNED, "unsigned int", objfile); 278 break; 279 case FT_LONG: 280 type = init_type (TYPE_CODE_INT, 281 gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT, 282 0, "long", objfile); 283 break; 284 case FT_SIGNED_LONG: 285 type = init_type (TYPE_CODE_INT, 286 gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT, 287 0, "long", objfile); /* FIXME -fnf */ 288 break; 289 case FT_UNSIGNED_LONG: 290 type = init_type (TYPE_CODE_INT, 291 gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT, 292 TYPE_FLAG_UNSIGNED, "unsigned long", objfile); 293 break; 294 case FT_LONG_LONG: 295 type = init_type (TYPE_CODE_INT, 296 gdbarch_long_long_bit (current_gdbarch) 297 / TARGET_CHAR_BIT, 298 0, "long long", objfile); 299 break; 300 case FT_SIGNED_LONG_LONG: 301 type = init_type (TYPE_CODE_INT, 302 gdbarch_long_long_bit (current_gdbarch) 303 / TARGET_CHAR_BIT, 304 0, "signed long long", objfile); 305 break; 306 case FT_UNSIGNED_LONG_LONG: 307 type = init_type (TYPE_CODE_INT, 308 gdbarch_long_long_bit (current_gdbarch) 309 / TARGET_CHAR_BIT, 310 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile); 311 break; 312 case FT_FLOAT: 313 type = init_type (TYPE_CODE_FLT, 314 gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT, 315 0, "float", objfile); 316 break; 317 case FT_DBL_PREC_FLOAT: 318 type = init_type (TYPE_CODE_FLT, 319 gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT, 320 0, "double", objfile); 321 break; 322 case FT_EXT_PREC_FLOAT: 323 type = init_type (TYPE_CODE_FLT, 324 gdbarch_long_double_bit (current_gdbarch) 325 / TARGET_CHAR_BIT, 326 0, "long double", objfile); 327 break; 328 case FT_COMPLEX: 329 type = init_type (TYPE_CODE_FLT, 330 2 * gdbarch_float_bit (current_gdbarch) 331 / TARGET_CHAR_BIT, 332 0, "complex float", objfile); 333 TYPE_TARGET_TYPE (type) 334 = init_type (TYPE_CODE_FLT, 335 gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT, 336 0, "float", objfile); 337 break; 338 case FT_DBL_PREC_COMPLEX: 339 type = init_type (TYPE_CODE_FLT, 340 2 * gdbarch_double_bit (current_gdbarch) 341 / TARGET_CHAR_BIT, 342 0, "complex double", objfile); 343 TYPE_TARGET_TYPE (type) 344 = init_type (TYPE_CODE_FLT, 345 gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT, 346 0, "double", objfile); 347 break; 348 case FT_EXT_PREC_COMPLEX: 349 type = init_type (TYPE_CODE_FLT, 350 2 * gdbarch_long_double_bit (current_gdbarch) 351 / TARGET_CHAR_BIT, 352 0, "complex long double", objfile); 353 TYPE_TARGET_TYPE (type) 354 = init_type (TYPE_CODE_FLT, 355 gdbarch_long_double_bit (current_gdbarch) 356 / TARGET_CHAR_BIT, 357 0, "long double", objfile); 358 break; 359 case FT_TEMPLATE_ARG: 360 type = init_type (TYPE_CODE_TEMPLATE_ARG, 361 0, 362 0, "<template arg>", objfile); 363 break; 364 } 365 return (type); 366} 367 368/* Preprocessing and parsing C and C++ expressions. */ 369 370 371/* When we find that lexptr (the global var defined in parse.c) is 372 pointing at a macro invocation, we expand the invocation, and call 373 scan_macro_expansion to save the old lexptr here and point lexptr 374 into the expanded text. When we reach the end of that, we call 375 end_macro_expansion to pop back to the value we saved here. The 376 macro expansion code promises to return only fully-expanded text, 377 so we don't need to "push" more than one level. 378 379 This is disgusting, of course. It would be cleaner to do all macro 380 expansion beforehand, and then hand that to lexptr. But we don't 381 really know where the expression ends. Remember, in a command like 382 383 (gdb) break *ADDRESS if CONDITION 384 385 we evaluate ADDRESS in the scope of the current frame, but we 386 evaluate CONDITION in the scope of the breakpoint's location. So 387 it's simply wrong to try to macro-expand the whole thing at once. */ 388static char *macro_original_text; 389static char *macro_expanded_text; 390 391 392void 393scan_macro_expansion (char *expansion) 394{ 395 /* We'd better not be trying to push the stack twice. */ 396 gdb_assert (! macro_original_text); 397 gdb_assert (! macro_expanded_text); 398 399 /* Save the old lexptr value, so we can return to it when we're done 400 parsing the expanded text. */ 401 macro_original_text = lexptr; 402 lexptr = expansion; 403 404 /* Save the expanded text, so we can free it when we're finished. */ 405 macro_expanded_text = expansion; 406} 407 408 409int 410scanning_macro_expansion (void) 411{ 412 return macro_original_text != 0; 413} 414 415 416void 417finished_macro_expansion (void) 418{ 419 /* There'd better be something to pop back to, and we better have 420 saved a pointer to the start of the expanded text. */ 421 gdb_assert (macro_original_text); 422 gdb_assert (macro_expanded_text); 423 424 /* Pop back to the original text. */ 425 lexptr = macro_original_text; 426 macro_original_text = 0; 427 428 /* Free the expanded text. */ 429 xfree (macro_expanded_text); 430 macro_expanded_text = 0; 431} 432 433 434static void 435scan_macro_cleanup (void *dummy) 436{ 437 if (macro_original_text) 438 finished_macro_expansion (); 439} 440 441 442/* We set these global variables before calling c_parse, to tell it 443 how it to find macro definitions for the expression at hand. */ 444macro_lookup_ftype *expression_macro_lookup_func; 445void *expression_macro_lookup_baton; 446 447 448static struct macro_definition * 449null_macro_lookup (const char *name, void *baton) 450{ 451 return 0; 452} 453 454 455static int 456c_preprocess_and_parse (void) 457{ 458 /* Set up a lookup function for the macro expander. */ 459 struct macro_scope *scope = 0; 460 struct cleanup *back_to = make_cleanup (free_current_contents, &scope); 461 462 if (expression_context_block) 463 scope = sal_macro_scope (find_pc_line (expression_context_pc, 0)); 464 else 465 scope = default_macro_scope (); 466 467 if (scope) 468 { 469 expression_macro_lookup_func = standard_macro_lookup; 470 expression_macro_lookup_baton = (void *) scope; 471 } 472 else 473 { 474 expression_macro_lookup_func = null_macro_lookup; 475 expression_macro_lookup_baton = 0; 476 } 477 478 gdb_assert (! macro_original_text); 479 make_cleanup (scan_macro_cleanup, 0); 480 481 { 482 int result = c_parse (); 483 do_cleanups (back_to); 484 return result; 485 } 486} 487 488 489 490/* Table mapping opcodes into strings for printing operators 491 and precedences of the operators. */ 492 493const struct op_print c_op_print_tab[] = 494{ 495 {",", BINOP_COMMA, PREC_COMMA, 0}, 496 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, 497 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, 498 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, 499 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0}, 500 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0}, 501 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0}, 502 {"==", BINOP_EQUAL, PREC_EQUAL, 0}, 503 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, 504 {"<=", BINOP_LEQ, PREC_ORDER, 0}, 505 {">=", BINOP_GEQ, PREC_ORDER, 0}, 506 {">", BINOP_GTR, PREC_ORDER, 0}, 507 {"<", BINOP_LESS, PREC_ORDER, 0}, 508 {">>", BINOP_RSH, PREC_SHIFT, 0}, 509 {"<<", BINOP_LSH, PREC_SHIFT, 0}, 510 {"+", BINOP_ADD, PREC_ADD, 0}, 511 {"-", BINOP_SUB, PREC_ADD, 0}, 512 {"*", BINOP_MUL, PREC_MUL, 0}, 513 {"/", BINOP_DIV, PREC_MUL, 0}, 514 {"%", BINOP_REM, PREC_MUL, 0}, 515 {"@", BINOP_REPEAT, PREC_REPEAT, 0}, 516 {"-", UNOP_NEG, PREC_PREFIX, 0}, 517 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, 518 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0}, 519 {"*", UNOP_IND, PREC_PREFIX, 0}, 520 {"&", UNOP_ADDR, PREC_PREFIX, 0}, 521 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, 522 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, 523 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, 524 {NULL, 0, 0, 0} 525}; 526 527enum c_primitive_types { 528 c_primitive_type_int, 529 c_primitive_type_long, 530 c_primitive_type_short, 531 c_primitive_type_char, 532 c_primitive_type_float, 533 c_primitive_type_double, 534 c_primitive_type_void, 535 c_primitive_type_long_long, 536 c_primitive_type_signed_char, 537 c_primitive_type_unsigned_char, 538 c_primitive_type_unsigned_short, 539 c_primitive_type_unsigned_int, 540 c_primitive_type_unsigned_long, 541 c_primitive_type_unsigned_long_long, 542 c_primitive_type_long_double, 543 c_primitive_type_complex, 544 c_primitive_type_double_complex, 545 nr_c_primitive_types 546}; 547 548void 549c_language_arch_info (struct gdbarch *gdbarch, 550 struct language_arch_info *lai) 551{ 552 const struct builtin_type *builtin = builtin_type (gdbarch); 553 lai->string_char_type = builtin->builtin_char; 554 lai->primitive_type_vector 555 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1, 556 struct type *); 557 lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int; 558 lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long; 559 lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short; 560 lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char; 561 lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float; 562 lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double; 563 lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void; 564 lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long; 565 lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char; 566 lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char; 567 lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short; 568 lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int; 569 lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long; 570 lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long; 571 lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double; 572 lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex; 573 lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex; 574} 575 576const struct language_defn c_language_defn = 577{ 578 "c", /* Language name */ 579 language_c, 580 NULL, 581 range_check_off, 582 type_check_off, 583 case_sensitive_on, 584 array_row_major, 585 &exp_descriptor_standard, 586 c_preprocess_and_parse, 587 c_error, 588 null_post_parser, 589 c_printchar, /* Print a character constant */ 590 c_printstr, /* Function to print string constant */ 591 c_emit_char, /* Print a single char */ 592 c_create_fundamental_type, /* Create fundamental type in this language */ 593 c_print_type, /* Print a type using appropriate syntax */ 594 c_val_print, /* Print a value using appropriate syntax */ 595 c_value_print, /* Print a top-level value */ 596 NULL, /* Language specific skip_trampoline */ 597 NULL, /* value_of_this */ 598 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 599 basic_lookup_transparent_type,/* lookup_transparent_type */ 600 NULL, /* Language specific symbol demangler */ 601 NULL, /* Language specific class_name_from_physname */ 602 c_op_print_tab, /* expression operators for printing */ 603 1, /* c-style arrays */ 604 0, /* String lower bound */ 605 NULL, 606 default_word_break_characters, 607 c_language_arch_info, 608 default_print_array_index, 609 LANG_MAGIC 610}; 611 612enum cplus_primitive_types { 613 cplus_primitive_type_int, 614 cplus_primitive_type_long, 615 cplus_primitive_type_short, 616 cplus_primitive_type_char, 617 cplus_primitive_type_float, 618 cplus_primitive_type_double, 619 cplus_primitive_type_void, 620 cplus_primitive_type_long_long, 621 cplus_primitive_type_signed_char, 622 cplus_primitive_type_unsigned_char, 623 cplus_primitive_type_unsigned_short, 624 cplus_primitive_type_unsigned_int, 625 cplus_primitive_type_unsigned_long, 626 cplus_primitive_type_unsigned_long_long, 627 cplus_primitive_type_long_double, 628 cplus_primitive_type_complex, 629 cplus_primitive_type_double_complex, 630 cplus_primitive_type_bool, 631 nr_cplus_primitive_types 632}; 633 634static void 635cplus_language_arch_info (struct gdbarch *gdbarch, 636 struct language_arch_info *lai) 637{ 638 const struct builtin_type *builtin = builtin_type (gdbarch); 639 lai->string_char_type = builtin->builtin_char; 640 lai->primitive_type_vector 641 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1, 642 struct type *); 643 lai->primitive_type_vector [cplus_primitive_type_int] 644 = builtin->builtin_int; 645 lai->primitive_type_vector [cplus_primitive_type_long] 646 = builtin->builtin_long; 647 lai->primitive_type_vector [cplus_primitive_type_short] 648 = builtin->builtin_short; 649 lai->primitive_type_vector [cplus_primitive_type_char] 650 = builtin->builtin_char; 651 lai->primitive_type_vector [cplus_primitive_type_float] 652 = builtin->builtin_float; 653 lai->primitive_type_vector [cplus_primitive_type_double] 654 = builtin->builtin_double; 655 lai->primitive_type_vector [cplus_primitive_type_void] 656 = builtin->builtin_void; 657 lai->primitive_type_vector [cplus_primitive_type_long_long] 658 = builtin->builtin_long_long; 659 lai->primitive_type_vector [cplus_primitive_type_signed_char] 660 = builtin->builtin_signed_char; 661 lai->primitive_type_vector [cplus_primitive_type_unsigned_char] 662 = builtin->builtin_unsigned_char; 663 lai->primitive_type_vector [cplus_primitive_type_unsigned_short] 664 = builtin->builtin_unsigned_short; 665 lai->primitive_type_vector [cplus_primitive_type_unsigned_int] 666 = builtin->builtin_unsigned_int; 667 lai->primitive_type_vector [cplus_primitive_type_unsigned_long] 668 = builtin->builtin_unsigned_long; 669 lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long] 670 = builtin->builtin_unsigned_long_long; 671 lai->primitive_type_vector [cplus_primitive_type_long_double] 672 = builtin->builtin_long_double; 673 lai->primitive_type_vector [cplus_primitive_type_complex] 674 = builtin->builtin_complex; 675 lai->primitive_type_vector [cplus_primitive_type_double_complex] 676 = builtin->builtin_double_complex; 677 lai->primitive_type_vector [cplus_primitive_type_bool] 678 = builtin->builtin_bool; 679} 680 681const struct language_defn cplus_language_defn = 682{ 683 "c++", /* Language name */ 684 language_cplus, 685 NULL, 686 range_check_off, 687 type_check_off, 688 case_sensitive_on, 689 array_row_major, 690 &exp_descriptor_standard, 691 c_preprocess_and_parse, 692 c_error, 693 null_post_parser, 694 c_printchar, /* Print a character constant */ 695 c_printstr, /* Function to print string constant */ 696 c_emit_char, /* Print a single char */ 697 c_create_fundamental_type, /* Create fundamental type in this language */ 698 c_print_type, /* Print a type using appropriate syntax */ 699 c_val_print, /* Print a value using appropriate syntax */ 700 c_value_print, /* Print a top-level value */ 701 cplus_skip_trampoline, /* Language specific skip_trampoline */ 702 value_of_this, /* value_of_this */ 703 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 704 cp_lookup_transparent_type, /* lookup_transparent_type */ 705 cplus_demangle, /* Language specific symbol demangler */ 706 cp_class_name_from_physname, /* Language specific class_name_from_physname */ 707 c_op_print_tab, /* expression operators for printing */ 708 1, /* c-style arrays */ 709 0, /* String lower bound */ 710 NULL, 711 default_word_break_characters, 712 cplus_language_arch_info, 713 default_print_array_index, 714 LANG_MAGIC 715}; 716 717const struct language_defn asm_language_defn = 718{ 719 "asm", /* Language name */ 720 language_asm, 721 NULL, 722 range_check_off, 723 type_check_off, 724 case_sensitive_on, 725 array_row_major, 726 &exp_descriptor_standard, 727 c_preprocess_and_parse, 728 c_error, 729 null_post_parser, 730 c_printchar, /* Print a character constant */ 731 c_printstr, /* Function to print string constant */ 732 c_emit_char, /* Print a single char */ 733 c_create_fundamental_type, /* Create fundamental type in this language */ 734 c_print_type, /* Print a type using appropriate syntax */ 735 c_val_print, /* Print a value using appropriate syntax */ 736 c_value_print, /* Print a top-level value */ 737 NULL, /* Language specific skip_trampoline */ 738 NULL, /* value_of_this */ 739 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 740 basic_lookup_transparent_type,/* lookup_transparent_type */ 741 NULL, /* Language specific symbol demangler */ 742 NULL, /* Language specific class_name_from_physname */ 743 c_op_print_tab, /* expression operators for printing */ 744 1, /* c-style arrays */ 745 0, /* String lower bound */ 746 NULL, 747 default_word_break_characters, 748 c_language_arch_info, /* FIXME: la_language_arch_info. */ 749 default_print_array_index, 750 LANG_MAGIC 751}; 752 753/* The following language_defn does not represent a real language. 754 It just provides a minimal support a-la-C that should allow users 755 to do some simple operations when debugging applications that use 756 a language currently not supported by GDB. */ 757 758const struct language_defn minimal_language_defn = 759{ 760 "minimal", /* Language name */ 761 language_minimal, 762 NULL, 763 range_check_off, 764 type_check_off, 765 case_sensitive_on, 766 array_row_major, 767 &exp_descriptor_standard, 768 c_preprocess_and_parse, 769 c_error, 770 null_post_parser, 771 c_printchar, /* Print a character constant */ 772 c_printstr, /* Function to print string constant */ 773 c_emit_char, /* Print a single char */ 774 c_create_fundamental_type, /* Create fundamental type in this language */ 775 c_print_type, /* Print a type using appropriate syntax */ 776 c_val_print, /* Print a value using appropriate syntax */ 777 c_value_print, /* Print a top-level value */ 778 NULL, /* Language specific skip_trampoline */ 779 NULL, /* value_of_this */ 780 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 781 basic_lookup_transparent_type,/* lookup_transparent_type */ 782 NULL, /* Language specific symbol demangler */ 783 NULL, /* Language specific class_name_from_physname */ 784 c_op_print_tab, /* expression operators for printing */ 785 1, /* c-style arrays */ 786 0, /* String lower bound */ 787 NULL, 788 default_word_break_characters, 789 c_language_arch_info, 790 default_print_array_index, 791 LANG_MAGIC 792}; 793 794void 795_initialize_c_language (void) 796{ 797 add_language (&c_language_defn); 798 add_language (&cplus_language_defn); 799 add_language (&asm_language_defn); 800 add_language (&minimal_language_defn); 801} 802