1 /* C language support routines for GDB, the GNU debugger.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include "defs.h"
23 #include "symtab.h"
24 #include "gdbtypes.h"
25 #include "expression.h"
26 #include "parser-defs.h"
27 #include "language.h"
28 #include "c-lang.h"
29 #include "valprint.h"
30 #include "macroscope.h"
31 #include "gdb_assert.h"
32 #include "charset.h"
33 #include "gdb_string.h"
34 #include "demangle.h"
35 #include "cp-support.h"
36
37 extern void _initialize_c_language (void);
38 static void c_emit_char (int c, struct ui_file * stream, int quoter);
39
40 /* Print the character C on STREAM as part of the contents of a literal
41 string whose delimiter is QUOTER. Note that that format for printing
42 characters and strings is language specific. */
43
44 static void
c_emit_char(int c,struct ui_file * stream,int quoter)45 c_emit_char (int c, struct ui_file *stream, int quoter)
46 {
47 const char *escape;
48 int host_char;
49
50 c &= 0xFF; /* Avoid sign bit follies */
51
52 escape = c_target_char_has_backslash_escape (c);
53 if (escape)
54 {
55 if (quoter == '"' && strcmp (escape, "0") == 0)
56 /* Print nulls embedded in double quoted strings as \000 to
57 prevent ambiguity. */
58 fprintf_filtered (stream, "\\000");
59 else
60 fprintf_filtered (stream, "\\%s", escape);
61 }
62 else if (target_char_to_host (c, &host_char)
63 && host_char_print_literally (host_char))
64 {
65 if (host_char == '\\' || host_char == quoter)
66 fputs_filtered ("\\", stream);
67 fprintf_filtered (stream, "%c", host_char);
68 }
69 else
70 fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
71 }
72
73 void
c_printchar(int c,struct ui_file * stream)74 c_printchar (int c, struct ui_file *stream)
75 {
76 fputc_filtered ('\'', stream);
77 LA_EMIT_CHAR (c, stream, '\'');
78 fputc_filtered ('\'', stream);
79 }
80
81 /* Print the character string STRING, printing at most LENGTH characters.
82 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
83 long. Printing stops early if the number hits print_max; repeat counts are
84 printed as appropriate. Print ellipses at the end if we had to stop before
85 printing LENGTH characters, or if FORCE_ELLIPSES. */
86
87 void
c_printstr(struct ui_file * stream,char * string,unsigned int length,int width,int force_ellipses)88 c_printstr (struct ui_file *stream, char *string, unsigned int length,
89 int width, int force_ellipses)
90 {
91 unsigned int i;
92 unsigned int things_printed = 0;
93 int in_quotes = 0;
94 int need_comma = 0;
95
96 /* If the string was not truncated due to `set print elements', and
97 the last byte of it is a null, we don't print that, in traditional C
98 style. */
99 if (!force_ellipses
100 && length > 0
101 && (extract_unsigned_integer (string + (length - 1) * width, width)
102 == '\0'))
103 length--;
104
105 if (length == 0)
106 {
107 fputs_filtered ("\"\"", stream);
108 return;
109 }
110
111 for (i = 0; i < length && things_printed < print_max; ++i)
112 {
113 /* Position of the character we are examining
114 to see whether it is repeated. */
115 unsigned int rep1;
116 /* Number of repetitions we have detected so far. */
117 unsigned int reps;
118 unsigned long current_char;
119
120 QUIT;
121
122 if (need_comma)
123 {
124 fputs_filtered (", ", stream);
125 need_comma = 0;
126 }
127
128 current_char = extract_unsigned_integer (string + i * width, width);
129
130 rep1 = i + 1;
131 reps = 1;
132 while (rep1 < length
133 && extract_unsigned_integer (string + rep1 * width, width)
134 == current_char)
135 {
136 ++rep1;
137 ++reps;
138 }
139
140 if (reps > repeat_count_threshold)
141 {
142 if (in_quotes)
143 {
144 if (inspect_it)
145 fputs_filtered ("\\\", ", stream);
146 else
147 fputs_filtered ("\", ", stream);
148 in_quotes = 0;
149 }
150 LA_PRINT_CHAR (current_char, stream);
151 fprintf_filtered (stream, " <repeats %u times>", reps);
152 i = rep1 - 1;
153 things_printed += repeat_count_threshold;
154 need_comma = 1;
155 }
156 else
157 {
158 if (!in_quotes)
159 {
160 if (inspect_it)
161 fputs_filtered ("\\\"", stream);
162 else
163 fputs_filtered ("\"", stream);
164 in_quotes = 1;
165 }
166 LA_EMIT_CHAR (current_char, stream, '"');
167 ++things_printed;
168 }
169 }
170
171 /* Terminate the quotes if necessary. */
172 if (in_quotes)
173 {
174 if (inspect_it)
175 fputs_filtered ("\\\"", stream);
176 else
177 fputs_filtered ("\"", stream);
178 }
179
180 if (force_ellipses || i < length)
181 fputs_filtered ("...", stream);
182 }
183
184 /* Create a fundamental C type using default reasonable for the current
185 target machine.
186
187 Some object/debugging file formats (DWARF version 1, COFF, etc) do not
188 define fundamental types such as "int" or "double". Others (stabs or
189 DWARF version 2, etc) do define fundamental types. For the formats which
190 don't provide fundamental types, gdb can create such types using this
191 function.
192
193 FIXME: Some compilers distinguish explicitly signed integral types
194 (signed short, signed int, signed long) from "regular" integral types
195 (short, int, long) in the debugging information. There is some dis-
196 agreement as to how useful this feature is. In particular, gcc does
197 not support this. Also, only some debugging formats allow the
198 distinction to be passed on to a debugger. For now, we always just
199 use "short", "int", or "long" as the type name, for both the implicit
200 and explicitly signed types. This also makes life easier for the
201 gdb test suite since we don't have to account for the differences
202 in output depending upon what the compiler and debugging format
203 support. We will probably have to re-examine the issue when gdb
204 starts taking it's fundamental type information directly from the
205 debugging information supplied by the compiler. fnf@cygnus.com */
206
207 struct type *
c_create_fundamental_type(struct objfile * objfile,int typeid)208 c_create_fundamental_type (struct objfile *objfile, int typeid)
209 {
210 struct type *type = NULL;
211
212 switch (typeid)
213 {
214 default:
215 /* FIXME: For now, if we are asked to produce a type not in this
216 language, create the equivalent of a C integer type with the
217 name "<?type?>". When all the dust settles from the type
218 reconstruction work, this should probably become an error. */
219 type = init_type (TYPE_CODE_INT,
220 TARGET_INT_BIT / TARGET_CHAR_BIT,
221 0, "<?type?>", objfile);
222 warning ("internal error: no C/C++ fundamental type %d", typeid);
223 break;
224 case FT_VOID:
225 type = init_type (TYPE_CODE_VOID,
226 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
227 0, "void", objfile);
228 break;
229 case FT_BOOLEAN:
230 type = init_type (TYPE_CODE_BOOL,
231 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
232 0, "bool", objfile);
233 break;
234 case FT_CHAR:
235 type = init_type (TYPE_CODE_INT,
236 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
237 TYPE_FLAG_NOSIGN, "char", objfile);
238 break;
239 case FT_SIGNED_CHAR:
240 type = init_type (TYPE_CODE_INT,
241 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
242 0, "signed char", objfile);
243 break;
244 case FT_UNSIGNED_CHAR:
245 type = init_type (TYPE_CODE_INT,
246 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
247 TYPE_FLAG_UNSIGNED, "unsigned char", objfile);
248 break;
249 case FT_SHORT:
250 type = init_type (TYPE_CODE_INT,
251 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
252 0, "short", objfile);
253 break;
254 case FT_SIGNED_SHORT:
255 type = init_type (TYPE_CODE_INT,
256 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
257 0, "short", objfile); /* FIXME-fnf */
258 break;
259 case FT_UNSIGNED_SHORT:
260 type = init_type (TYPE_CODE_INT,
261 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
262 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
263 break;
264 case FT_INTEGER:
265 type = init_type (TYPE_CODE_INT,
266 TARGET_INT_BIT / TARGET_CHAR_BIT,
267 0, "int", objfile);
268 break;
269 case FT_SIGNED_INTEGER:
270 type = init_type (TYPE_CODE_INT,
271 TARGET_INT_BIT / TARGET_CHAR_BIT,
272 0, "int", objfile); /* FIXME -fnf */
273 break;
274 case FT_UNSIGNED_INTEGER:
275 type = init_type (TYPE_CODE_INT,
276 TARGET_INT_BIT / TARGET_CHAR_BIT,
277 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
278 break;
279 case FT_LONG:
280 type = init_type (TYPE_CODE_INT,
281 TARGET_LONG_BIT / TARGET_CHAR_BIT,
282 0, "long", objfile);
283 break;
284 case FT_SIGNED_LONG:
285 type = init_type (TYPE_CODE_INT,
286 TARGET_LONG_BIT / TARGET_CHAR_BIT,
287 0, "long", objfile); /* FIXME -fnf */
288 break;
289 case FT_UNSIGNED_LONG:
290 type = init_type (TYPE_CODE_INT,
291 TARGET_LONG_BIT / TARGET_CHAR_BIT,
292 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
293 break;
294 case FT_LONG_LONG:
295 type = init_type (TYPE_CODE_INT,
296 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
297 0, "long long", objfile);
298 break;
299 case FT_SIGNED_LONG_LONG:
300 type = init_type (TYPE_CODE_INT,
301 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
302 0, "signed long long", objfile);
303 break;
304 case FT_UNSIGNED_LONG_LONG:
305 type = init_type (TYPE_CODE_INT,
306 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
307 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
308 break;
309 case FT_FLOAT:
310 type = init_type (TYPE_CODE_FLT,
311 TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
312 0, "float", objfile);
313 break;
314 case FT_DBL_PREC_FLOAT:
315 type = init_type (TYPE_CODE_FLT,
316 TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
317 0, "double", objfile);
318 break;
319 case FT_EXT_PREC_FLOAT:
320 type = init_type (TYPE_CODE_FLT,
321 TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
322 0, "long double", objfile);
323 break;
324 case FT_COMPLEX:
325 type = init_type (TYPE_CODE_FLT,
326 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
327 0, "complex float", objfile);
328 TYPE_TARGET_TYPE (type)
329 = init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
330 0, "float", objfile);
331 break;
332 case FT_DBL_PREC_COMPLEX:
333 type = init_type (TYPE_CODE_FLT,
334 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
335 0, "complex double", objfile);
336 TYPE_TARGET_TYPE (type)
337 = init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
338 0, "double", objfile);
339 break;
340 case FT_EXT_PREC_COMPLEX:
341 type = init_type (TYPE_CODE_FLT,
342 2 * TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
343 0, "complex long double", objfile);
344 TYPE_TARGET_TYPE (type)
345 = init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
346 0, "long double", objfile);
347 break;
348 case FT_TEMPLATE_ARG:
349 type = init_type (TYPE_CODE_TEMPLATE_ARG,
350 0,
351 0, "<template arg>", objfile);
352 break;
353 }
354 return (type);
355 }
356
357 /* Preprocessing and parsing C and C++ expressions. */
358
359
360 /* When we find that lexptr (the global var defined in parse.c) is
361 pointing at a macro invocation, we expand the invocation, and call
362 scan_macro_expansion to save the old lexptr here and point lexptr
363 into the expanded text. When we reach the end of that, we call
364 end_macro_expansion to pop back to the value we saved here. The
365 macro expansion code promises to return only fully-expanded text,
366 so we don't need to "push" more than one level.
367
368 This is disgusting, of course. It would be cleaner to do all macro
369 expansion beforehand, and then hand that to lexptr. But we don't
370 really know where the expression ends. Remember, in a command like
371
372 (gdb) break *ADDRESS if CONDITION
373
374 we evaluate ADDRESS in the scope of the current frame, but we
375 evaluate CONDITION in the scope of the breakpoint's location. So
376 it's simply wrong to try to macro-expand the whole thing at once. */
377 static char *macro_original_text;
378 static char *macro_expanded_text;
379
380
381 void
scan_macro_expansion(char * expansion)382 scan_macro_expansion (char *expansion)
383 {
384 /* We'd better not be trying to push the stack twice. */
385 gdb_assert (! macro_original_text);
386 gdb_assert (! macro_expanded_text);
387
388 /* Save the old lexptr value, so we can return to it when we're done
389 parsing the expanded text. */
390 macro_original_text = lexptr;
391 lexptr = expansion;
392
393 /* Save the expanded text, so we can free it when we're finished. */
394 macro_expanded_text = expansion;
395 }
396
397
398 int
scanning_macro_expansion(void)399 scanning_macro_expansion (void)
400 {
401 return macro_original_text != 0;
402 }
403
404
405 void
finished_macro_expansion(void)406 finished_macro_expansion (void)
407 {
408 /* There'd better be something to pop back to, and we better have
409 saved a pointer to the start of the expanded text. */
410 gdb_assert (macro_original_text);
411 gdb_assert (macro_expanded_text);
412
413 /* Pop back to the original text. */
414 lexptr = macro_original_text;
415 macro_original_text = 0;
416
417 /* Free the expanded text. */
418 xfree (macro_expanded_text);
419 macro_expanded_text = 0;
420 }
421
422
423 static void
scan_macro_cleanup(void * dummy)424 scan_macro_cleanup (void *dummy)
425 {
426 if (macro_original_text)
427 finished_macro_expansion ();
428 }
429
430
431 /* We set these global variables before calling c_parse, to tell it
432 how it to find macro definitions for the expression at hand. */
433 macro_lookup_ftype *expression_macro_lookup_func;
434 void *expression_macro_lookup_baton;
435
436
437 static struct macro_definition *
null_macro_lookup(const char * name,void * baton)438 null_macro_lookup (const char *name, void *baton)
439 {
440 return 0;
441 }
442
443
444 static int
c_preprocess_and_parse(void)445 c_preprocess_and_parse (void)
446 {
447 /* Set up a lookup function for the macro expander. */
448 struct macro_scope *scope = 0;
449 struct cleanup *back_to = make_cleanup (free_current_contents, &scope);
450
451 if (expression_context_block)
452 scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
453 else
454 scope = default_macro_scope ();
455
456 if (scope)
457 {
458 expression_macro_lookup_func = standard_macro_lookup;
459 expression_macro_lookup_baton = (void *) scope;
460 }
461 else
462 {
463 expression_macro_lookup_func = null_macro_lookup;
464 expression_macro_lookup_baton = 0;
465 }
466
467 gdb_assert (! macro_original_text);
468 make_cleanup (scan_macro_cleanup, 0);
469
470 {
471 int result = c_parse ();
472 do_cleanups (back_to);
473 return result;
474 }
475 }
476
477
478
479 /* Table mapping opcodes into strings for printing operators
480 and precedences of the operators. */
481
482 const struct op_print c_op_print_tab[] =
483 {
484 {",", BINOP_COMMA, PREC_COMMA, 0},
485 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
486 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
487 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
488 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
489 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
490 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
491 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
492 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
493 {"<=", BINOP_LEQ, PREC_ORDER, 0},
494 {">=", BINOP_GEQ, PREC_ORDER, 0},
495 {">", BINOP_GTR, PREC_ORDER, 0},
496 {"<", BINOP_LESS, PREC_ORDER, 0},
497 {">>", BINOP_RSH, PREC_SHIFT, 0},
498 {"<<", BINOP_LSH, PREC_SHIFT, 0},
499 {"+", BINOP_ADD, PREC_ADD, 0},
500 {"-", BINOP_SUB, PREC_ADD, 0},
501 {"*", BINOP_MUL, PREC_MUL, 0},
502 {"/", BINOP_DIV, PREC_MUL, 0},
503 {"%", BINOP_REM, PREC_MUL, 0},
504 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
505 {"-", UNOP_NEG, PREC_PREFIX, 0},
506 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
507 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
508 {"*", UNOP_IND, PREC_PREFIX, 0},
509 {"&", UNOP_ADDR, PREC_PREFIX, 0},
510 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
511 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
512 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
513 {NULL, 0, 0, 0}
514 };
515
516 enum c_primitive_types {
517 c_primitive_type_int,
518 c_primitive_type_long,
519 c_primitive_type_short,
520 c_primitive_type_char,
521 c_primitive_type_float,
522 c_primitive_type_double,
523 c_primitive_type_void,
524 c_primitive_type_long_long,
525 c_primitive_type_signed_char,
526 c_primitive_type_unsigned_char,
527 c_primitive_type_unsigned_short,
528 c_primitive_type_unsigned_int,
529 c_primitive_type_unsigned_long,
530 c_primitive_type_unsigned_long_long,
531 c_primitive_type_long_double,
532 c_primitive_type_complex,
533 c_primitive_type_double_complex,
534 nr_c_primitive_types
535 };
536
537 void
c_language_arch_info(struct gdbarch * gdbarch,struct language_arch_info * lai)538 c_language_arch_info (struct gdbarch *gdbarch,
539 struct language_arch_info *lai)
540 {
541 const struct builtin_type *builtin = builtin_type (gdbarch);
542 lai->string_char_type = builtin->builtin_char;
543 lai->primitive_type_vector
544 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
545 struct type *);
546 lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
547 lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
548 lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
549 lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
550 lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
551 lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
552 lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
553 lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
554 lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
555 lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
556 lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
557 lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
558 lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
559 lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
560 lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
561 lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
562 lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
563 };
564
565 const struct language_defn c_language_defn =
566 {
567 "c", /* Language name */
568 language_c,
569 NULL,
570 range_check_off,
571 type_check_off,
572 case_sensitive_on,
573 array_row_major,
574 &exp_descriptor_standard,
575 c_preprocess_and_parse,
576 c_error,
577 null_post_parser,
578 c_printchar, /* Print a character constant */
579 c_printstr, /* Function to print string constant */
580 c_emit_char, /* Print a single char */
581 c_create_fundamental_type, /* Create fundamental type in this language */
582 c_print_type, /* Print a type using appropriate syntax */
583 c_val_print, /* Print a value using appropriate syntax */
584 c_value_print, /* Print a top-level value */
585 NULL, /* Language specific skip_trampoline */
586 NULL, /* value_of_this */
587 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
588 basic_lookup_transparent_type,/* lookup_transparent_type */
589 NULL, /* Language specific symbol demangler */
590 NULL, /* Language specific class_name_from_physname */
591 c_op_print_tab, /* expression operators for printing */
592 1, /* c-style arrays */
593 0, /* String lower bound */
594 NULL,
595 default_word_break_characters,
596 c_language_arch_info,
597 LANG_MAGIC
598 };
599
600 struct type **const (cplus_builtin_types[]) =
601 {
602 &builtin_type_int,
603 &builtin_type_long,
604 &builtin_type_short,
605 &builtin_type_char,
606 &builtin_type_float,
607 &builtin_type_double,
608 &builtin_type_void,
609 &builtin_type_long_long,
610 &builtin_type_signed_char,
611 &builtin_type_unsigned_char,
612 &builtin_type_unsigned_short,
613 &builtin_type_unsigned_int,
614 &builtin_type_unsigned_long,
615 &builtin_type_unsigned_long_long,
616 &builtin_type_long_double,
617 &builtin_type_complex,
618 &builtin_type_double_complex,
619 &builtin_type_bool,
620 0
621 };
622
623 /* without this stub function, alpha attempts to generate a
624 * text relocation for the function pointer instead of a PLT reference.
625 */
626 static char *call_cplus_demangle (const char *mangled, int options);
627 static char *
call_cplus_demangle(const char * mangled,int options)628 call_cplus_demangle (const char *mangled, int options)
629 {
630 return cplus_demangle(mangled, options);
631 }
632
633 const struct language_defn cplus_language_defn =
634 {
635 "c++", /* Language name */
636 language_cplus,
637 cplus_builtin_types,
638 range_check_off,
639 type_check_off,
640 case_sensitive_on,
641 array_row_major,
642 &exp_descriptor_standard,
643 c_preprocess_and_parse,
644 c_error,
645 null_post_parser,
646 c_printchar, /* Print a character constant */
647 c_printstr, /* Function to print string constant */
648 c_emit_char, /* Print a single char */
649 c_create_fundamental_type, /* Create fundamental type in this language */
650 c_print_type, /* Print a type using appropriate syntax */
651 c_val_print, /* Print a value using appropriate syntax */
652 c_value_print, /* Print a top-level value */
653 NULL, /* Language specific skip_trampoline */
654 value_of_this, /* value_of_this */
655 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
656 cp_lookup_transparent_type, /* lookup_transparent_type */
657 call_cplus_demangle, /* Language specific symbol demangler */
658 cp_class_name_from_physname, /* Language specific class_name_from_physname */
659 c_op_print_tab, /* expression operators for printing */
660 1, /* c-style arrays */
661 0, /* String lower bound */
662 &builtin_type_char, /* Type of string elements */
663 default_word_break_characters,
664 NULL, /* FIXME: la_language_arch_info. */
665 LANG_MAGIC
666 };
667
668 const struct language_defn asm_language_defn =
669 {
670 "asm", /* Language name */
671 language_asm,
672 NULL,
673 range_check_off,
674 type_check_off,
675 case_sensitive_on,
676 array_row_major,
677 &exp_descriptor_standard,
678 c_preprocess_and_parse,
679 c_error,
680 null_post_parser,
681 c_printchar, /* Print a character constant */
682 c_printstr, /* Function to print string constant */
683 c_emit_char, /* Print a single char */
684 c_create_fundamental_type, /* Create fundamental type in this language */
685 c_print_type, /* Print a type using appropriate syntax */
686 c_val_print, /* Print a value using appropriate syntax */
687 c_value_print, /* Print a top-level value */
688 NULL, /* Language specific skip_trampoline */
689 NULL, /* value_of_this */
690 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
691 basic_lookup_transparent_type,/* lookup_transparent_type */
692 NULL, /* Language specific symbol demangler */
693 NULL, /* Language specific class_name_from_physname */
694 c_op_print_tab, /* expression operators for printing */
695 1, /* c-style arrays */
696 0, /* String lower bound */
697 NULL,
698 default_word_break_characters,
699 c_language_arch_info, /* FIXME: la_language_arch_info. */
700 LANG_MAGIC
701 };
702
703 /* The following language_defn does not represent a real language.
704 It just provides a minimal support a-la-C that should allow users
705 to do some simple operations when debugging applications that use
706 a language currently not supported by GDB. */
707
708 const struct language_defn minimal_language_defn =
709 {
710 "minimal", /* Language name */
711 language_minimal,
712 NULL,
713 range_check_off,
714 type_check_off,
715 case_sensitive_on,
716 array_row_major,
717 &exp_descriptor_standard,
718 c_preprocess_and_parse,
719 c_error,
720 null_post_parser,
721 c_printchar, /* Print a character constant */
722 c_printstr, /* Function to print string constant */
723 c_emit_char, /* Print a single char */
724 c_create_fundamental_type, /* Create fundamental type in this language */
725 c_print_type, /* Print a type using appropriate syntax */
726 c_val_print, /* Print a value using appropriate syntax */
727 c_value_print, /* Print a top-level value */
728 NULL, /* Language specific skip_trampoline */
729 NULL, /* value_of_this */
730 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
731 basic_lookup_transparent_type,/* lookup_transparent_type */
732 NULL, /* Language specific symbol demangler */
733 NULL, /* Language specific class_name_from_physname */
734 c_op_print_tab, /* expression operators for printing */
735 1, /* c-style arrays */
736 0, /* String lower bound */
737 NULL,
738 default_word_break_characters,
739 c_language_arch_info,
740 LANG_MAGIC
741 };
742
743 void
_initialize_c_language(void)744 _initialize_c_language (void)
745 {
746 add_language (&c_language_defn);
747 add_language (&cplus_language_defn);
748 add_language (&asm_language_defn);
749 add_language (&minimal_language_defn);
750 }
751