1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992-1996, 1998-2000, 2002-2005, 2007-2012 Free
4 Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
25 #include "parser-defs.h"
29 #include "macroscope.h"
30 #include "gdb_assert.h"
32 #include "gdb_string.h"
35 #include "cp-support.h"
36 #include "gdb_obstack.h"
38 #include "exceptions.h"
40 extern void _initialize_c_language (void);
42 /* Given a C string type, STR_TYPE, return the corresponding target
43 character set name. */
46 charset_for_string_type (enum c_string_type str_type,
47 struct gdbarch *gdbarch)
49 switch (str_type & ~C_CHAR)
52 return target_charset (gdbarch);
54 return target_wide_charset (gdbarch);
56 /* FIXME: UTF-16 is not always correct. */
57 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
62 /* FIXME: UTF-32 is not always correct. */
63 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
68 internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
71 /* Classify ELTTYPE according to what kind of character it is. Return
72 the enum constant representing the character type. Also set
73 *ENCODING to the name of the character set to use when converting
74 characters of this type in target BYTE_ORDER to the host character
77 static enum c_string_type
78 classify_type (struct type *elttype, struct gdbarch *gdbarch,
79 const char **encoding)
81 enum c_string_type result;
83 /* We loop because ELTTYPE may be a typedef, and we want to
84 successively peel each typedef until we reach a type we
85 understand. We don't use CHECK_TYPEDEF because that will strip
86 all typedefs at once -- but in C, wchar_t is itself a typedef, so
87 that would do the wrong thing. */
90 const char *name = TYPE_NAME (elttype);
92 if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
98 if (!strcmp (name, "wchar_t"))
100 result = C_WIDE_CHAR;
104 if (!strcmp (name, "char16_t"))
110 if (!strcmp (name, "char32_t"))
116 if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
119 /* Call for side effects. */
120 check_typedef (elttype);
122 if (TYPE_TARGET_TYPE (elttype))
123 elttype = TYPE_TARGET_TYPE (elttype);
126 /* Perhaps check_typedef did not update the target type. In
127 this case, force the lookup again and hope it works out.
128 It never will for C, but it might for C++. */
129 CHECK_TYPEDEF (elttype);
138 *encoding = charset_for_string_type (result, gdbarch);
143 /* Print the character C on STREAM as part of the contents of a
144 literal string whose delimiter is QUOTER. Note that that format
145 for printing characters and strings is language specific. */
148 c_emit_char (int c, struct type *type,
149 struct ui_file *stream, int quoter)
151 const char *encoding;
153 classify_type (type, get_type_arch (type), &encoding);
154 generic_emit_char (c, type, stream, quoter, encoding);
158 c_printchar (int c, struct type *type, struct ui_file *stream)
160 enum c_string_type str_type;
162 str_type = classify_type (type, get_type_arch (type), NULL);
168 fputc_filtered ('L', stream);
171 fputc_filtered ('u', stream);
174 fputc_filtered ('U', stream);
178 fputc_filtered ('\'', stream);
179 LA_EMIT_CHAR (c, type, stream, '\'');
180 fputc_filtered ('\'', stream);
183 /* Print the character string STRING, printing at most LENGTH
184 characters. LENGTH is -1 if the string is nul terminated. Each
185 character is WIDTH bytes long. Printing stops early if the number
186 hits print_max; repeat counts are printed as appropriate. Print
187 ellipses at the end if we had to stop before printing LENGTH
188 characters, or if FORCE_ELLIPSES. */
191 c_printstr (struct ui_file *stream, struct type *type,
192 const gdb_byte *string, unsigned int length,
193 const char *user_encoding, int force_ellipses,
194 const struct value_print_options *options)
196 enum c_string_type str_type;
197 const char *type_encoding;
198 const char *encoding;
200 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
202 unsigned int things_printed = 0;
205 struct obstack wchar_buf, output;
206 struct cleanup *cleanup;
207 struct wchar_iterator *iter;
211 str_type = (classify_type (type, get_type_arch (type), &type_encoding)
218 fputs_filtered ("L", stream);
221 fputs_filtered ("u", stream);
224 fputs_filtered ("U", stream);
228 encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
230 generic_printstr (stream, type, string, length, encoding, force_ellipses,
234 /* Obtain a C string from the inferior storing it in a newly allocated
235 buffer in BUFFER, which should be freed by the caller. If the in-
236 and out-parameter *LENGTH is specified at -1, the string is read
237 until a null character of the appropriate width is found, otherwise
238 the string is read to the length of characters specified. The size
239 of a character is determined by the length of the target type of
240 the pointer or array. If VALUE is an array with a known length,
241 the function will not read past the end of the array. On
242 completion, *LENGTH will be set to the size of the string read in
243 characters. (If a length of -1 is specified, the length returned
244 will not include the null character). CHARSET is always set to the
248 c_get_string (struct value *value, gdb_byte **buffer,
249 int *length, struct type **char_type,
250 const char **charset)
253 unsigned int fetchlimit;
254 struct type *type = check_typedef (value_type (value));
255 struct type *element_type = TYPE_TARGET_TYPE (type);
256 int req_length = *length;
257 enum bfd_endian byte_order
258 = gdbarch_byte_order (get_type_arch (type));
259 enum c_string_type kind;
261 if (element_type == NULL)
264 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
266 /* If we know the size of the array, we can use it as a limit on
267 the number of characters to be fetched. */
268 if (TYPE_NFIELDS (type) == 1
269 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
271 LONGEST low_bound, high_bound;
273 get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
274 &low_bound, &high_bound);
275 fetchlimit = high_bound - low_bound + 1;
278 fetchlimit = UINT_MAX;
280 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
281 fetchlimit = UINT_MAX;
283 /* We work only with arrays and pointers. */
286 if (! c_textual_element_type (element_type, 0))
288 kind = classify_type (element_type,
289 get_type_arch (element_type),
291 width = TYPE_LENGTH (element_type);
293 /* If the string lives in GDB's memory instead of the inferior's,
294 then we just need to copy it to BUFFER. Also, since such strings
295 are arrays with known size, FETCHLIMIT will hold the size of the
297 if ((VALUE_LVAL (value) == not_lval
298 || VALUE_LVAL (value) == lval_internalvar)
299 && fetchlimit != UINT_MAX)
302 const gdb_byte *contents = value_contents (value);
304 /* If a length is specified, use that. */
308 /* Otherwise, look for a null character. */
309 for (i = 0; i < fetchlimit; i++)
310 if (extract_unsigned_integer (contents + i * width,
311 width, byte_order) == 0)
314 /* I is now either a user-defined length, the number of non-null
315 characters, or FETCHLIMIT. */
317 *buffer = xmalloc (*length);
318 memcpy (*buffer, contents, *length);
323 CORE_ADDR addr = value_as_address (value);
325 err = read_string (addr, *length, width, fetchlimit,
326 byte_order, buffer, length);
331 throw_error (MEMORY_ERROR, "Address %s out of bounds",
332 paddress (get_type_arch (type), addr));
334 error (_("Error reading string from inferior: %s"),
335 safe_strerror (err));
339 /* If the LENGTH is specified at -1, we want to return the string
340 length up to the terminating null character. If an actual length
341 was specified, we want to return the length of exactly what was
343 if (req_length == -1)
344 /* If the last character is null, subtract it from LENGTH. */
346 && extract_unsigned_integer (*buffer + *length - width,
347 width, byte_order) == 0)
350 /* The read_string function will return the number of bytes read.
351 If length returned from read_string was > 0, return the number of
352 characters read by dividing the number of bytes by width. */
354 *length = *length / width;
356 *char_type = element_type;
364 type_str = type_to_string (type);
367 make_cleanup (xfree, type_str);
368 error (_("Trying to read string with inappropriate type `%s'."),
372 error (_("Trying to read string with inappropriate type."));
377 /* Evaluating C and C++ expressions. */
379 /* Convert a UCN. The digits of the UCN start at P and extend no
380 farther than LIMIT. DEST_CHARSET is the name of the character set
381 into which the UCN should be converted. The results are written to
382 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
383 Returns a pointer to just after the final digit of the UCN. */
386 convert_ucn (char *p, char *limit, const char *dest_charset,
387 struct obstack *output, int length)
389 unsigned long result = 0;
393 for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
394 result = (result << 4) + host_hex_value (*p);
396 for (i = 3; i >= 0; --i)
398 data[i] = result & 0xff;
402 convert_between_encodings ("UTF-32BE", dest_charset, data,
403 4, 4, output, translit_none);
408 /* Emit a character, VALUE, which was specified numerically, to
409 OUTPUT. TYPE is the target character type. */
412 emit_numeric_character (struct type *type, unsigned long value,
413 struct obstack *output)
417 buffer = alloca (TYPE_LENGTH (type));
418 pack_long (buffer, type, value);
419 obstack_grow (output, buffer, TYPE_LENGTH (type));
422 /* Convert an octal escape sequence. TYPE is the target character
423 type. The digits of the escape sequence begin at P and extend no
424 farther than LIMIT. The result is written to OUTPUT. Returns a
425 pointer to just after the final digit of the escape sequence. */
428 convert_octal (struct type *type, char *p,
429 char *limit, struct obstack *output)
432 unsigned long value = 0;
435 i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
438 value = 8 * value + host_hex_value (*p);
442 emit_numeric_character (type, value, output);
447 /* Convert a hex escape sequence. TYPE is the target character type.
448 The digits of the escape sequence begin at P and extend no farther
449 than LIMIT. The result is written to OUTPUT. Returns a pointer to
450 just after the final digit of the escape sequence. */
453 convert_hex (struct type *type, char *p,
454 char *limit, struct obstack *output)
456 unsigned long value = 0;
458 while (p < limit && isxdigit (*p))
460 value = 16 * value + host_hex_value (*p);
464 emit_numeric_character (type, value, output);
473 error (_("Malformed escape sequence")); \
476 /* Convert an escape sequence to a target format. TYPE is the target
477 character type to use, and DEST_CHARSET is the name of the target
478 character set. The backslash of the escape sequence is at *P, and
479 the escape sequence will not extend past LIMIT. The results are
480 written to OUTPUT. Returns a pointer to just past the final
481 character of the escape sequence. */
484 convert_escape (struct type *type, const char *dest_charset,
485 char *p, char *limit, struct obstack *output)
487 /* Skip the backslash. */
493 obstack_1grow (output, '\\');
500 error (_("\\x used with no following hex digits."));
501 p = convert_hex (type, p, limit, output);
512 p = convert_octal (type, p, limit, output);
518 int length = *p == 'u' ? 4 : 8;
522 error (_("\\u used with no following hex digits"));
523 p = convert_ucn (p, limit, dest_charset, output, length);
530 /* Given a single string from a (C-specific) OP_STRING list, convert
531 it to a target string, handling escape sequences specially. The
532 output is written to OUTPUT. DATA is the input string, which has
533 length LEN. DEST_CHARSET is the name of the target character set,
534 and TYPE is the type of target character to use. */
537 parse_one_string (struct obstack *output, char *data, int len,
538 const char *dest_charset, struct type *type)
548 /* Look for next escape, or the end of the input. */
549 while (p < limit && *p != '\\')
551 /* If we saw a run of characters, convert them all. */
553 convert_between_encodings (host_charset (), dest_charset,
555 output, translit_none);
556 /* If we saw an escape, convert it. */
558 p = convert_escape (type, dest_charset, p, limit, output);
563 /* Expression evaluator for the C language family. Most operations
564 are delegated to evaluate_subexp_standard; see that function for a
565 description of the arguments. */
568 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
569 int *pos, enum noside noside)
571 enum exp_opcode op = exp->elts[*pos].opcode;
579 struct obstack output;
580 struct cleanup *cleanup;
581 struct value *result;
582 enum c_string_type dest_type;
583 const char *dest_charset;
584 int satisfy_expected = 0;
586 obstack_init (&output);
587 cleanup = make_cleanup_obstack_free (&output);
590 oplen = longest_to_int (exp->elts[*pos].longconst);
593 limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
595 = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
596 switch (dest_type & ~C_CHAR)
599 type = language_string_char_type (exp->language_defn,
603 type = lookup_typename (exp->language_defn, exp->gdbarch,
607 type = lookup_typename (exp->language_defn, exp->gdbarch,
608 "char16_t", NULL, 0);
611 type = lookup_typename (exp->language_defn, exp->gdbarch,
612 "char32_t", NULL, 0);
615 internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
618 /* Ensure TYPE_LENGTH is valid for TYPE. */
619 check_typedef (type);
621 /* If the caller expects an array of some integral type,
622 satisfy them. If something odder is expected, rely on the
624 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
626 struct type *element_type
627 = check_typedef (TYPE_TARGET_TYPE (expect_type));
629 if (TYPE_CODE (element_type) == TYPE_CODE_INT
630 || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
633 satisfy_expected = 1;
637 dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
644 len = longest_to_int (exp->elts[*pos].longconst);
647 if (noside != EVAL_SKIP)
648 parse_one_string (&output, &exp->elts[*pos].string, len,
650 *pos += BYTES_TO_EXP_ELEM (len);
653 /* Skip the trailing length and opcode. */
656 if (noside == EVAL_SKIP)
658 /* Return a dummy value of the appropriate type. */
659 if (expect_type != NULL)
660 result = allocate_value (expect_type);
661 else if ((dest_type & C_CHAR) != 0)
662 result = allocate_value (type);
664 result = value_cstring ("", 0, type);
665 do_cleanups (cleanup);
669 if ((dest_type & C_CHAR) != 0)
673 if (obstack_object_size (&output) != TYPE_LENGTH (type))
674 error (_("Could not convert character "
675 "constant to target character set"));
676 value = unpack_long (type, obstack_base (&output));
677 result = value_from_longest (type, value);
683 /* Write the terminating character. */
684 for (i = 0; i < TYPE_LENGTH (type); ++i)
685 obstack_1grow (&output, 0);
687 if (satisfy_expected)
689 LONGEST low_bound, high_bound;
690 int element_size = TYPE_LENGTH (type);
692 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
693 &low_bound, &high_bound) < 0)
696 high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
698 if (obstack_object_size (&output) / element_size
699 > (high_bound - low_bound + 1))
700 error (_("Too many array elements"));
702 result = allocate_value (expect_type);
703 memcpy (value_contents_raw (result), obstack_base (&output),
704 obstack_object_size (&output));
707 result = value_cstring (obstack_base (&output),
708 obstack_object_size (&output),
711 do_cleanups (cleanup);
719 return evaluate_subexp_standard (expect_type, exp, pos, noside);
724 /* Table mapping opcodes into strings for printing operators
725 and precedences of the operators. */
727 const struct op_print c_op_print_tab[] =
729 {",", BINOP_COMMA, PREC_COMMA, 0},
730 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
731 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
732 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
733 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
734 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
735 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
736 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
737 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
738 {"<=", BINOP_LEQ, PREC_ORDER, 0},
739 {">=", BINOP_GEQ, PREC_ORDER, 0},
740 {">", BINOP_GTR, PREC_ORDER, 0},
741 {"<", BINOP_LESS, PREC_ORDER, 0},
742 {">>", BINOP_RSH, PREC_SHIFT, 0},
743 {"<<", BINOP_LSH, PREC_SHIFT, 0},
744 {"+", BINOP_ADD, PREC_ADD, 0},
745 {"-", BINOP_SUB, PREC_ADD, 0},
746 {"*", BINOP_MUL, PREC_MUL, 0},
747 {"/", BINOP_DIV, PREC_MUL, 0},
748 {"%", BINOP_REM, PREC_MUL, 0},
749 {"@", BINOP_REPEAT, PREC_REPEAT, 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 */
841 c_printchar, /* Print a character constant */
842 c_printstr, /* Function to print string constant */
843 c_emit_char, /* Print a single char */
844 c_print_type, /* Print a type using appropriate syntax */
845 c_print_typedef, /* Print a typedef using appropriate syntax */
846 c_val_print, /* Print a value using appropriate syntax */
847 c_value_print, /* Print a top-level value */
848 default_read_var_value, /* la_read_var_value */
849 NULL, /* Language specific skip_trampoline */
850 NULL, /* name_of_this */
851 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
852 basic_lookup_transparent_type,/* lookup_transparent_type */
853 NULL, /* Language specific symbol demangler */
854 NULL, /* Language specific
855 class_name_from_physname */
856 c_op_print_tab, /* expression operators for printing */
857 1, /* c-style arrays */
858 0, /* String lower bound */
859 default_word_break_characters,
860 default_make_symbol_completion_list,
861 c_language_arch_info,
862 default_print_array_index,
863 default_pass_by_reference,
865 NULL, /* la_get_symbol_name_cmp */
866 iterate_over_symbols,
870 enum cplus_primitive_types {
871 cplus_primitive_type_int,
872 cplus_primitive_type_long,
873 cplus_primitive_type_short,
874 cplus_primitive_type_char,
875 cplus_primitive_type_float,
876 cplus_primitive_type_double,
877 cplus_primitive_type_void,
878 cplus_primitive_type_long_long,
879 cplus_primitive_type_signed_char,
880 cplus_primitive_type_unsigned_char,
881 cplus_primitive_type_unsigned_short,
882 cplus_primitive_type_unsigned_int,
883 cplus_primitive_type_unsigned_long,
884 cplus_primitive_type_unsigned_long_long,
885 cplus_primitive_type_long_double,
886 cplus_primitive_type_complex,
887 cplus_primitive_type_double_complex,
888 cplus_primitive_type_bool,
889 cplus_primitive_type_decfloat,
890 cplus_primitive_type_decdouble,
891 cplus_primitive_type_declong,
892 nr_cplus_primitive_types
896 cplus_language_arch_info (struct gdbarch *gdbarch,
897 struct language_arch_info *lai)
899 const struct builtin_type *builtin = builtin_type (gdbarch);
901 lai->string_char_type = builtin->builtin_char;
902 lai->primitive_type_vector
903 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
905 lai->primitive_type_vector [cplus_primitive_type_int]
906 = builtin->builtin_int;
907 lai->primitive_type_vector [cplus_primitive_type_long]
908 = builtin->builtin_long;
909 lai->primitive_type_vector [cplus_primitive_type_short]
910 = builtin->builtin_short;
911 lai->primitive_type_vector [cplus_primitive_type_char]
912 = builtin->builtin_char;
913 lai->primitive_type_vector [cplus_primitive_type_float]
914 = builtin->builtin_float;
915 lai->primitive_type_vector [cplus_primitive_type_double]
916 = builtin->builtin_double;
917 lai->primitive_type_vector [cplus_primitive_type_void]
918 = builtin->builtin_void;
919 lai->primitive_type_vector [cplus_primitive_type_long_long]
920 = builtin->builtin_long_long;
921 lai->primitive_type_vector [cplus_primitive_type_signed_char]
922 = builtin->builtin_signed_char;
923 lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
924 = builtin->builtin_unsigned_char;
925 lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
926 = builtin->builtin_unsigned_short;
927 lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
928 = builtin->builtin_unsigned_int;
929 lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
930 = builtin->builtin_unsigned_long;
931 lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
932 = builtin->builtin_unsigned_long_long;
933 lai->primitive_type_vector [cplus_primitive_type_long_double]
934 = builtin->builtin_long_double;
935 lai->primitive_type_vector [cplus_primitive_type_complex]
936 = builtin->builtin_complex;
937 lai->primitive_type_vector [cplus_primitive_type_double_complex]
938 = builtin->builtin_double_complex;
939 lai->primitive_type_vector [cplus_primitive_type_bool]
940 = builtin->builtin_bool;
941 lai->primitive_type_vector [cplus_primitive_type_decfloat]
942 = builtin->builtin_decfloat;
943 lai->primitive_type_vector [cplus_primitive_type_decdouble]
944 = builtin->builtin_decdouble;
945 lai->primitive_type_vector [cplus_primitive_type_declong]
946 = builtin->builtin_declong;
948 lai->bool_type_symbol = "bool";
949 lai->bool_type_default = builtin->builtin_bool;
952 const struct language_defn cplus_language_defn =
954 "c++", /* Language name */
964 c_printchar, /* Print a character constant */
965 c_printstr, /* Function to print string constant */
966 c_emit_char, /* Print a single char */
967 c_print_type, /* Print a type using appropriate syntax */
968 c_print_typedef, /* Print a typedef using appropriate syntax */
969 c_val_print, /* Print a value using appropriate syntax */
970 c_value_print, /* Print a top-level value */
971 default_read_var_value, /* la_read_var_value */
972 cplus_skip_trampoline, /* Language specific skip_trampoline */
973 "this", /* name_of_this */
974 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
975 cp_lookup_transparent_type, /* lookup_transparent_type */
976 cplus_demangle, /* Language specific symbol demangler */
977 cp_class_name_from_physname, /* Language specific
978 class_name_from_physname */
979 c_op_print_tab, /* expression operators for printing */
980 1, /* c-style arrays */
981 0, /* String lower bound */
982 default_word_break_characters,
983 default_make_symbol_completion_list,
984 cplus_language_arch_info,
985 default_print_array_index,
986 cp_pass_by_reference,
988 NULL, /* la_get_symbol_name_cmp */
989 iterate_over_symbols,
993 const struct language_defn asm_language_defn =
995 "asm", /* Language name */
1005 c_printchar, /* Print a character constant */
1006 c_printstr, /* Function to print string constant */
1007 c_emit_char, /* Print a single char */
1008 c_print_type, /* Print a type using appropriate syntax */
1009 c_print_typedef, /* Print a typedef using appropriate syntax */
1010 c_val_print, /* Print a value using appropriate syntax */
1011 c_value_print, /* Print a top-level value */
1012 default_read_var_value, /* la_read_var_value */
1013 NULL, /* Language specific skip_trampoline */
1014 NULL, /* name_of_this */
1015 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1016 basic_lookup_transparent_type,/* lookup_transparent_type */
1017 NULL, /* Language specific symbol demangler */
1018 NULL, /* Language specific
1019 class_name_from_physname */
1020 c_op_print_tab, /* expression operators for printing */
1021 1, /* c-style arrays */
1022 0, /* String lower bound */
1023 default_word_break_characters,
1024 default_make_symbol_completion_list,
1025 c_language_arch_info, /* FIXME: la_language_arch_info. */
1026 default_print_array_index,
1027 default_pass_by_reference,
1029 NULL, /* la_get_symbol_name_cmp */
1030 iterate_over_symbols,
1034 /* The following language_defn does not represent a real language.
1035 It just provides a minimal support a-la-C that should allow users
1036 to do some simple operations when debugging applications that use
1037 a language currently not supported by GDB. */
1039 const struct language_defn minimal_language_defn =
1041 "minimal", /* Language name */
1051 c_printchar, /* Print a character constant */
1052 c_printstr, /* Function to print string constant */
1053 c_emit_char, /* Print a single char */
1054 c_print_type, /* Print a type using appropriate syntax */
1055 c_print_typedef, /* Print a typedef using appropriate syntax */
1056 c_val_print, /* Print a value using appropriate syntax */
1057 c_value_print, /* Print a top-level value */
1058 default_read_var_value, /* la_read_var_value */
1059 NULL, /* Language specific skip_trampoline */
1060 NULL, /* name_of_this */
1061 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1062 basic_lookup_transparent_type,/* lookup_transparent_type */
1063 NULL, /* Language specific symbol demangler */
1064 NULL, /* Language specific
1065 class_name_from_physname */
1066 c_op_print_tab, /* expression operators for printing */
1067 1, /* c-style arrays */
1068 0, /* String lower bound */
1069 default_word_break_characters,
1070 default_make_symbol_completion_list,
1071 c_language_arch_info,
1072 default_print_array_index,
1073 default_pass_by_reference,
1075 NULL, /* la_get_symbol_name_cmp */
1076 iterate_over_symbols,
1081 _initialize_c_language (void)
1083 add_language (&c_language_defn);
1084 add_language (&cplus_language_defn);
1085 add_language (&asm_language_defn);
1086 add_language (&minimal_language_defn);