1 /* C language support routines for GDB, the GNU debugger.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003,
4 2004, 2005, 2007, 2008, 2009 Free 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"
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)
47 switch (str_type & ~C_CHAR)
50 return target_charset ();
52 return target_wide_charset ();
54 /* FIXME: UCS-2 is not always correct. */
55 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
60 /* FIXME: UCS-4 is not always correct. */
61 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
66 internal_error (__FILE__, __LINE__, "unhandled c_string_type");
69 /* Classify ELTTYPE according to what kind of character it is. Return
70 the enum constant representing the character type. Also set
71 *ENCODING to the name of the character set to use when converting
72 characters of this type to the host character set. */
74 static enum c_string_type
75 classify_type (struct type *elttype, const char **encoding)
77 struct type *saved_type;
78 enum c_string_type result;
80 /* We do one or two passes -- one on ELTTYPE, and then maybe a
81 second one on a typedef target. */
84 char *name = TYPE_NAME (elttype);
86 if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
92 if (!strcmp (name, "wchar_t"))
98 if (!strcmp (name, "char16_t"))
104 if (!strcmp (name, "char32_t"))
110 saved_type = elttype;
111 CHECK_TYPEDEF (elttype);
113 while (elttype != saved_type);
119 *encoding = charset_for_string_type (result);
123 /* Return true if print_wchar can display W without resorting to a
124 numeric escape, false otherwise. */
127 wchar_printable (gdb_wchar_t w)
129 return (gdb_iswprint (w)
130 || w == LCST ('\a') || w == LCST ('\b')
131 || w == LCST ('\f') || w == LCST ('\n')
132 || w == LCST ('\r') || w == LCST ('\t')
133 || w == LCST ('\v'));
136 /* A helper function that converts the contents of STRING to wide
137 characters and then appends them to OUTPUT. */
140 append_string_as_wide (const char *string, struct obstack *output)
142 for (; *string; ++string)
144 gdb_wchar_t w = gdb_btowc (*string);
145 obstack_grow (output, &w, sizeof (gdb_wchar_t));
149 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
150 original (target) bytes representing the character, ORIG_LEN is the
151 number of valid bytes. WIDTH is the number of bytes in a base
152 characters of the type. OUTPUT is an obstack to which wide
153 characters are emitted. QUOTER is a (narrow) character indicating
154 the style of quotes surrounding the character to be printed.
155 NEED_ESCAPE is an in/out flag which is used to track numeric
156 escapes across calls. */
159 print_wchar (gdb_wint_t w, const gdb_byte *orig, int orig_len,
160 int width, struct obstack *output, int quoter,
163 int need_escape = *need_escapep;
165 if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w)
167 && w != LCST ('9'))))
169 if (w == gdb_btowc (quoter) || w == LCST ('\\'))
170 obstack_grow_wstr (output, LCST ("\\"));
171 obstack_grow (output, &w, sizeof (gdb_wchar_t));
178 obstack_grow_wstr (output, LCST ("\\a"));
181 obstack_grow_wstr (output, LCST ("\\b"));
184 obstack_grow_wstr (output, LCST ("\\f"));
187 obstack_grow_wstr (output, LCST ("\\n"));
190 obstack_grow_wstr (output, LCST ("\\r"));
193 obstack_grow_wstr (output, LCST ("\\t"));
196 obstack_grow_wstr (output, LCST ("\\v"));
202 for (i = 0; i + width <= orig_len; i += width)
205 ULONGEST value = extract_unsigned_integer (&orig[i], width);
206 sprintf (octal, "\\%lo", (long) value);
207 append_string_as_wide (octal, output);
209 /* If we somehow have extra bytes, print them now. */
213 sprintf (octal, "\\%.3o", orig[i] & 0xff);
214 append_string_as_wide (octal, output);
225 /* Print the character C on STREAM as part of the contents of a literal
226 string whose delimiter is QUOTER. Note that that format for printing
227 characters and strings is language specific. */
230 c_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
232 struct obstack wchar_buf, output;
233 struct cleanup *cleanups;
234 const char *encoding;
236 struct wchar_iterator *iter;
239 classify_type (type, &encoding);
241 buf = alloca (TYPE_LENGTH (type));
242 pack_long (buf, type, c);
244 iter = make_wchar_iterator (buf, TYPE_LENGTH (type), encoding,
246 cleanups = make_cleanup_wchar_iterator (iter);
248 /* This holds the printable form of the wchar_t data. */
249 obstack_init (&wchar_buf);
250 make_cleanup_obstack_free (&wchar_buf);
258 int print_escape = 1;
259 enum wchar_iterate_result result;
261 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
266 /* If all characters are printable, print them. Otherwise,
267 we're going to have to print an escape sequence. We
268 check all characters because we want to print the target
269 bytes in the escape sequence, and we don't know character
274 for (i = 0; i < num_chars; ++i)
275 if (!wchar_printable (chars[i]))
283 for (i = 0; i < num_chars; ++i)
284 print_wchar (chars[i], buf, buflen, TYPE_LENGTH (type),
285 &wchar_buf, quoter, &need_escape);
289 /* This handles the NUM_CHARS == 0 case as well. */
291 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type), &wchar_buf,
292 quoter, &need_escape);
295 /* The output in the host encoding. */
296 obstack_init (&output);
297 make_cleanup_obstack_free (&output);
299 convert_between_encodings ("wchar_t", host_charset (),
300 obstack_base (&wchar_buf),
301 obstack_object_size (&wchar_buf),
302 1, &output, translit_char);
303 obstack_1grow (&output, '\0');
305 fputs_filtered (obstack_base (&output), stream);
307 do_cleanups (cleanups);
311 c_printchar (int c, struct type *type, struct ui_file *stream)
313 enum c_string_type str_type;
314 const char *encoding;
316 str_type = classify_type (type, &encoding);
322 fputc_filtered ('L', stream);
325 fputc_filtered ('u', stream);
328 fputc_filtered ('U', stream);
332 fputc_filtered ('\'', stream);
333 LA_EMIT_CHAR (c, type, stream, '\'');
334 fputc_filtered ('\'', stream);
337 /* Print the character string STRING, printing at most LENGTH characters.
338 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
339 long. Printing stops early if the number hits print_max; repeat counts are
340 printed as appropriate. Print ellipses at the end if we had to stop before
341 printing LENGTH characters, or if FORCE_ELLIPSES. */
344 c_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
345 unsigned int length, int force_ellipses,
346 const struct value_print_options *options)
349 unsigned int things_printed = 0;
352 int width = TYPE_LENGTH (type);
353 struct obstack wchar_buf, output;
354 struct cleanup *cleanup;
355 enum c_string_type str_type;
356 const char *encoding;
357 struct wchar_iterator *iter;
361 /* If the string was not truncated due to `set print elements', and
362 the last byte of it is a null, we don't print that, in traditional C
366 && (extract_unsigned_integer (string + (length - 1) * width, width) == 0))
369 str_type = classify_type (type, &encoding) & ~C_CHAR;
375 fputs_filtered ("L", stream);
378 fputs_filtered ("u", stream);
381 fputs_filtered ("U", stream);
387 fputs_filtered ("\"\"", stream);
393 unsigned long current_char = 1;
394 for (i = 0; current_char; ++i)
397 current_char = extract_unsigned_integer (string + i * width, width);
402 /* Arrange to iterate over the characters, in wchar_t form. */
403 iter = make_wchar_iterator (string, length * width, encoding, width);
404 cleanup = make_cleanup_wchar_iterator (iter);
406 /* WCHAR_BUF is the obstack we use to represent the string in
408 obstack_init (&wchar_buf);
409 make_cleanup_obstack_free (&wchar_buf);
411 while (!finished && things_printed < options->print_max)
414 enum wchar_iterate_result result;
423 obstack_grow_wstr (&wchar_buf, LCST (", "));
427 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
428 /* We only look at repetitions when we were able to convert a
429 single character in isolation. This makes the code simpler
430 and probably does the sensible thing in the majority of
432 while (num_chars == 1)
434 /* Count the number of repetitions. */
435 unsigned int reps = 0;
436 gdb_wchar_t current_char = chars[0];
437 const gdb_byte *orig_buf = buf;
438 int orig_len = buflen;
442 obstack_grow_wstr (&wchar_buf, LCST (", "));
446 while (num_chars == 1 && current_char == chars[0])
448 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
452 /* Emit CURRENT_CHAR according to the repetition count and
454 if (reps > options->repeat_count_threshold)
458 if (options->inspect_it)
459 obstack_grow_wstr (&wchar_buf, LCST ("\\\", "));
461 obstack_grow_wstr (&wchar_buf, LCST ("\", "));
464 obstack_grow_wstr (&wchar_buf, LCST ("'"));
466 print_wchar (current_char, orig_buf, orig_len, width,
467 &wchar_buf, '\'', &need_escape);
468 obstack_grow_wstr (&wchar_buf, LCST ("'"));
470 /* Painful gyrations. */
472 char *s = xstrprintf (_(" <repeats %u times>"), reps);
473 for (j = 0; s[j]; ++j)
475 gdb_wchar_t w = gdb_btowc (s[j]);
476 obstack_grow (&wchar_buf, &w, sizeof (gdb_wchar_t));
480 things_printed += options->repeat_count_threshold;
485 /* Saw the character one or more times, but fewer than
486 the repetition threshold. */
489 if (options->inspect_it)
490 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
492 obstack_grow_wstr (&wchar_buf, LCST ("\""));
499 print_wchar (current_char, orig_buf, orig_len, width,
500 &wchar_buf, '"', &need_escape);
506 /* NUM_CHARS and the other outputs from wchar_iterate are valid
507 here regardless of which branch was taken above. */
517 case wchar_iterate_invalid:
520 if (options->inspect_it)
521 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
523 obstack_grow_wstr (&wchar_buf, LCST ("\""));
527 print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf,
531 case wchar_iterate_incomplete:
534 if (options->inspect_it)
535 obstack_grow_wstr (&wchar_buf, LCST ("\\\","));
537 obstack_grow_wstr (&wchar_buf, LCST ("\","));
540 obstack_grow_wstr (&wchar_buf, LCST (" <incomplete sequence "));
541 print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf,
543 obstack_grow_wstr (&wchar_buf, LCST (">"));
549 /* Terminate the quotes if necessary. */
552 if (options->inspect_it)
553 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
555 obstack_grow_wstr (&wchar_buf, LCST ("\""));
558 if (force_ellipses || !finished)
559 obstack_grow_wstr (&wchar_buf, LCST ("..."));
561 /* OUTPUT is where we collect `char's for printing. */
562 obstack_init (&output);
563 make_cleanup_obstack_free (&output);
565 convert_between_encodings ("wchar_t", host_charset (),
566 obstack_base (&wchar_buf),
567 obstack_object_size (&wchar_buf),
568 1, &output, translit_char);
569 obstack_1grow (&output, '\0');
571 fputs_filtered (obstack_base (&output), stream);
573 do_cleanups (cleanup);
576 /* Obtain a C string from the inferior storing it in a newly allocated
577 buffer in BUFFER, which should be freed by the caller. The string is
578 read until a null character is found. If VALUE is an array with known
579 length, the function will not read past the end of the array. LENGTH
580 will contain the size of the string in bytes (not counting the null
583 Assumes strings are terminated by a null character. The size of a character
584 is determined by the length of the target type of the pointer or array.
585 This means that a null byte present in a multi-byte character will not
586 terminate the string unless the whole character is null.
588 CHARSET is always set to the target charset. */
591 c_get_string (struct value *value, gdb_byte **buffer, int *length,
592 const char **charset)
595 unsigned int fetchlimit;
596 struct type *type = check_typedef (value_type (value));
597 struct type *element_type = TYPE_TARGET_TYPE (type);
599 if (element_type == NULL)
602 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
604 /* If we know the size of the array, we can use it as a limit on the
605 number of characters to be fetched. */
606 if (TYPE_NFIELDS (type) == 1
607 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
609 LONGEST low_bound, high_bound;
611 get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
612 &low_bound, &high_bound);
613 fetchlimit = high_bound - low_bound + 1;
616 fetchlimit = UINT_MAX;
618 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
619 fetchlimit = UINT_MAX;
621 /* We work only with arrays and pointers. */
624 element_type = check_typedef (element_type);
625 if (TYPE_CODE (element_type) != TYPE_CODE_INT
626 && TYPE_CODE (element_type) != TYPE_CODE_CHAR)
627 /* If the elements are not integers or characters, we don't consider it
631 width = TYPE_LENGTH (element_type);
633 /* If the string lives in GDB's memory intead of the inferior's, then we
634 just need to copy it to BUFFER. Also, since such strings are arrays
635 with known size, FETCHLIMIT will hold the size of the array. */
636 if ((VALUE_LVAL (value) == not_lval
637 || VALUE_LVAL (value) == lval_internalvar)
638 && fetchlimit != UINT_MAX)
641 const gdb_byte *contents = value_contents (value);
643 /* Look for a null character. */
644 for (i = 0; i < fetchlimit; i++)
645 if (extract_unsigned_integer (contents + i * width, width) == 0)
648 /* I is now either the number of non-null characters, or FETCHLIMIT. */
650 *buffer = xmalloc (*length);
651 memcpy (*buffer, contents, *length);
656 err = read_string (value_as_address (value), -1, width, fetchlimit,
661 error (_("Error reading string from inferior: %s"),
662 safe_strerror (err));
666 /* If the last character is null, subtract it from LENGTH. */
668 && extract_unsigned_integer (*buffer + *length - width, width) == 0)
671 *charset = target_charset ();
679 type_str = type_to_string (type);
682 make_cleanup (xfree, type_str);
683 error (_("Trying to read string with inappropriate type `%s'."),
687 error (_("Trying to read string with inappropriate type."));
692 /* Evaluating C and C++ expressions. */
694 /* Convert a UCN. The digits of the UCN start at P and extend no
695 farther than LIMIT. DEST_CHARSET is the name of the character set
696 into which the UCN should be converted. The results are written to
697 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
698 Returns a pointer to just after the final digit of the UCN. */
701 convert_ucn (char *p, char *limit, const char *dest_charset,
702 struct obstack *output, int length)
704 unsigned long result = 0;
708 for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
709 result = (result << 4) + host_hex_value (*p);
711 for (i = 3; i >= 0; --i)
713 data[i] = result & 0xff;
717 convert_between_encodings ("UCS-4BE", dest_charset, data, 4, 4, output,
723 /* Emit a character, VALUE, which was specified numerically, to
724 OUTPUT. TYPE is the target character type. */
727 emit_numeric_character (struct type *type, unsigned long value,
728 struct obstack *output)
732 buffer = alloca (TYPE_LENGTH (type));
733 pack_long (buffer, type, value);
734 obstack_grow (output, buffer, TYPE_LENGTH (type));
737 /* Convert an octal escape sequence. TYPE is the target character
738 type. The digits of the escape sequence begin at P and extend no
739 farther than LIMIT. The result is written to OUTPUT. Returns a
740 pointer to just after the final digit of the escape sequence. */
743 convert_octal (struct type *type, char *p, char *limit, struct obstack *output)
745 unsigned long value = 0;
747 while (p < limit && isdigit (*p) && *p != '8' && *p != '9')
749 value = 8 * value + host_hex_value (*p);
753 emit_numeric_character (type, value, output);
758 /* Convert a hex escape sequence. TYPE is the target character type.
759 The digits of the escape sequence begin at P and extend no farther
760 than LIMIT. The result is written to OUTPUT. Returns a pointer to
761 just after the final digit of the escape sequence. */
764 convert_hex (struct type *type, char *p, char *limit, struct obstack *output)
766 unsigned long value = 0;
768 while (p < limit && isxdigit (*p))
770 value = 16 * value + host_hex_value (*p);
774 emit_numeric_character (type, value, output);
783 error (_("Malformed escape sequence")); \
786 /* Convert an escape sequence to a target format. TYPE is the target
787 character type to use, and DEST_CHARSET is the name of the target
788 character set. The backslash of the escape sequence is at *P, and
789 the escape sequence will not extend past LIMIT. The results are
790 written to OUTPUT. Returns a pointer to just past the final
791 character of the escape sequence. */
794 convert_escape (struct type *type, const char *dest_charset,
795 char *p, char *limit, struct obstack *output)
797 /* Skip the backslash. */
803 obstack_1grow (output, '\\');
810 error (_("\\x used with no following hex digits."));
811 p = convert_hex (type, p, limit, output);
822 p = convert_octal (type, p, limit, output);
828 int length = *p == 'u' ? 4 : 8;
831 error (_("\\u used with no following hex digits"));
832 p = convert_ucn (p, limit, dest_charset, output, length);
839 /* Given a single string from a (C-specific) OP_STRING list, convert
840 it to a target string, handling escape sequences specially. The
841 output is written to OUTPUT. DATA is the input string, which has
842 length LEN. DEST_CHARSET is the name of the target character set,
843 and TYPE is the type of target character to use. */
846 parse_one_string (struct obstack *output, char *data, int len,
847 const char *dest_charset, struct type *type)
856 /* Look for next escape, or the end of the input. */
857 while (p < limit && *p != '\\')
859 /* If we saw a run of characters, convert them all. */
861 convert_between_encodings (host_charset (), dest_charset,
862 data, p - data, 1, output, translit_none);
863 /* If we saw an escape, convert it. */
865 p = convert_escape (type, dest_charset, p, limit, output);
870 /* Expression evaluator for the C language family. Most operations
871 are delegated to evaluate_subexp_standard; see that function for a
872 description of the arguments. */
874 static struct value *
875 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
876 int *pos, enum noside noside)
878 enum exp_opcode op = exp->elts[*pos].opcode;
886 struct obstack output;
887 struct cleanup *cleanup;
888 struct value *result;
889 enum c_string_type dest_type;
890 const char *dest_charset;
892 obstack_init (&output);
893 cleanup = make_cleanup_obstack_free (&output);
896 oplen = longest_to_int (exp->elts[*pos].longconst);
899 limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
901 = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
902 switch (dest_type & ~C_CHAR)
905 type = language_string_char_type (current_language,
909 type = lookup_typename ("wchar_t", NULL, 0);
912 type = lookup_typename ("char16_t", NULL, 0);
915 type = lookup_typename ("char32_t", NULL, 0);
918 internal_error (__FILE__, __LINE__, "unhandled c_string_type");
920 dest_charset = charset_for_string_type (dest_type);
927 len = longest_to_int (exp->elts[*pos].longconst);
930 if (noside != EVAL_SKIP)
931 parse_one_string (&output, &exp->elts[*pos].string, len,
933 *pos += BYTES_TO_EXP_ELEM (len);
936 /* Skip the trailing length and opcode. */
939 if (noside == EVAL_SKIP)
942 if ((dest_type & C_CHAR) != 0)
946 if (obstack_object_size (&output) != TYPE_LENGTH (type))
947 error (_("Could not convert character constant to target character set"));
948 value = unpack_long (type, obstack_base (&output));
949 result = value_from_longest (type, value);
954 /* Write the terminating character. */
955 for (i = 0; i < TYPE_LENGTH (type); ++i)
956 obstack_1grow (&output, 0);
957 result = value_typed_string (obstack_base (&output),
958 obstack_object_size (&output),
961 do_cleanups (cleanup);
969 return evaluate_subexp_standard (expect_type, exp, pos, noside);
974 /* Table mapping opcodes into strings for printing operators
975 and precedences of the operators. */
977 const struct op_print c_op_print_tab[] =
979 {",", BINOP_COMMA, PREC_COMMA, 0},
980 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
981 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
982 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
983 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
984 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
985 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
986 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
987 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
988 {"<=", BINOP_LEQ, PREC_ORDER, 0},
989 {">=", BINOP_GEQ, PREC_ORDER, 0},
990 {">", BINOP_GTR, PREC_ORDER, 0},
991 {"<", BINOP_LESS, PREC_ORDER, 0},
992 {">>", BINOP_RSH, PREC_SHIFT, 0},
993 {"<<", BINOP_LSH, PREC_SHIFT, 0},
994 {"+", BINOP_ADD, PREC_ADD, 0},
995 {"-", BINOP_SUB, PREC_ADD, 0},
996 {"*", BINOP_MUL, PREC_MUL, 0},
997 {"/", BINOP_DIV, PREC_MUL, 0},
998 {"%", BINOP_REM, PREC_MUL, 0},
999 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
1000 {"-", UNOP_NEG, PREC_PREFIX, 0},
1001 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
1002 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
1003 {"*", UNOP_IND, PREC_PREFIX, 0},
1004 {"&", UNOP_ADDR, PREC_PREFIX, 0},
1005 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
1006 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
1007 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
1011 enum c_primitive_types {
1012 c_primitive_type_int,
1013 c_primitive_type_long,
1014 c_primitive_type_short,
1015 c_primitive_type_char,
1016 c_primitive_type_float,
1017 c_primitive_type_double,
1018 c_primitive_type_void,
1019 c_primitive_type_long_long,
1020 c_primitive_type_signed_char,
1021 c_primitive_type_unsigned_char,
1022 c_primitive_type_unsigned_short,
1023 c_primitive_type_unsigned_int,
1024 c_primitive_type_unsigned_long,
1025 c_primitive_type_unsigned_long_long,
1026 c_primitive_type_long_double,
1027 c_primitive_type_complex,
1028 c_primitive_type_double_complex,
1029 c_primitive_type_decfloat,
1030 c_primitive_type_decdouble,
1031 c_primitive_type_declong,
1032 nr_c_primitive_types
1036 c_language_arch_info (struct gdbarch *gdbarch,
1037 struct language_arch_info *lai)
1039 const struct builtin_type *builtin = builtin_type (gdbarch);
1040 lai->string_char_type = builtin->builtin_char;
1041 lai->primitive_type_vector
1042 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
1044 lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
1045 lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
1046 lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
1047 lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
1048 lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
1049 lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
1050 lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
1051 lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
1052 lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
1053 lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
1054 lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
1055 lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
1056 lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
1057 lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
1058 lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
1059 lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
1060 lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
1061 lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
1062 lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
1063 lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
1065 lai->bool_type_default = builtin->builtin_int;
1068 static const struct exp_descriptor exp_descriptor_c =
1070 print_subexp_standard,
1071 operator_length_standard,
1073 dump_subexp_body_standard,
1077 const struct language_defn c_language_defn =
1079 "c", /* Language name */
1090 c_printchar, /* Print a character constant */
1091 c_printstr, /* Function to print string constant */
1092 c_emit_char, /* Print a single char */
1093 c_print_type, /* Print a type using appropriate syntax */
1094 c_print_typedef, /* Print a typedef using appropriate syntax */
1095 c_val_print, /* Print a value using appropriate syntax */
1096 c_value_print, /* Print a top-level value */
1097 NULL, /* Language specific skip_trampoline */
1098 NULL, /* name_of_this */
1099 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1100 basic_lookup_transparent_type,/* lookup_transparent_type */
1101 NULL, /* Language specific symbol demangler */
1102 NULL, /* Language specific class_name_from_physname */
1103 c_op_print_tab, /* expression operators for printing */
1104 1, /* c-style arrays */
1105 0, /* String lower bound */
1106 default_word_break_characters,
1107 default_make_symbol_completion_list,
1108 c_language_arch_info,
1109 default_print_array_index,
1110 default_pass_by_reference,
1115 enum cplus_primitive_types {
1116 cplus_primitive_type_int,
1117 cplus_primitive_type_long,
1118 cplus_primitive_type_short,
1119 cplus_primitive_type_char,
1120 cplus_primitive_type_float,
1121 cplus_primitive_type_double,
1122 cplus_primitive_type_void,
1123 cplus_primitive_type_long_long,
1124 cplus_primitive_type_signed_char,
1125 cplus_primitive_type_unsigned_char,
1126 cplus_primitive_type_unsigned_short,
1127 cplus_primitive_type_unsigned_int,
1128 cplus_primitive_type_unsigned_long,
1129 cplus_primitive_type_unsigned_long_long,
1130 cplus_primitive_type_long_double,
1131 cplus_primitive_type_complex,
1132 cplus_primitive_type_double_complex,
1133 cplus_primitive_type_bool,
1134 cplus_primitive_type_decfloat,
1135 cplus_primitive_type_decdouble,
1136 cplus_primitive_type_declong,
1137 nr_cplus_primitive_types
1141 cplus_language_arch_info (struct gdbarch *gdbarch,
1142 struct language_arch_info *lai)
1144 const struct builtin_type *builtin = builtin_type (gdbarch);
1145 lai->string_char_type = builtin->builtin_char;
1146 lai->primitive_type_vector
1147 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
1149 lai->primitive_type_vector [cplus_primitive_type_int]
1150 = builtin->builtin_int;
1151 lai->primitive_type_vector [cplus_primitive_type_long]
1152 = builtin->builtin_long;
1153 lai->primitive_type_vector [cplus_primitive_type_short]
1154 = builtin->builtin_short;
1155 lai->primitive_type_vector [cplus_primitive_type_char]
1156 = builtin->builtin_char;
1157 lai->primitive_type_vector [cplus_primitive_type_float]
1158 = builtin->builtin_float;
1159 lai->primitive_type_vector [cplus_primitive_type_double]
1160 = builtin->builtin_double;
1161 lai->primitive_type_vector [cplus_primitive_type_void]
1162 = builtin->builtin_void;
1163 lai->primitive_type_vector [cplus_primitive_type_long_long]
1164 = builtin->builtin_long_long;
1165 lai->primitive_type_vector [cplus_primitive_type_signed_char]
1166 = builtin->builtin_signed_char;
1167 lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
1168 = builtin->builtin_unsigned_char;
1169 lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
1170 = builtin->builtin_unsigned_short;
1171 lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
1172 = builtin->builtin_unsigned_int;
1173 lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
1174 = builtin->builtin_unsigned_long;
1175 lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
1176 = builtin->builtin_unsigned_long_long;
1177 lai->primitive_type_vector [cplus_primitive_type_long_double]
1178 = builtin->builtin_long_double;
1179 lai->primitive_type_vector [cplus_primitive_type_complex]
1180 = builtin->builtin_complex;
1181 lai->primitive_type_vector [cplus_primitive_type_double_complex]
1182 = builtin->builtin_double_complex;
1183 lai->primitive_type_vector [cplus_primitive_type_bool]
1184 = builtin->builtin_bool;
1185 lai->primitive_type_vector [cplus_primitive_type_decfloat]
1186 = builtin->builtin_decfloat;
1187 lai->primitive_type_vector [cplus_primitive_type_decdouble]
1188 = builtin->builtin_decdouble;
1189 lai->primitive_type_vector [cplus_primitive_type_declong]
1190 = builtin->builtin_declong;
1192 lai->bool_type_symbol = "bool";
1193 lai->bool_type_default = builtin->builtin_bool;
1196 const struct language_defn cplus_language_defn =
1198 "c++", /* Language name */
1209 c_printchar, /* Print a character constant */
1210 c_printstr, /* Function to print string constant */
1211 c_emit_char, /* Print a single char */
1212 c_print_type, /* Print a type using appropriate syntax */
1213 c_print_typedef, /* Print a typedef using appropriate syntax */
1214 c_val_print, /* Print a value using appropriate syntax */
1215 c_value_print, /* Print a top-level value */
1216 cplus_skip_trampoline, /* Language specific skip_trampoline */
1217 "this", /* name_of_this */
1218 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1219 cp_lookup_transparent_type, /* lookup_transparent_type */
1220 cplus_demangle, /* Language specific symbol demangler */
1221 cp_class_name_from_physname, /* Language specific class_name_from_physname */
1222 c_op_print_tab, /* expression operators for printing */
1223 1, /* c-style arrays */
1224 0, /* String lower bound */
1225 default_word_break_characters,
1226 default_make_symbol_completion_list,
1227 cplus_language_arch_info,
1228 default_print_array_index,
1229 cp_pass_by_reference,
1234 const struct language_defn asm_language_defn =
1236 "asm", /* Language name */
1247 c_printchar, /* Print a character constant */
1248 c_printstr, /* Function to print string constant */
1249 c_emit_char, /* Print a single char */
1250 c_print_type, /* Print a type using appropriate syntax */
1251 c_print_typedef, /* Print a typedef using appropriate syntax */
1252 c_val_print, /* Print a value using appropriate syntax */
1253 c_value_print, /* Print a top-level value */
1254 NULL, /* Language specific skip_trampoline */
1255 NULL, /* name_of_this */
1256 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1257 basic_lookup_transparent_type,/* lookup_transparent_type */
1258 NULL, /* Language specific symbol demangler */
1259 NULL, /* Language specific class_name_from_physname */
1260 c_op_print_tab, /* expression operators for printing */
1261 1, /* c-style arrays */
1262 0, /* String lower bound */
1263 default_word_break_characters,
1264 default_make_symbol_completion_list,
1265 c_language_arch_info, /* FIXME: la_language_arch_info. */
1266 default_print_array_index,
1267 default_pass_by_reference,
1272 /* The following language_defn does not represent a real language.
1273 It just provides a minimal support a-la-C that should allow users
1274 to do some simple operations when debugging applications that use
1275 a language currently not supported by GDB. */
1277 const struct language_defn minimal_language_defn =
1279 "minimal", /* Language name */
1290 c_printchar, /* Print a character constant */
1291 c_printstr, /* Function to print string constant */
1292 c_emit_char, /* Print a single char */
1293 c_print_type, /* Print a type using appropriate syntax */
1294 c_print_typedef, /* Print a typedef using appropriate syntax */
1295 c_val_print, /* Print a value using appropriate syntax */
1296 c_value_print, /* Print a top-level value */
1297 NULL, /* Language specific skip_trampoline */
1298 NULL, /* name_of_this */
1299 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1300 basic_lookup_transparent_type,/* lookup_transparent_type */
1301 NULL, /* Language specific symbol demangler */
1302 NULL, /* Language specific class_name_from_physname */
1303 c_op_print_tab, /* expression operators for printing */
1304 1, /* c-style arrays */
1305 0, /* String lower bound */
1306 default_word_break_characters,
1307 default_make_symbol_completion_list,
1308 c_language_arch_info,
1309 default_print_array_index,
1310 default_pass_by_reference,
1316 _initialize_c_language (void)
1318 add_language (&c_language_defn);
1319 add_language (&cplus_language_defn);
1320 add_language (&asm_language_defn);
1321 add_language (&minimal_language_defn);