c-lang.c revision 98944
1/* C language support routines for GDB, the GNU debugger. 2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002 3 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, 20 Boston, MA 02111-1307, USA. */ 21 22#include "defs.h" 23#include "symtab.h" 24#include "gdbtypes.h" 25#include "expression.h" 26#include "parser-defs.h" 27#include "language.h" 28#include "c-lang.h" 29#include "valprint.h" 30 31extern void _initialize_c_language (void); 32static void c_emit_char (int c, struct ui_file * stream, int quoter); 33 34/* Print the character C on STREAM as part of the contents of a literal 35 string whose delimiter is QUOTER. Note that that format for printing 36 characters and strings is language specific. */ 37 38static void 39c_emit_char (register int c, struct ui_file *stream, int quoter) 40{ 41 c &= 0xFF; /* Avoid sign bit follies */ 42 43 if (PRINT_LITERAL_FORM (c)) 44 { 45 if (c == '\\' || c == quoter) 46 { 47 fputs_filtered ("\\", stream); 48 } 49 fprintf_filtered (stream, "%c", c); 50 } 51 else 52 { 53 switch (c) 54 { 55 case '\n': 56 fputs_filtered ("\\n", stream); 57 break; 58 case '\b': 59 fputs_filtered ("\\b", stream); 60 break; 61 case '\t': 62 fputs_filtered ("\\t", stream); 63 break; 64 case '\f': 65 fputs_filtered ("\\f", stream); 66 break; 67 case '\r': 68 fputs_filtered ("\\r", stream); 69 break; 70 case '\013': 71 fputs_filtered ("\\v", stream); 72 break; 73 case '\033': 74 fputs_filtered ("\\e", stream); 75 break; 76 case '\007': 77 fputs_filtered ("\\a", stream); 78 break; 79 case '\0': 80 fputs_filtered ("\\0", stream); 81 break; 82 default: 83 fprintf_filtered (stream, "\\%.3o", (unsigned int) c); 84 break; 85 } 86 } 87} 88 89void 90c_printchar (int c, struct ui_file *stream) 91{ 92 fputc_filtered ('\'', stream); 93 LA_EMIT_CHAR (c, stream, '\''); 94 fputc_filtered ('\'', stream); 95} 96 97/* Print the character string STRING, printing at most LENGTH characters. 98 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes 99 long. Printing stops early if the number hits print_max; repeat counts are 100 printed as appropriate. Print ellipses at the end if we had to stop before 101 printing LENGTH characters, or if FORCE_ELLIPSES. */ 102 103void 104c_printstr (struct ui_file *stream, char *string, unsigned int length, 105 int width, int force_ellipses) 106{ 107 register unsigned int i; 108 unsigned int things_printed = 0; 109 int in_quotes = 0; 110 int need_comma = 0; 111 extern int inspect_it; 112 113 /* If the string was not truncated due to `set print elements', and 114 the last byte of it is a null, we don't print that, in traditional C 115 style. */ 116 if (!force_ellipses 117 && length > 0 118 && (extract_unsigned_integer (string + (length - 1) * width, width) 119 == '\0')) 120 length--; 121 122 if (length == 0) 123 { 124 fputs_filtered ("\"\"", stream); 125 return; 126 } 127 128 for (i = 0; i < length && things_printed < print_max; ++i) 129 { 130 /* Position of the character we are examining 131 to see whether it is repeated. */ 132 unsigned int rep1; 133 /* Number of repetitions we have detected so far. */ 134 unsigned int reps; 135 unsigned long current_char; 136 137 QUIT; 138 139 if (need_comma) 140 { 141 fputs_filtered (", ", stream); 142 need_comma = 0; 143 } 144 145 current_char = extract_unsigned_integer (string + i * width, width); 146 147 rep1 = i + 1; 148 reps = 1; 149 while (rep1 < length 150 && extract_unsigned_integer (string + rep1 * width, width) 151 == current_char) 152 { 153 ++rep1; 154 ++reps; 155 } 156 157 if (reps > repeat_count_threshold) 158 { 159 if (in_quotes) 160 { 161 if (inspect_it) 162 fputs_filtered ("\\\", ", stream); 163 else 164 fputs_filtered ("\", ", stream); 165 in_quotes = 0; 166 } 167 LA_PRINT_CHAR (current_char, stream); 168 fprintf_filtered (stream, " <repeats %u times>", reps); 169 i = rep1 - 1; 170 things_printed += repeat_count_threshold; 171 need_comma = 1; 172 } 173 else 174 { 175 if (!in_quotes) 176 { 177 if (inspect_it) 178 fputs_filtered ("\\\"", stream); 179 else 180 fputs_filtered ("\"", stream); 181 in_quotes = 1; 182 } 183 LA_EMIT_CHAR (current_char, stream, '"'); 184 ++things_printed; 185 } 186 } 187 188 /* Terminate the quotes if necessary. */ 189 if (in_quotes) 190 { 191 if (inspect_it) 192 fputs_filtered ("\\\"", stream); 193 else 194 fputs_filtered ("\"", stream); 195 } 196 197 if (force_ellipses || i < length) 198 fputs_filtered ("...", stream); 199} 200 201/* Create a fundamental C type using default reasonable for the current 202 target machine. 203 204 Some object/debugging file formats (DWARF version 1, COFF, etc) do not 205 define fundamental types such as "int" or "double". Others (stabs or 206 DWARF version 2, etc) do define fundamental types. For the formats which 207 don't provide fundamental types, gdb can create such types using this 208 function. 209 210 FIXME: Some compilers distinguish explicitly signed integral types 211 (signed short, signed int, signed long) from "regular" integral types 212 (short, int, long) in the debugging information. There is some dis- 213 agreement as to how useful this feature is. In particular, gcc does 214 not support this. Also, only some debugging formats allow the 215 distinction to be passed on to a debugger. For now, we always just 216 use "short", "int", or "long" as the type name, for both the implicit 217 and explicitly signed types. This also makes life easier for the 218 gdb test suite since we don't have to account for the differences 219 in output depending upon what the compiler and debugging format 220 support. We will probably have to re-examine the issue when gdb 221 starts taking it's fundamental type information directly from the 222 debugging information supplied by the compiler. fnf@cygnus.com */ 223 224struct type * 225c_create_fundamental_type (struct objfile *objfile, int typeid) 226{ 227 register struct type *type = NULL; 228 229 switch (typeid) 230 { 231 default: 232 /* FIXME: For now, if we are asked to produce a type not in this 233 language, create the equivalent of a C integer type with the 234 name "<?type?>". When all the dust settles from the type 235 reconstruction work, this should probably become an error. */ 236 type = init_type (TYPE_CODE_INT, 237 TARGET_INT_BIT / TARGET_CHAR_BIT, 238 0, "<?type?>", objfile); 239 warning ("internal error: no C/C++ fundamental type %d", typeid); 240 break; 241 case FT_VOID: 242 type = init_type (TYPE_CODE_VOID, 243 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 244 0, "void", objfile); 245 break; 246 case FT_BOOLEAN: 247 type = init_type (TYPE_CODE_BOOL, 248 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 249 0, "bool", objfile); 250 break; 251 case FT_CHAR: 252 type = init_type (TYPE_CODE_INT, 253 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 254 TYPE_FLAG_NOSIGN, "char", objfile); 255 break; 256 case FT_SIGNED_CHAR: 257 type = init_type (TYPE_CODE_INT, 258 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 259 0, "signed char", objfile); 260 break; 261 case FT_UNSIGNED_CHAR: 262 type = init_type (TYPE_CODE_INT, 263 TARGET_CHAR_BIT / TARGET_CHAR_BIT, 264 TYPE_FLAG_UNSIGNED, "unsigned char", objfile); 265 break; 266 case FT_SHORT: 267 type = init_type (TYPE_CODE_INT, 268 TARGET_SHORT_BIT / TARGET_CHAR_BIT, 269 0, "short", objfile); 270 break; 271 case FT_SIGNED_SHORT: 272 type = init_type (TYPE_CODE_INT, 273 TARGET_SHORT_BIT / TARGET_CHAR_BIT, 274 0, "short", objfile); /* FIXME-fnf */ 275 break; 276 case FT_UNSIGNED_SHORT: 277 type = init_type (TYPE_CODE_INT, 278 TARGET_SHORT_BIT / TARGET_CHAR_BIT, 279 TYPE_FLAG_UNSIGNED, "unsigned short", objfile); 280 break; 281 case FT_INTEGER: 282 type = init_type (TYPE_CODE_INT, 283 TARGET_INT_BIT / TARGET_CHAR_BIT, 284 0, "int", objfile); 285 break; 286 case FT_SIGNED_INTEGER: 287 type = init_type (TYPE_CODE_INT, 288 TARGET_INT_BIT / TARGET_CHAR_BIT, 289 0, "int", objfile); /* FIXME -fnf */ 290 break; 291 case FT_UNSIGNED_INTEGER: 292 type = init_type (TYPE_CODE_INT, 293 TARGET_INT_BIT / TARGET_CHAR_BIT, 294 TYPE_FLAG_UNSIGNED, "unsigned int", objfile); 295 break; 296 case FT_LONG: 297 type = init_type (TYPE_CODE_INT, 298 TARGET_LONG_BIT / TARGET_CHAR_BIT, 299 0, "long", objfile); 300 break; 301 case FT_SIGNED_LONG: 302 type = init_type (TYPE_CODE_INT, 303 TARGET_LONG_BIT / TARGET_CHAR_BIT, 304 0, "long", objfile); /* FIXME -fnf */ 305 break; 306 case FT_UNSIGNED_LONG: 307 type = init_type (TYPE_CODE_INT, 308 TARGET_LONG_BIT / TARGET_CHAR_BIT, 309 TYPE_FLAG_UNSIGNED, "unsigned long", objfile); 310 break; 311 case FT_LONG_LONG: 312 type = init_type (TYPE_CODE_INT, 313 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, 314 0, "long long", objfile); 315 break; 316 case FT_SIGNED_LONG_LONG: 317 type = init_type (TYPE_CODE_INT, 318 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, 319 0, "signed long long", objfile); 320 break; 321 case FT_UNSIGNED_LONG_LONG: 322 type = init_type (TYPE_CODE_INT, 323 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, 324 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile); 325 break; 326 case FT_FLOAT: 327 type = init_type (TYPE_CODE_FLT, 328 TARGET_FLOAT_BIT / TARGET_CHAR_BIT, 329 0, "float", objfile); 330 break; 331 case FT_DBL_PREC_FLOAT: 332 type = init_type (TYPE_CODE_FLT, 333 TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, 334 0, "double", objfile); 335 break; 336 case FT_EXT_PREC_FLOAT: 337 type = init_type (TYPE_CODE_FLT, 338 TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, 339 0, "long double", objfile); 340 break; 341 case FT_TEMPLATE_ARG: 342 type = init_type (TYPE_CODE_TEMPLATE_ARG, 343 0, 344 0, "<template arg>", objfile); 345 break; 346 } 347 return (type); 348} 349 350 351/* Table mapping opcodes into strings for printing operators 352 and precedences of the operators. */ 353 354const struct op_print c_op_print_tab[] = 355{ 356 {",", BINOP_COMMA, PREC_COMMA, 0}, 357 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, 358 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, 359 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, 360 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0}, 361 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0}, 362 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0}, 363 {"==", BINOP_EQUAL, PREC_EQUAL, 0}, 364 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, 365 {"<=", BINOP_LEQ, PREC_ORDER, 0}, 366 {">=", BINOP_GEQ, PREC_ORDER, 0}, 367 {">", BINOP_GTR, PREC_ORDER, 0}, 368 {"<", BINOP_LESS, PREC_ORDER, 0}, 369 {">>", BINOP_RSH, PREC_SHIFT, 0}, 370 {"<<", BINOP_LSH, PREC_SHIFT, 0}, 371 {"+", BINOP_ADD, PREC_ADD, 0}, 372 {"-", BINOP_SUB, PREC_ADD, 0}, 373 {"*", BINOP_MUL, PREC_MUL, 0}, 374 {"/", BINOP_DIV, PREC_MUL, 0}, 375 {"%", BINOP_REM, PREC_MUL, 0}, 376 {"@", BINOP_REPEAT, PREC_REPEAT, 0}, 377 {"-", UNOP_NEG, PREC_PREFIX, 0}, 378 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, 379 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0}, 380 {"*", UNOP_IND, PREC_PREFIX, 0}, 381 {"&", UNOP_ADDR, PREC_PREFIX, 0}, 382 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, 383 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, 384 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, 385 {NULL, 0, 0, 0} 386}; 387 388struct type **const (c_builtin_types[]) = 389{ 390 &builtin_type_int, 391 &builtin_type_long, 392 &builtin_type_short, 393 &builtin_type_char, 394 &builtin_type_float, 395 &builtin_type_double, 396 &builtin_type_void, 397 &builtin_type_long_long, 398 &builtin_type_signed_char, 399 &builtin_type_unsigned_char, 400 &builtin_type_unsigned_short, 401 &builtin_type_unsigned_int, 402 &builtin_type_unsigned_long, 403 &builtin_type_unsigned_long_long, 404 &builtin_type_long_double, 405 &builtin_type_complex, 406 &builtin_type_double_complex, 407 0 408}; 409 410const struct language_defn c_language_defn = 411{ 412 "c", /* Language name */ 413 language_c, 414 c_builtin_types, 415 range_check_off, 416 type_check_off, 417 case_sensitive_on, 418 c_parse, 419 c_error, 420 evaluate_subexp_standard, 421 c_printchar, /* Print a character constant */ 422 c_printstr, /* Function to print string constant */ 423 c_emit_char, /* Print a single char */ 424 c_create_fundamental_type, /* Create fundamental type in this language */ 425 c_print_type, /* Print a type using appropriate syntax */ 426 c_val_print, /* Print a value using appropriate syntax */ 427 c_value_print, /* Print a top-level value */ 428 {"", "", "", ""}, /* Binary format info */ 429 {"0%lo", "0", "o", ""}, /* Octal format info */ 430 {"%ld", "", "d", ""}, /* Decimal format info */ 431 {"0x%lx", "0x", "x", ""}, /* Hex format info */ 432 c_op_print_tab, /* expression operators for printing */ 433 1, /* c-style arrays */ 434 0, /* String lower bound */ 435 &builtin_type_char, /* Type of string elements */ 436 LANG_MAGIC 437}; 438 439struct type **const (cplus_builtin_types[]) = 440{ 441 &builtin_type_int, 442 &builtin_type_long, 443 &builtin_type_short, 444 &builtin_type_char, 445 &builtin_type_float, 446 &builtin_type_double, 447 &builtin_type_void, 448 &builtin_type_long_long, 449 &builtin_type_signed_char, 450 &builtin_type_unsigned_char, 451 &builtin_type_unsigned_short, 452 &builtin_type_unsigned_int, 453 &builtin_type_unsigned_long, 454 &builtin_type_unsigned_long_long, 455 &builtin_type_long_double, 456 &builtin_type_complex, 457 &builtin_type_double_complex, 458 &builtin_type_bool, 459 0 460}; 461 462const struct language_defn cplus_language_defn = 463{ 464 "c++", /* Language name */ 465 language_cplus, 466 cplus_builtin_types, 467 range_check_off, 468 type_check_off, 469 case_sensitive_on, 470 c_parse, 471 c_error, 472 evaluate_subexp_standard, 473 c_printchar, /* Print a character constant */ 474 c_printstr, /* Function to print string constant */ 475 c_emit_char, /* Print a single char */ 476 c_create_fundamental_type, /* Create fundamental type in this language */ 477 c_print_type, /* Print a type using appropriate syntax */ 478 c_val_print, /* Print a value using appropriate syntax */ 479 c_value_print, /* Print a top-level value */ 480 {"", "", "", ""}, /* Binary format info */ 481 {"0%lo", "0", "o", ""}, /* Octal format info */ 482 {"%ld", "", "d", ""}, /* Decimal format info */ 483 {"0x%lx", "0x", "x", ""}, /* Hex format info */ 484 c_op_print_tab, /* expression operators for printing */ 485 1, /* c-style arrays */ 486 0, /* String lower bound */ 487 &builtin_type_char, /* Type of string elements */ 488 LANG_MAGIC 489}; 490 491const struct language_defn asm_language_defn = 492{ 493 "asm", /* Language name */ 494 language_asm, 495 c_builtin_types, 496 range_check_off, 497 type_check_off, 498 case_sensitive_on, 499 c_parse, 500 c_error, 501 evaluate_subexp_standard, 502 c_printchar, /* Print a character constant */ 503 c_printstr, /* Function to print string constant */ 504 c_emit_char, /* Print a single char */ 505 c_create_fundamental_type, /* Create fundamental type in this language */ 506 c_print_type, /* Print a type using appropriate syntax */ 507 c_val_print, /* Print a value using appropriate syntax */ 508 c_value_print, /* Print a top-level value */ 509 {"", "", "", ""}, /* Binary format info */ 510 {"0%lo", "0", "o", ""}, /* Octal format info */ 511 {"%ld", "", "d", ""}, /* Decimal format info */ 512 {"0x%lx", "0x", "x", ""}, /* Hex format info */ 513 c_op_print_tab, /* expression operators for printing */ 514 1, /* c-style arrays */ 515 0, /* String lower bound */ 516 &builtin_type_char, /* Type of string elements */ 517 LANG_MAGIC 518}; 519 520void 521_initialize_c_language (void) 522{ 523 add_language (&c_language_defn); 524 add_language (&cplus_language_defn); 525 add_language (&asm_language_defn); 526} 527