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