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 gdb_wchar_t wchar = w;
171 if (w == gdb_btowc (quoter) || w == LCST ('\\'))
172 obstack_grow_wstr (output, LCST ("\\"));
173 obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
180 obstack_grow_wstr (output, LCST ("\\a"));
183 obstack_grow_wstr (output, LCST ("\\b"));
186 obstack_grow_wstr (output, LCST ("\\f"));
189 obstack_grow_wstr (output, LCST ("\\n"));
192 obstack_grow_wstr (output, LCST ("\\r"));
195 obstack_grow_wstr (output, LCST ("\\t"));
198 obstack_grow_wstr (output, LCST ("\\v"));
204 for (i = 0; i + width <= orig_len; i += width)
207 ULONGEST value = extract_unsigned_integer (&orig[i], width);
208 sprintf (octal, "\\%lo", (long) value);
209 append_string_as_wide (octal, output);
211 /* If we somehow have extra bytes, print them now. */
215 sprintf (octal, "\\%.3o", orig[i] & 0xff);
216 append_string_as_wide (octal, output);
227 /* Print the character C on STREAM as part of the contents of a literal
228 string whose delimiter is QUOTER. Note that that format for printing
229 characters and strings is language specific. */
232 c_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
234 struct obstack wchar_buf, output;
235 struct cleanup *cleanups;
236 const char *encoding;
238 struct wchar_iterator *iter;
241 classify_type (type, &encoding);
243 buf = alloca (TYPE_LENGTH (type));
244 pack_long (buf, type, c);
246 iter = make_wchar_iterator (buf, TYPE_LENGTH (type), encoding,
248 cleanups = make_cleanup_wchar_iterator (iter);
250 /* This holds the printable form of the wchar_t data. */
251 obstack_init (&wchar_buf);
252 make_cleanup_obstack_free (&wchar_buf);
260 int print_escape = 1;
261 enum wchar_iterate_result result;
263 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
268 /* If all characters are printable, print them. Otherwise,
269 we're going to have to print an escape sequence. We
270 check all characters because we want to print the target
271 bytes in the escape sequence, and we don't know character
276 for (i = 0; i < num_chars; ++i)
277 if (!wchar_printable (chars[i]))
285 for (i = 0; i < num_chars; ++i)
286 print_wchar (chars[i], buf, buflen, TYPE_LENGTH (type),
287 &wchar_buf, quoter, &need_escape);
291 /* This handles the NUM_CHARS == 0 case as well. */
293 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type), &wchar_buf,
294 quoter, &need_escape);
297 /* The output in the host encoding. */
298 obstack_init (&output);
299 make_cleanup_obstack_free (&output);
301 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
302 obstack_base (&wchar_buf),
303 obstack_object_size (&wchar_buf),
304 1, &output, translit_char);
305 obstack_1grow (&output, '\0');
307 fputs_filtered (obstack_base (&output), stream);
309 do_cleanups (cleanups);
313 c_printchar (int c, struct type *type, struct ui_file *stream)
315 enum c_string_type str_type;
316 const char *encoding;
318 str_type = classify_type (type, &encoding);
324 fputc_filtered ('L', stream);
327 fputc_filtered ('u', stream);
330 fputc_filtered ('U', stream);
334 fputc_filtered ('\'', stream);
335 LA_EMIT_CHAR (c, type, stream, '\'');
336 fputc_filtered ('\'', stream);
339 /* Print the character string STRING, printing at most LENGTH characters.
340 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
341 long. Printing stops early if the number hits print_max; repeat counts are
342 printed as appropriate. Print ellipses at the end if we had to stop before
343 printing LENGTH characters, or if FORCE_ELLIPSES. */
346 c_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
347 unsigned int length, int force_ellipses,
348 const struct value_print_options *options)
351 unsigned int things_printed = 0;
354 int width = TYPE_LENGTH (type);
355 struct obstack wchar_buf, output;
356 struct cleanup *cleanup;
357 enum c_string_type str_type;
358 const char *encoding;
359 struct wchar_iterator *iter;
363 /* If the string was not truncated due to `set print elements', and
364 the last byte of it is a null, we don't print that, in traditional C
368 && (extract_unsigned_integer (string + (length - 1) * width, width) == 0))
371 str_type = classify_type (type, &encoding) & ~C_CHAR;
377 fputs_filtered ("L", stream);
380 fputs_filtered ("u", stream);
383 fputs_filtered ("U", stream);
389 fputs_filtered ("\"\"", stream);
395 unsigned long current_char = 1;
396 for (i = 0; current_char; ++i)
399 current_char = extract_unsigned_integer (string + i * width, width);
404 /* Arrange to iterate over the characters, in wchar_t form. */
405 iter = make_wchar_iterator (string, length * width, encoding, width);
406 cleanup = make_cleanup_wchar_iterator (iter);
408 /* WCHAR_BUF is the obstack we use to represent the string in
410 obstack_init (&wchar_buf);
411 make_cleanup_obstack_free (&wchar_buf);
413 while (!finished && things_printed < options->print_max)
416 enum wchar_iterate_result result;
425 obstack_grow_wstr (&wchar_buf, LCST (", "));
429 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
430 /* We only look at repetitions when we were able to convert a
431 single character in isolation. This makes the code simpler
432 and probably does the sensible thing in the majority of
434 while (num_chars == 1)
436 /* Count the number of repetitions. */
437 unsigned int reps = 0;
438 gdb_wchar_t current_char = chars[0];
439 const gdb_byte *orig_buf = buf;
440 int orig_len = buflen;
444 obstack_grow_wstr (&wchar_buf, LCST (", "));
448 while (num_chars == 1 && current_char == chars[0])
450 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
454 /* Emit CURRENT_CHAR according to the repetition count and
456 if (reps > options->repeat_count_threshold)
460 if (options->inspect_it)
461 obstack_grow_wstr (&wchar_buf, LCST ("\\\", "));
463 obstack_grow_wstr (&wchar_buf, LCST ("\", "));
466 obstack_grow_wstr (&wchar_buf, LCST ("'"));
468 print_wchar (current_char, orig_buf, orig_len, width,
469 &wchar_buf, '\'', &need_escape);
470 obstack_grow_wstr (&wchar_buf, LCST ("'"));
472 /* Painful gyrations. */
474 char *s = xstrprintf (_(" <repeats %u times>"), reps);
475 for (j = 0; s[j]; ++j)
477 gdb_wchar_t w = gdb_btowc (s[j]);
478 obstack_grow (&wchar_buf, &w, sizeof (gdb_wchar_t));
482 things_printed += options->repeat_count_threshold;
487 /* Saw the character one or more times, but fewer than
488 the repetition threshold. */
491 if (options->inspect_it)
492 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
494 obstack_grow_wstr (&wchar_buf, LCST ("\""));
501 print_wchar (current_char, orig_buf, orig_len, width,
502 &wchar_buf, '"', &need_escape);
508 /* NUM_CHARS and the other outputs from wchar_iterate are valid
509 here regardless of which branch was taken above. */
519 case wchar_iterate_invalid:
522 if (options->inspect_it)
523 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
525 obstack_grow_wstr (&wchar_buf, LCST ("\""));
529 print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf,
533 case wchar_iterate_incomplete:
536 if (options->inspect_it)
537 obstack_grow_wstr (&wchar_buf, LCST ("\\\","));
539 obstack_grow_wstr (&wchar_buf, LCST ("\","));
542 obstack_grow_wstr (&wchar_buf, LCST (" <incomplete sequence "));
543 print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf,
545 obstack_grow_wstr (&wchar_buf, LCST (">"));
551 /* Terminate the quotes if necessary. */
554 if (options->inspect_it)
555 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
557 obstack_grow_wstr (&wchar_buf, LCST ("\""));
560 if (force_ellipses || !finished)
561 obstack_grow_wstr (&wchar_buf, LCST ("..."));
563 /* OUTPUT is where we collect `char's for printing. */
564 obstack_init (&output);
565 make_cleanup_obstack_free (&output);
567 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
568 obstack_base (&wchar_buf),
569 obstack_object_size (&wchar_buf),
570 1, &output, translit_char);
571 obstack_1grow (&output, '\0');
573 fputs_filtered (obstack_base (&output), stream);
575 do_cleanups (cleanup);
578 /* Obtain a C string from the inferior storing it in a newly allocated
579 buffer in BUFFER, which should be freed by the caller. The string is
580 read until a null character is found. If VALUE is an array with known
581 length, the function will not read past the end of the array. LENGTH
582 will contain the size of the string in bytes (not counting the null
585 Assumes strings are terminated by a null character. The size of a character
586 is determined by the length of the target type of the pointer or array.
587 This means that a null byte present in a multi-byte character will not
588 terminate the string unless the whole character is null.
590 CHARSET is always set to the target charset. */
593 c_get_string (struct value *value, gdb_byte **buffer, int *length,
594 const char **charset)
597 unsigned int fetchlimit;
598 struct type *type = check_typedef (value_type (value));
599 struct type *element_type = TYPE_TARGET_TYPE (type);
601 if (element_type == NULL)
604 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
606 /* If we know the size of the array, we can use it as a limit on the
607 number of characters to be fetched. */
608 if (TYPE_NFIELDS (type) == 1
609 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
611 LONGEST low_bound, high_bound;
613 get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
614 &low_bound, &high_bound);
615 fetchlimit = high_bound - low_bound + 1;
618 fetchlimit = UINT_MAX;
620 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
621 fetchlimit = UINT_MAX;
623 /* We work only with arrays and pointers. */
626 element_type = check_typedef (element_type);
627 if (TYPE_CODE (element_type) != TYPE_CODE_INT
628 && TYPE_CODE (element_type) != TYPE_CODE_CHAR)
629 /* If the elements are not integers or characters, we don't consider it
633 width = TYPE_LENGTH (element_type);
635 /* If the string lives in GDB's memory intead of the inferior's, then we
636 just need to copy it to BUFFER. Also, since such strings are arrays
637 with known size, FETCHLIMIT will hold the size of the array. */
638 if ((VALUE_LVAL (value) == not_lval
639 || VALUE_LVAL (value) == lval_internalvar)
640 && fetchlimit != UINT_MAX)
643 const gdb_byte *contents = value_contents (value);
645 /* Look for a null character. */
646 for (i = 0; i < fetchlimit; i++)
647 if (extract_unsigned_integer (contents + i * width, width) == 0)
650 /* I is now either the number of non-null characters, or FETCHLIMIT. */
652 *buffer = xmalloc (*length);
653 memcpy (*buffer, contents, *length);
658 err = read_string (value_as_address (value), -1, width, fetchlimit,
663 error (_("Error reading string from inferior: %s"),
664 safe_strerror (err));
668 /* If the last character is null, subtract it from LENGTH. */
670 && extract_unsigned_integer (*buffer + *length - width, width) == 0)
673 *charset = target_charset ();
681 type_str = type_to_string (type);
684 make_cleanup (xfree, type_str);
685 error (_("Trying to read string with inappropriate type `%s'."),
689 error (_("Trying to read string with inappropriate type."));
694 /* Evaluating C and C++ expressions. */
696 /* Convert a UCN. The digits of the UCN start at P and extend no
697 farther than LIMIT. DEST_CHARSET is the name of the character set
698 into which the UCN should be converted. The results are written to
699 OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
700 Returns a pointer to just after the final digit of the UCN. */
703 convert_ucn (char *p, char *limit, const char *dest_charset,
704 struct obstack *output, int length)
706 unsigned long result = 0;
710 for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
711 result = (result << 4) + host_hex_value (*p);
713 for (i = 3; i >= 0; --i)
715 data[i] = result & 0xff;
719 convert_between_encodings ("UCS-4BE", dest_charset, data, 4, 4, output,
725 /* Emit a character, VALUE, which was specified numerically, to
726 OUTPUT. TYPE is the target character type. */
729 emit_numeric_character (struct type *type, unsigned long value,
730 struct obstack *output)
734 buffer = alloca (TYPE_LENGTH (type));
735 pack_long (buffer, type, value);
736 obstack_grow (output, buffer, TYPE_LENGTH (type));
739 /* Convert an octal escape sequence. TYPE is the target character
740 type. The digits of the escape sequence begin at P and extend no
741 farther than LIMIT. The result is written to OUTPUT. Returns a
742 pointer to just after the final digit of the escape sequence. */
745 convert_octal (struct type *type, char *p, char *limit, struct obstack *output)
747 unsigned long value = 0;
749 while (p < limit && isdigit (*p) && *p != '8' && *p != '9')
751 value = 8 * value + host_hex_value (*p);
755 emit_numeric_character (type, value, output);
760 /* Convert a hex escape sequence. TYPE is the target character type.
761 The digits of the escape sequence begin at P and extend no farther
762 than LIMIT. The result is written to OUTPUT. Returns a pointer to
763 just after the final digit of the escape sequence. */
766 convert_hex (struct type *type, char *p, char *limit, struct obstack *output)
768 unsigned long value = 0;
770 while (p < limit && isxdigit (*p))
772 value = 16 * value + host_hex_value (*p);
776 emit_numeric_character (type, value, output);
785 error (_("Malformed escape sequence")); \
788 /* Convert an escape sequence to a target format. TYPE is the target
789 character type to use, and DEST_CHARSET is the name of the target
790 character set. The backslash of the escape sequence is at *P, and
791 the escape sequence will not extend past LIMIT. The results are
792 written to OUTPUT. Returns a pointer to just past the final
793 character of the escape sequence. */
796 convert_escape (struct type *type, const char *dest_charset,
797 char *p, char *limit, struct obstack *output)
799 /* Skip the backslash. */
805 obstack_1grow (output, '\\');
812 error (_("\\x used with no following hex digits."));
813 p = convert_hex (type, p, limit, output);
824 p = convert_octal (type, p, limit, output);
830 int length = *p == 'u' ? 4 : 8;
833 error (_("\\u used with no following hex digits"));
834 p = convert_ucn (p, limit, dest_charset, output, length);
841 /* Given a single string from a (C-specific) OP_STRING list, convert
842 it to a target string, handling escape sequences specially. The
843 output is written to OUTPUT. DATA is the input string, which has
844 length LEN. DEST_CHARSET is the name of the target character set,
845 and TYPE is the type of target character to use. */
848 parse_one_string (struct obstack *output, char *data, int len,
849 const char *dest_charset, struct type *type)
858 /* Look for next escape, or the end of the input. */
859 while (p < limit && *p != '\\')
861 /* If we saw a run of characters, convert them all. */
863 convert_between_encodings (host_charset (), dest_charset,
864 data, p - data, 1, output, translit_none);
865 /* If we saw an escape, convert it. */
867 p = convert_escape (type, dest_charset, p, limit, output);
872 /* Expression evaluator for the C language family. Most operations
873 are delegated to evaluate_subexp_standard; see that function for a
874 description of the arguments. */
876 static struct value *
877 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
878 int *pos, enum noside noside)
880 enum exp_opcode op = exp->elts[*pos].opcode;
888 struct obstack output;
889 struct cleanup *cleanup;
890 struct value *result;
891 enum c_string_type dest_type;
892 const char *dest_charset;
894 obstack_init (&output);
895 cleanup = make_cleanup_obstack_free (&output);
898 oplen = longest_to_int (exp->elts[*pos].longconst);
901 limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
903 = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
904 switch (dest_type & ~C_CHAR)
907 type = language_string_char_type (current_language,
911 type = lookup_typename ("wchar_t", NULL, 0);
914 type = lookup_typename ("char16_t", NULL, 0);
917 type = lookup_typename ("char32_t", NULL, 0);
920 internal_error (__FILE__, __LINE__, "unhandled c_string_type");
923 /* Ensure TYPE_LENGTH is valid for TYPE. */
924 check_typedef (type);
926 dest_charset = charset_for_string_type (dest_type);
933 len = longest_to_int (exp->elts[*pos].longconst);
936 if (noside != EVAL_SKIP)
937 parse_one_string (&output, &exp->elts[*pos].string, len,
939 *pos += BYTES_TO_EXP_ELEM (len);
942 /* Skip the trailing length and opcode. */
945 if (noside == EVAL_SKIP)
947 /* Return a dummy value of the appropriate type. */
948 if ((dest_type & C_CHAR) != 0)
949 result = allocate_value (type);
951 result = value_typed_string ("", 0, type);
952 do_cleanups (cleanup);
956 if ((dest_type & C_CHAR) != 0)
960 if (obstack_object_size (&output) != TYPE_LENGTH (type))
961 error (_("Could not convert character constant to target character set"));
962 value = unpack_long (type, obstack_base (&output));
963 result = value_from_longest (type, value);
968 /* Write the terminating character. */
969 for (i = 0; i < TYPE_LENGTH (type); ++i)
970 obstack_1grow (&output, 0);
971 result = value_typed_string (obstack_base (&output),
972 obstack_object_size (&output),
975 do_cleanups (cleanup);
983 return evaluate_subexp_standard (expect_type, exp, pos, noside);
988 /* Table mapping opcodes into strings for printing operators
989 and precedences of the operators. */
991 const struct op_print c_op_print_tab[] =
993 {",", BINOP_COMMA, PREC_COMMA, 0},
994 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
995 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
996 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
997 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
998 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
999 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
1000 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
1001 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
1002 {"<=", BINOP_LEQ, PREC_ORDER, 0},
1003 {">=", BINOP_GEQ, PREC_ORDER, 0},
1004 {">", BINOP_GTR, PREC_ORDER, 0},
1005 {"<", BINOP_LESS, PREC_ORDER, 0},
1006 {">>", BINOP_RSH, PREC_SHIFT, 0},
1007 {"<<", BINOP_LSH, PREC_SHIFT, 0},
1008 {"+", BINOP_ADD, PREC_ADD, 0},
1009 {"-", BINOP_SUB, PREC_ADD, 0},
1010 {"*", BINOP_MUL, PREC_MUL, 0},
1011 {"/", BINOP_DIV, PREC_MUL, 0},
1012 {"%", BINOP_REM, PREC_MUL, 0},
1013 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
1014 {"-", UNOP_NEG, PREC_PREFIX, 0},
1015 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
1016 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
1017 {"*", UNOP_IND, PREC_PREFIX, 0},
1018 {"&", UNOP_ADDR, PREC_PREFIX, 0},
1019 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
1020 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
1021 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
1025 enum c_primitive_types {
1026 c_primitive_type_int,
1027 c_primitive_type_long,
1028 c_primitive_type_short,
1029 c_primitive_type_char,
1030 c_primitive_type_float,
1031 c_primitive_type_double,
1032 c_primitive_type_void,
1033 c_primitive_type_long_long,
1034 c_primitive_type_signed_char,
1035 c_primitive_type_unsigned_char,
1036 c_primitive_type_unsigned_short,
1037 c_primitive_type_unsigned_int,
1038 c_primitive_type_unsigned_long,
1039 c_primitive_type_unsigned_long_long,
1040 c_primitive_type_long_double,
1041 c_primitive_type_complex,
1042 c_primitive_type_double_complex,
1043 c_primitive_type_decfloat,
1044 c_primitive_type_decdouble,
1045 c_primitive_type_declong,
1046 nr_c_primitive_types
1050 c_language_arch_info (struct gdbarch *gdbarch,
1051 struct language_arch_info *lai)
1053 const struct builtin_type *builtin = builtin_type (gdbarch);
1054 lai->string_char_type = builtin->builtin_char;
1055 lai->primitive_type_vector
1056 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
1058 lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
1059 lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
1060 lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
1061 lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
1062 lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
1063 lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
1064 lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
1065 lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
1066 lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
1067 lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
1068 lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
1069 lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
1070 lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
1071 lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
1072 lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
1073 lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
1074 lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
1075 lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
1076 lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
1077 lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
1079 lai->bool_type_default = builtin->builtin_int;
1082 static const struct exp_descriptor exp_descriptor_c =
1084 print_subexp_standard,
1085 operator_length_standard,
1087 dump_subexp_body_standard,
1091 const struct language_defn c_language_defn =
1093 "c", /* Language name */
1104 c_printchar, /* Print a character constant */
1105 c_printstr, /* Function to print string constant */
1106 c_emit_char, /* Print a single char */
1107 c_print_type, /* Print a type using appropriate syntax */
1108 c_print_typedef, /* Print a typedef using appropriate syntax */
1109 c_val_print, /* Print a value using appropriate syntax */
1110 c_value_print, /* Print a top-level value */
1111 NULL, /* Language specific skip_trampoline */
1112 NULL, /* name_of_this */
1113 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1114 basic_lookup_transparent_type,/* lookup_transparent_type */
1115 NULL, /* Language specific symbol demangler */
1116 NULL, /* Language specific class_name_from_physname */
1117 c_op_print_tab, /* expression operators for printing */
1118 1, /* c-style arrays */
1119 0, /* String lower bound */
1120 default_word_break_characters,
1121 default_make_symbol_completion_list,
1122 c_language_arch_info,
1123 default_print_array_index,
1124 default_pass_by_reference,
1129 enum cplus_primitive_types {
1130 cplus_primitive_type_int,
1131 cplus_primitive_type_long,
1132 cplus_primitive_type_short,
1133 cplus_primitive_type_char,
1134 cplus_primitive_type_float,
1135 cplus_primitive_type_double,
1136 cplus_primitive_type_void,
1137 cplus_primitive_type_long_long,
1138 cplus_primitive_type_signed_char,
1139 cplus_primitive_type_unsigned_char,
1140 cplus_primitive_type_unsigned_short,
1141 cplus_primitive_type_unsigned_int,
1142 cplus_primitive_type_unsigned_long,
1143 cplus_primitive_type_unsigned_long_long,
1144 cplus_primitive_type_long_double,
1145 cplus_primitive_type_complex,
1146 cplus_primitive_type_double_complex,
1147 cplus_primitive_type_bool,
1148 cplus_primitive_type_decfloat,
1149 cplus_primitive_type_decdouble,
1150 cplus_primitive_type_declong,
1151 nr_cplus_primitive_types
1155 cplus_language_arch_info (struct gdbarch *gdbarch,
1156 struct language_arch_info *lai)
1158 const struct builtin_type *builtin = builtin_type (gdbarch);
1159 lai->string_char_type = builtin->builtin_char;
1160 lai->primitive_type_vector
1161 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
1163 lai->primitive_type_vector [cplus_primitive_type_int]
1164 = builtin->builtin_int;
1165 lai->primitive_type_vector [cplus_primitive_type_long]
1166 = builtin->builtin_long;
1167 lai->primitive_type_vector [cplus_primitive_type_short]
1168 = builtin->builtin_short;
1169 lai->primitive_type_vector [cplus_primitive_type_char]
1170 = builtin->builtin_char;
1171 lai->primitive_type_vector [cplus_primitive_type_float]
1172 = builtin->builtin_float;
1173 lai->primitive_type_vector [cplus_primitive_type_double]
1174 = builtin->builtin_double;
1175 lai->primitive_type_vector [cplus_primitive_type_void]
1176 = builtin->builtin_void;
1177 lai->primitive_type_vector [cplus_primitive_type_long_long]
1178 = builtin->builtin_long_long;
1179 lai->primitive_type_vector [cplus_primitive_type_signed_char]
1180 = builtin->builtin_signed_char;
1181 lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
1182 = builtin->builtin_unsigned_char;
1183 lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
1184 = builtin->builtin_unsigned_short;
1185 lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
1186 = builtin->builtin_unsigned_int;
1187 lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
1188 = builtin->builtin_unsigned_long;
1189 lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
1190 = builtin->builtin_unsigned_long_long;
1191 lai->primitive_type_vector [cplus_primitive_type_long_double]
1192 = builtin->builtin_long_double;
1193 lai->primitive_type_vector [cplus_primitive_type_complex]
1194 = builtin->builtin_complex;
1195 lai->primitive_type_vector [cplus_primitive_type_double_complex]
1196 = builtin->builtin_double_complex;
1197 lai->primitive_type_vector [cplus_primitive_type_bool]
1198 = builtin->builtin_bool;
1199 lai->primitive_type_vector [cplus_primitive_type_decfloat]
1200 = builtin->builtin_decfloat;
1201 lai->primitive_type_vector [cplus_primitive_type_decdouble]
1202 = builtin->builtin_decdouble;
1203 lai->primitive_type_vector [cplus_primitive_type_declong]
1204 = builtin->builtin_declong;
1206 lai->bool_type_symbol = "bool";
1207 lai->bool_type_default = builtin->builtin_bool;
1210 const struct language_defn cplus_language_defn =
1212 "c++", /* Language name */
1223 c_printchar, /* Print a character constant */
1224 c_printstr, /* Function to print string constant */
1225 c_emit_char, /* Print a single char */
1226 c_print_type, /* Print a type using appropriate syntax */
1227 c_print_typedef, /* Print a typedef using appropriate syntax */
1228 c_val_print, /* Print a value using appropriate syntax */
1229 c_value_print, /* Print a top-level value */
1230 cplus_skip_trampoline, /* Language specific skip_trampoline */
1231 "this", /* name_of_this */
1232 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1233 cp_lookup_transparent_type, /* lookup_transparent_type */
1234 cplus_demangle, /* Language specific symbol demangler */
1235 cp_class_name_from_physname, /* Language specific class_name_from_physname */
1236 c_op_print_tab, /* expression operators for printing */
1237 1, /* c-style arrays */
1238 0, /* String lower bound */
1239 default_word_break_characters,
1240 default_make_symbol_completion_list,
1241 cplus_language_arch_info,
1242 default_print_array_index,
1243 cp_pass_by_reference,
1248 const struct language_defn asm_language_defn =
1250 "asm", /* Language name */
1261 c_printchar, /* Print a character constant */
1262 c_printstr, /* Function to print string constant */
1263 c_emit_char, /* Print a single char */
1264 c_print_type, /* Print a type using appropriate syntax */
1265 c_print_typedef, /* Print a typedef using appropriate syntax */
1266 c_val_print, /* Print a value using appropriate syntax */
1267 c_value_print, /* Print a top-level value */
1268 NULL, /* Language specific skip_trampoline */
1269 NULL, /* name_of_this */
1270 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1271 basic_lookup_transparent_type,/* lookup_transparent_type */
1272 NULL, /* Language specific symbol demangler */
1273 NULL, /* Language specific class_name_from_physname */
1274 c_op_print_tab, /* expression operators for printing */
1275 1, /* c-style arrays */
1276 0, /* String lower bound */
1277 default_word_break_characters,
1278 default_make_symbol_completion_list,
1279 c_language_arch_info, /* FIXME: la_language_arch_info. */
1280 default_print_array_index,
1281 default_pass_by_reference,
1286 /* The following language_defn does not represent a real language.
1287 It just provides a minimal support a-la-C that should allow users
1288 to do some simple operations when debugging applications that use
1289 a language currently not supported by GDB. */
1291 const struct language_defn minimal_language_defn =
1293 "minimal", /* Language name */
1304 c_printchar, /* Print a character constant */
1305 c_printstr, /* Function to print string constant */
1306 c_emit_char, /* Print a single char */
1307 c_print_type, /* Print a type using appropriate syntax */
1308 c_print_typedef, /* Print a typedef using appropriate syntax */
1309 c_val_print, /* Print a value using appropriate syntax */
1310 c_value_print, /* Print a top-level value */
1311 NULL, /* Language specific skip_trampoline */
1312 NULL, /* name_of_this */
1313 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1314 basic_lookup_transparent_type,/* lookup_transparent_type */
1315 NULL, /* Language specific symbol demangler */
1316 NULL, /* Language specific class_name_from_physname */
1317 c_op_print_tab, /* expression operators for printing */
1318 1, /* c-style arrays */
1319 0, /* String lower bound */
1320 default_word_break_characters,
1321 default_make_symbol_completion_list,
1322 c_language_arch_info,
1323 default_print_array_index,
1324 default_pass_by_reference,
1330 _initialize_c_language (void)
1332 add_language (&c_language_defn);
1333 add_language (&cplus_language_defn);
1334 add_language (&asm_language_defn);
1335 add_language (&minimal_language_defn);