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.
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"
30 #include "macroscope.h"
31 #include "gdb_assert.h"
33 extern void _initialize_c_language (void);
34 static void c_emit_char (int c
, struct ui_file
* stream
, int quoter
);
36 /* Print the character C on STREAM as part of the contents of a literal
37 string whose delimiter is QUOTER. Note that that format for printing
38 characters and strings is language specific. */
41 c_emit_char (register int c
, struct ui_file
*stream
, int quoter
)
43 c
&= 0xFF; /* Avoid sign bit follies */
45 if (PRINT_LITERAL_FORM (c
))
47 if (c
== '\\' || c
== quoter
)
49 fputs_filtered ("\\", stream
);
51 fprintf_filtered (stream
, "%c", c
);
58 fputs_filtered ("\\n", stream
);
61 fputs_filtered ("\\b", stream
);
64 fputs_filtered ("\\t", stream
);
67 fputs_filtered ("\\f", stream
);
70 fputs_filtered ("\\r", stream
);
73 fputs_filtered ("\\v", stream
);
76 fputs_filtered ("\\e", stream
);
79 fputs_filtered ("\\a", stream
);
82 fputs_filtered ("\\0", stream
);
85 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
92 c_printchar (int c
, struct ui_file
*stream
)
94 fputc_filtered ('\'', stream
);
95 LA_EMIT_CHAR (c
, stream
, '\'');
96 fputc_filtered ('\'', stream
);
99 /* Print the character string STRING, printing at most LENGTH characters.
100 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
101 long. Printing stops early if the number hits print_max; repeat counts are
102 printed as appropriate. Print ellipses at the end if we had to stop before
103 printing LENGTH characters, or if FORCE_ELLIPSES. */
106 c_printstr (struct ui_file
*stream
, char *string
, unsigned int length
,
107 int width
, int force_ellipses
)
109 register unsigned int i
;
110 unsigned int things_printed
= 0;
113 extern int inspect_it
;
115 /* If the string was not truncated due to `set print elements', and
116 the last byte of it is a null, we don't print that, in traditional C
120 && (extract_unsigned_integer (string
+ (length
- 1) * width
, width
)
126 fputs_filtered ("\"\"", stream
);
130 for (i
= 0; i
< length
&& things_printed
< print_max
; ++i
)
132 /* Position of the character we are examining
133 to see whether it is repeated. */
135 /* Number of repetitions we have detected so far. */
137 unsigned long current_char
;
143 fputs_filtered (", ", stream
);
147 current_char
= extract_unsigned_integer (string
+ i
* width
, width
);
152 && extract_unsigned_integer (string
+ rep1
* width
, width
)
159 if (reps
> repeat_count_threshold
)
164 fputs_filtered ("\\\", ", stream
);
166 fputs_filtered ("\", ", stream
);
169 LA_PRINT_CHAR (current_char
, stream
);
170 fprintf_filtered (stream
, " <repeats %u times>", reps
);
172 things_printed
+= repeat_count_threshold
;
180 fputs_filtered ("\\\"", stream
);
182 fputs_filtered ("\"", stream
);
185 LA_EMIT_CHAR (current_char
, stream
, '"');
190 /* Terminate the quotes if necessary. */
194 fputs_filtered ("\\\"", stream
);
196 fputs_filtered ("\"", stream
);
199 if (force_ellipses
|| i
< length
)
200 fputs_filtered ("...", stream
);
203 /* Create a fundamental C type using default reasonable for the current
206 Some object/debugging file formats (DWARF version 1, COFF, etc) do not
207 define fundamental types such as "int" or "double". Others (stabs or
208 DWARF version 2, etc) do define fundamental types. For the formats which
209 don't provide fundamental types, gdb can create such types using this
212 FIXME: Some compilers distinguish explicitly signed integral types
213 (signed short, signed int, signed long) from "regular" integral types
214 (short, int, long) in the debugging information. There is some dis-
215 agreement as to how useful this feature is. In particular, gcc does
216 not support this. Also, only some debugging formats allow the
217 distinction to be passed on to a debugger. For now, we always just
218 use "short", "int", or "long" as the type name, for both the implicit
219 and explicitly signed types. This also makes life easier for the
220 gdb test suite since we don't have to account for the differences
221 in output depending upon what the compiler and debugging format
222 support. We will probably have to re-examine the issue when gdb
223 starts taking it's fundamental type information directly from the
224 debugging information supplied by the compiler. fnf@cygnus.com */
227 c_create_fundamental_type (struct objfile
*objfile
, int typeid)
229 register struct type
*type
= NULL
;
234 /* FIXME: For now, if we are asked to produce a type not in this
235 language, create the equivalent of a C integer type with the
236 name "<?type?>". When all the dust settles from the type
237 reconstruction work, this should probably become an error. */
238 type
= init_type (TYPE_CODE_INT
,
239 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
240 0, "<?type?>", objfile
);
241 warning ("internal error: no C/C++ fundamental type %d", typeid);
244 type
= init_type (TYPE_CODE_VOID
,
245 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
249 type
= init_type (TYPE_CODE_BOOL
,
250 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
254 type
= init_type (TYPE_CODE_INT
,
255 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
256 TYPE_FLAG_NOSIGN
, "char", objfile
);
259 type
= init_type (TYPE_CODE_INT
,
260 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
261 0, "signed char", objfile
);
263 case FT_UNSIGNED_CHAR
:
264 type
= init_type (TYPE_CODE_INT
,
265 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
266 TYPE_FLAG_UNSIGNED
, "unsigned char", objfile
);
269 type
= init_type (TYPE_CODE_INT
,
270 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
271 0, "short", objfile
);
273 case FT_SIGNED_SHORT
:
274 type
= init_type (TYPE_CODE_INT
,
275 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
276 0, "short", objfile
); /* FIXME-fnf */
278 case FT_UNSIGNED_SHORT
:
279 type
= init_type (TYPE_CODE_INT
,
280 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
281 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
284 type
= init_type (TYPE_CODE_INT
,
285 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
288 case FT_SIGNED_INTEGER
:
289 type
= init_type (TYPE_CODE_INT
,
290 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
291 0, "int", objfile
); /* FIXME -fnf */
293 case FT_UNSIGNED_INTEGER
:
294 type
= init_type (TYPE_CODE_INT
,
295 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
296 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
299 type
= init_type (TYPE_CODE_INT
,
300 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
304 type
= init_type (TYPE_CODE_INT
,
305 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
306 0, "long", objfile
); /* FIXME -fnf */
308 case FT_UNSIGNED_LONG
:
309 type
= init_type (TYPE_CODE_INT
,
310 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
311 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
314 type
= init_type (TYPE_CODE_INT
,
315 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
316 0, "long long", objfile
);
318 case FT_SIGNED_LONG_LONG
:
319 type
= init_type (TYPE_CODE_INT
,
320 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
321 0, "signed long long", objfile
);
323 case FT_UNSIGNED_LONG_LONG
:
324 type
= init_type (TYPE_CODE_INT
,
325 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
326 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
329 type
= init_type (TYPE_CODE_FLT
,
330 TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
331 0, "float", objfile
);
333 case FT_DBL_PREC_FLOAT
:
334 type
= init_type (TYPE_CODE_FLT
,
335 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
336 0, "double", objfile
);
338 case FT_EXT_PREC_FLOAT
:
339 type
= init_type (TYPE_CODE_FLT
,
340 TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
341 0, "long double", objfile
);
344 type
= init_type (TYPE_CODE_FLT
,
345 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
346 0, "complex float", objfile
);
347 TYPE_TARGET_TYPE (type
)
348 = init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
349 0, "float", objfile
);
351 case FT_DBL_PREC_COMPLEX
:
352 type
= init_type (TYPE_CODE_FLT
,
353 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
354 0, "complex double", objfile
);
355 TYPE_TARGET_TYPE (type
)
356 = init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
357 0, "double", objfile
);
359 case FT_EXT_PREC_COMPLEX
:
360 type
= init_type (TYPE_CODE_FLT
,
361 2 * TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
362 0, "complex long double", objfile
);
363 TYPE_TARGET_TYPE (type
)
364 = init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
365 0, "long double", objfile
);
367 case FT_TEMPLATE_ARG
:
368 type
= init_type (TYPE_CODE_TEMPLATE_ARG
,
370 0, "<template arg>", objfile
);
376 /* Preprocessing and parsing C and C++ expressions. */
379 /* When we find that lexptr (the global var defined in parse.c) is
380 pointing at a macro invocation, we expand the invocation, and call
381 scan_macro_expansion to save the old lexptr here and point lexptr
382 into the expanded text. When we reach the end of that, we call
383 end_macro_expansion to pop back to the value we saved here. The
384 macro expansion code promises to return only fully-expanded text,
385 so we don't need to "push" more than one level.
387 This is disgusting, of course. It would be cleaner to do all macro
388 expansion beforehand, and then hand that to lexptr. But we don't
389 really know where the expression ends. Remember, in a command like
391 (gdb) break *ADDRESS if CONDITION
393 we evaluate ADDRESS in the scope of the current frame, but we
394 evaluate CONDITION in the scope of the breakpoint's location. So
395 it's simply wrong to try to macro-expand the whole thing at once. */
396 static char *macro_original_text
;
397 static char *macro_expanded_text
;
401 scan_macro_expansion (char *expansion
)
403 /* We'd better not be trying to push the stack twice. */
404 gdb_assert (! macro_original_text
);
405 gdb_assert (! macro_expanded_text
);
407 /* Save the old lexptr value, so we can return to it when we're done
408 parsing the expanded text. */
409 macro_original_text
= lexptr
;
412 /* Save the expanded text, so we can free it when we're finished. */
413 macro_expanded_text
= expansion
;
418 scanning_macro_expansion (void)
420 return macro_original_text
!= 0;
425 finished_macro_expansion (void)
427 /* There'd better be something to pop back to, and we better have
428 saved a pointer to the start of the expanded text. */
429 gdb_assert (macro_original_text
);
430 gdb_assert (macro_expanded_text
);
432 /* Pop back to the original text. */
433 lexptr
= macro_original_text
;
434 macro_original_text
= 0;
436 /* Free the expanded text. */
437 xfree (macro_expanded_text
);
438 macro_expanded_text
= 0;
443 scan_macro_cleanup (void *dummy
)
445 if (macro_original_text
)
446 finished_macro_expansion ();
450 /* We set these global variables before calling c_parse, to tell it
451 how it to find macro definitions for the expression at hand. */
452 macro_lookup_ftype
*expression_macro_lookup_func
;
453 void *expression_macro_lookup_baton
;
456 static struct macro_definition
*
457 null_macro_lookup (const char *name
, void *baton
)
464 c_preprocess_and_parse (void)
466 /* Set up a lookup function for the macro expander. */
467 struct macro_scope
*scope
= 0;
468 struct cleanup
*back_to
= make_cleanup (free_current_contents
, &scope
);
470 if (expression_context_block
)
471 scope
= sal_macro_scope (find_pc_line (expression_context_pc
, 0));
473 scope
= default_macro_scope ();
477 expression_macro_lookup_func
= standard_macro_lookup
;
478 expression_macro_lookup_baton
= (void *) scope
;
482 expression_macro_lookup_func
= null_macro_lookup
;
483 expression_macro_lookup_baton
= 0;
486 gdb_assert (! macro_original_text
);
487 make_cleanup (scan_macro_cleanup
, 0);
490 int result
= c_parse ();
491 do_cleanups (back_to
);
498 /* Table mapping opcodes into strings for printing operators
499 and precedences of the operators. */
501 const struct op_print c_op_print_tab
[] =
503 {",", BINOP_COMMA
, PREC_COMMA
, 0},
504 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
505 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
506 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
507 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
508 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
509 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
510 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
511 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
512 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
513 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
514 {">", BINOP_GTR
, PREC_ORDER
, 0},
515 {"<", BINOP_LESS
, PREC_ORDER
, 0},
516 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
517 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
518 {"+", BINOP_ADD
, PREC_ADD
, 0},
519 {"-", BINOP_SUB
, PREC_ADD
, 0},
520 {"*", BINOP_MUL
, PREC_MUL
, 0},
521 {"/", BINOP_DIV
, PREC_MUL
, 0},
522 {"%", BINOP_REM
, PREC_MUL
, 0},
523 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
524 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
525 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
526 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
527 {"*", UNOP_IND
, PREC_PREFIX
, 0},
528 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
529 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
530 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
531 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
535 struct type
**const (c_builtin_types
[]) =
542 &builtin_type_double
,
544 &builtin_type_long_long
,
545 &builtin_type_signed_char
,
546 &builtin_type_unsigned_char
,
547 &builtin_type_unsigned_short
,
548 &builtin_type_unsigned_int
,
549 &builtin_type_unsigned_long
,
550 &builtin_type_unsigned_long_long
,
551 &builtin_type_long_double
,
552 &builtin_type_complex
,
553 &builtin_type_double_complex
,
557 const struct language_defn c_language_defn
=
559 "c", /* Language name */
565 c_preprocess_and_parse
,
567 evaluate_subexp_standard
,
568 c_printchar
, /* Print a character constant */
569 c_printstr
, /* Function to print string constant */
570 c_emit_char
, /* Print a single char */
571 c_create_fundamental_type
, /* Create fundamental type in this language */
572 c_print_type
, /* Print a type using appropriate syntax */
573 c_val_print
, /* Print a value using appropriate syntax */
574 c_value_print
, /* Print a top-level value */
575 {"", "", "", ""}, /* Binary format info */
576 {"0%lo", "0", "o", ""}, /* Octal format info */
577 {"%ld", "", "d", ""}, /* Decimal format info */
578 {"0x%lx", "0x", "x", ""}, /* Hex format info */
579 c_op_print_tab
, /* expression operators for printing */
580 1, /* c-style arrays */
581 0, /* String lower bound */
582 &builtin_type_char
, /* Type of string elements */
586 struct type
**const (cplus_builtin_types
[]) =
593 &builtin_type_double
,
595 &builtin_type_long_long
,
596 &builtin_type_signed_char
,
597 &builtin_type_unsigned_char
,
598 &builtin_type_unsigned_short
,
599 &builtin_type_unsigned_int
,
600 &builtin_type_unsigned_long
,
601 &builtin_type_unsigned_long_long
,
602 &builtin_type_long_double
,
603 &builtin_type_complex
,
604 &builtin_type_double_complex
,
609 const struct language_defn cplus_language_defn
=
611 "c++", /* Language name */
617 c_preprocess_and_parse
,
619 evaluate_subexp_standard
,
620 c_printchar
, /* Print a character constant */
621 c_printstr
, /* Function to print string constant */
622 c_emit_char
, /* Print a single char */
623 c_create_fundamental_type
, /* Create fundamental type in this language */
624 c_print_type
, /* Print a type using appropriate syntax */
625 c_val_print
, /* Print a value using appropriate syntax */
626 c_value_print
, /* Print a top-level value */
627 {"", "", "", ""}, /* Binary format info */
628 {"0%lo", "0", "o", ""}, /* Octal format info */
629 {"%ld", "", "d", ""}, /* Decimal format info */
630 {"0x%lx", "0x", "x", ""}, /* Hex format info */
631 c_op_print_tab
, /* expression operators for printing */
632 1, /* c-style arrays */
633 0, /* String lower bound */
634 &builtin_type_char
, /* Type of string elements */
638 const struct language_defn asm_language_defn
=
640 "asm", /* Language name */
646 c_preprocess_and_parse
,
648 evaluate_subexp_standard
,
649 c_printchar
, /* Print a character constant */
650 c_printstr
, /* Function to print string constant */
651 c_emit_char
, /* Print a single char */
652 c_create_fundamental_type
, /* Create fundamental type in this language */
653 c_print_type
, /* Print a type using appropriate syntax */
654 c_val_print
, /* Print a value using appropriate syntax */
655 c_value_print
, /* Print a top-level value */
656 {"", "", "", ""}, /* Binary format info */
657 {"0%lo", "0", "o", ""}, /* Octal format info */
658 {"%ld", "", "d", ""}, /* Decimal format info */
659 {"0x%lx", "0x", "x", ""}, /* Hex format info */
660 c_op_print_tab
, /* expression operators for printing */
661 1, /* c-style arrays */
662 0, /* String lower bound */
663 &builtin_type_char
, /* Type of string elements */
668 _initialize_c_language (void)
670 add_language (&c_language_defn
);
671 add_language (&cplus_language_defn
);
672 add_language (&asm_language_defn
);