gdb/c-lang.c

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