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 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 2 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, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
26 #include "expression.h"
27 #include "parser-defs.h"
31 #include "macroscope.h"
32 #include "gdb_assert.h"
34 #include "gdb_string.h"
37 #include "cp-support.h"
39 extern void _initialize_c_language (void);
40 static void c_emit_char (int c
, struct ui_file
* stream
, int quoter
);
42 /* Print the character C on STREAM as part of the contents of a literal
43 string whose delimiter is QUOTER. Note that that format for printing
44 characters and strings is language specific. */
47 c_emit_char (int c
, struct ui_file
*stream
, int quoter
)
52 c
&= 0xFF; /* Avoid sign bit follies */
54 escape
= c_target_char_has_backslash_escape (c
);
57 if (quoter
== '"' && strcmp (escape
, "0") == 0)
58 /* Print nulls embedded in double quoted strings as \000 to
60 fprintf_filtered (stream
, "\\000");
62 fprintf_filtered (stream
, "\\%s", escape
);
64 else if (target_char_to_host (c
, &host_char
)
65 && host_char_print_literally (host_char
))
67 if (host_char
== '\\' || host_char
== quoter
)
68 fputs_filtered ("\\", stream
);
69 fprintf_filtered (stream
, "%c", host_char
);
72 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
76 c_printchar (int c
, struct ui_file
*stream
)
78 fputc_filtered ('\'', stream
);
79 LA_EMIT_CHAR (c
, stream
, '\'');
80 fputc_filtered ('\'', stream
);
83 /* Print the character string STRING, printing at most LENGTH characters.
84 LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
85 long. Printing stops early if the number hits print_max; repeat counts are
86 printed as appropriate. Print ellipses at the end if we had to stop before
87 printing LENGTH characters, or if FORCE_ELLIPSES. */
90 c_printstr (struct ui_file
*stream
, const gdb_byte
*string
,
91 unsigned int length
, int width
, int force_ellipses
)
94 unsigned int things_printed
= 0;
98 /* If the string was not truncated due to `set print elements', and
99 the last byte of it is a null, we don't print that, in traditional C
103 && (extract_unsigned_integer (string
+ (length
- 1) * width
, width
)
109 fputs_filtered ("\"\"", stream
);
113 for (i
= 0; i
< length
&& things_printed
< print_max
; ++i
)
115 /* Position of the character we are examining
116 to see whether it is repeated. */
118 /* Number of repetitions we have detected so far. */
120 unsigned long current_char
;
126 fputs_filtered (", ", stream
);
130 current_char
= extract_unsigned_integer (string
+ i
* width
, width
);
135 && extract_unsigned_integer (string
+ rep1
* width
, width
)
142 if (reps
> repeat_count_threshold
)
147 fputs_filtered ("\\\", ", stream
);
149 fputs_filtered ("\", ", stream
);
152 LA_PRINT_CHAR (current_char
, stream
);
153 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
155 things_printed
+= repeat_count_threshold
;
163 fputs_filtered ("\\\"", stream
);
165 fputs_filtered ("\"", stream
);
168 LA_EMIT_CHAR (current_char
, stream
, '"');
173 /* Terminate the quotes if necessary. */
177 fputs_filtered ("\\\"", stream
);
179 fputs_filtered ("\"", stream
);
182 if (force_ellipses
|| i
< length
)
183 fputs_filtered ("...", stream
);
186 /* Create a fundamental C type using default reasonable for the current
189 Some object/debugging file formats (DWARF version 1, COFF, etc) do not
190 define fundamental types such as "int" or "double". Others (stabs or
191 DWARF version 2, etc) do define fundamental types. For the formats which
192 don't provide fundamental types, gdb can create such types using this
195 FIXME: Some compilers distinguish explicitly signed integral types
196 (signed short, signed int, signed long) from "regular" integral types
197 (short, int, long) in the debugging information. There is some dis-
198 agreement as to how useful this feature is. In particular, gcc does
199 not support this. Also, only some debugging formats allow the
200 distinction to be passed on to a debugger. For now, we always just
201 use "short", "int", or "long" as the type name, for both the implicit
202 and explicitly signed types. This also makes life easier for the
203 gdb test suite since we don't have to account for the differences
204 in output depending upon what the compiler and debugging format
205 support. We will probably have to re-examine the issue when gdb
206 starts taking its fundamental type information directly from the
207 debugging information supplied by the compiler. fnf@cygnus.com */
210 c_create_fundamental_type (struct objfile
*objfile
, int typeid)
212 struct type
*type
= NULL
;
217 /* FIXME: For now, if we are asked to produce a type not in this
218 language, create the equivalent of a C integer type with the
219 name "<?type?>". When all the dust settles from the type
220 reconstruction work, this should probably become an error. */
221 type
= init_type (TYPE_CODE_INT
,
222 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
223 0, "<?type?>", objfile
);
224 warning (_("internal error: no C/C++ fundamental type %d"), typeid);
227 type
= init_type (TYPE_CODE_VOID
,
228 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
232 type
= init_type (TYPE_CODE_BOOL
,
233 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
237 type
= init_type (TYPE_CODE_INT
,
238 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
239 TYPE_FLAG_NOSIGN
, "char", objfile
);
242 type
= init_type (TYPE_CODE_INT
,
243 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
244 0, "signed char", objfile
);
246 case FT_UNSIGNED_CHAR
:
247 type
= init_type (TYPE_CODE_INT
,
248 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
249 TYPE_FLAG_UNSIGNED
, "unsigned char", objfile
);
252 type
= init_type (TYPE_CODE_INT
,
253 gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
254 0, "short", objfile
);
256 case FT_SIGNED_SHORT
:
257 type
= init_type (TYPE_CODE_INT
,
258 gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
259 0, "short", objfile
); /* FIXME-fnf */
261 case FT_UNSIGNED_SHORT
:
262 type
= init_type (TYPE_CODE_INT
,
263 gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
264 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
267 type
= init_type (TYPE_CODE_INT
,
268 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
271 case FT_SIGNED_INTEGER
:
272 type
= init_type (TYPE_CODE_INT
,
273 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
274 0, "int", objfile
); /* FIXME -fnf */
276 case FT_UNSIGNED_INTEGER
:
277 type
= init_type (TYPE_CODE_INT
,
278 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
279 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
282 type
= init_type (TYPE_CODE_INT
,
283 gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
287 type
= init_type (TYPE_CODE_INT
,
288 gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
289 0, "long", objfile
); /* FIXME -fnf */
291 case FT_UNSIGNED_LONG
:
292 type
= init_type (TYPE_CODE_INT
,
293 gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
294 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
297 type
= init_type (TYPE_CODE_INT
,
298 gdbarch_long_long_bit (current_gdbarch
)
300 0, "long long", objfile
);
302 case FT_SIGNED_LONG_LONG
:
303 type
= init_type (TYPE_CODE_INT
,
304 gdbarch_long_long_bit (current_gdbarch
)
306 0, "signed long long", objfile
);
308 case FT_UNSIGNED_LONG_LONG
:
309 type
= init_type (TYPE_CODE_INT
,
310 gdbarch_long_long_bit (current_gdbarch
)
312 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
315 type
= init_type (TYPE_CODE_FLT
,
316 TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
317 0, "float", objfile
);
319 case FT_DBL_PREC_FLOAT
:
320 type
= init_type (TYPE_CODE_FLT
,
321 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
322 0, "double", objfile
);
324 case FT_EXT_PREC_FLOAT
:
325 type
= init_type (TYPE_CODE_FLT
,
326 TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
327 0, "long double", objfile
);
330 type
= init_type (TYPE_CODE_FLT
,
331 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
332 0, "complex float", objfile
);
333 TYPE_TARGET_TYPE (type
)
334 = init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
335 0, "float", objfile
);
337 case FT_DBL_PREC_COMPLEX
:
338 type
= init_type (TYPE_CODE_FLT
,
339 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
340 0, "complex double", objfile
);
341 TYPE_TARGET_TYPE (type
)
342 = init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
343 0, "double", objfile
);
345 case FT_EXT_PREC_COMPLEX
:
346 type
= init_type (TYPE_CODE_FLT
,
347 2 * TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
348 0, "complex long double", objfile
);
349 TYPE_TARGET_TYPE (type
)
350 = init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
351 0, "long double", objfile
);
353 case FT_TEMPLATE_ARG
:
354 type
= init_type (TYPE_CODE_TEMPLATE_ARG
,
356 0, "<template arg>", objfile
);
362 /* Preprocessing and parsing C and C++ expressions. */
365 /* When we find that lexptr (the global var defined in parse.c) is
366 pointing at a macro invocation, we expand the invocation, and call
367 scan_macro_expansion to save the old lexptr here and point lexptr
368 into the expanded text. When we reach the end of that, we call
369 end_macro_expansion to pop back to the value we saved here. The
370 macro expansion code promises to return only fully-expanded text,
371 so we don't need to "push" more than one level.
373 This is disgusting, of course. It would be cleaner to do all macro
374 expansion beforehand, and then hand that to lexptr. But we don't
375 really know where the expression ends. Remember, in a command like
377 (gdb) break *ADDRESS if CONDITION
379 we evaluate ADDRESS in the scope of the current frame, but we
380 evaluate CONDITION in the scope of the breakpoint's location. So
381 it's simply wrong to try to macro-expand the whole thing at once. */
382 static char *macro_original_text
;
383 static char *macro_expanded_text
;
387 scan_macro_expansion (char *expansion
)
389 /* We'd better not be trying to push the stack twice. */
390 gdb_assert (! macro_original_text
);
391 gdb_assert (! macro_expanded_text
);
393 /* Save the old lexptr value, so we can return to it when we're done
394 parsing the expanded text. */
395 macro_original_text
= lexptr
;
398 /* Save the expanded text, so we can free it when we're finished. */
399 macro_expanded_text
= expansion
;
404 scanning_macro_expansion (void)
406 return macro_original_text
!= 0;
411 finished_macro_expansion (void)
413 /* There'd better be something to pop back to, and we better have
414 saved a pointer to the start of the expanded text. */
415 gdb_assert (macro_original_text
);
416 gdb_assert (macro_expanded_text
);
418 /* Pop back to the original text. */
419 lexptr
= macro_original_text
;
420 macro_original_text
= 0;
422 /* Free the expanded text. */
423 xfree (macro_expanded_text
);
424 macro_expanded_text
= 0;
429 scan_macro_cleanup (void *dummy
)
431 if (macro_original_text
)
432 finished_macro_expansion ();
436 /* We set these global variables before calling c_parse, to tell it
437 how it to find macro definitions for the expression at hand. */
438 macro_lookup_ftype
*expression_macro_lookup_func
;
439 void *expression_macro_lookup_baton
;
442 static struct macro_definition
*
443 null_macro_lookup (const char *name
, void *baton
)
450 c_preprocess_and_parse (void)
452 /* Set up a lookup function for the macro expander. */
453 struct macro_scope
*scope
= 0;
454 struct cleanup
*back_to
= make_cleanup (free_current_contents
, &scope
);
456 if (expression_context_block
)
457 scope
= sal_macro_scope (find_pc_line (expression_context_pc
, 0));
459 scope
= default_macro_scope ();
463 expression_macro_lookup_func
= standard_macro_lookup
;
464 expression_macro_lookup_baton
= (void *) scope
;
468 expression_macro_lookup_func
= null_macro_lookup
;
469 expression_macro_lookup_baton
= 0;
472 gdb_assert (! macro_original_text
);
473 make_cleanup (scan_macro_cleanup
, 0);
476 int result
= c_parse ();
477 do_cleanups (back_to
);
484 /* Table mapping opcodes into strings for printing operators
485 and precedences of the operators. */
487 const struct op_print c_op_print_tab
[] =
489 {",", BINOP_COMMA
, PREC_COMMA
, 0},
490 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
491 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
492 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
493 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
494 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
495 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
496 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
497 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
498 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
499 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
500 {">", BINOP_GTR
, PREC_ORDER
, 0},
501 {"<", BINOP_LESS
, PREC_ORDER
, 0},
502 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
503 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
504 {"+", BINOP_ADD
, PREC_ADD
, 0},
505 {"-", BINOP_SUB
, PREC_ADD
, 0},
506 {"*", BINOP_MUL
, PREC_MUL
, 0},
507 {"/", BINOP_DIV
, PREC_MUL
, 0},
508 {"%", BINOP_REM
, PREC_MUL
, 0},
509 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
510 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
511 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
512 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
513 {"*", UNOP_IND
, PREC_PREFIX
, 0},
514 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
515 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
516 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
517 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
521 enum c_primitive_types
{
522 c_primitive_type_int
,
523 c_primitive_type_long
,
524 c_primitive_type_short
,
525 c_primitive_type_char
,
526 c_primitive_type_float
,
527 c_primitive_type_double
,
528 c_primitive_type_void
,
529 c_primitive_type_long_long
,
530 c_primitive_type_signed_char
,
531 c_primitive_type_unsigned_char
,
532 c_primitive_type_unsigned_short
,
533 c_primitive_type_unsigned_int
,
534 c_primitive_type_unsigned_long
,
535 c_primitive_type_unsigned_long_long
,
536 c_primitive_type_long_double
,
537 c_primitive_type_complex
,
538 c_primitive_type_double_complex
,
543 c_language_arch_info (struct gdbarch
*gdbarch
,
544 struct language_arch_info
*lai
)
546 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
547 lai
->string_char_type
= builtin
->builtin_char
;
548 lai
->primitive_type_vector
549 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_c_primitive_types
+ 1,
551 lai
->primitive_type_vector
[c_primitive_type_int
] = builtin
->builtin_int
;
552 lai
->primitive_type_vector
[c_primitive_type_long
] = builtin
->builtin_long
;
553 lai
->primitive_type_vector
[c_primitive_type_short
] = builtin
->builtin_short
;
554 lai
->primitive_type_vector
[c_primitive_type_char
] = builtin
->builtin_char
;
555 lai
->primitive_type_vector
[c_primitive_type_float
] = builtin
->builtin_float
;
556 lai
->primitive_type_vector
[c_primitive_type_double
] = builtin
->builtin_double
;
557 lai
->primitive_type_vector
[c_primitive_type_void
] = builtin
->builtin_void
;
558 lai
->primitive_type_vector
[c_primitive_type_long_long
] = builtin
->builtin_long_long
;
559 lai
->primitive_type_vector
[c_primitive_type_signed_char
] = builtin
->builtin_signed_char
;
560 lai
->primitive_type_vector
[c_primitive_type_unsigned_char
] = builtin
->builtin_unsigned_char
;
561 lai
->primitive_type_vector
[c_primitive_type_unsigned_short
] = builtin
->builtin_unsigned_short
;
562 lai
->primitive_type_vector
[c_primitive_type_unsigned_int
] = builtin
->builtin_unsigned_int
;
563 lai
->primitive_type_vector
[c_primitive_type_unsigned_long
] = builtin
->builtin_unsigned_long
;
564 lai
->primitive_type_vector
[c_primitive_type_unsigned_long_long
] = builtin
->builtin_unsigned_long_long
;
565 lai
->primitive_type_vector
[c_primitive_type_long_double
] = builtin
->builtin_long_double
;
566 lai
->primitive_type_vector
[c_primitive_type_complex
] = builtin
->builtin_complex
;
567 lai
->primitive_type_vector
[c_primitive_type_double_complex
] = builtin
->builtin_double_complex
;
570 const struct language_defn c_language_defn
=
572 "c", /* Language name */
579 &exp_descriptor_standard
,
580 c_preprocess_and_parse
,
583 c_printchar
, /* Print a character constant */
584 c_printstr
, /* Function to print string constant */
585 c_emit_char
, /* Print a single char */
586 c_create_fundamental_type
, /* Create fundamental type in this language */
587 c_print_type
, /* Print a type using appropriate syntax */
588 c_val_print
, /* Print a value using appropriate syntax */
589 c_value_print
, /* Print a top-level value */
590 NULL
, /* Language specific skip_trampoline */
591 NULL
, /* value_of_this */
592 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
593 basic_lookup_transparent_type
,/* lookup_transparent_type */
594 NULL
, /* Language specific symbol demangler */
595 NULL
, /* Language specific class_name_from_physname */
596 c_op_print_tab
, /* expression operators for printing */
597 1, /* c-style arrays */
598 0, /* String lower bound */
600 default_word_break_characters
,
601 c_language_arch_info
,
602 default_print_array_index
,
606 struct type
**const (cplus_builtin_types
[]) =
613 &builtin_type_double
,
615 &builtin_type_long_long
,
616 &builtin_type_signed_char
,
617 &builtin_type_unsigned_char
,
618 &builtin_type_unsigned_short
,
619 &builtin_type_unsigned_int
,
620 &builtin_type_unsigned_long
,
621 &builtin_type_unsigned_long_long
,
622 &builtin_type_long_double
,
623 &builtin_type_complex
,
624 &builtin_type_double_complex
,
629 const struct language_defn cplus_language_defn
=
631 "c++", /* Language name */
638 &exp_descriptor_standard
,
639 c_preprocess_and_parse
,
642 c_printchar
, /* Print a character constant */
643 c_printstr
, /* Function to print string constant */
644 c_emit_char
, /* Print a single char */
645 c_create_fundamental_type
, /* Create fundamental type in this language */
646 c_print_type
, /* Print a type using appropriate syntax */
647 c_val_print
, /* Print a value using appropriate syntax */
648 c_value_print
, /* Print a top-level value */
649 cplus_skip_trampoline
, /* Language specific skip_trampoline */
650 value_of_this
, /* value_of_this */
651 cp_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
652 cp_lookup_transparent_type
, /* lookup_transparent_type */
653 cplus_demangle
, /* Language specific symbol demangler */
654 cp_class_name_from_physname
, /* Language specific class_name_from_physname */
655 c_op_print_tab
, /* expression operators for printing */
656 1, /* c-style arrays */
657 0, /* String lower bound */
658 &builtin_type_char
, /* Type of string elements */
659 default_word_break_characters
,
660 NULL
, /* FIXME: la_language_arch_info. */
661 default_print_array_index
,
665 const struct language_defn asm_language_defn
=
667 "asm", /* Language name */
674 &exp_descriptor_standard
,
675 c_preprocess_and_parse
,
678 c_printchar
, /* Print a character constant */
679 c_printstr
, /* Function to print string constant */
680 c_emit_char
, /* Print a single char */
681 c_create_fundamental_type
, /* Create fundamental type in this language */
682 c_print_type
, /* Print a type using appropriate syntax */
683 c_val_print
, /* Print a value using appropriate syntax */
684 c_value_print
, /* Print a top-level value */
685 NULL
, /* Language specific skip_trampoline */
686 NULL
, /* value_of_this */
687 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
688 basic_lookup_transparent_type
,/* lookup_transparent_type */
689 NULL
, /* Language specific symbol demangler */
690 NULL
, /* Language specific class_name_from_physname */
691 c_op_print_tab
, /* expression operators for printing */
692 1, /* c-style arrays */
693 0, /* String lower bound */
695 default_word_break_characters
,
696 c_language_arch_info
, /* FIXME: la_language_arch_info. */
697 default_print_array_index
,
701 /* The following language_defn does not represent a real language.
702 It just provides a minimal support a-la-C that should allow users
703 to do some simple operations when debugging applications that use
704 a language currently not supported by GDB. */
706 const struct language_defn minimal_language_defn
=
708 "minimal", /* Language name */
715 &exp_descriptor_standard
,
716 c_preprocess_and_parse
,
719 c_printchar
, /* Print a character constant */
720 c_printstr
, /* Function to print string constant */
721 c_emit_char
, /* Print a single char */
722 c_create_fundamental_type
, /* Create fundamental type in this language */
723 c_print_type
, /* Print a type using appropriate syntax */
724 c_val_print
, /* Print a value using appropriate syntax */
725 c_value_print
, /* Print a top-level value */
726 NULL
, /* Language specific skip_trampoline */
727 NULL
, /* value_of_this */
728 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
729 basic_lookup_transparent_type
,/* lookup_transparent_type */
730 NULL
, /* Language specific symbol demangler */
731 NULL
, /* Language specific class_name_from_physname */
732 c_op_print_tab
, /* expression operators for printing */
733 1, /* c-style arrays */
734 0, /* String lower bound */
736 default_word_break_characters
,
737 c_language_arch_info
,
738 default_print_array_index
,
743 _initialize_c_language (void)
745 add_language (&c_language_defn
);
746 add_language (&cplus_language_defn
);
747 add_language (&asm_language_defn
);
748 add_language (&minimal_language_defn
);