1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "expression.h"
24 #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"
38 #include "exceptions.h"
41 extern void _initialize_c_language (void);
43 /* Given a C string type, STR_TYPE, return the corresponding target
44 character set name. */
47 charset_for_string_type (enum c_string_type str_type
,
48 struct gdbarch
*gdbarch
)
50 switch (str_type
& ~C_CHAR
)
53 return target_charset (gdbarch
);
55 return target_wide_charset (gdbarch
);
57 /* FIXME: UTF-16 is not always correct. */
58 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
63 /* FIXME: UTF-32 is not always correct. */
64 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
69 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
72 /* Classify ELTTYPE according to what kind of character it is. Return
73 the enum constant representing the character type. Also set
74 *ENCODING to the name of the character set to use when converting
75 characters of this type in target BYTE_ORDER to the host character
78 static enum c_string_type
79 classify_type (struct type
*elttype
, struct gdbarch
*gdbarch
,
80 const char **encoding
)
82 enum c_string_type result
;
84 /* We loop because ELTTYPE may be a typedef, and we want to
85 successively peel each typedef until we reach a type we
86 understand. We don't use CHECK_TYPEDEF because that will strip
87 all typedefs at once -- but in C, wchar_t is itself a typedef, so
88 that would do the wrong thing. */
91 const char *name
= TYPE_NAME (elttype
);
93 if (TYPE_CODE (elttype
) == TYPE_CODE_CHAR
|| !name
)
99 if (!strcmp (name
, "wchar_t"))
101 result
= C_WIDE_CHAR
;
105 if (!strcmp (name
, "char16_t"))
111 if (!strcmp (name
, "char32_t"))
117 if (TYPE_CODE (elttype
) != TYPE_CODE_TYPEDEF
)
120 /* Call for side effects. */
121 check_typedef (elttype
);
123 if (TYPE_TARGET_TYPE (elttype
))
124 elttype
= TYPE_TARGET_TYPE (elttype
);
127 /* Perhaps check_typedef did not update the target type. In
128 this case, force the lookup again and hope it works out.
129 It never will for C, but it might for C++. */
130 CHECK_TYPEDEF (elttype
);
139 *encoding
= charset_for_string_type (result
, gdbarch
);
144 /* Print the character C on STREAM as part of the contents of a
145 literal string whose delimiter is QUOTER. Note that that format
146 for printing characters and strings is language specific. */
149 c_emit_char (int c
, struct type
*type
,
150 struct ui_file
*stream
, int quoter
)
152 const char *encoding
;
154 classify_type (type
, get_type_arch (type
), &encoding
);
155 generic_emit_char (c
, type
, stream
, quoter
, encoding
);
159 c_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
161 enum c_string_type str_type
;
163 str_type
= classify_type (type
, get_type_arch (type
), NULL
);
169 fputc_filtered ('L', stream
);
172 fputc_filtered ('u', stream
);
175 fputc_filtered ('U', stream
);
179 fputc_filtered ('\'', stream
);
180 LA_EMIT_CHAR (c
, type
, stream
, '\'');
181 fputc_filtered ('\'', stream
);
184 /* Print the character string STRING, printing at most LENGTH
185 characters. LENGTH is -1 if the string is nul terminated. Each
186 character is WIDTH bytes long. Printing stops early if the number
187 hits print_max; repeat counts are printed as appropriate. Print
188 ellipses at the end if we had to stop before printing LENGTH
189 characters, or if FORCE_ELLIPSES. */
192 c_printstr (struct ui_file
*stream
, struct type
*type
,
193 const gdb_byte
*string
, unsigned int length
,
194 const char *user_encoding
, int force_ellipses
,
195 const struct value_print_options
*options
)
197 enum c_string_type str_type
;
198 const char *type_encoding
;
199 const char *encoding
;
201 str_type
= (classify_type (type
, get_type_arch (type
), &type_encoding
)
208 fputs_filtered ("L", stream
);
211 fputs_filtered ("u", stream
);
214 fputs_filtered ("U", stream
);
218 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
220 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
224 /* Obtain a C string from the inferior storing it in a newly allocated
225 buffer in BUFFER, which should be freed by the caller. If the in-
226 and out-parameter *LENGTH is specified at -1, the string is read
227 until a null character of the appropriate width is found, otherwise
228 the string is read to the length of characters specified. The size
229 of a character is determined by the length of the target type of
230 the pointer or array. If VALUE is an array with a known length,
231 the function will not read past the end of the array. On
232 completion, *LENGTH will be set to the size of the string read in
233 characters. (If a length of -1 is specified, the length returned
234 will not include the null character). CHARSET is always set to the
238 c_get_string (struct value
*value
, gdb_byte
**buffer
,
239 int *length
, struct type
**char_type
,
240 const char **charset
)
243 unsigned int fetchlimit
;
244 struct type
*type
= check_typedef (value_type (value
));
245 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
246 int req_length
= *length
;
247 enum bfd_endian byte_order
248 = gdbarch_byte_order (get_type_arch (type
));
250 if (element_type
== NULL
)
253 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
255 /* If we know the size of the array, we can use it as a limit on
256 the number of characters to be fetched. */
257 if (TYPE_NFIELDS (type
) == 1
258 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
260 LONGEST low_bound
, high_bound
;
262 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
263 &low_bound
, &high_bound
);
264 fetchlimit
= high_bound
- low_bound
+ 1;
267 fetchlimit
= UINT_MAX
;
269 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
270 fetchlimit
= UINT_MAX
;
272 /* We work only with arrays and pointers. */
275 if (! c_textual_element_type (element_type
, 0))
277 classify_type (element_type
, get_type_arch (element_type
), charset
);
278 width
= TYPE_LENGTH (element_type
);
280 /* If the string lives in GDB's memory instead of the inferior's,
281 then we just need to copy it to BUFFER. Also, since such strings
282 are arrays with known size, FETCHLIMIT will hold the size of the
284 if ((VALUE_LVAL (value
) == not_lval
285 || VALUE_LVAL (value
) == lval_internalvar
)
286 && fetchlimit
!= UINT_MAX
)
289 const gdb_byte
*contents
= value_contents (value
);
291 /* If a length is specified, use that. */
295 /* Otherwise, look for a null character. */
296 for (i
= 0; i
< fetchlimit
; i
++)
297 if (extract_unsigned_integer (contents
+ i
* width
,
298 width
, byte_order
) == 0)
301 /* I is now either a user-defined length, the number of non-null
302 characters, or FETCHLIMIT. */
304 *buffer
= xmalloc (*length
);
305 memcpy (*buffer
, contents
, *length
);
310 CORE_ADDR addr
= value_as_address (value
);
312 err
= read_string (addr
, *length
, width
, fetchlimit
,
313 byte_order
, buffer
, length
);
317 memory_error (err
, addr
);
321 /* If the LENGTH is specified at -1, we want to return the string
322 length up to the terminating null character. If an actual length
323 was specified, we want to return the length of exactly what was
325 if (req_length
== -1)
326 /* If the last character is null, subtract it from LENGTH. */
328 && extract_unsigned_integer (*buffer
+ *length
- width
,
329 width
, byte_order
) == 0)
332 /* The read_string function will return the number of bytes read.
333 If length returned from read_string was > 0, return the number of
334 characters read by dividing the number of bytes by width. */
336 *length
= *length
/ width
;
338 *char_type
= element_type
;
346 type_str
= type_to_string (type
);
349 make_cleanup (xfree
, type_str
);
350 error (_("Trying to read string with inappropriate type `%s'."),
354 error (_("Trying to read string with inappropriate type."));
359 /* Evaluating C and C++ expressions. */
361 /* Convert a UCN. The digits of the UCN start at P and extend no
362 farther than LIMIT. DEST_CHARSET is the name of the character set
363 into which the UCN should be converted. The results are written to
364 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
365 Returns a pointer to just after the final digit of the UCN. */
368 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
369 struct obstack
*output
, int length
)
371 unsigned long result
= 0;
375 for (i
= 0; i
< length
&& p
< limit
&& isxdigit (*p
); ++i
, ++p
)
376 result
= (result
<< 4) + host_hex_value (*p
);
378 for (i
= 3; i
>= 0; --i
)
380 data
[i
] = result
& 0xff;
384 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
385 4, 4, output
, translit_none
);
390 /* Emit a character, VALUE, which was specified numerically, to
391 OUTPUT. TYPE is the target character type. */
394 emit_numeric_character (struct type
*type
, unsigned long value
,
395 struct obstack
*output
)
399 buffer
= alloca (TYPE_LENGTH (type
));
400 pack_long (buffer
, type
, value
);
401 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
404 /* Convert an octal escape sequence. TYPE is the target character
405 type. The digits of the escape sequence begin at P and extend no
406 farther than LIMIT. The result is written to OUTPUT. Returns a
407 pointer to just after the final digit of the escape sequence. */
410 convert_octal (struct type
*type
, char *p
,
411 char *limit
, struct obstack
*output
)
414 unsigned long value
= 0;
417 i
< 3 && p
< limit
&& isdigit (*p
) && *p
!= '8' && *p
!= '9';
420 value
= 8 * value
+ host_hex_value (*p
);
424 emit_numeric_character (type
, value
, output
);
429 /* Convert a hex escape sequence. TYPE is the target character type.
430 The digits of the escape sequence begin at P and extend no farther
431 than LIMIT. The result is written to OUTPUT. Returns a pointer to
432 just after the final digit of the escape sequence. */
435 convert_hex (struct type
*type
, char *p
,
436 char *limit
, struct obstack
*output
)
438 unsigned long value
= 0;
440 while (p
< limit
&& isxdigit (*p
))
442 value
= 16 * value
+ host_hex_value (*p
);
446 emit_numeric_character (type
, value
, output
);
455 error (_("Malformed escape sequence")); \
458 /* Convert an escape sequence to a target format. TYPE is the target
459 character type to use, and DEST_CHARSET is the name of the target
460 character set. The backslash of the escape sequence is at *P, and
461 the escape sequence will not extend past LIMIT. The results are
462 written to OUTPUT. Returns a pointer to just past the final
463 character of the escape sequence. */
466 convert_escape (struct type
*type
, const char *dest_charset
,
467 char *p
, char *limit
, struct obstack
*output
)
469 /* Skip the backslash. */
475 obstack_1grow (output
, '\\');
482 error (_("\\x used with no following hex digits."));
483 p
= convert_hex (type
, p
, limit
, output
);
494 p
= convert_octal (type
, p
, limit
, output
);
500 int length
= *p
== 'u' ? 4 : 8;
504 error (_("\\u used with no following hex digits"));
505 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
512 /* Given a single string from a (C-specific) OP_STRING list, convert
513 it to a target string, handling escape sequences specially. The
514 output is written to OUTPUT. DATA is the input string, which has
515 length LEN. DEST_CHARSET is the name of the target character set,
516 and TYPE is the type of target character to use. */
519 parse_one_string (struct obstack
*output
, char *data
, int len
,
520 const char *dest_charset
, struct type
*type
)
530 /* Look for next escape, or the end of the input. */
531 while (p
< limit
&& *p
!= '\\')
533 /* If we saw a run of characters, convert them all. */
535 convert_between_encodings (host_charset (), dest_charset
,
536 (gdb_byte
*) data
, p
- data
, 1,
537 output
, translit_none
);
538 /* If we saw an escape, convert it. */
540 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
545 /* Expression evaluator for the C language family. Most operations
546 are delegated to evaluate_subexp_standard; see that function for a
547 description of the arguments. */
550 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
551 int *pos
, enum noside noside
)
553 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
561 struct obstack output
;
562 struct cleanup
*cleanup
;
563 struct value
*result
;
564 enum c_string_type dest_type
;
565 const char *dest_charset
;
566 int satisfy_expected
= 0;
568 obstack_init (&output
);
569 cleanup
= make_cleanup_obstack_free (&output
);
572 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
575 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
577 = (enum c_string_type
) longest_to_int (exp
->elts
[*pos
].longconst
);
578 switch (dest_type
& ~C_CHAR
)
581 type
= language_string_char_type (exp
->language_defn
,
585 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
589 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
590 "char16_t", NULL
, 0);
593 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
594 "char32_t", NULL
, 0);
597 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
600 /* Ensure TYPE_LENGTH is valid for TYPE. */
601 check_typedef (type
);
603 /* If the caller expects an array of some integral type,
604 satisfy them. If something odder is expected, rely on the
606 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_ARRAY
)
608 struct type
*element_type
609 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
611 if (TYPE_CODE (element_type
) == TYPE_CODE_INT
612 || TYPE_CODE (element_type
) == TYPE_CODE_CHAR
)
615 satisfy_expected
= 1;
619 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
626 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
629 if (noside
!= EVAL_SKIP
)
630 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
632 *pos
+= BYTES_TO_EXP_ELEM (len
);
635 /* Skip the trailing length and opcode. */
638 if (noside
== EVAL_SKIP
)
640 /* Return a dummy value of the appropriate type. */
641 if (expect_type
!= NULL
)
642 result
= allocate_value (expect_type
);
643 else if ((dest_type
& C_CHAR
) != 0)
644 result
= allocate_value (type
);
646 result
= value_cstring ("", 0, type
);
647 do_cleanups (cleanup
);
651 if ((dest_type
& C_CHAR
) != 0)
655 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
656 error (_("Could not convert character "
657 "constant to target character set"));
658 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
659 result
= value_from_longest (type
, value
);
665 /* Write the terminating character. */
666 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
667 obstack_1grow (&output
, 0);
669 if (satisfy_expected
)
671 LONGEST low_bound
, high_bound
;
672 int element_size
= TYPE_LENGTH (type
);
674 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type
),
675 &low_bound
, &high_bound
) < 0)
678 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
680 if (obstack_object_size (&output
) / element_size
681 > (high_bound
- low_bound
+ 1))
682 error (_("Too many array elements"));
684 result
= allocate_value (expect_type
);
685 memcpy (value_contents_raw (result
), obstack_base (&output
),
686 obstack_object_size (&output
));
689 result
= value_cstring (obstack_base (&output
),
690 obstack_object_size (&output
),
693 do_cleanups (cleanup
);
701 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
706 /* Table mapping opcodes into strings for printing operators
707 and precedences of the operators. */
709 const struct op_print c_op_print_tab
[] =
711 {",", BINOP_COMMA
, PREC_COMMA
, 0},
712 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
713 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
714 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
715 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
716 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
717 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
718 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
719 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
720 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
721 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
722 {">", BINOP_GTR
, PREC_ORDER
, 0},
723 {"<", BINOP_LESS
, PREC_ORDER
, 0},
724 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
725 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
726 {"+", BINOP_ADD
, PREC_ADD
, 0},
727 {"-", BINOP_SUB
, PREC_ADD
, 0},
728 {"*", BINOP_MUL
, PREC_MUL
, 0},
729 {"/", BINOP_DIV
, PREC_MUL
, 0},
730 {"%", BINOP_REM
, PREC_MUL
, 0},
731 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
732 {"+", UNOP_PLUS
, PREC_PREFIX
, 0},
733 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
734 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
735 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
736 {"*", UNOP_IND
, PREC_PREFIX
, 0},
737 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
738 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
739 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
740 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
744 enum c_primitive_types
{
745 c_primitive_type_int
,
746 c_primitive_type_long
,
747 c_primitive_type_short
,
748 c_primitive_type_char
,
749 c_primitive_type_float
,
750 c_primitive_type_double
,
751 c_primitive_type_void
,
752 c_primitive_type_long_long
,
753 c_primitive_type_signed_char
,
754 c_primitive_type_unsigned_char
,
755 c_primitive_type_unsigned_short
,
756 c_primitive_type_unsigned_int
,
757 c_primitive_type_unsigned_long
,
758 c_primitive_type_unsigned_long_long
,
759 c_primitive_type_long_double
,
760 c_primitive_type_complex
,
761 c_primitive_type_double_complex
,
762 c_primitive_type_decfloat
,
763 c_primitive_type_decdouble
,
764 c_primitive_type_declong
,
769 c_language_arch_info (struct gdbarch
*gdbarch
,
770 struct language_arch_info
*lai
)
772 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
774 lai
->string_char_type
= builtin
->builtin_char
;
775 lai
->primitive_type_vector
776 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
778 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
779 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
780 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
781 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
782 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
783 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
784 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
785 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
786 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
787 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
788 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
789 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
790 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
791 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
792 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
793 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
794 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
795 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
796 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
797 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
799 lai
->bool_type_default
= builtin
->builtin_int
;
802 const struct exp_descriptor exp_descriptor_c
=
804 print_subexp_standard
,
805 operator_length_standard
,
806 operator_check_standard
,
808 dump_subexp_body_standard
,
812 const struct language_defn c_language_defn
=
814 "c", /* Language name */
824 c_printchar
, /* Print a character constant */
825 c_printstr
, /* Function to print string constant */
826 c_emit_char
, /* Print a single char */
827 c_print_type
, /* Print a type using appropriate syntax */
828 c_print_typedef
, /* Print a typedef using appropriate syntax */
829 c_val_print
, /* Print a value using appropriate syntax */
830 c_value_print
, /* Print a top-level value */
831 default_read_var_value
, /* la_read_var_value */
832 NULL
, /* Language specific skip_trampoline */
833 NULL
, /* name_of_this */
834 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
835 basic_lookup_transparent_type
,/* lookup_transparent_type */
836 NULL
, /* Language specific symbol demangler */
837 NULL
, /* Language specific
838 class_name_from_physname */
839 c_op_print_tab
, /* expression operators for printing */
840 1, /* c-style arrays */
841 0, /* String lower bound */
842 default_word_break_characters
,
843 default_make_symbol_completion_list
,
844 c_language_arch_info
,
845 default_print_array_index
,
846 default_pass_by_reference
,
848 NULL
, /* la_get_symbol_name_cmp */
849 iterate_over_symbols
,
854 enum cplus_primitive_types
{
855 cplus_primitive_type_int
,
856 cplus_primitive_type_long
,
857 cplus_primitive_type_short
,
858 cplus_primitive_type_char
,
859 cplus_primitive_type_float
,
860 cplus_primitive_type_double
,
861 cplus_primitive_type_void
,
862 cplus_primitive_type_long_long
,
863 cplus_primitive_type_signed_char
,
864 cplus_primitive_type_unsigned_char
,
865 cplus_primitive_type_unsigned_short
,
866 cplus_primitive_type_unsigned_int
,
867 cplus_primitive_type_unsigned_long
,
868 cplus_primitive_type_unsigned_long_long
,
869 cplus_primitive_type_long_double
,
870 cplus_primitive_type_complex
,
871 cplus_primitive_type_double_complex
,
872 cplus_primitive_type_bool
,
873 cplus_primitive_type_decfloat
,
874 cplus_primitive_type_decdouble
,
875 cplus_primitive_type_declong
,
876 nr_cplus_primitive_types
880 cplus_language_arch_info (struct gdbarch
*gdbarch
,
881 struct language_arch_info
*lai
)
883 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
885 lai
->string_char_type
= builtin
->builtin_char
;
886 lai
->primitive_type_vector
887 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
889 lai
->primitive_type_vector
[cplus_primitive_type_int
]
890 = builtin
->builtin_int
;
891 lai
->primitive_type_vector
[cplus_primitive_type_long
]
892 = builtin
->builtin_long
;
893 lai
->primitive_type_vector
[cplus_primitive_type_short
]
894 = builtin
->builtin_short
;
895 lai
->primitive_type_vector
[cplus_primitive_type_char
]
896 = builtin
->builtin_char
;
897 lai
->primitive_type_vector
[cplus_primitive_type_float
]
898 = builtin
->builtin_float
;
899 lai
->primitive_type_vector
[cplus_primitive_type_double
]
900 = builtin
->builtin_double
;
901 lai
->primitive_type_vector
[cplus_primitive_type_void
]
902 = builtin
->builtin_void
;
903 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
904 = builtin
->builtin_long_long
;
905 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
906 = builtin
->builtin_signed_char
;
907 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
908 = builtin
->builtin_unsigned_char
;
909 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
910 = builtin
->builtin_unsigned_short
;
911 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
912 = builtin
->builtin_unsigned_int
;
913 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
914 = builtin
->builtin_unsigned_long
;
915 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
916 = builtin
->builtin_unsigned_long_long
;
917 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
918 = builtin
->builtin_long_double
;
919 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
920 = builtin
->builtin_complex
;
921 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
922 = builtin
->builtin_double_complex
;
923 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
924 = builtin
->builtin_bool
;
925 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
926 = builtin
->builtin_decfloat
;
927 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
928 = builtin
->builtin_decdouble
;
929 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
930 = builtin
->builtin_declong
;
932 lai
->bool_type_symbol
= "bool";
933 lai
->bool_type_default
= builtin
->builtin_bool
;
936 const struct language_defn cplus_language_defn
=
938 "c++", /* Language name */
948 c_printchar
, /* Print a character constant */
949 c_printstr
, /* Function to print string constant */
950 c_emit_char
, /* Print a single char */
951 c_print_type
, /* Print a type using appropriate syntax */
952 c_print_typedef
, /* Print a typedef using appropriate syntax */
953 c_val_print
, /* Print a value using appropriate syntax */
954 c_value_print
, /* Print a top-level value */
955 default_read_var_value
, /* la_read_var_value */
956 cplus_skip_trampoline
, /* Language specific skip_trampoline */
957 "this", /* name_of_this */
958 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
959 cp_lookup_transparent_type
, /* lookup_transparent_type */
960 gdb_demangle
, /* Language specific symbol demangler */
961 cp_class_name_from_physname
, /* Language specific
962 class_name_from_physname */
963 c_op_print_tab
, /* expression operators for printing */
964 1, /* c-style arrays */
965 0, /* String lower bound */
966 default_word_break_characters
,
967 default_make_symbol_completion_list
,
968 cplus_language_arch_info
,
969 default_print_array_index
,
970 cp_pass_by_reference
,
972 NULL
, /* la_get_symbol_name_cmp */
973 iterate_over_symbols
,
978 const struct language_defn asm_language_defn
=
980 "asm", /* Language name */
990 c_printchar
, /* Print a character constant */
991 c_printstr
, /* Function to print string constant */
992 c_emit_char
, /* Print a single char */
993 c_print_type
, /* Print a type using appropriate syntax */
994 c_print_typedef
, /* Print a typedef using appropriate syntax */
995 c_val_print
, /* Print a value using appropriate syntax */
996 c_value_print
, /* Print a top-level value */
997 default_read_var_value
, /* la_read_var_value */
998 NULL
, /* Language specific skip_trampoline */
999 NULL
, /* name_of_this */
1000 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1001 basic_lookup_transparent_type
,/* lookup_transparent_type */
1002 NULL
, /* Language specific symbol demangler */
1003 NULL
, /* Language specific
1004 class_name_from_physname */
1005 c_op_print_tab
, /* expression operators for printing */
1006 1, /* c-style arrays */
1007 0, /* String lower bound */
1008 default_word_break_characters
,
1009 default_make_symbol_completion_list
,
1010 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1011 default_print_array_index
,
1012 default_pass_by_reference
,
1014 NULL
, /* la_get_symbol_name_cmp */
1015 iterate_over_symbols
,
1016 &default_varobj_ops
,
1020 /* The following language_defn does not represent a real language.
1021 It just provides a minimal support a-la-C that should allow users
1022 to do some simple operations when debugging applications that use
1023 a language currently not supported by GDB. */
1025 const struct language_defn minimal_language_defn
=
1027 "minimal", /* Language name */
1037 c_printchar
, /* Print a character constant */
1038 c_printstr
, /* Function to print string constant */
1039 c_emit_char
, /* Print a single char */
1040 c_print_type
, /* Print a type using appropriate syntax */
1041 c_print_typedef
, /* Print a typedef using appropriate syntax */
1042 c_val_print
, /* Print a value using appropriate syntax */
1043 c_value_print
, /* Print a top-level value */
1044 default_read_var_value
, /* la_read_var_value */
1045 NULL
, /* Language specific skip_trampoline */
1046 NULL
, /* name_of_this */
1047 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1048 basic_lookup_transparent_type
,/* lookup_transparent_type */
1049 NULL
, /* Language specific symbol demangler */
1050 NULL
, /* Language specific
1051 class_name_from_physname */
1052 c_op_print_tab
, /* expression operators for printing */
1053 1, /* c-style arrays */
1054 0, /* String lower bound */
1055 default_word_break_characters
,
1056 default_make_symbol_completion_list
,
1057 c_language_arch_info
,
1058 default_print_array_index
,
1059 default_pass_by_reference
,
1061 NULL
, /* la_get_symbol_name_cmp */
1062 iterate_over_symbols
,
1063 &default_varobj_ops
,
1068 _initialize_c_language (void)
1070 add_language (&c_language_defn
);
1071 add_language (&cplus_language_defn
);
1072 add_language (&asm_language_defn
);
1073 add_language (&minimal_language_defn
);