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, 2010 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 struct gdbarch
*gdbarch
)
48 switch (str_type
& ~C_CHAR
)
51 return target_charset (gdbarch
);
53 return target_wide_charset (gdbarch
);
55 /* FIXME: UTF-16 is not always correct. */
56 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
61 /* FIXME: UTF-32 is not always correct. */
62 if (gdbarch_byte_order (gdbarch
) == 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
, struct gdbarch
*gdbarch
,
77 const char **encoding
)
79 enum c_string_type result
;
81 /* We loop because ELTTYPE may be a typedef, and we want to
82 successively peel each typedef until we reach a type we
83 understand. We don't use CHECK_TYPEDEF because that will strip
84 all typedefs at once -- but in C, wchar_t is itself a typedef, so
85 that would do the wrong thing. */
88 char *name
= TYPE_NAME (elttype
);
90 if (TYPE_CODE (elttype
) == TYPE_CODE_CHAR
|| !name
)
96 if (!strcmp (name
, "wchar_t"))
102 if (!strcmp (name
, "char16_t"))
108 if (!strcmp (name
, "char32_t"))
114 if (TYPE_CODE (elttype
) != TYPE_CODE_TYPEDEF
)
117 /* Call for side effects. */
118 check_typedef (elttype
);
120 if (TYPE_TARGET_TYPE (elttype
))
121 elttype
= TYPE_TARGET_TYPE (elttype
);
124 /* Perhaps check_typedef did not update the target type. In
125 this case, force the lookup again and hope it works out.
126 It never will for C, but it might for C++. */
127 CHECK_TYPEDEF (elttype
);
136 *encoding
= charset_for_string_type (result
, gdbarch
);
141 /* Return true if print_wchar can display W without resorting to a
142 numeric escape, false otherwise. */
145 wchar_printable (gdb_wchar_t w
)
147 return (gdb_iswprint (w
)
148 || w
== LCST ('\a') || w
== LCST ('\b')
149 || w
== LCST ('\f') || w
== LCST ('\n')
150 || w
== LCST ('\r') || w
== LCST ('\t')
151 || w
== LCST ('\v'));
154 /* A helper function that converts the contents of STRING to wide
155 characters and then appends them to OUTPUT. */
158 append_string_as_wide (const char *string
, struct obstack
*output
)
160 for (; *string
; ++string
)
162 gdb_wchar_t w
= gdb_btowc (*string
);
163 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
167 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
168 original (target) bytes representing the character, ORIG_LEN is the
169 number of valid bytes. WIDTH is the number of bytes in a base
170 characters of the type. OUTPUT is an obstack to which wide
171 characters are emitted. QUOTER is a (narrow) character indicating
172 the style of quotes surrounding the character to be printed.
173 NEED_ESCAPE is an in/out flag which is used to track numeric
174 escapes across calls. */
177 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
, int orig_len
,
178 int width
, enum bfd_endian byte_order
, struct obstack
*output
,
179 int quoter
, int *need_escapep
)
181 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
)
228 value
= extract_unsigned_integer (&orig
[i
], width
, byte_order
);
229 /* If the value fits in 3 octal digits, print it that
230 way. Otherwise, print it as a hex escape. */
232 sprintf (octal
, "\\%.3o", (int) (value
& 0777));
234 sprintf (octal
, "\\x%lx", (long) value
);
235 append_string_as_wide (octal
, output
);
237 /* If we somehow have extra bytes, print them now. */
242 sprintf (octal
, "\\%.3o", orig
[i
] & 0xff);
243 append_string_as_wide (octal
, output
);
254 /* Print the character C on STREAM as part of the contents of a literal
255 string whose delimiter is QUOTER. Note that that format for printing
256 characters and strings is language specific. */
259 c_emit_char (int c
, struct type
*type
,
260 struct ui_file
*stream
, int quoter
)
262 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
263 struct obstack wchar_buf
, output
;
264 struct cleanup
*cleanups
;
265 const char *encoding
;
267 struct wchar_iterator
*iter
;
270 classify_type (type
, get_type_arch (type
), &encoding
);
272 buf
= alloca (TYPE_LENGTH (type
));
273 pack_long (buf
, type
, c
);
275 iter
= make_wchar_iterator (buf
, TYPE_LENGTH (type
), encoding
,
277 cleanups
= make_cleanup_wchar_iterator (iter
);
279 /* This holds the printable form of the wchar_t data. */
280 obstack_init (&wchar_buf
);
281 make_cleanup_obstack_free (&wchar_buf
);
289 int print_escape
= 1;
290 enum wchar_iterate_result result
;
292 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
297 /* If all characters are printable, print them. Otherwise,
298 we're going to have to print an escape sequence. We
299 check all characters because we want to print the target
300 bytes in the escape sequence, and we don't know character
305 for (i
= 0; i
< num_chars
; ++i
)
306 if (!wchar_printable (chars
[i
]))
314 for (i
= 0; i
< num_chars
; ++i
)
315 print_wchar (chars
[i
], buf
, buflen
, TYPE_LENGTH (type
),
316 byte_order
, &wchar_buf
, quoter
, &need_escape
);
320 /* This handles the NUM_CHARS == 0 case as well. */
322 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
), byte_order
,
323 &wchar_buf
, quoter
, &need_escape
);
326 /* The output in the host encoding. */
327 obstack_init (&output
);
328 make_cleanup_obstack_free (&output
);
330 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
331 obstack_base (&wchar_buf
),
332 obstack_object_size (&wchar_buf
),
333 1, &output
, translit_char
);
334 obstack_1grow (&output
, '\0');
336 fputs_filtered (obstack_base (&output
), stream
);
338 do_cleanups (cleanups
);
342 c_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
344 enum c_string_type str_type
;
346 str_type
= classify_type (type
, get_type_arch (type
), NULL
);
352 fputc_filtered ('L', stream
);
355 fputc_filtered ('u', stream
);
358 fputc_filtered ('U', stream
);
362 fputc_filtered ('\'', stream
);
363 LA_EMIT_CHAR (c
, type
, stream
, '\'');
364 fputc_filtered ('\'', stream
);
367 /* Print the character string STRING, printing at most LENGTH characters.
368 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
369 long. Printing stops early if the number hits print_max; repeat counts are
370 printed as appropriate. Print ellipses at the end if we had to stop before
371 printing LENGTH characters, or if FORCE_ELLIPSES. */
374 c_printstr (struct ui_file
*stream
, struct type
*type
, const gdb_byte
*string
,
375 unsigned int length
, const char *user_encoding
, int force_ellipses
,
376 const struct value_print_options
*options
)
378 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
380 unsigned int things_printed
= 0;
383 int width
= TYPE_LENGTH (type
);
384 struct obstack wchar_buf
, output
;
385 struct cleanup
*cleanup
;
386 enum c_string_type str_type
;
387 const char *type_encoding
;
388 const char *encoding
;
389 struct wchar_iterator
*iter
;
395 unsigned long current_char
= 1;
397 for (i
= 0; current_char
; ++i
)
400 current_char
= extract_unsigned_integer (string
+ i
* width
,
406 /* If the string was not truncated due to `set print elements', and
407 the last byte of it is a null, we don't print that, in traditional C
411 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
412 width
, byte_order
) == 0))
415 str_type
= (classify_type (type
, get_type_arch (type
), &type_encoding
)
422 fputs_filtered ("L", stream
);
425 fputs_filtered ("u", stream
);
428 fputs_filtered ("U", stream
);
432 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
436 fputs_filtered ("\"\"", stream
);
440 /* Arrange to iterate over the characters, in wchar_t form. */
441 iter
= make_wchar_iterator (string
, length
* width
, encoding
, width
);
442 cleanup
= make_cleanup_wchar_iterator (iter
);
444 /* WCHAR_BUF is the obstack we use to represent the string in
446 obstack_init (&wchar_buf
);
447 make_cleanup_obstack_free (&wchar_buf
);
449 while (!finished
&& things_printed
< options
->print_max
)
452 enum wchar_iterate_result result
;
461 obstack_grow_wstr (&wchar_buf
, LCST (", "));
465 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
466 /* We only look at repetitions when we were able to convert a
467 single character in isolation. This makes the code simpler
468 and probably does the sensible thing in the majority of
470 while (num_chars
== 1 && things_printed
< options
->print_max
)
472 /* Count the number of repetitions. */
473 unsigned int reps
= 0;
474 gdb_wchar_t current_char
= chars
[0];
475 const gdb_byte
*orig_buf
= buf
;
476 int orig_len
= buflen
;
480 obstack_grow_wstr (&wchar_buf
, LCST (", "));
484 while (num_chars
== 1 && current_char
== chars
[0])
486 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
490 /* Emit CURRENT_CHAR according to the repetition count and
492 if (reps
> options
->repeat_count_threshold
)
496 if (options
->inspect_it
)
497 obstack_grow_wstr (&wchar_buf
, LCST ("\\\", "));
499 obstack_grow_wstr (&wchar_buf
, LCST ("\", "));
502 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
504 print_wchar (current_char
, orig_buf
, orig_len
, width
,
505 byte_order
, &wchar_buf
, '\'', &need_escape
);
506 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
508 /* Painful gyrations. */
510 char *s
= xstrprintf (_(" <repeats %u times>"), reps
);
512 for (j
= 0; s
[j
]; ++j
)
514 gdb_wchar_t w
= gdb_btowc (s
[j
]);
515 obstack_grow (&wchar_buf
, &w
, sizeof (gdb_wchar_t
));
519 things_printed
+= options
->repeat_count_threshold
;
524 /* Saw the character one or more times, but fewer than
525 the repetition threshold. */
528 if (options
->inspect_it
)
529 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
531 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
538 print_wchar (current_char
, orig_buf
, orig_len
, width
,
539 byte_order
, &wchar_buf
, '"', &need_escape
);
545 /* NUM_CHARS and the other outputs from wchar_iterate are valid
546 here regardless of which branch was taken above. */
556 case wchar_iterate_invalid
:
559 if (options
->inspect_it
)
560 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
562 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
566 print_wchar (gdb_WEOF
, buf
, buflen
, width
, byte_order
, &wchar_buf
,
570 case wchar_iterate_incomplete
:
573 if (options
->inspect_it
)
574 obstack_grow_wstr (&wchar_buf
, LCST ("\\\","));
576 obstack_grow_wstr (&wchar_buf
, LCST ("\","));
579 obstack_grow_wstr (&wchar_buf
, LCST (" <incomplete sequence "));
580 print_wchar (gdb_WEOF
, buf
, buflen
, width
, byte_order
, &wchar_buf
,
582 obstack_grow_wstr (&wchar_buf
, LCST (">"));
588 /* Terminate the quotes if necessary. */
591 if (options
->inspect_it
)
592 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
594 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
597 if (force_ellipses
|| !finished
)
598 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
600 /* OUTPUT is where we collect `char's for printing. */
601 obstack_init (&output
);
602 make_cleanup_obstack_free (&output
);
604 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
605 obstack_base (&wchar_buf
),
606 obstack_object_size (&wchar_buf
),
607 1, &output
, translit_char
);
608 obstack_1grow (&output
, '\0');
610 fputs_filtered (obstack_base (&output
), stream
);
612 do_cleanups (cleanup
);
615 /* Obtain a C string from the inferior storing it in a newly allocated
616 buffer in BUFFER, which should be freed by the caller. If the
617 in- and out-parameter *LENGTH is specified at -1, the string is read
618 until a null character of the appropriate width is found, otherwise
619 the string is read to the length of characters specified.
620 The size of a character is determined by the length of the target
621 type of the pointer or array. If VALUE is an array with a known
622 length, the function will not read past the end of the array.
623 On completion, *LENGTH will be set to the size of the string read in
624 characters. (If a length of -1 is specified, the length returned
625 will not include the null character). CHARSET is always set to the
629 c_get_string (struct value
*value
, gdb_byte
**buffer
, int *length
,
630 struct type
**char_type
, const char **charset
)
633 unsigned int fetchlimit
;
634 struct type
*type
= check_typedef (value_type (value
));
635 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
636 int req_length
= *length
;
637 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
638 enum c_string_type kind
;
640 if (element_type
== NULL
)
643 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
645 /* If we know the size of the array, we can use it as a limit on the
646 number of characters to be fetched. */
647 if (TYPE_NFIELDS (type
) == 1
648 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
650 LONGEST low_bound
, high_bound
;
652 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
653 &low_bound
, &high_bound
);
654 fetchlimit
= high_bound
- low_bound
+ 1;
657 fetchlimit
= UINT_MAX
;
659 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
660 fetchlimit
= UINT_MAX
;
662 /* We work only with arrays and pointers. */
665 if (! c_textual_element_type (element_type
, 0))
667 kind
= classify_type (element_type
,
668 get_type_arch (element_type
),
670 width
= TYPE_LENGTH (element_type
);
672 /* If the string lives in GDB's memory instead of the inferior's, then we
673 just need to copy it to BUFFER. Also, since such strings are arrays
674 with known size, FETCHLIMIT will hold the size of the array. */
675 if ((VALUE_LVAL (value
) == not_lval
676 || VALUE_LVAL (value
) == lval_internalvar
)
677 && fetchlimit
!= UINT_MAX
)
680 const gdb_byte
*contents
= value_contents (value
);
682 /* If a length is specified, use that. */
686 /* Otherwise, look for a null character. */
687 for (i
= 0; i
< fetchlimit
; i
++)
688 if (extract_unsigned_integer (contents
+ i
* width
, width
,
692 /* I is now either a user-defined length, the number of non-null
693 characters, or FETCHLIMIT. */
695 *buffer
= xmalloc (*length
);
696 memcpy (*buffer
, contents
, *length
);
701 err
= read_string (value_as_address (value
), *length
, width
, fetchlimit
,
702 byte_order
, buffer
, length
);
706 error (_("Error reading string from inferior: %s"),
707 safe_strerror (err
));
711 /* If the LENGTH is specified at -1, we want to return the string
712 length up to the terminating null character. If an actual length
713 was specified, we want to return the length of exactly what was
715 if (req_length
== -1)
716 /* If the last character is null, subtract it from LENGTH. */
718 && extract_unsigned_integer (*buffer
+ *length
- width
, width
,
722 /* The read_string function will return the number of bytes read.
723 If length returned from read_string was > 0, return the number of
724 characters read by dividing the number of bytes by width. */
726 *length
= *length
/ width
;
728 *char_type
= element_type
;
736 type_str
= type_to_string (type
);
739 make_cleanup (xfree
, type_str
);
740 error (_("Trying to read string with inappropriate type `%s'."),
744 error (_("Trying to read string with inappropriate type."));
749 /* Evaluating C and C++ expressions. */
751 /* Convert a UCN. The digits of the UCN start at P and extend no
752 farther than LIMIT. DEST_CHARSET is the name of the character set
753 into which the UCN should be converted. The results are written to
754 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
755 Returns a pointer to just after the final digit of the UCN. */
758 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
759 struct obstack
*output
, int length
)
761 unsigned long result
= 0;
765 for (i
= 0; i
< length
&& p
< limit
&& isxdigit (*p
); ++i
, ++p
)
766 result
= (result
<< 4) + host_hex_value (*p
);
768 for (i
= 3; i
>= 0; --i
)
770 data
[i
] = result
& 0xff;
774 convert_between_encodings ("UTF-32BE", dest_charset
, data
, 4, 4, output
,
780 /* Emit a character, VALUE, which was specified numerically, to
781 OUTPUT. TYPE is the target character type. */
784 emit_numeric_character (struct type
*type
, unsigned long value
,
785 struct obstack
*output
)
789 buffer
= alloca (TYPE_LENGTH (type
));
790 pack_long (buffer
, type
, value
);
791 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
794 /* Convert an octal escape sequence. TYPE is the target character
795 type. The digits of the escape sequence begin at P and extend no
796 farther than LIMIT. The result is written to OUTPUT. Returns a
797 pointer to just after the final digit of the escape sequence. */
800 convert_octal (struct type
*type
, char *p
, char *limit
, struct obstack
*output
)
803 unsigned long value
= 0;
806 i
< 3 && p
< limit
&& isdigit (*p
) && *p
!= '8' && *p
!= '9';
809 value
= 8 * value
+ host_hex_value (*p
);
813 emit_numeric_character (type
, value
, output
);
818 /* Convert a hex escape sequence. TYPE is the target character type.
819 The digits of the escape sequence begin at P and extend no farther
820 than LIMIT. The result is written to OUTPUT. Returns a pointer to
821 just after the final digit of the escape sequence. */
824 convert_hex (struct type
*type
, char *p
, char *limit
, struct obstack
*output
)
826 unsigned long value
= 0;
828 while (p
< limit
&& isxdigit (*p
))
830 value
= 16 * value
+ host_hex_value (*p
);
834 emit_numeric_character (type
, value
, output
);
843 error (_("Malformed escape sequence")); \
846 /* Convert an escape sequence to a target format. TYPE is the target
847 character type to use, and DEST_CHARSET is the name of the target
848 character set. The backslash of the escape sequence is at *P, and
849 the escape sequence will not extend past LIMIT. The results are
850 written to OUTPUT. Returns a pointer to just past the final
851 character of the escape sequence. */
854 convert_escape (struct type
*type
, const char *dest_charset
,
855 char *p
, char *limit
, struct obstack
*output
)
857 /* Skip the backslash. */
863 obstack_1grow (output
, '\\');
870 error (_("\\x used with no following hex digits."));
871 p
= convert_hex (type
, p
, limit
, output
);
882 p
= convert_octal (type
, p
, limit
, output
);
888 int length
= *p
== 'u' ? 4 : 8;
892 error (_("\\u used with no following hex digits"));
893 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
900 /* Given a single string from a (C-specific) OP_STRING list, convert
901 it to a target string, handling escape sequences specially. The
902 output is written to OUTPUT. DATA is the input string, which has
903 length LEN. DEST_CHARSET is the name of the target character set,
904 and TYPE is the type of target character to use. */
907 parse_one_string (struct obstack
*output
, char *data
, int len
,
908 const char *dest_charset
, struct type
*type
)
918 /* Look for next escape, or the end of the input. */
919 while (p
< limit
&& *p
!= '\\')
921 /* If we saw a run of characters, convert them all. */
923 convert_between_encodings (host_charset (), dest_charset
,
924 data
, p
- data
, 1, output
, translit_none
);
925 /* If we saw an escape, convert it. */
927 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
932 /* Expression evaluator for the C language family. Most operations
933 are delegated to evaluate_subexp_standard; see that function for a
934 description of the arguments. */
936 static struct value
*
937 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
938 int *pos
, enum noside noside
)
940 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
948 struct obstack output
;
949 struct cleanup
*cleanup
;
950 struct value
*result
;
951 enum c_string_type dest_type
;
952 const char *dest_charset
;
954 obstack_init (&output
);
955 cleanup
= make_cleanup_obstack_free (&output
);
958 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
961 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
963 = (enum c_string_type
) longest_to_int (exp
->elts
[*pos
].longconst
);
964 switch (dest_type
& ~C_CHAR
)
967 type
= language_string_char_type (exp
->language_defn
,
971 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
975 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
976 "char16_t", NULL
, 0);
979 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
980 "char32_t", NULL
, 0);
983 internal_error (__FILE__
, __LINE__
, "unhandled c_string_type");
986 /* Ensure TYPE_LENGTH is valid for TYPE. */
987 check_typedef (type
);
989 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
996 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
999 if (noside
!= EVAL_SKIP
)
1000 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
1001 dest_charset
, type
);
1002 *pos
+= BYTES_TO_EXP_ELEM (len
);
1005 /* Skip the trailing length and opcode. */
1008 if (noside
== EVAL_SKIP
)
1010 /* Return a dummy value of the appropriate type. */
1011 if ((dest_type
& C_CHAR
) != 0)
1012 result
= allocate_value (type
);
1014 result
= value_cstring ("", 0, type
);
1015 do_cleanups (cleanup
);
1019 if ((dest_type
& C_CHAR
) != 0)
1023 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
1024 error (_("Could not convert character constant to target character set"));
1025 value
= unpack_long (type
, obstack_base (&output
));
1026 result
= value_from_longest (type
, value
);
1032 /* Write the terminating character. */
1033 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
1034 obstack_1grow (&output
, 0);
1035 result
= value_cstring (obstack_base (&output
),
1036 obstack_object_size (&output
),
1039 do_cleanups (cleanup
);
1047 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1052 /* Table mapping opcodes into strings for printing operators
1053 and precedences of the operators. */
1055 const struct op_print c_op_print_tab
[] =
1057 {",", BINOP_COMMA
, PREC_COMMA
, 0},
1058 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
1059 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
1060 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
1061 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
1062 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
1063 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
1064 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
1065 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
1066 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
1067 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
1068 {">", BINOP_GTR
, PREC_ORDER
, 0},
1069 {"<", BINOP_LESS
, PREC_ORDER
, 0},
1070 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
1071 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
1072 {"+", BINOP_ADD
, PREC_ADD
, 0},
1073 {"-", BINOP_SUB
, PREC_ADD
, 0},
1074 {"*", BINOP_MUL
, PREC_MUL
, 0},
1075 {"/", BINOP_DIV
, PREC_MUL
, 0},
1076 {"%", BINOP_REM
, PREC_MUL
, 0},
1077 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
1078 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
1079 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
1080 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
1081 {"*", UNOP_IND
, PREC_PREFIX
, 0},
1082 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
1083 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
1084 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
1085 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
1089 enum c_primitive_types
{
1090 c_primitive_type_int
,
1091 c_primitive_type_long
,
1092 c_primitive_type_short
,
1093 c_primitive_type_char
,
1094 c_primitive_type_float
,
1095 c_primitive_type_double
,
1096 c_primitive_type_void
,
1097 c_primitive_type_long_long
,
1098 c_primitive_type_signed_char
,
1099 c_primitive_type_unsigned_char
,
1100 c_primitive_type_unsigned_short
,
1101 c_primitive_type_unsigned_int
,
1102 c_primitive_type_unsigned_long
,
1103 c_primitive_type_unsigned_long_long
,
1104 c_primitive_type_long_double
,
1105 c_primitive_type_complex
,
1106 c_primitive_type_double_complex
,
1107 c_primitive_type_decfloat
,
1108 c_primitive_type_decdouble
,
1109 c_primitive_type_declong
,
1110 nr_c_primitive_types
1114 c_language_arch_info (struct gdbarch
*gdbarch
,
1115 struct language_arch_info
*lai
)
1117 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1119 lai
->string_char_type
= builtin
->builtin_char
;
1120 lai
->primitive_type_vector
1121 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
1123 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
1124 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
1125 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
1126 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
1127 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
1128 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
1129 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
1130 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
1131 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
1132 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
1133 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
1134 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
1135 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
1136 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
1137 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
1138 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
1139 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
1140 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
1141 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
1142 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
1144 lai
->bool_type_default
= builtin
->builtin_int
;
1147 const struct exp_descriptor exp_descriptor_c
=
1149 print_subexp_standard
,
1150 operator_length_standard
,
1151 operator_check_standard
,
1153 dump_subexp_body_standard
,
1157 const struct language_defn c_language_defn
=
1159 "c", /* Language name */
1170 c_printchar
, /* Print a character constant */
1171 c_printstr
, /* Function to print string constant */
1172 c_emit_char
, /* Print a single char */
1173 c_print_type
, /* Print a type using appropriate syntax */
1174 c_print_typedef
, /* Print a typedef using appropriate syntax */
1175 c_val_print
, /* Print a value using appropriate syntax */
1176 c_value_print
, /* Print a top-level value */
1177 NULL
, /* Language specific skip_trampoline */
1178 NULL
, /* name_of_this */
1179 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1180 basic_lookup_transparent_type
,/* lookup_transparent_type */
1181 NULL
, /* Language specific symbol demangler */
1182 NULL
, /* Language specific class_name_from_physname */
1183 c_op_print_tab
, /* expression operators for printing */
1184 1, /* c-style arrays */
1185 0, /* String lower bound */
1186 default_word_break_characters
,
1187 default_make_symbol_completion_list
,
1188 c_language_arch_info
,
1189 default_print_array_index
,
1190 default_pass_by_reference
,
1195 enum cplus_primitive_types
{
1196 cplus_primitive_type_int
,
1197 cplus_primitive_type_long
,
1198 cplus_primitive_type_short
,
1199 cplus_primitive_type_char
,
1200 cplus_primitive_type_float
,
1201 cplus_primitive_type_double
,
1202 cplus_primitive_type_void
,
1203 cplus_primitive_type_long_long
,
1204 cplus_primitive_type_signed_char
,
1205 cplus_primitive_type_unsigned_char
,
1206 cplus_primitive_type_unsigned_short
,
1207 cplus_primitive_type_unsigned_int
,
1208 cplus_primitive_type_unsigned_long
,
1209 cplus_primitive_type_unsigned_long_long
,
1210 cplus_primitive_type_long_double
,
1211 cplus_primitive_type_complex
,
1212 cplus_primitive_type_double_complex
,
1213 cplus_primitive_type_bool
,
1214 cplus_primitive_type_decfloat
,
1215 cplus_primitive_type_decdouble
,
1216 cplus_primitive_type_declong
,
1217 nr_cplus_primitive_types
1221 cplus_language_arch_info (struct gdbarch
*gdbarch
,
1222 struct language_arch_info
*lai
)
1224 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1226 lai
->string_char_type
= builtin
->builtin_char
;
1227 lai
->primitive_type_vector
1228 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
1230 lai
->primitive_type_vector
[cplus_primitive_type_int
]
1231 = builtin
->builtin_int
;
1232 lai
->primitive_type_vector
[cplus_primitive_type_long
]
1233 = builtin
->builtin_long
;
1234 lai
->primitive_type_vector
[cplus_primitive_type_short
]
1235 = builtin
->builtin_short
;
1236 lai
->primitive_type_vector
[cplus_primitive_type_char
]
1237 = builtin
->builtin_char
;
1238 lai
->primitive_type_vector
[cplus_primitive_type_float
]
1239 = builtin
->builtin_float
;
1240 lai
->primitive_type_vector
[cplus_primitive_type_double
]
1241 = builtin
->builtin_double
;
1242 lai
->primitive_type_vector
[cplus_primitive_type_void
]
1243 = builtin
->builtin_void
;
1244 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
1245 = builtin
->builtin_long_long
;
1246 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
1247 = builtin
->builtin_signed_char
;
1248 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
1249 = builtin
->builtin_unsigned_char
;
1250 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
1251 = builtin
->builtin_unsigned_short
;
1252 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
1253 = builtin
->builtin_unsigned_int
;
1254 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
1255 = builtin
->builtin_unsigned_long
;
1256 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
1257 = builtin
->builtin_unsigned_long_long
;
1258 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
1259 = builtin
->builtin_long_double
;
1260 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
1261 = builtin
->builtin_complex
;
1262 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
1263 = builtin
->builtin_double_complex
;
1264 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
1265 = builtin
->builtin_bool
;
1266 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
1267 = builtin
->builtin_decfloat
;
1268 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
1269 = builtin
->builtin_decdouble
;
1270 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
1271 = builtin
->builtin_declong
;
1273 lai
->bool_type_symbol
= "bool";
1274 lai
->bool_type_default
= builtin
->builtin_bool
;
1277 const struct language_defn cplus_language_defn
=
1279 "c++", /* Language name */
1290 c_printchar
, /* Print a character constant */
1291 c_printstr
, /* Function to print string constant */
1292 c_emit_char
, /* Print a single char */
1293 c_print_type
, /* Print a type using appropriate syntax */
1294 c_print_typedef
, /* Print a typedef using appropriate syntax */
1295 c_val_print
, /* Print a value using appropriate syntax */
1296 c_value_print
, /* Print a top-level value */
1297 cplus_skip_trampoline
, /* Language specific skip_trampoline */
1298 "this", /* name_of_this */
1299 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1300 cp_lookup_transparent_type
, /* lookup_transparent_type */
1301 cplus_demangle
, /* Language specific symbol demangler */
1302 cp_class_name_from_physname
, /* Language specific class_name_from_physname */
1303 c_op_print_tab
, /* expression operators for printing */
1304 1, /* c-style arrays */
1305 0, /* String lower bound */
1306 default_word_break_characters
,
1307 default_make_symbol_completion_list
,
1308 cplus_language_arch_info
,
1309 default_print_array_index
,
1310 cp_pass_by_reference
,
1315 const struct language_defn asm_language_defn
=
1317 "asm", /* Language name */
1328 c_printchar
, /* Print a character constant */
1329 c_printstr
, /* Function to print string constant */
1330 c_emit_char
, /* Print a single char */
1331 c_print_type
, /* Print a type using appropriate syntax */
1332 c_print_typedef
, /* Print a typedef using appropriate syntax */
1333 c_val_print
, /* Print a value using appropriate syntax */
1334 c_value_print
, /* Print a top-level value */
1335 NULL
, /* Language specific skip_trampoline */
1336 NULL
, /* name_of_this */
1337 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1338 basic_lookup_transparent_type
,/* lookup_transparent_type */
1339 NULL
, /* Language specific symbol demangler */
1340 NULL
, /* Language specific class_name_from_physname */
1341 c_op_print_tab
, /* expression operators for printing */
1342 1, /* c-style arrays */
1343 0, /* String lower bound */
1344 default_word_break_characters
,
1345 default_make_symbol_completion_list
,
1346 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1347 default_print_array_index
,
1348 default_pass_by_reference
,
1353 /* The following language_defn does not represent a real language.
1354 It just provides a minimal support a-la-C that should allow users
1355 to do some simple operations when debugging applications that use
1356 a language currently not supported by GDB. */
1358 const struct language_defn minimal_language_defn
=
1360 "minimal", /* Language name */
1371 c_printchar
, /* Print a character constant */
1372 c_printstr
, /* Function to print string constant */
1373 c_emit_char
, /* Print a single char */
1374 c_print_type
, /* Print a type using appropriate syntax */
1375 c_print_typedef
, /* Print a typedef using appropriate syntax */
1376 c_val_print
, /* Print a value using appropriate syntax */
1377 c_value_print
, /* Print a top-level value */
1378 NULL
, /* Language specific skip_trampoline */
1379 NULL
, /* name_of_this */
1380 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1381 basic_lookup_transparent_type
,/* lookup_transparent_type */
1382 NULL
, /* Language specific symbol demangler */
1383 NULL
, /* Language specific class_name_from_physname */
1384 c_op_print_tab
, /* expression operators for printing */
1385 1, /* c-style arrays */
1386 0, /* String lower bound */
1387 default_word_break_characters
,
1388 default_make_symbol_completion_list
,
1389 c_language_arch_info
,
1390 default_print_array_index
,
1391 default_pass_by_reference
,
1397 _initialize_c_language (void)
1399 add_language (&c_language_defn
);
1400 add_language (&cplus_language_defn
);
1401 add_language (&asm_language_defn
);
1402 add_language (&minimal_language_defn
);