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 enum bfd_endian byte_order
)
48 switch (str_type
& ~C_CHAR
)
51 return target_charset ();
53 return target_wide_charset (byte_order
);
55 /* FIXME: UTF-16 is not always correct. */
56 if (byte_order
== BFD_ENDIAN_BIG
)
61 /* FIXME: UTF-32 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
, const char *user_encoding
, 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 *type_encoding
;
385 const char *encoding
;
386 struct wchar_iterator
*iter
;
390 /* If the string was not truncated due to `set print elements', and
391 the last byte of it is a null, we don't print that, in traditional C
395 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
396 width
, byte_order
) == 0))
399 str_type
= classify_type (type
, byte_order
, &type_encoding
) & ~C_CHAR
;
405 fputs_filtered ("L", stream
);
408 fputs_filtered ("u", stream
);
411 fputs_filtered ("U", stream
);
415 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
419 fputs_filtered ("\"\"", stream
);
425 unsigned long current_char
= 1;
426 for (i
= 0; current_char
; ++i
)
429 current_char
= extract_unsigned_integer (string
+ i
* width
,
435 /* Arrange to iterate over the characters, in wchar_t form. */
436 iter
= make_wchar_iterator (string
, length
* width
, encoding
, width
);
437 cleanup
= make_cleanup_wchar_iterator (iter
);
439 /* WCHAR_BUF is the obstack we use to represent the string in
441 obstack_init (&wchar_buf
);
442 make_cleanup_obstack_free (&wchar_buf
);
444 while (!finished
&& things_printed
< options
->print_max
)
447 enum wchar_iterate_result result
;
456 obstack_grow_wstr (&wchar_buf
, LCST (", "));
460 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
461 /* We only look at repetitions when we were able to convert a
462 single character in isolation. This makes the code simpler
463 and probably does the sensible thing in the majority of
465 while (num_chars
== 1 && things_printed
< options
->print_max
)
467 /* Count the number of repetitions. */
468 unsigned int reps
= 0;
469 gdb_wchar_t current_char
= chars
[0];
470 const gdb_byte
*orig_buf
= buf
;
471 int orig_len
= buflen
;
475 obstack_grow_wstr (&wchar_buf
, LCST (", "));
479 while (num_chars
== 1 && current_char
== chars
[0])
481 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
485 /* Emit CURRENT_CHAR according to the repetition count and
487 if (reps
> options
->repeat_count_threshold
)
491 if (options
->inspect_it
)
492 obstack_grow_wstr (&wchar_buf
, LCST ("\\\", "));
494 obstack_grow_wstr (&wchar_buf
, LCST ("\", "));
497 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
499 print_wchar (current_char
, orig_buf
, orig_len
, width
,
500 byte_order
, &wchar_buf
, '\'', &need_escape
);
501 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
503 /* Painful gyrations. */
505 char *s
= xstrprintf (_(" <repeats %u times>"), reps
);
506 for (j
= 0; s
[j
]; ++j
)
508 gdb_wchar_t w
= gdb_btowc (s
[j
]);
509 obstack_grow (&wchar_buf
, &w
, sizeof (gdb_wchar_t
));
513 things_printed
+= options
->repeat_count_threshold
;
518 /* Saw the character one or more times, but fewer than
519 the repetition threshold. */
522 if (options
->inspect_it
)
523 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
525 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
532 print_wchar (current_char
, orig_buf
, orig_len
, width
,
533 byte_order
, &wchar_buf
, '"', &need_escape
);
539 /* NUM_CHARS and the other outputs from wchar_iterate are valid
540 here regardless of which branch was taken above. */
550 case wchar_iterate_invalid
:
553 if (options
->inspect_it
)
554 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
556 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
560 print_wchar (gdb_WEOF
, buf
, buflen
, width
, byte_order
, &wchar_buf
,
564 case wchar_iterate_incomplete
:
567 if (options
->inspect_it
)
568 obstack_grow_wstr (&wchar_buf
, LCST ("\\\","));
570 obstack_grow_wstr (&wchar_buf
, LCST ("\","));
573 obstack_grow_wstr (&wchar_buf
, LCST (" <incomplete sequence "));
574 print_wchar (gdb_WEOF
, buf
, buflen
, width
, byte_order
, &wchar_buf
,
576 obstack_grow_wstr (&wchar_buf
, LCST (">"));
582 /* Terminate the quotes if necessary. */
585 if (options
->inspect_it
)
586 obstack_grow_wstr (&wchar_buf
, LCST ("\\\""));
588 obstack_grow_wstr (&wchar_buf
, LCST ("\""));
591 if (force_ellipses
|| !finished
)
592 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
594 /* OUTPUT is where we collect `char's for printing. */
595 obstack_init (&output
);
596 make_cleanup_obstack_free (&output
);
598 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
599 obstack_base (&wchar_buf
),
600 obstack_object_size (&wchar_buf
),
601 1, &output
, translit_char
);
602 obstack_1grow (&output
, '\0');
604 fputs_filtered (obstack_base (&output
), stream
);
606 do_cleanups (cleanup
);
609 /* Obtain a C string from the inferior storing it in a newly allocated
610 buffer in BUFFER, which should be freed by the caller. If the
611 in- and out-parameter *LENGTH is specified at -1, the string is read
612 until a null character of the appropriate width is found, otherwise
613 the string is read to the length of characters specified.
614 The size of a character is determined by the length of the target
615 type of the pointer or array. If VALUE is an array with a known
616 length, the function will not read past the end of the array.
617 On completion, *LENGTH will be set to the size of the string read in
618 characters. (If a length of -1 is specified, the length returned
619 will not include the null character). CHARSET is always set to the
623 c_get_string (struct value
*value
, gdb_byte
**buffer
, int *length
,
624 struct type
**char_type
, const char **charset
)
627 unsigned int fetchlimit
;
628 struct type
*type
= check_typedef (value_type (value
));
629 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
630 int req_length
= *length
;
631 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
632 enum c_string_type kind
;
634 if (element_type
== NULL
)
637 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
639 /* If we know the size of the array, we can use it as a limit on the
640 number of characters to be fetched. */
641 if (TYPE_NFIELDS (type
) == 1
642 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
644 LONGEST low_bound
, high_bound
;
646 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
647 &low_bound
, &high_bound
);
648 fetchlimit
= high_bound
- low_bound
+ 1;
651 fetchlimit
= UINT_MAX
;
653 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
654 fetchlimit
= UINT_MAX
;
656 /* We work only with arrays and pointers. */
659 if (! c_textual_element_type (element_type
, 0))
661 kind
= classify_type (element_type
,
662 gdbarch_byte_order (get_type_arch (element_type
)),
664 width
= TYPE_LENGTH (element_type
);
666 /* If the string lives in GDB's memory instead of the inferior's, then we
667 just need to copy it to BUFFER. Also, since such strings are arrays
668 with known size, FETCHLIMIT will hold the size of the array. */
669 if ((VALUE_LVAL (value
) == not_lval
670 || VALUE_LVAL (value
) == lval_internalvar
)
671 && fetchlimit
!= UINT_MAX
)
674 const gdb_byte
*contents
= value_contents (value
);
676 /* If a length is specified, use that. */
680 /* Otherwise, look for a null character. */
681 for (i
= 0; i
< fetchlimit
; i
++)
682 if (extract_unsigned_integer (contents
+ i
* width
, width
,
686 /* I is now either a user-defined length, the number of non-null
687 characters, or FETCHLIMIT. */
689 *buffer
= xmalloc (*length
);
690 memcpy (*buffer
, contents
, *length
);
695 err
= read_string (value_as_address (value
), *length
, width
, fetchlimit
,
696 byte_order
, buffer
, length
);
700 error (_("Error reading string from inferior: %s"),
701 safe_strerror (err
));
705 /* If the LENGTH is specified at -1, we want to return the string
706 length up to the terminating null character. If an actual length
707 was specified, we want to return the length of exactly what was
709 if (req_length
== -1)
710 /* If the last character is null, subtract it from LENGTH. */
712 && extract_unsigned_integer (*buffer
+ *length
- width
, width
,
716 /* The read_string function will return the number of bytes read.
717 If length returned from read_string was > 0, return the number of
718 characters read by dividing the number of bytes by width. */
720 *length
= *length
/ width
;
722 *char_type
= element_type
;
730 type_str
= type_to_string (type
);
733 make_cleanup (xfree
, type_str
);
734 error (_("Trying to read string with inappropriate type `%s'."),
738 error (_("Trying to read string with inappropriate type."));
743 /* Evaluating C and C++ expressions. */
745 /* Convert a UCN. The digits of the UCN start at P and extend no
746 farther than LIMIT. DEST_CHARSET is the name of the character set
747 into which the UCN should be converted. The results are written to
748 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
749 Returns a pointer to just after the final digit of the UCN. */
752 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
753 struct obstack
*output
, int length
)
755 unsigned long result
= 0;
759 for (i
= 0; i
< length
&& p
< limit
&& isxdigit (*p
); ++i
, ++p
)
760 result
= (result
<< 4) + host_hex_value (*p
);
762 for (i
= 3; i
>= 0; --i
)
764 data
[i
] = result
& 0xff;
768 convert_between_encodings ("UTF-32BE", dest_charset
, data
, 4, 4, output
,
774 /* Emit a character, VALUE, which was specified numerically, to
775 OUTPUT. TYPE is the target character type. */
778 emit_numeric_character (struct type
*type
, unsigned long value
,
779 struct obstack
*output
)
783 buffer
= alloca (TYPE_LENGTH (type
));
784 pack_long (buffer
, type
, value
);
785 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
788 /* Convert an octal escape sequence. TYPE is the target character
789 type. The digits of the escape sequence begin at P and extend no
790 farther than LIMIT. The result is written to OUTPUT. Returns a
791 pointer to just after the final digit of the escape sequence. */
794 convert_octal (struct type
*type
, char *p
, char *limit
, struct obstack
*output
)
797 unsigned long value
= 0;
800 i
< 3 && p
< limit
&& isdigit (*p
) && *p
!= '8' && *p
!= '9';
803 value
= 8 * value
+ host_hex_value (*p
);
807 emit_numeric_character (type
, value
, output
);
812 /* Convert a hex escape sequence. TYPE is the target character type.
813 The digits of the escape sequence begin at P and extend no farther
814 than LIMIT. The result is written to OUTPUT. Returns a pointer to
815 just after the final digit of the escape sequence. */
818 convert_hex (struct type
*type
, char *p
, char *limit
, struct obstack
*output
)
820 unsigned long value
= 0;
822 while (p
< limit
&& isxdigit (*p
))
824 value
= 16 * value
+ host_hex_value (*p
);
828 emit_numeric_character (type
, value
, output
);
837 error (_("Malformed escape sequence")); \
840 /* Convert an escape sequence to a target format. TYPE is the target
841 character type to use, and DEST_CHARSET is the name of the target
842 character set. The backslash of the escape sequence is at *P, and
843 the escape sequence will not extend past LIMIT. The results are
844 written to OUTPUT. Returns a pointer to just past the final
845 character of the escape sequence. */
848 convert_escape (struct type
*type
, const char *dest_charset
,
849 char *p
, char *limit
, struct obstack
*output
)
851 /* Skip the backslash. */
857 obstack_1grow (output
, '\\');
864 error (_("\\x used with no following hex digits."));
865 p
= convert_hex (type
, p
, limit
, output
);
876 p
= convert_octal (type
, p
, limit
, output
);
882 int length
= *p
== 'u' ? 4 : 8;
885 error (_("\\u used with no following hex digits"));
886 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
893 /* Given a single string from a (C-specific) OP_STRING list, convert
894 it to a target string, handling escape sequences specially. The
895 output is written to OUTPUT. DATA is the input string, which has
896 length LEN. DEST_CHARSET is the name of the target character set,
897 and TYPE is the type of target character to use. */
900 parse_one_string (struct obstack
*output
, char *data
, int len
,
901 const char *dest_charset
, struct type
*type
)
910 /* Look for next escape, or the end of the input. */
911 while (p
< limit
&& *p
!= '\\')
913 /* If we saw a run of characters, convert them all. */
915 convert_between_encodings (host_charset (), dest_charset
,
916 data
, p
- data
, 1, output
, translit_none
);
917 /* If we saw an escape, convert it. */
919 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
924 /* Expression evaluator for the C language family. Most operations
925 are delegated to evaluate_subexp_standard; see that function for a
926 description of the arguments. */
928 static struct value
*
929 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
930 int *pos
, enum noside noside
)
932 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
940 struct obstack output
;
941 struct cleanup
*cleanup
;
942 struct value
*result
;
943 enum c_string_type dest_type
;
944 const char *dest_charset
;
945 enum bfd_endian byte_order
;
947 obstack_init (&output
);
948 cleanup
= make_cleanup_obstack_free (&output
);
951 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
954 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
956 = (enum c_string_type
) longest_to_int (exp
->elts
[*pos
].longconst
);
957 switch (dest_type
& ~C_CHAR
)
960 type
= language_string_char_type (exp
->language_defn
,
964 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
968 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
969 "char16_t", NULL
, 0);
972 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
973 "char32_t", NULL
, 0);
976 internal_error (__FILE__
, __LINE__
, "unhandled c_string_type");
979 /* Ensure TYPE_LENGTH is valid for TYPE. */
980 check_typedef (type
);
982 byte_order
= gdbarch_byte_order (exp
->gdbarch
);
983 dest_charset
= charset_for_string_type (dest_type
, byte_order
);
990 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
993 if (noside
!= EVAL_SKIP
)
994 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
996 *pos
+= BYTES_TO_EXP_ELEM (len
);
999 /* Skip the trailing length and opcode. */
1002 if (noside
== EVAL_SKIP
)
1004 /* Return a dummy value of the appropriate type. */
1005 if ((dest_type
& C_CHAR
) != 0)
1006 result
= allocate_value (type
);
1008 result
= value_cstring ("", 0, type
);
1009 do_cleanups (cleanup
);
1013 if ((dest_type
& C_CHAR
) != 0)
1017 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
1018 error (_("Could not convert character constant to target character set"));
1019 value
= unpack_long (type
, obstack_base (&output
));
1020 result
= value_from_longest (type
, value
);
1025 /* Write the terminating character. */
1026 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
1027 obstack_1grow (&output
, 0);
1028 result
= value_cstring (obstack_base (&output
),
1029 obstack_object_size (&output
),
1032 do_cleanups (cleanup
);
1040 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1045 /* Table mapping opcodes into strings for printing operators
1046 and precedences of the operators. */
1048 const struct op_print c_op_print_tab
[] =
1050 {",", BINOP_COMMA
, PREC_COMMA
, 0},
1051 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
1052 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
1053 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
1054 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
1055 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
1056 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
1057 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
1058 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
1059 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
1060 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
1061 {">", BINOP_GTR
, PREC_ORDER
, 0},
1062 {"<", BINOP_LESS
, PREC_ORDER
, 0},
1063 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
1064 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
1065 {"+", BINOP_ADD
, PREC_ADD
, 0},
1066 {"-", BINOP_SUB
, PREC_ADD
, 0},
1067 {"*", BINOP_MUL
, PREC_MUL
, 0},
1068 {"/", BINOP_DIV
, PREC_MUL
, 0},
1069 {"%", BINOP_REM
, PREC_MUL
, 0},
1070 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
1071 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
1072 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
1073 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
1074 {"*", UNOP_IND
, PREC_PREFIX
, 0},
1075 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
1076 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
1077 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
1078 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
1082 enum c_primitive_types
{
1083 c_primitive_type_int
,
1084 c_primitive_type_long
,
1085 c_primitive_type_short
,
1086 c_primitive_type_char
,
1087 c_primitive_type_float
,
1088 c_primitive_type_double
,
1089 c_primitive_type_void
,
1090 c_primitive_type_long_long
,
1091 c_primitive_type_signed_char
,
1092 c_primitive_type_unsigned_char
,
1093 c_primitive_type_unsigned_short
,
1094 c_primitive_type_unsigned_int
,
1095 c_primitive_type_unsigned_long
,
1096 c_primitive_type_unsigned_long_long
,
1097 c_primitive_type_long_double
,
1098 c_primitive_type_complex
,
1099 c_primitive_type_double_complex
,
1100 c_primitive_type_decfloat
,
1101 c_primitive_type_decdouble
,
1102 c_primitive_type_declong
,
1103 nr_c_primitive_types
1107 c_language_arch_info (struct gdbarch
*gdbarch
,
1108 struct language_arch_info
*lai
)
1110 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1111 lai
->string_char_type
= builtin
->builtin_char
;
1112 lai
->primitive_type_vector
1113 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
1115 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
1116 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
1117 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
1118 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
1119 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
1120 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
1121 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
1122 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
1123 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
1124 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
1125 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
1126 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
1127 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
1128 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
1129 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
1130 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
1131 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
1132 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
1133 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
1134 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
1136 lai
->bool_type_default
= builtin
->builtin_int
;
1139 static const struct exp_descriptor exp_descriptor_c
=
1141 print_subexp_standard
,
1142 operator_length_standard
,
1144 dump_subexp_body_standard
,
1148 const struct language_defn c_language_defn
=
1150 "c", /* Language name */
1161 c_printchar
, /* Print a character constant */
1162 c_printstr
, /* Function to print string constant */
1163 c_emit_char
, /* Print a single char */
1164 c_print_type
, /* Print a type using appropriate syntax */
1165 c_print_typedef
, /* Print a typedef using appropriate syntax */
1166 c_val_print
, /* Print a value using appropriate syntax */
1167 c_value_print
, /* Print a top-level value */
1168 NULL
, /* Language specific skip_trampoline */
1169 NULL
, /* name_of_this */
1170 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1171 basic_lookup_transparent_type
,/* lookup_transparent_type */
1172 NULL
, /* Language specific symbol demangler */
1173 NULL
, /* Language specific class_name_from_physname */
1174 c_op_print_tab
, /* expression operators for printing */
1175 1, /* c-style arrays */
1176 0, /* String lower bound */
1177 default_word_break_characters
,
1178 default_make_symbol_completion_list
,
1179 c_language_arch_info
,
1180 default_print_array_index
,
1181 default_pass_by_reference
,
1186 enum cplus_primitive_types
{
1187 cplus_primitive_type_int
,
1188 cplus_primitive_type_long
,
1189 cplus_primitive_type_short
,
1190 cplus_primitive_type_char
,
1191 cplus_primitive_type_float
,
1192 cplus_primitive_type_double
,
1193 cplus_primitive_type_void
,
1194 cplus_primitive_type_long_long
,
1195 cplus_primitive_type_signed_char
,
1196 cplus_primitive_type_unsigned_char
,
1197 cplus_primitive_type_unsigned_short
,
1198 cplus_primitive_type_unsigned_int
,
1199 cplus_primitive_type_unsigned_long
,
1200 cplus_primitive_type_unsigned_long_long
,
1201 cplus_primitive_type_long_double
,
1202 cplus_primitive_type_complex
,
1203 cplus_primitive_type_double_complex
,
1204 cplus_primitive_type_bool
,
1205 cplus_primitive_type_decfloat
,
1206 cplus_primitive_type_decdouble
,
1207 cplus_primitive_type_declong
,
1208 nr_cplus_primitive_types
1212 cplus_language_arch_info (struct gdbarch
*gdbarch
,
1213 struct language_arch_info
*lai
)
1215 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1216 lai
->string_char_type
= builtin
->builtin_char
;
1217 lai
->primitive_type_vector
1218 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
1220 lai
->primitive_type_vector
[cplus_primitive_type_int
]
1221 = builtin
->builtin_int
;
1222 lai
->primitive_type_vector
[cplus_primitive_type_long
]
1223 = builtin
->builtin_long
;
1224 lai
->primitive_type_vector
[cplus_primitive_type_short
]
1225 = builtin
->builtin_short
;
1226 lai
->primitive_type_vector
[cplus_primitive_type_char
]
1227 = builtin
->builtin_char
;
1228 lai
->primitive_type_vector
[cplus_primitive_type_float
]
1229 = builtin
->builtin_float
;
1230 lai
->primitive_type_vector
[cplus_primitive_type_double
]
1231 = builtin
->builtin_double
;
1232 lai
->primitive_type_vector
[cplus_primitive_type_void
]
1233 = builtin
->builtin_void
;
1234 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
1235 = builtin
->builtin_long_long
;
1236 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
1237 = builtin
->builtin_signed_char
;
1238 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
1239 = builtin
->builtin_unsigned_char
;
1240 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
1241 = builtin
->builtin_unsigned_short
;
1242 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
1243 = builtin
->builtin_unsigned_int
;
1244 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
1245 = builtin
->builtin_unsigned_long
;
1246 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
1247 = builtin
->builtin_unsigned_long_long
;
1248 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
1249 = builtin
->builtin_long_double
;
1250 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
1251 = builtin
->builtin_complex
;
1252 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
1253 = builtin
->builtin_double_complex
;
1254 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
1255 = builtin
->builtin_bool
;
1256 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
1257 = builtin
->builtin_decfloat
;
1258 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
1259 = builtin
->builtin_decdouble
;
1260 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
1261 = builtin
->builtin_declong
;
1263 lai
->bool_type_symbol
= "bool";
1264 lai
->bool_type_default
= builtin
->builtin_bool
;
1267 const struct language_defn cplus_language_defn
=
1269 "c++", /* Language name */
1280 c_printchar
, /* Print a character constant */
1281 c_printstr
, /* Function to print string constant */
1282 c_emit_char
, /* Print a single char */
1283 c_print_type
, /* Print a type using appropriate syntax */
1284 c_print_typedef
, /* Print a typedef using appropriate syntax */
1285 c_val_print
, /* Print a value using appropriate syntax */
1286 c_value_print
, /* Print a top-level value */
1287 cplus_skip_trampoline
, /* Language specific skip_trampoline */
1288 "this", /* name_of_this */
1289 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1290 cp_lookup_transparent_type
, /* lookup_transparent_type */
1291 cplus_demangle
, /* Language specific symbol demangler */
1292 cp_class_name_from_physname
, /* Language specific class_name_from_physname */
1293 c_op_print_tab
, /* expression operators for printing */
1294 1, /* c-style arrays */
1295 0, /* String lower bound */
1296 default_word_break_characters
,
1297 default_make_symbol_completion_list
,
1298 cplus_language_arch_info
,
1299 default_print_array_index
,
1300 cp_pass_by_reference
,
1305 const struct language_defn asm_language_defn
=
1307 "asm", /* Language name */
1318 c_printchar
, /* Print a character constant */
1319 c_printstr
, /* Function to print string constant */
1320 c_emit_char
, /* Print a single char */
1321 c_print_type
, /* Print a type using appropriate syntax */
1322 c_print_typedef
, /* Print a typedef using appropriate syntax */
1323 c_val_print
, /* Print a value using appropriate syntax */
1324 c_value_print
, /* Print a top-level value */
1325 NULL
, /* Language specific skip_trampoline */
1326 NULL
, /* name_of_this */
1327 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1328 basic_lookup_transparent_type
,/* lookup_transparent_type */
1329 NULL
, /* Language specific symbol demangler */
1330 NULL
, /* Language specific class_name_from_physname */
1331 c_op_print_tab
, /* expression operators for printing */
1332 1, /* c-style arrays */
1333 0, /* String lower bound */
1334 default_word_break_characters
,
1335 default_make_symbol_completion_list
,
1336 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1337 default_print_array_index
,
1338 default_pass_by_reference
,
1343 /* The following language_defn does not represent a real language.
1344 It just provides a minimal support a-la-C that should allow users
1345 to do some simple operations when debugging applications that use
1346 a language currently not supported by GDB. */
1348 const struct language_defn minimal_language_defn
=
1350 "minimal", /* Language name */
1361 c_printchar
, /* Print a character constant */
1362 c_printstr
, /* Function to print string constant */
1363 c_emit_char
, /* Print a single char */
1364 c_print_type
, /* Print a type using appropriate syntax */
1365 c_print_typedef
, /* Print a typedef using appropriate syntax */
1366 c_val_print
, /* Print a value using appropriate syntax */
1367 c_value_print
, /* Print a top-level value */
1368 NULL
, /* Language specific skip_trampoline */
1369 NULL
, /* name_of_this */
1370 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1371 basic_lookup_transparent_type
,/* lookup_transparent_type */
1372 NULL
, /* Language specific symbol demangler */
1373 NULL
, /* Language specific class_name_from_physname */
1374 c_op_print_tab
, /* expression operators for printing */
1375 1, /* c-style arrays */
1376 0, /* String lower bound */
1377 default_word_break_characters
,
1378 default_make_symbol_completion_list
,
1379 c_language_arch_info
,
1380 default_print_array_index
,
1381 default_pass_by_reference
,
1387 _initialize_c_language (void)
1389 add_language (&c_language_defn
);
1390 add_language (&cplus_language_defn
);
1391 add_language (&asm_language_defn
);
1392 add_language (&minimal_language_defn
);