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_COMPLEX:
 329       type = init_type (TYPE_CODE_FLT,
 330                         2 * gdbarch_float_bit (current_gdbarch)
 331                           / TARGET_CHAR_BIT,
 332                         0, "complex float", objfile);
 333       TYPE_TARGET_TYPE (type)
 334         = init_type (TYPE_CODE_FLT,
 335                      gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
 336                      0, "float", objfile);
 337       break;
 338     case FT_DBL_PREC_COMPLEX:
 339       type = init_type (TYPE_CODE_FLT,
 340                         2 * gdbarch_double_bit (current_gdbarch)
 341                           / TARGET_CHAR_BIT,
 342                         0, "complex double", objfile);
 343       TYPE_TARGET_TYPE (type)
 344         = init_type (TYPE_CODE_FLT,
 345                      gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
 346                      0, "double", objfile);
 347       break;
 348     case FT_EXT_PREC_COMPLEX:
 349       type = init_type (TYPE_CODE_FLT,
 350                         2 * gdbarch_long_double_bit (current_gdbarch)
 351                           / TARGET_CHAR_BIT,
 352                         0, "complex long double", objfile);
 353       TYPE_TARGET_TYPE (type)
 354         = init_type (TYPE_CODE_FLT,
 355                      gdbarch_long_double_bit (current_gdbarch)
 356                        / TARGET_CHAR_BIT,
 357                      0, "long double", objfile);
 358       break;
 359     case FT_TEMPLATE_ARG:
 360       type = init_type (TYPE_CODE_TEMPLATE_ARG,
 361                         0,
 362                         0, "<template arg>", objfile);
 363       break;
 364     }
 365   return (type);
 366 }
 367 \f
 368 /* Preprocessing and parsing C and C++ expressions.  */
 369
 370
 371 /* When we find that lexptr (the global var defined in parse.c) is
 372    pointing at a macro invocation, we expand the invocation, and call
 373    scan_macro_expansion to save the old lexptr here and point lexptr
 374    into the expanded text.  When we reach the end of that, we call
 375    end_macro_expansion to pop back to the value we saved here.  The
 376    macro expansion code promises to return only fully-expanded text,
 377    so we don't need to "push" more than one level.
 378
 379    This is disgusting, of course.  It would be cleaner to do all macro
 380    expansion beforehand, and then hand that to lexptr.  But we don't
 381    really know where the expression ends.  Remember, in a command like
 382
 383      (gdb) break *ADDRESS if CONDITION
 384
 385    we evaluate ADDRESS in the scope of the current frame, but we
 386    evaluate CONDITION in the scope of the breakpoint's location.  So
 387    it's simply wrong to try to macro-expand the whole thing at once.  */
 388 static char *macro_original_text;
 389 static char *macro_expanded_text;
 390
 391
 392 void
 393 scan_macro_expansion (char *expansion)
 394 {
 395   /* We'd better not be trying to push the stack twice.  */
 396   gdb_assert (! macro_original_text);
 397   gdb_assert (! macro_expanded_text);
 398
 399   /* Save the old lexptr value, so we can return to it when we're done
 400      parsing the expanded text.  */
 401   macro_original_text = lexptr;
 402   lexptr = expansion;
 403
 404   /* Save the expanded text, so we can free it when we're finished.  */
 405   macro_expanded_text = expansion;
 406 }
 407
 408
 409 int
 410 scanning_macro_expansion (void)
 411 {
 412   return macro_original_text != 0;
 413 }
 414
 415
 416 void
 417 finished_macro_expansion (void)
 418 {
 419   /* There'd better be something to pop back to, and we better have
 420      saved a pointer to the start of the expanded text.  */
 421   gdb_assert (macro_original_text);
 422   gdb_assert (macro_expanded_text);
 423
 424   /* Pop back to the original text.  */
 425   lexptr = macro_original_text;
 426   macro_original_text = 0;
 427
 428   /* Free the expanded text.  */
 429   xfree (macro_expanded_text);
 430   macro_expanded_text = 0;
 431 }
 432
 433
 434 static void
 435 scan_macro_cleanup (void *dummy)
 436 {
 437   if (macro_original_text)
 438     finished_macro_expansion ();
 439 }
 440
 441
 442 /* We set these global variables before calling c_parse, to tell it
 443    how it to find macro definitions for the expression at hand.  */
 444 macro_lookup_ftype *expression_macro_lookup_func;
 445 void *expression_macro_lookup_baton;
 446
 447
 448 static struct macro_definition *
 449 null_macro_lookup (const char *name, void *baton)
 450 {
 451   return 0;
 452 }
 453
 454
 455 static int
 456 c_preprocess_and_parse (void)
 457 {
 458   /* Set up a lookup function for the macro expander.  */
 459   struct macro_scope *scope = 0;
 460   struct cleanup *back_to = make_cleanup (free_current_contents, &scope);
 461
 462   if (expression_context_block)
 463     scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
 464   else
 465     scope = default_macro_scope ();
 466
 467   if (scope)
 468     {
 469       expression_macro_lookup_func = standard_macro_lookup;
 470       expression_macro_lookup_baton = (void *) scope;
 471     }
 472   else
 473     {
 474       expression_macro_lookup_func = null_macro_lookup;
 475       expression_macro_lookup_baton = 0;
 476     }
 477
 478   gdb_assert (! macro_original_text);
 479   make_cleanup (scan_macro_cleanup, 0);
 480
 481   {
 482     int result = c_parse ();
 483     do_cleanups (back_to);
 484     return result;
 485   }
 486 }
 487
 488
 489 \f
 490 /* Table mapping opcodes into strings for printing operators
 491    and precedences of the operators.  */
 492
 493 const struct op_print c_op_print_tab[] =
 494 {
 495   {",", BINOP_COMMA, PREC_COMMA, 0},
 496   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 497   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 498   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 499   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 500   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 501   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 502   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 503   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 504   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 505   {">=", BINOP_GEQ, PREC_ORDER, 0},
 506   {">", BINOP_GTR, PREC_ORDER, 0},
 507   {"<", BINOP_LESS, PREC_ORDER, 0},
 508   {">>", BINOP_RSH, PREC_SHIFT, 0},
 509   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 510   {"+", BINOP_ADD, PREC_ADD, 0},
 511   {"-", BINOP_SUB, PREC_ADD, 0},
 512   {"*", BINOP_MUL, PREC_MUL, 0},
 513   {"/", BINOP_DIV, PREC_MUL, 0},
 514   {"%", BINOP_REM, PREC_MUL, 0},
 515   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 516   {"-", UNOP_NEG, PREC_PREFIX, 0},
 517   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 518   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 519   {"*", UNOP_IND, PREC_PREFIX, 0},
 520   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 521   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 522   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 523   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 524   {NULL, 0, 0, 0}
 525 };
 526 \f
 527 enum c_primitive_types {
 528   c_primitive_type_int,
 529   c_primitive_type_long,
 530   c_primitive_type_short,
 531   c_primitive_type_char,
 532   c_primitive_type_float,
 533   c_primitive_type_double,
 534   c_primitive_type_void,
 535   c_primitive_type_long_long,
 536   c_primitive_type_signed_char,
 537   c_primitive_type_unsigned_char,
 538   c_primitive_type_unsigned_short,
 539   c_primitive_type_unsigned_int,
 540   c_primitive_type_unsigned_long,
 541   c_primitive_type_unsigned_long_long,
 542   c_primitive_type_long_double,
 543   c_primitive_type_complex,
 544   c_primitive_type_double_complex,
 545   nr_c_primitive_types
 546 };
 547
 548 void
 549 c_language_arch_info (struct gdbarch *gdbarch,
 550                       struct language_arch_info *lai)
 551 {
 552   const struct builtin_type *builtin = builtin_type (gdbarch);
 553   lai->string_char_type = builtin->builtin_char;
 554   lai->primitive_type_vector
 555     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 556                               struct type *);
 557   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 558   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 559   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 560   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 561   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 562   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 563   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 564   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 565   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 566   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 567   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 568   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 569   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 570   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 571   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 572   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 573   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 574 }
 575
 576 const struct language_defn c_language_defn =
 577 {
 578   "c",                          /* Language name */
 579   language_c,
 580   NULL,
 581   range_check_off,
 582   type_check_off,
 583   case_sensitive_on,
 584   array_row_major,
 585   &exp_descriptor_standard,
 586   c_preprocess_and_parse,
 587   c_error,
 588   null_post_parser,
 589   c_printchar,                  /* Print a character constant */
 590   c_printstr,                   /* Function to print string constant */
 591   c_emit_char,                  /* Print a single char */
 592   c_create_fundamental_type,    /* Create fundamental type in this language */
 593   c_print_type,                 /* Print a type using appropriate syntax */
 594   c_val_print,                  /* Print a value using appropriate syntax */
 595   c_value_print,                /* Print a top-level value */
 596   NULL,                         /* Language specific skip_trampoline */
 597   NULL,                         /* value_of_this */
 598   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 599   basic_lookup_transparent_type,/* lookup_transparent_type */
 600   NULL,                         /* Language specific symbol demangler */
 601   NULL,                         /* Language specific class_name_from_physname */
 602   c_op_print_tab,               /* expression operators for printing */
 603   1,                            /* c-style arrays */
 604   0,                            /* String lower bound */
 605   NULL,
 606   default_word_break_characters,
 607   c_language_arch_info,
 608   default_print_array_index,
 609   LANG_MAGIC
 610 };
 611
 612 enum cplus_primitive_types {
 613   cplus_primitive_type_int,
 614   cplus_primitive_type_long,
 615   cplus_primitive_type_short,
 616   cplus_primitive_type_char,
 617   cplus_primitive_type_float,
 618   cplus_primitive_type_double,
 619   cplus_primitive_type_void,
 620   cplus_primitive_type_long_long,
 621   cplus_primitive_type_signed_char,
 622   cplus_primitive_type_unsigned_char,
 623   cplus_primitive_type_unsigned_short,
 624   cplus_primitive_type_unsigned_int,
 625   cplus_primitive_type_unsigned_long,
 626   cplus_primitive_type_unsigned_long_long,
 627   cplus_primitive_type_long_double,
 628   cplus_primitive_type_complex,
 629   cplus_primitive_type_double_complex,
 630   cplus_primitive_type_bool,
 631   nr_cplus_primitive_types
 632 };
 633
 634 static void
 635 cplus_language_arch_info (struct gdbarch *gdbarch,
 636                           struct language_arch_info *lai)
 637 {
 638   const struct builtin_type *builtin = builtin_type (gdbarch);
 639   lai->string_char_type = builtin->builtin_char;
 640   lai->primitive_type_vector
 641     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 642                               struct type *);
 643   lai->primitive_type_vector [cplus_primitive_type_int]
 644     = builtin->builtin_int;
 645   lai->primitive_type_vector [cplus_primitive_type_long]
 646     = builtin->builtin_long;
 647   lai->primitive_type_vector [cplus_primitive_type_short]
 648     = builtin->builtin_short;
 649   lai->primitive_type_vector [cplus_primitive_type_char]
 650     = builtin->builtin_char;
 651   lai->primitive_type_vector [cplus_primitive_type_float]
 652     = builtin->builtin_float;
 653   lai->primitive_type_vector [cplus_primitive_type_double]
 654     = builtin->builtin_double;
 655   lai->primitive_type_vector [cplus_primitive_type_void]
 656     = builtin->builtin_void;
 657   lai->primitive_type_vector [cplus_primitive_type_long_long]
 658     = builtin->builtin_long_long;
 659   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 660     = builtin->builtin_signed_char;
 661   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 662     = builtin->builtin_unsigned_char;
 663   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 664     = builtin->builtin_unsigned_short;
 665   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 666     = builtin->builtin_unsigned_int;
 667   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 668     = builtin->builtin_unsigned_long;
 669   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 670     = builtin->builtin_unsigned_long_long;
 671   lai->primitive_type_vector [cplus_primitive_type_long_double]
 672     = builtin->builtin_long_double;
 673   lai->primitive_type_vector [cplus_primitive_type_complex]
 674     = builtin->builtin_complex;
 675   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 676     = builtin->builtin_double_complex;
 677   lai->primitive_type_vector [cplus_primitive_type_bool]
 678     = builtin->builtin_bool;
 679 }
 680
 681 const struct language_defn cplus_language_defn =
 682 {
 683   "c++",                        /* Language name */
 684   language_cplus,
 685   NULL,
 686   range_check_off,
 687   type_check_off,
 688   case_sensitive_on,
 689   array_row_major,
 690   &exp_descriptor_standard,
 691   c_preprocess_and_parse,
 692   c_error,
 693   null_post_parser,
 694   c_printchar,                  /* Print a character constant */
 695   c_printstr,                   /* Function to print string constant */
 696   c_emit_char,                  /* Print a single char */
 697   c_create_fundamental_type,    /* Create fundamental type in this language */
 698   c_print_type,                 /* Print a type using appropriate syntax */
 699   c_val_print,                  /* Print a value using appropriate syntax */
 700   c_value_print,                /* Print a top-level value */
 701   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 702   value_of_this,                /* value_of_this */
 703   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 704   cp_lookup_transparent_type,   /* lookup_transparent_type */
 705   cplus_demangle,               /* Language specific symbol demangler */
 706   cp_class_name_from_physname,  /* Language specific class_name_from_physname */
 707   c_op_print_tab,               /* expression operators for printing */
 708   1,                            /* c-style arrays */
 709   0,                            /* String lower bound */
 710   NULL,
 711   default_word_break_characters,
 712   cplus_language_arch_info,
 713   default_print_array_index,
 714   LANG_MAGIC
 715 };
 716
 717 const struct language_defn asm_language_defn =
 718 {
 719   "asm",                        /* Language name */
 720   language_asm,
 721   NULL,
 722   range_check_off,
 723   type_check_off,
 724   case_sensitive_on,
 725   array_row_major,
 726   &exp_descriptor_standard,
 727   c_preprocess_and_parse,
 728   c_error,
 729   null_post_parser,
 730   c_printchar,                  /* Print a character constant */
 731   c_printstr,                   /* Function to print string constant */
 732   c_emit_char,                  /* Print a single char */
 733   c_create_fundamental_type,    /* Create fundamental type in this language */
 734   c_print_type,                 /* Print a type using appropriate syntax */
 735   c_val_print,                  /* Print a value using appropriate syntax */
 736   c_value_print,                /* Print a top-level value */
 737   NULL,                         /* Language specific skip_trampoline */
 738   NULL,                         /* value_of_this */
 739   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 740   basic_lookup_transparent_type,/* lookup_transparent_type */
 741   NULL,                         /* Language specific symbol demangler */
 742   NULL,                         /* Language specific class_name_from_physname */
 743   c_op_print_tab,               /* expression operators for printing */
 744   1,                            /* c-style arrays */
 745   0,                            /* String lower bound */
 746   NULL,
 747   default_word_break_characters,
 748   c_language_arch_info, /* FIXME: la_language_arch_info.  */
 749   default_print_array_index,
 750   LANG_MAGIC
 751 };
 752
 753 /* The following language_defn does not represent a real language.
 754    It just provides a minimal support a-la-C that should allow users
 755    to do some simple operations when debugging applications that use
 756    a language currently not supported by GDB.  */
 757
 758 const struct language_defn minimal_language_defn =
 759 {
 760   "minimal",                    /* Language name */
 761   language_minimal,
 762   NULL,
 763   range_check_off,
 764   type_check_off,
 765   case_sensitive_on,
 766   array_row_major,
 767   &exp_descriptor_standard,
 768   c_preprocess_and_parse,
 769   c_error,
 770   null_post_parser,
 771   c_printchar,                  /* Print a character constant */
 772   c_printstr,                   /* Function to print string constant */
 773   c_emit_char,                  /* Print a single char */
 774   c_create_fundamental_type,    /* Create fundamental type in this language */
 775   c_print_type,                 /* Print a type using appropriate syntax */
 776   c_val_print,                  /* Print a value using appropriate syntax */
 777   c_value_print,                /* Print a top-level value */
 778   NULL,                         /* Language specific skip_trampoline */
 779   NULL,                         /* value_of_this */
 780   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 781   basic_lookup_transparent_type,/* lookup_transparent_type */
 782   NULL,                         /* Language specific symbol demangler */
 783   NULL,                         /* Language specific class_name_from_physname */
 784   c_op_print_tab,               /* expression operators for printing */
 785   1,                            /* c-style arrays */
 786   0,                            /* String lower bound */
 787   NULL,
 788   default_word_break_characters,
 789   c_language_arch_info,
 790   default_print_array_index,
 791   LANG_MAGIC
 792 };
 793
 794 void
 795 _initialize_c_language (void)
 796 {
 797   add_language (&c_language_defn);
 798   add_language (&cplus_language_defn);
 799   add_language (&asm_language_defn);
 800   add_language (&minimal_language_defn);
 801 }