1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003,
4 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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/>. */
24 #include "expression.h"
25 #include "parser-defs.h"
29 #include "macroscope.h"
30 #include "gdb_assert.h"
32 #include "gdb_string.h"
35 #include "cp-support.h"
36 #include "gdb_obstack.h"
39 extern void _initialize_c_language (void);
41 /* Given a C string type, STR_TYPE, return the corresponding target
42 character set name. */
45 charset_for_string_type (enum c_string_type str_type
,
46 enum bfd_endian byte_order
)
48 switch (str_type
& ~C_CHAR
)
51 return target_charset ();
53 return target_wide_charset (byte_order
);
55 /* FIXME: UCS-2 is not always correct. */
56 if (byte_order
== BFD_ENDIAN_BIG
)
61 /* FIXME: UCS-4 is not always correct. */
62 if (byte_order
== BFD_ENDIAN_BIG
)
67 internal_error (__FILE__
, __LINE__
, "unhandled c_string_type");
70 /* Classify ELTTYPE according to what kind of character it is. Return
71 the enum constant representing the character type. Also set
72 *ENCODING to the name of the character set to use when converting
73 characters of this type in target BYTE_ORDER to the host character set. */
75 static enum c_string_type
76 classify_type (struct type
*elttype
, enum bfd_endian byte_order
,
77 const char **encoding
)
79 struct type
*saved_type
;
80 enum c_string_type result
;
82 /* We loop because ELTTYPE may be a typedef, and we want to
83 successively peel each typedef until we reach a type we
84 understand. We don't use CHECK_TYPEDEF because that will strip
85 all typedefs at once -- but in C, wchar_t is itself a typedef, so
86 that would do the wrong thing. */
89 char *name
= TYPE_NAME (elttype
);
91 if (TYPE_CODE (elttype
) == TYPE_CODE_CHAR
|| !name
)
97 if (!strcmp (name
, "wchar_t"))
103 if (!strcmp (name
, "char16_t"))
109 if (!strcmp (name
, "char32_t"))
115 if (TYPE_CODE (elttype
) != TYPE_CODE_TYPEDEF
)
118 /* Call for side effects. */
119 check_typedef (elttype
);
121 if (TYPE_TARGET_TYPE (elttype
))
122 elttype
= TYPE_TARGET_TYPE (elttype
);
125 /* Perhaps check_typedef did not update the target type. In
126 this case, force the lookup again and hope it works out.
127 It never will for C, but it might for C++. */
128 CHECK_TYPEDEF (elttype
);
137 *encoding
= charset_for_string_type (result
, byte_order
);
142 /* Return true if print_wchar can display W without resorting to a
143 numeric escape, false otherwise. */
146 wchar_printable (gdb_wchar_t w
)
148 return (gdb_iswprint (w
)
149 || w
== LCST ('\a') || w
== LCST ('\b')
150 || w
== LCST ('\f') || w
== LCST ('\n')
151 || w
== LCST ('\r') || w
== LCST ('\t')
152 || w
== LCST ('\v'));
155 /* A helper function that converts the contents of STRING to wide
156 characters and then appends them to OUTPUT. */
159 append_string_as_wide (const char *string
, struct obstack
*output
)
161 for (; *string
; ++string
)
163 gdb_wchar_t w
= gdb_btowc (*string
);
164 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
168 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
169 original (target) bytes representing the character, ORIG_LEN is the
170 number of valid bytes. WIDTH is the number of bytes in a base
171 characters of the type. OUTPUT is an obstack to which wide
172 characters are emitted. QUOTER is a (narrow) character indicating
173 the style of quotes surrounding the character to be printed.
174 NEED_ESCAPE is an in/out flag which is used to track numeric
175 escapes across calls. */
178 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
, int orig_len
,
179 int width
, enum bfd_endian byte_order
, struct obstack
*output
,
180 int quoter
, int *need_escapep
)
182 int need_escape
= *need_escapep
;
184 if (gdb_iswprint (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
186 && w
!= LCST ('9'))))
188 gdb_wchar_t wchar
= w
;
190 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
191 obstack_grow_wstr (output
, LCST ("\\"));
192 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
199 obstack_grow_wstr (output
, LCST ("\\a"));
202 obstack_grow_wstr (output
, LCST ("\\b"));
205 obstack_grow_wstr (output
, LCST ("\\f"));
208 obstack_grow_wstr (output
, LCST ("\\n"));
211 obstack_grow_wstr (output
, LCST ("\\r"));
214 obstack_grow_wstr (output
, LCST ("\\t"));
217 obstack_grow_wstr (output
, LCST ("\\v"));
223 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
227 value
= extract_unsigned_integer (&orig
[i
], width
, byte_order
);
228 /* If the value fits in 3 octal digits, print it that
229 way. Otherwise, print it as a hex escape. */
231 sprintf (octal
, "\\%.3o", (int) (value
& 0777));
233 sprintf (octal
, "\\x%lx", (long) value
);
234 append_string_as_wide (octal
, output
);
236 /* If we somehow have extra bytes, print them now. */
240 sprintf (octal
, "\\%.3o", orig
[i
] & 0xff);
241 append_string_as_wide (octal
, output
);
252 /* Print the character C on STREAM as part of the contents of a literal
253 string whose delimiter is QUOTER. Note that that format for printing
254 characters and strings is language specific. */
257 c_emit_char (int c
, struct type
*type
, struct ui_file
*stream
, int quoter
)
259 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
260 struct obstack wchar_buf
, output
;
261 struct cleanup
*cleanups
;
262 const char *encoding
;
264 struct wchar_iterator
*iter
;
267 classify_type (type
, byte_order
, &encoding
);
269 buf
= alloca (TYPE_LENGTH (type
));
270 pack_long (buf
, type
, c
);
272 iter
= make_wchar_iterator (buf
, TYPE_LENGTH (type
), encoding
,
274 cleanups
= make_cleanup_wchar_iterator (iter
);
276 /* This holds the printable form of the wchar_t data. */
277 obstack_init (&wchar_buf
);
278 make_cleanup_obstack_free (&wchar_buf
);
286 int print_escape
= 1;
287 enum wchar_iterate_result result
;
289 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
294 /* If all characters are printable, print them. Otherwise,
295 we're going to have to print an escape sequence. We
296 check all characters because we want to print the target
297 bytes in the escape sequence, and we don't know character
302 for (i
= 0; i
< num_chars
; ++i
)
303 if (!wchar_printable (chars
[i
]))
311 for (i
= 0; i
< num_chars
; ++i
)
312 print_wchar (chars
[i
], buf
, buflen
, TYPE_LENGTH (type
),
313 byte_order
, &wchar_buf
, quoter
, &need_escape
);
317 /* This handles the NUM_CHARS == 0 case as well. */
319 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
), byte_order
,
320 &wchar_buf
, quoter
, &need_escape
);
323 /* The output in the host encoding. */
324 obstack_init (&output
);
325 make_cleanup_obstack_free (&output
);
327 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
328 obstack_base (&wchar_buf
),
329 obstack_object_size (&wchar_buf
),
330 1, &output
, translit_char
);
331 obstack_1grow (&output
, '\0');
333 fputs_filtered (obstack_base (&output
), stream
);
335 do_cleanups (cleanups
);
339 c_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
341 enum c_string_type str_type
;
343 str_type
= classify_type (type
, BFD_ENDIAN_UNKNOWN
, NULL
);
349 fputc_filtered ('L', stream
);
352 fputc_filtered ('u', stream
);
355 fputc_filtered ('U', stream
);
359 fputc_filtered ('\'', stream
);
360 LA_EMIT_CHAR (c
, type
, stream
, '\'');
361 fputc_filtered ('\'', stream
);
364 /* Print the character string STRING, printing at most LENGTH characters.
365 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
366 long. Printing stops early if the number hits print_max; repeat counts are
367 printed as appropriate. Print ellipses at the end if we had to stop before
368 printing LENGTH characters, or if FORCE_ELLIPSES. */
371 c_printstr (struct ui_file
*stream
, struct type
*type
, const gdb_byte
*string
,
372 unsigned int length
, int force_ellipses
,
373 const struct value_print_options
*options
)
375 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
377 unsigned int things_printed
= 0;
380 int width
= TYPE_LENGTH (type
);
381 struct obstack wchar_buf
, output
;
382 struct cleanup
*cleanup
;
383 enum c_string_type str_type
;
384 const char *encoding
;
385 struct wchar_iterator
*iter
;
389 /* If the string was not truncated due to `set print elements', and
390 the last byte of it is a null, we don't print that, in traditional C
394 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
395 width
, byte_order
) == 0))
398 str_type
= classify_type (type
, byte_order
, &encoding
) & ~C_CHAR
;
404 fputs_filtered ("L", stream
);
407 fputs_filtered ("u", stream
);
410 fputs_filtered ("U", stream
);
416 fputs_filtered ("\"\"", stream
);
422 unsigned long current_char
= 1;
423 for (i
= 0; current_char
; ++i
)
426 current_char
= extract_unsigned_integer (string
+ i
* width
,
432 /* Arrange to iterate over the characters, in wchar_t form. */
433 iter
= make_wchar_iterator (string
, length
* width
, encoding
, width
);
434 cleanup
= make_cleanup_wchar_iterator (iter
);
436 /* WCHAR_BUF is the obstack we use to represent the string in
438 obstack_init (&wchar_buf
);
439 make_cleanup_obstack_free (&wchar_buf
);
441 while (!finished
&& things_printed
< options
->print_max
)
444 enum wchar_iterate_result result
;
453 obstack_grow_wstr (&wchar_buf
, LCST (", "));
457 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
458 /* We only look at repetitions when we were able to convert a
459 single character in isolation. This makes the code simpler
460 and probably does the sensible thing in the majority of
462 while (num_chars
== 1)
464 /* Count the number of repetitions. */
465 unsigned int reps
= 0;
466 gdb_wchar_t current_char
= chars
[0];
467 const gdb_byte
*orig_buf
= buf
;
468 int orig_len
= buflen
;
472 obstack_grow_wstr (&wchar_buf
, LCST (", "));
476 while (num_chars
== 1 && current_char
== chars
[0])
478 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
482 /* Emit CURRENT_CHAR according to the repetition count and
484 if (reps
> options
->repeat_count_threshold
)
488 if (options
->inspect_it
)
489 obstack_grow_wstr (&wchar_buf
, LCST ("\\\", "));
491 obstack_grow_wstr (&wchar_buf
, LCST ("\", "));
494 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
496 print_wchar (current_char
, orig_buf
, orig_len
, width
,
497 byte_order
, &wchar_buf
, '\'', &need_escape
);
498 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
500 /* Painful gyrations. */
502 char *s
= xstrprintf (_(" <repeats %u times>"), reps
);
503 for (j
= 0; s
[j
]; ++j
)
505 gdb_wchar_t w
= gdb_btowc (s
[j
]);
506 obstack_grow (&wchar_buf
, &w
, sizeof (gdb_wchar_t
));
510 things_printed
+= options
->repeat_count_threshold
;
515 /* Saw the character one or more times, but fewer than
516 the repetition threshold. */
519 if (options
->inspect_it
)
520 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
522 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
529 print_wchar (current_char
, orig_buf
, orig_len
, width
,
530 byte_order
, &wchar_buf
, '"', &need_escape
);
536 /* NUM_CHARS and the other outputs from wchar_iterate are valid
537 here regardless of which branch was taken above. */
547 case wchar_iterate_invalid
:
550 if (options
->inspect_it
)
551 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
553 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
557 print_wchar (gdb_WEOF
, buf
, buflen
, width
, byte_order
, &wchar_buf
,
561 case wchar_iterate_incomplete
:
564 if (options
->inspect_it
)
565 obstack_grow_wstr (&wchar_buf
, LCST ("\\\","));
567 obstack_grow_wstr (&wchar_buf
, LCST ("\","));
570 obstack_grow_wstr (&wchar_buf
, LCST (" <incomplete sequence "));
571 print_wchar (gdb_WEOF
, buf
, buflen
, width
, byte_order
, &wchar_buf
,
573 obstack_grow_wstr (&wchar_buf
, LCST (">"));
579 /* Terminate the quotes if necessary. */
582 if (options
->inspect_it
)
583 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
585 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
588 if (force_ellipses
|| !finished
)
589 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
591 /* OUTPUT is where we collect `char's for printing. */
592 obstack_init (&output
);
593 make_cleanup_obstack_free (&output
);
595 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
596 obstack_base (&wchar_buf
),
597 obstack_object_size (&wchar_buf
),
598 1, &output
, translit_char
);
599 obstack_1grow (&output
, '\0');
601 fputs_filtered (obstack_base (&output
), stream
);
603 do_cleanups (cleanup
);
606 /* Obtain a C string from the inferior storing it in a newly allocated
607 buffer in BUFFER, which should be freed by the caller. The string is
608 read until a null character is found. If VALUE is an array with known
609 length, the function will not read past the end of the array. LENGTH
610 will contain the size of the string in bytes (not counting the null
613 Assumes strings are terminated by a null character. The size of a character
614 is determined by the length of the target type of the pointer or array.
615 This means that a null byte present in a multi-byte character will not
616 terminate the string unless the whole character is null.
618 CHARSET is always set to the target charset. */
621 c_get_string (struct value
*value
, gdb_byte
**buffer
, int *length
,
622 const char **charset
)
625 unsigned int fetchlimit
;
626 struct type
*type
= check_typedef (value_type (value
));
627 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
628 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
630 if (element_type
== NULL
)
633 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
635 /* If we know the size of the array, we can use it as a limit on the
636 number of characters to be fetched. */
637 if (TYPE_NFIELDS (type
) == 1
638 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
640 LONGEST low_bound
, high_bound
;
642 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
643 &low_bound
, &high_bound
);
644 fetchlimit
= high_bound
- low_bound
+ 1;
647 fetchlimit
= UINT_MAX
;
649 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
650 fetchlimit
= UINT_MAX
;
652 /* We work only with arrays and pointers. */
655 element_type
= check_typedef (element_type
);
656 if (TYPE_CODE (element_type
) != TYPE_CODE_INT
657 && TYPE_CODE (element_type
) != TYPE_CODE_CHAR
)
658 /* If the elements are not integers or characters, we don't consider it
662 width
= TYPE_LENGTH (element_type
);
664 /* If the string lives in GDB's memory intead of the inferior's, then we
665 just need to copy it to BUFFER. Also, since such strings are arrays
666 with known size, FETCHLIMIT will hold the size of the array. */
667 if ((VALUE_LVAL (value
) == not_lval
668 || VALUE_LVAL (value
) == lval_internalvar
)
669 && fetchlimit
!= UINT_MAX
)
672 const gdb_byte
*contents
= value_contents (value
);
674 /* Look for a null character. */
675 for (i
= 0; i
< fetchlimit
; i
++)
676 if (extract_unsigned_integer (contents
+ i
* width
, width
,
680 /* I is now either the number of non-null characters, or FETCHLIMIT. */
682 *buffer
= xmalloc (*length
);
683 memcpy (*buffer
, contents
, *length
);
688 err
= read_string (value_as_address (value
), -1, width
, fetchlimit
,
689 byte_order
, buffer
, length
);
693 error (_("Error reading string from inferior: %s"),
694 safe_strerror (err
));
698 /* If the last character is null, subtract it from LENGTH. */
700 && extract_unsigned_integer (*buffer
+ *length
- width
, width
,
704 *charset
= target_charset ();
712 type_str
= type_to_string (type
);
715 make_cleanup (xfree
, type_str
);
716 error (_("Trying to read string with inappropriate type `%s'."),
720 error (_("Trying to read string with inappropriate type."));
725 /* Evaluating C and C++ expressions. */
727 /* Convert a UCN. The digits of the UCN start at P and extend no
728 farther than LIMIT. DEST_CHARSET is the name of the character set
729 into which the UCN should be converted. The results are written to
730 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
731 Returns a pointer to just after the final digit of the UCN. */
734 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
735 struct obstack
*output
, int length
)
737 unsigned long result
= 0;
741 for (i
= 0; i
< length
&& p
< limit
&& isxdigit (*p
); ++i
, ++p
)
742 result
= (result
<< 4) + host_hex_value (*p
);
744 for (i
= 3; i
>= 0; --i
)
746 data
[i
] = result
& 0xff;
750 convert_between_encodings ("UCS-4BE", dest_charset
, data
, 4, 4, output
,
756 /* Emit a character, VALUE, which was specified numerically, to
757 OUTPUT. TYPE is the target character type. */
760 emit_numeric_character (struct type
*type
, unsigned long value
,
761 struct obstack
*output
)
765 buffer
= alloca (TYPE_LENGTH (type
));
766 pack_long (buffer
, type
, value
);
767 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
770 /* Convert an octal escape sequence. TYPE is the target character
771 type. The digits of the escape sequence begin at P and extend no
772 farther than LIMIT. The result is written to OUTPUT. Returns a
773 pointer to just after the final digit of the escape sequence. */
776 convert_octal (struct type
*type
, char *p
, char *limit
, struct obstack
*output
)
779 unsigned long value
= 0;
782 i
< 3 && p
< limit
&& isdigit (*p
) && *p
!= '8' && *p
!= '9';
785 value
= 8 * value
+ host_hex_value (*p
);
789 emit_numeric_character (type
, value
, output
);
794 /* Convert a hex escape sequence. TYPE is the target character type.
795 The digits of the escape sequence begin at P and extend no farther
796 than LIMIT. The result is written to OUTPUT. Returns a pointer to
797 just after the final digit of the escape sequence. */
800 convert_hex (struct type
*type
, char *p
, char *limit
, struct obstack
*output
)
802 unsigned long value
= 0;
804 while (p
< limit
&& isxdigit (*p
))
806 value
= 16 * value
+ host_hex_value (*p
);
810 emit_numeric_character (type
, value
, output
);
819 error (_("Malformed escape sequence")); \
822 /* Convert an escape sequence to a target format. TYPE is the target
823 character type to use, and DEST_CHARSET is the name of the target
824 character set. The backslash of the escape sequence is at *P, and
825 the escape sequence will not extend past LIMIT. The results are
826 written to OUTPUT. Returns a pointer to just past the final
827 character of the escape sequence. */
830 convert_escape (struct type
*type
, const char *dest_charset
,
831 char *p
, char *limit
, struct obstack
*output
)
833 /* Skip the backslash. */
839 obstack_1grow (output
, '\\');
846 error (_("\\x used with no following hex digits."));
847 p
= convert_hex (type
, p
, limit
, output
);
858 p
= convert_octal (type
, p
, limit
, output
);
864 int length
= *p
== 'u' ? 4 : 8;
867 error (_("\\u used with no following hex digits"));
868 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
875 /* Given a single string from a (C-specific) OP_STRING list, convert
876 it to a target string, handling escape sequences specially. The
877 output is written to OUTPUT. DATA is the input string, which has
878 length LEN. DEST_CHARSET is the name of the target character set,
879 and TYPE is the type of target character to use. */
882 parse_one_string (struct obstack
*output
, char *data
, int len
,
883 const char *dest_charset
, struct type
*type
)
892 /* Look for next escape, or the end of the input. */
893 while (p
< limit
&& *p
!= '\\')
895 /* If we saw a run of characters, convert them all. */
897 convert_between_encodings (host_charset (), dest_charset
,
898 data
, p
- data
, 1, output
, translit_none
);
899 /* If we saw an escape, convert it. */
901 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
906 /* Expression evaluator for the C language family. Most operations
907 are delegated to evaluate_subexp_standard; see that function for a
908 description of the arguments. */
910 static struct value
*
911 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
912 int *pos
, enum noside noside
)
914 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
922 struct obstack output
;
923 struct cleanup
*cleanup
;
924 struct value
*result
;
925 enum c_string_type dest_type
;
926 const char *dest_charset
;
927 enum bfd_endian byte_order
;
929 obstack_init (&output
);
930 cleanup
= make_cleanup_obstack_free (&output
);
933 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
936 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
938 = (enum c_string_type
) longest_to_int (exp
->elts
[*pos
].longconst
);
939 switch (dest_type
& ~C_CHAR
)
942 type
= language_string_char_type (exp
->language_defn
,
946 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
950 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
951 "char16_t", NULL
, 0);
954 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
955 "char32_t", NULL
, 0);
958 internal_error (__FILE__
, __LINE__
, "unhandled c_string_type");
961 /* Ensure TYPE_LENGTH is valid for TYPE. */
962 check_typedef (type
);
964 byte_order
= gdbarch_byte_order (exp
->gdbarch
);
965 dest_charset
= charset_for_string_type (dest_type
, byte_order
);
972 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
975 if (noside
!= EVAL_SKIP
)
976 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
978 *pos
+= BYTES_TO_EXP_ELEM (len
);
981 /* Skip the trailing length and opcode. */
984 if (noside
== EVAL_SKIP
)
986 /* Return a dummy value of the appropriate type. */
987 if ((dest_type
& C_CHAR
) != 0)
988 result
= allocate_value (type
);
990 result
= value_cstring ("", 0, type
);
991 do_cleanups (cleanup
);
995 if ((dest_type
& C_CHAR
) != 0)
999 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
1000 error (_("Could not convert character constant to target character set"));
1001 value
= unpack_long (type
, obstack_base (&output
));
1002 result
= value_from_longest (type
, value
);
1007 /* Write the terminating character. */
1008 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
1009 obstack_1grow (&output
, 0);
1010 result
= value_cstring (obstack_base (&output
),
1011 obstack_object_size (&output
),
1014 do_cleanups (cleanup
);
1022 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1027 /* Table mapping opcodes into strings for printing operators
1028 and precedences of the operators. */
1030 const struct op_print c_op_print_tab
[] =
1032 {",", BINOP_COMMA
, PREC_COMMA
, 0},
1033 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
1034 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
1035 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
1036 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
1037 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
1038 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
1039 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
1040 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
1041 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
1042 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
1043 {">", BINOP_GTR
, PREC_ORDER
, 0},
1044 {"<", BINOP_LESS
, PREC_ORDER
, 0},
1045 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
1046 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
1047 {"+", BINOP_ADD
, PREC_ADD
, 0},
1048 {"-", BINOP_SUB
, PREC_ADD
, 0},
1049 {"*", BINOP_MUL
, PREC_MUL
, 0},
1050 {"/", BINOP_DIV
, PREC_MUL
, 0},
1051 {"%", BINOP_REM
, PREC_MUL
, 0},
1052 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
1053 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
1054 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
1055 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
1056 {"*", UNOP_IND
, PREC_PREFIX
, 0},
1057 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
1058 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
1059 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
1060 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
1064 enum c_primitive_types
{
1065 c_primitive_type_int
,
1066 c_primitive_type_long
,
1067 c_primitive_type_short
,
1068 c_primitive_type_char
,
1069 c_primitive_type_float
,
1070 c_primitive_type_double
,
1071 c_primitive_type_void
,
1072 c_primitive_type_long_long
,
1073 c_primitive_type_signed_char
,
1074 c_primitive_type_unsigned_char
,
1075 c_primitive_type_unsigned_short
,
1076 c_primitive_type_unsigned_int
,
1077 c_primitive_type_unsigned_long
,
1078 c_primitive_type_unsigned_long_long
,
1079 c_primitive_type_long_double
,
1080 c_primitive_type_complex
,
1081 c_primitive_type_double_complex
,
1082 c_primitive_type_decfloat
,
1083 c_primitive_type_decdouble
,
1084 c_primitive_type_declong
,
1085 nr_c_primitive_types
1089 c_language_arch_info (struct gdbarch
*gdbarch
,
1090 struct language_arch_info
*lai
)
1092 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1093 lai
->string_char_type
= builtin
->builtin_char
;
1094 lai
->primitive_type_vector
1095 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
1097 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
1098 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
1099 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
1100 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
1101 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
1102 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
1103 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
1104 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
1105 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
1106 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
1107 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
1108 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
1109 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
1110 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
1111 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
1112 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
1113 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
1114 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
1115 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
1116 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
1118 lai
->bool_type_default
= builtin
->builtin_int
;
1121 static const struct exp_descriptor exp_descriptor_c
=
1123 print_subexp_standard
,
1124 operator_length_standard
,
1126 dump_subexp_body_standard
,
1130 const struct language_defn c_language_defn
=
1132 "c", /* Language name */
1143 c_printchar
, /* Print a character constant */
1144 c_printstr
, /* Function to print string constant */
1145 c_emit_char
, /* Print a single char */
1146 c_print_type
, /* Print a type using appropriate syntax */
1147 c_print_typedef
, /* Print a typedef using appropriate syntax */
1148 c_val_print
, /* Print a value using appropriate syntax */
1149 c_value_print
, /* Print a top-level value */
1150 NULL
, /* Language specific skip_trampoline */
1151 NULL
, /* name_of_this */
1152 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1153 basic_lookup_transparent_type
,/* lookup_transparent_type */
1154 NULL
, /* Language specific symbol demangler */
1155 NULL
, /* Language specific class_name_from_physname */
1156 c_op_print_tab
, /* expression operators for printing */
1157 1, /* c-style arrays */
1158 0, /* String lower bound */
1159 default_word_break_characters
,
1160 default_make_symbol_completion_list
,
1161 c_language_arch_info
,
1162 default_print_array_index
,
1163 default_pass_by_reference
,
1168 enum cplus_primitive_types
{
1169 cplus_primitive_type_int
,
1170 cplus_primitive_type_long
,
1171 cplus_primitive_type_short
,
1172 cplus_primitive_type_char
,
1173 cplus_primitive_type_float
,
1174 cplus_primitive_type_double
,
1175 cplus_primitive_type_void
,
1176 cplus_primitive_type_long_long
,
1177 cplus_primitive_type_signed_char
,
1178 cplus_primitive_type_unsigned_char
,
1179 cplus_primitive_type_unsigned_short
,
1180 cplus_primitive_type_unsigned_int
,
1181 cplus_primitive_type_unsigned_long
,
1182 cplus_primitive_type_unsigned_long_long
,
1183 cplus_primitive_type_long_double
,
1184 cplus_primitive_type_complex
,
1185 cplus_primitive_type_double_complex
,
1186 cplus_primitive_type_bool
,
1187 cplus_primitive_type_decfloat
,
1188 cplus_primitive_type_decdouble
,
1189 cplus_primitive_type_declong
,
1190 nr_cplus_primitive_types
1194 cplus_language_arch_info (struct gdbarch
*gdbarch
,
1195 struct language_arch_info
*lai
)
1197 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1198 lai
->string_char_type
= builtin
->builtin_char
;
1199 lai
->primitive_type_vector
1200 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
1202 lai
->primitive_type_vector
[cplus_primitive_type_int
]
1203 = builtin
->builtin_int
;
1204 lai
->primitive_type_vector
[cplus_primitive_type_long
]
1205 = builtin
->builtin_long
;
1206 lai
->primitive_type_vector
[cplus_primitive_type_short
]
1207 = builtin
->builtin_short
;
1208 lai
->primitive_type_vector
[cplus_primitive_type_char
]
1209 = builtin
->builtin_char
;
1210 lai
->primitive_type_vector
[cplus_primitive_type_float
]
1211 = builtin
->builtin_float
;
1212 lai
->primitive_type_vector
[cplus_primitive_type_double
]
1213 = builtin
->builtin_double
;
1214 lai
->primitive_type_vector
[cplus_primitive_type_void
]
1215 = builtin
->builtin_void
;
1216 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
1217 = builtin
->builtin_long_long
;
1218 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
1219 = builtin
->builtin_signed_char
;
1220 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
1221 = builtin
->builtin_unsigned_char
;
1222 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
1223 = builtin
->builtin_unsigned_short
;
1224 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
1225 = builtin
->builtin_unsigned_int
;
1226 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
1227 = builtin
->builtin_unsigned_long
;
1228 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
1229 = builtin
->builtin_unsigned_long_long
;
1230 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
1231 = builtin
->builtin_long_double
;
1232 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
1233 = builtin
->builtin_complex
;
1234 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
1235 = builtin
->builtin_double_complex
;
1236 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
1237 = builtin
->builtin_bool
;
1238 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
1239 = builtin
->builtin_decfloat
;
1240 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
1241 = builtin
->builtin_decdouble
;
1242 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
1243 = builtin
->builtin_declong
;
1245 lai
->bool_type_symbol
= "bool";
1246 lai
->bool_type_default
= builtin
->builtin_bool
;
1249 const struct language_defn cplus_language_defn
=
1251 "c++", /* Language name */
1262 c_printchar
, /* Print a character constant */
1263 c_printstr
, /* Function to print string constant */
1264 c_emit_char
, /* Print a single char */
1265 c_print_type
, /* Print a type using appropriate syntax */
1266 c_print_typedef
, /* Print a typedef using appropriate syntax */
1267 c_val_print
, /* Print a value using appropriate syntax */
1268 c_value_print
, /* Print a top-level value */
1269 cplus_skip_trampoline
, /* Language specific skip_trampoline */
1270 "this", /* name_of_this */
1271 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1272 cp_lookup_transparent_type
, /* lookup_transparent_type */
1273 cplus_demangle
, /* Language specific symbol demangler */
1274 cp_class_name_from_physname
, /* Language specific class_name_from_physname */
1275 c_op_print_tab
, /* expression operators for printing */
1276 1, /* c-style arrays */
1277 0, /* String lower bound */
1278 default_word_break_characters
,
1279 default_make_symbol_completion_list
,
1280 cplus_language_arch_info
,
1281 default_print_array_index
,
1282 cp_pass_by_reference
,
1287 const struct language_defn asm_language_defn
=
1289 "asm", /* Language name */
1300 c_printchar
, /* Print a character constant */
1301 c_printstr
, /* Function to print string constant */
1302 c_emit_char
, /* Print a single char */
1303 c_print_type
, /* Print a type using appropriate syntax */
1304 c_print_typedef
, /* Print a typedef using appropriate syntax */
1305 c_val_print
, /* Print a value using appropriate syntax */
1306 c_value_print
, /* Print a top-level value */
1307 NULL
, /* Language specific skip_trampoline */
1308 NULL
, /* name_of_this */
1309 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1310 basic_lookup_transparent_type
,/* lookup_transparent_type */
1311 NULL
, /* Language specific symbol demangler */
1312 NULL
, /* Language specific class_name_from_physname */
1313 c_op_print_tab
, /* expression operators for printing */
1314 1, /* c-style arrays */
1315 0, /* String lower bound */
1316 default_word_break_characters
,
1317 default_make_symbol_completion_list
,
1318 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1319 default_print_array_index
,
1320 default_pass_by_reference
,
1325 /* The following language_defn does not represent a real language.
1326 It just provides a minimal support a-la-C that should allow users
1327 to do some simple operations when debugging applications that use
1328 a language currently not supported by GDB. */
1330 const struct language_defn minimal_language_defn
=
1332 "minimal", /* Language name */
1343 c_printchar
, /* Print a character constant */
1344 c_printstr
, /* Function to print string constant */
1345 c_emit_char
, /* Print a single char */
1346 c_print_type
, /* Print a type using appropriate syntax */
1347 c_print_typedef
, /* Print a typedef using appropriate syntax */
1348 c_val_print
, /* Print a value using appropriate syntax */
1349 c_value_print
, /* Print a top-level value */
1350 NULL
, /* Language specific skip_trampoline */
1351 NULL
, /* name_of_this */
1352 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1353 basic_lookup_transparent_type
,/* lookup_transparent_type */
1354 NULL
, /* Language specific symbol demangler */
1355 NULL
, /* Language specific class_name_from_physname */
1356 c_op_print_tab
, /* expression operators for printing */
1357 1, /* c-style arrays */
1358 0, /* String lower bound */
1359 default_word_break_characters
,
1360 default_make_symbol_completion_list
,
1361 c_language_arch_info
,
1362 default_print_array_index
,
1363 default_pass_by_reference
,
1369 _initialize_c_language (void)
1371 add_language (&c_language_defn
);
1372 add_language (&cplus_language_defn
);
1373 add_language (&asm_language_defn
);
1374 add_language (&minimal_language_defn
);