Commit | Line | Data |
---|---|---|
c906108c | 1 | /* C language support routines for GDB, the GNU debugger. |
ce27fb25 | 2 | |
6aba47ca | 3 | Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003, |
0fb0cc75 | 4 | 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. |
c906108c | 5 | |
c5aa993b | 6 | This file is part of GDB. |
c906108c | 7 | |
c5aa993b JM |
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 | |
a9762ec7 | 10 | the Free Software Foundation; either version 3 of the License, or |
c5aa993b | 11 | (at your option) any later version. |
c906108c | 12 | |
c5aa993b JM |
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. | |
c906108c | 17 | |
c5aa993b | 18 | You should have received a copy of the GNU General Public License |
a9762ec7 | 19 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
c906108c SS |
20 | |
21 | #include "defs.h" | |
22 | #include "symtab.h" | |
23 | #include "gdbtypes.h" | |
24 | #include "expression.h" | |
25 | #include "parser-defs.h" | |
26 | #include "language.h" | |
27 | #include "c-lang.h" | |
745b8ca0 | 28 | #include "valprint.h" |
84f0252a JB |
29 | #include "macroscope.h" |
30 | #include "gdb_assert.h" | |
234b45d4 | 31 | #include "charset.h" |
a15ef5f5 | 32 | #include "gdb_string.h" |
9a3d7dfd | 33 | #include "demangle.h" |
b18be20d | 34 | #include "cp-abi.h" |
1fcb5155 | 35 | #include "cp-support.h" |
6c7a06a3 TT |
36 | #include "gdb_obstack.h" |
37 | #include <ctype.h> | |
c906108c | 38 | |
a14ed312 | 39 | extern void _initialize_c_language (void); |
6c7a06a3 TT |
40 | |
41 | /* Given a C string type, STR_TYPE, return the corresponding target | |
42 | character set name. */ | |
43 | ||
44 | static const char * | |
45 | charset_for_string_type (enum c_string_type str_type) | |
46 | { | |
47 | switch (str_type & ~C_CHAR) | |
48 | { | |
49 | case C_STRING: | |
50 | return target_charset (); | |
51 | case C_WIDE_STRING: | |
52 | return target_wide_charset (); | |
53 | case C_STRING_16: | |
54 | /* FIXME: UCS-2 is not always correct. */ | |
55 | if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) | |
56 | return "UCS-2BE"; | |
57 | else | |
58 | return "UCS-2LE"; | |
59 | case C_STRING_32: | |
60 | /* FIXME: UCS-4 is not always correct. */ | |
61 | if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) | |
62 | return "UCS-4BE"; | |
63 | else | |
64 | return "UCS-4LE"; | |
65 | } | |
66 | internal_error (__FILE__, __LINE__, "unhandled c_string_type"); | |
67 | } | |
68 | ||
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. */ | |
73 | ||
74 | static enum c_string_type | |
75 | classify_type (struct type *elttype, const char **encoding) | |
76 | { | |
77 | struct type *saved_type; | |
78 | enum c_string_type result; | |
79 | ||
80 | /* We do one or two passes -- one on ELTTYPE, and then maybe a | |
81 | second one on a typedef target. */ | |
82 | do | |
83 | { | |
84 | char *name = TYPE_NAME (elttype); | |
85 | ||
86 | if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name) | |
87 | { | |
88 | result = C_CHAR; | |
89 | goto done; | |
90 | } | |
91 | ||
92 | if (!strcmp (name, "wchar_t")) | |
93 | { | |
94 | result = C_WIDE_CHAR; | |
95 | goto done; | |
96 | } | |
97 | ||
98 | if (!strcmp (name, "char16_t")) | |
99 | { | |
100 | result = C_CHAR_16; | |
101 | goto done; | |
102 | } | |
103 | ||
104 | if (!strcmp (name, "char32_t")) | |
105 | { | |
106 | result = C_CHAR_32; | |
107 | goto done; | |
108 | } | |
109 | ||
110 | saved_type = elttype; | |
111 | CHECK_TYPEDEF (elttype); | |
112 | } | |
113 | while (elttype != saved_type); | |
114 | ||
115 | /* Punt. */ | |
116 | result = C_CHAR; | |
117 | ||
118 | done: | |
119 | *encoding = charset_for_string_type (result); | |
120 | return result; | |
121 | } | |
122 | ||
123 | /* Return true if print_wchar can display W without resorting to a | |
124 | numeric escape, false otherwise. */ | |
125 | ||
126 | static int | |
127 | wchar_printable (gdb_wchar_t w) | |
128 | { | |
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')); | |
134 | } | |
135 | ||
136 | /* A helper function that converts the contents of STRING to wide | |
137 | characters and then appends them to OUTPUT. */ | |
138 | ||
139 | static void | |
140 | append_string_as_wide (const char *string, struct obstack *output) | |
141 | { | |
142 | for (; *string; ++string) | |
143 | { | |
144 | gdb_wchar_t w = gdb_btowc (*string); | |
145 | obstack_grow (output, &w, sizeof (gdb_wchar_t)); | |
146 | } | |
147 | } | |
148 | ||
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. */ | |
157 | ||
158 | static void | |
159 | print_wchar (gdb_wint_t w, const gdb_byte *orig, int orig_len, | |
160 | int width, struct obstack *output, int quoter, | |
161 | int *need_escapep) | |
162 | { | |
163 | int need_escape = *need_escapep; | |
164 | *need_escapep = 0; | |
165 | if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w) | |
166 | && w != LCST ('8') | |
167 | && w != LCST ('9')))) | |
168 | { | |
169 | if (w == gdb_btowc (quoter) || w == LCST ('\\')) | |
170 | obstack_grow_wstr (output, LCST ("\\")); | |
171 | obstack_grow (output, &w, sizeof (gdb_wchar_t)); | |
172 | } | |
173 | else | |
174 | { | |
175 | switch (w) | |
176 | { | |
177 | case LCST ('\a'): | |
178 | obstack_grow_wstr (output, LCST ("\\a")); | |
179 | break; | |
180 | case LCST ('\b'): | |
181 | obstack_grow_wstr (output, LCST ("\\b")); | |
182 | break; | |
183 | case LCST ('\f'): | |
184 | obstack_grow_wstr (output, LCST ("\\f")); | |
185 | break; | |
186 | case LCST ('\n'): | |
187 | obstack_grow_wstr (output, LCST ("\\n")); | |
188 | break; | |
189 | case LCST ('\r'): | |
190 | obstack_grow_wstr (output, LCST ("\\r")); | |
191 | break; | |
192 | case LCST ('\t'): | |
193 | obstack_grow_wstr (output, LCST ("\\t")); | |
194 | break; | |
195 | case LCST ('\v'): | |
196 | obstack_grow_wstr (output, LCST ("\\v")); | |
197 | break; | |
198 | default: | |
199 | { | |
200 | int i; | |
201 | ||
202 | for (i = 0; i + width <= orig_len; i += width) | |
203 | { | |
204 | char octal[30]; | |
205 | ULONGEST value = extract_unsigned_integer (&orig[i], width); | |
206 | sprintf (octal, "\\%lo", (long) value); | |
207 | append_string_as_wide (octal, output); | |
208 | } | |
209 | /* If we somehow have extra bytes, print them now. */ | |
210 | while (i < orig_len) | |
211 | { | |
212 | char octal[5]; | |
213 | sprintf (octal, "\\%.3o", orig[i] & 0xff); | |
214 | append_string_as_wide (octal, output); | |
215 | ++i; | |
216 | } | |
217 | ||
218 | *need_escapep = 1; | |
219 | } | |
220 | break; | |
221 | } | |
222 | } | |
223 | } | |
c906108c SS |
224 | |
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. */ | |
228 | ||
229 | static void | |
6c7a06a3 | 230 | c_emit_char (int c, struct type *type, struct ui_file *stream, int quoter) |
c906108c | 231 | { |
6c7a06a3 TT |
232 | struct obstack wchar_buf, output; |
233 | struct cleanup *cleanups; | |
234 | const char *encoding; | |
235 | gdb_byte *buf; | |
236 | struct wchar_iterator *iter; | |
237 | int need_escape = 0; | |
234b45d4 | 238 | |
6c7a06a3 | 239 | classify_type (type, &encoding); |
c906108c | 240 | |
6c7a06a3 TT |
241 | buf = alloca (TYPE_LENGTH (type)); |
242 | pack_long (buf, type, c); | |
243 | ||
244 | iter = make_wchar_iterator (buf, TYPE_LENGTH (type), encoding, | |
245 | TYPE_LENGTH (type)); | |
246 | cleanups = make_cleanup_wchar_iterator (iter); | |
247 | ||
248 | /* This holds the printable form of the wchar_t data. */ | |
249 | obstack_init (&wchar_buf); | |
250 | make_cleanup_obstack_free (&wchar_buf); | |
251 | ||
252 | while (1) | |
c906108c | 253 | { |
6c7a06a3 TT |
254 | int num_chars; |
255 | gdb_wchar_t *chars; | |
256 | const gdb_byte *buf; | |
257 | size_t buflen; | |
258 | int print_escape = 1; | |
259 | enum wchar_iterate_result result; | |
260 | ||
261 | num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen); | |
262 | if (num_chars < 0) | |
263 | break; | |
264 | if (num_chars > 0) | |
265 | { | |
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 | |
270 | boundaries there. */ | |
271 | int i; | |
272 | ||
273 | print_escape = 0; | |
274 | for (i = 0; i < num_chars; ++i) | |
275 | if (!wchar_printable (chars[i])) | |
276 | { | |
277 | print_escape = 1; | |
278 | break; | |
279 | } | |
280 | ||
281 | if (!print_escape) | |
282 | { | |
283 | for (i = 0; i < num_chars; ++i) | |
284 | print_wchar (chars[i], buf, buflen, TYPE_LENGTH (type), | |
285 | &wchar_buf, quoter, &need_escape); | |
286 | } | |
287 | } | |
288 | ||
289 | /* This handles the NUM_CHARS == 0 case as well. */ | |
290 | if (print_escape) | |
291 | print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type), &wchar_buf, | |
292 | quoter, &need_escape); | |
c906108c | 293 | } |
6c7a06a3 TT |
294 | |
295 | /* The output in the host encoding. */ | |
296 | obstack_init (&output); | |
297 | make_cleanup_obstack_free (&output); | |
298 | ||
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'); | |
304 | ||
305 | fputs_filtered (obstack_base (&output), stream); | |
306 | ||
307 | do_cleanups (cleanups); | |
c906108c SS |
308 | } |
309 | ||
310 | void | |
6c7a06a3 | 311 | c_printchar (int c, struct type *type, struct ui_file *stream) |
c906108c | 312 | { |
6c7a06a3 TT |
313 | enum c_string_type str_type; |
314 | const char *encoding; | |
315 | ||
316 | str_type = classify_type (type, &encoding); | |
317 | switch (str_type) | |
318 | { | |
319 | case C_CHAR: | |
320 | break; | |
321 | case C_WIDE_CHAR: | |
322 | fputc_filtered ('L', stream); | |
323 | break; | |
324 | case C_CHAR_16: | |
325 | fputc_filtered ('u', stream); | |
326 | break; | |
327 | case C_CHAR_32: | |
328 | fputc_filtered ('U', stream); | |
329 | break; | |
330 | } | |
331 | ||
c906108c | 332 | fputc_filtered ('\'', stream); |
6c7a06a3 | 333 | LA_EMIT_CHAR (c, type, stream, '\''); |
c906108c SS |
334 | fputc_filtered ('\'', stream); |
335 | } | |
336 | ||
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. */ | |
342 | ||
343 | void | |
6c7a06a3 TT |
344 | c_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string, |
345 | unsigned int length, int force_ellipses, | |
79a45b7d | 346 | const struct value_print_options *options) |
c906108c | 347 | { |
f86f5ca3 | 348 | unsigned int i; |
c906108c SS |
349 | unsigned int things_printed = 0; |
350 | int in_quotes = 0; | |
351 | int need_comma = 0; | |
6c7a06a3 TT |
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; | |
358 | int finished = 0; | |
359 | int need_escape = 0; | |
c906108c SS |
360 | |
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 | |
363 | style. */ | |
364 | if (!force_ellipses | |
365 | && length > 0 | |
6c7a06a3 | 366 | && (extract_unsigned_integer (string + (length - 1) * width, width) == 0)) |
c906108c SS |
367 | length--; |
368 | ||
6c7a06a3 TT |
369 | str_type = classify_type (type, &encoding) & ~C_CHAR; |
370 | switch (str_type) | |
371 | { | |
372 | case C_STRING: | |
373 | break; | |
374 | case C_WIDE_STRING: | |
375 | fputs_filtered ("L", stream); | |
376 | break; | |
377 | case C_STRING_16: | |
378 | fputs_filtered ("u", stream); | |
379 | break; | |
380 | case C_STRING_32: | |
381 | fputs_filtered ("U", stream); | |
382 | break; | |
383 | } | |
384 | ||
c906108c SS |
385 | if (length == 0) |
386 | { | |
387 | fputs_filtered ("\"\"", stream); | |
388 | return; | |
389 | } | |
390 | ||
6c7a06a3 TT |
391 | if (length == -1) |
392 | { | |
393 | unsigned long current_char = 1; | |
394 | for (i = 0; current_char; ++i) | |
395 | { | |
396 | QUIT; | |
397 | current_char = extract_unsigned_integer (string + i * width, width); | |
398 | } | |
399 | length = i; | |
400 | } | |
401 | ||
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); | |
405 | ||
406 | /* WCHAR_BUF is the obstack we use to represent the string in | |
407 | wchar_t form. */ | |
408 | obstack_init (&wchar_buf); | |
409 | make_cleanup_obstack_free (&wchar_buf); | |
410 | ||
411 | while (!finished && things_printed < options->print_max) | |
c906108c | 412 | { |
6c7a06a3 TT |
413 | int num_chars; |
414 | enum wchar_iterate_result result; | |
415 | gdb_wchar_t *chars; | |
416 | const gdb_byte *buf; | |
417 | size_t buflen; | |
c906108c SS |
418 | |
419 | QUIT; | |
420 | ||
421 | if (need_comma) | |
422 | { | |
6c7a06a3 | 423 | obstack_grow_wstr (&wchar_buf, LCST (", ")); |
c906108c SS |
424 | need_comma = 0; |
425 | } | |
426 | ||
6c7a06a3 TT |
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 | |
431 | cases. */ | |
432 | while (num_chars == 1) | |
433 | { | |
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; | |
c906108c | 439 | |
6c7a06a3 TT |
440 | if (need_comma) |
441 | { | |
442 | obstack_grow_wstr (&wchar_buf, LCST (", ")); | |
443 | need_comma = 0; | |
444 | } | |
445 | ||
446 | while (num_chars == 1 && current_char == chars[0]) | |
447 | { | |
448 | num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen); | |
449 | ++reps; | |
450 | } | |
451 | ||
452 | /* Emit CURRENT_CHAR according to the repetition count and | |
453 | options. */ | |
454 | if (reps > options->repeat_count_threshold) | |
455 | { | |
456 | if (in_quotes) | |
457 | { | |
458 | if (options->inspect_it) | |
459 | obstack_grow_wstr (&wchar_buf, LCST ("\\\", ")); | |
460 | else | |
461 | obstack_grow_wstr (&wchar_buf, LCST ("\", ")); | |
462 | in_quotes = 0; | |
463 | } | |
464 | obstack_grow_wstr (&wchar_buf, LCST ("'")); | |
465 | need_escape = 0; | |
466 | print_wchar (current_char, orig_buf, orig_len, width, | |
467 | &wchar_buf, '\'', &need_escape); | |
468 | obstack_grow_wstr (&wchar_buf, LCST ("'")); | |
469 | { | |
470 | /* Painful gyrations. */ | |
471 | int j; | |
472 | char *s = xstrprintf (_(" <repeats %u times>"), reps); | |
473 | for (j = 0; s[j]; ++j) | |
474 | { | |
475 | gdb_wchar_t w = gdb_btowc (s[j]); | |
476 | obstack_grow (&wchar_buf, &w, sizeof (gdb_wchar_t)); | |
477 | } | |
478 | xfree (s); | |
479 | } | |
480 | things_printed += options->repeat_count_threshold; | |
481 | need_comma = 1; | |
482 | } | |
483 | else | |
484 | { | |
485 | /* Saw the character one or more times, but fewer than | |
486 | the repetition threshold. */ | |
487 | if (!in_quotes) | |
488 | { | |
489 | if (options->inspect_it) | |
490 | obstack_grow_wstr (&wchar_buf, LCST ("\\\"")); | |
491 | else | |
492 | obstack_grow_wstr (&wchar_buf, LCST ("\"")); | |
493 | in_quotes = 1; | |
494 | need_escape = 0; | |
495 | } | |
496 | ||
497 | while (reps-- > 0) | |
498 | { | |
499 | print_wchar (current_char, orig_buf, orig_len, width, | |
500 | &wchar_buf, '"', &need_escape); | |
501 | ++things_printed; | |
502 | } | |
503 | } | |
504 | } | |
505 | ||
506 | /* NUM_CHARS and the other outputs from wchar_iterate are valid | |
507 | here regardless of which branch was taken above. */ | |
508 | if (num_chars < 0) | |
c906108c | 509 | { |
6c7a06a3 TT |
510 | /* Hit EOF. */ |
511 | finished = 1; | |
512 | break; | |
c906108c SS |
513 | } |
514 | ||
6c7a06a3 | 515 | switch (result) |
c906108c | 516 | { |
6c7a06a3 TT |
517 | case wchar_iterate_invalid: |
518 | if (!in_quotes) | |
c906108c | 519 | { |
79a45b7d | 520 | if (options->inspect_it) |
6c7a06a3 | 521 | obstack_grow_wstr (&wchar_buf, LCST ("\\\"")); |
c906108c | 522 | else |
6c7a06a3 TT |
523 | obstack_grow_wstr (&wchar_buf, LCST ("\"")); |
524 | in_quotes = 1; | |
c906108c | 525 | } |
6c7a06a3 TT |
526 | need_escape = 0; |
527 | print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf, | |
528 | '"', &need_escape); | |
529 | break; | |
530 | ||
531 | case wchar_iterate_incomplete: | |
532 | if (in_quotes) | |
c906108c | 533 | { |
79a45b7d | 534 | if (options->inspect_it) |
6c7a06a3 | 535 | obstack_grow_wstr (&wchar_buf, LCST ("\\\",")); |
c906108c | 536 | else |
6c7a06a3 TT |
537 | obstack_grow_wstr (&wchar_buf, LCST ("\",")); |
538 | in_quotes = 0; | |
c906108c | 539 | } |
6c7a06a3 TT |
540 | obstack_grow_wstr (&wchar_buf, LCST (" <incomplete sequence ")); |
541 | print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf, | |
542 | 0, &need_escape); | |
543 | obstack_grow_wstr (&wchar_buf, LCST (">")); | |
544 | finished = 1; | |
545 | break; | |
c906108c SS |
546 | } |
547 | } | |
548 | ||
549 | /* Terminate the quotes if necessary. */ | |
550 | if (in_quotes) | |
551 | { | |
79a45b7d | 552 | if (options->inspect_it) |
6c7a06a3 | 553 | obstack_grow_wstr (&wchar_buf, LCST ("\\\"")); |
c906108c | 554 | else |
6c7a06a3 | 555 | obstack_grow_wstr (&wchar_buf, LCST ("\"")); |
c906108c SS |
556 | } |
557 | ||
6c7a06a3 TT |
558 | if (force_ellipses || !finished) |
559 | obstack_grow_wstr (&wchar_buf, LCST ("...")); | |
560 | ||
561 | /* OUTPUT is where we collect `char's for printing. */ | |
562 | obstack_init (&output); | |
563 | make_cleanup_obstack_free (&output); | |
564 | ||
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'); | |
570 | ||
571 | fputs_filtered (obstack_base (&output), stream); | |
572 | ||
573 | do_cleanups (cleanup); | |
c906108c | 574 | } |
ae6a3a4c TJB |
575 | |
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 | |
581 | character). | |
582 | ||
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. | |
587 | ||
588 | CHARSET is always set to the target charset. */ | |
589 | ||
590 | void | |
591 | c_get_string (struct value *value, gdb_byte **buffer, int *length, | |
592 | const char **charset) | |
593 | { | |
594 | int err, width; | |
595 | unsigned int fetchlimit; | |
596 | struct type *type = check_typedef (value_type (value)); | |
597 | struct type *element_type = TYPE_TARGET_TYPE (type); | |
598 | ||
599 | if (element_type == NULL) | |
600 | goto error; | |
601 | ||
602 | if (TYPE_CODE (type) == TYPE_CODE_ARRAY) | |
603 | { | |
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) | |
608 | { | |
609 | LONGEST low_bound, high_bound; | |
610 | ||
611 | get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), | |
612 | &low_bound, &high_bound); | |
613 | fetchlimit = high_bound - low_bound + 1; | |
614 | } | |
615 | else | |
616 | fetchlimit = UINT_MAX; | |
617 | } | |
618 | else if (TYPE_CODE (type) == TYPE_CODE_PTR) | |
619 | fetchlimit = UINT_MAX; | |
620 | else | |
621 | /* We work only with arrays and pointers. */ | |
622 | goto error; | |
623 | ||
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 | |
628 | a string. */ | |
629 | goto error; | |
630 | ||
631 | width = TYPE_LENGTH (element_type); | |
632 | ||
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) | |
639 | { | |
640 | int i; | |
641 | const gdb_byte *contents = value_contents (value); | |
642 | ||
643 | /* Look for a null character. */ | |
644 | for (i = 0; i < fetchlimit; i++) | |
645 | if (extract_unsigned_integer (contents + i * width, width) == 0) | |
646 | break; | |
647 | ||
648 | /* I is now either the number of non-null characters, or FETCHLIMIT. */ | |
649 | *length = i * width; | |
650 | *buffer = xmalloc (*length); | |
651 | memcpy (*buffer, contents, *length); | |
652 | err = 0; | |
653 | } | |
654 | else | |
655 | { | |
656 | err = read_string (value_as_address (value), -1, width, fetchlimit, | |
657 | buffer, length); | |
658 | if (err) | |
659 | { | |
660 | xfree (buffer); | |
661 | error (_("Error reading string from inferior: %s"), | |
662 | safe_strerror (err)); | |
663 | } | |
664 | } | |
665 | ||
666 | /* If the last character is null, subtract it from LENGTH. */ | |
667 | if (*length > 0 | |
668 | && extract_unsigned_integer (*buffer + *length - width, width) == 0) | |
669 | *length -= width; | |
670 | ||
671 | *charset = target_charset (); | |
672 | ||
673 | return; | |
674 | ||
675 | error: | |
676 | { | |
677 | char *type_str; | |
678 | ||
679 | type_str = type_to_string (type); | |
680 | if (type_str) | |
681 | { | |
682 | make_cleanup (xfree, type_str); | |
683 | error (_("Trying to read string with inappropriate type `%s'."), | |
684 | type_str); | |
685 | } | |
686 | else | |
687 | error (_("Trying to read string with inappropriate type.")); | |
688 | } | |
689 | } | |
690 | ||
c906108c | 691 | \f |
6c7a06a3 TT |
692 | /* Evaluating C and C++ expressions. */ |
693 | ||
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. */ | |
699 | ||
700 | static char * | |
701 | convert_ucn (char *p, char *limit, const char *dest_charset, | |
702 | struct obstack *output, int length) | |
703 | { | |
704 | unsigned long result = 0; | |
705 | gdb_byte data[4]; | |
706 | int i; | |
707 | ||
708 | for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p) | |
709 | result = (result << 4) + host_hex_value (*p); | |
710 | ||
711 | for (i = 3; i >= 0; --i) | |
712 | { | |
713 | data[i] = result & 0xff; | |
714 | result >>= 8; | |
715 | } | |
716 | ||
717 | convert_between_encodings ("UCS-4BE", dest_charset, data, 4, 4, output, | |
718 | translit_none); | |
719 | ||
720 | return p; | |
721 | } | |
722 | ||
723 | /* Emit a character, VALUE, which was specified numerically, to | |
724 | OUTPUT. TYPE is the target character type. */ | |
725 | ||
726 | static void | |
727 | emit_numeric_character (struct type *type, unsigned long value, | |
728 | struct obstack *output) | |
729 | { | |
730 | gdb_byte *buffer; | |
731 | ||
732 | buffer = alloca (TYPE_LENGTH (type)); | |
733 | pack_long (buffer, type, value); | |
734 | obstack_grow (output, buffer, TYPE_LENGTH (type)); | |
735 | } | |
736 | ||
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. */ | |
741 | ||
742 | static char * | |
743 | convert_octal (struct type *type, char *p, char *limit, struct obstack *output) | |
744 | { | |
745 | unsigned long value = 0; | |
746 | ||
747 | while (p < limit && isdigit (*p) && *p != '8' && *p != '9') | |
748 | { | |
749 | value = 8 * value + host_hex_value (*p); | |
750 | ++p; | |
751 | } | |
752 | ||
753 | emit_numeric_character (type, value, output); | |
754 | ||
755 | return p; | |
756 | } | |
757 | ||
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. */ | |
762 | ||
763 | static char * | |
764 | convert_hex (struct type *type, char *p, char *limit, struct obstack *output) | |
765 | { | |
766 | unsigned long value = 0; | |
767 | ||
768 | while (p < limit && isxdigit (*p)) | |
769 | { | |
770 | value = 16 * value + host_hex_value (*p); | |
771 | ++p; | |
772 | } | |
773 | ||
774 | emit_numeric_character (type, value, output); | |
775 | ||
776 | return p; | |
777 | } | |
778 | ||
779 | #define ADVANCE \ | |
780 | do { \ | |
781 | ++p; \ | |
782 | if (p == limit) \ | |
783 | error (_("Malformed escape sequence")); \ | |
784 | } while (0) | |
785 | ||
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. */ | |
792 | ||
793 | static char * | |
794 | convert_escape (struct type *type, const char *dest_charset, | |
795 | char *p, char *limit, struct obstack *output) | |
796 | { | |
797 | /* Skip the backslash. */ | |
798 | ADVANCE; | |
799 | ||
800 | switch (*p) | |
801 | { | |
802 | case '\\': | |
803 | obstack_1grow (output, '\\'); | |
804 | ++p; | |
805 | break; | |
806 | ||
807 | case 'x': | |
808 | ADVANCE; | |
809 | if (!isxdigit (*p)) | |
810 | error (_("\\x used with no following hex digits.")); | |
811 | p = convert_hex (type, p, limit, output); | |
812 | break; | |
813 | ||
814 | case '0': | |
815 | case '1': | |
816 | case '2': | |
817 | case '3': | |
818 | case '4': | |
819 | case '5': | |
820 | case '6': | |
821 | case '7': | |
822 | p = convert_octal (type, p, limit, output); | |
823 | break; | |
824 | ||
825 | case 'u': | |
826 | case 'U': | |
827 | { | |
828 | int length = *p == 'u' ? 4 : 8; | |
829 | ADVANCE; | |
830 | if (!isxdigit (*p)) | |
831 | error (_("\\u used with no following hex digits")); | |
832 | p = convert_ucn (p, limit, dest_charset, output, length); | |
833 | } | |
834 | } | |
835 | ||
836 | return p; | |
837 | } | |
838 | ||
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. */ | |
844 | ||
845 | static void | |
846 | parse_one_string (struct obstack *output, char *data, int len, | |
847 | const char *dest_charset, struct type *type) | |
848 | { | |
849 | char *limit; | |
850 | ||
851 | limit = data + len; | |
852 | ||
853 | while (data < limit) | |
854 | { | |
855 | char *p = data; | |
856 | /* Look for next escape, or the end of the input. */ | |
857 | while (p < limit && *p != '\\') | |
858 | ++p; | |
859 | /* If we saw a run of characters, convert them all. */ | |
860 | if (p > data) | |
861 | convert_between_encodings (host_charset (), dest_charset, | |
862 | data, p - data, 1, output, translit_none); | |
863 | /* If we saw an escape, convert it. */ | |
864 | if (p < limit) | |
865 | p = convert_escape (type, dest_charset, p, limit, output); | |
866 | data = p; | |
867 | } | |
868 | } | |
869 | ||
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. */ | |
873 | ||
874 | static struct value * | |
875 | evaluate_subexp_c (struct type *expect_type, struct expression *exp, | |
876 | int *pos, enum noside noside) | |
877 | { | |
878 | enum exp_opcode op = exp->elts[*pos].opcode; | |
879 | ||
880 | switch (op) | |
881 | { | |
882 | case OP_STRING: | |
883 | { | |
884 | int oplen, limit; | |
885 | struct type *type; | |
886 | struct obstack output; | |
887 | struct cleanup *cleanup; | |
888 | struct value *result; | |
889 | enum c_string_type dest_type; | |
890 | const char *dest_charset; | |
891 | ||
892 | obstack_init (&output); | |
893 | cleanup = make_cleanup_obstack_free (&output); | |
894 | ||
895 | ++*pos; | |
896 | oplen = longest_to_int (exp->elts[*pos].longconst); | |
897 | ||
898 | ++*pos; | |
899 | limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1); | |
900 | dest_type | |
901 | = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst); | |
902 | switch (dest_type & ~C_CHAR) | |
903 | { | |
904 | case C_STRING: | |
905 | type = language_string_char_type (current_language, | |
906 | current_gdbarch); | |
907 | break; | |
908 | case C_WIDE_STRING: | |
909 | type = lookup_typename ("wchar_t", NULL, 0); | |
910 | break; | |
911 | case C_STRING_16: | |
912 | type = lookup_typename ("char16_t", NULL, 0); | |
913 | break; | |
914 | case C_STRING_32: | |
915 | type = lookup_typename ("char32_t", NULL, 0); | |
916 | break; | |
917 | default: | |
918 | internal_error (__FILE__, __LINE__, "unhandled c_string_type"); | |
919 | } | |
920 | dest_charset = charset_for_string_type (dest_type); | |
921 | ||
922 | ++*pos; | |
923 | while (*pos < limit) | |
924 | { | |
925 | int len; | |
926 | ||
927 | len = longest_to_int (exp->elts[*pos].longconst); | |
928 | ||
929 | ++*pos; | |
930 | if (noside != EVAL_SKIP) | |
931 | parse_one_string (&output, &exp->elts[*pos].string, len, | |
932 | dest_charset, type); | |
933 | *pos += BYTES_TO_EXP_ELEM (len); | |
934 | } | |
935 | ||
936 | /* Skip the trailing length and opcode. */ | |
937 | *pos += 2; | |
938 | ||
939 | if (noside == EVAL_SKIP) | |
940 | return NULL; | |
941 | ||
942 | if ((dest_type & C_CHAR) != 0) | |
943 | { | |
944 | LONGEST value; | |
945 | ||
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); | |
950 | } | |
951 | else | |
952 | { | |
953 | int i; | |
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), | |
959 | type); | |
960 | } | |
961 | do_cleanups (cleanup); | |
962 | return result; | |
963 | } | |
964 | break; | |
965 | ||
966 | default: | |
967 | break; | |
968 | } | |
969 | return evaluate_subexp_standard (expect_type, exp, pos, noside); | |
970 | } | |
c5aa993b | 971 | |
84f0252a | 972 | |
84f0252a | 973 | \f |
c906108c SS |
974 | /* Table mapping opcodes into strings for printing operators |
975 | and precedences of the operators. */ | |
976 | ||
977 | const struct op_print c_op_print_tab[] = | |
c5aa993b JM |
978 | { |
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}, | |
c5aa993b | 1008 | {NULL, 0, 0, 0} |
c906108c SS |
1009 | }; |
1010 | \f | |
685419e2 AC |
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, | |
213e4dc2 TJB |
1029 | c_primitive_type_decfloat, |
1030 | c_primitive_type_decdouble, | |
1031 | c_primitive_type_declong, | |
685419e2 AC |
1032 | nr_c_primitive_types |
1033 | }; | |
1034 | ||
e9667a65 | 1035 | void |
685419e2 AC |
1036 | c_language_arch_info (struct gdbarch *gdbarch, |
1037 | struct language_arch_info *lai) | |
1038 | { | |
1039 | const struct builtin_type *builtin = builtin_type (gdbarch); | |
e9667a65 | 1040 | lai->string_char_type = builtin->builtin_char; |
685419e2 AC |
1041 | lai->primitive_type_vector |
1042 | = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1, | |
1043 | struct type *); | |
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; | |
213e4dc2 TJB |
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; | |
fbb06eb1 UW |
1064 | |
1065 | lai->bool_type_default = builtin->builtin_int; | |
cad351d1 | 1066 | } |
685419e2 | 1067 | |
6c7a06a3 TT |
1068 | static const struct exp_descriptor exp_descriptor_c = |
1069 | { | |
1070 | print_subexp_standard, | |
1071 | operator_length_standard, | |
1072 | op_name_standard, | |
1073 | dump_subexp_body_standard, | |
1074 | evaluate_subexp_c | |
1075 | }; | |
1076 | ||
c5aa993b JM |
1077 | const struct language_defn c_language_defn = |
1078 | { | |
c906108c SS |
1079 | "c", /* Language name */ |
1080 | language_c, | |
c906108c SS |
1081 | range_check_off, |
1082 | type_check_off, | |
63872f9d | 1083 | case_sensitive_on, |
7ca2d3a3 | 1084 | array_row_major, |
9a044a89 | 1085 | macro_expansion_c, |
6c7a06a3 | 1086 | &exp_descriptor_c, |
7c8adf68 | 1087 | c_parse, |
c906108c | 1088 | c_error, |
e85c3284 | 1089 | null_post_parser, |
c906108c SS |
1090 | c_printchar, /* Print a character constant */ |
1091 | c_printstr, /* Function to print string constant */ | |
1092 | c_emit_char, /* Print a single char */ | |
c906108c | 1093 | c_print_type, /* Print a type using appropriate syntax */ |
5c6ce71d | 1094 | c_print_typedef, /* Print a typedef using appropriate syntax */ |
c906108c SS |
1095 | c_val_print, /* Print a value using appropriate syntax */ |
1096 | c_value_print, /* Print a top-level value */ | |
f636b87d | 1097 | NULL, /* Language specific skip_trampoline */ |
2b2d9e11 | 1098 | NULL, /* name_of_this */ |
5f9a71c3 | 1099 | basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ |
b368761e | 1100 | basic_lookup_transparent_type,/* lookup_transparent_type */ |
9a3d7dfd | 1101 | NULL, /* Language specific symbol demangler */ |
31c27f77 | 1102 | NULL, /* Language specific class_name_from_physname */ |
c906108c SS |
1103 | c_op_print_tab, /* expression operators for printing */ |
1104 | 1, /* c-style arrays */ | |
1105 | 0, /* String lower bound */ | |
6084f43a | 1106 | default_word_break_characters, |
41d27058 | 1107 | default_make_symbol_completion_list, |
685419e2 | 1108 | c_language_arch_info, |
e79af960 | 1109 | default_print_array_index, |
41f1b697 | 1110 | default_pass_by_reference, |
ae6a3a4c | 1111 | c_get_string, |
c906108c SS |
1112 | LANG_MAGIC |
1113 | }; | |
1114 | ||
cad351d1 UW |
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, | |
213e4dc2 TJB |
1134 | cplus_primitive_type_decfloat, |
1135 | cplus_primitive_type_decdouble, | |
1136 | cplus_primitive_type_declong, | |
cad351d1 | 1137 | nr_cplus_primitive_types |
c906108c SS |
1138 | }; |
1139 | ||
cad351d1 UW |
1140 | static void |
1141 | cplus_language_arch_info (struct gdbarch *gdbarch, | |
1142 | struct language_arch_info *lai) | |
1143 | { | |
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, | |
1148 | struct type *); | |
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; | |
213e4dc2 TJB |
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; | |
fbb06eb1 UW |
1191 | |
1192 | lai->bool_type_symbol = "bool"; | |
1193 | lai->bool_type_default = builtin->builtin_bool; | |
cad351d1 UW |
1194 | } |
1195 | ||
c5aa993b JM |
1196 | const struct language_defn cplus_language_defn = |
1197 | { | |
1198 | "c++", /* Language name */ | |
c906108c | 1199 | language_cplus, |
c906108c SS |
1200 | range_check_off, |
1201 | type_check_off, | |
63872f9d | 1202 | case_sensitive_on, |
7ca2d3a3 | 1203 | array_row_major, |
9a044a89 | 1204 | macro_expansion_c, |
6c7a06a3 | 1205 | &exp_descriptor_c, |
7c8adf68 | 1206 | c_parse, |
c906108c | 1207 | c_error, |
e85c3284 | 1208 | null_post_parser, |
c906108c SS |
1209 | c_printchar, /* Print a character constant */ |
1210 | c_printstr, /* Function to print string constant */ | |
1211 | c_emit_char, /* Print a single char */ | |
c906108c | 1212 | c_print_type, /* Print a type using appropriate syntax */ |
5c6ce71d | 1213 | c_print_typedef, /* Print a typedef using appropriate syntax */ |
c906108c SS |
1214 | c_val_print, /* Print a value using appropriate syntax */ |
1215 | c_value_print, /* Print a top-level value */ | |
b18be20d | 1216 | cplus_skip_trampoline, /* Language specific skip_trampoline */ |
2b2d9e11 | 1217 | "this", /* name_of_this */ |
1fcb5155 | 1218 | cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ |
b368761e | 1219 | cp_lookup_transparent_type, /* lookup_transparent_type */ |
9a3d7dfd | 1220 | cplus_demangle, /* Language specific symbol demangler */ |
31c27f77 | 1221 | cp_class_name_from_physname, /* Language specific class_name_from_physname */ |
c906108c SS |
1222 | c_op_print_tab, /* expression operators for printing */ |
1223 | 1, /* c-style arrays */ | |
1224 | 0, /* String lower bound */ | |
6084f43a | 1225 | default_word_break_characters, |
41d27058 | 1226 | default_make_symbol_completion_list, |
cad351d1 | 1227 | cplus_language_arch_info, |
e79af960 | 1228 | default_print_array_index, |
41f1b697 | 1229 | cp_pass_by_reference, |
ae6a3a4c | 1230 | c_get_string, |
c906108c SS |
1231 | LANG_MAGIC |
1232 | }; | |
1233 | ||
c5aa993b JM |
1234 | const struct language_defn asm_language_defn = |
1235 | { | |
c906108c SS |
1236 | "asm", /* Language name */ |
1237 | language_asm, | |
c906108c SS |
1238 | range_check_off, |
1239 | type_check_off, | |
63872f9d | 1240 | case_sensitive_on, |
7ca2d3a3 | 1241 | array_row_major, |
9a044a89 | 1242 | macro_expansion_c, |
6c7a06a3 | 1243 | &exp_descriptor_c, |
7c8adf68 | 1244 | c_parse, |
c906108c | 1245 | c_error, |
e85c3284 | 1246 | null_post_parser, |
c906108c SS |
1247 | c_printchar, /* Print a character constant */ |
1248 | c_printstr, /* Function to print string constant */ | |
1249 | c_emit_char, /* Print a single char */ | |
c906108c | 1250 | c_print_type, /* Print a type using appropriate syntax */ |
5c6ce71d | 1251 | c_print_typedef, /* Print a typedef using appropriate syntax */ |
c906108c SS |
1252 | c_val_print, /* Print a value using appropriate syntax */ |
1253 | c_value_print, /* Print a top-level value */ | |
f636b87d | 1254 | NULL, /* Language specific skip_trampoline */ |
2b2d9e11 | 1255 | NULL, /* name_of_this */ |
5f9a71c3 | 1256 | basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ |
b368761e | 1257 | basic_lookup_transparent_type,/* lookup_transparent_type */ |
9a3d7dfd | 1258 | NULL, /* Language specific symbol demangler */ |
31c27f77 | 1259 | NULL, /* Language specific class_name_from_physname */ |
c906108c SS |
1260 | c_op_print_tab, /* expression operators for printing */ |
1261 | 1, /* c-style arrays */ | |
1262 | 0, /* String lower bound */ | |
6084f43a | 1263 | default_word_break_characters, |
41d27058 | 1264 | default_make_symbol_completion_list, |
e9667a65 | 1265 | c_language_arch_info, /* FIXME: la_language_arch_info. */ |
e79af960 | 1266 | default_print_array_index, |
41f1b697 | 1267 | default_pass_by_reference, |
ae6a3a4c | 1268 | c_get_string, |
c906108c SS |
1269 | LANG_MAGIC |
1270 | }; | |
1271 | ||
20a0e81d JB |
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. */ | |
1276 | ||
1277 | const struct language_defn minimal_language_defn = | |
1278 | { | |
1279 | "minimal", /* Language name */ | |
1280 | language_minimal, | |
20a0e81d JB |
1281 | range_check_off, |
1282 | type_check_off, | |
1283 | case_sensitive_on, | |
7ca2d3a3 | 1284 | array_row_major, |
9a044a89 | 1285 | macro_expansion_c, |
6c7a06a3 | 1286 | &exp_descriptor_c, |
7c8adf68 | 1287 | c_parse, |
20a0e81d | 1288 | c_error, |
e85c3284 | 1289 | null_post_parser, |
20a0e81d JB |
1290 | c_printchar, /* Print a character constant */ |
1291 | c_printstr, /* Function to print string constant */ | |
1292 | c_emit_char, /* Print a single char */ | |
20a0e81d | 1293 | c_print_type, /* Print a type using appropriate syntax */ |
5c6ce71d | 1294 | c_print_typedef, /* Print a typedef using appropriate syntax */ |
20a0e81d JB |
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 */ | |
2b2d9e11 | 1298 | NULL, /* name_of_this */ |
5f9a71c3 | 1299 | basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ |
b368761e | 1300 | basic_lookup_transparent_type,/* lookup_transparent_type */ |
20a0e81d | 1301 | NULL, /* Language specific symbol demangler */ |
31c27f77 | 1302 | NULL, /* Language specific class_name_from_physname */ |
20a0e81d JB |
1303 | c_op_print_tab, /* expression operators for printing */ |
1304 | 1, /* c-style arrays */ | |
1305 | 0, /* String lower bound */ | |
6084f43a | 1306 | default_word_break_characters, |
41d27058 | 1307 | default_make_symbol_completion_list, |
e9667a65 | 1308 | c_language_arch_info, |
e79af960 | 1309 | default_print_array_index, |
41f1b697 | 1310 | default_pass_by_reference, |
ae6a3a4c | 1311 | c_get_string, |
20a0e81d JB |
1312 | LANG_MAGIC |
1313 | }; | |
1314 | ||
c906108c | 1315 | void |
fba45db2 | 1316 | _initialize_c_language (void) |
c906108c SS |
1317 | { |
1318 | add_language (&c_language_defn); | |
1319 | add_language (&cplus_language_defn); | |
1320 | add_language (&asm_language_defn); | |
20a0e81d | 1321 | add_language (&minimal_language_defn); |
c906108c | 1322 | } |