| /* C language support routines for GDB, the GNU debugger. | |
| Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003, | |
| 2004, 2005, 2007, 2008 Free Software Foundation, Inc. | |
| This file is part of GDB. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 3 of the License, or | |
| (at your option) any later version. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
| #include "defs.h" | |
| #include "symtab.h" | |
| #include "gdbtypes.h" | |
| #include "expression.h" | |
| #include "parser-defs.h" | |
| #include "language.h" | |
| #include "c-lang.h" | |
| #include "valprint.h" | |
| #include "macroscope.h" | |
| #include "gdb_assert.h" | |
| #include "charset.h" | |
| #include "gdb_string.h" | |
| #include "demangle.h" | |
| #include "cp-abi.h" | |
| #include "cp-support.h" | |
| extern void _initialize_c_language (void); | |
| static void c_emit_char (int c, struct ui_file * stream, int quoter); | |
| /* Print the character C on STREAM as part of the contents of a literal | |
| string whose delimiter is QUOTER. Note that that format for printing | |
| characters and strings is language specific. */ | |
| static void | |
| c_emit_char (int c, struct ui_file *stream, int quoter) | |
| { | |
| const char *escape; | |
| int host_char; | |
| c &= 0xFF; /* Avoid sign bit follies */ | |
| escape = c_target_char_has_backslash_escape (c); | |
| if (escape) | |
| { | |
| if (quoter == '"' && strcmp (escape, "0") == 0) | |
| /* Print nulls embedded in double quoted strings as \000 to | |
| prevent ambiguity. */ | |
| fprintf_filtered (stream, "\\000"); | |
| else | |
| fprintf_filtered (stream, "\\%s", escape); | |
| } | |
| else if (target_char_to_host (c, &host_char) | |
| && host_char_print_literally (host_char)) | |
| { | |
| if (host_char == '\\' || host_char == quoter) | |
| fputs_filtered ("\\", stream); | |
| fprintf_filtered (stream, "%c", host_char); | |
| } | |
| else | |
| fprintf_filtered (stream, "\\%.3o", (unsigned int) c); | |
| } | |
| void | |
| c_printchar (int c, struct ui_file *stream) | |
| { | |
| fputc_filtered ('\'', stream); | |
| LA_EMIT_CHAR (c, stream, '\''); | |
| fputc_filtered ('\'', stream); | |
| } | |
| /* Print the character string STRING, printing at most LENGTH characters. | |
| LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes | |
| long. Printing stops early if the number hits print_max; repeat counts are | |
| printed as appropriate. Print ellipses at the end if we had to stop before | |
| printing LENGTH characters, or if FORCE_ELLIPSES. */ | |
| void | |
| c_printstr (struct ui_file *stream, const gdb_byte *string, | |
| unsigned int length, int width, int force_ellipses) | |
| { | |
| unsigned int i; | |
| unsigned int things_printed = 0; | |
| int in_quotes = 0; | |
| int need_comma = 0; | |
| /* If the string was not truncated due to `set print elements', and | |
| the last byte of it is a null, we don't print that, in traditional C | |
| style. */ | |
| if (!force_ellipses | |
| && length > 0 | |
| && (extract_unsigned_integer (string + (length - 1) * width, width) | |
| == '\0')) | |
| length--; | |
| if (length == 0) | |
| { | |
| fputs_filtered ("\"\"", stream); | |
| return; | |
| } | |
| for (i = 0; i < length && things_printed < print_max; ++i) | |
| { | |
| /* Position of the character we are examining | |
| to see whether it is repeated. */ | |
| unsigned int rep1; | |
| /* Number of repetitions we have detected so far. */ | |
| unsigned int reps; | |
| unsigned long current_char; | |
| QUIT; | |
| if (need_comma) | |
| { | |
| fputs_filtered (", ", stream); | |
| need_comma = 0; | |
| } | |
| current_char = extract_unsigned_integer (string + i * width, width); | |
| rep1 = i + 1; | |
| reps = 1; | |
| while (rep1 < length | |
| && extract_unsigned_integer (string + rep1 * width, width) | |
| == current_char) | |
| { | |
| ++rep1; | |
| ++reps; | |
| } | |
| if (reps > repeat_count_threshold) | |
| { | |
| if (in_quotes) | |
| { | |
| if (inspect_it) | |
| fputs_filtered ("\\\", ", stream); | |
| else | |
| fputs_filtered ("\", ", stream); | |
| in_quotes = 0; | |
| } | |
| LA_PRINT_CHAR (current_char, stream); | |
| fprintf_filtered (stream, _(" <repeats %u times>"), reps); | |
| i = rep1 - 1; | |
| things_printed += repeat_count_threshold; | |
| need_comma = 1; | |
| } | |
| else | |
| { | |
| if (!in_quotes) | |
| { | |
| if (inspect_it) | |
| fputs_filtered ("\\\"", stream); | |
| else | |
| fputs_filtered ("\"", stream); | |
| in_quotes = 1; | |
| } | |
| LA_EMIT_CHAR (current_char, stream, '"'); | |
| ++things_printed; | |
| } | |
| } | |
| /* Terminate the quotes if necessary. */ | |
| if (in_quotes) | |
| { | |
| if (inspect_it) | |
| fputs_filtered ("\\\"", stream); | |
| else | |
| fputs_filtered ("\"", stream); | |
| } | |
| if (force_ellipses || i < length) | |
| fputs_filtered ("...", stream); | |
| } | |
| /* Preprocessing and parsing C and C++ expressions. */ | |
| /* When we find that lexptr (the global var defined in parse.c) is | |
| pointing at a macro invocation, we expand the invocation, and call | |
| scan_macro_expansion to save the old lexptr here and point lexptr | |
| into the expanded text. When we reach the end of that, we call | |
| end_macro_expansion to pop back to the value we saved here. The | |
| macro expansion code promises to return only fully-expanded text, | |
| so we don't need to "push" more than one level. | |
| This is disgusting, of course. It would be cleaner to do all macro | |
| expansion beforehand, and then hand that to lexptr. But we don't | |
| really know where the expression ends. Remember, in a command like | |
| (gdb) break *ADDRESS if CONDITION | |
| we evaluate ADDRESS in the scope of the current frame, but we | |
| evaluate CONDITION in the scope of the breakpoint's location. So | |
| it's simply wrong to try to macro-expand the whole thing at once. */ | |
| static char *macro_original_text; | |
| static char *macro_expanded_text; | |
| void | |
| scan_macro_expansion (char *expansion) | |
| { | |
| /* We'd better not be trying to push the stack twice. */ | |
| gdb_assert (! macro_original_text); | |
| gdb_assert (! macro_expanded_text); | |
| /* Save the old lexptr value, so we can return to it when we're done | |
| parsing the expanded text. */ | |
| macro_original_text = lexptr; | |
| lexptr = expansion; | |
| /* Save the expanded text, so we can free it when we're finished. */ | |
| macro_expanded_text = expansion; | |
| } | |
| int | |
| scanning_macro_expansion (void) | |
| { | |
| return macro_original_text != 0; | |
| } | |
| void | |
| finished_macro_expansion (void) | |
| { | |
| /* There'd better be something to pop back to, and we better have | |
| saved a pointer to the start of the expanded text. */ | |
| gdb_assert (macro_original_text); | |
| gdb_assert (macro_expanded_text); | |
| /* Pop back to the original text. */ | |
| lexptr = macro_original_text; | |
| macro_original_text = 0; | |
| /* Free the expanded text. */ | |
| xfree (macro_expanded_text); | |
| macro_expanded_text = 0; | |
| } | |
| static void | |
| scan_macro_cleanup (void *dummy) | |
| { | |
| if (macro_original_text) | |
| finished_macro_expansion (); | |
| } | |
| /* We set these global variables before calling c_parse, to tell it | |
| how it to find macro definitions for the expression at hand. */ | |
| macro_lookup_ftype *expression_macro_lookup_func; | |
| void *expression_macro_lookup_baton; | |
| static struct macro_definition * | |
| null_macro_lookup (const char *name, void *baton) | |
| { | |
| return 0; | |
| } | |
| static int | |
| c_preprocess_and_parse (void) | |
| { | |
| /* Set up a lookup function for the macro expander. */ | |
| struct macro_scope *scope = 0; | |
| struct cleanup *back_to = make_cleanup (free_current_contents, &scope); | |
| if (expression_context_block) | |
| scope = sal_macro_scope (find_pc_line (expression_context_pc, 0)); | |
| else | |
| scope = default_macro_scope (); | |
| if (scope) | |
| { | |
| expression_macro_lookup_func = standard_macro_lookup; | |
| expression_macro_lookup_baton = (void *) scope; | |
| } | |
| else | |
| { | |
| expression_macro_lookup_func = null_macro_lookup; | |
| expression_macro_lookup_baton = 0; | |
| } | |
| gdb_assert (! macro_original_text); | |
| make_cleanup (scan_macro_cleanup, 0); | |
| { | |
| int result = c_parse (); | |
| do_cleanups (back_to); | |
| return result; | |
| } | |
| } | |
| /* Table mapping opcodes into strings for printing operators | |
| and precedences of the operators. */ | |
| const struct op_print c_op_print_tab[] = | |
| { | |
| {",", BINOP_COMMA, PREC_COMMA, 0}, | |
| {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, | |
| {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, | |
| {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, | |
| {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0}, | |
| {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0}, | |
| {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0}, | |
| {"==", BINOP_EQUAL, PREC_EQUAL, 0}, | |
| {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, | |
| {"<=", BINOP_LEQ, PREC_ORDER, 0}, | |
| {">=", BINOP_GEQ, PREC_ORDER, 0}, | |
| {">", BINOP_GTR, PREC_ORDER, 0}, | |
| {"<", BINOP_LESS, PREC_ORDER, 0}, | |
| {">>", BINOP_RSH, PREC_SHIFT, 0}, | |
| {"<<", BINOP_LSH, PREC_SHIFT, 0}, | |
| {"+", BINOP_ADD, PREC_ADD, 0}, | |
| {"-", BINOP_SUB, PREC_ADD, 0}, | |
| {"*", BINOP_MUL, PREC_MUL, 0}, | |
| {"/", BINOP_DIV, PREC_MUL, 0}, | |
| {"%", BINOP_REM, PREC_MUL, 0}, | |
| {"@", BINOP_REPEAT, PREC_REPEAT, 0}, | |
| {"-", UNOP_NEG, PREC_PREFIX, 0}, | |
| {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, | |
| {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0}, | |
| {"*", UNOP_IND, PREC_PREFIX, 0}, | |
| {"&", UNOP_ADDR, PREC_PREFIX, 0}, | |
| {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, | |
| {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, | |
| {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, | |
| {NULL, 0, 0, 0} | |
| }; | |
| enum c_primitive_types { | |
| c_primitive_type_int, | |
| c_primitive_type_long, | |
| c_primitive_type_short, | |
| c_primitive_type_char, | |
| c_primitive_type_float, | |
| c_primitive_type_double, | |
| c_primitive_type_void, | |
| c_primitive_type_long_long, | |
| c_primitive_type_signed_char, | |
| c_primitive_type_unsigned_char, | |
| c_primitive_type_unsigned_short, | |
| c_primitive_type_unsigned_int, | |
| c_primitive_type_unsigned_long, | |
| c_primitive_type_unsigned_long_long, | |
| c_primitive_type_long_double, | |
| c_primitive_type_complex, | |
| c_primitive_type_double_complex, | |
| c_primitive_type_decfloat, | |
| c_primitive_type_decdouble, | |
| c_primitive_type_declong, | |
| nr_c_primitive_types | |
| }; | |
| void | |
| c_language_arch_info (struct gdbarch *gdbarch, | |
| struct language_arch_info *lai) | |
| { | |
| const struct builtin_type *builtin = builtin_type (gdbarch); | |
| lai->string_char_type = builtin->builtin_char; | |
| lai->primitive_type_vector | |
| = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1, | |
| struct type *); | |
| lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int; | |
| lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long; | |
| lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short; | |
| lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char; | |
| lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float; | |
| lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double; | |
| lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void; | |
| lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long; | |
| lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char; | |
| lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char; | |
| lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short; | |
| lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int; | |
| lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long; | |
| lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long; | |
| lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double; | |
| lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex; | |
| lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex; | |
| lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat; | |
| lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble; | |
| lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong; | |
| } | |
| const struct language_defn c_language_defn = | |
| { | |
| "c", /* Language name */ | |
| language_c, | |
| range_check_off, | |
| type_check_off, | |
| case_sensitive_on, | |
| array_row_major, | |
| &exp_descriptor_standard, | |
| c_preprocess_and_parse, | |
| c_error, | |
| null_post_parser, | |
| c_printchar, /* Print a character constant */ | |
| c_printstr, /* Function to print string constant */ | |
| c_emit_char, /* Print a single char */ | |
| c_print_type, /* Print a type using appropriate syntax */ | |
| c_val_print, /* Print a value using appropriate syntax */ | |
| c_value_print, /* Print a top-level value */ | |
| NULL, /* Language specific skip_trampoline */ | |
| NULL, /* name_of_this */ | |
| basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ | |
| basic_lookup_transparent_type,/* lookup_transparent_type */ | |
| NULL, /* Language specific symbol demangler */ | |
| NULL, /* Language specific class_name_from_physname */ | |
| c_op_print_tab, /* expression operators for printing */ | |
| 1, /* c-style arrays */ | |
| 0, /* String lower bound */ | |
| default_word_break_characters, | |
| default_make_symbol_completion_list, | |
| c_language_arch_info, | |
| default_print_array_index, | |
| default_pass_by_reference, | |
| LANG_MAGIC | |
| }; | |
| enum cplus_primitive_types { | |
| cplus_primitive_type_int, | |
| cplus_primitive_type_long, | |
| cplus_primitive_type_short, | |
| cplus_primitive_type_char, | |
| cplus_primitive_type_float, | |
| cplus_primitive_type_double, | |
| cplus_primitive_type_void, | |
| cplus_primitive_type_long_long, | |
| cplus_primitive_type_signed_char, | |
| cplus_primitive_type_unsigned_char, | |
| cplus_primitive_type_unsigned_short, | |
| cplus_primitive_type_unsigned_int, | |
| cplus_primitive_type_unsigned_long, | |
| cplus_primitive_type_unsigned_long_long, | |
| cplus_primitive_type_long_double, | |
| cplus_primitive_type_complex, | |
| cplus_primitive_type_double_complex, | |
| cplus_primitive_type_bool, | |
| cplus_primitive_type_decfloat, | |
| cplus_primitive_type_decdouble, | |
| cplus_primitive_type_declong, | |
| nr_cplus_primitive_types | |
| }; | |
| static void | |
| cplus_language_arch_info (struct gdbarch *gdbarch, | |
| struct language_arch_info *lai) | |
| { | |
| const struct builtin_type *builtin = builtin_type (gdbarch); | |
| lai->string_char_type = builtin->builtin_char; | |
| lai->primitive_type_vector | |
| = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1, | |
| struct type *); | |
| lai->primitive_type_vector [cplus_primitive_type_int] | |
| = builtin->builtin_int; | |
| lai->primitive_type_vector [cplus_primitive_type_long] | |
| = builtin->builtin_long; | |
| lai->primitive_type_vector [cplus_primitive_type_short] | |
| = builtin->builtin_short; | |
| lai->primitive_type_vector [cplus_primitive_type_char] | |
| = builtin->builtin_char; | |
| lai->primitive_type_vector [cplus_primitive_type_float] | |
| = builtin->builtin_float; | |
| lai->primitive_type_vector [cplus_primitive_type_double] | |
| = builtin->builtin_double; | |
| lai->primitive_type_vector [cplus_primitive_type_void] | |
| = builtin->builtin_void; | |
| lai->primitive_type_vector [cplus_primitive_type_long_long] | |
| = builtin->builtin_long_long; | |
| lai->primitive_type_vector [cplus_primitive_type_signed_char] | |
| = builtin->builtin_signed_char; | |
| lai->primitive_type_vector [cplus_primitive_type_unsigned_char] | |
| = builtin->builtin_unsigned_char; | |
| lai->primitive_type_vector [cplus_primitive_type_unsigned_short] | |
| = builtin->builtin_unsigned_short; | |
| lai->primitive_type_vector [cplus_primitive_type_unsigned_int] | |
| = builtin->builtin_unsigned_int; | |
| lai->primitive_type_vector [cplus_primitive_type_unsigned_long] | |
| = builtin->builtin_unsigned_long; | |
| lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long] | |
| = builtin->builtin_unsigned_long_long; | |
| lai->primitive_type_vector [cplus_primitive_type_long_double] | |
| = builtin->builtin_long_double; | |
| lai->primitive_type_vector [cplus_primitive_type_complex] | |
| = builtin->builtin_complex; | |
| lai->primitive_type_vector [cplus_primitive_type_double_complex] | |
| = builtin->builtin_double_complex; | |
| lai->primitive_type_vector [cplus_primitive_type_bool] | |
| = builtin->builtin_bool; | |
| lai->primitive_type_vector [cplus_primitive_type_decfloat] | |
| = builtin->builtin_decfloat; | |
| lai->primitive_type_vector [cplus_primitive_type_decdouble] | |
| = builtin->builtin_decdouble; | |
| lai->primitive_type_vector [cplus_primitive_type_declong] | |
| = builtin->builtin_declong; | |
| } | |
| const struct language_defn cplus_language_defn = | |
| { | |
| "c++", /* Language name */ | |
| language_cplus, | |
| range_check_off, | |
| type_check_off, | |
| case_sensitive_on, | |
| array_row_major, | |
| &exp_descriptor_standard, | |
| c_preprocess_and_parse, | |
| c_error, | |
| null_post_parser, | |
| c_printchar, /* Print a character constant */ | |
| c_printstr, /* Function to print string constant */ | |
| c_emit_char, /* Print a single char */ | |
| c_print_type, /* Print a type using appropriate syntax */ | |
| c_val_print, /* Print a value using appropriate syntax */ | |
| c_value_print, /* Print a top-level value */ | |
| cplus_skip_trampoline, /* Language specific skip_trampoline */ | |
| "this", /* name_of_this */ | |
| cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ | |
| cp_lookup_transparent_type, /* lookup_transparent_type */ | |
| cplus_demangle, /* Language specific symbol demangler */ | |
| cp_class_name_from_physname, /* Language specific class_name_from_physname */ | |
| c_op_print_tab, /* expression operators for printing */ | |
| 1, /* c-style arrays */ | |
| 0, /* String lower bound */ | |
| default_word_break_characters, | |
| default_make_symbol_completion_list, | |
| cplus_language_arch_info, | |
| default_print_array_index, | |
| cp_pass_by_reference, | |
| LANG_MAGIC | |
| }; | |
| const struct language_defn asm_language_defn = | |
| { | |
| "asm", /* Language name */ | |
| language_asm, | |
| range_check_off, | |
| type_check_off, | |
| case_sensitive_on, | |
| array_row_major, | |
| &exp_descriptor_standard, | |
| c_preprocess_and_parse, | |
| c_error, | |
| null_post_parser, | |
| c_printchar, /* Print a character constant */ | |
| c_printstr, /* Function to print string constant */ | |
| c_emit_char, /* Print a single char */ | |
| c_print_type, /* Print a type using appropriate syntax */ | |
| c_val_print, /* Print a value using appropriate syntax */ | |
| c_value_print, /* Print a top-level value */ | |
| NULL, /* Language specific skip_trampoline */ | |
| NULL, /* name_of_this */ | |
| basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ | |
| basic_lookup_transparent_type,/* lookup_transparent_type */ | |
| NULL, /* Language specific symbol demangler */ | |
| NULL, /* Language specific class_name_from_physname */ | |
| c_op_print_tab, /* expression operators for printing */ | |
| 1, /* c-style arrays */ | |
| 0, /* String lower bound */ | |
| default_word_break_characters, | |
| default_make_symbol_completion_list, | |
| c_language_arch_info, /* FIXME: la_language_arch_info. */ | |
| default_print_array_index, | |
| default_pass_by_reference, | |
| LANG_MAGIC | |
| }; | |
| /* The following language_defn does not represent a real language. | |
| It just provides a minimal support a-la-C that should allow users | |
| to do some simple operations when debugging applications that use | |
| a language currently not supported by GDB. */ | |
| const struct language_defn minimal_language_defn = | |
| { | |
| "minimal", /* Language name */ | |
| language_minimal, | |
| range_check_off, | |
| type_check_off, | |
| case_sensitive_on, | |
| array_row_major, | |
| &exp_descriptor_standard, | |
| c_preprocess_and_parse, | |
| c_error, | |
| null_post_parser, | |
| c_printchar, /* Print a character constant */ | |
| c_printstr, /* Function to print string constant */ | |
| c_emit_char, /* Print a single char */ | |
| c_print_type, /* Print a type using appropriate syntax */ | |
| c_val_print, /* Print a value using appropriate syntax */ | |
| c_value_print, /* Print a top-level value */ | |
| NULL, /* Language specific skip_trampoline */ | |
| NULL, /* name_of_this */ | |
| basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ | |
| basic_lookup_transparent_type,/* lookup_transparent_type */ | |
| NULL, /* Language specific symbol demangler */ | |
| NULL, /* Language specific class_name_from_physname */ | |
| c_op_print_tab, /* expression operators for printing */ | |
| 1, /* c-style arrays */ | |
| 0, /* String lower bound */ | |
| default_word_break_characters, | |
| default_make_symbol_completion_list, | |
| c_language_arch_info, | |
| default_print_array_index, | |
| default_pass_by_reference, | |
| LANG_MAGIC | |
| }; | |
| void | |
| _initialize_c_language (void) | |
| { | |
| add_language (&c_language_defn); | |
| add_language (&cplus_language_defn); | |
| add_language (&asm_language_defn); | |
| add_language (&minimal_language_defn); | |
| } |