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"
30 #include "gdb_assert.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.
232 If VALUE is an array with a known length, and *LENGTH is -1,
233 the function will not read past the end of the array. However, any
234 declared size of the array is ignored if *LENGTH > 0.
236 On completion, *LENGTH will be set to the size of the string read in
237 characters. (If a length of -1 is specified, the length returned
238 will not include the null character). CHARSET is always set to the
242 c_get_string (struct value
*value
, gdb_byte
**buffer
,
243 int *length
, struct type
**char_type
,
244 const char **charset
)
247 unsigned int fetchlimit
;
248 struct type
*type
= check_typedef (value_type (value
));
249 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
250 int req_length
= *length
;
251 enum bfd_endian byte_order
252 = gdbarch_byte_order (get_type_arch (type
));
254 if (element_type
== NULL
)
257 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
259 /* If we know the size of the array, we can use it as a limit on
260 the number of characters to be fetched. */
261 if (TYPE_NFIELDS (type
) == 1
262 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_RANGE
)
264 LONGEST low_bound
, high_bound
;
266 get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0),
267 &low_bound
, &high_bound
);
268 fetchlimit
= high_bound
- low_bound
+ 1;
271 fetchlimit
= UINT_MAX
;
273 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
274 fetchlimit
= UINT_MAX
;
276 /* We work only with arrays and pointers. */
279 if (! c_textual_element_type (element_type
, 0))
281 classify_type (element_type
, get_type_arch (element_type
), charset
);
282 width
= TYPE_LENGTH (element_type
);
284 /* If the string lives in GDB's memory instead of the inferior's,
285 then we just need to copy it to BUFFER. Also, since such strings
286 are arrays with known size, FETCHLIMIT will hold the size of the
288 if ((VALUE_LVAL (value
) == not_lval
289 || VALUE_LVAL (value
) == lval_internalvar
)
290 && fetchlimit
!= UINT_MAX
)
293 const gdb_byte
*contents
= value_contents (value
);
295 /* If a length is specified, use that. */
299 /* Otherwise, look for a null character. */
300 for (i
= 0; i
< fetchlimit
; i
++)
301 if (extract_unsigned_integer (contents
+ i
* width
,
302 width
, byte_order
) == 0)
305 /* I is now either a user-defined length, the number of non-null
306 characters, or FETCHLIMIT. */
308 *buffer
= xmalloc (*length
);
309 memcpy (*buffer
, contents
, *length
);
314 CORE_ADDR addr
= value_as_address (value
);
316 /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
317 if length > 0. The old "broken" behaviour is the behaviour we want:
318 The caller may want to fetch 100 bytes from a variable length array
319 implemented using the common idiom of having an array of length 1 at
320 the end of a struct. In this case we want to ignore the declared
321 size of the array. However, it's counterintuitive to implement that
322 behaviour in read_string: what does fetchlimit otherwise mean if
323 length > 0. Therefore we implement the behaviour we want here:
324 If *length > 0, don't specify a fetchlimit. This preserves the
325 previous behaviour. We could move this check above where we know
326 whether the array is declared with a fixed size, but we only want
327 to apply this behaviour when calling read_string. PR 16286. */
329 fetchlimit
= UINT_MAX
;
331 err
= read_string (addr
, *length
, width
, fetchlimit
,
332 byte_order
, buffer
, length
);
336 memory_error (err
, addr
);
340 /* If the LENGTH is specified at -1, we want to return the string
341 length up to the terminating null character. If an actual length
342 was specified, we want to return the length of exactly what was
344 if (req_length
== -1)
345 /* If the last character is null, subtract it from LENGTH. */
347 && extract_unsigned_integer (*buffer
+ *length
- width
,
348 width
, byte_order
) == 0)
351 /* The read_string function will return the number of bytes read.
352 If length returned from read_string was > 0, return the number of
353 characters read by dividing the number of bytes by width. */
355 *length
= *length
/ width
;
357 *char_type
= element_type
;
365 type_str
= type_to_string (type
);
368 make_cleanup (xfree
, type_str
);
369 error (_("Trying to read string with inappropriate type `%s'."),
373 error (_("Trying to read string with inappropriate type."));
378 /* Evaluating C and C++ expressions. */
380 /* Convert a UCN. The digits of the UCN start at P and extend no
381 farther than LIMIT. DEST_CHARSET is the name of the character set
382 into which the UCN should be converted. The results are written to
383 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
384 Returns a pointer to just after the final digit of the UCN. */
387 convert_ucn (char *p
, char *limit
, const char *dest_charset
,
388 struct obstack
*output
, int length
)
390 unsigned long result
= 0;
394 for (i
= 0; i
< length
&& p
< limit
&& isxdigit (*p
); ++i
, ++p
)
395 result
= (result
<< 4) + host_hex_value (*p
);
397 for (i
= 3; i
>= 0; --i
)
399 data
[i
] = result
& 0xff;
403 convert_between_encodings ("UTF-32BE", dest_charset
, data
,
404 4, 4, output
, translit_none
);
409 /* Emit a character, VALUE, which was specified numerically, to
410 OUTPUT. TYPE is the target character type. */
413 emit_numeric_character (struct type
*type
, unsigned long value
,
414 struct obstack
*output
)
418 buffer
= alloca (TYPE_LENGTH (type
));
419 pack_long (buffer
, type
, value
);
420 obstack_grow (output
, buffer
, TYPE_LENGTH (type
));
423 /* Convert an octal escape sequence. TYPE is the target character
424 type. The digits of the escape sequence begin at P and extend no
425 farther than LIMIT. The result is written to OUTPUT. Returns a
426 pointer to just after the final digit of the escape sequence. */
429 convert_octal (struct type
*type
, char *p
,
430 char *limit
, struct obstack
*output
)
433 unsigned long value
= 0;
436 i
< 3 && p
< limit
&& isdigit (*p
) && *p
!= '8' && *p
!= '9';
439 value
= 8 * value
+ host_hex_value (*p
);
443 emit_numeric_character (type
, value
, output
);
448 /* Convert a hex escape sequence. TYPE is the target character type.
449 The digits of the escape sequence begin at P and extend no farther
450 than LIMIT. The result is written to OUTPUT. Returns a pointer to
451 just after the final digit of the escape sequence. */
454 convert_hex (struct type
*type
, char *p
,
455 char *limit
, struct obstack
*output
)
457 unsigned long value
= 0;
459 while (p
< limit
&& isxdigit (*p
))
461 value
= 16 * value
+ host_hex_value (*p
);
465 emit_numeric_character (type
, value
, output
);
474 error (_("Malformed escape sequence")); \
477 /* Convert an escape sequence to a target format. TYPE is the target
478 character type to use, and DEST_CHARSET is the name of the target
479 character set. The backslash of the escape sequence is at *P, and
480 the escape sequence will not extend past LIMIT. The results are
481 written to OUTPUT. Returns a pointer to just past the final
482 character of the escape sequence. */
485 convert_escape (struct type
*type
, const char *dest_charset
,
486 char *p
, char *limit
, struct obstack
*output
)
488 /* Skip the backslash. */
494 obstack_1grow (output
, '\\');
501 error (_("\\x used with no following hex digits."));
502 p
= convert_hex (type
, p
, limit
, output
);
513 p
= convert_octal (type
, p
, limit
, output
);
519 int length
= *p
== 'u' ? 4 : 8;
523 error (_("\\u used with no following hex digits"));
524 p
= convert_ucn (p
, limit
, dest_charset
, output
, length
);
531 /* Given a single string from a (C-specific) OP_STRING list, convert
532 it to a target string, handling escape sequences specially. The
533 output is written to OUTPUT. DATA is the input string, which has
534 length LEN. DEST_CHARSET is the name of the target character set,
535 and TYPE is the type of target character to use. */
538 parse_one_string (struct obstack
*output
, char *data
, int len
,
539 const char *dest_charset
, struct type
*type
)
549 /* Look for next escape, or the end of the input. */
550 while (p
< limit
&& *p
!= '\\')
552 /* If we saw a run of characters, convert them all. */
554 convert_between_encodings (host_charset (), dest_charset
,
555 (gdb_byte
*) data
, p
- data
, 1,
556 output
, translit_none
);
557 /* If we saw an escape, convert it. */
559 p
= convert_escape (type
, dest_charset
, p
, limit
, output
);
564 /* Expression evaluator for the C language family. Most operations
565 are delegated to evaluate_subexp_standard; see that function for a
566 description of the arguments. */
569 evaluate_subexp_c (struct type
*expect_type
, struct expression
*exp
,
570 int *pos
, enum noside noside
)
572 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
580 struct obstack output
;
581 struct cleanup
*cleanup
;
582 struct value
*result
;
583 enum c_string_type dest_type
;
584 const char *dest_charset
;
585 int satisfy_expected
= 0;
587 obstack_init (&output
);
588 cleanup
= make_cleanup_obstack_free (&output
);
591 oplen
= longest_to_int (exp
->elts
[*pos
].longconst
);
594 limit
= *pos
+ BYTES_TO_EXP_ELEM (oplen
+ 1);
596 = (enum c_string_type
) longest_to_int (exp
->elts
[*pos
].longconst
);
597 switch (dest_type
& ~C_CHAR
)
600 type
= language_string_char_type (exp
->language_defn
,
604 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
608 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
609 "char16_t", NULL
, 0);
612 type
= lookup_typename (exp
->language_defn
, exp
->gdbarch
,
613 "char32_t", NULL
, 0);
616 internal_error (__FILE__
, __LINE__
, _("unhandled c_string_type"));
619 /* Ensure TYPE_LENGTH is valid for TYPE. */
620 check_typedef (type
);
622 /* If the caller expects an array of some integral type,
623 satisfy them. If something odder is expected, rely on the
625 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_ARRAY
)
627 struct type
*element_type
628 = check_typedef (TYPE_TARGET_TYPE (expect_type
));
630 if (TYPE_CODE (element_type
) == TYPE_CODE_INT
631 || TYPE_CODE (element_type
) == TYPE_CODE_CHAR
)
634 satisfy_expected
= 1;
638 dest_charset
= charset_for_string_type (dest_type
, exp
->gdbarch
);
645 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
648 if (noside
!= EVAL_SKIP
)
649 parse_one_string (&output
, &exp
->elts
[*pos
].string
, len
,
651 *pos
+= BYTES_TO_EXP_ELEM (len
);
654 /* Skip the trailing length and opcode. */
657 if (noside
== EVAL_SKIP
)
659 /* Return a dummy value of the appropriate type. */
660 if (expect_type
!= NULL
)
661 result
= allocate_value (expect_type
);
662 else if ((dest_type
& C_CHAR
) != 0)
663 result
= allocate_value (type
);
665 result
= value_cstring ("", 0, type
);
666 do_cleanups (cleanup
);
670 if ((dest_type
& C_CHAR
) != 0)
674 if (obstack_object_size (&output
) != TYPE_LENGTH (type
))
675 error (_("Could not convert character "
676 "constant to target character set"));
677 value
= unpack_long (type
, (gdb_byte
*) obstack_base (&output
));
678 result
= value_from_longest (type
, value
);
684 /* Write the terminating character. */
685 for (i
= 0; i
< TYPE_LENGTH (type
); ++i
)
686 obstack_1grow (&output
, 0);
688 if (satisfy_expected
)
690 LONGEST low_bound
, high_bound
;
691 int element_size
= TYPE_LENGTH (type
);
693 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type
),
694 &low_bound
, &high_bound
) < 0)
697 high_bound
= (TYPE_LENGTH (expect_type
) / element_size
) - 1;
699 if (obstack_object_size (&output
) / element_size
700 > (high_bound
- low_bound
+ 1))
701 error (_("Too many array elements"));
703 result
= allocate_value (expect_type
);
704 memcpy (value_contents_raw (result
), obstack_base (&output
),
705 obstack_object_size (&output
));
708 result
= value_cstring (obstack_base (&output
),
709 obstack_object_size (&output
),
712 do_cleanups (cleanup
);
720 return evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
725 /* Table mapping opcodes into strings for printing operators
726 and precedences of the operators. */
728 const struct op_print c_op_print_tab
[] =
730 {",", BINOP_COMMA
, PREC_COMMA
, 0},
731 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
732 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
733 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
734 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
735 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
736 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
737 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
738 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
739 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
740 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
741 {">", BINOP_GTR
, PREC_ORDER
, 0},
742 {"<", BINOP_LESS
, PREC_ORDER
, 0},
743 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
744 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
745 {"+", BINOP_ADD
, PREC_ADD
, 0},
746 {"-", BINOP_SUB
, PREC_ADD
, 0},
747 {"*", BINOP_MUL
, PREC_MUL
, 0},
748 {"/", BINOP_DIV
, PREC_MUL
, 0},
749 {"%", BINOP_REM
, PREC_MUL
, 0},
750 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
751 {"+", UNOP_PLUS
, PREC_PREFIX
, 0},
752 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
753 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
754 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
755 {"*", UNOP_IND
, PREC_PREFIX
, 0},
756 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
757 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
758 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
759 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
763 enum c_primitive_types
{
764 c_primitive_type_int
,
765 c_primitive_type_long
,
766 c_primitive_type_short
,
767 c_primitive_type_char
,
768 c_primitive_type_float
,
769 c_primitive_type_double
,
770 c_primitive_type_void
,
771 c_primitive_type_long_long
,
772 c_primitive_type_signed_char
,
773 c_primitive_type_unsigned_char
,
774 c_primitive_type_unsigned_short
,
775 c_primitive_type_unsigned_int
,
776 c_primitive_type_unsigned_long
,
777 c_primitive_type_unsigned_long_long
,
778 c_primitive_type_long_double
,
779 c_primitive_type_complex
,
780 c_primitive_type_double_complex
,
781 c_primitive_type_decfloat
,
782 c_primitive_type_decdouble
,
783 c_primitive_type_declong
,
788 c_language_arch_info (struct gdbarch
*gdbarch
,
789 struct language_arch_info
*lai
)
791 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
793 lai
->string_char_type
= builtin
->builtin_char
;
794 lai
->primitive_type_vector
795 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
797 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
798 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
799 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
800 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
801 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
802 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
803 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
804 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
805 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
806 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
807 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
808 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
809 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
810 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
811 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
812 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
813 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
814 lai
->primitive_type_vector
[c_primitive_type_decfloat
] = builtin
->builtin_decfloat
;
815 lai
->primitive_type_vector
[c_primitive_type_decdouble
] = builtin
->builtin_decdouble
;
816 lai
->primitive_type_vector
[c_primitive_type_declong
] = builtin
->builtin_declong
;
818 lai
->bool_type_default
= builtin
->builtin_int
;
821 const struct exp_descriptor exp_descriptor_c
=
823 print_subexp_standard
,
824 operator_length_standard
,
825 operator_check_standard
,
827 dump_subexp_body_standard
,
831 const struct language_defn c_language_defn
=
833 "c", /* Language name */
844 c_printchar
, /* Print a character constant */
845 c_printstr
, /* Function to print string constant */
846 c_emit_char
, /* Print a single char */
847 c_print_type
, /* Print a type using appropriate syntax */
848 c_print_typedef
, /* Print a typedef using appropriate syntax */
849 c_val_print
, /* Print a value using appropriate syntax */
850 c_value_print
, /* Print a top-level value */
851 default_read_var_value
, /* la_read_var_value */
852 NULL
, /* Language specific skip_trampoline */
853 NULL
, /* name_of_this */
854 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
855 basic_lookup_transparent_type
,/* lookup_transparent_type */
856 NULL
, /* Language specific symbol demangler */
857 NULL
, /* Language specific
858 class_name_from_physname */
859 c_op_print_tab
, /* expression operators for printing */
860 1, /* c-style arrays */
861 0, /* String lower bound */
862 default_word_break_characters
,
863 default_make_symbol_completion_list
,
864 c_language_arch_info
,
865 default_print_array_index
,
866 default_pass_by_reference
,
868 NULL
, /* la_get_symbol_name_cmp */
869 iterate_over_symbols
,
874 enum cplus_primitive_types
{
875 cplus_primitive_type_int
,
876 cplus_primitive_type_long
,
877 cplus_primitive_type_short
,
878 cplus_primitive_type_char
,
879 cplus_primitive_type_float
,
880 cplus_primitive_type_double
,
881 cplus_primitive_type_void
,
882 cplus_primitive_type_long_long
,
883 cplus_primitive_type_signed_char
,
884 cplus_primitive_type_unsigned_char
,
885 cplus_primitive_type_unsigned_short
,
886 cplus_primitive_type_unsigned_int
,
887 cplus_primitive_type_unsigned_long
,
888 cplus_primitive_type_unsigned_long_long
,
889 cplus_primitive_type_long_double
,
890 cplus_primitive_type_complex
,
891 cplus_primitive_type_double_complex
,
892 cplus_primitive_type_bool
,
893 cplus_primitive_type_decfloat
,
894 cplus_primitive_type_decdouble
,
895 cplus_primitive_type_declong
,
896 nr_cplus_primitive_types
900 cplus_language_arch_info (struct gdbarch
*gdbarch
,
901 struct language_arch_info
*lai
)
903 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
905 lai
->string_char_type
= builtin
->builtin_char
;
906 lai
->primitive_type_vector
907 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_cplus_primitive_types
+ 1,
909 lai
->primitive_type_vector
[cplus_primitive_type_int
]
910 = builtin
->builtin_int
;
911 lai
->primitive_type_vector
[cplus_primitive_type_long
]
912 = builtin
->builtin_long
;
913 lai
->primitive_type_vector
[cplus_primitive_type_short
]
914 = builtin
->builtin_short
;
915 lai
->primitive_type_vector
[cplus_primitive_type_char
]
916 = builtin
->builtin_char
;
917 lai
->primitive_type_vector
[cplus_primitive_type_float
]
918 = builtin
->builtin_float
;
919 lai
->primitive_type_vector
[cplus_primitive_type_double
]
920 = builtin
->builtin_double
;
921 lai
->primitive_type_vector
[cplus_primitive_type_void
]
922 = builtin
->builtin_void
;
923 lai
->primitive_type_vector
[cplus_primitive_type_long_long
]
924 = builtin
->builtin_long_long
;
925 lai
->primitive_type_vector
[cplus_primitive_type_signed_char
]
926 = builtin
->builtin_signed_char
;
927 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_char
]
928 = builtin
->builtin_unsigned_char
;
929 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_short
]
930 = builtin
->builtin_unsigned_short
;
931 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_int
]
932 = builtin
->builtin_unsigned_int
;
933 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long
]
934 = builtin
->builtin_unsigned_long
;
935 lai
->primitive_type_vector
[cplus_primitive_type_unsigned_long_long
]
936 = builtin
->builtin_unsigned_long_long
;
937 lai
->primitive_type_vector
[cplus_primitive_type_long_double
]
938 = builtin
->builtin_long_double
;
939 lai
->primitive_type_vector
[cplus_primitive_type_complex
]
940 = builtin
->builtin_complex
;
941 lai
->primitive_type_vector
[cplus_primitive_type_double_complex
]
942 = builtin
->builtin_double_complex
;
943 lai
->primitive_type_vector
[cplus_primitive_type_bool
]
944 = builtin
->builtin_bool
;
945 lai
->primitive_type_vector
[cplus_primitive_type_decfloat
]
946 = builtin
->builtin_decfloat
;
947 lai
->primitive_type_vector
[cplus_primitive_type_decdouble
]
948 = builtin
->builtin_decdouble
;
949 lai
->primitive_type_vector
[cplus_primitive_type_declong
]
950 = builtin
->builtin_declong
;
952 lai
->bool_type_symbol
= "bool";
953 lai
->bool_type_default
= builtin
->builtin_bool
;
956 const struct language_defn cplus_language_defn
=
958 "c++", /* Language name */
969 c_printchar
, /* Print a character constant */
970 c_printstr
, /* Function to print string constant */
971 c_emit_char
, /* Print a single char */
972 c_print_type
, /* Print a type using appropriate syntax */
973 c_print_typedef
, /* Print a typedef using appropriate syntax */
974 c_val_print
, /* Print a value using appropriate syntax */
975 c_value_print
, /* Print a top-level value */
976 default_read_var_value
, /* la_read_var_value */
977 cplus_skip_trampoline
, /* Language specific skip_trampoline */
978 "this", /* name_of_this */
979 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
980 cp_lookup_transparent_type
, /* lookup_transparent_type */
981 gdb_demangle
, /* Language specific symbol demangler */
982 cp_class_name_from_physname
, /* Language specific
983 class_name_from_physname */
984 c_op_print_tab
, /* expression operators for printing */
985 1, /* c-style arrays */
986 0, /* String lower bound */
987 default_word_break_characters
,
988 default_make_symbol_completion_list
,
989 cplus_language_arch_info
,
990 default_print_array_index
,
991 cp_pass_by_reference
,
993 NULL
, /* la_get_symbol_name_cmp */
994 iterate_over_symbols
,
999 const struct language_defn asm_language_defn
=
1001 "asm", /* Language name */
1012 c_printchar
, /* Print a character constant */
1013 c_printstr
, /* Function to print string constant */
1014 c_emit_char
, /* Print a single char */
1015 c_print_type
, /* Print a type using appropriate syntax */
1016 c_print_typedef
, /* Print a typedef using appropriate syntax */
1017 c_val_print
, /* Print a value using appropriate syntax */
1018 c_value_print
, /* Print a top-level value */
1019 default_read_var_value
, /* la_read_var_value */
1020 NULL
, /* Language specific skip_trampoline */
1021 NULL
, /* name_of_this */
1022 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1023 basic_lookup_transparent_type
,/* lookup_transparent_type */
1024 NULL
, /* Language specific symbol demangler */
1025 NULL
, /* Language specific
1026 class_name_from_physname */
1027 c_op_print_tab
, /* expression operators for printing */
1028 1, /* c-style arrays */
1029 0, /* String lower bound */
1030 default_word_break_characters
,
1031 default_make_symbol_completion_list
,
1032 c_language_arch_info
, /* FIXME: la_language_arch_info. */
1033 default_print_array_index
,
1034 default_pass_by_reference
,
1036 NULL
, /* la_get_symbol_name_cmp */
1037 iterate_over_symbols
,
1038 &default_varobj_ops
,
1042 /* The following language_defn does not represent a real language.
1043 It just provides a minimal support a-la-C that should allow users
1044 to do some simple operations when debugging applications that use
1045 a language currently not supported by GDB. */
1047 const struct language_defn minimal_language_defn
=
1049 "minimal", /* Language name */
1060 c_printchar
, /* Print a character constant */
1061 c_printstr
, /* Function to print string constant */
1062 c_emit_char
, /* Print a single char */
1063 c_print_type
, /* Print a type using appropriate syntax */
1064 c_print_typedef
, /* Print a typedef using appropriate syntax */
1065 c_val_print
, /* Print a value using appropriate syntax */
1066 c_value_print
, /* Print a top-level value */
1067 default_read_var_value
, /* la_read_var_value */
1068 NULL
, /* Language specific skip_trampoline */
1069 NULL
, /* name_of_this */
1070 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1071 basic_lookup_transparent_type
,/* lookup_transparent_type */
1072 NULL
, /* Language specific symbol demangler */
1073 NULL
, /* Language specific
1074 class_name_from_physname */
1075 c_op_print_tab
, /* expression operators for printing */
1076 1, /* c-style arrays */
1077 0, /* String lower bound */
1078 default_word_break_characters
,
1079 default_make_symbol_completion_list
,
1080 c_language_arch_info
,
1081 default_print_array_index
,
1082 default_pass_by_reference
,
1084 NULL
, /* la_get_symbol_name_cmp */
1085 iterate_over_symbols
,
1086 &default_varobj_ops
,
1091 _initialize_c_language (void)
1093 add_language (&c_language_defn
);
1094 add_language (&cplus_language_defn
);
1095 add_language (&asm_language_defn
);
1096 add_language (&minimal_language_defn
);