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"
28 #include "macroscope.h"
29 #include "gdb_assert.h"
31 #include "gdb_string.h"
34 #include "cp-support.h"
35 #include "gdb_obstack.h"
37 #include "exceptions.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
76 static enum c_string_type
77 classify_type (struct type
*elttype
, struct gdbarch
*gdbarch
,
78 const char **encoding
)
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 const 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
, gdbarch
);
142 /* Print the character C on STREAM as part of the contents of a
143 literal string whose delimiter is QUOTER. Note that that format
144 for printing characters and strings is language specific. */
147 c_emit_char (int c
, struct type
*type
,
148 struct ui_file
*stream
, int quoter
)
150 const char *encoding
;
152 classify_type (type
, get_type_arch (type
), &encoding
);
153 generic_emit_char (c
, type
, stream
, quoter
, encoding
);
157 c_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
159 enum c_string_type str_type
;
161 str_type
= classify_type (type
, get_type_arch (type
), NULL
);
167 fputc_filtered ('L', stream
);
170 fputc_filtered ('u', stream
);
173 fputc_filtered ('U', stream
);
177 fputc_filtered ('\'', stream
);
178 LA_EMIT_CHAR (c
, type
, stream
, '\'');
179 fputc_filtered ('\'', stream
);
182 /* Print the character string STRING, printing at most LENGTH
183 characters. LENGTH is -1 if the string is nul terminated. Each
184 character is WIDTH bytes long. Printing stops early if the number
185 hits print_max; repeat counts are printed as appropriate. Print
186 ellipses at the end if we had to stop before printing LENGTH
187 characters, or if FORCE_ELLIPSES. */
190 c_printstr (struct ui_file
*stream
, struct type
*type
,
191 const gdb_byte
*string
, unsigned int length
,
192 const char *user_encoding
, int force_ellipses
,
193 const struct value_print_options
*options
)
195 enum c_string_type str_type
;
196 const char *type_encoding
;
197 const char *encoding
;
199 str_type
= (classify_type (type
, get_type_arch (type
), &type_encoding
)
206 fputs_filtered ("L", stream
);
209 fputs_filtered ("u", stream
);
212 fputs_filtered ("U", stream
);
216 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: type_encoding
;
218 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
222 /* Obtain a C string from the inferior storing it in a newly allocated
223 buffer in BUFFER, which should be freed by the caller. If the in-
224 and out-parameter *LENGTH is specified at -1, the string is read
225 until a null character of the appropriate width is found, otherwise
226 the string is read to the length of characters specified. The size
227 of a character is determined by the length of the target type of
228 the pointer or array. If VALUE is an array with a known length,
229 the function will not read past the end of the array. On
230 completion, *LENGTH will be set to the size of the string read in
231 characters. (If a length of -1 is specified, the length returned
232 will not include the null character). CHARSET is always set to the
236 c_get_string (struct value
*value
, gdb_byte
**buffer
,
237 int *length
, struct type
**char_type
,
238 const char **charset
)
241 unsigned int fetchlimit
;
242 struct type
*type
= check_typedef (value_type (value
));
243 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
244 int req_length
= *length
;
245 enum bfd_endian byte_order
246 = gdbarch_byte_order (get_type_arch (type
));
248 if (element_type
== NULL
)
251 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
253 /* If we know the size of the array, we can use it as a limit on
254 the number of characters to be fetched. */
255 if (TYPE_NFIELDS (type
) == 1
256 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
258 LONGEST low_bound
, high_bound
;
260 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
261 &low_bound
, &high_bound
);
262 fetchlimit
= high_bound
- low_bound
+ 1;
265 fetchlimit
= UINT_MAX
;
267 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
268 fetchlimit
= UINT_MAX
;
270 /* We work only with arrays and pointers. */
273 if (! c_textual_element_type (element_type
, 0))
275 classify_type (element_type
, get_type_arch (element_type
), charset
);
276 width
= TYPE_LENGTH (element_type
);
278 /* If the string lives in GDB's memory instead of the inferior's,
279 then we just need to copy it to BUFFER. Also, since such strings
280 are arrays with known size, FETCHLIMIT will hold the size of the
282 if ((VALUE_LVAL (value
) == not_lval
283 || VALUE_LVAL (value
) == lval_internalvar
)
284 && fetchlimit
!= UINT_MAX
)
287 const gdb_byte
*contents
= value_contents (value
);
289 /* If a length is specified, use that. */
293 /* Otherwise, look for a null character. */
294 for (i
= 0; i
< fetchlimit
; i
++)
295 if (extract_unsigned_integer (contents
+ i
* width
,
296 width
, byte_order
) == 0)
299 /* I is now either a user-defined length, the number of non-null
300 characters, or FETCHLIMIT. */
302 *buffer
= xmalloc (*length
);
303 memcpy (*buffer
, contents
, *length
);
308 CORE_ADDR addr
= value_as_address (value
);
310 err
= read_string (addr
, *length
, width
, fetchlimit
,
311 byte_order
, buffer
, length
);
316 throw_error (MEMORY_ERROR
, "Address %s out of bounds",
317 paddress (get_type_arch (type
), addr
));
319 error (_("Error reading string from inferior: %s"),
320 safe_strerror (err
));
324 /* If the LENGTH is specified at -1, we want to return the string
325 length up to the terminating null character. If an actual length
326 was specified, we want to return the length of exactly what was
328 if (req_length
== -1)
329 /* If the last character is null, subtract it from LENGTH. */
331 && extract_unsigned_integer (*buffer
+ *length
- width
,
332 width
, byte_order
) == 0)
335 /* The read_string function will return the number of bytes read.
336 If length returned from read_string was > 0, return the number of
337 characters read by dividing the number of bytes by width. */
339 *length
= *length
/ width
;
341 *char_type
= element_type
;
349 type_str
= type_to_string (type
);
352 make_cleanup (xfree
, type_str
);
353 error (_("Trying to read string with inappropriate type `%s'."),
357 error (_("Trying to read string with inappropriate type."));
362 /* Evaluating C and C++ expressions. */
364 /* Convert a UCN. The digits of the UCN start at P and extend no
365 farther than LIMIT. DEST_CHARSET is the name of the character set
366 into which the UCN should be converted. The results are written to
367 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
368 Returns a pointer to just after the final digit of the UCN. */
371 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
372 struct obstack
*output
, int length
)
374 unsigned long result
= 0;
378 for (i
= 0; i
< length
&& p
< limit
&& isxdigit (*p
); ++i
, ++p
)
379 result
= (result
<< 4) + host_hex_value (*p
);
381 for (i
= 3; i
>= 0; --i
)
383 data
[i
] = result
& 0xff;
387 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
388 4, 4, output
, translit_none
);
393 /* Emit a character, VALUE, which was specified numerically, to
394 OUTPUT. TYPE is the target character type. */
397 emit_numeric_character (struct type
*type
, unsigned long value
,
398 struct obstack
*output
)
402 buffer
= alloca (TYPE_LENGTH (type
));
403 pack_long (buffer
, type
, value
);
404 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
407 /* Convert an octal escape sequence. TYPE is the target character
408 type. The digits of the escape sequence begin at P and extend no
409 farther than LIMIT. The result is written to OUTPUT. Returns a
410 pointer to just after the final digit of the escape sequence. */
413 convert_octal (struct type
*type
, char *p
,
414 char *limit
, struct obstack
*output
)
417 unsigned long value
= 0;
420 i
< 3 && p
< limit
&& isdigit (*p
) && *p
!= '8' && *p
!= '9';
423 value
= 8 * value
+ host_hex_value (*p
);
427 emit_numeric_character (type
, value
, output
);
432 /* Convert a hex escape sequence. TYPE is the target character type.
433 The digits of the escape sequence begin at P and extend no farther
434 than LIMIT. The result is written to OUTPUT. Returns a pointer to
435 just after the final digit of the escape sequence. */
438 convert_hex (struct type
*type
, char *p
,
439 char *limit
, struct obstack
*output
)
441 unsigned long value
= 0;
443 while (p
< limit
&& isxdigit (*p
))
445 value
= 16 * value
+ host_hex_value (*p
);
449 emit_numeric_character (type
, value
, output
);
458 error (_("Malformed escape sequence")); \
461 /* Convert an escape sequence to a target format. TYPE is the target
462 character type to use, and DEST_CHARSET is the name of the target
463 character set. The backslash of the escape sequence is at *P, and
464 the escape sequence will not extend past LIMIT. The results are
465 written to OUTPUT. Returns a pointer to just past the final
466 character of the escape sequence. */
469 convert_escape (struct type
*type
, const char *dest_charset
,
470 char *p
, char *limit
, struct obstack
*output
)
472 /* Skip the backslash. */
478 obstack_1grow (output
, '\\');
485 error (_("\\x used with no following hex digits."));
486 p
= convert_hex (type
, p
, limit
, output
);
497 p
= convert_octal (type
, p
, limit
, output
);
503 int length
= *p
== 'u' ? 4 : 8;
507 error (_("\\u used with no following hex digits"));
508 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
515 /* Given a single string from a (C-specific) OP_STRING list, convert
516 it to a target string, handling escape sequences specially. The
517 output is written to OUTPUT. DATA is the input string, which has
518 length LEN. DEST_CHARSET is the name of the target character set,
519 and TYPE is the type of target character to use. */
522 parse_one_string (struct obstack
*output
, char *data
, int len
,
523 const char *dest_charset
, struct type
*type
)
533 /* Look for next escape, or the end of the input. */
534 while (p
< limit
&& *p
!= '\\')
536 /* If we saw a run of characters, convert them all. */
538 convert_between_encodings (host_charset (), dest_charset
,
540 output
, translit_none
);
541 /* If we saw an escape, convert it. */
543 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
548 /* Expression evaluator for the C language family. Most operations
549 are delegated to evaluate_subexp_standard; see that function for a
550 description of the arguments. */
553 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
554 int *pos
, enum noside noside
)
556 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
564 struct obstack output
;
565 struct cleanup
*cleanup
;
566 struct value
*result
;
567 enum c_string_type dest_type
;
568 const char *dest_charset
;
569 int satisfy_expected
= 0;
571 obstack_init (&output
);
572 cleanup
= make_cleanup_obstack_free (&output
);
575 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
578 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
580 = (enum c_string_type
) longest_to_int (exp
->elts
[*pos
].longconst
);
581 switch (dest_type
& ~C_CHAR
)
584 type
= language_string_char_type (exp
->language_defn
,
588 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
592 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
593 "char16_t", NULL
, 0);
596 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
597 "char32_t", NULL
, 0);
600 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
603 /* Ensure TYPE_LENGTH is valid for TYPE. */
604 check_typedef (type
);
606 /* If the caller expects an array of some integral type,
607 satisfy them. If something odder is expected, rely on the
609 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_ARRAY
)
611 struct type
*element_type
612 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
614 if (TYPE_CODE (element_type
) == TYPE_CODE_INT
615 || TYPE_CODE (element_type
) == TYPE_CODE_CHAR
)
618 satisfy_expected
= 1;
622 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
629 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
632 if (noside
!= EVAL_SKIP
)
633 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
635 *pos
+= BYTES_TO_EXP_ELEM (len
);
638 /* Skip the trailing length and opcode. */
641 if (noside
== EVAL_SKIP
)
643 /* Return a dummy value of the appropriate type. */
644 if (expect_type
!= NULL
)
645 result
= allocate_value (expect_type
);
646 else if ((dest_type
& C_CHAR
) != 0)
647 result
= allocate_value (type
);
649 result
= value_cstring ("", 0, type
);
650 do_cleanups (cleanup
);
654 if ((dest_type
& C_CHAR
) != 0)
658 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
659 error (_("Could not convert character "
660 "constant to target character set"));
661 value
= unpack_long (type
, obstack_base (&output
));
662 result
= value_from_longest (type
, value
);
668 /* Write the terminating character. */
669 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
670 obstack_1grow (&output
, 0);
672 if (satisfy_expected
)
674 LONGEST low_bound
, high_bound
;
675 int element_size
= TYPE_LENGTH (type
);
677 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type
),
678 &low_bound
, &high_bound
) < 0)
681 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
683 if (obstack_object_size (&output
) / element_size
684 > (high_bound
- low_bound
+ 1))
685 error (_("Too many array elements"));
687 result
= allocate_value (expect_type
);
688 memcpy (value_contents_raw (result
), obstack_base (&output
),
689 obstack_object_size (&output
));
692 result
= value_cstring (obstack_base (&output
),
693 obstack_object_size (&output
),
696 do_cleanups (cleanup
);
704 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
709 /* Table mapping opcodes into strings for printing operators
710 and precedences of the operators. */
712 const struct op_print c_op_print_tab
[] =
714 {",", BINOP_COMMA
, PREC_COMMA
, 0},
715 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
716 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
717 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
718 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
719 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
720 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
721 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
722 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
723 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
724 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
725 {">", BINOP_GTR
, PREC_ORDER
, 0},
726 {"<", BINOP_LESS
, PREC_ORDER
, 0},
727 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
728 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
729 {"+", BINOP_ADD
, PREC_ADD
, 0},
730 {"-", BINOP_SUB
, PREC_ADD
, 0},
731 {"*", BINOP_MUL
, PREC_MUL
, 0},
732 {"/", BINOP_DIV
, PREC_MUL
, 0},
733 {"%", BINOP_REM
, PREC_MUL
, 0},
734 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
735 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
736 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
737 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
738 {"*", UNOP_IND
, PREC_PREFIX
, 0},
739 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
740 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
741 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
742 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
746 enum c_primitive_types
{
747 c_primitive_type_int
,
748 c_primitive_type_long
,
749 c_primitive_type_short
,
750 c_primitive_type_char
,
751 c_primitive_type_float
,
752 c_primitive_type_double
,
753 c_primitive_type_void
,
754 c_primitive_type_long_long
,
755 c_primitive_type_signed_char
,
756 c_primitive_type_unsigned_char
,
757 c_primitive_type_unsigned_short
,
758 c_primitive_type_unsigned_int
,
759 c_primitive_type_unsigned_long
,
760 c_primitive_type_unsigned_long_long
,
761 c_primitive_type_long_double
,
762 c_primitive_type_complex
,
763 c_primitive_type_double_complex
,
764 c_primitive_type_decfloat
,
765 c_primitive_type_decdouble
,
766 c_primitive_type_declong
,
771 c_language_arch_info (struct gdbarch
*gdbarch
,
772 struct language_arch_info
*lai
)
774 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
776 lai
->string_char_type
= builtin
->builtin_char
;
777 lai
->primitive_type_vector
778 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
780 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
781 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
782 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
783 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
784 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
785 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
786 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
787 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
788 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
789 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
790 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
791 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
792 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
793 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
794 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
795 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
796 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
797 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
798 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
799 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
801 lai
->bool_type_default
= builtin
->builtin_int
;
804 const struct exp_descriptor exp_descriptor_c
=
806 print_subexp_standard
,
807 operator_length_standard
,
808 operator_check_standard
,
810 dump_subexp_body_standard
,
814 const struct language_defn c_language_defn
=
816 "c", /* Language name */
826 c_printchar
, /* Print a character constant */
827 c_printstr
, /* Function to print string constant */
828 c_emit_char
, /* Print a single char */
829 c_print_type
, /* Print a type using appropriate syntax */
830 c_print_typedef
, /* Print a typedef using appropriate syntax */
831 c_val_print
, /* Print a value using appropriate syntax */
832 c_value_print
, /* Print a top-level value */
833 default_read_var_value
, /* la_read_var_value */
834 NULL
, /* Language specific skip_trampoline */
835 NULL
, /* name_of_this */
836 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
837 basic_lookup_transparent_type
,/* lookup_transparent_type */
838 NULL
, /* Language specific symbol demangler */
839 NULL
, /* Language specific
840 class_name_from_physname */
841 c_op_print_tab
, /* expression operators for printing */
842 1, /* c-style arrays */
843 0, /* String lower bound */
844 default_word_break_characters
,
845 default_make_symbol_completion_list
,
846 c_language_arch_info
,
847 default_print_array_index
,
848 default_pass_by_reference
,
850 NULL
, /* la_get_symbol_name_cmp */
851 iterate_over_symbols
,
855 enum cplus_primitive_types
{
856 cplus_primitive_type_int
,
857 cplus_primitive_type_long
,
858 cplus_primitive_type_short
,
859 cplus_primitive_type_char
,
860 cplus_primitive_type_float
,
861 cplus_primitive_type_double
,
862 cplus_primitive_type_void
,
863 cplus_primitive_type_long_long
,
864 cplus_primitive_type_signed_char
,
865 cplus_primitive_type_unsigned_char
,
866 cplus_primitive_type_unsigned_short
,
867 cplus_primitive_type_unsigned_int
,
868 cplus_primitive_type_unsigned_long
,
869 cplus_primitive_type_unsigned_long_long
,
870 cplus_primitive_type_long_double
,
871 cplus_primitive_type_complex
,
872 cplus_primitive_type_double_complex
,
873 cplus_primitive_type_bool
,
874 cplus_primitive_type_decfloat
,
875 cplus_primitive_type_decdouble
,
876 cplus_primitive_type_declong
,
877 nr_cplus_primitive_types
881 cplus_language_arch_info (struct gdbarch
*gdbarch
,
882 struct language_arch_info
*lai
)
884 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
886 lai
->string_char_type
= builtin
->builtin_char
;
887 lai
->primitive_type_vector
888 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
890 lai
->primitive_type_vector
[cplus_primitive_type_int
]
891 = builtin
->builtin_int
;
892 lai
->primitive_type_vector
[cplus_primitive_type_long
]
893 = builtin
->builtin_long
;
894 lai
->primitive_type_vector
[cplus_primitive_type_short
]
895 = builtin
->builtin_short
;
896 lai
->primitive_type_vector
[cplus_primitive_type_char
]
897 = builtin
->builtin_char
;
898 lai
->primitive_type_vector
[cplus_primitive_type_float
]
899 = builtin
->builtin_float
;
900 lai
->primitive_type_vector
[cplus_primitive_type_double
]
901 = builtin
->builtin_double
;
902 lai
->primitive_type_vector
[cplus_primitive_type_void
]
903 = builtin
->builtin_void
;
904 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
905 = builtin
->builtin_long_long
;
906 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
907 = builtin
->builtin_signed_char
;
908 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
909 = builtin
->builtin_unsigned_char
;
910 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
911 = builtin
->builtin_unsigned_short
;
912 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
913 = builtin
->builtin_unsigned_int
;
914 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
915 = builtin
->builtin_unsigned_long
;
916 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
917 = builtin
->builtin_unsigned_long_long
;
918 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
919 = builtin
->builtin_long_double
;
920 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
921 = builtin
->builtin_complex
;
922 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
923 = builtin
->builtin_double_complex
;
924 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
925 = builtin
->builtin_bool
;
926 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
927 = builtin
->builtin_decfloat
;
928 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
929 = builtin
->builtin_decdouble
;
930 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
931 = builtin
->builtin_declong
;
933 lai
->bool_type_symbol
= "bool";
934 lai
->bool_type_default
= builtin
->builtin_bool
;
937 const struct language_defn cplus_language_defn
=
939 "c++", /* Language name */
949 c_printchar
, /* Print a character constant */
950 c_printstr
, /* Function to print string constant */
951 c_emit_char
, /* Print a single char */
952 c_print_type
, /* Print a type using appropriate syntax */
953 c_print_typedef
, /* Print a typedef using appropriate syntax */
954 c_val_print
, /* Print a value using appropriate syntax */
955 c_value_print
, /* Print a top-level value */
956 default_read_var_value
, /* la_read_var_value */
957 cplus_skip_trampoline
, /* Language specific skip_trampoline */
958 "this", /* name_of_this */
959 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
960 cp_lookup_transparent_type
, /* lookup_transparent_type */
961 cplus_demangle
, /* Language specific symbol demangler */
962 cp_class_name_from_physname
, /* Language specific
963 class_name_from_physname */
964 c_op_print_tab
, /* expression operators for printing */
965 1, /* c-style arrays */
966 0, /* String lower bound */
967 default_word_break_characters
,
968 default_make_symbol_completion_list
,
969 cplus_language_arch_info
,
970 default_print_array_index
,
971 cp_pass_by_reference
,
973 NULL
, /* la_get_symbol_name_cmp */
974 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
,
1019 /* The following language_defn does not represent a real language.
1020 It just provides a minimal support a-la-C that should allow users
1021 to do some simple operations when debugging applications that use
1022 a language currently not supported by GDB. */
1024 const struct language_defn minimal_language_defn
=
1026 "minimal", /* Language name */
1036 c_printchar
, /* Print a character constant */
1037 c_printstr
, /* Function to print string constant */
1038 c_emit_char
, /* Print a single char */
1039 c_print_type
, /* Print a type using appropriate syntax */
1040 c_print_typedef
, /* Print a typedef using appropriate syntax */
1041 c_val_print
, /* Print a value using appropriate syntax */
1042 c_value_print
, /* Print a top-level value */
1043 default_read_var_value
, /* la_read_var_value */
1044 NULL
, /* Language specific skip_trampoline */
1045 NULL
, /* name_of_this */
1046 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1047 basic_lookup_transparent_type
,/* lookup_transparent_type */
1048 NULL
, /* Language specific symbol demangler */
1049 NULL
, /* Language specific
1050 class_name_from_physname */
1051 c_op_print_tab
, /* expression operators for printing */
1052 1, /* c-style arrays */
1053 0, /* String lower bound */
1054 default_word_break_characters
,
1055 default_make_symbol_completion_list
,
1056 c_language_arch_info
,
1057 default_print_array_index
,
1058 default_pass_by_reference
,
1060 NULL
, /* la_get_symbol_name_cmp */
1061 iterate_over_symbols
,
1066 _initialize_c_language (void)
1068 add_language (&c_language_defn
);
1069 add_language (&cplus_language_defn
);
1070 add_language (&asm_language_defn
);
1071 add_language (&minimal_language_defn
);