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 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
25 #include "parser-defs.h"
29 #include "macroscope.h"
30 #include "gdb_assert.h"
32 #include "gdb_string.h"
35 #include "cp-support.h"
37 extern void _initialize_c_language (void);
38 static void c_emit_char (int c, struct ui_file * stream, int quoter);
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. */
45 c_emit_char (int c, struct ui_file *stream, int quoter)
50 c &= 0xFF; /* Avoid sign bit follies */
52 escape = c_target_char_has_backslash_escape (c);
55 if (quoter == '"' && strcmp (escape, "0") == 0)
56 /* Print nulls embedded in double quoted strings as \000 to
58 fprintf_filtered (stream, "\\000");
60 fprintf_filtered (stream, "\\%s", escape);
62 else if (target_char_to_host (c, &host_char)
63 && host_char_print_literally (host_char))
65 if (host_char == '\\' || host_char == quoter)
66 fputs_filtered ("\\", stream);
67 fprintf_filtered (stream, "%c", host_char);
70 fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
74 c_printchar (int c, struct ui_file *stream)
76 fputc_filtered ('\'', stream);
77 LA_EMIT_CHAR (c, stream, '\'');
78 fputc_filtered ('\'', stream);
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. */
88 c_printstr (struct ui_file *stream, const gdb_byte *string,
89 unsigned int length, int width, int force_ellipses)
92 unsigned int things_printed = 0;
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
101 && (extract_unsigned_integer (string + (length - 1) * width, width)
107 fputs_filtered ("\"\"", stream);
111 for (i = 0; i < length && things_printed < print_max; ++i)
113 /* Position of the character we are examining
114 to see whether it is repeated. */
116 /* Number of repetitions we have detected so far. */
118 unsigned long current_char;
124 fputs_filtered (", ", stream);
128 current_char = extract_unsigned_integer (string + i * width, width);
133 && extract_unsigned_integer (string + rep1 * width, width)
140 if (reps > repeat_count_threshold)
145 fputs_filtered ("\\\", ", stream);
147 fputs_filtered ("\", ", stream);
150 LA_PRINT_CHAR (current_char, stream);
151 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
153 things_printed += repeat_count_threshold;
161 fputs_filtered ("\\\"", stream);
163 fputs_filtered ("\"", stream);
166 LA_EMIT_CHAR (current_char, stream, '"');
171 /* Terminate the quotes if necessary. */
175 fputs_filtered ("\\\"", stream);
177 fputs_filtered ("\"", stream);
180 if (force_ellipses || i < length)
181 fputs_filtered ("...", stream);
184 /* Create a fundamental C type using default reasonable for the current
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
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 its fundamental type information directly from the
205 debugging information supplied by the compiler. fnf@cygnus.com */
208 c_create_fundamental_type (struct objfile *objfile, int typeid)
210 struct type *type = NULL;
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 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
221 0, "<?type?>", objfile);
222 warning (_("internal error: no C/C++ fundamental type %d"), typeid);
225 type = init_type (TYPE_CODE_VOID,
226 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
230 type = init_type (TYPE_CODE_BOOL,
231 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
235 type = init_type (TYPE_CODE_INT,
236 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
237 TYPE_FLAG_NOSIGN, "char", objfile);
240 type = init_type (TYPE_CODE_INT,
241 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
242 0, "signed char", objfile);
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);
250 type = init_type (TYPE_CODE_INT,
251 gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
252 0, "short", objfile);
254 case FT_SIGNED_SHORT:
255 type = init_type (TYPE_CODE_INT,
256 gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
257 0, "short", objfile); /* FIXME-fnf */
259 case FT_UNSIGNED_SHORT:
260 type = init_type (TYPE_CODE_INT,
261 gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
262 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
265 type = init_type (TYPE_CODE_INT,
266 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
269 case FT_SIGNED_INTEGER:
270 type = init_type (TYPE_CODE_INT,
271 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
272 0, "int", objfile); /* FIXME -fnf */
274 case FT_UNSIGNED_INTEGER:
275 type = init_type (TYPE_CODE_INT,
276 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
277 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
280 type = init_type (TYPE_CODE_INT,
281 gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
285 type = init_type (TYPE_CODE_INT,
286 gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
287 0, "long", objfile); /* FIXME -fnf */
289 case FT_UNSIGNED_LONG:
290 type = init_type (TYPE_CODE_INT,
291 gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
292 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
295 type = init_type (TYPE_CODE_INT,
296 gdbarch_long_long_bit (current_gdbarch)
298 0, "long long", objfile);
300 case FT_SIGNED_LONG_LONG:
301 type = init_type (TYPE_CODE_INT,
302 gdbarch_long_long_bit (current_gdbarch)
304 0, "signed long long", objfile);
306 case FT_UNSIGNED_LONG_LONG:
307 type = init_type (TYPE_CODE_INT,
308 gdbarch_long_long_bit (current_gdbarch)
310 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
313 type = init_type (TYPE_CODE_FLT,
314 gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
315 0, "float", objfile);
317 case FT_DBL_PREC_FLOAT:
318 type = init_type (TYPE_CODE_FLT,
319 gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
320 0, "double", objfile);
322 case FT_EXT_PREC_FLOAT:
323 type = init_type (TYPE_CODE_FLT,
324 gdbarch_long_double_bit (current_gdbarch)
326 0, "long double", objfile);
329 type = init_type (TYPE_CODE_DECFLOAT,
331 0, "decimal float", objfile);
333 case FT_DBL_PREC_DECFLOAT:
334 type = init_type (TYPE_CODE_DECFLOAT,
336 0, "decimal double", objfile);
338 case FT_EXT_PREC_DECFLOAT:
339 type = init_type (TYPE_CODE_DECFLOAT,
341 0, "decimal long double", objfile);
344 type = init_type (TYPE_CODE_FLT,
345 2 * gdbarch_float_bit (current_gdbarch)
347 0, "complex float", objfile);
348 TYPE_TARGET_TYPE (type)
349 = init_type (TYPE_CODE_FLT,
350 gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
351 0, "float", objfile);
353 case FT_DBL_PREC_COMPLEX:
354 type = init_type (TYPE_CODE_FLT,
355 2 * gdbarch_double_bit (current_gdbarch)
357 0, "complex double", objfile);
358 TYPE_TARGET_TYPE (type)
359 = init_type (TYPE_CODE_FLT,
360 gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
361 0, "double", objfile);
363 case FT_EXT_PREC_COMPLEX:
364 type = init_type (TYPE_CODE_FLT,
365 2 * gdbarch_long_double_bit (current_gdbarch)
367 0, "complex long double", objfile);
368 TYPE_TARGET_TYPE (type)
369 = init_type (TYPE_CODE_FLT,
370 gdbarch_long_double_bit (current_gdbarch)
372 0, "long double", objfile);
374 case FT_TEMPLATE_ARG:
375 type = init_type (TYPE_CODE_TEMPLATE_ARG,
377 0, "<template arg>", objfile);
383 /* Preprocessing and parsing C and C++ expressions. */
386 /* When we find that lexptr (the global var defined in parse.c) is
387 pointing at a macro invocation, we expand the invocation, and call
388 scan_macro_expansion to save the old lexptr here and point lexptr
389 into the expanded text. When we reach the end of that, we call
390 end_macro_expansion to pop back to the value we saved here. The
391 macro expansion code promises to return only fully-expanded text,
392 so we don't need to "push" more than one level.
394 This is disgusting, of course. It would be cleaner to do all macro
395 expansion beforehand, and then hand that to lexptr. But we don't
396 really know where the expression ends. Remember, in a command like
398 (gdb) break *ADDRESS if CONDITION
400 we evaluate ADDRESS in the scope of the current frame, but we
401 evaluate CONDITION in the scope of the breakpoint's location. So
402 it's simply wrong to try to macro-expand the whole thing at once. */
403 static char *macro_original_text;
404 static char *macro_expanded_text;
408 scan_macro_expansion (char *expansion)
410 /* We'd better not be trying to push the stack twice. */
411 gdb_assert (! macro_original_text);
412 gdb_assert (! macro_expanded_text);
414 /* Save the old lexptr value, so we can return to it when we're done
415 parsing the expanded text. */
416 macro_original_text = lexptr;
419 /* Save the expanded text, so we can free it when we're finished. */
420 macro_expanded_text = expansion;
425 scanning_macro_expansion (void)
427 return macro_original_text != 0;
432 finished_macro_expansion (void)
434 /* There'd better be something to pop back to, and we better have
435 saved a pointer to the start of the expanded text. */
436 gdb_assert (macro_original_text);
437 gdb_assert (macro_expanded_text);
439 /* Pop back to the original text. */
440 lexptr = macro_original_text;
441 macro_original_text = 0;
443 /* Free the expanded text. */
444 xfree (macro_expanded_text);
445 macro_expanded_text = 0;
450 scan_macro_cleanup (void *dummy)
452 if (macro_original_text)
453 finished_macro_expansion ();
457 /* We set these global variables before calling c_parse, to tell it
458 how it to find macro definitions for the expression at hand. */
459 macro_lookup_ftype *expression_macro_lookup_func;
460 void *expression_macro_lookup_baton;
463 static struct macro_definition *
464 null_macro_lookup (const char *name, void *baton)
471 c_preprocess_and_parse (void)
473 /* Set up a lookup function for the macro expander. */
474 struct macro_scope *scope = 0;
475 struct cleanup *back_to = make_cleanup (free_current_contents, &scope);
477 if (expression_context_block)
478 scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
480 scope = default_macro_scope ();
484 expression_macro_lookup_func = standard_macro_lookup;
485 expression_macro_lookup_baton = (void *) scope;
489 expression_macro_lookup_func = null_macro_lookup;
490 expression_macro_lookup_baton = 0;
493 gdb_assert (! macro_original_text);
494 make_cleanup (scan_macro_cleanup, 0);
497 int result = c_parse ();
498 do_cleanups (back_to);
505 /* Table mapping opcodes into strings for printing operators
506 and precedences of the operators. */
508 const struct op_print c_op_print_tab[] =
510 {",", BINOP_COMMA, PREC_COMMA, 0},
511 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
512 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
513 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
514 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
515 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
516 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
517 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
518 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
519 {"<=", BINOP_LEQ, PREC_ORDER, 0},
520 {">=", BINOP_GEQ, PREC_ORDER, 0},
521 {">", BINOP_GTR, PREC_ORDER, 0},
522 {"<", BINOP_LESS, PREC_ORDER, 0},
523 {">>", BINOP_RSH, PREC_SHIFT, 0},
524 {"<<", BINOP_LSH, PREC_SHIFT, 0},
525 {"+", BINOP_ADD, PREC_ADD, 0},
526 {"-", BINOP_SUB, PREC_ADD, 0},
527 {"*", BINOP_MUL, PREC_MUL, 0},
528 {"/", BINOP_DIV, PREC_MUL, 0},
529 {"%", BINOP_REM, PREC_MUL, 0},
530 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
531 {"-", UNOP_NEG, PREC_PREFIX, 0},
532 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
533 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
534 {"*", UNOP_IND, PREC_PREFIX, 0},
535 {"&", UNOP_ADDR, PREC_PREFIX, 0},
536 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
537 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
538 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
542 enum c_primitive_types {
543 c_primitive_type_int,
544 c_primitive_type_long,
545 c_primitive_type_short,
546 c_primitive_type_char,
547 c_primitive_type_float,
548 c_primitive_type_double,
549 c_primitive_type_void,
550 c_primitive_type_long_long,
551 c_primitive_type_signed_char,
552 c_primitive_type_unsigned_char,
553 c_primitive_type_unsigned_short,
554 c_primitive_type_unsigned_int,
555 c_primitive_type_unsigned_long,
556 c_primitive_type_unsigned_long_long,
557 c_primitive_type_long_double,
558 c_primitive_type_complex,
559 c_primitive_type_double_complex,
564 c_language_arch_info (struct gdbarch *gdbarch,
565 struct language_arch_info *lai)
567 const struct builtin_type *builtin = builtin_type (gdbarch);
568 lai->string_char_type = builtin->builtin_char;
569 lai->primitive_type_vector
570 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
572 lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
573 lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
574 lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
575 lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
576 lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
577 lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
578 lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
579 lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
580 lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
581 lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
582 lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
583 lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
584 lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
585 lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
586 lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
587 lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
588 lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
591 const struct language_defn c_language_defn =
593 "c", /* Language name */
600 &exp_descriptor_standard,
601 c_preprocess_and_parse,
604 c_printchar, /* Print a character constant */
605 c_printstr, /* Function to print string constant */
606 c_emit_char, /* Print a single char */
607 c_create_fundamental_type, /* Create fundamental type in this language */
608 c_print_type, /* Print a type using appropriate syntax */
609 c_val_print, /* Print a value using appropriate syntax */
610 c_value_print, /* Print a top-level value */
611 NULL, /* Language specific skip_trampoline */
612 NULL, /* value_of_this */
613 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
614 basic_lookup_transparent_type,/* lookup_transparent_type */
615 NULL, /* Language specific symbol demangler */
616 NULL, /* Language specific class_name_from_physname */
617 c_op_print_tab, /* expression operators for printing */
618 1, /* c-style arrays */
619 0, /* String lower bound */
621 default_word_break_characters,
622 c_language_arch_info,
623 default_print_array_index,
624 default_pass_by_reference,
628 enum cplus_primitive_types {
629 cplus_primitive_type_int,
630 cplus_primitive_type_long,
631 cplus_primitive_type_short,
632 cplus_primitive_type_char,
633 cplus_primitive_type_float,
634 cplus_primitive_type_double,
635 cplus_primitive_type_void,
636 cplus_primitive_type_long_long,
637 cplus_primitive_type_signed_char,
638 cplus_primitive_type_unsigned_char,
639 cplus_primitive_type_unsigned_short,
640 cplus_primitive_type_unsigned_int,
641 cplus_primitive_type_unsigned_long,
642 cplus_primitive_type_unsigned_long_long,
643 cplus_primitive_type_long_double,
644 cplus_primitive_type_complex,
645 cplus_primitive_type_double_complex,
646 cplus_primitive_type_bool,
647 nr_cplus_primitive_types
651 cplus_language_arch_info (struct gdbarch *gdbarch,
652 struct language_arch_info *lai)
654 const struct builtin_type *builtin = builtin_type (gdbarch);
655 lai->string_char_type = builtin->builtin_char;
656 lai->primitive_type_vector
657 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
659 lai->primitive_type_vector [cplus_primitive_type_int]
660 = builtin->builtin_int;
661 lai->primitive_type_vector [cplus_primitive_type_long]
662 = builtin->builtin_long;
663 lai->primitive_type_vector [cplus_primitive_type_short]
664 = builtin->builtin_short;
665 lai->primitive_type_vector [cplus_primitive_type_char]
666 = builtin->builtin_char;
667 lai->primitive_type_vector [cplus_primitive_type_float]
668 = builtin->builtin_float;
669 lai->primitive_type_vector [cplus_primitive_type_double]
670 = builtin->builtin_double;
671 lai->primitive_type_vector [cplus_primitive_type_void]
672 = builtin->builtin_void;
673 lai->primitive_type_vector [cplus_primitive_type_long_long]
674 = builtin->builtin_long_long;
675 lai->primitive_type_vector [cplus_primitive_type_signed_char]
676 = builtin->builtin_signed_char;
677 lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
678 = builtin->builtin_unsigned_char;
679 lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
680 = builtin->builtin_unsigned_short;
681 lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
682 = builtin->builtin_unsigned_int;
683 lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
684 = builtin->builtin_unsigned_long;
685 lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
686 = builtin->builtin_unsigned_long_long;
687 lai->primitive_type_vector [cplus_primitive_type_long_double]
688 = builtin->builtin_long_double;
689 lai->primitive_type_vector [cplus_primitive_type_complex]
690 = builtin->builtin_complex;
691 lai->primitive_type_vector [cplus_primitive_type_double_complex]
692 = builtin->builtin_double_complex;
693 lai->primitive_type_vector [cplus_primitive_type_bool]
694 = builtin->builtin_bool;
697 const struct language_defn cplus_language_defn =
699 "c++", /* Language name */
706 &exp_descriptor_standard,
707 c_preprocess_and_parse,
710 c_printchar, /* Print a character constant */
711 c_printstr, /* Function to print string constant */
712 c_emit_char, /* Print a single char */
713 c_create_fundamental_type, /* Create fundamental type in this language */
714 c_print_type, /* Print a type using appropriate syntax */
715 c_val_print, /* Print a value using appropriate syntax */
716 c_value_print, /* Print a top-level value */
717 cplus_skip_trampoline, /* Language specific skip_trampoline */
718 value_of_this, /* value_of_this */
719 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
720 cp_lookup_transparent_type, /* lookup_transparent_type */
721 cplus_demangle, /* Language specific symbol demangler */
722 cp_class_name_from_physname, /* Language specific class_name_from_physname */
723 c_op_print_tab, /* expression operators for printing */
724 1, /* c-style arrays */
725 0, /* String lower bound */
727 default_word_break_characters,
728 cplus_language_arch_info,
729 default_print_array_index,
730 cp_pass_by_reference,
734 const struct language_defn asm_language_defn =
736 "asm", /* Language name */
743 &exp_descriptor_standard,
744 c_preprocess_and_parse,
747 c_printchar, /* Print a character constant */
748 c_printstr, /* Function to print string constant */
749 c_emit_char, /* Print a single char */
750 c_create_fundamental_type, /* Create fundamental type in this language */
751 c_print_type, /* Print a type using appropriate syntax */
752 c_val_print, /* Print a value using appropriate syntax */
753 c_value_print, /* Print a top-level value */
754 NULL, /* Language specific skip_trampoline */
755 NULL, /* value_of_this */
756 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
757 basic_lookup_transparent_type,/* lookup_transparent_type */
758 NULL, /* Language specific symbol demangler */
759 NULL, /* Language specific class_name_from_physname */
760 c_op_print_tab, /* expression operators for printing */
761 1, /* c-style arrays */
762 0, /* String lower bound */
764 default_word_break_characters,
765 c_language_arch_info, /* FIXME: la_language_arch_info. */
766 default_print_array_index,
767 default_pass_by_reference,
771 /* The following language_defn does not represent a real language.
772 It just provides a minimal support a-la-C that should allow users
773 to do some simple operations when debugging applications that use
774 a language currently not supported by GDB. */
776 const struct language_defn minimal_language_defn =
778 "minimal", /* Language name */
785 &exp_descriptor_standard,
786 c_preprocess_and_parse,
789 c_printchar, /* Print a character constant */
790 c_printstr, /* Function to print string constant */
791 c_emit_char, /* Print a single char */
792 c_create_fundamental_type, /* Create fundamental type in this language */
793 c_print_type, /* Print a type using appropriate syntax */
794 c_val_print, /* Print a value using appropriate syntax */
795 c_value_print, /* Print a top-level value */
796 NULL, /* Language specific skip_trampoline */
797 NULL, /* value_of_this */
798 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
799 basic_lookup_transparent_type,/* lookup_transparent_type */
800 NULL, /* Language specific symbol demangler */
801 NULL, /* Language specific class_name_from_physname */
802 c_op_print_tab, /* expression operators for printing */
803 1, /* c-style arrays */
804 0, /* String lower bound */
806 default_word_break_characters,
807 c_language_arch_info,
808 default_print_array_index,
809 default_pass_by_reference,
814 _initialize_c_language (void)
816 add_language (&c_language_defn);
817 add_language (&cplus_language_defn);
818 add_language (&asm_language_defn);
819 add_language (&minimal_language_defn);