1 /* C language support routines for GDB, the GNU debugger.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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. */
25 #include "expression.h"
26 #include "parser-defs.h"
31 extern void _initialize_c_language (void);
32 static void c_emit_char (int c, struct ui_file * stream, int quoter);
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. */
39 c_emit_char (register int c, struct ui_file *stream, int quoter)
41 c &= 0xFF; /* Avoid sign bit follies */
43 if (PRINT_LITERAL_FORM (c))
45 if (c == '\\' || c == quoter)
47 fputs_filtered ("\\", stream);
49 fprintf_filtered (stream, "%c", c);
56 fputs_filtered ("\\n", stream);
59 fputs_filtered ("\\b", stream);
62 fputs_filtered ("\\t", stream);
65 fputs_filtered ("\\f", stream);
68 fputs_filtered ("\\r", stream);
71 fputs_filtered ("\\e", stream);
74 fputs_filtered ("\\a", stream);
77 fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
84 c_printchar (int c, struct ui_file *stream)
86 fputc_filtered ('\'', stream);
87 LA_EMIT_CHAR (c, stream, '\'');
88 fputc_filtered ('\'', stream);
91 /* Print the character string STRING, printing at most LENGTH characters.
92 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
93 long. Printing stops early if the number hits print_max; repeat counts are
94 printed as appropriate. Print ellipses at the end if we had to stop before
95 printing LENGTH characters, or if FORCE_ELLIPSES. */
98 c_printstr (struct ui_file *stream, char *string, unsigned int length,
99 int width, int force_ellipses)
101 register unsigned int i;
102 unsigned int things_printed = 0;
105 extern int inspect_it;
107 /* If the string was not truncated due to `set print elements', and
108 the last byte of it is a null, we don't print that, in traditional C
112 && (extract_unsigned_integer (string + (length - 1) * width, width)
118 fputs_filtered ("\"\"", stream);
122 for (i = 0; i < length && things_printed < print_max; ++i)
124 /* Position of the character we are examining
125 to see whether it is repeated. */
127 /* Number of repetitions we have detected so far. */
129 unsigned long current_char;
135 fputs_filtered (", ", stream);
139 current_char = extract_unsigned_integer (string + i * width, width);
144 && extract_unsigned_integer (string + rep1 * width, width)
151 if (reps > repeat_count_threshold)
156 fputs_filtered ("\\\", ", stream);
158 fputs_filtered ("\", ", stream);
161 LA_PRINT_CHAR (current_char, stream);
162 fprintf_filtered (stream, " <repeats %u times>", reps);
164 things_printed += repeat_count_threshold;
172 fputs_filtered ("\\\"", stream);
174 fputs_filtered ("\"", stream);
177 LA_EMIT_CHAR (current_char, stream, '"');
182 /* Terminate the quotes if necessary. */
186 fputs_filtered ("\\\"", stream);
188 fputs_filtered ("\"", stream);
191 if (force_ellipses || i < length)
192 fputs_filtered ("...", stream);
195 /* Create a fundamental C type using default reasonable for the current
198 Some object/debugging file formats (DWARF version 1, COFF, etc) do not
199 define fundamental types such as "int" or "double". Others (stabs or
200 DWARF version 2, etc) do define fundamental types. For the formats which
201 don't provide fundamental types, gdb can create such types using this
204 FIXME: Some compilers distinguish explicitly signed integral types
205 (signed short, signed int, signed long) from "regular" integral types
206 (short, int, long) in the debugging information. There is some dis-
207 agreement as to how useful this feature is. In particular, gcc does
208 not support this. Also, only some debugging formats allow the
209 distinction to be passed on to a debugger. For now, we always just
210 use "short", "int", or "long" as the type name, for both the implicit
211 and explicitly signed types. This also makes life easier for the
212 gdb test suite since we don't have to account for the differences
213 in output depending upon what the compiler and debugging format
214 support. We will probably have to re-examine the issue when gdb
215 starts taking it's fundamental type information directly from the
216 debugging information supplied by the compiler. fnf@cygnus.com */
219 c_create_fundamental_type (struct objfile *objfile, int typeid)
221 register struct type *type = NULL;
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);
236 type = init_type (TYPE_CODE_VOID,
237 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
241 type = init_type (TYPE_CODE_BOOL,
242 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
246 type = init_type (TYPE_CODE_INT,
247 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
248 TYPE_FLAG_NOSIGN, "char", objfile);
251 type = init_type (TYPE_CODE_INT,
252 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
253 0, "signed char", objfile);
255 case FT_UNSIGNED_CHAR:
256 type = init_type (TYPE_CODE_INT,
257 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
258 TYPE_FLAG_UNSIGNED, "unsigned char", objfile);
261 type = init_type (TYPE_CODE_INT,
262 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
263 0, "short", objfile);
265 case FT_SIGNED_SHORT:
266 type = init_type (TYPE_CODE_INT,
267 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
268 0, "short", objfile); /* FIXME-fnf */
270 case FT_UNSIGNED_SHORT:
271 type = init_type (TYPE_CODE_INT,
272 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
273 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
276 type = init_type (TYPE_CODE_INT,
277 TARGET_INT_BIT / TARGET_CHAR_BIT,
280 case FT_SIGNED_INTEGER:
281 type = init_type (TYPE_CODE_INT,
282 TARGET_INT_BIT / TARGET_CHAR_BIT,
283 0, "int", objfile); /* FIXME -fnf */
285 case FT_UNSIGNED_INTEGER:
286 type = init_type (TYPE_CODE_INT,
287 TARGET_INT_BIT / TARGET_CHAR_BIT,
288 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
291 type = init_type (TYPE_CODE_INT,
292 TARGET_LONG_BIT / TARGET_CHAR_BIT,
296 type = init_type (TYPE_CODE_INT,
297 TARGET_LONG_BIT / TARGET_CHAR_BIT,
298 0, "long", objfile); /* FIXME -fnf */
300 case FT_UNSIGNED_LONG:
301 type = init_type (TYPE_CODE_INT,
302 TARGET_LONG_BIT / TARGET_CHAR_BIT,
303 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
306 type = init_type (TYPE_CODE_INT,
307 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
308 0, "long long", objfile);
310 case FT_SIGNED_LONG_LONG:
311 type = init_type (TYPE_CODE_INT,
312 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
313 0, "signed long long", objfile);
315 case FT_UNSIGNED_LONG_LONG:
316 type = init_type (TYPE_CODE_INT,
317 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
318 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
321 type = init_type (TYPE_CODE_FLT,
322 TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
323 0, "float", objfile);
325 case FT_DBL_PREC_FLOAT:
326 type = init_type (TYPE_CODE_FLT,
327 TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
328 0, "double", objfile);
330 case FT_EXT_PREC_FLOAT:
331 type = init_type (TYPE_CODE_FLT,
332 TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
333 0, "long double", objfile);
335 case FT_TEMPLATE_ARG:
336 type = init_type (TYPE_CODE_TEMPLATE_ARG,
338 0, "<template arg>", objfile);
345 /* Table mapping opcodes into strings for printing operators
346 and precedences of the operators. */
348 const struct op_print c_op_print_tab[] =
350 {",", BINOP_COMMA, PREC_COMMA, 0},
351 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
352 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
353 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
354 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
355 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
356 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
357 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
358 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
359 {"<=", BINOP_LEQ, PREC_ORDER, 0},
360 {">=", BINOP_GEQ, PREC_ORDER, 0},
361 {">", BINOP_GTR, PREC_ORDER, 0},
362 {"<", BINOP_LESS, PREC_ORDER, 0},
363 {">>", BINOP_RSH, PREC_SHIFT, 0},
364 {"<<", BINOP_LSH, PREC_SHIFT, 0},
365 {"+", BINOP_ADD, PREC_ADD, 0},
366 {"-", BINOP_SUB, PREC_ADD, 0},
367 {"*", BINOP_MUL, PREC_MUL, 0},
368 {"/", BINOP_DIV, PREC_MUL, 0},
369 {"%", BINOP_REM, PREC_MUL, 0},
370 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
371 {"-", UNOP_NEG, PREC_PREFIX, 0},
372 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
373 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
374 {"*", UNOP_IND, PREC_PREFIX, 0},
375 {"&", UNOP_ADDR, PREC_PREFIX, 0},
376 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
377 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
378 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
382 struct type **CONST_PTR (c_builtin_types[]) =
389 &builtin_type_double,
391 &builtin_type_long_long,
392 &builtin_type_signed_char,
393 &builtin_type_unsigned_char,
394 &builtin_type_unsigned_short,
395 &builtin_type_unsigned_int,
396 &builtin_type_unsigned_long,
397 &builtin_type_unsigned_long_long,
398 &builtin_type_long_double,
399 &builtin_type_complex,
400 &builtin_type_double_complex,
404 const struct language_defn c_language_defn =
406 "c", /* Language name */
414 evaluate_subexp_standard,
415 c_printchar, /* Print a character constant */
416 c_printstr, /* Function to print string constant */
417 c_emit_char, /* Print a single char */
418 c_create_fundamental_type, /* Create fundamental type in this language */
419 c_print_type, /* Print a type using appropriate syntax */
420 c_val_print, /* Print a value using appropriate syntax */
421 c_value_print, /* Print a top-level value */
422 {"", "", "", ""}, /* Binary format info */
423 {"0%lo", "0", "o", ""}, /* Octal format info */
424 {"%ld", "", "d", ""}, /* Decimal format info */
425 {"0x%lx", "0x", "x", ""}, /* Hex format info */
426 c_op_print_tab, /* expression operators for printing */
427 1, /* c-style arrays */
428 0, /* String lower bound */
429 &builtin_type_char, /* Type of string elements */
433 struct type **const (cplus_builtin_types[]) =
440 &builtin_type_double,
442 &builtin_type_long_long,
443 &builtin_type_signed_char,
444 &builtin_type_unsigned_char,
445 &builtin_type_unsigned_short,
446 &builtin_type_unsigned_int,
447 &builtin_type_unsigned_long,
448 &builtin_type_unsigned_long_long,
449 &builtin_type_long_double,
450 &builtin_type_complex,
451 &builtin_type_double_complex,
456 const struct language_defn cplus_language_defn =
458 "c++", /* Language name */
466 evaluate_subexp_standard,
467 c_printchar, /* Print a character constant */
468 c_printstr, /* Function to print string constant */
469 c_emit_char, /* Print a single char */
470 c_create_fundamental_type, /* Create fundamental type in this language */
471 c_print_type, /* Print a type using appropriate syntax */
472 c_val_print, /* Print a value using appropriate syntax */
473 c_value_print, /* Print a top-level value */
474 {"", "", "", ""}, /* Binary format info */
475 {"0%lo", "0", "o", ""}, /* Octal format info */
476 {"%ld", "", "d", ""}, /* Decimal format info */
477 {"0x%lx", "0x", "x", ""}, /* Hex format info */
478 c_op_print_tab, /* expression operators for printing */
479 1, /* c-style arrays */
480 0, /* String lower bound */
481 &builtin_type_char, /* Type of string elements */
485 const struct language_defn asm_language_defn =
487 "asm", /* Language name */
495 evaluate_subexp_standard,
496 c_printchar, /* Print a character constant */
497 c_printstr, /* Function to print string constant */
498 c_emit_char, /* Print a single char */
499 c_create_fundamental_type, /* Create fundamental type in this language */
500 c_print_type, /* Print a type using appropriate syntax */
501 c_val_print, /* Print a value using appropriate syntax */
502 c_value_print, /* Print a top-level value */
503 {"", "", "", ""}, /* Binary format info */
504 {"0%lo", "0", "o", ""}, /* Octal format info */
505 {"%ld", "", "d", ""}, /* Decimal format info */
506 {"0x%lx", "0x", "x", ""}, /* Hex format info */
507 c_op_print_tab, /* expression operators for printing */
508 1, /* c-style arrays */
509 0, /* String lower bound */
510 &builtin_type_char, /* Type of string elements */
515 _initialize_c_language (void)
517 add_language (&c_language_defn);
518 add_language (&cplus_language_defn);
519 add_language (&asm_language_defn);