1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992-2014 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"
33 #include "cp-support.h"
34 #include "gdb_obstack.h"
36 #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.
230 If VALUE is an array with a known length, and *LENGTH is -1,
231 the function will not read past the end of the array. However, any
232 declared size of the array is ignored if *LENGTH > 0.
234 On completion, *LENGTH will be set to the size of the string read in
235 characters. (If a length of -1 is specified, the length returned
236 will not include the null character). CHARSET is always set to the
240 c_get_string (struct value
*value
, gdb_byte
**buffer
,
241 int *length
, struct type
**char_type
,
242 const char **charset
)
245 unsigned int fetchlimit
;
246 struct type
*type
= check_typedef (value_type (value
));
247 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
248 int req_length
= *length
;
249 enum bfd_endian byte_order
250 = gdbarch_byte_order (get_type_arch (type
));
252 if (element_type
== NULL
)
255 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
257 /* If we know the size of the array, we can use it as a limit on
258 the number of characters to be fetched. */
259 if (TYPE_NFIELDS (type
) == 1
260 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
262 LONGEST low_bound
, high_bound
;
264 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
265 &low_bound
, &high_bound
);
266 fetchlimit
= high_bound
- low_bound
+ 1;
269 fetchlimit
= UINT_MAX
;
271 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
272 fetchlimit
= UINT_MAX
;
274 /* We work only with arrays and pointers. */
277 if (! c_textual_element_type (element_type
, 0))
279 classify_type (element_type
, get_type_arch (element_type
), charset
);
280 width
= TYPE_LENGTH (element_type
);
282 /* If the string lives in GDB's memory instead of the inferior's,
283 then we just need to copy it to BUFFER. Also, since such strings
284 are arrays with known size, FETCHLIMIT will hold the size of the
286 if ((VALUE_LVAL (value
) == not_lval
287 || VALUE_LVAL (value
) == lval_internalvar
)
288 && fetchlimit
!= UINT_MAX
)
291 const gdb_byte
*contents
= value_contents (value
);
293 /* If a length is specified, use that. */
297 /* Otherwise, look for a null character. */
298 for (i
= 0; i
< fetchlimit
; i
++)
299 if (extract_unsigned_integer (contents
+ i
* width
,
300 width
, byte_order
) == 0)
303 /* I is now either a user-defined length, the number of non-null
304 characters, or FETCHLIMIT. */
306 *buffer
= xmalloc (*length
);
307 memcpy (*buffer
, contents
, *length
);
312 CORE_ADDR addr
= value_as_address (value
);
314 /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
315 if length > 0. The old "broken" behaviour is the behaviour we want:
316 The caller may want to fetch 100 bytes from a variable length array
317 implemented using the common idiom of having an array of length 1 at
318 the end of a struct. In this case we want to ignore the declared
319 size of the array. However, it's counterintuitive to implement that
320 behaviour in read_string: what does fetchlimit otherwise mean if
321 length > 0. Therefore we implement the behaviour we want here:
322 If *length > 0, don't specify a fetchlimit. This preserves the
323 previous behaviour. We could move this check above where we know
324 whether the array is declared with a fixed size, but we only want
325 to apply this behaviour when calling read_string. PR 16286. */
327 fetchlimit
= UINT_MAX
;
329 err
= read_string (addr
, *length
, width
, fetchlimit
,
330 byte_order
, buffer
, length
);
334 memory_error (err
, addr
);
338 /* If the LENGTH is specified at -1, we want to return the string
339 length up to the terminating null character. If an actual length
340 was specified, we want to return the length of exactly what was
342 if (req_length
== -1)
343 /* If the last character is null, subtract it from LENGTH. */
345 && extract_unsigned_integer (*buffer
+ *length
- width
,
346 width
, byte_order
) == 0)
349 /* The read_string function will return the number of bytes read.
350 If length returned from read_string was > 0, return the number of
351 characters read by dividing the number of bytes by width. */
353 *length
= *length
/ width
;
355 *char_type
= element_type
;
363 type_str
= type_to_string (type
);
366 make_cleanup (xfree
, type_str
);
367 error (_("Trying to read string with inappropriate type `%s'."),
371 error (_("Trying to read string with inappropriate type."));
376 /* Evaluating C and C++ expressions. */
378 /* Convert a UCN. The digits of the UCN start at P and extend no
379 farther than LIMIT. DEST_CHARSET is the name of the character set
380 into which the UCN should be converted. The results are written to
381 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
382 Returns a pointer to just after the final digit of the UCN. */
385 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
386 struct obstack
*output
, int length
)
388 unsigned long result
= 0;
392 for (i
= 0; i
< length
&& p
< limit
&& isxdigit (*p
); ++i
, ++p
)
393 result
= (result
<< 4) + host_hex_value (*p
);
395 for (i
= 3; i
>= 0; --i
)
397 data
[i
] = result
& 0xff;
401 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
402 4, 4, output
, translit_none
);
407 /* Emit a character, VALUE, which was specified numerically, to
408 OUTPUT. TYPE is the target character type. */
411 emit_numeric_character (struct type
*type
, unsigned long value
,
412 struct obstack
*output
)
416 buffer
= alloca (TYPE_LENGTH (type
));
417 pack_long (buffer
, type
, value
);
418 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
421 /* Convert an octal escape sequence. TYPE is the target character
422 type. The digits of the escape sequence begin at P and extend no
423 farther than LIMIT. The result is written to OUTPUT. Returns a
424 pointer to just after the final digit of the escape sequence. */
427 convert_octal (struct type
*type
, char *p
,
428 char *limit
, struct obstack
*output
)
431 unsigned long value
= 0;
434 i
< 3 && p
< limit
&& isdigit (*p
) && *p
!= '8' && *p
!= '9';
437 value
= 8 * value
+ host_hex_value (*p
);
441 emit_numeric_character (type
, value
, output
);
446 /* Convert a hex escape sequence. TYPE is the target character type.
447 The digits of the escape sequence begin at P and extend no farther
448 than LIMIT. The result is written to OUTPUT. Returns a pointer to
449 just after the final digit of the escape sequence. */
452 convert_hex (struct type
*type
, char *p
,
453 char *limit
, struct obstack
*output
)
455 unsigned long value
= 0;
457 while (p
< limit
&& isxdigit (*p
))
459 value
= 16 * value
+ host_hex_value (*p
);
463 emit_numeric_character (type
, value
, output
);
472 error (_("Malformed escape sequence")); \
475 /* Convert an escape sequence to a target format. TYPE is the target
476 character type to use, and DEST_CHARSET is the name of the target
477 character set. The backslash of the escape sequence is at *P, and
478 the escape sequence will not extend past LIMIT. The results are
479 written to OUTPUT. Returns a pointer to just past the final
480 character of the escape sequence. */
483 convert_escape (struct type
*type
, const char *dest_charset
,
484 char *p
, char *limit
, struct obstack
*output
)
486 /* Skip the backslash. */
492 obstack_1grow (output
, '\\');
499 error (_("\\x used with no following hex digits."));
500 p
= convert_hex (type
, p
, limit
, output
);
511 p
= convert_octal (type
, p
, limit
, output
);
517 int length
= *p
== 'u' ? 4 : 8;
521 error (_("\\u used with no following hex digits"));
522 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
529 /* Given a single string from a (C-specific) OP_STRING list, convert
530 it to a target string, handling escape sequences specially. The
531 output is written to OUTPUT. DATA is the input string, which has
532 length LEN. DEST_CHARSET is the name of the target character set,
533 and TYPE is the type of target character to use. */
536 parse_one_string (struct obstack
*output
, char *data
, int len
,
537 const char *dest_charset
, struct type
*type
)
547 /* Look for next escape, or the end of the input. */
548 while (p
< limit
&& *p
!= '\\')
550 /* If we saw a run of characters, convert them all. */
552 convert_between_encodings (host_charset (), dest_charset
,
553 (gdb_byte
*) data
, p
- data
, 1,
554 output
, translit_none
);
555 /* If we saw an escape, convert it. */
557 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
562 /* Expression evaluator for the C language family. Most operations
563 are delegated to evaluate_subexp_standard; see that function for a
564 description of the arguments. */
567 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
568 int *pos
, enum noside noside
)
570 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
578 struct obstack output
;
579 struct cleanup
*cleanup
;
580 struct value
*result
;
581 enum c_string_type dest_type
;
582 const char *dest_charset
;
583 int satisfy_expected
= 0;
585 obstack_init (&output
);
586 cleanup
= make_cleanup_obstack_free (&output
);
589 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
592 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
594 = (enum c_string_type
) longest_to_int (exp
->elts
[*pos
].longconst
);
595 switch (dest_type
& ~C_CHAR
)
598 type
= language_string_char_type (exp
->language_defn
,
602 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
606 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
607 "char16_t", NULL
, 0);
610 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
611 "char32_t", NULL
, 0);
614 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
617 /* Ensure TYPE_LENGTH is valid for TYPE. */
618 check_typedef (type
);
620 /* If the caller expects an array of some integral type,
621 satisfy them. If something odder is expected, rely on the
623 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_ARRAY
)
625 struct type
*element_type
626 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
628 if (TYPE_CODE (element_type
) == TYPE_CODE_INT
629 || TYPE_CODE (element_type
) == TYPE_CODE_CHAR
)
632 satisfy_expected
= 1;
636 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
643 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
646 if (noside
!= EVAL_SKIP
)
647 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
649 *pos
+= BYTES_TO_EXP_ELEM (len
);
652 /* Skip the trailing length and opcode. */
655 if (noside
== EVAL_SKIP
)
657 /* Return a dummy value of the appropriate type. */
658 if (expect_type
!= NULL
)
659 result
= allocate_value (expect_type
);
660 else if ((dest_type
& C_CHAR
) != 0)
661 result
= allocate_value (type
);
663 result
= value_cstring ("", 0, type
);
664 do_cleanups (cleanup
);
668 if ((dest_type
& C_CHAR
) != 0)
672 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
673 error (_("Could not convert character "
674 "constant to target character set"));
675 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
676 result
= value_from_longest (type
, value
);
682 /* Write the terminating character. */
683 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
684 obstack_1grow (&output
, 0);
686 if (satisfy_expected
)
688 LONGEST low_bound
, high_bound
;
689 int element_size
= TYPE_LENGTH (type
);
691 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type
),
692 &low_bound
, &high_bound
) < 0)
695 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
697 if (obstack_object_size (&output
) / element_size
698 > (high_bound
- low_bound
+ 1))
699 error (_("Too many array elements"));
701 result
= allocate_value (expect_type
);
702 memcpy (value_contents_raw (result
), obstack_base (&output
),
703 obstack_object_size (&output
));
706 result
= value_cstring (obstack_base (&output
),
707 obstack_object_size (&output
),
710 do_cleanups (cleanup
);
718 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
723 /* Table mapping opcodes into strings for printing operators
724 and precedences of the operators. */
726 const struct op_print c_op_print_tab
[] =
728 {",", BINOP_COMMA
, PREC_COMMA
, 0},
729 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
730 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
731 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
732 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
733 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
734 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
735 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
736 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
737 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
738 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
739 {">", BINOP_GTR
, PREC_ORDER
, 0},
740 {"<", BINOP_LESS
, PREC_ORDER
, 0},
741 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
742 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
743 {"+", BINOP_ADD
, PREC_ADD
, 0},
744 {"-", BINOP_SUB
, PREC_ADD
, 0},
745 {"*", BINOP_MUL
, PREC_MUL
, 0},
746 {"/", BINOP_DIV
, PREC_MUL
, 0},
747 {"%", BINOP_REM
, PREC_MUL
, 0},
748 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
749 {"+", UNOP_PLUS
, PREC_PREFIX
, 0},
750 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
751 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
752 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
753 {"*", UNOP_IND
, PREC_PREFIX
, 0},
754 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
755 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
756 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
757 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
761 enum c_primitive_types
{
762 c_primitive_type_int
,
763 c_primitive_type_long
,
764 c_primitive_type_short
,
765 c_primitive_type_char
,
766 c_primitive_type_float
,
767 c_primitive_type_double
,
768 c_primitive_type_void
,
769 c_primitive_type_long_long
,
770 c_primitive_type_signed_char
,
771 c_primitive_type_unsigned_char
,
772 c_primitive_type_unsigned_short
,
773 c_primitive_type_unsigned_int
,
774 c_primitive_type_unsigned_long
,
775 c_primitive_type_unsigned_long_long
,
776 c_primitive_type_long_double
,
777 c_primitive_type_complex
,
778 c_primitive_type_double_complex
,
779 c_primitive_type_decfloat
,
780 c_primitive_type_decdouble
,
781 c_primitive_type_declong
,
786 c_language_arch_info (struct gdbarch
*gdbarch
,
787 struct language_arch_info
*lai
)
789 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
791 lai
->string_char_type
= builtin
->builtin_char
;
792 lai
->primitive_type_vector
793 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
795 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
796 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
797 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
798 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
799 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
800 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
801 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
802 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
803 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
804 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
805 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
806 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
807 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
808 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
809 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
810 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
811 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
812 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
813 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
814 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
816 lai
->bool_type_default
= builtin
->builtin_int
;
819 const struct exp_descriptor exp_descriptor_c
=
821 print_subexp_standard
,
822 operator_length_standard
,
823 operator_check_standard
,
825 dump_subexp_body_standard
,
829 const struct language_defn c_language_defn
=
831 "c", /* Language name */
842 c_printchar
, /* Print a character constant */
843 c_printstr
, /* Function to print string constant */
844 c_emit_char
, /* Print a single char */
845 c_print_type
, /* Print a type using appropriate syntax */
846 c_print_typedef
, /* Print a typedef using appropriate syntax */
847 c_val_print
, /* Print a value using appropriate syntax */
848 c_value_print
, /* Print a top-level value */
849 default_read_var_value
, /* la_read_var_value */
850 NULL
, /* Language specific skip_trampoline */
851 NULL
, /* name_of_this */
852 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
853 basic_lookup_transparent_type
,/* lookup_transparent_type */
854 NULL
, /* Language specific symbol demangler */
855 NULL
, /* Language specific
856 class_name_from_physname */
857 c_op_print_tab
, /* expression operators for printing */
858 1, /* c-style arrays */
859 0, /* String lower bound */
860 default_word_break_characters
,
861 default_make_symbol_completion_list
,
862 c_language_arch_info
,
863 default_print_array_index
,
864 default_pass_by_reference
,
866 NULL
, /* la_get_symbol_name_cmp */
867 iterate_over_symbols
,
872 enum cplus_primitive_types
{
873 cplus_primitive_type_int
,
874 cplus_primitive_type_long
,
875 cplus_primitive_type_short
,
876 cplus_primitive_type_char
,
877 cplus_primitive_type_float
,
878 cplus_primitive_type_double
,
879 cplus_primitive_type_void
,
880 cplus_primitive_type_long_long
,
881 cplus_primitive_type_signed_char
,
882 cplus_primitive_type_unsigned_char
,
883 cplus_primitive_type_unsigned_short
,
884 cplus_primitive_type_unsigned_int
,
885 cplus_primitive_type_unsigned_long
,
886 cplus_primitive_type_unsigned_long_long
,
887 cplus_primitive_type_long_double
,
888 cplus_primitive_type_complex
,
889 cplus_primitive_type_double_complex
,
890 cplus_primitive_type_bool
,
891 cplus_primitive_type_decfloat
,
892 cplus_primitive_type_decdouble
,
893 cplus_primitive_type_declong
,
894 nr_cplus_primitive_types
898 cplus_language_arch_info (struct gdbarch
*gdbarch
,
899 struct language_arch_info
*lai
)
901 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
903 lai
->string_char_type
= builtin
->builtin_char
;
904 lai
->primitive_type_vector
905 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
907 lai
->primitive_type_vector
[cplus_primitive_type_int
]
908 = builtin
->builtin_int
;
909 lai
->primitive_type_vector
[cplus_primitive_type_long
]
910 = builtin
->builtin_long
;
911 lai
->primitive_type_vector
[cplus_primitive_type_short
]
912 = builtin
->builtin_short
;
913 lai
->primitive_type_vector
[cplus_primitive_type_char
]
914 = builtin
->builtin_char
;
915 lai
->primitive_type_vector
[cplus_primitive_type_float
]
916 = builtin
->builtin_float
;
917 lai
->primitive_type_vector
[cplus_primitive_type_double
]
918 = builtin
->builtin_double
;
919 lai
->primitive_type_vector
[cplus_primitive_type_void
]
920 = builtin
->builtin_void
;
921 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
922 = builtin
->builtin_long_long
;
923 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
924 = builtin
->builtin_signed_char
;
925 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
926 = builtin
->builtin_unsigned_char
;
927 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
928 = builtin
->builtin_unsigned_short
;
929 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
930 = builtin
->builtin_unsigned_int
;
931 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
932 = builtin
->builtin_unsigned_long
;
933 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
934 = builtin
->builtin_unsigned_long_long
;
935 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
936 = builtin
->builtin_long_double
;
937 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
938 = builtin
->builtin_complex
;
939 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
940 = builtin
->builtin_double_complex
;
941 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
942 = builtin
->builtin_bool
;
943 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
944 = builtin
->builtin_decfloat
;
945 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
946 = builtin
->builtin_decdouble
;
947 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
948 = builtin
->builtin_declong
;
950 lai
->bool_type_symbol
= "bool";
951 lai
->bool_type_default
= builtin
->builtin_bool
;
954 const struct language_defn cplus_language_defn
=
956 "c++", /* Language name */
967 c_printchar
, /* Print a character constant */
968 c_printstr
, /* Function to print string constant */
969 c_emit_char
, /* Print a single char */
970 c_print_type
, /* Print a type using appropriate syntax */
971 c_print_typedef
, /* Print a typedef using appropriate syntax */
972 c_val_print
, /* Print a value using appropriate syntax */
973 c_value_print
, /* Print a top-level value */
974 default_read_var_value
, /* la_read_var_value */
975 cplus_skip_trampoline
, /* Language specific skip_trampoline */
976 "this", /* name_of_this */
977 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
978 cp_lookup_transparent_type
, /* lookup_transparent_type */
979 gdb_demangle
, /* Language specific symbol demangler */
980 cp_class_name_from_physname
, /* Language specific
981 class_name_from_physname */
982 c_op_print_tab
, /* expression operators for printing */
983 1, /* c-style arrays */
984 0, /* String lower bound */
985 default_word_break_characters
,
986 default_make_symbol_completion_list
,
987 cplus_language_arch_info
,
988 default_print_array_index
,
989 cp_pass_by_reference
,
991 NULL
, /* la_get_symbol_name_cmp */
992 iterate_over_symbols
,
997 const struct language_defn asm_language_defn
=
999 "asm", /* Language name */
1010 c_printchar
, /* Print a character constant */
1011 c_printstr
, /* Function to print string constant */
1012 c_emit_char
, /* Print a single char */
1013 c_print_type
, /* Print a type using appropriate syntax */
1014 c_print_typedef
, /* Print a typedef using appropriate syntax */
1015 c_val_print
, /* Print a value using appropriate syntax */
1016 c_value_print
, /* Print a top-level value */
1017 default_read_var_value
, /* la_read_var_value */
1018 NULL
, /* Language specific skip_trampoline */
1019 NULL
, /* name_of_this */
1020 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1021 basic_lookup_transparent_type
,/* lookup_transparent_type */
1022 NULL
, /* Language specific symbol demangler */
1023 NULL
, /* Language specific
1024 class_name_from_physname */
1025 c_op_print_tab
, /* expression operators for printing */
1026 1, /* c-style arrays */
1027 0, /* String lower bound */
1028 default_word_break_characters
,
1029 default_make_symbol_completion_list
,
1030 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1031 default_print_array_index
,
1032 default_pass_by_reference
,
1034 NULL
, /* la_get_symbol_name_cmp */
1035 iterate_over_symbols
,
1036 &default_varobj_ops
,
1040 /* The following language_defn does not represent a real language.
1041 It just provides a minimal support a-la-C that should allow users
1042 to do some simple operations when debugging applications that use
1043 a language currently not supported by GDB. */
1045 const struct language_defn minimal_language_defn
=
1047 "minimal", /* Language name */
1058 c_printchar
, /* Print a character constant */
1059 c_printstr
, /* Function to print string constant */
1060 c_emit_char
, /* Print a single char */
1061 c_print_type
, /* Print a type using appropriate syntax */
1062 c_print_typedef
, /* Print a typedef using appropriate syntax */
1063 c_val_print
, /* Print a value using appropriate syntax */
1064 c_value_print
, /* Print a top-level value */
1065 default_read_var_value
, /* la_read_var_value */
1066 NULL
, /* Language specific skip_trampoline */
1067 NULL
, /* name_of_this */
1068 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1069 basic_lookup_transparent_type
,/* lookup_transparent_type */
1070 NULL
, /* Language specific symbol demangler */
1071 NULL
, /* Language specific
1072 class_name_from_physname */
1073 c_op_print_tab
, /* expression operators for printing */
1074 1, /* c-style arrays */
1075 0, /* String lower bound */
1076 default_word_break_characters
,
1077 default_make_symbol_completion_list
,
1078 c_language_arch_info
,
1079 default_print_array_index
,
1080 default_pass_by_reference
,
1082 NULL
, /* la_get_symbol_name_cmp */
1083 iterate_over_symbols
,
1084 &default_varobj_ops
,
1089 _initialize_c_language (void)
1091 add_language (&c_language_defn
);
1092 add_language (&cplus_language_defn
);
1093 add_language (&asm_language_defn
);
1094 add_language (&minimal_language_defn
);