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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "expression.h"
  25 #include "parser-defs.h"
  26 #include "language.h"
  27 #include "c-lang.h"
  28 #include "valprint.h"
  29 #include "macroscope.h"
  30 #include "gdb_assert.h"
  31 #include "charset.h"
  32 #include "gdb_string.h"
  33 #include "demangle.h"
  34 #include "cp-abi.h"
  35 #include "cp-support.h"
  36
  37 extern void _initialize_c_language (void);
  38 static void c_emit_char (int c, struct ui_file * stream, int quoter);
  39
  40 /* Print the character C on STREAM as part of the contents of a literal
  41    string whose delimiter is QUOTER.  Note that that format for printing
  42    characters and strings is language specific. */
  43
  44 static void
  45 c_emit_char (int c, struct ui_file *stream, int quoter)
  46 {
  47   const char *escape;
  48   int host_char;
  49
  50   c &= 0xFF;                    /* Avoid sign bit follies */
  51
  52   escape = c_target_char_has_backslash_escape (c);
  53   if (escape)
  54     {
  55       if (quoter == '"' && strcmp (escape, "0") == 0)
  56         /* Print nulls embedded in double quoted strings as \000 to
  57            prevent ambiguity.  */
  58         fprintf_filtered (stream, "\\000");
  59       else
  60         fprintf_filtered (stream, "\\%s", escape);
  61     }
  62   else if (target_char_to_host (c, &host_char)
  63            && host_char_print_literally (host_char))
  64     {
  65       if (host_char == '\\' || host_char == quoter)
  66         fputs_filtered ("\\", stream);
  67       fprintf_filtered (stream, "%c", host_char);
  68     }
  69   else
  70     fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
  71 }
  72
  73 void
  74 c_printchar (int c, struct ui_file *stream)
  75 {
  76   fputc_filtered ('\'', stream);
  77   LA_EMIT_CHAR (c, stream, '\'');
  78   fputc_filtered ('\'', stream);
  79 }
  80
  81 /* Print the character string STRING, printing at most LENGTH characters.
  82    LENGTH is -1 if the string is nul terminated.  Each character is WIDTH bytes
  83    long.  Printing stops early if the number hits print_max; repeat counts are
  84    printed as appropriate.  Print ellipses at the end if we had to stop before
  85    printing LENGTH characters, or if FORCE_ELLIPSES.  */
  86
  87 void
  88 c_printstr (struct ui_file *stream, const gdb_byte *string,
  89             unsigned int length, int width, int force_ellipses)
  90 {
  91   unsigned int i;
  92   unsigned int things_printed = 0;
  93   int in_quotes = 0;
  94   int need_comma = 0;
  95
  96   /* If the string was not truncated due to `set print elements', and
  97      the last byte of it is a null, we don't print that, in traditional C
  98      style.  */
  99   if (!force_ellipses
 100       && length > 0
 101       && (extract_unsigned_integer (string + (length - 1) * width, width)
 102           == '\0'))
 103     length--;
 104
 105   if (length == 0)
 106     {
 107       fputs_filtered ("\"\"", stream);
 108       return;
 109     }
 110
 111   for (i = 0; i < length && things_printed < print_max; ++i)
 112     {
 113       /* Position of the character we are examining
 114          to see whether it is repeated.  */
 115       unsigned int rep1;
 116       /* Number of repetitions we have detected so far.  */
 117       unsigned int reps;
 118       unsigned long current_char;
 119
 120       QUIT;
 121
 122       if (need_comma)
 123         {
 124           fputs_filtered (", ", stream);
 125           need_comma = 0;
 126         }
 127
 128       current_char = extract_unsigned_integer (string + i * width, width);
 129
 130       rep1 = i + 1;
 131       reps = 1;
 132       while (rep1 < length
 133              && extract_unsigned_integer (string + rep1 * width, width)
 134              == current_char)
 135         {
 136           ++rep1;
 137           ++reps;
 138         }
 139
 140       if (reps > repeat_count_threshold)
 141         {
 142           if (in_quotes)
 143             {
 144               if (inspect_it)
 145                 fputs_filtered ("\\\", ", stream);
 146               else
 147                 fputs_filtered ("\", ", stream);
 148               in_quotes = 0;
 149             }
 150           LA_PRINT_CHAR (current_char, stream);
 151           fprintf_filtered (stream, _(" <repeats %u times>"), reps);
 152           i = rep1 - 1;
 153           things_printed += repeat_count_threshold;
 154           need_comma = 1;
 155         }
 156       else
 157         {
 158           if (!in_quotes)
 159             {
 160               if (inspect_it)
 161                 fputs_filtered ("\\\"", stream);
 162               else
 163                 fputs_filtered ("\"", stream);
 164               in_quotes = 1;
 165             }
 166           LA_EMIT_CHAR (current_char, stream, '"');
 167           ++things_printed;
 168         }
 169     }
 170
 171   /* Terminate the quotes if necessary.  */
 172   if (in_quotes)
 173     {
 174       if (inspect_it)
 175         fputs_filtered ("\\\"", stream);
 176       else
 177         fputs_filtered ("\"", stream);
 178     }
 179
 180   if (force_ellipses || i < length)
 181     fputs_filtered ("...", stream);
 182 }
 183
 184 /* Create a fundamental C type using default reasonable for the current
 185    target machine.
 186
 187    Some object/debugging file formats (DWARF version 1, COFF, etc) do not
 188    define fundamental types such as "int" or "double".  Others (stabs or
 189    DWARF version 2, etc) do define fundamental types.  For the formats which
 190    don't provide fundamental types, gdb can create such types using this
 191    function.
 192
 193    FIXME:  Some compilers distinguish explicitly signed integral types
 194    (signed short, signed int, signed long) from "regular" integral types
 195    (short, int, long) in the debugging information.  There is some dis-
 196    agreement as to how useful this feature is.  In particular, gcc does
 197    not support this.  Also, only some debugging formats allow the
 198    distinction to be passed on to a debugger.  For now, we always just
 199    use "short", "int", or "long" as the type name, for both the implicit
 200    and explicitly signed types.  This also makes life easier for the
 201    gdb test suite since we don't have to account for the differences
 202    in output depending upon what the compiler and debugging format
 203    support.  We will probably have to re-examine the issue when gdb
 204    starts taking its fundamental type information directly from the
 205    debugging information supplied by the compiler.  fnf@cygnus.com */
 206
 207 struct type *
 208 c_create_fundamental_type (struct objfile *objfile, int typeid)
 209 {
 210   struct type *type = NULL;
 211
 212   switch (typeid)
 213     {
 214     default:
 215       /* FIXME:  For now, if we are asked to produce a type not in this
 216          language, create the equivalent of a C integer type with the
 217          name "<?type?>".  When all the dust settles from the type
 218          reconstruction work, this should probably become an error. */
 219       type = init_type (TYPE_CODE_INT,
 220                         gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
 221                         0, "<?type?>", objfile);
 222       warning (_("internal error: no C/C++ fundamental type %d"), typeid);
 223       break;
 224     case FT_VOID:
 225       type = init_type (TYPE_CODE_VOID,
 226                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 227                         0, "void", objfile);
 228       break;
 229     case FT_BOOLEAN:
 230       type = init_type (TYPE_CODE_BOOL,
 231                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 232                         0, "bool", objfile);
 233       break;
 234     case FT_CHAR:
 235       type = init_type (TYPE_CODE_INT,
 236                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 237                         TYPE_FLAG_NOSIGN, "char", objfile);
 238       break;
 239     case FT_SIGNED_CHAR:
 240       type = init_type (TYPE_CODE_INT,
 241                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 242                         0, "signed char", objfile);
 243       break;
 244     case FT_UNSIGNED_CHAR:
 245       type = init_type (TYPE_CODE_INT,
 246                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 247                         TYPE_FLAG_UNSIGNED, "unsigned char", objfile);
 248       break;
 249     case FT_SHORT:
 250       type = init_type (TYPE_CODE_INT,
 251                         gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
 252                         0, "short", objfile);
 253       break;
 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 */
 258       break;
 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);
 263       break;
 264     case FT_INTEGER:
 265       type = init_type (TYPE_CODE_INT,
 266                         gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
 267                         0, "int", objfile);
 268       break;
 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 */
 273       break;
 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);
 278       break;
 279     case FT_LONG:
 280       type = init_type (TYPE_CODE_INT,
 281                         gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
 282                         0, "long", objfile);
 283       break;
 284     case FT_SIGNED_LONG:
 285       type = init_type (TYPE_CODE_INT,
 286                         gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
 287                         0, "long", objfile);    /* FIXME -fnf */
 288       break;
 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);
 293       break;
 294     case FT_LONG_LONG:
 295       type = init_type (TYPE_CODE_INT,
 296                         gdbarch_long_long_bit (current_gdbarch)
 297                           / TARGET_CHAR_BIT,
 298                         0, "long long", objfile);
 299       break;
 300     case FT_SIGNED_LONG_LONG:
 301       type = init_type (TYPE_CODE_INT,
 302                         gdbarch_long_long_bit (current_gdbarch)
 303                           / TARGET_CHAR_BIT,
 304                         0, "signed long long", objfile);
 305       break;
 306     case FT_UNSIGNED_LONG_LONG:
 307       type = init_type (TYPE_CODE_INT,
 308                         gdbarch_long_long_bit (current_gdbarch)
 309                           / TARGET_CHAR_BIT,
 310                         TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
 311       break;
 312     case FT_FLOAT:
 313       type = init_type (TYPE_CODE_FLT,
 314                         gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
 315                         0, "float", objfile);
 316       break;
 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);
 321       break;
 322     case FT_EXT_PREC_FLOAT:
 323       type = init_type (TYPE_CODE_FLT,
 324                         gdbarch_long_double_bit (current_gdbarch)
 325                           / TARGET_CHAR_BIT,
 326                         0, "long double", objfile);
 327       break;
 328     case FT_DECFLOAT:
 329       type = init_type (TYPE_CODE_DECFLOAT,
 330                         32 / 8,
 331                         0, "decimal float", objfile);
 332       break;
 333     case FT_DBL_PREC_DECFLOAT:
 334       type = init_type (TYPE_CODE_DECFLOAT,
 335                         64 / 8,
 336                         0, "decimal double", objfile);
 337       break;
 338     case FT_EXT_PREC_DECFLOAT:
 339       type = init_type (TYPE_CODE_DECFLOAT,
 340                         128 / 8,
 341                         0, "decimal long double", objfile);
 342       break;
 343     case FT_COMPLEX:
 344       type = init_type (TYPE_CODE_FLT,
 345                         2 * gdbarch_float_bit (current_gdbarch)
 346                           / TARGET_CHAR_BIT,
 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);
 352       break;
 353     case FT_DBL_PREC_COMPLEX:
 354       type = init_type (TYPE_CODE_FLT,
 355                         2 * gdbarch_double_bit (current_gdbarch)
 356                           / TARGET_CHAR_BIT,
 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);
 362       break;
 363     case FT_EXT_PREC_COMPLEX:
 364       type = init_type (TYPE_CODE_FLT,
 365                         2 * gdbarch_long_double_bit (current_gdbarch)
 366                           / TARGET_CHAR_BIT,
 367                         0, "complex long double", objfile);
 368       TYPE_TARGET_TYPE (type)
 369         = init_type (TYPE_CODE_FLT,
 370                      gdbarch_long_double_bit (current_gdbarch)
 371                        / TARGET_CHAR_BIT,
 372                      0, "long double", objfile);
 373       break;
 374     case FT_TEMPLATE_ARG:
 375       type = init_type (TYPE_CODE_TEMPLATE_ARG,
 376                         0,
 377                         0, "<template arg>", objfile);
 378       break;
 379     }
 380   return (type);
 381 }
 382 \f
 383 /* Preprocessing and parsing C and C++ expressions.  */
 384
 385
 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.
 393
 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
 397
 398      (gdb) break *ADDRESS if CONDITION
 399
 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;
 405
 406
 407 void
 408 scan_macro_expansion (char *expansion)
 409 {
 410   /* We'd better not be trying to push the stack twice.  */
 411   gdb_assert (! macro_original_text);
 412   gdb_assert (! macro_expanded_text);
 413
 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;
 417   lexptr = expansion;
 418
 419   /* Save the expanded text, so we can free it when we're finished.  */
 420   macro_expanded_text = expansion;
 421 }
 422
 423
 424 int
 425 scanning_macro_expansion (void)
 426 {
 427   return macro_original_text != 0;
 428 }
 429
 430
 431 void
 432 finished_macro_expansion (void)
 433 {
 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);
 438
 439   /* Pop back to the original text.  */
 440   lexptr = macro_original_text;
 441   macro_original_text = 0;
 442
 443   /* Free the expanded text.  */
 444   xfree (macro_expanded_text);
 445   macro_expanded_text = 0;
 446 }
 447
 448
 449 static void
 450 scan_macro_cleanup (void *dummy)
 451 {
 452   if (macro_original_text)
 453     finished_macro_expansion ();
 454 }
 455
 456
 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;
 461
 462
 463 static struct macro_definition *
 464 null_macro_lookup (const char *name, void *baton)
 465 {
 466   return 0;
 467 }
 468
 469
 470 static int
 471 c_preprocess_and_parse (void)
 472 {
 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);
 476
 477   if (expression_context_block)
 478     scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
 479   else
 480     scope = default_macro_scope ();
 481
 482   if (scope)
 483     {
 484       expression_macro_lookup_func = standard_macro_lookup;
 485       expression_macro_lookup_baton = (void *) scope;
 486     }
 487   else
 488     {
 489       expression_macro_lookup_func = null_macro_lookup;
 490       expression_macro_lookup_baton = 0;
 491     }
 492
 493   gdb_assert (! macro_original_text);
 494   make_cleanup (scan_macro_cleanup, 0);
 495
 496   {
 497     int result = c_parse ();
 498     do_cleanups (back_to);
 499     return result;
 500   }
 501 }
 502
 503
 504 \f
 505 /* Table mapping opcodes into strings for printing operators
 506    and precedences of the operators.  */
 507
 508 const struct op_print c_op_print_tab[] =
 509 {
 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},
 539   {NULL, 0, 0, 0}
 540 };
 541 \f
 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,
 560   nr_c_primitive_types
 561 };
 562
 563 void
 564 c_language_arch_info (struct gdbarch *gdbarch,
 565                       struct language_arch_info *lai)
 566 {
 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,
 571                               struct type *);
 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;
 589 }
 590
 591 const struct language_defn c_language_defn =
 592 {
 593   "c",                          /* Language name */
 594   language_c,
 595   NULL,
 596   range_check_off,
 597   type_check_off,
 598   case_sensitive_on,
 599   array_row_major,
 600   &exp_descriptor_standard,
 601   c_preprocess_and_parse,
 602   c_error,
 603   null_post_parser,
 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 */
 620   NULL,
 621   default_word_break_characters,
 622   c_language_arch_info,
 623   default_print_array_index,
 624   default_pass_by_reference,
 625   LANG_MAGIC
 626 };
 627
 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
 648 };
 649
 650 static void
 651 cplus_language_arch_info (struct gdbarch *gdbarch,
 652                           struct language_arch_info *lai)
 653 {
 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,
 658                               struct type *);
 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;
 695 }
 696
 697 const struct language_defn cplus_language_defn =
 698 {
 699   "c++",                        /* Language name */
 700   language_cplus,
 701   NULL,
 702   range_check_off,
 703   type_check_off,
 704   case_sensitive_on,
 705   array_row_major,
 706   &exp_descriptor_standard,
 707   c_preprocess_and_parse,
 708   c_error,
 709   null_post_parser,
 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 */
 726   NULL,
 727   default_word_break_characters,
 728   cplus_language_arch_info,
 729   default_print_array_index,
 730   cp_pass_by_reference,
 731   LANG_MAGIC
 732 };
 733
 734 const struct language_defn asm_language_defn =
 735 {
 736   "asm",                        /* Language name */
 737   language_asm,
 738   NULL,
 739   range_check_off,
 740   type_check_off,
 741   case_sensitive_on,
 742   array_row_major,
 743   &exp_descriptor_standard,
 744   c_preprocess_and_parse,
 745   c_error,
 746   null_post_parser,
 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 */
 763   NULL,
 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,
 768   LANG_MAGIC
 769 };
 770
 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.  */
 775
 776 const struct language_defn minimal_language_defn =
 777 {
 778   "minimal",                    /* Language name */
 779   language_minimal,
 780   NULL,
 781   range_check_off,
 782   type_check_off,
 783   case_sensitive_on,
 784   array_row_major,
 785   &exp_descriptor_standard,
 786   c_preprocess_and_parse,
 787   c_error,
 788   null_post_parser,
 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 */
 805   NULL,
 806   default_word_break_characters,
 807   c_language_arch_info,
 808   default_print_array_index,
 809   default_pass_by_reference,
 810   LANG_MAGIC
 811 };
 812
 813 void
 814 _initialize_c_language (void)
 815 {
 816   add_language (&c_language_defn);
 817   add_language (&cplus_language_defn);
 818   add_language (&asm_language_defn);
 819   add_language (&minimal_language_defn);
 820 }